-
Thread
stm32 uart flash reset über gpio?
https://satoshinm.github.io/blog/171223_jtagswdpillblink_jtagswd_debugging_via_black_magic_probe_on_an_stm32_blue_pill_and_blinking_a_led_using_stm32cubemx_libopencm3_and_bare_metal_c.html
stm32f103c8_blue_pill.cfg Open On-Chip Debugger 0.10.0+dev-01177-gb9a30e08-dirty (2020-04-13-16:34) BCM2835 GPIO nums: swclk = 11, swdio = 25 swd Info : Listening on port 6666 for tcl connections
-
Thread
Taugen MSP430 noch was?
sind viel zu sehr > damit beschäftigt intel im PC-Markt zu bedrängen. Daher auch die Cortex-M0, M0+ von ARM. SiLabs EFM32 Zero, Freescale KL0 (und etliche andere), NXP LPC800, STM32F0 usw. Selbst einige der größeren M3/M4 sind in einem ähnlich niedrigen Bereich des Strombedarfs.
sind viel zu sehr >> damit beschäftigt intel im PC-Markt zu bedrängen. > > Daher auch die Cortex-M0, M0+ von ARM. > SiLabs EFM32 Zero, Freescale KL0 (und etliche andere), NXP LPC800, > STM32F0 usw. Selbst einige der größeren M3/M4 sind in einem ähnlich > niedrigen Bereich des Strombedarfs.
-
Thread
µC-"Kulturgut"-Verlust:STM32: mikrocontroller.bplaced.net
Beispiele findet ihr unter diesen dropbox links (bin mir nicht sicher ob aktuell und vollständig) STM32F407: https://www.dropbox.com/sh/2r76h2isusr8a02/AAC_X0Q6NAD-_Zkiyg3ZchT8a?dl=0 STM32F429: https://www.dropbox.com/sh/lcmhpkk4q89r3sq/AAD9o7BPZrSlwa5Gryd3uEG0a?dl=0 STM32F746: https://www.dropbox.com
Uwe B. schrieb im Beitrag #5197441: > STM32F407: > https://www.dropbox.com/sh/2r76h2isusr8a02/AAC_X0Q6NAD-_Zkiyg3ZchT8a?dl=0 Hi Uwe, es fehlen folgende Demos: 97 = ILI9325 (um ein Grafik-Display mit dem ILI9325 Chip anzusteuern) 98
-
Thread
stm32f411re timer clock speed ermitteln?
für Timer-Clocks rauskommen. Diese tippe ich dann ab, um die Datei system_stm32f4xx.c an den entsprechenden STM32 anzupassen. Du findest diese im Anhang. Unterstützt werden damit: [code] STM32F103C8 Mini-Dev-Board STM32F401RE Nucleo Board STM32F411RE
zugehörigen Kondensatoren bequem nachrüsten. Die resultierenden Clocks findest Du im Code, z.B. für STM32F411RE: [c] /*---------------------------------------------------------------------------- * STM32F411RE Nucleo Board with 8 MHz crystal (100 MHz) * * Input frequency 8MHz * PLL M
-
Thread
STM32 Discovery-Boards
Das STM32F4Discovery hat im Vergleich mit dem STM32VLDiscovery den wesentlich leisungsfähigeren Prozessor und ist nicht wirklich teurer. Wenn du auf das LCD und die Audio Peripherie, die Michael beim STM32LDiscovery
stecken, beim stm32f4 geht das nicht mehr.
-
Thread
Mikrocontroller aussuchen
STM32H7 Dual Core
STM32F0 im TSSOP 20 Gehäuse reicht dafür locker aus... Man kann auch zu einem AVR greifen, aber wozu?
-
Thread
ARM Cortex M0+ Startupcode Minimal
Stefanus F. schrieb im Beitrag #5790070: > Die System Workbench for STM32 generiert recht übersichtlichen > Startup-Codee für C Projekt. Ich habe ihn mal angehängt. Was mich an diesem Code schon lange juckt: Er ist für ARMv6M geschrieben und damit für den Cortex-M0(
, die Programmiersprache auf einem PC (ohne µC) zu erlernen (falls nicht bereits geschehen) und danach schau Dir mal meine STM32 Seiten an. Ich habe da schon ein bisschen was für den STM32L0 (das ist ein Cortex-M0+) zusammen geschrieben. Du wirst
-
Thread
SPI-RAM-Bank an STM32F0-Discovery - write, kein read
convert and flash: VGACam-RamBank.hex VGACam-RamBank.hex converted to flash.bin. Starting upload to STM32F103: Bootloader version 22 Chip id `['0x4', '0x10']' Write 256 bytes at 0x8000000 Write 256 bytes at 0x8000100 [...] Write 256 bytes at 0x8006000 Write 256 bytes at 0x8006100 Read 256 bytes
- http://stm32flash.googlecode.com/ Serial Config: 115200 8E1 Version : 0x22 Option 1 : 0x00 Option 2 : 0x00 Device ID : 0x0410 (Medium-density) - RAM : 20KiB (512b reserved by bootloader
-
Thread
Empfehlungen für aktuellen µC
aber nicht ultra-Sparsam (kein Batteriebetrieb) > - 2x UART > - 4x PWM (unabhängiger Kanal) > - I2C > - 2x SPI > - Toolchain / Programmer unter Linux lauffähig und Open Source > Meine Empfehlung stm32f411 https://stm32-base.org/boards/STM32F411CEU6-WeAct-Black-Pill-V2.0. Preiswert zu bekommen, wenn man etwas Zeit bei Aliexpress. Und den ST Link gleich mitbestimmen. https://stm32-base.org/boards/Debugger-STM32F103C8U6-STLINKV2 Mit Cube-IDE, läuft perfekt mit Linux Christian
-
Thread
Bootloader STMF413VGT6
normales Programm geschrieben. Startadresse 0x8000000. zu ladendes Anwendungsprogramm: Startadresse bei mir 0x8010000 dann den linkerfile entsprechend anpassen und jetzt kommt das merkwürdige: im sourcefile system_stm32f4xx.c, das von CubeMX
ich dafür ein Discoveryboard hoer habe): [c] #include "stm32f4xx.h" #define T_OUTPUT 0x01 #define MODE(a,b) ((b)<<(2*a)) #define SET(a) (1<<(a)) #define F_CPU 16000000 volatile static uint16_t temp = 0; int main(void){
-
Thread
STM32F4 sprintf Problem
zu senden. Mich laust es aber, warum das mit sprintf nicht geht. [c] #include "stm32f4xx.h" #include "stm32f4_discovery.h" #include "tm_stm32f4_usart.h" #include <stdio.h> #include <stdlib.h> int main(void) { SystemInit(); char str[120]; TM_USART_Init
in OpenSTM32 muss da wenn ich das richtig sehe __FPU_USED=1 definiert sein. Hier ein Auszug aus der system_stm32f4xx.c [C] void SystemInit(void) { /* FPU settings --------------------------
-
Thread
STM32 : QWord
überhaupt sein soll! Das ist allerdings wirklich wenig verständlich; er vertraut wohl darauf dass STM32-Kundige wissen, wie das bei allen STM32 aussieht.
sein soll! > > Das ist allerdings wirklich wenig verständlich; er vertraut wohl darauf > dass STM32-Kundige wissen, wie das bei allen STM32 aussieht. Er hat ja auch erst im 11. Post preisgegeben, dass es um Pascal und nicht um C geht. Warum sollte er also den Controller so schnell preisgeben?
-
Thread
Sinn und Zweck des TXFE-Bits im STM32F407?
Habe jetzt den FIFO komplett gefüllt, 3 Pakete, 1076 Bytes. [c] dieptsiz1.d32 = USB.INEP_REGS[1]->DIEPTSIZ; dieptsiz1.b.pktcnt = 3; dieptsiz1.b.xfrsiz = 1076; USB.INEP_REGS[1]->DIEPTSIZ = dieptsiz1.d32; USB.INEP_REGS[1]->DIEPCTL |= DIEPCTL0_EPENA|DIEPCTL0_CNAK; for (uint32_t i = 0; i < 269; i++){ *(USB).DFIFO[1]=*((uint32_t *)(test_string)+i); } USB.DREGS->DIEPEMPMSK |= DIEPEMPMSK_INEPTXFEM_1; [/c] Zwei IN Interrupte werden ausgelöst, der erste TXFE,
-
Thread
Diskussionsrunde: Opensource Entwicklungstools für STM32
newtap stm32 cpu -irlen 4 -ircapture 0x1 -irmask 0xf -expected-id 0x3ba00477 jtag newtap stm32 bs -irlen 5 -ircapture 0x1 -irmask 0x1 -expected-id 0x16410041 target create stm32.cpu cortex_m3 -endian little -chain-position stm32.cpu stm32.cpu configure -work-area-virt 0 -work-area-phys 0x20000000 -work-area-size 16384 -work-area-backup 0 flash bank stm32x 0x08000000 0x20000 0 0 0 script flash-elf.script [/pre] Das
-
Thread
C++ auf einem MC, wie geht das?
z.B.: https://github.com/roboterclubaachen/xpcc/blob/develop/src/xpcc/architecture/platform/devices/stm32/stm32f405_407_415_417-i_r_v_z-e_g.xml 2. Mit deren Hilfe werden für jeden verfügbaren (also auch gebondeten) Pin drei Klassen erzeugt: z.B. GpioA0, GpioOutputA0, GpioInputA0 Das Headerfiletemplate
Scelumbro schrieb im Beitrag #3990136: > Überhaupt die zusammenarbeit von ISR mit C++ bereitet mir noch > Kopfzerbrechen. Auf einem STM32F4 Discovery Board habe ich das so gelöst: [c] (...) static dma::DmaChannel ada_dmaChannel(adc_dmaStream, 0); static
-
Thread
STM32F103: Delay mit TIM2
= TIM2->CNT; while((TIM2->CNT - StartTick) <= msTick){ }; TIM_Cmd(TIM2,DISABLE); } [/c] timer.h [c] #ifndef TIMER_H #define TIMER_H #include <stm32f10x_tim.h> #define DELAY_TIM_FREQUENCY_MS 1000 extern void ConfigDelay_in_ms(void); extern void delay_ms(uint32_t
diesen Falle habe ich: SystemCoreClock = (720000 / 2000) = 36000. Dieses wieder durch 65535 = 0,54 ms Der Bezeichner msTick in void delay_ms(uint32_t msTick) wird mit 2 multipliziert d.h. es ergibt sich 1,08 ms. timer.c [c] #ifndef TIMER_H #define TIMER_H #include <stm32f10x_tim.h
-
Thread
Kleines Tiny13 Sensorboard
STM32F4 schrieb im Beitrag #4288671: > und nach > jeder C-Implementierung erfindest du neue Anforderungen. Stimmt. Gab ja schon einige C-Versionen... Wo ist eigentlich Deine? Ich erfinde natürlich
STM32F4 schrieb im Beitrag #4288695: > Zählt Entwicklungszeit auch als Ressource? Die kann keine große C-Ressource sein, sonst wär schon längst eine Lösung fertig die meiner das Wasser reichen kann
-
Thread
Blinking a mikrocontroller
0x01; _delay_ms( 100 ); } return 0; } [/c] Das Listing: [c] int main(void) { DDRB |= 0x01; 0: b8 9a sbi 0x17, 0 ; 23 while(1) { PINB |= 0x01; 2: b0 9a
Christoph M. schrieb im Beitrag #7855104: > Welche IDE würdet ihr für den STM32L432 verwenden, um zu assemblieren? STM32CubeIDE, und eben den C-Code aus dem Projekt löschen.
-
Thread
ARM Cortex M3/M4: Wieviele Takte verbraucht diese Funktion?
Anfang an feststeht, die Flash-Waitstates > hineinspielen? Ich erkläre das mal am Beispiel eines STM32F103 und diesem (nicht optimalen) Code: [c] void delay(uint16_t msec) { for (uint32_t j=0; j<2000*msec; j++) { __NOP (); } } [/c] Diese Funktion soll eine gewisse
Hoppla, veraltete Version. Richtig ist natürlich: [c] /* nanoseconds: Konstant zur Compilezeit */ void delay_nsnew(uint32_t nanoseconds) { const uint32_t loopOverhead = 0; // FIXME: Tatsaechlicher Overhead unbekannt uint32_t nCycle = nanosecondToCycle
-
Thread
HY_STM32F417_BB
...das neue STM32F2-F4_Demonstration_Builder_V1.0.0 ; comp. mit dem alten atollic , geflascht mit ST-Link eines Discovery; - als STM322x-Eval und STM32f417ZGT als Prozessor;
/stappl/resourceSelector/app?page=resourceSelector&doctype=FIRMWARE&SubClassID=1520 - als STM32F105/7 STM32F2 and STM32F4 USB on-the-go Host and device library (auch ohne USB-Teil ist hier die TFT - Soft) -im 2. Teil beziehe ich mich auf : STM32F2 and STM32F4 demonstration builder platform
-
Thread
S: Doku für SI5351 I2c LowLevel
es dir, von meinem Beispielcode abzugucken. Damit müsste das klappen: http://stefanfrings.de/stm32/stm32f1.html#i2c
, den STM32F103C8T6 probiere ich jetzt noch aus. Pille
-
Thread
STM32 SPI HAL extrem langsam
Der FIFO wird beim H7 in HAL_SPI_Transmit genutzt. https://github.com/STMicroelectronics/STM32CubeH7/blob/0c3a06c18bd2a87b006a84f997f2b0b56d97a113/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_spi.c#L941
> Der FIFO wird beim H7 in HAL_SPI_Transmit genutzt. > > https://github.com/STMicroelectronics/STM32CubeH7/blob/0c3a06c18bd2a87b006a84f997f2b0b56d97a113/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_spi.c#L941 Danke. Diese funktion scheint auch nicht blockierend (zumindest nicht wenn der SPI
-
Thread
µC und Gbit Ethernet
STM32MP und STM32N6 haben auch GBit Ethernet, STM32N6 ist eher ein uC. STM32MP ohne Linux etc duerfte schwieriger sein.
Uwe B. schrieb im Beitrag #7852476: > STM32MP und STM32N6 haben auch GBit Ethernet, STM32N6 ist eher ein uC. > STM32MP ohne Linux etc duerfte schwieriger sein. OK, hatte bisher noch keine Berührungspunkte mit den MPUs... Was ist denn
-
Thread
STM32 - Debugger - Software ?
zusammen, kurzes Frage-Antwort-Spiel in die Runde. Frage: Da will doch jemand nen ARM genauer nen STM32 kennen lernen, oder? Antwort: Ja Frage: Reicht da nicht dieses völlig super billige (Preis < 10€) fast schon geklaute STM32F0DISCOVERY Board die es bei den verschiedenen Elektronikversandhäusern gibt? http://de.farnell.com/stmicroelectronics/stm32f0discovery/eval-bord-cortex-m0-stm32f0/dp/2096251 http://www.watterott.com/de/STM32F0DISCOVERY Antwort: Hat sich für den Einsteiger hoffentlich erledigt. Mit dem Ding kann man auch Debuggen
-
Thread
Zeigt her eure Kunstwerke (2) Gesperrt Bilder
Vorgestellt hier ist meine neueste Einsteckplatine für den STM32F10Vx MCU. An zusätzlichen Bauteilen sind vorhanden. MAX3223 RS232 Transceiver mit Anschluss Flag TMP101 Temperatursensor + (Interner STM32 Die Sensor ist auch vorhanden) AT24C08 EEPROM LM4132
Universaltaster und RESET Taster ist vorhanden. Die kleine LED Statusplatine oben links wird mittels I2C und PCA9554 angesteuert. Die 4x4 Keypad ist chinesischer Herkunft. Die neueste Version der STM32-MINI Platine kann nun mit allen 100-pin Versionen bestückt werden (STM32F10X,20X,40X). Leider habe
-
Thread
STM32 Flash Schaltung über UART
Für die STM32G0 ist ein Debug-Stecker ganz besonders zu empfehlen. Ich bin bei STM32L4xx immer ohne ausgekommen, aber bei einem G0 habe ich den dringend gebraucht. Neben SWDIO, SWCLK und GND gehört da auch NRST
weniger. Hier gibt's noch etwas zum Lesen: https://developer.arm.com/documentation/ka001776/1-0/?lang=en https://www.st.com/resource/en/datasheet/stm32g030c6.pdf https://www.st.com/resource/en/application_note/cd00167594-stm32-microcontroller-system-memory-boot-mode-stmicroelectronics.pdf
-
Thread
Welche AVR (Atmega) haben UPDI?
/application_note/cd00167594-stm32-microcontroller-system-memory-boot-mode-stmicroelectronics.pdf
Beitrag #7224408: > Wir sind noch beim AVR ATMega4809 der ab Werk keinen Bootloader hat? > > Der STM32 und EFM8 scheint einen Bootloader ab Werk zu haben. > > Der ATMega4809 aber nicht. STM32 hat DFU, der megaavr-0/da/db/dd/tiny-1/tiny-2 haben UPDI. Was ist Deiner Meinung nach der prinzipielle
-
Thread
Einstiegshilfe in ARM-Controller
herumschlagen musst. Ansonsten wird der Einstieg ziemlich steinig. Da ich bisher nur Erfahrung mit der STM32 Familie habe, bezieht sich der folgende Erfahrungsbericht nur auf diese Mikrocontroller-Familie: ST liefert für die STM32 Familie eine umfangreiche Library mit. Es gibt einige Leute hier im Forum
gutes Paket! Raisonance mit Primer2 ist dann ein sehr guter Kandidat, wenn es wirklich in Richtung STM32 gehen soll. Gruss, Robert
-
Thread
CodeBlocks und STM32F3Discovery, Probleme beim Compilieren
C:\Programme\CodeBlocks\STM32F3-Discovery_FW_V1.1.0\Libraries\CMSIS\Lib\ ARM\arm_cortexM0l_math.lib C:\Programme\CodeBlocks\STM32F3-Discovery_FW_V1.1.0\Libraries\CMSIS\Lib\ ARM\arm_cortexM3b_math.lib C:\Programme\CodeBlocks\STM32F3-Discovery_FW_V1.1.0\Libraries\CMSIS\Lib\ ARM\arm_cortexM3l_math.lib C:\Programme\CodeBlocks\STM32F3-Discovery_FW_V1.1.0\Libraries\CMSIS\Lib\ ARM\arm_cortexM4b_math.lib
-
Thread
Live-Linux: Anleitung schreiben
lenovo x230i, 4 GB Ram, i3-3120. In einer Virtualbox läuft sogar Windows 2000 um darin Sprint-Layout 6.0 laufen zu lassen. Das ganze problemlos und relativ flott: Compilierung eines STM32F4 Programms, das ein 112kByte großes Binärfile erzeugt in unterhalb 4 Sekunden. ---------------------------------
Ralph S. schrieb im Beitrag #7835362: > Ein Beispiel für Textdisplays und STM32F030 findet man im Anhang. Furchtbar! Normale Menschen installieren sich die STM32 Cube IDE, oder die Arduino IDE und den STM32duino Core. Dann hat man auch eine Chance auf Hilfe von mehr Leuten
-
Thread
STM32 Core Arduino Framework
mir nicht https://github.com/stm32duino/STM32Examples Beispiele zum Offical Core. Ziemlich mager. https://github.com/GrumpyOldPizza/arduino-STM32L4 Nicht HAL-bassierter Core. Compiliert sehr schnell, effizient. Für das flashen
Wie kann man die STM32 Boards debuggen? Es geht wohl mit Eclipse, aber die Einrichtung scheint etwas aufwändig: https://github.com/stm32duino/wiki/wiki/How-to-debug https://www.youtube.com/watch?v=D-MbC9N5U7o
-
Thread
Problem mit RTC bei STM32F103
Ich versuche, an einem STM32F103 die RTC mit dem 32-kHz-Quarz in Betrieb zu nehmen. Ich habe mir aus Datenblatt sowie Beispielcode das hier als Initialisierung heraus gepuzzelt: [c] void init_RTC(void) { PWR->CR
Dafür hat der STM32F103 zwei andere Register mit denen man viel feiner abstimmen kann: http://stefanfrings.de/stm32/stm32f1.html#rtc_calibrate
-
Thread
automatischer Vorschub für Drehbank
Netzteil sind geordert und an der Maschine ist soweit alles vorbereitet. Als Board dachte ich an ein STM32F0-Discovery. Der F0 (auf dem Board ein STM32F051R8T6) ist mit 48 MHz flott genug, hat 64K Flash/8 KB RAM und hat auch die Encoder-Logik an Board, außerdem noch einen 32-Bit-Zähler. Und das sehr preiswerte
heutzutage muss ja alles mindestens 7 Zoll und Touch haben). Da gibt es doch sicherlich eine passende C-Bibliothek. Aber auch für STM32? Ansonsten muss ich wohl AVR-Code umstricken - wäre aber auch kein Drama. EDIT: bin gerade fündig geworden: https://stm32f4-discovery.net/2015/07/hal-library-15-hd44780
-
Thread
ATxMega o. ARM-Cortex-M3
in den STM32 in grenzen. Ich denke die größte Schwierigkeit ist ganz von 0 beginnend ein funktionierendes Eclipse hin zu bekommen, obwohl es jetzt schon einiges an Doku gibt. Die Errata sieht nicht so dramatisch
Demo-Boards reicht das auch mit Farnell. Ansonsten bei EBV nachfragen: http://www.ebv.com/index.php?L=0&no_cache=1&id=58&tx_ebvsearch_pi1[qs]=1&ct_ref=u6&tx_indexedsearch[sword]=STM32F20&tx_indexedsearch[results]=5&tx_indexedsearch[lang]=&search_est=fb0a30ba4490bd598331a4e31e5c1074 Die haben auf Lager
-
Thread
STM32 bootloader
Ich habe es mit einem CH341 und einem STM32F103C8(nicht BluePill) auf der Kommandozeile probiert. Auch an UART1, PA9, PA10 und Boot0=1. ./STM32_Programmer.sh -c port=/dev/ttyUSB0 -r 0x08000000 0x100 x.bin Fnktioniert zwar, aber es zeigt
ganz i.O. ist das auch nicht. Kannst ja mal einen Debug Level 3 probieren. Graphisch, oder: ./STM32_Programmer.sh -c port=/dev/ttyUSB0 -vb 3 -r 0x08000000 0x100 x.bin
-
Thread
Probleme mit I2C beim STM32F103C8T6
Init-Seq from ST ERRATA-Sheet +++ // ++++++++++++++++++++++++++++++++++++++++++ // +++ I2C +++ RCC->APB1ENR |= (uint32_t)(0x00200000); //I2C1 aktivieren //Set Up Register for AF (I2C) [0x0E] setGPIORegister(GPIOB,0x0E,6); //AlternateFunction, OpenDrain, LowSpeed [0x0E] setGPIORegister
hast um schnell auf einen grünen Zweig zu kommen. Für deinen Fall wäre das in der SPL die Dateien stm32f10x_i2c.c und stm32f10x_i2c.h Die bieten dir eine anständige Schnittstelle "nach unten" und du kannst den Code der da unten verwendet wird auch kopieren um eigenständig zu sein. Die
-
Thread
Suffix für uint8_t
schneller. Allerdings musst Du dann alle bisher implizit einkalkulierten Überläufe selber mit & 0xFF in Ordnung bringen, da auf dem STM32 ein uint_fast8t denselben Wertebereich wie ein uint32_t hat.
, das habe ich noch nicht > benutzt. uint_fast8_t benutzt immer den Typ, mit dem der konkrete µC am schnellsten rechnen kann. Auf dem STM32 ist es identisch mit uint32_t, auf einem ATmega oder ATtiny ist es identisch mit uint8_t. Das heisst konkret für den STM32: Er rechnet in 32-Bit sauschnell
-
Thread
STM32 F2/F4 - was ich vermisse - Wunschliste für ST
Ich schreibe mal auf was ich beim STM32 vermisse. Der STM32F2xx/F4xx sind jetzt schon sehr gut geworden, aber dennoch habe ich Wünsche... 1) UART5 lässt sich beim F4xx nur auf einen einzigen Port-Pin mappen, wenn man SDIO haben will,
?RootFolder=%2Fpublic%2FSTe2ecommunities%2Fmcu%2FLists%2Fcortex_mx_stm32%2FSTM32F4%2C%20wish%20list%20for%202012&FolderCTID=0x01200200770978C69A1141439FE559EB459D7580009C4E14902C3CDE46A77F0FFD06506F5B¤tviews=797 > UART5 lässt sich beim F4xx nur auf einen einzigen
-
Thread
Umstieg von ATmega2560 auf STM32F767 ?
/STM32F767-Development-Board-Cortex-M7-Small-System-Board-STM32F767IGT6-STM32-p-1420406.html ?
Mixed-Signal-Derivate aus der STM32F3-Serie an. Und ja, die Rechenleistung reicht. Wenns auf dem ATMEGA ruckelt, dann flutscht es auf dem Cortex-M4 mit 10MHz. Möglicherweise reicht dir auch ein F0? Das solltes du dir gut überlegen
-
Thread
STM32 F0 über UART senden zum PC
aber ebenso kommt auch nichts auf meinem PC an. Der Code sieht wie folgt aus: [c] #include "CMSIS\stm32f0xx.h" #include "STM32F0xx\stm32f0xx_hal_conf.h" #include "STM32F0xx\stm32f0xx_hal.h" #include "STM32F0xx\stm32f0xx_hal_tim.h" GPIO_InitTypeDef GPIO_struct; UART_HandleTypeDef
Signal da ist. Kommen denn mit HTerm die Signale an? Gruß Daniel PS: Ich sehe gerade: [c] #include "CMSIS\stm32f0xx.h" #include "STM32F0xx\stm32f0xx_hal_conf.h" #include "STM32F0xx\stm32f0xx_hal.h" #include "STM32F0xx\stm32f0xx_hal_tim.h" [/c] Es müsste doch auch eine [c] #include
-
Thread
c++ 11/14/17?
> aLed; int main(void) { while (1) { aLed.Set(); aLed.Clr(); } return 0; } [/C] der erzeugt Code sieht so aus: [C] int main(void) { 4803 ldr r0, =0x48000018 2120 movs r1, #32 F44F1200 mov.w r2, #0x200000 --- main.cpp -- 128 --------
// wird zu enum class AHB1_Clock : reg32_t { GPIOA = 1<<0, } // sollte ich vielleicht besser umbenennen, dann passen alle Namen // genau zum Datenblatt enum class RCC_AHB1ENR : reg32_t { GPIOAEN = 1<<0, } [/c]
-
Thread
STM32 ADC liefert falsche Werte
Hallo, ich bin jetzt schon seit Tagen dabei, den ADC meines STM32f103c8t6 zum Laufen zu bekommen. Allerdings zeigt sich dabei ein sehr eigenartiges Verhalten: Wenn ich 0V anlege, werden Werte zwischen 1949 und 1951 angezeigt. Zum Testen habe ich einfach nen 10k
Hallo, ich habe gestern genau eine solche Routine für einen STM32F103C8t& codiert für AIN0 (Baujahr 2015, Week 47)und sie läuft einwandfrei. Ohne das jetzt alles durchzulesen hier mein Code, der einwandfrei läuft. Wie ich sehe wurde einiges von dem STM32 Genius
-
Thread
Controller via USB an Computer: Wie am besten?
Alex G. schrieb im Beitrag #5730611: > Willst du wirklich direkt mit den uC an USB? > Das ist eine haarige Sache. Für jemanden der mit C grad anfängt nicht > wirklich optimal. Definitiv. Es reicht ja ein Blick in das [[USB-Tutorial_mit_STM32]], um abzuschätzen wieviel
Verwendung veröffentlicht. Ich habe daraus ein Projekt für das Blue-Pill Board (ist ein gängiger STM32 mit Cortex M3) gemacht, dass ich gerne als Basis für weitere Entwicklungen verwende: http://stefanfrings.de/stm32/index.html#vcpnohal > Es heißt immer C und PHP wären ähnlich, Nee, ganz sicher
-
Thread
ARM M4 (stm32): free running timer statt systick interrupt
das genaue Problem? Wenn ich z.B. einen 8MHz Quarz nutze, > dann geht der laut Datenblatt meines µC (STM32) /8 zum Systick, also > 1MHz. Bist du da sicher? Bei all meinen STM32 wird der SysTick vom Platform-Takt abgeleitet, also z.B. 72 MHz und das kann man in SYST_CSR einstellen. W.S.
jede ms ein Inkrement. Siehe auch Beitrag über mir. Im STM32 Universum überschreibe ich dann die Funktion [c]uint32_t GetTick() { return __HAL_TIM_GET_COUNTER(&htim2); } [/c] und fertig. Nochmal die Vorteile: -> kein Interrupt -> Zeitbasis
-
Thread
"Arduino kompatibler" MC für 2025
Headerfiles beider Controller. Wahllos verglichen, paar Bsp. [code] P: #define SPCR _SFR_IO8(0x2C) PB: #define SPCR0 _SFR_IO8(0x2C) P: #define PRR _SFR_MEM8(0x64) PB: #define PRR0 _SFR_MEM8(0x64) P: #define TWCR _SFR_MEM8(0xBC) PB: #define TWCR0 _SFR_MEM8(0xBC) P: #define
USART0_UDRE_vect_num #define USART_TX_vect USART0_TX_vect #define USART_TX_vect_num USART0_TX_vect_num #endif // 328PB defs [/c]
-
Thread
Auslesen Reset Source STM32
manually after use RCC_ClearFlag(); Allerdings bekommen ich Fehler beim Übersetzten: D:\work\stm32\03_SolarController\Debug/../Src/main.c:128: undefined reference to `RCC_GetFlagStatus' D:\work\stm32\03_SolarController\Debug/../Src/main.c:145: undefined reference to `RCC_ClearFlag' D:\work\stm32
herunterladen) die entsprechende Source und Header-Datei. Und binde sie in dein Projekt ein. Also stm32f4xx_rcc.h und stm32f4xx_rcc.c
-
Thread
Auswahl Cortex M3 Start-kit, Board
Hallo, Neuling! Richtig, bei den STM32F103ern ist USB nicht mit CAN gleichzeitig zu betreiben, beim 105er und 107er aber - das ist die "Connectivity Line" - geht das sehr gut. Ich verwende das STM3210C, wo ein 107VCT6 aufgelötet ist. Es
Als Anregung oder Alternative: Versuche nicht gleich von 0 auf 100 zu springen. Die Geschmäcker sind verschieden und eine µC Familie die der eine ganz toll findet, kann für den nächsten schon schlecht sein. Beispiel Datenblatt: Mit der Doku vom STM32 komme
-
Thread
Welches stm32 Entwicklungsboard?
Ich würde an der Stelle einfach mal den STM32F103 (z.B. STM32F103C8T6) in den Raum werfen, bei Reichelt günstig zu haben, leistungsstark genug für die allermeisten Projekte, via China gibt es Boards für wenige Euro, die sich mit einem ST-Link
Sachen, und ich kann dann wie gewohnt mit KEIL µVision fortfahren? https://de.aliexpress.com/item/STM32F103C8T6-ARM-STM32-Minimum-System-Development-Board-Module-For-Arduino/32246273606.html?spm=2114.13010308.0.0.jPKCJ7 https://de.aliexpress.com/item/ST-Link-V2-stlink-mini-STM8STM32-STLINK-simulator-download-programming-With-Cover
-
Thread
mbed - oder es muss nicht immer Arduino sein
/users/hudakz/code/STM32F103C8T6_USBSerial/ Wenn ich den Online-Compiler benutze kriege ich am Ende ein Binarie von ca 34k. Da kann man aber mit Keil in der freien Version schon nicht mehr debuggen. Exportiere ich das
fett. Allerdings ist das auch kein Wunder. Unter dem (in meinen Augen recht gut geschriebenen) mbed-C++ Code liegt nochmal die ganze STM32-HAL. Allein die nötigen Header belegen 6MB in 248 Dateien. Arduino ist da auch nicht viel sparsamer, aber diese Entwicklung mache ich persönlich nicht mehr mit. Für
-
Thread
Compilierung des EU1KY AA unter Linux.
ja mal rein schauen, ob Dir was an den includes auffällt. >find ./rtc -name \*.h -or -name \*.c -exec grep -H include {} \; ./rtc/STM32F7RTC.c:#include <stdint.h> ./rtc/STM32F7RTC.c:#include <stdio.h> ./rtc/STM32F7RTC.c:#include <string.h> ./rtc/STM32F7RTC.c:#include <ctype.h> ./rtc/STM32F7RTC.c:#include <stdlib.h> ./rtc/STM32F7RTC.c:#include "stm32f7xx_hal_rtc.h" ./rtc/STM32F7RTC.c:#include "stm32f7xx_hal_rtc_ex.h" ./rtc/STM32F7RTC.c:#include "STM32F7RTC.h" ./rtc/emrtc.c:#include "RTC.h" ./rtc/emrtc.c:#include "GPIO.h