-
Thread
AVR64DD32, UART-Ausgabe bleibt hängen, Assembler
wenige Ausnahmen. Sorry, aber du bist nicht mehr auf dem aktuellen Stand. Siehe Datenblatt des AVR64DD32, S. 134; dort wird es in Satz 2 sehr deutlich: "15.3.2.4 Interrupt Priority AVR64DD32/28 CPUINT - CPU Interrupt Controller All interrupt vectors are assigned to one of three possible priority
avrasm] erfolgen. PS: Beim ATmega328 hebt sich der Fehler heraus (in gewissen Grenzen), aber beim AVR64DD32 (mit seiner hohen SRAM-Startadresse) nicht.
-
Thread
AVR64DD32: TCA-Overflow-Interrupt deaktiviert RTC
Hi, ich nutze erfoglreich bei einem AVR64DD28 den RTC und TCA im Interruptmodus (RTC für Interrupt alle 1 Sekunde, und den TCA alle 50ms) - siehe auch https://www.mikrocontroller.net/topic/562401 Wenn ich das selbe beim AVR64DD32 versuche
(apropos: da fehlt '-1'). Die Hex-Dateien müssen gleich sein, also vielleicht auch mal die des AVR64DD32 direkt auf den 28 übertragen (und umgekehrt).
-
Bild
AVR64DU32 Curiosity Nano User Guide mit Evaluation Kit
AVR64DU32 Curiosity Nano User Guide AVR64DU32 Curiosity Nano Preface The AVR64DU32 Curiosity Nano evaluation kit (EV59F82A) is a hardware platform to evaluate the AVR DU family microcontrollers. This board has the AVR64DU32 microcontroller (MCU) mounted. The Curiosity Nano series of evaluation boards include an on-board debugger. No external tools are necessary to program and debug the AVR64DU32. MICROCHIP AVR USB
-
Thread
[V] AVR64DD32- und AVR16EB32-Experimentierboards
Hallo, je drei Stück folgender teilbestückter AVR-Experimentierboards stehen zum Verkauf: * (1) AVR64DD32, 50×50 mm², 4-Layer, sämtliche IOs auf Stiftleisten geführt. * (2) AVR16EB32 + 4-Digit-7-Segment-Anzeige, 80×100 mm², 2-Layer, IR-Sender
Zwei von den AVR64DD32-Boards sind nun verkauft, eines ist noch verfügbar.
-
Thread
IRMP - Infrared Multi Protocol Decoder
der irsndconfig noch eingetragen werden, da auch hier die Pins nicht stimmen: [c] #if defined (__AVR_ATmega32__) || defined (__AVR_ATmega644P__) || defined (__AVR_ATmega324P__) // usw. [/c] Vielen Dank für dieses schöne Projekt!!! Grüße, Peter
irsndconfig noch eingetragen werden, da auch hier > die Pins nicht stimmen: > [c] > #if defined (__AVR_ATmega32__) || defined (__AVR_ATmega644P__) || > defined (__AVR_ATmega324P__) > // usw. > [/c] Danke, habe ich so übernommen, kommt ins nächste Release. > Vielen Dank für dieses schöne Projekt
-
Thread
UART Bootloader ATtiny13 - ATmega644
time: 0.00 seconds C:\AVR>FBOOT.EXE /PC:\AVR\LED_mega32.hex COM 1 at 115200 Baud: Connected Bootloader V1.4 Target: 1E9502 ATmega32 Buffer: 1792 Byte Size available: 32256 Byte File C:\AVR\LED_mega32.hex open failed !
Assemblieren des Bootloaders folgender Fehler auf: D:\Bootloader>avrasm2 -fi bootload.asm AVRASM: AVR macro assembler 2.1.42 (build 1796 Sep 15 2009 10:48:36) Copyright (C) 1995-2009 ATMEL Corporation bootload.asm(32): Including file 'C:\Program Files\Atmel\AVR Tools\AvrAssembler2 \Appnotes\m64def.inc
-
Thread
Schnelle FFT in Assembler
was spricht gegen einen externen speicher ? die kosten nichts ! und gibt es in 16..32..64kb..
Asselborn\mega32.asm(7): Including file 'C:\Programme\Atmel\AVR Tools\AvrAssembler2\Appnotes\m32def.inc' C:\Dokumente und Einstellungen\Matthias Asselborn\mega32.asm(8): Including file 'C:\Programme\Atmel\AVR Tools\
-
Thread
SSD1306/1309 Library zum Darstellen von Text auf OLED Displays
i am OK"); lcd_gotoxy(0,2); lcd_puts("12345678901234567890");[/c] Bei der Einstellung WIDHT 64, HEIGHT 32: Bild "64x32" kleines Display Bild "128x64_falsch" großes Display Bei der Einstellung WIDHT 128, HEIGHT 32: Bild "128x64_ok" großes Display
schon geschrieben, mein großes Display läuft ohne Probleme, mein Problem ist das kleine Display, das 64x32. Und da bekomme ich trotz WIDTH 64 und HEIGHT 32 keine vernünftige Anzeige, siehe Bild "64x32"
-
Thread
CP/M auf ATmega88
ab (8K), für CCP+BDOS, die von dort beim Warmstart neu geladen werden. Vom letzten Laufwerk gehen 64Kbyte ab. Schließlich bracht der Rechner ja auch etwas Arbeitsspeicher. ;-) Im AVR-Teil sind 32 Sektoren pro Spur und maximal 1 MByte pro Laufwerk fest vorgegeben. Die obersten 64K werden immer als
,dphd, , , , ,dphi> ; Name spt bls dks dir cks off ; dpb dpb243, 26, 1024, 243, 64, 64, 2 ; dpb dp8192s,32, 4096,2046, 512, 512, 2 dpb dp8192, 32, 4096,2046,1024,1024, 2 ; dpb dpbrd, 32, 1024, 56, 32, 0, 2 dpb rd192, 32, 1024, 192, 32, 0, 0 ; dpb rd1016
-
Thread
Welche 8-Bit-Architekturen werden in 10 Jahren relevant sein? Gesperrt
So schnell wird der Uebergang nach 32 bit nicht gehen. Meine persoenlichen Versuche resp Plaene sind bisher gescheitert. Da war mal ein AVR32, der mir gefallen haette, speziell die UC3 Familie davon, er ist aber gefloppt. Und nicht mehr
auch App-Hersteller auch zu 64-Bit-Kompatiblität. (prx) A. K. schrieb im Beitrag #7423913: > Schon mit Android 5 fing die Migration zu 64-System und 64-Bit Apps an. > Aber erst jetzt wird die Kompatibilität zu 32-Bit runtergefahren
-
Thread
LCD Controller für 640x480 LCD mit mega8515
Wieso hat ein 64kB SRAM eine A16 Leitung ? Hast du A15 vom AVR an CS gehängt ? Vermutlich ja. Es werden 64kB benötigt. A15 vom SRAM muss an A15 vom AVR. In den meisten Schaltplänen hängt A15 nur deshalb an CS\ weil 64kB relativ selten sind, und ich daher meist 2x 32kB verwende.
-
Thread
AVR-ChipBasic2 - BASIC-Computer mit ATMega 644
demonstriert (recht eindrucksvoll) was mit dem Basic-Computer machbar ist. [pre] 01 BO 0:P=0:GOS 64:DA 64,0,4,32,0 02 ALERT 64:X=AR(1):Y=AR(0):D=21 03 GOSUB 48:FOR F=1 TO 4:A=F*5 04 IF AR(A)<>AR(3) THEN GO 9 05 IF AR(A+1)<>AR(4) THEN GO 9 06 IF G>0 THEN NO 98:P=P+20:GO 35 07 ? @AR(3)+1,AR(4)+
IF N=2 THEN DA A+1,AR(A+1)-1 29 IF N=3 THEN DA A,AR(A)-1 30 DA A+2,N:NEXT 31 IF G>0 THEN G=G-1 32 COLOR 7,0:? @0,10;"Punkte:";P 33 SYNC 3: IF Q=1 THEN GO 35 34 GO 3 35 DA A,10,10:N=1:GO 31 36 GOSUB 64:DA 64,0,4,32,0:GOTO 2 37 Z=RND(3):IF Z=2 THEN Z=3 38 N=(M+Z)&3:RETURN 39 'check if figure
-
Thread
AVR64EA28: PIT-Interrupt
C-hater: Übrigens finde ich diese 'Note' zwar im Datenblatt des ATmega4809, aber weder in dem für AVR128DA28/32/48/64 noch im Preliminary für AVR64EA28/32/48; also eine simple Suche nach 'during device'.
Hallo, bei mir blinkt es auf einem AVR64EA32. Bei dir auf einem AVR32EA28, aber nicht auf einem AVR64EA28. Das mutet seltsam an. :-) Deine Toolchain ist aber soweit okay? Device Packs sind aktuell?
-
Thread
cannot read spec file 'device-specs/specs-atmega4808'
lib/avr5/atmega32u6 avr/lib/avr5/atmega406 avr/lib/avr5/atmega644rfr2 avr/lib/avr5/atmega64rfr2 avr/lib/avr5/atmega64 avr/lib/avr5/atmega64a avr/lib/avr5/atmega640 avr/lib/avr5/atmega644
-as... no > checking for i686-w64-mingw32-dlltool... no > checking for i686-w64-mingw32-ld... no > [...] > checking for avr-cc... no > checking for avr-gcc... no > checking for avr-c++... no Siehe Johann L. schrieb im Beitrag
-
Thread
Moderne AVR (Nachfolger Atmega und Attiny)
, AVR64DA48, AVR64DA64, AVR64DB28, AVR64DB32, AVR64DB48, AVR64DB64, AVR64DD14, AVR64DD20, AVR64DD28, AVR64DD32, AVR64DU28, AVR64DU32, AVR64EA28, AVR64EA32, AVR64EA48, AVR64SD28, AVR64SD32, AVR64SD48, AVR128DA28
per Kommandozeilen-Option auswählen: > > AVR64DA28, AVR64DA32, AVR64DA48, AVR64DA64, AVR64DB28, AVR64DB32, > AVR64DB48, AVR64DB64, AVR64DD14, AVR64DD20, AVR64DD28, AVR64DD32, > AVR64DU28, AVR64DU32, AVR64EA28, AVR64EA32, AVR64EA48, AVR64SD28
-
Thread
gcc11 könnte das avr Backend verlieren
GPUs arm - ARM arm64 - ARM64 (little endian) arm64_32 - ARM64 (little endian ILP32) armeb - ARM (big endian) avr - Atmel AVR Microcontroller bpf - BPF (host endian) bpfeb - BPF (big endian
32-bit nvptx64 - NVIDIA PTX 64-bit ppc32 - PowerPC 32 ppc64 - PowerPC 64 ppc64le - PowerPC 64 LE r600 - AMD GPUs HD2XXX-HD6XXX riscv32 - 32-bit RISC-V riscv64 - 64-bit
-
Thread
6502 Prozessor wer kennt den noch?
einem Mikroprozessor :) Hast Du das Board noch? Ich hatte mal was vergleichbares mit einem 8088, 32kB EPROM, 64kB SRAM, eine COM und zwei Ports für LEDs...
>Mir ist kein 32- oder 64-Bit Prozessor mit fester Befehlslänge bekannt, >der den gesamten Adressraum mit relativer Adressierung erfassen kann. (also RISC, weil feste Befehlslänge) Das kann norm.weise auch nicht gehen
-
Thread
AVR C Programmierung unter Linux
=64 avr3/long-double32;@mmcu=avr3@mlong-double=32 avr31/double64;@mmcu=avr31@mdouble=64 avr31/long-double32;@mmcu=avr31@mlong-double=32 avr35/double64;@mmcu=avr35@mdouble=64 avr35/long-double32;@mmcu=avr35@mlong-double=32 avr4/double64;@mmcu=avr4@mdouble=64 avr4/long-double32;@mmcu=avr4@mlong-double=32 avr5/double64;@mmcu=avr5@mdouble=64 avr5/long-double32;@mmcu=avr5@mlong-double=32 avr51/double64
-
Thread
Arm Cortex im DIP Gehäuse Gesperrt
MHz neben 32 Bit (float) auch 64 Bit (double) direkt unterstützt. Richtig edle Teile, kennt hier allerdings kein Schwein ;-)
bei Renesas: RX111 geht bis 512 kiB Flash, 64 kiB, USB, 12-Bit ADC, DAC, netter Befehlssatz u.a. 32x32->64 Multiplikation, Barrelshifter, RMPA (Repeated MultiPly and Accumulate mit 80-Bit-Ergebnis) Edith: Da oben der gute alte 68k und Assembler
-
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
-
Thread
STM32 für Einsteiger - der Artikel zum Krieg (µC Wahl)
ST32Anwender schrieb im Beitrag #3463819: Praktisch NUR Schwachsinn!!! > ATMEL (insbes. AVR und XMEGA) ist in größeren Firmen nicht gerne gesehen > Preis/Leistung ist bescheiden. STM32 mit 64kB
ST32Anwender schrieb im Beitrag #3463819: > ATMEL (insbes. AVR und XMEGA) ist in größeren Firmen nicht gerne gesehen > Preis/Leistung ist bescheiden. STM32 mit 64kB Flash gibt es zu 40% des > Preises eines
-
Thread
AVR-Bootloader mit Verschlüsselung
Passwortes. Sollten diese nicht identisch sein so wurde entweder mit falschem Passwort verschlüsselt, der AVR benutzt ein falsches Passwort zur Entschlüsselung, der Datenstrom wurde falsch übertragen (wir nutzten extern nur eine 16 Bit CRC) mit dem XTEA nutzen wir eine 64 Bit CRC die aber auf 32Bit truncated
m3250P m325A m325 m325PA m325P m328 m328PB m328P m3290A m3290 m3290PA m3290P m329A m329 m329PA m329P m32A m32C1 m32 m32HVB m32M1 m32U2 m32U4 m406 m48A m48 m48PA m48P m640 m644A m644 m644PA m644P m6450A m6450 m6450P m645A m645 m645P m6490A m6490 m6490P m649A m649 m649P m64A m64C1 m64 m64M1 m64RFR2 m8515
-
Thread
Toochain bauen avr-gcc-x.x mit binutils-2.34 funktioniert nicht
/avr5/at90can32 avr/lib/avr5/at90can64 avr/lib/avr5/at90pwm216 avr/lib/avr5/at90pwm316 avr/lib/avr5/at90pwm161 avr/lib/avr5/at90scr100 avr/lib/avr5/at90usb646 avr/lib/avr5/at90usb647
/lib/avr5/atmega32u4 avr/lib/avr5/atmega32u6 avr/lib/avr5/atmega406 avr/lib/avr5/atmega644rfr2 avr/lib/avr5/atmega64rfr2 avr/lib/avr5/atmega64 avr/lib/avr5/atmega64a avr/lib/avr5/atmega640
-
Thread
MMC/SD-Karte mit FAT16 an AVR
32Bit-Operationen benötigt. Ich vermute, das es auf einem MSP430, ARM oder auch AVR32 wesentlich besser liefe. Werde es auch mal mit größeren Blockgrößen versuchen. Im Moment lese ich ja immer nur 8Byte
Alles hat seinen Preis. Nun mache ich mir Sorgen ob das auch in einen M644 noch rein paßt. Einen M32 mußte ich schnell ersetzen. Der hat zwar noch für den reinen SD-Reader gereicht aber nicht mehr für Erweiterungen. > Vielleicht komme ich ja noch dazu einen Patch für 32 oder 64k zu machen. > 64k
-
Thread
Wettkampf Opa(MOS6502) gegen Frischling(ATmega)
Mikroprozessor (der originale MOS6502 > ca.1976) schneller arbeiten als ein deutlich modernerer AVR ATmega32u4 Eigentlich: nein, der ATmega macht das ca. 100 x schneller. Aber wenn dein 6502 über 64k RAM verfügen kann, kann er den ATmega, der wenig RAM hat, schlagen.
🍅🍅 🍅. schrieb im Beitrag #7863423: > Schätzung: > AVR32: > 4x schneller wegen 32bit > 16x schneller wegen Mhz > 3x schneller wegen IPC Der AVR32U4 ist ein 8 Bitter mit 32kB Flash und USB ;-) Es gab einen AVR32, der ist aber im Strom der Zeit versunken
-
Thread
Grasshopper Inbetriebnahme
avr32-linux-uclibc-cc avr32-linux-c++filt avr32-linux-uclibc-c++filt avr32-linux-cpp avr32-linux-uclibc-cpp avr32-linux-depmod26 avr32-linux-uclibc-gcc
avr32-linux-uclibc-objdump avr32-linux-nm avr32-linux-uclibc-ranlib avr32-linux-objcopy avr32-linux-uclibc-readelf avr32-linux-objdump avr32-linux-uclibc-size
-
Thread
64 Bit float Emulator in C, IEEE754 compatibel
--with-double64 | -- | 32 | 32 | 32 | -mdouble64 | 32 | 64 | 64 [/pre] Eine Einschränkung auf Devices mit MUL gibt es nicht mehr: Beim
mal in die Tools integriert (für Windos): https://sourceforge.net/projects/mobilechessboar/files/avr-gcc%20snapshots%20%28Win32%29/avr-gcc-10.0.0_2019-12-16_-mingw32.zip/download Hat neue Optionen: -mlong-double=32/64 (default: 64) -mdouble=32/64 (default: 32)
-
Thread
was spricht eigentlich gegen die xmega? Gesperrt
und 4KB RAM + EEPROM: atxmega64a3u : Mouser 3,49€ atxmega64d3 : Mouser 2,90€ bei STM32 sieht das so aus, die haben 8KB RAM: STM32F030R8 : Mouser 1,77€ + 24LC32 EEPROM 0,30€ = 2,07€ STM32L100R8 : Mouser 2,89€ (Incl. EEPROM)
weil ein CortexM wohl zuviel strom verbraucht, deswegen setzen Microsoft in seinen Surface Pro einen 32Bit AVR ein, und in Samsung Tablets steckt ebenfalls ein 32Bit AVR. schon komisch obwohl Atmel auch einen SAMD20 gehabt hätte aber anscheinend ist ein ARM core nicht so effizient wie ein AVR32. Da hilft
-
Thread
AVR für wenig Geld im LAN
Fehlermeldung: Build started 3.10.2008 at 12:33:09 avr-gcc.exe -mmcu=atmega32 -Wall -gdwarf-2 -std=gnu99 -DF_CPU=16000000UL -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -MD -MP -MT base64.o -MF dep/base64.o.d -c ../base64.
an AVR-NET-IO senden. z.B Atmeg32 sendet 64 Byte an AVR-NET-IO und diese werden dann im Browser angezeigt. Auch für kleine Aplikationen mit AVR wäre diese Funktion sinnvoll. AVR-NET-IO läuft bei mir mit
-
Thread
Welche AVR (Atmega) haben UPDI?
| 32 Pin | 48 Pin | 64 Pin ___________|____________|____________|_____________ AVR32DA28 | AVR32DA32 | AVR32DA48 | AVR64DA28 | AVR64DA32 | AVR64DA48 | AVR64DA64 AVR128DA28 | AVR128DA32
| AVR32DD32 AVR64DD14 | AVR64DD20 | AVR64DD28 | AVR64DD32 [/code]
-
Thread
MMC/SD Bootloader füt ATMega16
und muss sagen, dass wäre genau das richtige als Erweiterung für das MMC2IEC-Projekt bei dem ein Mega32 mit SD-Karte als C64-Diskettenlaufwerk benutzt wird. Ich habe noch nie Bootloader mit den AVR's benutzt. Daher habe ich da mal ein paar Fragen. Erstmal, wie sieht das aus, die Rede war hier nur
TU karl.M. but where is fusebits in bootloder ? Am i neede to chang it for other MC like atmega32 or 64 ?
-
Thread
ARM-Cortex als Anfänger?
Nachdem ich einige Erfahrung mit AVR Mikrocontrollern hinter mir habe, probiere ich gerade einen STM32F103rB aus - in Form eines Nucleo-64 Boardes. Für geübte Programmierer mag der Chip und die Software kein Problem sein. Aber ich tu
du schreibst über ein ganz anderes Produkt als ich. Also, ich schreibe zum Beispiel über "MKE02P64M40SF0RM.pdf", das ist das RefManual zu den MKE02Z16VLC4, MKE02Z32VLC4, MKE02Z64VLC4, MKE02Z16VLD4, MKE02Z32VLD4, MKE02Z64VLD4, MKE02Z32VLH4, MKE02Z64VLH4, MKE02Z32VQH4, MKE02Z64VQH4, MKE02Z16VFM4, MKE02Z32VFM4
-
Thread
Hat hier schon mal jemand einen WinXP-Treiber nach Win7/64 konvertiert?
ich vorliegen. Grundsätzlich laufen 32bit-Anwendungen ja auch in win7/64 mit WOW64.
es 64-Bit Windows gibt parallel 32-Bit und 64-Bit Treiber für die entsprechenden Geräte ausgeliefert? Wenn es anders möglich wäre unter 64-Bit Windows einen 32-Bit Treiber zu verwenden hätte man das längst
-
Thread
Logamatic 2107 Schnittstelle
} 16:20:32 15.07.10: 10 21 AC 00 00 00 00 1A {--} 16:20:32 15.07.10: 10 {BA} 16:20:32 15.07.10: 08 00 18 00 5A 02 C1 64 64 0A 10 E5 60 80 00 02 0C 02 72 00 84 0F 3D 48 00 C9 FF 03 00 BA {--} 16:20:32 15.07.10
:32 15.07.10: 10 {2F} 16:20:32 15.07.10: 08 00 18 00 5A 02 C3 64 64 0A 10 E5 60 80 00 02 0C 02 73 00 82 0F 3D 48 00 C9 FF 03 00 2F {--} 16:20:32 15.07.10: A1 {--} 16:20:32 15.07.10: 21 21 [/code]
-
Thread
Division 64Bit durch 32Bit gesucht
Geschätztes Forum, ein 64Bit Zahl, soll durch eine 32Bit Zahl In Assembler z.B. ATmega8 dividiert werden. Siehe 32Bit Division: https://www.mikrocontroller.net/articles/AVR_Arithmetik#32_Bit_.2F_32_Bit Kann jemand helfen
im Beitrag #6661532: > Ein ATmega328P (und natürlich ein ATmega1284P u.v.a. ebenso) schafft > DIV64/32 mit 64 Bit Ergebnis und 32 Bit Rest (besser und genauer geht es > nicht) mit dem von mir oben aufgelisteten, sehr geradlinigen > AVR-Assembler-Unterprogramm (nur 60 Bytes Programmspeicher) in ca
-
Thread
Was benötige ich um einen 8086 in Assembbler zu programmieren ?
Hardcorebastler interessant: > https://de.wikipedia.org/wiki/MenuetOS Naja, das läuft nur ab 80386 aufwärts (32 Bit), entwickelt wird gar nur noch mit 64 Bit Prozessoren (AMD64). Für 8086 könnte das alte Minix (1.x) taugen oder ELKS: https://de.wikipedia.org/wiki/Embeddable_Linux_Kernel_Subset
AVR hat 32 privilegierte Register, die man möglicherweise als Akkus ansprechen könnte. Bei den alten IBMs bin ich mir nicht sicher, ob es erforderlich war, in einen Akku zu rechnen, wenn der gelesene
-
Thread
AVR Synthesizer mit ATxmega128A1
Hallo, kannst Du bitte mal den kompletten code posten? Ich möchte das auf einem AVR32 testen. Viele Grüße
Hallo Rolf, vielen Dank, ich versuche mich jetzt daran den code auf dem AVR32 zum laufen zu kriegen. Viele Grüße
-
Thread
Verständnisproblem in AVR C Syntax Gesperrt
einem AVR 8 Bit, auf einem MSP430 16Bit und auf ARM 32 Bit. Ganz anders sieht es aus wenn man Strukturen definiert. Hier sollte man mit "[u]int_least_[8|16|32|64]_t" arbeiten. Man gibt dem Compiler damit auch
umzuschreiben zu #define int8_t #define uint8_t #define int16_t #define uint16_t #define int32_t #define uint32_t #define int64_t #define uint64_t das macht es definitiv Plattform unabhängiger, schliesslich laufen meine alten C-Routinen auch immer noch auf dem AVR > Sollte in jedem
-
Thread
Rust - ist das hier um zu bleiben?
_64-unknown-cloudabi x86_64-unknown-freebsd x86_64-unknown-linux-gnu (default) x86_64-unknown-linux-gnux32 x86_64-unknown-linux-musl x86_64-unknown-netbsd x86_64-unknown-redox [/pre] AVR soll auch
mismatched types --> src/main.rs:4:17 | 4 | let z = x + y; | ^ expected `i32`, found `i64` error[E0277]: cannot add `i64` to `i32` --> src/main.rs:4:15 | 4 | let z = x + y; | ^ no implementation for `i32 + i64` | = help: the trait `Add<i64>
-
Thread
Nachfolger für ATMega gesucht
ATSAMC21 wenn es 5V sein soll mit CAN-FD. Bis 256k Flash, 32/48/64/100 Pins, Cortex M0+ 48MHz. Oder in 3,3V dafür bis 1MB Flash, bis 128 Pins, Cortex M4F 120MHz: ATSAME51. Edit: die gerne gehypten STM32 gibt es erst ab H7 mit CAN-FD, die kleinste von den
wesentlich eine nette Diskussion war und kein Glaubenskrieg ;) Resumee Vorschläge als Nachfolger der AVR bzw. des 328P: - XMega Serie: gute Peripherie, kein großer Umstieg, teurer, weiterhin 8Bit - STM32 Serie: sehr gute Peripherie, große Range/Auswahl, günstig, 32bit, große Community - PIC32: steht
-
Thread
Taschenrechner - Algorithmen
dem es um die schlechte Optimierung des gcc's bei 32bit ging. Ich glaube nicht das 64bit effizienter sind. Ich denke sowieso, dass ich einen externen Quarz mit 16MHz oder ~18MHz hinhänge (Baudratenquarz, hab der Wert grad nicht im Kopf)
bisher noch > keine Berechnungen in dieser Richtung angestellt, ich weiß also nicht > wie lange ien AVR für 64bit-Operationen braucht. was hindert dich daran, einfach mal im Simulator ein paar Berechnungen durchlaufen zu lassen?
-
Thread
FT800 / FT810 Library
Detect Erase Read/Write CMD_FLASHFAST W25Q128JVSIQ 128 Yes Yes Yes Yes SST26VF064BA-104I/SM 64 Yes Yes Write fails - AT25QF128A-SHB-T 128 Yes Yes Yes 0xE004 - device/blob mismatch W25Q32JVSSIQ 32 Yes Yes Yes Yes W25Q64JVSSIQ 64 Yes Yes Yes Yes IS25LP128F-JBLE 128 Yes
habe ich nur an der Oberfläche gekratzt. c-hater schrieb im Beitrag #6647994: > Unterstützung für AVR-Host-Flash >64kB) Also grundsätzlich ist das drin: [code] static inline uint8_t fetch_flash_byte(const uint8_t *data) { #if defined (__AVR_HAVE_ELPM__) /* we have an AVR with more than 64kB
-
Thread
6502 Emulation auf AVR ?
und zurück und 4 für Reti sind 13 Takte, die habe ich bei 32 Takten für einen 2-Zyklen Befehl des 6510 nicht übrig. 6510 immer mit rund 1MHz gerechnet, also C64 Speed. Falls jemand Interesse hat und mitdenken/mitbasteln will, packe ich das AVR-Projekt gern
überflogen. Aber egal: vielleicht bringt das Projekt ja doch noch die ein oder andere Erkenntnis für eine AVR-C64.
-
Thread
Transistortester AVR
usb -v bekam ich auch die "did not find any USB device" Fehlermeldung. Ich habe dann libusb-win32-bin-1.2.6.0 aus dem Internet geladen. Im ausgepackten Verzeichnis habe ich den "libusb-win32 Inf-Wizard" ausgeführt (Doppelklick). Mein Diamex ALL-AVR war dabei schon eingesteckt (USB). Danach geht
-DPULLUP_DISABLE -DANZ_MESS=25 -DPOWER_OFF -DBAT_CHECK -DBAT_OUT=150 -DBAT_POOR=64 -DF_CPU=8000000UL -mmcu=atmega168 -gdwarf-2 -std=gnu99 -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -MD -MP -MT main.o -MF dep/main.o.d -DLANG_ENGLISH -c ../main.c avr-gcc
-
Thread
C versus Assembler->Performance Gesperrt
A. K. schrieb im Beitrag #4251774: > Nö, beim AVR. Ausgeschlossen. Falls Du nicht AVR32 meinst.
Arithmetik ist keine AVR/ASM Stärke. Hier irrst du bezüglich des AVR gewaltig. Der AVR ist bei der 32-Bit-Arithmetik viel besser als manch anderer 8-Bitter. Selbst die 32-Bit-Gleitkommaarithmetik von AVR-GCC/avr-libc
-
Thread
AVR-Studio 5
Vielleicht ist das File auch einfach so groß weil 32 Bit UND 64 Bit (nativ) Version enthalten sind. Alleine die 64-Bit binaries sind ja ~30% größer als die 32 Bit binaries.
Eine Entwicklungsumgebung für AVR und AVR32 AVR Studio 5 von Atmel ist eine neue Entwicklungsumgebung, die eine Kombination aus AVR Studio 4 und AVR32 Studio darstellt und sämtliche 8- und 32-Bit-Mikrocontroller der Baureihe AVR
-
Thread
Webserver ATmega32/644DIP ENC28J60
avr-gcc.exe -I"C:\Users\user\Desktop\test\..\..\..\..\Program Files\Atmel\AVR Tools\include" -mmcu=atmega32 -Wall -gdwarf-2 -mmcu=atmega32 -O0 -fsigned-char -MD -MP -MT test.o -MF dep/test.o.d -c ../test.c avr-gcc.exe -I"C:\Users\user\Desktop\test\..\..\..\..\Program Files\Atmel\AVR Tools\include" -mmcu=atmega32 -Wall -gdwarf-2 -mmcu=atmega32 -O0 -fsigned-char -MD -MP -MT enc28j60.o -MF dep/enc28j60.o.d
-
Thread
AVR-GCC selbst bauen - Unter Linux für Windows?
kein Problem mit Linux) Also schnell Ubuntu in ner Virtuellen Maschine installiert und auch ming32 (x86_64-w64-ming32-gcc etc.) nur bin ich mir nicht sicher, wie ich damit jetzt die Windows-Binaries bauen kann. Ich dachte zuerst an [code] PREFIX=$HOME/local/avr PATH=$PATH:$PREFIX/bin ../binutils-2.25/configure --prefix=$PREFIX --target=avr --disable-nls --host x86_64-w64-ming32 ../gcc-5.3.0/configure --prefix=$PREFIX --target=avr --enable-languages=c,c++ --disable-nls --disable-libssp --with-dwarf2 --host x86_64-w64-ming32 etc. [/
-
Thread
Das Ende von 8bit?
Jay schrieb im Beitrag #4646946: > Nicht zu vergessen, viele 8-Biter sind einfacher als die 32-Biter. Naja, nicht immer. So einige 8-bitter sind von hinten durch die Brust designt, dazu würde ich gerade die beliebten AVR zählen. Der Sprung von 8 auf 32 bit ist nicht gerade kompliziert, und
A. K. schrieb im Beitrag #4647335: > Welche aktuell verbreiteten 32- und 64-Bit Prozessoren enthalten > eigentlich BCD-Operationen, abgesehen von x86? Insbesondere auch in > voller Breite, denn in 8 Bits wärs ja absurd. In x86-64 sind die AAx/DAx Befehle übrigens
-
Thread
AVR-Studio 4.19 und JTAG ICE MK2 unter Windows 11 64 Bit installieren
uint16_t u16; typedef int16_t s16; typedef uint32_t u32; typedef int32_t s32; typedef uint64_t u64; typedef int64_t s64; typedef __uint24 u24; typedef __int24 s24; [/c] Es steht entsprechend in AvrStudio_c.ini: [code] uint8_t =
: > C:\Atmel-Toolchain\AVR8\avr-gcc-12.1.0-x64-windows\bin\avr-cpp.exe > > Pfad zu MAKE eintragen : > C:\Atmel-Toolchain\AVR8\avr-gcc-12.1.0-x64-windows\bin\make.exe > > Die aktuelle Toolchain und MAKE sind verfügbar bei
