-
Thread
Mikrocontroller mit 9 PWM ausgängen?
Board mal an, hat USB schon drauf, reichlich PWM Kanäle und kostet nur 5 Euro. http://stefanfrings.de/stm32/stm32f3.html#stm32f3mini Der Shop ist offenbar gerade down, versuche es später nochmal. Die nehmen jedenfalls weniger als 5€ Versandkosten.
ein Beispiel von der Forumslegende Peter Dannegger: https://www.mikrocontroller.net/topic/340449 8 Kanäle bei 12 Bit @ 2kHz BAM auf einem 8MHz AVR: 9% CPU Load, und die 8 Kanäle sind synchron. Bei 8 Bit Auflösung wirds dann wahlweise schneller (16x) -> 32kHz Refreshrate, oder noch weniger Zeitkritisch
-
Thread
stm32F103 (fake) on chip debug
Ich habe Probleme on-chip-debugging auf einem Blue-Pill Board mit einem Fake STM32F103C8T6 zum Laufen zu kriegen. Ich entwickle unter - Windows 7 - STM32CubeIDE (V1.11.2) - mit einem ST-Link V2, Firmware V2J40S7 - Treiber für ST-Link: STMicroelectronics V 2.2.0.0 Mit
der nicht funktionierenden ist die Schrift nur aufgedruckt, nicht tief eingelasert: STM32 F103C8T6 9901KA 93 MYS 806 Der STM32CubeProgrammer listet unter Target Information: Device: STM32F101/F103 High-density Device ID: 0x414 Revision ID: Rev Z Flash size: 256 KB > Und wenn
-
Thread
STM32 Frequenzmessung im Capturemodus
Hallöchen.. Ich benutze einen STM32F103C8T6 für eine Frequenzmessung im Bereich von 1Hz-10Khz. Leider habe ich das Problem, das es sporadisch zu falschen Messergebnissen kommt. In die Berechnung ist der Capture_overflow Counter mit
Frequenzwerte nicht so stabil sind. Eventuell kann man den Prescaler Division Ratio im Timer (Div: 0/2/4/8) im Programm automatisch anpassen. Kleines Video: https://youtu.be/2HHfi0Ipwqk Geänderter Code für die Frequenzmessung mit STM32F103C8Tx [c] /* Includes ------------------------------------
-
Thread
Projektidee "RGB-LED-Matrix"
. Wenn man pro STM32F4DISCOVERY eine Kachel-Zeile aus 10 Kacheln mit Signalen versorgt, sollten noch genügend Pins frei sein, um die Daten 8 bit parallel aus dem FPGA oder dem Raspberry pi zu lesen. Das STM32F4DISCOVERY
nicht ganz klar ist: Welche Controller nehme ich? zu 2a) PIC16F1825 scheint zu passen, aber auch STM8 und ATMega kommen in Frage. Ich brauche ca. 1KB RAM. I²C und SPI wären gut. zu 2b) ATSAM4N8, MKL05Z32 oder LPC1347 scheinen dafür gute Kandidaten zu sein. Sie sind schnell genug und haben genügend
-
Thread
USB-CAN Analyzer Linux
ist USB an PA11/PA12 und CAN wahlweise an PA11/PA12 oder! PA8/PA9.
und da ist USB an PA11/PA12 und CAN wahlweise an PA11/PA12 oder! > PA8/PA9. Bin ich wohl spontan einer Ente aufgesessen:https://github.com/majbthrd/CANsniffer Aber es ist PB8/PB9 und nicht PA8/PA9.
-
Thread
LED- Schaltung
preiswerter sind als ein Arduino. Der hier erwähnte STM8S103 sollte laut Datenblatt (maximum rating conditions) allerdings nicht dauerhaft mit 20mA belastet werden. Aber die LEDs wechseln ja oder man kommt mit z.B. 15mA aus. Immernoch hell genug.
doch die perfekte Lösung. :) > > Charlyplexing mit Lookup-Tabelle und Arduino > oder z.B. einem STM8S103F3P6 Board. hm.... und wie wäre es mit "Charlieplexing mit dem Pollin Roulette-Spiel"? https://www.mikrocontroller.net/topic/465788#5680246 Die Grundplatine ist vorhanden, und alles wäre
-
Thread
Controller für DCDC Converter
großen Auswahlbox "Comparator" und "DAC" auswählst, bleiben nicht mehr so viele übrig, hauptsächlich STM32F3xx Wenn's etwas mehr sein darf ;) STM32F334 mit 217ps PWM. Evt. kommst du sogar mit dem 32-Pin-Gehäuse mit 0.8mm Pitch aus. http://www.st.com/web/en/catalog/mmc/SC1169/SS1576/LN1820
Bei den STMs kannst du ein Discovery Boards als Debugger nutzen. Da ist ein ST Link V2 drauf. Die Toolchain wäre dann die Frage. CoIDE (1.7.8) tut es, aber ich weiß nicht ob es deine Anforderungen erfüllt.
-
Thread
Welchen PIC würdet ihr nehmen?
solche Pfuschsoftware? Oh Mann ... Sven S. schrieb im Beitrag #3159975: > Ich hab mal mit einem STM32F4 eine Platine gemacht gehabt aber die > kostet ca. 200€ pro stück, das geht garnicht. Daher wollte ich ein > billiges PIC Board Für 200€/Stück kann ich ja 8 Lagen machen. Was hast denn da
Also ich glaube das ich doch mein altes STM32 F4 board nehme und es auf das nötigste runterbreche. den code der mit flowcode erstellt wurde kann ich da implementieren. der rest ist i/o sache. Der Pic würde 6-8 euro kosten, da kann ich auch den
-
Thread
Arduino bietet nicht genug PWM-Pins
STM32?
hinbasteln. Softwareseitig natürlich auch Arduino-Kompatibel: https://os.mbed.com/users/hudakz/code/STM32F103C8T6_Hello/
-
Thread
PSK 31 Modlulation im Mikrocontroller
buffer[i] = 0; } //uint32_t period_0 = TIM2->ARR; int32_t neg_peak_value; uint8_t neg_peak_time; uint8_t symbol_sample_time = 16; uint8_t time = 0; int16_t x = 0; while (1) { if (have_sample) { have_sample = false; int32
marc schrieb im Beitrag #3947352: > Ich schätze, dass die Rechenleistung eines Atmega8 für den Dekoder > ausreichen würde .... Das müsste gehen, das ist auch meine Absicht. Der einzige Grund warum ich das momentan auf dem stm32 laufen habe ist der daß ich den (als totaler ARM-Neuling
-
Thread
Anpassbares GUI für STM32F4
für die STM-Familie oft genannt wird ist ja die Segger Version von STM. Allerdings bin ich mir nicht sicher ob sich diese Oberfläche genug an meine Bedürfnisse anpassen lässt. Das GUI sollte möglichst schlicht
laufen schon, als Standbild. Aber eine Performance wie der TO sich wünscht erreichst du auf einem STM32 nicht!
-
Thread
Eclipse CDT + ARM + AVR
kopieren. Ich habe alle CMSIS Core Header mal aus den Cube-HAL Paketen extrahiert: http://stefanfrings.de/stm32/CMSIS-STM32.zip
Beitrag #6050185: > Allerdings nutze ich gerne die auf Eclipse basierte > "System Workbench for STM32", wo OpenOCD samt Plugin funktionsfähig > vorkonfiguriert sind. Lassen sich denn in SW4STM32 und/oder STM2CubeIDE CubeMX-Makefile-Projekte einbinden, kompilieren und debuggen? Das Makefile-Projekt
-
Thread
Virtueller Serial Port Splitter gesucht Win10
COM8 erzeugen. * Logger mit COM 8 verbinden (der ist dann _belegt_ und wird nicht mehr gefunden) * Im Logger CNCX TX an COM8 RX streamen (und loggen) … und COM8 TX an CNCX RX streamen (und
STM32 schrieb im Beitrag #4734687: > --route=\\.\COM9 \\.\CNCA1 \\.\COM9 \\.\CNCB1 Und dann geht COM9 TX bei COM8 RX an? ?! Und wohin geht COM8 TX? Falls das ein Tippfehler war, vielleicht meintest
-
Thread
Ein kleiner Oberoncompiler für die C16x-Familie
ließen sich denn auf einem uC >> implementieren ? >> > >Alle. Ruby, Python, PHP auf nem Mega8 ?!?!? Zeig mal ... @ersa >Aber mir! Wer sagt denn das C#/.NET hier "nicht sinnvoll" seien? Ist >doch längst realität! Auch hier : Auf einem Mega8 ?!?! Zeig mal ... Von einem 32-Bitter zu
Controller von Infineon einfach, da ich die entsprechenden Definitionen von DAVE übernehmen kann. Für die STM-Controler wird das schwieriger, von STM gibt es keinerlei Support. Natürlich könnte man die Hedaerfiles von Keil benutzen, das wäre aber Klauen. Also werde ich diese für die meinerseits vorhandenen
-
Thread
DMX-Empfang mit STM32F767
Deinen Code schaue ich mir morgen früh am PC an. Eine normale uart -kommunikation zwischen PC und stm, oder auch stm zu stm habe ich bereits erfolgreich implementiert. Ich scheitere tatsächlich an den speziellen Gegebenheiten bei DMX: Break von 88us, Mark after Break 8u - und der Tatsache, dass nicht
(&huart1, (uint8_t*)buf3, strlen(buf3), HAL_MAX_DELAY); if ((isrflags & USART_ISR_FE)!=RESET){ //IF Frameerror detected message="Frame-error detected\r\n"; HAL_UART_Transmit(&huart1, (uint8_t*)message
-
Thread
stm32f103 CAN-Interface
als Versuche zu senden wobei er irgendwann aufgibt #define CAN_TxStatus_Failed ((uint8_t)0x00)/*!< CAN transmission failed */ #define CAN_TxStatus_Ok ((uint8_t)0x01) /*!< CAN transmission succeeded */ #define CAN_TxStatus_Pending ((uint8_t)0x02) /*!< CAN transmission pending */ #define CAN_TxStatus_NoMailBox ((uint8_t)0x04) /*!< CAN cell did not provide an empty mailbox */ (Auszug aus stm32f10x_can.h)
-
Thread
Netzspannung ans STM32F3 Discovery
ACTION=3&LA=2&ARTICLE=1598&GROUPID=3312&artnr=150.06-1 Da da immer noch 6V AC rauskommen (also etwa 8,4Vss) wirst du für einen typischen STM32 AD Wandler einen Spannungsteiler mit etwa 4:1 benötigen. Eine leichte Belastung des Trafos schadet sicher nicht, da die Leerlaufspannung höher sein dürfte. Wenn
http://www.st.com/content/st_com/en/products/evaluation-tools/product-evaluation-tools/mcu-eval-tools/stm32-mcu-eval-tools/stm32-mcu-discovery-kits/32f401cdiscovery.html Das hilft enorm, freie Pins zu finden, denn oft sind die Disco Boards ein wenig - sagen wir, verbaut. Uwe B. hat da schon einige
-
Thread
STM32 vs DSPIC vs AVR XMega
Für den STM32 gibt es die HAL-Library, und die beinhaltet auch sehr viele DSP-Routinen. FFT, Filter, alles dabei. Für Deien Anwendung würde ich gleich den STM32F4xx mit DSP-Befehlen nehmen. Gruß, Stefan
So wärmeempfindlich ist der STM32F4 gar nicht ;-) Viel Spaß beim Ausprobieren, Stefan
-
Thread
Elektronische Last mit MOSFET
viel für einen einzelnen MOSFET. Mein aktueller Plan wäre die OPs mit 12V für den dicken BUK (~0,8mR) und 4mR Shunt und das in 4facher Ausführung zu benutzen. (edit: die 0,8mR haben eigentlich kaum eine Relevanz, weil für 60A müsste ein MOSFET (15A pro MOSFET) dann einen Rds von 76mR haben 🙈 Aber
C-headern usw von einem Generator generiert 🥴 Ziemlicher Aufwand und echt krass wieviele verschiedene STM32s es gibt - war mir garnicht bewusst. Ist auch irgendwie ein Wunder wie STMicro diese "Vielfalt" überhaupt noch managen kann und der Code-Generator in STM32CubeMX eigentlich relativ gut funktioniert
-
Thread
Einstieg 32Bit µC - Welche "Familie"
ich die Treads auch nicht exhumiern möchte hier der neue Beitrag. Vorhanden ist die Erfahrung: 8-Bit µC (Schreib grade ne Ansteuerung für PATA nach dem ATA-8 Standart) PC Programmierung C / C++ / C++ Cli/.net sowie Grundkentnisse DirektX mehr schlecht als recht leider =/ Platinen ätzen kann ich
sind z.B Regler wo man am Eingang einen 8Bit Wert vom AD-Wandler hat und am Ausgang wieder einen 8Bit Wert fuer seine PWM benoetig. Dazwischen aber wird gerechnet und das sind 16Bit schon angesagt. Da merkt man erstmal so richtig was fuer
-
Thread
BLDC Startup Algorithmus eines China-ESCs
erkennen, siehe auch VESC. Der VESC Regler ist immernoch ein nebenprodukt. Früher waren es Atmega8 mit Simonk Firmware. Vor kurzem sind dann alle mit Silabs EFM8 Chips und Blheli_s gebaut worden. Aktuell gehen fast alle Hersteller auf STM32 mit Blheli_32 oder eben eigener Firmware, denn Blheli_32
Ben B. schrieb im Beitrag #5631085: > ROFL... jetzt braucht man schon einen STM32, um einen Motor zu drehen. > Mal sehen was als nächstes kommt. Vielleicht einen Intel x64 mit 16 > HT-Kernen?! Selbst ein x51 Single Core wäre genug, hätte er Timer, ADC und DMA eines STM32
-
Thread
Auflösung der Abtastung eines periodischen Signals mit ADC
relativ alt und würde früher in Oszilloskopen verwendet. Ich habe damit mal mit dem ADC eines Atmega8 das stehende Bild eines Videosignals gesampelt.
1,5 ns auf. Der zweite Anstieg ist übrigens die Reflektion vom Ende eines offenen Koaxkabels, ca. 8 Meter lang.
-
Thread
minimale Boards
kannst. Aber (L)QFP oder TSSOP bis 0.65mm Pinabstand finde ich von Hand noch einigermaßen lötbar. 0.8mm ist komfortabel. 0.5mm finde ich grenzwertig. > 3) Außer AVR und STM32 noch andere uC anschauen? Ich mag die STM8 ganz gerne. PIC24 und PIC32 gefallen mir zumindest auf dem Papier (ganz im Gegensatz
x^3 schrieb im Beitrag #5586196: >> Ich mag die STM8 ganz gerne. > > Wenn man das Gewuerge des C-Compilers bei seiner nativen Taetigkeit: > der Berechnung von int-Ausdruecken sieht, vergeht einem das > mitunter. Der STM8 ist ein recht C-freundlicher
-
Thread
uC Crystal Berechnung
Hallo zusammen, ich würde gerne eine Schaltung mit dem STM32 aufbauen. Dieser benötigt einen 8MHz Crystal und ich würde gerne folgenden benutzen: https://datasheet.lcsc.com/lcsc/2103291135_Yangxing-Tech-X50328MSB2GI_C115962.pdf CL ist bei dem Exemplar das
ST selber hat mit AN2867 eine gute Beschreibung für die Quarzoszillatoren der STM32 herausgebracht. https://www.st.com/resource/en/application_note/cd00221665-oscillator-design-guide-for-stm8afals-stm32-mcus-and-mpus-stmicroelectronics.pdf (Falls der Link irgendwann nicht mehr
-
Thread
HDMI für Bastler machbar ?
https://www.amazon.de/deleyCON-Repeater-Signal-Verst%C3%A4rker-Kabel/dp/B009117JP8/ref=sr_1_2?ie=UTF8&qid=1477641838&sr=8-2&keywords=hdmi+verst%C3%A4rker
bei 24bit RGB seriell (DSI) > > Klingt interessant ! > > > Die Pixeldaten kommen aus einem 8- oder 16-Bit Buffer bestehend aus > einem (vermutlich) 55ns-SRAM. Als Bildquelle sollten sich die Display-Controller üblicher Mikrocontroller, wie z.B. STM32 eignen. Oder natürlich FPGA. > Braucht
-
Thread
USART Verbindunz zwischen Atmega 32 und Cortex M3 (Stm32)
functions.h" void uart_init(void); functions.h: void uart_init(void) { UBRRH = UBRR_VAL >> 8; UBRRL = UBRR_VAL & 0xFF; UCSRB |= (1<<TXEN); // UART TX einschalten UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // Asynchron 8N1 } [/c] Prozessor B: Auszug vom Programm: [c
System A: -6,8V am TX System B: 7V am TX
-
Thread
wie im µs Berich effizient warten
Hi, beim Atmel habe ich einmach _delay_us() verwendet aber beim STM32 finde ich schade wenn der Gute mit 72Mhz rennt und im Code gewartet wird.
es auch bei verschiedenen Displays bei mir https://github.com/adafruit/Adafruit-GFX-Library/blob/8d7bdff6dc9dac30528469936959a446b661c8b9/Adafruit_GFX.h#L133-L154 Aber diese Lib ist für Grafikdisplays und die kann der TO bei seinem DOGM163 nicht gebrauchen.
-
Thread
DCF77 von Peter Danegger
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, // year 0xFF }; // parity uint8_t PROGMEM BMASK[] = { 1, 2, 4, 8, 10, 20, 40, 80 }; struct time newtime; uint8_t dcf77error = 0; uint8_t synchronize = 0; // successful recieved void decode_dcf77( uint8_t pulse
// day 6 1, 2, 4, // weekday 3 1, 2, 4, 8, 16, // month 5 1, 2, 4, 8, 16, 32, 64, 128, // year 8 0x0 }; // parity 1 void decode_dcf77(uint8_t pulse) { uint8_t i; static uint8_t parity=0; if
-
Thread
STM32: SPI - HAL durch eigenen code ersetzen
SPI_CR1_SSM | SPI_CR1_SSI; g_spi->CR2 = SPI_CR2_DS_0 | SPI_CR2_DS_1 | SPI_CR2_DS_2| SPI_CR2_FRXTH; //8Bit, 8Bit RX threshold [/c] Der Chip ist ein STM32L452. [c] SPI_TypeDef * g_spi = (SPI_TypeDef *)SPI2_BASE; void PerPrint(void) { printf("CR1: %08x\r\n", (unsigned int)g_spi->CR1);
) { //something to receive printf("RX1\r\n"); uint8_t data = *(__IO uint8_t *)g_spi->DR; if ((dataIn) && (rxLen >= 1)) { *dataIn = data; dataIn += sizeof(uint8_t); rxLen -= 1; } } } //while (g_spi->SR
-
Thread
[V] uC, Digtal, Analog, Transistoren, Evalboards
-> 0,75€/Stk. 120x NCP303LSN30T1G, On Semi: Low-Noise OP -> 0,10€/Stk. 8x TSV912AIYST, STM: Dual RRIO OP -> 0,25€/Stk. 90x LMV822M/NOPB, TI: Dual Low Voltage RRO OP -> 0,25€/Stk. 1x INA122UA, TI: Micropower Instrumentation Amplifier
-> 0,75€/Stk. 120x NCP303LSN30T1G, On Semi: Low-Noise OP -> 0,10€/Stk. 8x TSV912AIYST, STM: Dual RRIO OP -> 0,25€/Stk. 80x LMV822M/NOPB, TI: Dual Low Voltage RRO OP -> 0,25€/Stk. 1x INA122UA, TI: Micropower Instrumentation Amplifier
-
Thread
Webserver: Software wie am besten realisieren?
deaktiviert. Ging eigentlich relativ gut. Nun möchte ich einen neuen Webserver machen. Mit X-Port und STM32. Zugriff übers Internet soll auch wieder möglich sein. Das ganze Handling würde ich am liebsten auch wieder komplett im STM32 machen. Ich kann nur C und etwas HTML. Zu Beginn würde ich mal eine primitive
spart dir Rechenzeit (falls nötig) auf dem STM32. Komplizierter wird Secure HTTP, aber evtl. finden sich da Beispiele im Netz.
-
Thread
STM32F103C8T6 - TIM2 PWM
Habe eine kleine (STM32CubeIDE) Anwendung auf einem STM32F103C8T6 und möchte auf pin PA15 ein PWM-Signal ausgeben. Es kommt aber leider nichts raus. Habe das Problem auf ein kleineres Projekt heruntergebrochen, was auch
geladen. Die Frequenzen gehen von 32 bis 65 Hz. 256 Stützwerte ergibt eine Samplefrequenz von ca. 8,3 - 17,7 KHz. Die gibst Du dann auf den DAC und fertig - dachte ich. Vielleicht noch einen Tiefpass als Opamp hinter den Ausgang und fertig. DAC? Wo war der denn? Mußte lernen, daß der STM32F103C8T6
-
Thread
STM32 - 16Bit Integer Wert über UART senden
Hallo, ich arbeite mich gerade mit dem NUCLEO Board L476RG in die STM32 Welt ein. Gibt es eine einfache Möglichkeit mittels HAL Library einen 16Bit Integer Wert über die UART zu senden? Oder muss ich diesen Wert in 8Bit Werte vorher zerlegen?
die HAL_Uart erwartet einen pointer bei 8N1 werden nur 8 bit gesendet also übergibst du ihm einfach deinen 16mit wert und castest auf 8bit mit der länge 2 kurz gesagt: uint16_t wert; HAL_UartSend( UART1 , (uint8_t*) &wert , 2 );
-
Thread
Shield 4 oder 5
Moin, nach über 1jährigem Lauf meiner Wordclock auf dem STM32F103C8T6 mit ESP8266 (gelötet auf dem STM-Shield V.5) funktioniert die Uhr nach einem Neustart für ca. 2 Stunden, danach fallen die unteren 5 Zeilen aus und das Netzteil wird sehr heiß. Da ich noch
gefunden der ein STM32F103, > ESP8266 und DS3231 RTC + EEPROM miteinander verbindet. Willkommen im Makerverse . . . 8-0 > Wenn Niemand einen Plan für mich hat werde ich mich hiermit vom Projekt > "Wordclock" verabschieden
-
Thread
Index von Array: welcher Datentyp in C
Testvariable uint32_t Feld; // Parameter für die Feldauswahl Feld = 18; test = array[(uint8_t)Feld]; [/c] Grund für die Frage: Da ich einen STM32 verwende, möchte ich weitestmöglich 32-Bit-Variablen verwenden. Dann muß der Mikrocontroller nicht ständig aus 32-Bit-Registern 8-Bit-Werte
sind solche wirklich "schmutzigen" Makros obsolet. P.P.S. Zur ursprünglichen Frage des TOs: 8-Bit-Variablen sind auf den STM32 tatsächlich *erheblich* langsamer als 32-Bit-Variablen - nicht nur als Indices. Wenn der TO tatsächlich 8-Bit verwenden will, um anzudeuten, dass sein Index niemals größer
-
Thread
Game of Life läuft nur eine Runde!
] void GameOfLife_Spielfeldzeichnen(uint16_t Spielfeldgroesse_x, uint16_t Spielfeldgroesse_y, uint8_t *SpielfeldPt) { uint32_t X = 0; uint32_t Y = 0; uint8_t i = 0; uint8_t j = 0; uint8_t Textarray[] = "Conways Game of Life"; uint8_t *TextPt = &Textarray[0]; /* Layerswitch
= TOT; } Nachbarschaft = 0; } X++; } } void FeldCheck(uint8_t *RegelPt, uint8_t *SpielfeldPt, uint8_t *SpielfeldschattenPt, uint16_t Spielfeldgroesse_x, uint16_t Spielfeldgroesse_y) { uint8_t Nachbarschaft = 0; uint8_t X = 1; uint8_t Y = 1; while
-
Thread
Nachfolger Bluepill?
moin, für mich habe ich folgende Lösung gefunden: BlackPill mit STM32F401CC kaufen, den MC ersetzen durch STM32F412CE. BlackPill mit STM32F401RC kaufen, den MC ersetzen durch STM32F446RE. Beim STM32F401RC stört mich, das dieser 7,5 Raster Abstand der Stiftleisten
USB-Peripherie ein Pluspunkt. Von der Rechenleistung > hätte es bei fast allen diesen Projekten ein 8-Bitter auch getan. Dann solltest du dir die STM NUCLEOs angucken. Daist sogar der ST-Link schon drauf. Und es gibt sie mit verschiedenen Controllern.
-
Thread
Beratung bzgl. Wahl des Mikrocontrollers
Also ich würde auf jeden Fall das STM32F4-Discovery-Board empfehlen, oder zum Selbstlöten einen Cortex M3 oder M4
Board Pins > draufgehen(Gyro, Taster, Aux, USB-Micro, LED's, etc.) Gibt ja auch andere Boards mit STM32 ohne dieses Zeug. Außerdem sind noch ziemlich viele Pins frei. > und dass man ohne > weiteres KEINE Grafische Oberfläche hat, auf der man das Linux bedienen > könnte, weil das STM keinen Videoausgang
-
Thread
Waage-Terminal emulieren mit STM32 development board + 2.4 inch TFT
Hallo ManiB! Das STM32L Discovery Board hat ein LCD Display einen Touchslider zwei Leds und einen Userbutton samt ST LinkV2 Programmieradapter um ~10,- Euro. Das STM8L Discovery Board hat ein LCD Display zwei Leds und
Stefan Oberpeilsteiner schrieb im Beitrag #3226416: > Hallo ManiB! > > Das STM32L Discovery Board hat ein LCD Display einen Touchslider zwei > Leds und einen Userbutton samt ST LinkV2 Programmieradapter um ~10,- > Euro. > > Das STM8L Discovery Board hat ein LCD Display
-
Thread
infinite loop, externer Interrupt, STM32F746, HAL-Library
ohne CubeMx?)? Aktuell behelfe ich mir da mit der Google-Suche. Aber das ist mühsam. Mit Arduino (stm32duino) kann ich einfach attachInterrupt() machen, und es läuft. [c] #include "stm32f7xx.h" #include "stm32f7xx_hal_def.h" #include "../Utilities/STM32746G-Discovery/stm32746g_discovery.h"
/Projects/STM32F746ZG-Nucleo/Examples/GPIO/GPIO_EXTI/Src/stm32f7xx_it.c#L155-L158
-
Thread
STM32-F407-DIY-MORE mit gdb und blackmagic blue pill programmieren
9" | sed 's/^.* //'` sed -i -e "s,/dev.*$,$USBDEV," .gdbinit /Users/kuku/opt/gcc-arm-none-eabi-8-2018-q4-major/bin/arm-none-eabi-gdb [/c] (damit ich beim Ändern des Devicenamens den nicht immer neu eingeben muß) [c] $ ./GDB GNU gdb (GNU Tools for Arm Embedded Processors 8-2018-q4-major) 8.2.50.20181213
einen Exkurs in die Grammatik veranstalten wollen: Du übersiehst das Objekt: <Akkusativ Objekt>: STM32-F407-DIY-MORE <Subjekt(substantiviertes Verb)>: programmieren <Adverbiale Ergänzung>:mit gdb und blackmagic blue pill Wen oder was? STM32... Was: programmieren Mittels: gdb und bmp bp Weder
-
Thread
Wetterstation - Low Power Design
dabei. Die braucht man zwar nicht unbedingt, aber damit könnte man noch mehr Strom sparen. Den 8MHz-Quarz könnte man ganz weg lassen. Die internen RC-Oszillatoren der STM32L4 können per Software und beim L431 auch per Hardware getrimmt werden. Als Referenz dienen die 32kHz oder ein 1Hz-Takt von
Feuchtesensor durch Kapazitätsmessung. Und kleine Cortex-M brauchen im Deep Sleep auch nur 0,x µA. Das 8 Bitter sparsamer sind ist wohl eine nicht totzukriegende Mär.
-
Thread
stm32 SPI NSS Signal Anfänger
*/ /* Includes ------------------------------------------------------------------*/ #include "stm32f10x.h" #include "platform_config.h" /** @addtogroup STM32F10x_StdPeriph_Examples * @{ */ /** @addtogroup SPI_DMA * @{ */ /* Private typedef -------------------------------
(void); void GPIO_Configuration(void); TestStatus Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength); /* Private functions ---------------------------------------------------------*/ /** * @brief Main program * @param None * @retval
-
Thread
Suche alternatives Bauteil (DMS307/308)
307 Und jetzt gehts mit einer Suchmaschine Deiner Wahl weiter. Du suchst einen kleinen Chip mit 8 Pins.
So wie es aussieht, kann das sogar ein STM32F0: https://hsel.co.uk/2015/06/16/stm32f0-audio-graphic-spectrum-analyzer/ Eigentlich ein interessantes Thema, leider habe ich keine Zeit mich damit zu befassen.
-
Thread
arduino oder GCC Programmierung
= 5.2.0 __GNUC_MINOR__ = 2 __GNUC_PATCHLEVEL__ = 0 in *.h struct eep_var{ uint8_t backlicht; // eep_var uint8_t contra; // eep_var uint8_t bias; // eep_var char mesz_str[5]; // "MESZ" || " MEZ" }; extern struct eep_var MY_EEP_VAR; in der *.c ausserhalb
// I2C Busfehler ? } return true; } bool readTwoRegister (const uint8_t i2cAdr, const uint8_t firstReg, uint8_t &var1, uint8_t &var2) { Wire.beginTransmission(i2cAdr); // Connect Wire.write(firstReg); // Anfrage ab/der Register Nummer if
-
Thread
STM32x kein malloc mehr möglich
mcu/modules.php?mop=modload&name=Splatt_Forums&file=attachment&AtchOp=get&postid=20160&AtchName=cs-stm32-0.91.zip&AtchNum=0) Syscalls habe ich auch begefügt, diese habe ich aus einem STM32-Framework. (zu finden unter http://www.munts.com/MCU/ARM/stm32f103/) In den Syscalls wird mit end[] der Heappointer
20STM32-103STK-.zip , zu finden im Ordner STM32-103STK-MassStorage/app die Dateien mmc.c +.h und mmc_ll_SPI2.c). Den habe ich modifiziert und erstmal alles was die DMA betrifft, entfernt. Das ist meine Grundlage
-
Thread
CooCox parasitär?
Hallo, Schau doch mal die STM32 Reihe und die Evalboards dazu an. Die Discoveryboards sind sehr günstig und haben schon einen integrierten Debugger mit dabei. Ich habe mich damals für STM32F4Discocery entschieden, da dieser massig
es aber auch die STM32F103 beim Chinesen, so ein http://de.aliexpress.com/item/STM32F103C8T6-ARM-STM32-Minimum-System-Development-Board-Module-ForArduin/32282374854.html Board (mit 64 Karat Flash!) habe ich gerade hier
-
Thread
STM32F0 Bootloader-Problem (UART, Neuling braucht Hilfe)
Hallo liebe Leute! Ich muss ein bisschen weiter "ausholen": Ich habe mein erstes Board mit einem STM32-Controller entworfen. Konkret ist es der STM32F030C8T6. Ich habe vorher noch nie mit STM32- oder STM8-Controllern gearbeitet. Ich hab heute Morgen das Board zum ersten Mal eingeschaltet. Soweit
habe ich das so verstanden). Ja. Siehe Datenblatt unter https://www.st.com/resource/en/datasheet/stm32f030c8.pdf Seite 12/93, Abschnitt 3.3 Boot Modes. Da steht ganz klar: "The boot loader is located in System Memory. It is used to reprogram the Flash memory by using USART on pins PA14/PA15 or
-
Thread
8MHz Quarz, aber STM32 läuft mit 72MHz.
Kannst ja mal mit STM32CubeMX deine Konfiguration nachbauen und dann den Unterschied zu deinem Code suchen.
schwingen und eine der (vielen) Oberwellen ausfiltern, verstärken und weitergeben. Im Falle eines STM des TOs würde also die Frequenz von 8 MHz auf 72MHz, oder in vielen anderen Fällen, auf 168 MHz vervielfacht, was nicht der Fall ist. Somit behaupte und bestätige ich nochmals meine Aussage:
-
Thread
verschwundene MIDI-Synth-Boards: Nachfolgetechnik?
Soft-Musikinstrumente dabei, Klavier, Orgel, Drums, AnalogSynth usw. Spaß macht auch der SuperWave P8, ein VST Plugin. Mit ein paar Tricks läuft dieses 32-Bit VST Plugin auch unterer einem 64 Bit Host. (https://www.superwavesynths.com/p8). Ist halt dann komplett weg vom Selbstbau.
wavetable Synthese per MIDI-ÜBerblendung, wie man es sonst mit outboard-Equipment gemacht hat: 8 Kanäle reagieren auf denselben MIDI-Eingang, spielen aber 8 Stimmen mit jeweils unterschiedlichen Sounds. Die ADSR der 8 Stimmen werden so eingestellt, dass sie zeitlich versetzt aktiv werden. Weil das