-
Thread
(dauerhaft) aktuelle Toolchain
dem Utils-Verzeivhnis von WinAVR-Version dahin kopiert. Läuft ohne Probleme unter W8.1, 64bit.
/files/avr-gcc%20snapshots%20%28Win32%29/ Ist eine Toolchain mit avr-gcc 6.1.1, ist aber ohne make & Co. Dafür läuft diese mit WinAvr 4.18 - jedenfalls bis Win7.
-
Thread
ATmega2560 - LED blinkt nicht
Thomas G. schrieb im Beitrag #5714058: > Also eine positive (unsigned) 64-Bit (long) Zahl. Nein! Long ist nur als "mindestens 32bit" spezifiziert, meisten sind es tatsächlich 32bit. Für 64bit musst du "unsigned long long" bzw "ULL" schreiben. > würde unsigned int
OK, hab ich das dann so richtig verstanden: LONG >= 32-Bit LONG LONG = 64-Bit Und was ist mit: VERY LONG; MUCH LONGER & EVEN LONGER? Schönen Abend noch!
-
Thread
Einstieg USB Programmer
USBasp würde dann Problemlos mit XP usw. arbeiten (glaube unter Win7 auch ohne Probleme) das aber mit 32Bit Windows Betriebsysteme unter 64Bit muß man 1000 Dinge machen damit er funktioniert. Gruß Martin
angefangen. Hatte mit mikrocontroller oder ähnlichem noch nie zu tun. Mein System: Windows 7 64 bit oder Laptop mit Parallelport Windows xp 32 bit
-
Thread
Unterschiede zwischen ARM und ATmega in der Programmierung
Die AVR's liefern bis zu 40mA an ihren I/O Pins, STM32F1 schaffen gerade mal halb so viel. Dafür haben die meisten STM32F1 Chips mehr RAM und Flash als AVR's. Die zahlreichen I/O Features schaust Du Dir
> angenehmer Vorteil von ARM versus AVR Das konnte Mann auch schon mit 16 bit Architekturen haben. Wenn es denn alles in die 64 kByte gepasst hat. Gott sei Dank sind kleine 32 Bitter mittlerweile billiger.
-
Thread
Mini Computer. Wer hat lust?
#2050059: > Sowas geistert hier doch gerade schon rum. Irgendwas mit "Handhelden". Dieser hat einen AVR32 und ist im vergleich zu den neuen ARMs ziemlich lahm
Du meinst also praktisch sowas: http://www.mikrocontroller.net/articles/AVR32_Grasshopper
-
Thread
32 bit Zeiger auf Flash AVR 8-Bit GCC
Hmm, die Doku der avr libc sagt, dass es near pointer (16 bit) und far pointer (32 Bit) gibt.
Hi. Soweit mir bekannt ist, stellt die AVR-toolchain sicher, dass PROGMEMs in die oberen 64K deiner firmware gelinkt werden. Insofern du also deine Firware ab Adresse 0x0000 installierst, müsstest du bis zu (fast) 64KB PROGMEMs ganz normal
-
Thread
1000 Leds an Atmega32
Auf der Suche nach Portexpandern, habe ich den PCF8574 gefunden. Wenn ich 8 davon nehme, habe ich 64 Pins. Damit kann ich eine 32 x 32 = 1024 LED Matrix betreiben (Mit Treibern natürlich). Liege ich damit richtig? Hat einer von euch Erfahrungen mit diesen Chips? Freundliche Grüsse Florian
avr schrieb im Beitrag #3886689: > 1/32 dutycycle? Bei dem UDN bekommen die Leds einen Strom von ~300µA. Troll dich. Oder such jemanden der dir vorlesen kann, was ich geschrieben habe.
-
Thread
In Dauerschleif eine Aktion alle 30s durchführen oder direkt am Start
Stefan ⛄ F. schrieb im Beitrag #6794688: > Weil millis() einen 64 Bit Integer liefert. Aua! Zeile 56: https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c#L65
Auf einem AVR eine 32Bit-Variable zu laden, kostet mehr Code, im Vergleich zu einem weiteren RCALL zu Beginn.
-
Thread
Wofür Propeller von Parallax ?
wenn gewünscht. Auch wenn es für manche unglaublich klingen mag, der Propeller 2 kann bis zu: - 64 DACs - 64 ADCs - 32 USB Schnittstellen (Host oder Device) - 64 UART Kanäle (RX oder TX) - 64 PWM Ausgänge - 64 Frequenzzähler - und vieles mehr, alles natürlich nur einmal pro Pin/Pinpaar einsetzbar
Geschichte. > Auch wenn es für manche unglaublich klingen mag, der Propeller 2 kann > bis zu: > - 64 DACs > - 64 ADCs > - 32 USB Schnittstellen (Host oder Device) > - 64 UART Kanäle (RX oder TX) > - 64 PWM Ausgänge > - 64 Frequenzzähler Fuer mich klingt das auch ueberraschend. Aber wie schon
-
Thread
Fehlermeldung Arduino C++
Die AVR-Freaks behandeln das Thema ausführlich. Wenn ich es richtig verstehe, gibt es beim AVR-GCC eine Limitierung auf 32k : http://www.avrfreaks.net/forum/maximum-size-progmem-array Einer schlägt vor,
der ist beim avr-gcc 16 bit breit. Da ist bei 32k Arrayelementen Schluss. Oliver
-
Thread
Was wird denn nun aus AVR?
Da fragt man sich doch, wo ist das ganze Geld dann hingegangen? Vielleicht hat der Versuch, mit AVR32 eine eigene lizenzfreie 32-Bit Schiene zu fahren, zu viel Geld geschluckt.
Rennen. ;-) Das ist eine Frage der Anforderungen. Meine Spielwiese ist Automotive und da ist ein STM32 schon mal raus, egal wie sehr die Dinger gehyped werden. Ich suche schon ziemlich lange nach einer Alternative zu den AVR und habe dabei eher dezente Anforderungen. Es sollen nicht mehr als 64 Pins
-
Thread
Programmcode aus RAM ausführen
irrelevant. spielt dies keine Rolle. Wenn ehe schon Atmel-Tools vorhanden sind, wäre hier ein AVR32 keine schlechte Wahl.
ich vote auch für AVR32
-
Thread
AVRdude hängt beim flashen
Anhang an deine Beiträge anhängen. 2. In der Debugausgabe taucht jetzt als zu programmierender AVR ein *ATMEGA8* auf aber in deinem Makefile ist als Target ein *ATMEGA32* (siehe auch 1. Beitrag: Device signature = 0x1e9502) eingetragen. Ein für Atmega32 übersetztes Programm läuft i.d.R. auf dem Atmega8
I [49] avrdude: Recv: S [53] avrdude: Recv: P [50] avrdude: Recv: _ [5f] avrdude: Recv: 2 [32] avrdude: Recv: t [74] avrdude: stk500v2_getsync(): found AVRISP programmer AVR Part : ATMEGA32 Chip Erase delay : 9000 us PAGEL
-
Thread
STM32 Einstieg
Wenn ich die größten AVR Modelle (Xmega) mit den mittleren STM32 vergleiche, kommen sie mir gleich komplex vor. Die AVR sind aber 5x so teuer und nicht so einfach als steckbares Modul erhältlich.
alleine schrieb im Beitrag #6071986: > Du mußt schon genauer lesen. > Bei "die AVR" gehört ein ATmega dazu. Das gleiche gilt auch für "die STM32". Es gibt eine breite Palette von einfachen bis komplexen AVR Modellen. Ebenso sieht es bei STM32 aus. "die STM32" als für Anfänger zu
-
Thread
AVR-Studio Obsolet?
Visual-Krams nutzen musste, naja, da war wohl viel Politik dabei. Insbesondere Nicht-Windows-Nutzer von AVR hatten bis zuletzt ja auf Eclipse gehofft, das ja durchaus mal zur Auswahl stand (die eher linuxlastige AVR32-Truppe hatte es dafür schon eine Weile in Verwendung), und es gab auf avrfreaks einen
Atmel Studio V7 und MPLABX sind in meiner Umwelt mit Abstand die langsamsten. Auch mit i7 und X64/32Gb Ich hätte da eine Frage: Ab und zu kommt es vor, daß ich nur einen Bootloader via SPI auf einen AVR flashen möchte. Dazu nehme ich immer AVR-Studio 4.19. Geht ruck-zuck. Wenn ich dasselbe
-
Thread
Kein Zugriff zum Programmer mit AVRDUDE unter Wine (Ubuntu 22.04)
LunaAVR + AVRDUDE + Pololu Programmer 2.1 funktionieren auf einem 32-bit Linux ohne Probleme. Für Ubuntu 22.04 gibt es leider keine 32-bit Architektur mehr. Daher habe ich LunaAVR + AVRDUDE unter Wine installiert
Tim 🔆 schrieb im Beitrag #7513087: > LunaAVR ist das eigentliche Problem, das funktioniert nicht auf 64-bit. 64-Bit Linux kann 32-Bit-Programme ausführen. Du musst nur die Bibliotheken, die das 32-Bit-Programm braucht, auch in einer 32-Bit-Version
-
Thread
STM32 Chips zur Zeit so gut wie nicht beschaffbar
mcu-32-bit-64mhz-lqfp-64/dp/3652236 Ich hatte mir ein Evalboard mit einem STM32F411RE gekauft, aber da ist die Lieferzeit noch länger (und die M0+ wären mir sogar lieber).
9200 128kb STM32F103 sind noch verfügbar und ich brauche die, weil ich meine 64kb grad gesprengt habe :-( Aber die sind wohl aus Gold :-(((
-
Thread
Atemega328p - schaffst du das?
@ avrFanBoy 8-) (Gast) >> Timer2 läuft mit Prescaler=64 / OCR2A=36 (-1 natürlich) und feuert >> alle 248.785us >Warum eigentlich? Ist das dann ein Takt abgezogen um in nächsten Takt >dann die
@avrFanBoy 8-) (Gast) >> Hmmm. Vielleicht reicht ja die Hälfte, muss man testen. Oder man nimmt >> einen ATXmega, die laufen auch bei 3,3V bis 32 MHz. >genau, ist die Frage. Aber dann ist es nicht
-
Thread
Index von Array: welcher Datentyp in C
, der native > "zur Maschine passt" und damit effizient ist (von kleinen Architekturen > wie dem AVR abgesehen, bei denen ein "int" zwei Byte benutzt). … und abgesehen von großen Architekturen, wo die native Breite 64 Bit ist und int nur 32 Bit. Wilhelm M. schrieb im Beitrag #7455231: > Arduino
include <stdint.h> int foo_char(int array[], char index) { return array[index]; } int foo_i32(int array[], int index) { return array[index]; } int foo_u32(int array[], unsigned index) { return array[index]; } int foo_i64(int array[], int64_t index) { return array[index]; } int foo_u64
-
Thread
warum __inline zwingend erforderlich?
Resourcen ausgehen, z.B. Stack? habe ich auch vermutet. Habe dann meine Tabelle die 18 von den 32Byte RAM frisst ins Flash gemapt. [c] static const __flash uint8_t Wave_Tab[18] = {1,2,4,8,16,32,64,128,255,128,64,32,16,8,4,2,1,0}; [/c] Und schon ein neues Problem, ich bekomme beim Compilieren
Jetzt funktionierts! :-) [c] #include <avr/pgmspace.h> * * * const uint8_t PROGMEM Wave_Tab[18] = {1,2,4,8,16,32,64,128,255,128,64,32,16,8,4,2,1,0}; * * * Helligkeit = pgm_read_byte(&Wave_Tab[n]); * * * [/c] __inline ist nicht
-
Thread
AVR32 AT32UC3C0512C Bootloader Frequenz
to be stable*/ while((AVR32_PM.poscsr & AVR32_PM_POSCSR_OSC0RDY_MASK)== 0); //AVR32_PM_POSCSR_OSC0RDY_MASK = 0x00000080 /*5- PLL 0 konfigurieren*/ AVR32_PM.pll[0] = 0 << AVR32_PM_PLLOSC_OFFSET | // Oscillator
fPLL = fvco / Wide Bandwidth Mode disabled /*6- Clock Select und PBB-PBA-CPU-HSB Division*/ AVR32_PM.cksel = 0x80808080; /*7- PLL starten*/ AVR32_PM.pll[0] |= AVR32_PM_PLLEN_MASK; // PLL enable /*8- Wait for pll to be stable*/ while(!(AVR32_PM.poscsr & AVR32_
-
Thread
arduino esp32 32bit/64bit-problem
Joachim B. schrieb im Beitrag #6918132: > aber unter 32&64 bit nur die 1.8.9 1.8.16 geht definitiv mit Win7-32bit
grundschüler schrieb im Beitrag #6916060: > Frage: > geht esp32 nur mit 64-bit Arduino oder habe ich was falsch gemacht? > > ich verwendete arduino-1.8.16-windows.exe- Müsste eigentlich 32-bit > sein. funktioniert doch mit windows 7x64 und windows 10/32bit
-
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
grasshopper Atmel buildroot 2.3.0 kompilieren avr32.ext2 make error 1
-linux-uclibc-ldconfig && /home/klemmi/grasshopper/buildroot-avr32-v2.3.0_patched_grasshopper/build_avr32/staging_dir/sbin/avr32-linux-uclibc-ldconfig -r /home/klemmi/grasshopper/buildroot-avr32-v2.3.0_patched_grasshopper/project_build_avr32/grasshopper/root 2>/dev
aussehen: [pre] root@grasshopper:/tmp# mount / -o remount,ro root@grasshopper:/tmp# dd if=rootfs.avr32.ext2 of=/dev/mtdblock2 bs=64k [/pre] Gruß Udo
-
Thread
Pointer auf Array
den er zeigt. Zeiger sind systemgegeben immer gleich lang (je nach CPU bzw. Programmiermodell 16, 32 oder 64 Bit), egal auf welchen Datentyp sie zeigen. Deshalb ist bei der Deklaration nur die Länge des Zieldatentyps interessant, aber nicht die Länge des Zeigers selbst. Zur Veranschaulichung kannst
aufgefallen. zumal es hier glaube um einen AVR ging ... und es nur ein einfacher zeiger im RAM war es ging um uint8_t* , uint16_t* , uint32_t* ... sonderfälle beim AVR sind die __flash The __flash qualifier locates data in the
-
Thread
Raspberry Pi 3 Model A+ verfügbar
im 32bit Modus deutlich schneller, als im 64bit Modus.
> im 32bit Modus deutlich schneller, als im 64bit Modus. Windows 7? Das schaltete unter 32 bit einige Grafik-Efekte aus. Falk B. schrieb im Beitrag #5624409: > Ja eben. In der Hand eines Noobs mit lausigem
-
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
Atmel AVR in der Industrie
mitspielt... Da wurd ich aufpassen. Atmel hat viel ueber quality gelernt seit sie auch automotive avr anbieten, deswegen nutze ich auch den Avr32 da dieser automotive qual hat.. Den kleinen mehrpreis bezahle ich gern und weiss dass die dann auch so gut wie nicht ausfallen werden. Die Can Implementierung bei 32bit avr ist ein Traum zum Vergleich stm32f103....
-
Thread
STM32 Shift operationen
des Makros auf >32 Bit (bei int = 32 Bit) hier auch zu Fehlern führen - tut es aber nicht! Ich behaupte mal, daß das BITNR-Makro unverändert auch bei C-Compilern füt AVR und sogar PIC12 funktioniert.
(außerhalb des Bereichs)? Sollte int aber 64Bit sein, fehlen jedenfalls 32 Fälle...
-
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
STM32 Arduino
: > Im folgenden wird exakt der gleiche FFT-Code von hier Ob Dein "exakt" auch zutrifft? Beim AVR wird mit float (32 Bit) gerechnet und beim F103 vermutlich mit double (64 Bit).
Gerade gefunden: Benchmarks AVR gegen STM32F103 http://www.stm32duino.com/viewtopic.php?f=3&t=76 Der erste Test kommt beim Dhrystone Benchmark auf einen Faktor von ~6
-
Thread
STM32F103 GPIO
Größenordnungen einfacher, um gerade mal einen Pin zu setzen. > ganz ohne Bank-Umschaltung (wie bei AVR's mit > 64 KiB > Speicher), Wer braucht schon soviel bei typischen 8-Bit Programmen... Und ja, bei größerem Speicherbedarf ist 32Bit ARM im Vorteil und anzuraten, hat ja gar keiner bestritten.
komplexen ARM-Meer ;-) > Achja, von wegen Einfachheit: Programmiere mal diese C-Funktion in > AVR-Assembler:uint32_t shift (uint32_t x, uint32_t y) { > return x << y; > } > > Im ARMv7M-Assembler sieht's so aus:shift: > lsl r0, r1 > bx lr > Na, ists auf dem AVR auch so einfach? Und
-
Thread
Ersatz für PonyProg unter Vista 64bit?
Das AVR Studio wird doch von Windos Vista 64 garnicht unterstützt.
is established. To add USB support for Windows XP 64, AVR Studio 4.13 must be uninstalled and reinstalled with USB option enabled. Windows Vista 64: USB is not supported on Windows Vista 64
-
Thread
Suche MOPPEL Projekt in Heft oder .PDF
moin, moin, kurzer Zwischenstand: Die AVR-Seite mit dem FAT16-Dateisystem funktioniert jetzt. Lösung: 1GB-Speicherkarte - warum das Ganze mit den kleinen Karten (4, 32, 512MB) nicht funktioniert ist mir schleierhaft. Egal - so kleine
Übertragung von einzelnen Bytes, sowie das Empfangen einer Zeile bis CR eintrifft. Daten werden im AVR und Moppel über ein Buffer (64Byte) ausgetauscht. Damit kann dann der Hexlader mit 38kb Daten empfangen. Die Senderoutine ist noch in der Testphase... Der Rest vom PIO-Baustein kann nun als 8bit
-
Thread
Suche schnellen µC
AVR32 ?
".... ist das nicht das selbe (sagt Simon Huwyler). Im Moment sind also PIC32 AVR32 und Cortex-M/STM32 im Spiel. Ist das jetzt nur noch Geschmackssache, oder gibts gute Gründe für den einen oder anderen?
-
Thread
Kommerzieller AVR C Compiler
ich nichts sagen. Wenn Du Lust hast, dann mach doch beim LLVM AVR-backend mit!
jammern? Das wäre /ganz erheblicher Aufwand/. Bedenke, daß der gcc in erster Linie ein Compiler für 32-Bit- oder noch größere Systeme ist, den einige Leute mit viel Aufwand so weit aufgebohrt haben, daß er auch brauchbaren Code für 8-Bit-Architekturen wie den AVR erzeugen kann. Das jetzt noch um "
-
Thread
Einen Softcore (AVR) an andere FPGA anpassen?
Dokumentation auf englisch zum FPGA und der Software ist da, allerdings mühsam zusammengestellt. Ich habe 64x9k und 16x32k Block RAM und 19600 LUT zur Verfühgung. Einen LCD Controller àla SSD1351 für einen 8bit AVR (6800-series Interface) hab ich schon erfolgreich in den FPGA gebaut und eingepflanzt. Dazu
8 Bitter auf FPGA...naja. AVR benötigt wohl ähnlich viele Resourcen wie ein 8051 Core, und damit immer noch mehr als ein schmaler RISC-V. Der NEORV32 ist mir etwas zu überdosiert und die Pipeline-Architektur etwas eigenwillig.
-
Thread
AVR: größe der Variablen
Sebastian T. schrieb im Beitrag #5758126: > Darf man aber auf einem 8bit AVR einfach größere Variablen wie z.B. > uint16_t, uint32_t oder gar uint64_t benutzen?? Das ist eine Frage des Compilers, nicht des AVR: du kannst benutzen was immer der Compiler zulässt, der muss
Sebastian T. schrieb im Beitrag #5758126: > Darf man aber auf einem 8bit AVR einfach größere Variablen wie z.B. > uint16_t, uint32_t oder gar uint64_t benutzen?? Du darfst sogar float und double benutzen, obwohl der AVR keine FPU hat. Beides ist auf dem AVR-GCC 4 Byte groß
-
Thread
AVR32: undefined reference to `__avr32_udiv64'
[code]Linking to `uc3a1256-sample.elf'. system.o: In function `cpu_is_timeout': /home/jd/work/at32uc3/DRIVERS/CPU/CYCLE_COUNTER/cycle_counter.h:184: undefined reference to `__avr32_udiv64' /home/jd/work/at32uc3/DRIVERS/CPU/CYCLE_COUNTER/cycle_counter.h:184: undefined reference to `__avr32_udiv64'
Delays werden temporäre Variablen vom Typ "unsigned long long" benutzt. Welche Library stellt `__avr32_udiv64' zur Verfügung? Ich habe mit find und nm nach diesem Symbol geGREPt, aber es ist überall nur als "undefined" aufgelistet. Das Hinzulinken mit -lm -lc usw. bringt leider nichts. Ich hatte
-
Thread
PWM auf ATmega328p Timer0 nicht so wie erwartet.
Counter stopped). 0 0 1 clk T2S /(No prescaling) 0 1 0 clk T2S /8 (From prescaler) 0 1 1 clk T2S /32 (From prescaler) 1 0 0 clk T2S /64 (From prescaler) 1 0 1 clk T2S /128 (From prescaler) 1 1 0 clk T 2 S /256 (From prescaler) 1 1 1 clk T 2 S /1024 (From prescaler) > was da heißt: 5 entspricht
jedem selbst überlassen bleiben. Im Laufe meines Berufslebens hatte ich mit MCS-51, PIC16F, MSP430, AVR, STM32F und STM8F zu tun (lustigerweise dienstlich noch nie NXP). Hier habe ich es mir sehr zur Angewohnheit gemacht, eine API (auch wenn die Hardware sehr unterschiedlich ist) so ähnlich wie nur möglich
-
Thread
große Zahl (lomg long) und trotzdem genau ?
s32; typedef signed long long s64; typedef unsigned char u08; typedef unsigned int u16; typedef unsigned long u32; typedef unsigned long long u64; void SPI_set_dds(u32 f_dds)
// multiplicator to ensure enough bit accuracy { union {u64 reg; u08 byte[8];} freq; // for easy u64 byte access freq.reg = (f_dds * (DDS_MPL/DDS_SYS_CLK)); // 32 x 32 Bit => 64 Bit multiplication PORTB &= ~(1<<CS_DDS); // set
-
Thread
µC für "Anfänger"
das kann die neueren PICs nicht mehr. Ich empfehle übrigens für den Anfang einen PIC24 (zB PIC24FJ64GA002), aber das bleibt Dir überlassen - das PicKIT3 kann alle aktuellen 8-, 16- und 32-Bit PICs programmieren. fchk
böse was die Versorgung angeht und ein Steckbrett-Kontakt kann da schon zu viel "im Weg" sein. Ein AVR mit internem Oszi ist noch relativ zuverlässig zu betreiben, aber spätestens wenn man einen genaueren Takt will gehts los mit Pfuschen (und ein 32-Bit ARM ist da noch schlimmer). Deswegen Arduino-Nano
-
Thread
Wie 300 PWM ausgänge?
Paar billige STM32, kosten doch nichts.
64 Kanäle bequem mit einem Mega48 aber auch noch ausbaufähig http://www.mino-elektronik.de/AVR_PWM_64/AVR_PWM_64.htm
-
Thread
Can-Controller/µC
André M. schrieb im Beitrag #4259365: > Der Wechsel von der 68000 Familie auf AVR war schon eine gewaltige > Umstellung für mich. .... Die kleinsten 8-Bit AVR mit CAN die mir jetzt in den Sinn kommen sind ATMega16M1, ATMega32M1 und ATMega64M1, die gibt es in TQFP-32. Je nach
dann kein Spaß ist, wirds ernst ;) Daniel H. schrieb im Beitrag #4259392: > Die kleinsten 8-Bit AVR mit CAN die mir jetzt in den Sinn kommen sind > ATMega16M1, ATMega32M1 und ATMega64M1, Ich hab grad mal schnell oberflächlich bei Atmel geschaut. Wenn ich CAN auswähle wird mit kein Atmega angezeigt
-
Thread
Atmel ist unter "Profis" nicht gerade beliebt - Warum?
eine Stelle. ;-) Indirekt schon, wenn du den Begriff des AVR-GCC etwas weiter fasst. Eric Weddington ist seit einiger Zeit bei Atmel angestellt und hat nunmehr damit die dienstliche Aufgabe, WinAVR zu betreuen. Für den AVR32 ist das anders, dort ist die
fällt. Als Bastler ist die Auswahl deutlich eingeschränkter! Persönlich bin mal gespannt wie der AVR32 sich behaupten kann...
-
Thread
Zeigt her eure Kunstwerke (2) Gesperrt Bilder
die einzelnen Menüs (=Räume) gescrollt werden kann und Temperaturen eingestellt werden können. - 64x128 OLED - RFM70 zur Kommunikation mit dem Webserver - STM32F103 - 100mAh LiPo Akku
nun ja aber mit dem Adapter habe ich 17 Euro gespart http://www.ebay.de/itm/Flap-QFP32-TQFP32-PQFP32-TO-DIP32-Programmer-Socket-Adapter-Conveter-IC51-D0090-/130834643503
-
Thread
eigenes Z80 Mainboard - geht das so?
Peripherie könnte übrigens Konflikte mit deiner IRQ Vektor Logik geben, check das nochmal. Bei meinem TMS32C025 Projekt fungiert auch ein AVR als Board Controller, ich habe allerdings einem Mega32 genommen und mich für paralleles Schreiben und Lesen des RAM entschlossen, damit es ein wenig schneller geht.
aufstocken, ich habe das Zeuch mal Tütenweise geerbt.. > >> Bei meinem TMS32C025 Projekt fungiert auch ein AVR als Board Controller, >> ich habe allerdings einem Mega32 genommen und mich für paralleles >> Schreiben und Lesen des RAM entschlossen, damit es ein wenig schneller
-
Thread
AVR128DA64 TCA1 funktioniert nicht mit alternativen Output?
/Errata/AVR128DA-28-32-48-64-SilConErrataClarif-DS80000882.pdf
Zukunft müsste ich da auf jeden > Fall was ändern. Man könnte natürlich auch gleich z.B. zu STM32 greifen, sofern man nicht auf 5V als VCC angewiesen ist, denn der Lötaufwand bei LQFP64 mit 0,5mm Raster ist dann quasi gleich – selbst ein STM32F030RC müsste dem Anwender mehr als ein AVR128 bieten,
-
Thread
Speicher AT90CAN128
lies dir dochmal die doku zum avr-gcc durch: http://www.nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html
echt nicht drum herum..) http://www.atmel.com/Images/doc7679.pdf da steht sowas drinnen wie: * 32K/64K/128K Bytes of In-System Reprogrammable Flash (AT90CAN32/64/128) * 1K/2K/4K Bytes EEPROM (Endurance: 100,000 Write/Erase Cycles) (AT90CAN32/64/128) jetzt kannst du mal raten wieso es mitm eeprom
-
Thread
Verständnisfrage zu Assembler bei PIC und ATMEL
vorbildliche) Doku von Microchip zum PIC hatte verwöhnt. Danach sollte ich mal eine kurze Arbeit mit einem AVR32 machen. katastrophe. Doku/Referenzhandbuch des Kerns passt(e) überhaupt nicht zum von AVR bereitgestellten Framework und die Kommunity trug die Nase in den Wolken. Danke, nie wieder.
bessere Idee, wie du mit einem 8Bit Arbeitsregister > 1023 Adressen nutzen kannst? Z.B. 8051 oder AVR zeigen Dir, wie man 64kB Daten + 64kB Code linear adressieren kann. https://de.wikipedia.org/wiki/Intel_MCS-51 Es gab auch mal 8051 mit >64kB Code (AT89C51RE2: 128kB Flash). Leider ist die Fabrik