-
Thread
Gutes JTAG Tutorial gesucht
Boundery scann Für welchen Controller Famile wilst du mittels JTAG Debuggen? - ARM7 - CortexM3 - AVR32 - ... > Ich habe ja mit den Segger und J-Flash bereits den Flash eines Gerätes > ausgelesen, aber auch hier habe ich Probleme das auf einen anderen > Adapter/Software zu transponieren und
for(int i = 0; i < devCount; i++) { int strSize; for(strSize = 0; strSize < 64 && deviceNames[i*64 + strSize] != 0; strSize++); //get real string size devices[i] = new String(deviceNames, i*64, strSize, Charset.forName("US-ASCII")); // Only count the first
-
Thread
Floppy MFM Decoder selber bauen AVR ATmega Assembler Beispiele FDD Diskette
Klar haben die STM32 mehr Rechenleistung und RAM als ein AVR. Aber ein AVR reicht völlig. Und vor allem macht die Herausforderung, etwas auf einem in die Jahre gekommenen 8-bit Prozessor zu programmieren wo andere alle sofort
Peter S. schrieb im Beitrag #6137096: > Klar haben die STM32 mehr Rechenleistung und RAM als ein AVR. > Aber ein AVR reicht völlig. Nachweislich. :-) Ich dachte allerdings eher daran, dass man besser an Daten von schlecht lesbaren Disketten rankommen kann
-
Thread
Fuses falsch eingestellt Keine Reaktion mehr vom Controller
geschrotet.. Eingestellt habe ich: Ext. Crystal/Resonator Medium Freq; Start-up-time: 16K CK + 64ms zudem habe ich geändert: Brown-out detection at VCC=4.0V Jetzt kann ich weder Fuses einstellen, noch den Controller programmieren. Habe im Atmega32 die Pinne 12/13 mit einem Quartz versehen
https://www.mikrocontroller.net/articles/AVR_Fuses#Reaktivieren_bei_fehlerhaften_Taktquellen-Fuse-Einstellungen
-
Thread
Festkommaarithmetik
... unabhängig davon, dass ich den Sinn dieser Rechnerei nicht verstehe.... ein uint64_t gibts zwar beim avr-gcc... imho ist dieser allerdings dennoch bloß 32 Bit groß.
Ralph S. schrieb im Beitrag #5575248: > ein uint64_t gibts zwar beim avr-gcc... imho ist dieser > allerdings dennoch bloß 32 Bit groß. Das ist falsch. Wo ein int64 draufsteht, ist auch ein int64 drin. Aber: "double" und "float" sind auf dem AVR
-
Thread
ARM gibt Cortex-M-Prozessoren für Xilinx FPGAs frei
Ist zwar etwas OT aber es gibt ein Interview mit dem Kerl hinter PicoRV32, Clifford Wolf. Da erklärt er (unter anderem) was es mit PicoRV32 auf sich hat und noch vieles, vieles mehr (das Interview ist über 2,5h lang): https://theamphour.com/374-an-interview-with-clifford-wolf
new-part-day-the-r... Das Teil ist ja der Hammer! - RISC-V Prozessor der ARM-A-Klasse - 2 Kerne - 64Bit IMAFDC RISC_V (damit sollte sogar Linux laufen!) - Double Precision FPU (2x) - jeweils 32K I- und D-Cache pro Kern - 8MB onChip SRAM (2MB AI-RAM und 6MB General Purpose) - 7 Priority-Interrupt-Level
-
Thread
Mitstreiter für RISC-V Mikrocontrollers gesucht
das die verfügbaren Befehle durch die > RISC-V Spezifikation standardisiert wurde, egal ob der Core 32, 64 oder > 128 bit hat. Ist bei MIPS auch spezifiziert. (Bei so vielen Kernen wird dir der Platz ausgehen, dass du dich mit 32bit begnügen solltest) > Der entscheidendste Unterschied ist jedoch
die verfügbaren Befehle durch die >> RISC-V Spezifikation standardisiert wurde, egal ob der Core 32, 64 oder >> 128 bit hat. > Ist bei MIPS auch spezifiziert. > (Bei so vielen Kernen wird dir der Platz ausgehen, dass du dich mit > 32bit begnügen solltest) Es sollen auch nur 32bit Cores verwendet
-
Thread
Delphi oder Lazarus mit PASCAL
Einen > verneinten sie die Notwendigkeit, fanden Single genuege. Zum Zweiten > fanden sie waere der AVR eh zu langsam. Und Drittens brauchten diese > Funktion zuviel Speicher. Dafür gibts aber: Fix64 Fixed point Typ. 64 bit, 8 Bytes. Besteht aus einem 32bit ganzahligen und aus einem 32bit Nachkomma
Quellcode unbrauchbar,.. >... >Wenn man sich schon auf ein System festlegen will..verwende LunaAVR >https://avr.myluna.de/doku.php?id=de:start Mit LunaAVR begibst dich aber in die selbe Sackgasse, nur für AVR!
-
Thread
ESP8266 crash während updateWifi() - ist millis() das Problem?
() in Interrupt Routinen? [c] unsigned long ICACHE_RAM_ATTR millis() { union { uint64_t q; // Accumulator, 64-bit, little endian uint32_t a[2]; // ..........., 32-bit segments } acc; acc.a[1] = 0; // Zero high-acc uint32_t m = system_get_time(); uint32
micros_overflow_count + ((m < micros_at_last_overflow_tick) ? 1 : 0); acc.q = ( (uint64_t)( m * (uint64_t)MAGIC_1E3_wLO ) >> 32 ); acc.q += ( m * (uint64_t)MAGIC_1E3_wHI ); acc.q += ( c * (uint64_t)MAGIC_1E3_wLO ); acc.a[1] += (uint32_t)( c * (uint64_t)MAGIC_1E3_wHI ); return
-
Thread
Marlin Firmware mit dem ATMEL STUDIO 7 auf das Arduino Mega 2560 Board flashen
file "G:\AVR Studio\7.0\Build1188\7.0\Vs\Assembler.targets" from project "E:\Projekte AVR-Studio\ATmega\ATmega88\TWI_3\TWI_3\TWI_3.asmproj" (target "Build" depends on it): Task "RunAssemblerTask" G:\AVR
E:\Projekte AVR-Studio\ATmega\ATmega88\TWI_3\TWI_3\Debug\TWI_3.obj" "" -I "G:\AVR Studio\7.0\Build1188\7.0\toolchain\avr8\avrassembler\Include" AVRASM: AVR macro assembler 2.2.7 (build 69 Jul 26 2017 16:25:
-
Artikel
LPC-Mikrocontroller
1-36kB 1.71-3.6V USB, CAN, EEPROM LPC1200 Cortex-M0 32-128kB 4-8kB 1.8-3.6V 8 kV protection, IEC 60730 Class B certified LPC1300 Cortex-M3 72MHz 8-64kB 4-12kB 2.0-3.6V USB LPC1500 64-256kB 12-36kB 2.4-3.6V USB, CAN, QEI LPC1700 120MHz style="text-align:
On-chip memory (flashless parts LPC1850/30/20/10) Up to 200 kB SRAM total for code and data use. Two 32 kB SRAM blocks with separate bus access. Both SRAM blocks can be powered down individually. 64 kB ROM containing boot code and on-chip software drivers. 32-bit One-Time Programmable (OTP) memory for
-
Thread
Frage zu MSP430 Dokumentation für Einstieg
Bernd, Nachtrag: Ich installierte CCS8 auf einer W10X32 Maschine und der Debugger laeuft da einwandfrei. Keine RESET Probleme. Da stimmt irgend ewtas nicht auf meinem W7X64 System. Gerhard
für 10 Stunden. Finde ich nicht wirklich toll. Das sind 28 ppm Abweichung, da sollte mit einem 32-kHz-Quarz mehr machbar sein. Ansonsten: [[AVR_-_Die_genaue_Sekunde_/_RTC#Echtzeituhr_mit_Uhrenquarz]] Der Code dort ist zwar für einen AVR, aber die Idee dahinter kann man ja auch woanders implementieren
-
Thread
Was soll ich über Timer denken?
verlinke das hier und versuche das zu lesen und zu verstehen https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Die_Timer_und_Z%C3%A4hler_des_AVR doch erst mal kapiere ich gar nichts, weil immer alles so kompliziert ist. Warum wird hier von "Overflow" gesprochen wenn der Zähler wieder auf 0
0xFF bzw. 0xFFFF) hinaus. Das Overflow-Bit gestattet es, in Software weiter zu zählen, z.B. um einen 32Bit-Zähler zu erhalten.
-
Thread
DS18B20 Verkabelungs od Software Problem
Beitrag #5569845: > In Deiner Schaltung ist er am leitungsanfang oder? Auf der Platine mit dem AVR.
Temperature. DallasTemperature sensors(&oneWire); DeviceAddress TempBox1 = { 0x28, 0x61, 0x64, 0x11, 0xB0, 0x46, 0xC5, 0x2B }; DeviceAddress TempBox2 = { 0x28, 0x61, 0x64, 0x11, 0xB0, 0x65, 0x7F, 0xF3 }; DeviceAddress TempBox3 = { 0x28, 0x61, 0x64, 0x11, 0xB0, 0x43, 0xF6, 0x88 };
-
Thread
Wer nutzt das Nucleo-64 und kann mir
einen Fehler melden. Warum er sich > anders verhält, sehe ich gerade nicht. Moment! Beim STM32 macht er ja irgendwas! Ich bekomme über 100 Adressen wenn ich scanne. Nur beim AVR und ESP funktioniert es. Bedeutet durch den Switch auf STM32 nimmt er eine .h die gar nicht (richtig) funktioniert.
ist die Softwareentwicklung einfacher, man kann damit aber nicht alle Features der µC nutzen. Was STM32 angeht, ist in Arduino die Unterstützung der STM32F1 Serie am weitesten fortgeschritten. Deswegen würde ich Dir empfehlen, Arduino nur mit STM32F1 zu verwenden. Von Deinem Nucleo-64 könntest du den ST-Link
-
Thread
Mehrmonatsprojekt - Elin Stromgenerator 8kW 231V 50Hz@1500U zum Leben erwecken
Generator mit Stator-Erregung. Grobe Schätzung der Erregerleistung: 100-500 Watt, bei 8 Ohm wären das 32V 4A 128W 40V 5A 200W 48V 6A 288W 56V 7A 392W 64V 8A 512W
einphasige Generator funktioniert. 230V 2,2kVA <<-- diese ist die Ausgangsspannung/Leistung Err. 32V/1,5A <<-- diese Angabe gibt die Erregerspannung wieder dort ist die Erregerleistung 48W bei 2200VA, also 4,4%. Bei 8kVA sind 4% 320W. Zeno: AVR bedeutet hier Automatic Voltage Regulator
-
Thread
Daten von dynamischen Variabel vor Stromausfall schützen
Gegenvorschlag: > 23LCV1024 > > Oder ein I2C FRAM Adafruit I2C Non-Volatile FRAM Breakout - 256Kbit / 32KByte AF1895 Adafruit SPI Non-Volatile FRAM Breakout Board, 64Kbit / 8KByte Liest sich interessant, ist allerdings nicht 100% nötig da die Daten am Anfang geschrieben werden und nicht erst bei einer
[64]; } f3_label: bits64[beep] = 18::bits64; bits64[beep+4*8] = bits64[beep]; if (%zx32(bits8[beep+4*8]) == 18) { return; } goto f3_label; } explode(bits32) { boom(333); [/code] Das
-
Thread
Datentyp Speicherverbrauch
werden müssen, wenn dem so wäre. Folglich ist "long" In Win64 auch nur 32 Bit gross. > Wie bekommt man solche Faelle in Griff, Siehe types.h. Wenn du 64 Bits brauchst, schreib sowas wie int64_t. Das geht vom 8-Bitter AVR bis zum 64-Bitter.
bei 64-Bit-Plattformen int in der Regel 32 Bit breit. > - Integer hat 16/32/64 Bit ?!? Wenn du mit "Integer" int meinst, muss dieser mindestens 16 Bit breit sein, darf aber beliebig breiter sein. Das
-
Thread
Nuvoton N76E003
Oha, stimmt ganz genau... Woher weißt du das und kennen wir uns ? Und natürlich hab ich den STM32F030 (andere STM32 auch) im Repertoire (und den mag ich sehr)... Der Nuvotron würde mein "Setup" der verschiedenen MCU's erweitern. MCS-51 hab ich mit erscheinen und größer werden von AVR und dann
aufwändiger als gedacht) . Smile, im Archiv zum Flashershield in Projekte & Code ist ein Binarie für 32 und 64 Bit Linux enthalten.
-
Thread
Lookup Tablegenerator für NTC-Widerstände (Linux)
] Optional koennen weitere Parameter angegeben werden: [code] -a | Sourcedatei fuer AVR-Conroller erstellen (Tabelle wird im "PROGMEM" abgelegt) -l | Lookup-Table mit 32 Punkten (statt 16), erzielt etwas bessere Genauigkeit [/code] Die Ausgabe von NTCTABLE erfolgt auf
AMIAAOSwyttZyS3u NTC-Sensor 10K Ohm, B(eta)wert 3950, Pullupwiderstand 4,7 kOhm Ausgabe fuer ATMEL-AVR Controller NTC Kennlinie in 32 Stuetzpunkte unterteilt ntctable -r 10000 -R 4700 -b 3950 -a -l > ntc10k.c ------------------------------------ Auch wenn die Kommandozeile nur 16 oder 32
-
Thread
Welcher Fehler hat euch zuletzt Zeit gekostet ?
Bei der Portierung von STM8 (Compiler = SDCC) nach AVR hat mich folgendes (eigentlich einfaches) schier Verzweifeln lassen (und ich hätte früher ins Assemblerlisting gucken sollen), Code ist in einer ISR: SDCC: [code] uint32_charlie_buf; uint32_t
... [/code] Ein Blick in meine Notizen zum originalen Programm hat mir auch gezeigt, warum nr 32-Bit lang war. AVR-GCC: macht erst mal irgendwie Müll wenn nr 32-Bit groß ist. Okay, gibt es das halt in: [code] uint32_charlie_buf; uint32_t nr; ... if (charlie_buf & (1 << nr)) { } .
-
Thread
AVR Assembler: add adc auf 0 prüfen
Da es hier in diesem Thread um AVR geht sollte für alle Beteiligten klar sein, welches Handbuch maßgeblich ist. http://ww1.microchip.com/downloads/en/devicedoc/atmel-0856-avr-instruction-set-manual.pdf Nachtrag: Oh, das hat sich
geben. http://lyons42.com/AVR/Opcodes/AVRAllOpcodes.html
-
Thread
(sehr) kleines "FrameWork" für ATtiny44
bewerkstelligen. Damit das so klein wie möglich wird habe ich ein OLED Display, SSD1306 Controller mit nur 64 x 32 Pixeln ausgesucht. Schwups: meine Routinen für die üblichen OLED Displays mit 128 x 64 Pixeln funktionieren nicht. Das kleine Display benötigt eine andere Initialisierung und eine andere Adressierung
Sourcen. Wer tatsächlich dieses Framework nutzt muß aus dem Zip-File lediglich die Dateien oled_64x32_i2c.c / .h in die entsprechenden Ordner src und include kopieren. Wer es brauchen kann: Viel Spaß damit ! (alle anderen dürfen Spaß beim Lästern haben). Gruß jjflash
-
Thread
Arduino - UNO Flashershield (Linux)
eine alte und neue gibt. Das entpacken war kein Problem, danach war dann immer (unter anderen) ein 32-Bit- und 64-Bit-Verzeichnis da. Der Installer suchte sich automatisch das richtige Verzeichnis aus. Bei der alten Ausgabe fehlte jedoch im 64-Bit-Verzeichnis die Datei "flashershield", die im 32er
komplette Installation ohne Fehlermeldung erfolgen. Da vermute ich, dass die Software selbst auf 32 und 64-Bit- Rechnern gleich sein kann. Gruß, Hans
-
Thread
Einfach zu implementierende CPU in VHDL
der falsche Weg. Dann lieber eine richtig schnelle CPU. Ein moderner FPGA treibt "eine Art von AVR" mit 300 MHz an. Da macht das Sinn, weil die effektive Leistungs dieses AVRs bei etwa 100MHz liegt. Eine 32 Bit-CPU in SW kriegt man auch maximal auf die halbe effektive Taktfrequenz, aufgrund der
DMA/ISR, die CPU steht quasi voll für Spielelogik und Videotechnik zur Verfügung. Ganz easy: STM32L432KB - 256kB Flash, 64kB RAM. Fang mal mit Snake an und mach dann PacMan.
-
Thread
74HC573 als Eingangserweiterung
Ok, habe gerade das Beispiel hier auf der Seite gesehen dazu: "AVR-Tutorial: Schieberegister" Im prinzip könnnte ich das Kaskadieren bis zu beliebig vielen Eingängen. Quellcode wäre dann der unter Ansteuerung Software? Müsste ich mich ma mit auseinander setzten
#5553582: > Bei cpu/2 ist die Interrupt-Rate zu hoch. Sicher? Ich habs nicht probiert, aber <32 Zyklen je Interrupt klingt nicht unmöglich. Zumindest in Assembler ist es bequem zu schaffen. Selbst F_CPU/4 ist immer noch deutlich schneller als Bit-Banging. F_CPU/4 sind 64 Zyklen alle 2 Bytes
-
Thread
Wanderkiste Widlar, Runde III
Matrix Display) https://github.com/hzeller/rpi-rgb-led-matrix - 4 platinen fuer ein einfaches AVR basiertes LED lauflicht schaltplaene mit den bauteilen sind ausgedruckt dabei in_3: - 5* bluetooth/RS232 adapter https://www.mikrocontroller.net/topic/290615 - neues headset/mikrofon
machen. Ich habe auf meiner test pcb sehr viel unterschiedliche Formate drauf. Auch qfp48 und qfp64. Ansonsten halt 0402 -1210/2010. Diverse SOT formate. Ansonsten brauch ich selber THT Sachen, primär Transistoren oder opamps. Dankeschön
-
Thread
Rust auf AVR: AVR-Rust -> So geht's
Bevor mein Spieltrieb geweckt wird eine kurze Zwischenfrage: Werden bei AVR-Rust die Typen f32 *und* f64 unterstützt?
//github.com/avr-rust/rust/issues/76#issue-258761696 Da wird auch ueber die breite von f32 und f64 diskutiert.
-
Thread
Welcher Microcontroller für i2c-Display
Bauteile eingekauft. Auch das hat sich in den letzten 10 Jahren drastisch verändert. Die Diskussion AVR versus 32bit halte ich an dieser Stelle für unangebracht, dafür gibt es genug eigene Threads. Der TO hat sich für AVR entschieden und das ist ganz sicher kein Griff ins Klo. Man kann sie problemlos
Finger weg schrieb im Beitrag #5552530: > Interessant, es gibt nur ARM oder AVR? > Ihr lebt in einer sehr kleinen Welt. :'( Ob AVR, PIC oder 8051 ist relativ egal. Ich bevorzuge AVR (kenne die PICs aber kaum). Ob ARM, MIPS32 oder Renesas ist relativ egal. Dort ist ARM
-
Thread
Floppy FDD Diskette an AVR Mikrocontroller ATmega Beispiele Assembler
71858 https://www.mikrocontroller.net/topic/223147 Zur Soft-Dekodierung, falls es unbedingt ein AVR8 sein soll und die Zeit nicht ausreicht: die laufen bei sauberem Aufbau auch bis 24 / 28 MHz. Zum HD44780 fallen mir noch HD64180 (verbesserter Z80 im shrinkDIP64 1,778mm) und HD63484 (color graphic
soll ALLE bis zuletzt verfügbaren Formate unterstützen dies bis zum aussterben gab. Das mit dem AVR hier klingt auch interessant, dann hätte der Floppycontroller aber mehr Rechenleistung als die CPU!
-
Thread
STM32 Interrupt programmatisch auslösen
Servus, uC: STM32F411RE (Nucleo 64 board) Sprache: C++ IDE: Eclipse ich möchte gerne einen Interrupt programmatisch auslösen. D.h. ich möchte nicht auf ein Ereignis an einem Pin warten, oder einen Timer oder so,
ich angenommen habe. Also: Guck in die Lernbetty oder in das Mini-Projekt, das ich mal für die STM32F103C8T6 (aka "BluePill") geschrieben habe. Ich glaub, das hieß "STM32F103C8T6.ZIP". Dort findest du zum Nachlesen, wie das gedacht ist. Die Grundsätze sind dir aber hoffentlich bekannt, oder? Also
-
Thread
Fragen zu schrittmotor Treiber
Schritten pro OCR3A-ISR-Aufruf. Der Treiber ist auf 6400 Schritte pro Umdrehung bzw. Microstepping 32 eingestellt. Rainer W. schrieb im Beitrag #7527394: > In der Application Note AVR446 "Linear speed control of stepper motor" > von Atmel wird beschrieben, wie dafür die Frequenz bzw. der Abstand
Also mit 32 Microstepping erreiche ich im FastPWM-Mode 15, bei 16MHz CPU-Takt ohne Vorteilung, eine Taktrate von 58,824kHz, was einem OCRnx-Wert von 271 entspricht. Das sind 9,191 U/s bzw. 551 U/min. Gemessen habe
-
Thread
GRLB-Alternative?
Gowron schrieb im Beitrag #5540621: > - GRBL schafft nur 30 kHz Stepfrequenz auf den AVR, es gibt aber auch Portierungen auf den STM32F103, da habe ich von 180kHz gelesen.
den GRLB Motorschritte System auf einen Motor mit Encoder zu kommen. Wird wohl nicht mehr mit dem AVR gehen.
-
Thread
Empfehlung CAN Interface
Wenn man noch ein stm32f072 disco rumfliegen hat, reicht ein DIL8/SO8 CAN trx und eine Firmware von github, die ich nicht mehr finden kann..
normalen Tools benutzen (wireshark etc). Sonst hätte ich auch noch PCBs für den oben verlinkten AVR CAN Debugger.
-
Thread
Suche nach gutem Mikrocontroller
Preis pro Stück ist Egal :) Wir produzieren nur in Kleinserie daher ist das verlöten schon teurer. 2. 32-Bit Arm 3. 40+ Mhz 4. 256+ KB Flash 5. In unterschiedlichen Größen verfügbar. 32, 64, 100 Pin 6. SMD per Hand lötbar. Also kein BGA 7. Eclipse basierte IDE (wenn möglich) ohne Einschränkungen
USB noch Spannungsregler brauchst, bleibt ja nur noch der nackte Mikrocontroller übrig (sowohl bei AVR als auch bei STM32). Damit erübrigt sich die Frage nach dem Modul oder dem Nachbauen.
-
Thread
diskrete CPU
Die oberen 6 > Adressbits werden mit dem Befehlsregister verbunden, somit kann die CPU > bis zu 64 unterschiedliche Befehle ausführen, jeder mit bis zu 16 > Mikroschritten. Wie kommst du auf die 64?
ja mal gespannt was da kommt. Ne CPU zu bauen ist ja nunmal nicht so einfach. Wobei wirs ja mit 32Bit MIPS auch gleich komplett übertrieben haben ;) http://www.fritzler-avr.de/spaceage2/index.htm (Der eingebundene Webring ist SEHR zu empfehlen!) Aber in klein geht sowas ja auch: http://digitarworld.uw.hu
-
Thread
Lohnt sich der Einstieg in die MSP430 Welt?
, nen 32Bit ARM-Cortex (NXP, ST, Michrochip, TI, AD, Maxim usw.). Die Bitbreite hat nichts mit der Rechengenauigkeit zu tun, sondern nur mit der Geschwindigkeit und dem Adreßbereich. Auch ein AVR kann 32Bit float und 64Bit int (AVR-GCC) und 256kB Flash (ATmega2560).
-
Artikel
Mikrocontroller Vergleich
mit R8C, die /8x Modelle mit M32C (hier nicht näher betrachtet). Der 64KB RAM-I/O-Adressraum ist ein Teil des 1MB großen Gesamtadressraumes, Daten im ROM liegen jedoch ausserhalb dieser 64KB und sind daher anders als beim R8C nicht
auch die Dokumentation von NXP zu den LPCXpresso-Entwicklungskits (PDF) und diese Beschreibung STM32 Discovery Board für ca. 20 Euro Infineon XMC4500 Relax Kit für ca. 10 Euro Energy Micro Starter Kit ab ca. 55 Euro EFM32 unterstützt nur SWD. AVR: für ATmega16/162/32/128 ist JTAG günstig verfügbar (
-
Thread
PiXtend V2 -L-: Steuerung für Heim- und Industrianwendungen
hier im Forum gibts haufenweise Leute, die das besser könnten. Daß die neue Version immer noch auf AVR beruht rundet das Bild nur ab. Ein Großteil der Hardware dient nur der Pegelwandlung von 3,3V (RPi) auf AVR (5V) Das alles hätte man sich sparen können, wenn man direkt einen kleinen ARM verwendet
hätte. Ausserdem hätte man sich damit die Probleme mit der grottigen SPI-Slave-Schnittstelle der AVR erspart. Entsprechende Hinweise von mir im Pixtend-Forum wurden ignoriert...
-
Thread
Wie programmiert man einen STM32?
beschränkt, die Register direkt zu befüllen und auszulesen und mich so Schritt für Schritt an den uC (STM32F411RE nucleo-64) rangetastet. Nachdem ich nun (nach einigen Wochen) so weit gekommen bin, dass ich LEDs blinken lassen, via I2C Sensorwerte einlesen und mittels PWM Servos ansteuern kann, beginne
beschränkt, die Register direkt zu befüllen und > auszulesen und mich so Schritt für Schritt an den uC (STM32F411RE > nucleo-64) rangetastet. Ja, sure, das ist besonders für Anfänger geeignet. Da kann man so viel bei der Init-Routinen falsch machen bzw. vergessen, dass es einfach lachhaft ist, den Anfängern
-
Thread
Auswahl Einplatinencomputer
schwierig? Da nimmt man passende Hardware, oder einen µC, dessen Timer AB-Signale verstehen. STM32 können das. Da zählt die Hardware. Das dürfte problemlos bis in den MHz-Bereich gehen. Siehe auch: http://www.micromouseonline.com/2013/02/16/quadrature-encoders-with-the-stm32f4/
soso... schrieb im Beitrag #5531300: > STM32 können das. Aber locker, man nimmt einfach einen 32Bit Timer und lässt diesen Incrementieren. Man zählt während der 15s die Überläufe, die ~alle 6s kommen und wertet nach 15s den Zählerstand + Überläufe
-
Thread
stromsparender Raspberry Pi als Webserver
Ein STM32F107 duerfte allemal noch sparsamer sein. Aber wer nur einen Hammer kennt, wird auch nur Naegel in die Wand klopfen.
ausdrücklich darauf hinweisen, dass sie für FAT Filesystem (manchmal sogar noch spezifischer FAT16 oder FAT32) vorgesehen sind.
-
Thread
ATTiny2313 und SPI
verwendete Pascal Compiler intetessieren. Es soll Leute geben, die es geschafft haben, FreePascal für AVR und STM32 ans laufen zu bringen... ich wars nicht.
schaust Du am besten im deutschen Lazarusforum. .. das hab ich schon geguckt... Hmmmm, kannst du ein 32 und ein 64 Bit Binary hochladen?
-
Thread
ubuntu flaschen von ATmega324PB mit avrdude
Naja ein atmega32 ist kein atmega324PB. "-p m32" Da must Du wohl noch mal die Beschreibung lesen.
blink.o avr-objcopy -j .text -j .data -O ihex blink.elf blink.hex avr-size --format=avr --mcu=atmega324p blink.elf [/code]
-
Thread
ISR mit Quarz auslösen
#5524645: > Könnten wir das aktuelle Programm sehen? Gerne. [c] #define F_CPU 1000000 #include <avr/io.h> #include <avr/delay.h> #include <avr/interrupt.h> void TIMER(void) { TCCR0A= 0x00; //Mode of Operation: Normal TCCR0B= (1<<CS02)|(1<<CS00); //Prescaler x1024 TIMSK0=(1<<TOIE0
verloren. Übernehmen Sie mal Folgendes, bei mir läuft das: [c] #define F_CPU 1000000 #include <avr/io.h> #include <util/delay.h> #include <avr/interrupt.h> uint32_t volatile toc=0; void TIMER(void) { TCCR0B= (1<<CS02); //Prescaler 256 TIMSK0= (1<<TOIE0); } int main(void) {
-
Thread
Flankenauswertung bei vielen Tasten
erheblich codesparender, als das umständliche Hantieren mit Arrayindexen. Nimmt man für die Variablen uint64_t, lassen sich nach dieser Methode bis zu 64 Tasten entprellen. Die loslassende Flanke brauche ich zwar nicht, aber die läßt sich einfach dazu basteln, siehe: https://www.mikrocontroller.net/topic/
man 2..6 Tasten sehr wohl auf einen Port legen. Aber auch 12 Tasten an einem ARM (z.B. LPC1768) mit 32Bit-Ports lassen noch viel Freiheit bei der Zuordnung. Ich würde daher sagen: Es kann manchmal Fälle geben, wo man Tasten auf mehrere Ports verteilen muß.
-
Artikel
AVR Checkliste
den Ausgang auf den gewünschten Zustand ziehen. Besonderheiten bei ATmega128 und seinen Derivaten im 64-Pin-Gehäuse. Der ATmega64 und der ATmega128 sowie alle vom ATMega128 abgeleiteten AVRs im 64-Pin-Gehäuse (ATMega641/1281/2561, AT90PWM2/3/2B/3B sowie AT90CAN32/64/128, Ausnahmen sind nur AT90USB64/128
betrifft die M103C-Fuse (ATmega103 Compatibility Mode, nur bei den ATmega-Typen, nicht beim AT90CAN32/64/128). Diese ist bei fabrikneuen Atmega64/128 gesetzt und sorgt dafür, dass sich diese wie ein Atmega103 verhalten. Dies hat zur Folge, dass ein für den ATmega64 oder ATmega128 geschriebenes Programm
-
Thread
Maximale Quellcodedateigröße?
nicht mehr so oft ins C Compiler Fettnäpfchen. Das Ganze erinnert mich an die Diskussionen "nur AVR, bloß kein ARM!". Und die damaligen ARM-Hater rühren heute die ARM Werbetrommel und verfluchen die AVR.
amalgamation.html da steht auch was über ein split-amalgamation was sie anbieten wegen Debuggingproblemen über 32k lines. vielleicht hab ich mich auch um eine Potenz getäuscht.
-
Thread
Rust als Embedded-Programmiersprache Gesperrt
Programmiersprache aus. Und ihr wollt hier diskutieren, ob sich _DAS_ als Programmiersprache für einen PIC32 oder einen Cortex eignet? Nur zu, wer es sich in den Kopf gesetzt hat, partout Rust für die Firmware seines BluePill-Brettl's oder seines AVR nehmen zu wollen, der muß es halt tun - wenngleich ich das
wahrscheinlich auch seine Wurzeln in Haskell. Oder schau Dir mal diesen Schnipsel an: [pre] fn add(x: i32, y: i32) -> i32 { x + y } fn sub(x: i32, y: i32) -> i32 { x - y } fn calc(f: fn(i32, i32) -> i32, x:i32, y: i32) -> i32 { f(x, y) } fn main() { let x = calc(add, 2, 3)