-
Thread
Frage zur Funktionsweise des Netzwerk-Adapters
bis +15V und unterteile beides in jeweils 16 Intervalle. So kann man doch mit nur einer Spannung ein 32bit-Wert signalisieren. Und wenn man die Intervallbreite halbiert kann man mit einem Spannungswert 64bits signalisieren. Und wenn man es nochmal halbiert, dann sogar 128bits usw. Kann man so nicht Leitungsgeschwindigkeiten
Spannungswert; also das max. mögliche), am besten das ganze zusammen mit einem der folgenden Methoden: 64b/66b encoding 128b/130b encoding 256b/257b encoding https://en.wikipedia.org/wiki/64b/66b_encoding#Technologies_that_use_256b/257b_encoding
-
Thread
IntToHex function
HexW_Out (aHex >> 16); HexW_Out (aHex); } /* ein QWORD als Hexa ausgeben */ void HexQ_Out (int64* aHex) { HexL_Out (*aHex >> 32); HexL_Out (*aHex); } [/c] So, reicht's? Und wie man den ganzen Schmonzes in einen Puffer schreibt und dann die Länge oder nen Zeiger auf das folgende Nullbyte
auf STM32, AVR, 8051, PIC usw. Nechteilig finde ich nur, das die Tabelle auf manchen Plattformen im RAM liegen muss. Aber wer heute keine 16 Bytes mehr frei hat, der hat auch noch andere Probleme.
-
Thread
Am besten C lernen
schrieb im Beitrag #5821686: > Da würde ich mir klassischerweise eine Funktion schreiben, die einen > 32-bit Wert verarbeiten kann, und ich übergebe die Länge, wie breit mein > Datenwort ist. Und was, wenn du ein 64bit-Wort umwandeln willst? Dann brauchst du eine 2. Funktion. Oder du machst immer 64bit, und ziehst auf nicht-64bit-Rechnern immer 32 unnötige Bits mit. Ineffizient. Joe F. schrieb im Beitrag #5821686: > Der Compiler castet den uint8 auf > uint32. Kein Problem. Gerade auf 8-Bit-Controllern hat man dann
-
Thread
Einstieg in die Welt der Mikrocontroller leicht gemacht: Onlinekurs zum ESP32 im Mai
verstehen. Na toll. Dann haben wir ab nächstem Jahr als Studienabschlüsse: - Fachingenieur für STM32F10x - Fachingenieur für STM32F30x - Fachingenieur für ESP32 - Fachingenieur für ARDUINO - Fachingenieur für ATmega und so weiter. Was für ein Mumpitz! Nein, die Welt teilt sich anders auf,
#5843946: > Na toll. Dann haben wir ab nächstem Jahr als Studienabschlüsse: > - Fachingenieur für STM32F10x > - Fachingenieur für STM32F30x > - Fachingenieur für ESP32 > - Fachingenieur für ARDUINO > - Fachingenieur für ATmega Das nennt sich Spezialist, einer der immer mehr von immer weniger
-
Thread
Servo verhält sich nicht wie erwartet
<<ADEN) | (1<<ADPS2) | (1<<ADPS1); ADCSRA |= (1<<ADSC); while (1){ OCR2 = F_CPU / 64 / ((uint32_t)ADC * 4000 / 1024); } } [/c]
Für 1 ms Pulse brauchst du in OCR den Wert 1 ms/64 µs = 16 Für 1,5 ms Pulse brauchst du in OCR den Wert 1,5 ms/64 µs = 23 Für 2 ms Pulse brauchst du in OCR den Wert 2 ms/64 µs = 32 Ich vermute, dass dein ADC Werte von 0 bis 1023 liefert. Rechnen
-
Thread
Automatische Variable vs. malloc()
In der Steinzeit der > AVRs haben wir mal für einen Buffer genau soviel SRAM gebraucht, wie der > AVR an Bord hatte. In dem Fall war es praktisch, dass man den Stack in > die Registerbank legen kann... Welcher AVR soll denn das gewesen sein? Ich hatte das auch mal probiert bei einem ATTiny25, R0
der Steinzeit der >> AVRs haben wir mal für einen Buffer genau soviel SRAM gebraucht, wie der >> AVR an Bord hatte. In dem Fall war es praktisch, dass man den Stack in >> die Registerbank legen kann... > > Welcher AVR soll denn das gewesen sein? > Ich hatte das auch mal probiert bei einem ATTiny25
-
Thread
umstieg von Symbol zu Grafikdisplay
kleinen µC mit seriellen API Methoden aufrufen ohne Fonts und Grafiken vorzuhalten. Mit einem STM32F103 wäre ein GFX mit z.B. 128x64 Pixeln preiswerter und der Zeichensatz paßt in den µC, Grafikdinge auch. Allerdings brauchen einige davon etliche Pins, hab hier noch mehrere alte mit parallelen Anschlüssen
wirst > du sowas brauchen. > Olaf da hatte ich mir bei meinem ersten Timer mit einer PWM aus dem AVR und einer Ladungspumpe beholfen, einstellbar vom AVR. https://www.holger-klabunde.de/dcdc/picdcdc.htm
-
Thread
Messumformer 4..20mA mit Arduino auswerten
Rauschen erlaubt mit dieser Methode die effektive ADC Auflösung zu verbessern. Das lohnt sich ab 16-64 ADC Messungen per Zyklus. Nicht vergessen die Hälfte des Mittelwert N zum Result hinzuaddieren um den 1/2-bit Fehler zu kompensieren. Z.B. bei 64 Messungen addierst Du dann am Ausgangswert 32. durch
Strom der den AVR nicht beschädigt. Da die 6.8V TVS diode 1.8V von 5V weg ist, sollte der Leckstrom vernachläßig sein. Im Normalfall bekommt also der AVR ADC Eingang die erwartete Spannung von 1-5V. Also fallen am 1K
-
Thread
Fehler beim Flaschen ATMEGA328P
Hallo, ich benutze einen ATMEGA32P mit 20Mhz LOW Fuse 0xFF High Fuse 0xD9 Extended Fuse 0xFF Lockbits 0xFF Wenn ich nun versuche den Atmega zu flashen kommt folgende Fehlermeldung im AvrProgTool: benutze: mySmartUSB MK2
Derzeit habe ich: Ext. Crystal Osc.; Frequency 8.0 - Mhz; Start-up time > PWRDWN/RESET: 16K CK/14 CK +64ms eingestellt > > Laut einem Youtube Tutorial sollte es mit den Einstellungen gehen: > Youtube-Video "Die Fuse-Bits des AVR mit dem myAVR ProgTool bearbeiten" Sorry aber Wiki und Youtube sind
-
Thread
STM32 Taktfrequenz
Es ist aber schon (zumindest für mich) eine wichtige Erkenntnis, dass STM32 ihre I/O Pins per Software verhältnismäßig wesentlich langsamer toggeln, als AVR Mikrocontroller. Ein 8 MHz AVR schafft 4 MHz, weil jeder I/O Zugriff nur einen Takt dauert.
Dann ist aber ein Add > auch 1 Cycle und du bist wieder in der Atmega-Welt. Wobei dann so ein STM32 letztendlich langsamer wird, als ein AVR mit 20 oder 32 MHz. Der Flash von ST kann nämlich nur maximal 24 Mhz und für viele Befehle (insbesondere I/O) sind mehr Takzyklen nötig, als bei AVR.
-
Thread
HDMI an Arduino
hier VGA auf nem Atmega1284: https://hackaday.com/2013/03/29/avr-vga-generator/ übertaktet auf 25MHz, schafft ganze 128×96 Pixel mit 64 Farben, aber Respekt dass er das überhaupt hinbekommen hat.
aber nicht alle. Wenns also ein anderer µC sein darf: Ein PIC32MZ(DA) hat eine GPU und 32MByte RAM sowie ein LCD-Interface. Dafür dürfte man HDMI-Tranceiver bekommen. Selbst damit wollte man sich aber vermutlich auf kleiner Auflösungen beschränken. Auch mit einem
-
Thread
Atmega88-20PU + Arduino Uno
Du kannst zusätzlich den Pfad zur Konfigurationsdatei angeben: [pre] G:\Arduino\hardware\tools\avr\bin\avrdude.exe -v -C G:\Arduino\hardware\tools\avr\etc\avrdude.conf -c stk500 -P COM4 -B20 -p atmega88p [/pre]
> avrdude.exe: Version 6.0.1, compiled on Apr 15 2015 at 19:59:58 > "G:\Arduino\hardware\tools\avr\bin\avrdude.conf" Hmmm... Aktuell wäre > avrdude: Version 6.3-20171130 -------- Die Meldung zeigt klar, keine Verbindung zwischen "Arduino as ISP" und AvrDude
-
Thread
Byte auf verteilten Ausgängen ordnen
0x0b, 7 sbrc r25, 0 sbi 0x0b, 7 // 8 Bytes [/c] Das sind 8*8 Bytes = 64 Bytes. + 2(mov am Start) + 2(rjmp am ende) ergibt 68 Bytes. Und ergibt immer 8*4 Takte = 32 Takte. Dass die lut Tabellen kompliziert und auch kompliziert zu ändern sind, ist wohl klar. Tim
sbrc r25, 0 > sbi 0x0b, 7 // 8 Bytes > [/c] > Das sind 8*8 Bytes = 64 Bytes. > + 2(mov am Start) + 2(rjmp am ende) ergibt 68 Bytes. > Und ergibt immer 8*4 Takte = 32 Takte. Hmm, ich komm da auf andere Werte: Angenommen das Bit ist gesetzt, dann braucht sbrs 2
-
Thread
I2C EEPROM Beschreiben mit SAM3X8: Pollingproblem
Hanns-Jürgen M. schrieb im Beitrag #5807082: > Beim 24C256 kann ich aber in Blöcken a' 64 byte beschreiben und > muß nur ein einziges Mal pro Block den Delay benutzen. Das sind dann beim Beschreiben der 32kB schon 10s Wartezeit gegenüber nur 2,5s, wenn der Chip schon nach 5ms wieder bereit
#5807945: > Hanns-Jürgen M. schrieb im Beitrag #5807082: >> Beim 24C256 kann ich aber in Blöcken a' 64 byte beschreiben und >> muß nur ein einziges Mal pro Block den Delay benutzen. > > Das sind dann beim Beschreiben der 32kB schon 10s Wartezeit gegenüber > nur 2,5s, wenn der Chip schon nach 5ms
-
Thread
Bekomme mein LCD Display nicht ins Laufen
lcd-routines.c/.h aus diesem Video (https://www.youtube.com/watch?v=p8r1EXRLQV0&t=304s) Mein µC: Atmega32A-PU (Datenblatt: https://www.promelec.ru/pdf/atmega32a.pdf) Angeschlossen ist das Display wie folgt(4-Bit Modus?): LCD Pin 1_(VSS)_____an GND LCD Pin 2_(VDD)_____an VCC (5V) LCD Pin 3__(VO)_
Fuses habe ich gerade mal noch von ext. Crystal zurück auf default (Int. RC Osc. 1MHZ; Start-Up 6CK+64ms;default value) gestellt. Hat allerdings zu nichts geführt.
-
Thread
Approximation durch Fixpunktrechnung
genutzte) Term x*a/b mit konstanten Parametern a und b . Direkt würde er so ausgewertet: [c] int32_t term(int32_t x, int32_t a, int32_t b) { assert( b > a ); assert( a > 0 ); return (int64_t) x*a/b; } [/c] Das Ganze will ich beschleunigen durch eine Approximation durch eine Qn-Fixpunkt-Zahl
= true; val = (((uint64_t) a << 32) / (uint32_t) b); } return ((int64_t) x * val) >> 32; }[/c] Allerdings ist nicht klar, welche Probleme du zu umschiffen versuchst und auf welcher Plattform das laufen
-
Thread
Rotary-Encoder mit Arduino als Konzentrator
Controller zu programmieren. Es ist eine Astaktionsebene mehr, da man mit diesem System sowohl 8-Bit-AVR, als auch 32-Bit-arm-Controller programmieren kann.
"transmit buffer" ist genau der 2-Byte-Fifo, den ich oben > beschrieben habe. Für die üblichen AVR Arduinos gilt: #define SERIAL_TX_BUFFER_SIZE 64 Siehe: https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/HardwareSerial.h https://github.com/arduino/ArduinoCore-avr/blob/master
-
Thread
Diskussion: Pi möglichst schnell berechnen
flo schrieb im Beitrag #5801268: > Gibt es die math.h auch für AVR-Controller Ja. > und wenn ja, ist irgendwo verständlich dokumentiert, was sie kann? Ja, hier: https://www.nongnu.org/avr-libc/user-manual/group__avr__math.html
int main(void) { float pi; // pi = z / 64 # if defined __STDC_IEC_559__ || defined __AVR_ARCH__ union { float f; uint8_t c[4]; } u = { z }; // u.f = z; # if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ u.c[3] -= 3;
-
Thread
Auswahl uController
Kennst Du AVR32? Schon was damit gemacht? Bei Microchip ist AVR32 quasi EOL (End Of Life). Ja, sie verkaufen noch welche, solange noch Nachfrage ist, aber diese Architektur ist bei denen quasi auf dem Abstellgleis
Die AVR32 Serie mag ich gerne. Ich nutze den AVR32UC3C0512 in einem neuen Projekt. Aber nur, weil es einem bestehenden Projekt sehr ähnelt. Ansonsten hätte ich mich auch eher für einen stm32 entschieden. Leider
-
Thread
Neue MegaAVR 0-Series jetzt auch in DIP Version
40poligem Gehäuse (ATMega4809) : http://ww1.microchip.com/downloads/en/DeviceDoc/40-pin-Data-Sheet-megaAVR-0-series-DS40002104A.pdf
UART flöten geht. Doch verbleiben immer noch drei- und damit immer noch mehr als in jedem anderen DIP-AVR.
-
Thread
Oszilloskop für Optimales PWM-->DC-Motor
- PWM_Bits = 10 -->TOP = 1024-1 Formel war doch nun: https://www.mikrocontroller.net/articles/AVR_PWM#C_2 31250/(2*TOP) = 15 Hz Das kommt mir etwas wenig vor?
Korrektheit mit > > - 8000000 Hz MCU (fix) > - PWM_Prescaler von 256 --> 31250 Hz PWM Jain. Das sind 32,25kHz PWM-Takt > - PWM_Bits = 10 -->TOP = 1024-1 > > Formel war doch nun: > https://www.mikrocontroller.net/articles/AVR_PWM#C_2 > 31250/(2*TOP) = 15 Hz Das ist die PWM-Frequenz. > Das
-
Thread
Avr 8bit VGA
Das von mir in diesem Thread zweimal verlinkte Projekt ("AVR VGA Terminal") macht dasselbe, mit einem (übertakteten) AVR anstelle eines 32-Bit-PICs.
stm32 als GPU für nen 8 bit'ter.. ich weiss nicht, dann lass doch gleich einen "AVR-Emulator" drauf laufen. Oder schneid den AVR-Zopf gleich ab.
-
Thread
Module miteinander verbinden - welchen Bus nehmen?
gibt es Sender und Empfänger, die locker 10 MBit/s Datenrate und mehr können. Bei so etwas ist ein AVR raus, da brauchst Du einen ARM oder MIPS (PIC32) mit DMA und geeigneten UARTs. Früher hätte man da Zilog ESCCs mit HDLC genommen, aber das ist ja inzwischen aus der Mode gekommen. Damit ist zumindest
und die meisten Transceiver gehen auch offiziell bestenfalls bis 5MBit. Und die Pakete können bis 64 Byte groß sein. Dafür müsste der unbekannte Typ STM32 aber CAN-FD unterstützen und das können soweit nur die H7 (und irgendwelche L-Typen die im Zusammenhang mit einem Display eher nicht relevant sein
-
Thread
ST-Link V2 aus China
flashen (der ST-Link V2 aus China hingegeben schon). Mein Microcontrollerpaket soll die Familien AVR, MCS51, STM8 und STM32 unterstuetzen. Der ST-Link V2 unterstützt hier beide Familien, STM8 und STM32.
(20 KiB), Flash: 0x10000 bytes (64 KiB) in pages of 1024 bytes 2019-06-27T22:54:32 INFO common.c: Attempting to write 6844 (0x1abc) bytes to stm32 address: 134217728 (0x8000000) Flash page at addr: 0x08001800 erased 2019-06-27T22:54
-
Thread
STM32G071 LQFP32 und der HSE
PCB-Design sowie mein Nucleo-Board (STM32g071RBTx ... 64 Pins) zeigen bei gleichem Code das gleiche Verhalten. SYSCLK direkt gemessen mit Oszi am MCO Pin ohne Vorteiler: HSE ... OK HSI ... OK LSI ... OK HSE mit PLL bis 55MHz ... OK HSI
unerwähnt geblieben. Der Wert scheint vllt. ungewoehnlich, dieser stammt aus einem Projekt von einem stm32f303, daher sind da noch ganz paar Quarze da. So ergibt sich, dass [math] HSE / div3 * LL\_RCC\_PLLN\_MUL\_SYS / div4 [/math] 64Mhz ist bei LL_RCC_PLLN_MUL_SYS = 64 Dieses Symbol steht fuer
-
Thread
MCU mit 64Mbyte RAM
Bei Deinen Randbedingungen (AVR, vom Bastler lötbar) sage ich: vergiss es. Wenn Du etwas haben willst, was in Deiner technischen Reichweite liegt: PIC32MZ1064DAG176 https://www.microchip.com/wwwproducts/en/PIC32MZ1064DAG176
PS: Also diverse ARM-uC wie STM32 können das natürlich auch, aber mir fällt gerade kein fertiges Board mit 64 MB ein. Selbst-Bau ginge damit aber.
-
Thread
Wie viel Prozent des Gehalts sparen und wie anlegen? Gesperrt
nächste Regierung anfängt an der Abgabenschraube/Rentenschraube zu drehen geht ich eben weiter runter, 32..30..28 mal sehen.
F. B. schrieb im Beitrag #6890004: > VSBLTY nachgekauft. All in. -32% in 1,5 Monaten. Verbesserungswürdige Performance.
-
Thread
STM32F4xx / L4xx DMA durch externes Signal triggern
Ganz neue, größere STM32-Serien haben einen DMAMUX, z.B. die STM32L5. Mit dem kann man direkt EXTI-Lines als DMA-Trigger verwenden.
das funktioniert auch schon), aber es ist schon irgendwie verschwendete Rechenzeit. Wenn schon ein AVR (bei 25MHz) VGA-Ausgabe über externes RAM und einfache 3D-Berechnungen (incl. Z-BUffer) kann, dann sollte sich aus einem STM32 noch einiges mehr herausholen lassen... Jörg
-
Thread
Erste 65C02 Basteleien.
besser bleiben lassen. Dabei lernst du nichts nützliches. Wenn du gerade Langeweile hast und die AVR schon kennst, dann schau Dir einen 32bit ARM Controller an. Evaluation Kits bekommst du innerhalb von 48 Stunden original ab 10€: https://www.amazon.de/STM32-ST-NUCLEO-L073RZ-Nucleo-Development/dp
6502 ist der 6504. Komisch, mein Rockwell Datenbuch von 1984 hat auf Seite 2-18 einen R6501Q im 64 beinigen Gehäuse. Der hat 32 I/O Pins zusätzlich und etwas internen Speicher.
-
Thread
Theoretische Überlegung: Was bringt externer, seriell angebundener SRAM?
Speichrbereich ab und regelt den Zugriff transparent. Schau dir 'mal das QSPI-Interface bei den großen STM32-Controllern an. Jens
Beim ESP32 wird's verwendet: https://www.mikrocontroller.net/topic/465403
-
Thread
Mikrocontroller - die Qual der Wahl, oder doch die Wahl der Qual?
STM32F0 mit 8MHz ist immer > noch um ein vielfaches schneller als ein AVR mit 16MHz. Das bezweifle ich allerdings. Er mag schneller rechnen können, aber das wär's dann auch schon.
hat. Das stimmt so auch nicht, denn es gibt durchaus kleinere µC Chips mit ARM Kern. Beispiel: STM32F0xx Der hat zwar einen 32 Bit Cortex-M0, ist dennoch mit relativ wenigen Pins ein kleiner Typ. Ich würde den eher als Ersatztyp für den AVR ansehen. Die großen wie z.B. STM32F4xx sind in der Tat
-
Thread
USB Audio Sync Endpoint Implementierung
funktioniert nun soweit! Treiberseitig ist der USB Treiber aus dem ASF und die Audioklasse ist vom AVR32 portiert. Das Device enumeriert unter Windows sauber und wird problemlos als Audiodevice erkannt. Das Abspielen funktioniert ebenfalls (im momentanen Testaufbau in Kombination mit einem DSP, der
zusammengenagelt: USB Treiber aus dem ASF für den SAMD21, USB Audio Treiber vom SAM3X und USB Audio Class 1 vom AVR32. Das ließ sich alles noch "relativ" gut ohne größere Reibungsverluste adaptieren, weil der Code großteils portierbar ist. > Du stellst bei jedem SOF einen neuen passenden Wert ein sobald dein
-
Thread
IDE für STM32
Mit STM32CubeMX kannst du dir die Konfiguration der Hardware zusammenklicken und dann als Projekt für deine IDE (SW4STM32 z.B.) exportieren.
installierst du neben der IDE zusätzlich CubeMX von ST. Eventuell helfen Dir meine Notizen zu STM32F1 und F3: http://stefanfrings.de/stm32/index.html
-
Thread
Module initialisieren
Hallo, Würde man einen AVR betrachten, was sind den "Module"? Wo finde ich den Begriff?
Dir mal vor, du will so ein Hello-World Programm noch universeller machen, dass es nicht nur auf STM32 läuft. Dann wird das so groß, dass es auf die kleinen AVR's gar nicht mehr drauf passt. Ich kann jetzt schon den Einen oder Anderen beeindrucken, dass meine Programme mit 1MHz genau so gut laufen,
-
Thread
Wie verdient Microsoft sein Geld
egal. Wenn Du heute zufällig ausgewählt Leute an ihren Arbeitsplätzen fragst, ob ihr System mit 32 oder 64 Bit läuft, würden 90% wahrscheinlich antworten: Häh? Das interessiert die nicht. Die interessiert, ob sie mit dem Computer ihre Aufgaben erfüllen können, ob die Daten austauschbar sind und
> Wenn Du heute zufällig ausgewählt Leute an ihren Arbeitsplätzen fragst, > ob ihr System mit 32 oder 64 Bit läuft, würden 90% wahrscheinlich > antworten: Häh? Ja, sagte ich schon, Microsoft erhebt die Dunkelheit zum Industriestandard, Du die Dummen... > > Das interessiert die nicht. Die
-
Thread
Qualität und Haltbarkeit von preiswerten DSOs
Beispiel ein und den selben Mikrocontroller > mit drei unterschiedlichen Beschriftungen: > > STM32F101CBT6 (128kB ohne USB) > STM32F103C8T6 ( 64kB mit USB) > STM32F103CBT6 (128kB mit USB) Kann natürlich reine Marketing Sache sein. Aber es gibt auch die Möglichkeit das der Chip beim binning
Beispiel ein und den selben Mikrocontroller > mit drei unterschiedlichen Beschriftungen: > > STM32F101CBT6 (128kB ohne USB) > STM32F103C8T6 ( 64kB mit USB) > STM32F103CBT6 (128kB mit USB) Testzeit auf der Fertigungslinie ist teuer. (so hat mir das ein FAE erklärt). Wenn weniger Flash getestet
-
Thread
AVR AtMEGA328P-PU u. I2C in Arduino: Probleme mit mehrdimensionale Arrays
Zeitabstand. } void sendarr(byte led[8][8]) { Wire.beginTransmission(8); for (int i=0;i<=64; i++) { Wire.write(led[y][x]); //Das geht nicht, auch nicht wenn man versucht x++; // es auf Wire.write(led, 64); zu bringen. if (x==7) { x=0; y++;
nicht achten. Das ist ein Quick&Dirty Framework, das nur einfachen Ansprüchen genügt. Mehr als die 32 Bytes gehen halt nicht.
-
Thread
Schalter über Internet steuern
die geforderte Performance und Rechenleistung total! Das braucht mindestens einen Intel Core i9 mit 64GB RAM! Gruss Chregu
Ist zwar schon älter aber sollte für deinen Zweck ausreichen, der gute alte AVR-NET-IO https://www.pollin.de/p/bausatz-avr-net-io-810058
-
Artikel
Soft-PWM
mit 100 Hz (PWM-Zyklus 10ms) und acht Kanälen generiert werden. Der verwendete Controller ist ein AVR vom Typ ATmega32, welcher mit dem internen RC-Oszillator auf 8 MHz getaktet wird. Das Programm kann jedoch problemlos an so ziemlich jeden anderen AVR angepasst werden. Die Programme wurden mit dem
stromstarke und widerstandsarme Leistungs-MOSFETs. Als Controller bieten sich ARM-basierte Typen oder AVR32 an, deren zeitkritischer Firmware-Teil ebenfalls in Assembler zu programmieren ist und im RAM (nicht im lahmen Flash) ablaufen muss. Es gibt auch RGB-LEDs mit eingebauter PWM-Steuerung und SPI-Businterface
-
Thread
Schnellere MCU als der ESP8266 zu einem guten Preis?
Sorry, das STM32f429 Discovery Board kostet so ca 30.- das ist doch nicht zu teuer! Da hast du einen 2MB controller + 64MB SDRam dabei und das Display! Nebenbei auch noch den entsprechenden Debugger und alle Pins
bildfläche ebenso die integration in die arduinoumgebung das zeug ist jetzt schüttgut ... > avr schrieb: >> Der ESP ist vor allem langsamer als ein M7 - trotz dual core. > > Hast du eine Quelle für diese Behauptung? aus neugier gegoogled: ein 32F7 At 216 MHz fCPU, the STM32F745 delivers
-
Thread
Vergleich zweier Prozessoren
spms338e.pdf und Atmel/MCP SAM3X (http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-11057-32-bit-Cortex-M3-Microcontroller-SAM3X-SAM3A_Datasheet.pdf) Beide 32bit, der Cortex M4F läuft mit max 80MHz, der Cortex M3 mit max. 84MHz. Zum Cortex M3 finde ich die Angabe "105 MIPS", zum Cortex M4F
benutzt, macht eine FPU einen riesen Unterschied. Der M4 kann beispielsweise mit einer Instruktion 2 32bit Werte zu einem 64bit Wert multiplizieren, der M3 kann das nicht. Auch einige andere Instructions wie MAC (multiply accumulate) sind auf dem M4 schneller.
-
Thread
[C] Böse Falle: Datentyp korrekt angegeben, falscher verwendet
_t i = 30000 * 2; > > Code 2: long a = 30000; > long b = 2; > uint32_t i = a * b; Und schon kommen unterschiedliche Ergebnisse auf dem AVR. Und am PC hängt es davon ab, ob Windows (int=32, long=32) oder Linux (int=32, long=64), sobald die Zahlen größer werden. Sorry
Linux nicht 64 Bit breit? > > Nein. Das ist LP64, also 32-Bit int und 64-Bit long/pointer. Zu den > Gründen mag zählen, dass es in ILP64 keine im Standard vorkommenden > Typen für 16 und 32 Bits gibt. Für eines