-
Thread
Calibration ADC STM32F334
jeder Farbe. Wenn ich Platinen selber ätzen oder fräsen wollte, würde ich eher zwei uC im LQFP-32 als einen im LQFP-48 einbauen.
Hier hast du Beispielcode für den F303: http://stefanfrings.de/stm32/stm32f3.html#analog Da sind Hinweise aus dem Errata und einer Application Note eingeflossen (welche habe ich vergessen). Ich schätze dass es bei deinem ebenso geht.
-
Thread
Stack im STM32
leichter durch die Benennung der Umgebung zu beschreiben. Auszug aus dem Mapping file für einen STM32L476 [c] Component: ARM Compiler 5.06 update 6 (build 750) Tool: armlink [4d35ed] ... 0x200004ac - 0x00000060 Zero RW 3014 .bss c_w.l(libspace.o) 0x2000050c 0x080047b0 0x00000004 PAD 0x20000510 - 0x00000200 Zero RW 131 HEAP startup_stm32l476xx.o 0x20000710 - 0x00000400 Zero
-
Thread
STM32 Breakout Board
freundliche Chinese von nebenan hatte auch schon so eine Idee: http://www.ebay.de/itm/ARM-Cortex-M3-STM32F103C8T6-STM32-Kern-Board-Minimum-System-Entwickeln-Board-MN-/251544868893?pt=Wissenschaftliche_Ger%C3%A4te&hash=item3a913e181d
jedoch habe ich dazu noch 3 Anmerkungen, die Du unbedingt berücksichtigen solltest: 1. Tauglich für STM32F4xx machen: Schaue mal in das Datasheet vom STM32F407, dort gibt es "Figure 1. Compatible board design between STM32F10xx/STM32F4xx for LQFP64" Mache diese beiden 0-Ohm Widerstände mit rein und
-
Thread
STM32 USB HID Keyboard
daß ich auf die Mithilfe jemandes hoffte, der soetwas schon einmal gemacht hat. Ich nutze die STM32_USB-FS-Device_Lib_V4.0.0 auf einem STM32F103C8T6, der auch schon korrekt als HID-Keyboard erkannt wird, und der Tastendrücke korrekt an den PC schickt. Wenn der PC die Tastatur-Status-LEDs
Hallo, ich möchte das selbe tun wie Walter... ich will mit dem STM32f103c8T6 Minimal Board Tastaturdrucke statt einer echten Tastatur an den PC schicken. Habe das Beispiel Custom_HID compiliert und auf das Stm32 system gespielt. es wird auch richtig als STM32
-
Thread
[Sammelbestellung] µC-Board + RAM
Torsten C. schrieb im Beitrag #3595903: > Wieviel RAM und welcher CPU-Core soll's sein? CPU STM32 mit FMSC Memory Controller z.B.: STM32F103
Joe G. schrieb im Beitrag #3598496: > Torsten C. schrieb: >> Wieviel RAM und welcher CPU-Core soll's sein? > CPU STM32 mit FMSC Memory Controller z.B.: STM32F103 Und dann mit 4MiB PSRAM? Das wäre dann die Variante mit dem kleinsten und teuersten
-
Thread
MOSI-Pegel viel zu niedrig, aber warum?
, A, 8); GPIO__OUTPUT(LSM330DLC_GYRO_CS, C, 9); static bool initClock() { xpcc::stm32::Clock::enablePll(xpcc::stm32::Clock::PLL_HSI, 8, 168); return xpcc::stm32::Clock::switchToPll(); } MAIN_FUNCTION { initClock();
::setOutput(true); LSM330DLC_GYRO_CS::setOutput(true); typedef xpcc::stm32::SpiMaster3 MySpi3; MySpi3::initialize(MySpi3::MODE_0, MySpi3::PRESCALER_256); MySpi3::configurePins(MySpi3::REMAP_PC10_PC11_PC12); while (1) { } return 0; } [/c]
-
Thread
HILFE! SPI macht mich fertig!
Signal haben. Damit sind auch alle Verbindungen gescheit verbunden. Auf den beiden Eval Boards vom STM32 um AT90CAN werden die SPI Leitungen einfach nur nach draußen geführt, ohne irgendwelche PullUps oder Kapazitäten oder sonstiges. Bis auf die uC auf den jeweiligen Boards gibt es also im Aufbau keinen
schrieb im Beitrag #5912387: > man kann nicht sehen, was du wirklich machst. In F0004TEK.jpg > wird 0x0004 0x07C2 gesendet. Also ein RDCVA. Hast du vorher eine > Wandlung gemacht? Genau. 0x0004 ist der Befehl 0x07C2 ist der entsprechende PEC. Darth Moan schrieb im Beitrag #5912387: > Wenn keine
-
Thread
Pico2 RP2350 GPIO Fehler
beieinander. Falls jemand das auch mal mit Micropython testen will: [code] from machine import ADC, mem32, Pin from time import sleep_ms PADS_BANK0_BASE = 0x40038000 # PADS_BANK0_BASE GPIO_REG = PADS_BANK0_BASE + 0x70 # GPIO27 adc = ADC(Pin(27)) print(bin(mem32[GPIO_REG])) mem32[GPIO_REG]=0b0001010000
nachträgliches Luxus-Feature mit 39k Längswiderstand zum Eingang. Witzigerweise hat das mit einem STM32L031 dann doch nicht funktioniert... Stefan K. schrieb im Beitrag #7731982: > Bei schnellen und damit steilen Signalen sind die sehr kurzen maximal > etwa 0,1mA gegenüber den Strömen zum Umladen
-
Thread
UART bei Stm32 mit internem RC
die Frage nun auch wieder nicht vor. Da ich gerade vor demselben Problem stand (ich verwende einen STM32 ohne OSC_OUT!) hier eine Stelle aus dem STM32G0x0-Datenblatt.
Nicht jeder STM32-Chip hat einen Quarzoszillator.
-
Thread
Was heißt __IO beim GCC
Hinweis. Muss zugeben, die CMSIS Dokumentation bis dato nur überflogen zu haben. Bin im Quellcode der STM32 StdPerLib an einigen wenigen Stellen (z.B. in system_stm32f10x.c, stm32f10x_flash.c V3.1.0) über die Verwendung von __IO gestolpert, wo keine Register der Hardware angesprochen werden aber der __IO
damit eine Delay-Schleife > zu bauen. "Pessimierung" trifft wahrscheinlich auf sowas zu (auch STM32F StdPerLib): [c] __IO uint32_t StartUpCounter = 0, HSEStatus = 0; ... do { HSEStatus = RCC->CR & RCC_CR_HSERDY; StartUpCounter++; } while((HSEStatus == 0) && (StartUpCounter != HSEStartUp_TimeOut
-
Thread
STM32F103 GPIO
LD). Ist so im Endeffekt sogar einfacher. Achja, von wegen Einfachheit: Programmiere mal diese C-Funktion in AVR-Assembler: [c]uint32_t shift (uint32_t x, uint32_t y) { return x << y; }[/c] Im ARMv7M-Assembler sieht's so aus: [avrasm]shift: lsl r0, r1 bx lr[/avrasm] Na, ists auf
definieren, die genauso wie beim AVR funktionieren: [avrasm].syntax unified .equ GPIOD_MODER, 0x40020C00 .equ GPIOD_BSRR, 0x40020C18 .equ GPIOD_ODR, 0x40020C14 .macro sbi REG:req, bit:req push {r0, r1} ldr r0, =(0x42000000 + ((\REG-0x40000000) * 32) + (\bit * 4)) mov r1, 1
-
Thread
Cortex M3 Development - Was brauche ich noch alles?
eine Toolchain fertig downzuloaden: https://launchpad.net/gcc-arm-embedded Schau im Wiki unter [[STM32#GCC]] und [[STM32#Programmierung]], das ist zwar für die STM32 Controller aber das Software-Setup ist das selbe, da auch Cortex-M3/4F.
Ende sei noch erwaehnt, dass ich inzwischen von den LPC's ein wenig abgekommen bin und mehr mit den STM32's mache. Spezielle Gruende dafuer sind das es mir leichter faellt die STM RM's zu lesen und zu verstehen als die von NXP und das es mehr allgemeine Informationen zu den STM32's im Netz gibt als zu
-
Thread
ISR wie normale Funktion aufrufen
Guten Tag, ist es möglich, auf einem STM32 eine ISR einfach wie eine normale void-voi-Funktion aufrufen, also: [c] extern int32_t g; void foo(void) { do { TIM6_DAC_IRQHandler(); } while( g == 0 ); } [/c] oder
Funktionus Interuptus schrieb im Beitrag #5212820: > ist es möglich, auf einem STM32 eine ISR einfach wie eine normale > void-voi-Funktion aufrufen, also: > extern int32_t g; > > void foo(void) > { > do > { > TIM6_DAC_IRQHandler(); > } while( g == 0 )
-
Thread
Arduino-Gadgeteer, 64bit-MPU von Microchip und vieles andere mehr
Frank O. schrieb im Beitrag #7701096: > Da muss jetzt ein ST32F4 mit auf so einem Bord, Das ist wohl ein "STM32C011F4" drauf, also eine Cortex M0+ und kein STM32F4. Kostet bei mittlerer Menge so um die 0,43 €/Stück. Dafür baust du keine diskrete Schaltung die I2C kompatibel ist. - https://www.st.com/en/microcontrollers-microprocessors/stm32c011f4.html - https://www.mouser.de/ProductDetail/STMicroelectronics/STM32C011F4U6TR?qs=IPgv5n7u5Qao9K%252BX0pScKA%3D
-
Thread
STM32 DMA TO GPIO HILFE
Geht das bei den STM32 mit Cortex M0 Kernen überhaupt? Denn beim M0 hängen die GPIO an einem speziellen Port des Kerns. Der Rest des Speichers ist über einen anderen Port angesclossen und somit auch der DMA Controller
deswegen serielle tfts: https://www.mikrocontroller.net/topic/361700?goto=4061425#4061425 Bildaufbau 0,11sec schneller muss bei mir nicht. > gibt es das Bluepill Board mit mehr IOS. https://www.ebay.de/itm/Core407V-STM32F407VET6-STM32-Cortex-M4-Development-Board-Motherboard-Module-Kit/322268845458
-
Thread
Codebeispiel für LCD an STM32 mit HAL gesucht.
Hi Sören, im jeweiligen STM32-Package: STM32Cube_FW_F4_V1.12.0, STM32Cube_FW_L4_V1.4.0 \STM32Cube_FW_F4_V1.12.0\Projects\STM32xxxxx-Discovery\Examples\LCD_DSI\ z.B. Grüße Runout
Thomas T. schrieb im Beitrag #4633576: > im jeweiligen STM32-Package: > STM32Cube_FW_F4_V1.12.0, STM32Cube_FW_L4_V1.4.0 > > \STM32Cube_FW_F4_V1.12.0\Projects\STM32xxxxx-Discovery\Examples\LCD_DSI\ Das sieht total gut aus! Leider habe ich keinen Plan
-
Thread
CH32V003-J4M6: Einfacher Rechteckgenerator 0,5 Hz 20 kHz
+fBXcGxLkipBoksy9q0jG1wkPb19-CA7YLtyMcbmBx42y-we4yBscIXi+Z1O5xY70eKjgeWwQh0DSaZy8wOUVD+nEIGleAOangRXCo0MhGjBVAxcKxaXxTxRaK+ZR25Mm5Lqx1h51aVwWt26ozpmTpMz0YIUQWgS3C5PUSNR6S2cFyDPq5NeigA5pT0uSEJkcmTJYTVeKymTuMjesjFGkTQkqqbZap1No8Li7Wb7Y6CQ6
USB trennen muß um etwas hochzuladen ... im Moment ist meine Wahl für "kompliziertere" Sachen ein STM32F4 oder, wenn es noch "schlimmer" wird (erst ein einziges mal geschehen) STM32H743VGT6
-
Thread
uC mit USB gesucht
soweit für alle USB-fähigen Controller gleich. USB-fähige Controller gibt es viele, z.B. die meisten STM32. In meinem [[USB-Tutorial mit STM32]] wird die USB-Programmierung bei den STM32F103-Controllern erläutert. Im Abschnitt https://www.mikrocontroller.net/articles/USB-Tutorial_mit_STM32#Eigene_Anwendung_f.C3
mit). Je nach Anforderung würde ich daher zu einem Controller mit der "USB"-Peripherie raten, wie STM32F103, und nicht den von "jemand" genannten STM32F407, welcher gleich 2 "OTG"-Module hat.
-
Thread
Mikrocontroller und PHP
linux-vdso.so.1 (0x00007ffea6b6c000) libdl.so.2 libm.so.6 libpthread.so.0 libc.so.6 libcrypt.so.1 /lib64/ld-linux-x86-64.so.2 (0x00007f4f667ed000) /usr/bin/ruby2.5
einem Mikrocontroller gesehen? Ich meine nicht einen in der Größenordnung vom Raspberry Pi oder ESP32, sondern etwas in Richtung ATmega328 oder meinetwegen auch einen Boliden wie den STM32F4.
-
Thread
STM32: Bitbanding für Arrays?
ist es so was was du meinst? [C] #define BitBandMemAddr(addr, bitnum) ((volatile uint32_t*)(0x22000000 + (((uint32_t)(addr) & 0xFFFFF) << 5) + ((bitnum) << 2))) volatile uint8_t bitarray[10]; int main(void) { volatile
Platz? Diese F407 Board hier könnte noch auf Deine Platine passen: http://www.ebay.de/itm/STM32F407VET6-ARM-Mini-Version-Core-Board-Cortex-M4-STM32-Minimum-System-Board-/122444767496?hash=item1c8246e108
-
Thread
STLink Programmersoftware nur wie ?
-c port=SWD -w ob1.bin 0x4002201c ./STM32_Programmer.sh -c port=SWD -w ob2.bin 0x1ffff800
zu erhalten, von einem korrekt programmierten Chip diese auslesen. Schutz bei Bedarf anpassen. ./STM32_Programmer.sh -c port=SWD -r 0x4002201c 0x8 ob1.bin ./STM32_Programmer.sh -c port=SWD -r 0x1ffff800 0x10 ob2.bin ist für F103. Für andere anpassen!
-
Thread
STLink + OpenOCD + Eclipse
speed 1000 kHz, using 950 kHz Info : clock speed 950 kHz Info : STLINK v2 JTAG v28 API v2 SWIM v0 VID 0x0483 PID 0x3748 Info : using stlink api v2 Info : Target voltage: 2.903986 Info : stm32f0x.cpu: hardware has 4 breakpoints, 2 watchpoints Info : accepting 'gdb' connection on tcp/3333 Info
Ok, vielen Dank. Ich habe bei mir "new" bei "GDB OpenOCD Debugging" gemacht. "AC6 STM32 Debugging" steht bei mir nicht. Muss ich da in Eclipse noch was nachinstallieren? Bei mir im Debugger Reiter hab ich unter Config Option nur das config file angegeben. -f board/stm32f0discovery.cfg
-
Thread
stm32f103 mit usb-stick
danke für die schnelle Antwort. Hat er den wirklich nicht? STM32F102/103 Cortex - M3 1x USB 2.0 FS device controller
STM32F102/103 Cortex - M3 1x USB 2.0 FS *device* controller Steht dort *device* oder *host*?
-
Thread
Spannungsteiler an ADC von STM32F4?
voltage "The voltage on VREF ranges from 1.8 V to VDDA" ------------------------------- Quelle: STM32F446xC/E Datasheet https://www.st.com/resource/en/datasheet/stm32f446mc.pdf Kapitel 6.2 Absolute maximum ratings (...) VDDx Variations between different VDD power pins: 50 mV max.
Magnus M. schrieb im Beitrag #7505519: > Quelle: STM32F446xC/E Datasheet > https://www.st.com/resource/en/datasheet/stm32f446mc.pdf Und, oh Wunder oh Wunder, genau in dem Dokument findet sich "Equation 1", die die Ausgangsfrage beantwortet! LG,
-
Thread
infinite loop, externer Interrupt, STM32F746, HAL-Library
all diese HAL-Funktionen/Dokumentation (geht > das überhaupt ohne CubeMx?) z.B. auf github im STM32CubeF7 Repo sind Beispiele und Doku. Wie schon genannt, fehlt vermutlich die eigentliche ISR und der Interrupt landet im Defaulthandler. https://github.com/STMicroelectronics/STM32CubeF7/blob/e96f98542c6782d97bdd0c50833ee4b70130f3a7/Projects/STM32F746ZG-Nucleo/Examples/GPIO/GPIO_EXTI/Src/stm32f7xx_it.c#L155-L158
-
Thread
STM32Fxxx Warum keine zwei Alternative Function Register?
) #define RCC_APB1Periph_USART3 ((uint32_t)0x00040000) #define RCC_APB1Periph_UART4 ((uint32_t)0x00080000) #define RCC_APB1Periph_UART5 ((uint32_t)0x00100000) #define RCC_APB1Periph_I2C1 ((uint32_t)0x00200000) #define RCC_APB1Periph_I2C2 ((uint32_t)0x00400000) #define RCC_APB1Periph_USB ((uint32_t)0x00800000) #define RCC_APB1Periph_CAN1 ((uint32_t)0x02000000) #define RCC_APB1Periph_CAN2
-
Thread
UART Clock Initialisierungsproblem auf STM32F407G-DISC1 (Discovery)
stm32l053c8 stm32l073rz stm32l152 stm32l152rb stm32l476 stm32wb55 > Auf was löst denn das Macro "RCC_CR" auf? Sprich: Welche Adresse steht Kein Macro, sondern ein .EQU: stm32F407/terminal.s
da > tatsächlich? Auch hier kann's mal Unterschiede zw. CPUs der selben > Familie geben. > stm32F407/terminal.s: .equ HSERDY , BIT17 stm32F407/terminal.s: .equ HSEON , BIT16 stm32F407/terminal.s: mov r0, HSEON stm32F407/terminal.s: ands r0, #HSERDY
-
Thread
Günstige CAN-Filter Lösung
sowas zu gebrauchen... Frage: Gibt es eine günstige Alternative dazu? Sicher wäre es besser einen uC mit integriertem CAN-Controller zu haben, wie den AT90CAN oder den STM32. Die haben aber alle "nur" einen CAN drauf und wenn bräuchte ich wohl zwei? Wer hat schonmal solch einen Filter/Gateway gebaut
Du hast Recht, nicht alle STM32 haben 2 * CAN. Du kannst auf der ST-Seite nachschauen, welches Derivat wieviele Schnittstellen hat. STM32F1xx: ein paar ... STM32F2xx: alle ... STM32F4xx: fast alle ... haben 2 CAN-Schnittstellen
-
Thread
65C21 Peripherie Baustein am STM32
Kann man den Peripheriebaustein 65C21 am STM32 betreiben mittels Businterface? http://www.westerndesigncenter.com/wdc/w65c21-chip.cfm Bzw. den HD63B40 (gleiches Businterface). R/W, Takt, /CS, Register select (Adressbus) http://docs-europe.electrocomponents.com
komplette Einarbeitung in den Controller. 2 Controller zu programmieren ist eigentlich schon genug (AVR, STM32).
-
Thread
RISC/V kommt in Schwung
Lohnt es sich STM32 noch zu lernen?
olaf schrieb im Beitrag #7320101: > Gut vergleichen kann man das Teil > vermutlich mit einem STM32F030F4P6TR. Allerdings ist der CH32V003 offenbar als pinkompatibler Ersatz für den STM8S003 gedacht.
-
Thread
SD card über sdio interface mit STM32 HAL
https://github.com/ARMmbed/mbed-os/blob/d311a96061ff3526bc805e20eb35774885ace1ec/targets/TARGET_STM/TARGET_STM32F4/device/stm32f4xx_hal_sd.c#L688 noch einen Leidensgenossen gefunden: https://community.st.com/s/question/0D50X00009fEfUeSAK/about-sdio-and-hal-read-write-functions
ein Kommando 51 aus. https://github.com/ARMmbed/mbed-os/blob/a5b757312d875521a06de42d898d5d00a86b1a0e/targets/TARGET_STM/TARGET_STM32F4/device/stm32f4xx_hal_sd.c#L2789 Wenn ich wie hier vorgeschlagen https://blog.frankvh.com/2011/09/04/stm32f2xx-sdio-sd-card-interface/ das Find_SCR() einfach weglasse
-
Thread
DMA + UART parallel empfangen
3Byte Variablenwert). Die Auswertung geschieht im HAL_UART_RxCpltCallback() und sieht so aus: [c] SMP_StatusTypeDef MMP_STM32_Client_read(SMP_HandleTypeDef* SMP){ character_id = SMP->rx_buffer[0]; uint8_t data[3] = {SMP->rx_buffer[1],SMP->rx_buffer[2],SMP->rx_buffer[3]}; /* decode data
Aus den STM32 F0 Ref : Universal synchronous asynchronous receiver transmitter (USART) RM0360 606/779 DocID025023 Rev 4 Overrun error An overrun error occurs when a character is received when RXNE has not
-
Thread
STM32F3 FPU Aktivieren/Benutzen in STM32CubeIDE
(3UL << 11*2) ); /* set CP11 Full Access */ #endif [/c] Habe bei mir einen Breakpoint gesetzt, und siehe da, die Bits werden bei mir gesetzt. Mir gefällt deine Webseite bezüglich STM32, Stefan. :) Gruß,
.h zu finden? [c] typedef struct { ... __IOM uint32_t CPACR; /*!< Offset: 0x088 (R/W) Coprocessor Access Control Register */ } SCB_Type; [/c] Und dann weiter unten: [c] #define SCB
-
Thread
Image-Grabber für CVBS (bzw. FBAS) per STM32F103C8T6
Hardware. https://www.st.com/resource/en/application_note/dm00356635-hardware-jpeg-codec-peripheral-in-stm32f7677xxx-and-stm32h743534555475750a3b3b0xx-microcontrollers-stmicroelectronics.pdf > Auf die Schnelle habe ich nur einen kaufbaren H7 gefunden und das zum > Preis von über 20 Euro. Einen fertigen
Hardware. > https://www.st.com/resource/en/application_note/dm00356635-hardware-jpeg-codec-peripheral-in-stm32f7677xxx-and-stm32h743534555475750a3b3b0xx-microcontrollers-stmicroelectronics.pdf > Danke, werde ich mir ansehen.
-
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
da automatisch eingesetzt wurde. Aber das sind ja Routinen, die man überschreibt. Jetzt sehe ich in stm32f1xx_it.c : [pre] void TIM1_UP_IRQHandler(void) { /* USER CODE BEGIN TIM1_UP_IRQn 0 */ /* USER CODE END TIM1_UP_IRQn 0 */ HAL_TIM_IRQHandler(&htim1); /* USER CODE BEGIN TIM1_UP_IRQn
-
Thread
CAN auf STM32F4
Hallo, ich möchte die CAN-Schnittstelle an meinem STM32F4Discovery nutzen. Die Hardware sollte soweit passen... Ich habe an einem STM32F4Discovery PD0/PD1 einen MCP2662 angeschlossen. Wenn ich ein funktionierenden Sensor an den Bus (H/L) anstecke, sehe
Beitrag #6139773: > Das sind immer nur welche mit älteren HAL-Ständen. Ich habe gerade nur das STM32CubeF1 installiert, und da gibt es: ~/STM32Cube/Repository/STM32Cube_FW_F1_V1.7.0/Projects/STM3210E_EVAL/Examples/CAN/ Beim STM32CubeF4 müsste es etwas ähnliches geben. Das sollte doch zur gleichzeitig
-
Thread
Alternativen zu C, C++ auf ARM cortex M?
abhängig. Bei IAR dürfte das gehen - und dann sind wir sogar noch etwas übersichtlicher als Pascal. [c]uint32_t NVIC_ISPR @0xE000E200;[/c]
retq 0000000000000028 <thread2>: 28: 48 83 ec 08 sub $0x8,%rsp 2c: 8b 3d 00 00 00 00 mov 0x0(%rip),%edi # 32 <thread2+0xa> 32: e8 00 00 00 00 callq 37 <thread2+0xf> 37: 8b 3d 00 00 00 00 mov 0x0(%rip),%edi
-
Thread
Microcontroller verstehen / A/D Wandler
Ich habe jetzt eine Menge nachzulesen. Und falls dir die Lesestoff ausgeht, die Hersteller der µC schreiben da auch noch einiges dazu:-) z.B.: - https://www.st.com/content/ccc/resource/training/technical/product_training/group0/0b/e4/af/01/4a/92/44/dc/STM32F7_Analog_ADC/files/STM32F7_Analog_ADC.pdf
/rm0385-stm32f75xxx-and-stm32f74xxx-advanced-armbased-32bit-mcus-stmicroelectronics.pdf
-
Thread
STM32 ADC Verhalten eigentümlich
Die Linearität ist gut, wenn man unten etwas auslässt. Der erste ATxmega war bis jetzt sehr grausam. STM32 geht gerade so. Mit dem Analog Device ADuC7026 habe ich die besten Erfahrungen gemacht. Das sieht für mich auch eher alles nach einem 10+ Bit Wandler aus. Ich vermute da steckt nur Marketing dahinter
Hi Norbert, von STM gibt es eine PDF wo das "Phänomen" externer Kondensator an einem AIN-Pin vom STM32 beschrieben wird https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/Attachments/22412/2012_STM32%
-
Thread
STM32L4 I2C slave interrupt transmit
nutzen. In den Beispielen ist eine Kommunikation von 2 Boards als Master und Slave vorhanden. STM32Cube_FW_L4_V1.12.0/Projects/NUCLEO-L476RG/Examples/I2C/I2C_TwoBoards_ComIT/
#5553189: > Wo finde ich diese Beispiele? Steht doch da: chrstm schrieb im Beitrag #5553189: >> STM32Cube_FW_L4_V1.12.0/Projects/NUCLEO-L476RG/Examples/I2C/I2C_TwoBoard Such nach dem Ordner STM32Cube_FW_L4_V1.12.0 auf deiner HD. Im Normalfall sollte der im workspace liegen.
-
Thread
Drehzahlmesser in Assembler (ATmega328)
Drehzahlmessung in eine existierende Maschinensteuerung einbauen. Einmal auf einem NXP11, parallel auf einem STM32H Prozessor. Das habe ich mit C++ erledigt. Das gesamte Framework ist schon C++. Dieses stellt mir auch einen Microsekunden-Timer zur Verfügung, weil ich den auch für andere Zeitmessungen brauche.
Peter schrieb im Beitrag #7636145: > Einmal auf einem NXP11, parallel auf einem STM32H Prozessor. Das habe > ich mit C++ erledigt. Das gesamte Framework ist schon C++. > Es geht also auch in einer Hochsprache Selbstverständlich Peter. Auf diesem Hardware-Level geht es eigentlich
-
Thread
STM32 I2C Bus bleibt hängen
Hi, ich möchte mit dem STM32 Cortex M3 einen I2C Sensor auslesen. Allerdings scheitere ich schon an der Konfiguration der Schnittstelle. Ich nutze folgenden Code: [code] I2C_InitTypeDef I2C_InitStructure; I2C_DeInit(I2C1
davon im Fehlerfall leuchtet. > Ich meine mich zu erinnern, dass beim Initialisieren > vom I2C-Modul die Pins kurz auf GND gehen. Nicht, wenn man die Initialisierung in der richtigen Reihenfolge vornimmt. Hier mal ein korrektes Beispiel ohne HAL: http://stefanfrings.de/stm32/stm32f1.html#i2c
-
Thread
port IRMP to Arduino
ich ja damals für IRMP unbewusst den richtigen Timer gewählt. > Das dortige Beispiel nutzt Timer0. > Das ist eine schlechte Idee, da dieser schon für Millis, Delay und seine > Brüder genutzt wird. > Das kracht! Aha. Also doch Glücksspiel. Und wie ist das bei STM32 oder ESP8266 oder ESP32
darf.... Ich schrieb ja oben: Wenn man die Interna der Arduino-Laufzeitumgebung kennt (AVR: Timer0, STM32: TimerX, ESP8266: TimerY, ESP32: TimerZ nicht anfassen), dann bekommt man das vielleicht portabel hin. Aber ich dachte, dass Arduino gerade so ausgelegt ist, dass man eben nichts über die Interna
-
Thread
Schnellere MCU als der ESP8266 zu einem guten Preis?
Ich hab nirgends was von Speicher geschrieben Hans schrieb im Beitrag #5767691: > Sorry, das STM32f429 Discovery Board kostet so ca 30.- das ist doch > nicht zu teuer! Wenn man die ganzen Features braucht: bestimmt nicht. Ansonsten schon. Richard B. schrieb im Beitrag #5767663: > Der ESP32
trotz dual core. > > Hast du eine Quelle für diese Behauptung? aus neugier gegoogled: ein 32F7 At 216 MHz fCPU, the STM32F745 delivers 1082 CoreMark / 462 DMIPS macht : 2,138 DMIPS/Mhz ein 32H7 At 400 MHz fCPU, the STM32H743/753 lines deliver 2020 CoreMark /856 DMIPS macht : 2,14 DMIPS
-
Thread
CCMRAM richtig einsetzen
Guten Abend, ich spiele mit einem STM32F334. Mir ist aufgefallen das dieser µC einen CCMRAM hat. Leider verstehe ich nicht was ich Sinnhaftes damit machen kann. Kann mir bitte jemand kurz erklären welchen Zweck dieses Ram erfühlt? Danke
mal eines für den F429ZI an, um zu zeigen wies gemacht wird. Im Code kannst dann sowas schreiben: [c] char CCRAM buf[32]; uint32_t CCRAM maxA, maxB ; [/c]
-
Thread
STM32, Cortex-M3 Power
Hallo, ich beschäftige mich seit ein paar Wochen mit den Cortex-M3 Controllern STM32F10x. Sind eine echte Alternative zu Atmel-ARM und NXP-ARM meiner Meinung nach. Max. 72 MHz Takt, 128k Flash, 20 k RAM, viel Peripherie (2 x SPI, 3 x UART, 2 x I2C, USB, CAN) alles DMA-fähig. Vor
/ET-STM32_Stamp.shtml Bei weitem genug zum spielen und günstig. Viele Grüße
-
Thread
Zusicherung der initialisierung von globalen Variablen in C und C++
... CopyDataInit: ldr r3, =_sidata ldr r3, [r3, r1] ... FillZerobss: movs r3, #0 str r3, [r2], #4 ... [/avrasm] Wenn W.S. eine kaputte Implementierung kennt, könnte er die hier gern mal benennen.... [1] ~/.ac6/SW4STM32/firmwares/STM32Cube_FW_F4_V1.13.1/Drivers/CMSIS/Device/ST/STM32F4xx/Source/Templates/gcc/startup_stm32f446xx.s
-
Thread
STM32 FFT arn_math.h sqrt unbekannt?!
zumindest compilieren, allerdings hängt er sich bei der ausgeklammert Zeile auf, wie kann das sein? [c] arm_cfft_radix4_init_f32(&fft_S, FFT_SIZE, 0, 1); //arm_cfft_radix4_f32(&fft_S, Input); arm_cmplx_mag_f32(Input, Output, FFT_SIZE); arm_max_f32(Output, FFT_SIZE, &maxValue, &maxIndex); [/c]
aber nicht. Kann eine alte sein, hier mal die neue. Ich habe mal in die entsprechende xxx_can.c reingeguckt, dort ist die .h gar nicht eingebunden, sondern nur die globale #include "stm32f4xx_hal.h" Was stimmt da denn nicht?! Ich verstehe es nicht, jede Funktion meckert der nur rum das die undefinierte
-
Thread
Theremin bauen mit µC oder/und FPGA
man auch direkt die Frequenz messen kann? > Für die Signalverarbeitung (DSP) dachte ich an einen STM32F102 oder nen > FPGA. Ein FPGA halte ich für übertrieben, der STM32 sollte das leicht schaffen.
/part/STM32F103 dann müsste der verstimmte Schwingkreis mit ner geringeren Frequenz laufen <500kHz!!!
-
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
Sebastian N. schrieb im Beitrag #4181877: > *==STM32==* > > Con: > -Community/Libraries? > -Programmierung schaut komplexer/Umfangreicher aus um das gleiche zu > erzielen wie z.B. beim AVR (Port-Init, PWM...) Egal welchen aktuellen µC Du verwenden