-
Thread
AVR64EA28: PIT-Interrupt
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?
Um genau zu sein: blinkt auf meinem einzigen AVR32EA28, aber nicht auf den beiden AVR64EA28. Alles Weitere aber können Sie (viel) weiter oben nachlesen.
-
Thread
Li-Akku Reihenschaltung einzeln nacheinander laden (Switch-Control) Asm@AVR64EA28
Ladegerät/Modul- Ausgang (hier ein TP5000 für LiFePO4) mit Relais umgeschaltet. Umsetzung auf einem AVR64EA28 in Assembler. Dieser steuert die kontrollierte Weiterschaltung bis alle Akkus voll sind. Der Taster startet den Ladevorgang (und stoppt ihn bei Bedarf). Als Spannungsregler-Modul zur Stromversorgung
OK, das ist valide :) "The AVR64EA28 is a microcontroller in the AVR® EA family featuring the AVR® CPU with hardware multiplier, running at up to 20 MHz and with 64 KB Flash with dedicated Read-While-Write (RWW) section, 6 KB SRAM
-
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
AVR 10-Bit-DAC
, AVR128DB28, AVR128DB32, AVR128DB48, AVR128DB64 AVR16DD14, AVR16DD20, AVR16DD28, AVR16DD32, AVR32DD14, AVR32DD20, AVR32DD28, AVR32DD32, AVR64DD14, AVR64DD20, AVR64DD28, AVR64DD32 AVR16EA28, AVR16EA32, AVR16EA48, AVR32EA28, AVR32EA32, AVR32EA48, AVR64EA28, AVR64EA32, AVR64EA48
-
Thread
Neue ATTINY3226 usw. gar nicht mitbekommen
___________|____________|____________|_____________ AVR32DB28 | AVR32DB32 | AVR32DB48 | AVR64DB28 | AVR64DB32 | AVR64DB48 | AVR64DB64 AVR128DB28 | AVR128DB32 | AVR128DB48 | AVR128DB64 14 Pin | 20 Pin | 28 Pin | 32Pin ______
_____|____________|____________| AVR64EA28 | AVR64EA32 | AVR64EA48 | [/code]
-
Thread
Atmega via Ethernet flashen
gnu99 -Wundef -MMD -MP -MF .dep/device_002.sizeelf.d etherflash.o checksu m.o ethernet.o arp.o enc28j60.o spi.o udp.o dhcpc.o eemem.o --output device_002. sizeelf -Wl,--defsym=app_start=0 -Wl,-Map=device_002.map,--cref -lm -Wl,--de fsym=app_start=0xEMB_LINKER_SCRIPT = -T ../make.files/eth-avr5
Ich hab avr-gcc 4.3.2 aus WinAVR-20090313 benutzt unter Win7 x64 und hatte keine solchen Probleme, weder mit device 001 noch 002. Welche Revision ich allerdings habe weiß ich nicht, wüßte nicht wo ich das nachsehen
-
Thread
AVR64DD28, mEDBG, Studio 7.0 - Fehler beim Schreiben von Fuses
0x1100-Anweisung ist angehängt. Auf diese LDS-Anweisungen folgt leider keine Antwort, weder vom AVR64DD28 noch vom ATtiny416, mit dem ich ebenfalls teste. Ich kann mir nun einfach nicht erklären, warum. Der Empfang des SIB funktioniert ja: ich erhalte [code] AVR P:2D:1-3 [/code] vom AVR64DD28
Mit dieser Änderung lässt sich, zumindest bei mir, die Signatur auslesen von ATtiny412, ATmega4809, AVR128DB28, AVR16DD28, AVR32EA28 und AVR16EB14.
-
Thread
Webserver ATmega32/644DIP ENC28J60
aussehen: (CCD Modul 420Linien = Analog)>(A/D Wandler=?)>(Mikrocontroller=?)>(Ethernet Interface=ENC28J60) Dieses teil sollte über eine IP ansprechbar sein?! Ähnlich wie das hier: http://avr.auctionant.de/avr-ip-webcam/avr-webserver-hardware.html
/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
ATtiny Typenchaos bei Microchip Gesperrt
| AVR128DA32 | AVR128DA48 | AVR128DA64 ___________|____________|____________|_____________ AVR32DB28 | AVR32DB32 | AVR32DB48 | AVR64DB28 | AVR64DB32 | AVR64DB48 | AVR64DB64 AVR128DB28 | AVR128DB32
| AVR32DD28 | AVR32DD32 AVR64DD14 | AVR64DD20 | AVR64DD28 | AVR64DD32 28 Pin | 32 Pin | 48 Pin | ___________|____________|____________| AVR64EA28 | AVR64EA32 | AVR64EA48 | [
-
Thread
Atmel Studio 4.19 unter W10X64
weniger interessant. Ich möchte nun die Varianten in SO-28 und TQFP-64 verwenden. Letzte hat zwar 0,5 mm Pinabstand, aber notfalls geht das auch... Und meine Lieblinge ATMega1284(P) und auch AT90CAN128 kann ich wie früher mit Atmel AVR JTAGICE mkII bedienen:
finde ich weniger interessant. Ich > möchte nun die Varianten in SO-28 und TQFP-64 verwenden. Letzte hat zwar > 0,5 mm Pinabstand, aber notfalls geht das auch... Und meine Lieblinge > ATMega1284(P) und auch AT90CAN128 kann ich wie früher mit Atmel AVR > JTAGICE mkII
-
Thread
flash-Fehler mit ATtiny2313, compile ok
; 0x246 1ea: 68 96 adiw r28, 0x18 ; 24 1ec: ea e0 ldi r30, 0x0A ; 10 1ee: f5 c1 rjmp .+1002 ; 0x5da 1f0: a8 e1 ldi r26, 0x18
mov r14, r24 20e: f1 2c mov r15, r1 210: ec 0e add r14, r28 212: fd 1e adc r15, r29 214: ce 01 movw r24, r28 216: 01 96 adiw r24, 0x01 ; 1 218: b7 01 movw r22, r14 21a: ea d0
-
Thread
Library für EA-DOGM Grafikdisplays inkl. Font-Generator
representieren die Abmessungen. (Siehe letzten Beitrag) Eine Falle gibt es noch, falls du den Konverter von ea verwenden willst: ggf. einfügen von "static" und "PROGMEM" für winavr. die Längenkonstante brauchst du nicht. (WinAvr Compiler) static uint8_t Image_ICON_BMP[] PROGMEM = { 128, 64, 255,255,255,255,255,243,243
mit einem ESP8266 Modul. Zu finden wie immer auf github: https://github.com/mueschel/lcdlib (EA DOG LCD & ILI9341 für AVR) https://github.com/mueschel/lcdlib-arduino (ILI9341 mit Arduino)
-
Thread
AVR tiny0/tiny1/megaAVR0/DA/DB/DD/DE Systematik der internen Peripherie
im Beitrag #7391281: > Ah ja: "gibts ... schon" klang so, als seien sie bereits erhältlich Die EA im kleinsten SMD Gehäuse gibts schon zu kaufen. https://www.microchipdirect.com/product/search/all/avr64ea
AVR128DA | AVR128DB | AVR64DD | AVR16|32DD | AVR4808|4809 Es gibt viele identische Peripherie-Komponenten, aber auch unterschiedliche und welche mit minimalen Differenzen.
-
Thread
AVR32 grasshopper patch für ATMEL buildroot 2.3.0
/Grasshopper« werden überschrieben package/mpfr/mpfr.mk:64: Warnung: Alte Befehle für das Ziel »/home/xxx/Grashopper/buildroot-avr32-v2.3.0/project_build_avr32/Grasshopper« werden ignoriert package/mtd/mtd-utils/mtd.mk:105: *** Mehrfache Target-Muster. Schluss
ffffffff 939e9c80 5e80: 00000000 00000000 00000000 00000000 93817200 00000000 00000000 93816c2c 5ea0: 93817200 9002daa0 939f5ea8 939f5ea8 00000000 00000000 00000000 003d08bb 5ec0: 64e53700 003d08bb 00000080 9023a3d8 901a9e56 939f5efc 9023a3a0 93817200 5ee0: 901a9f3c 939f5efc 9023a3a0 938f2c00 00000080
-
Thread
=== GCC v15 ===
Hat hier wer ein gcc v15 avr/arm binary für x86/64bit oder wie/wo nutzt ihr den Compiler?
automatisch im Flash landen. µC AVR128DB64.
-
Thread
AVR128DA64 TCA1 funktioniert nicht mit alternativen Output?
/Errata/AVR128DA-28-32-48-64-SilConErrataClarif-DS80000882.pdf
Blick bezüglich des besagten TCA-Problems jedenfalls etwas anders zu sein. Es gibt noch die Serien AVR-DD und AVR-EA – die haben aber anscheinend keine TQFP64-Typen.
-
Thread
UART Bootloader ATtiny13 - ATmega644
[pre] /dev/ttyS0 at 115200 Baud: / Connected Bootloader V1.4 Target: 1E9205 ATmega48 Buffer: 64 Byte Size available: 3582 Byte reading file... Done. Program project.hex: 0000 - 0D25 successful CRC: o.k. Elapsed time: 28 seconds andreas@andreas:~/avr/bootloader_linux$ ./main /Vproject.hex
/articles/AVR_Bootloader_FastBoot_von_Peter_Dannegger#Assemblieren_des_Bootloaders_.28Angepasste_Version_f.C3.BCr_AVR-GCC-Toolchain.29 Lars
-
Thread
Grosses Display (ev. 7-Seg.) für CO2-Anzeige gesucht
batterietauglich. Naja, wenn das das einzige Problem ist, die Schrittmotoren sehen schwer nach 28BYJ-48 aus, zum Beispiel wie die hier: https://www.amazon.de/28BYJ-48-28BYJ48-4-Phase-Arduino-Stepper/dp/B00ATA5MFE Die Dinger haben ein Getriebe drin, die verdreht man stromlos nicht einfach so, die Untersetzung ist 1:64 und der macht 5,625° pro Schritt, also 64*64 = 4096 Schritte für eine Umdrehung. Der Treiber ist einfach ein ULN2003 Relais-Treiber, die werden bewegt indem man in der richtigen Reihenfolge mit 4
-
Thread
[V] seltsames Matrix-Display auf Platine
e2: sei ; Referenced from offset 0x1bc by rjmp Label7: e4: clr r20 e6: ldi r28, 0x60 ; 96 e8: clr r29 ea: sbi PORTA, 2 ; 0x04 = 4 ; Referenced from offset 0x156 by rjmp Label8: ec: sbrc r21, 0 ; 0x01 = 1 ee: cbi 0x18
r2, r16 484: ldi r16, 0x14 ; 20 486: mov r3, r16 488: ldi r16, 0x28 ; 40 48a: mov r5, r16 48c: ldi r16, 0x64 ; 100 48e: mov r4, r16 490: ret ; Referenced from offset 0x98 by rcall ; Referenced from offset 0x270 by rcall
-
Thread
UPDI Debugger fuer neuere AVR
integrieren. Es ist wichtig, das jeweilige Datenblatt genauer zu lesen. Z.B. EV66E56A: All external AVR microcontrollers with the UPDI interface can be programmed and debugged with the on-board debugger with Microchip Studio. AVR64EA48 Curiosity Nano can program and debug external AVR64EA48 microcontrollers
Ok Danke, das hilft, insbesondere auch das verlinkte "AVR64EA48-CNANO-HW-UserGuide-DS50003494.pdf".
-
Thread
Logamatic 2107 Schnittstelle
40 DD 00 C3 EA 14 08 00 19 00 00 02 14 00 00 64 08 02 37 00 02 A0 06 00 23 13 [/code]
* ! 22 * ! CB 00 CB FOUND: 08 * ! 10 * ! 14 * ! 00 * ! 1E * ! 64 * ! 24 * ! CD 00 CD FOUND: 08 * ! 10 * ! 14 * ! 00 * ! 1E * ! 64 * ! 26 * ! CF 00 CF FOUND: 08 * ! 10 * ! 14 * ! 00 * ! 1E * ! 64 * ! 28 * ! C1 00 C1 FOUND: 08 * ! 10 * ! 14 * ! 00 * ! 1E * ! 64
-
Thread
bin neu hier, atmega8.
offenbar Einsteiger bist, ist dir dringendst nahezulegen, mit was neuerem anzufangen. Wenn es 8-bit AVR sein soll: DB-, DD-, EA- und EB-Serien, z.B. AVR64DD28. Sogar auch in DIP28 erhältlich.
bis vier Jahren erneut, weil die mir halt schon etwas bekannt waren und vorallem auch wegen des [[AVR-Tutorial]]s. (Ich hatte seitdem tatsächlich einige Male überlegt, irgendwann mal eine Neuauflage für AVR64[DB|DD|EA]28 zu schreiben, bin mir aber nicht sicher, ob sich das "heutzutage" noch lohnt).
-
Thread
Nach fast 3 Jahren fehlerkorrigiertes Datenblatt für die AVR-DB Serie erschienen
Client. https://ww1.microchip.com/downloads/aemDocuments/documents/MCU08/ProductDocuments/DataSheets/AVR128DB28-32-48-64-DataSheet-DS40002247A.pdf
Nun gibt es schon die AVR_DU-Datenblätter: AVR64DU-28-32-Prelim-DataSheet-DS40002548.pdf AVR32-16DU-14-20-28-32-Prelim-DataSheet-DS40002576.pdf
-
Thread
atmega läuft nicht
Menge. http://www.sics.se/~adam/uip/index.php/Main_Page Aber ist halt ersteinmal nicht für den AVR. Und es gibt keine Fehlermeldung. > Passt das ganze überhaupt noch in Deinen AVR? Optimierung eigeschaltet? jup, brauche 20kb von 64 > Das Programm startet immer wieder neu. Nach der Initialisierung
r26, 0x60 ; 96 64: b0 e0 ldi r27, 0x00 ; 0 66: ea e2 ldi r30, 0x2A ; 42 68: f4 e3 ldi r31, 0x34 ; 52 6a: 02 c0 rjmp .+4 ; 0x70 6c: 05 90 lpm r0, Z+ 6e:
-
Thread
Welche AVR (Atmega) haben UPDI?
| 32 Pin | 48 Pin | 64 Pin ___________|____________|____________|_____________ AVR32DA28 | AVR32DA32 | AVR32DA48 | AVR64DA28 | AVR64DA32 | AVR64DA48 | AVR64DA64 AVR128DA28 | AVR128DA32 | AVR128DA48 | AVR128DA64
Microchip verlängert das Sterben. https://www.microchip.com/content/dam/mchp/mrt-dam/ic-images/spdip/28-lead-m3x/AVR64EA28-M3X-Regular.jpg
-
Thread
Neue 8-Bit Tinys vorgestellt: 417/814/816/817 Gesperrt
denn? Ich könnte auch noch was unter dem ATMega16M1 einsetzen. Ach ja, ein Traum wären ja 32MHz+ AVR mit 44 oder 64 Pins und 2x CAN-FD. :-) Oh ja, mit 0,5mm Pin-Abständen natürlich. Aber nun ja, wird es nicht geben fürchte ich und so sehe ich für die ständig näher rückende Zukunft was mit ARM Kern
hat ja auch ARM im Sortiment. Nur haben die einfach nichts was ich als richtiges Upgrade zu den AVR gebrauchen könnte, da ich CAN brauche und nicht so viele Pins. Die M7 von Atmel haben bei 64 Pins nur einen CAN, sonst gibt es nur M3 mit 100 Pins aufwärts, A5 und den M0 C21 der mir wiederrum als
-
Thread
Analoges Projekt auf MC umrüsten. Frage zu PIN Zuweisungen.
https://www.reichelt.de/de/de/shop/produkt/avr_64kb_rww_6kb_ram_28p_20mhz-375464?search=avr%2526%2524ea&
_6kb_ram_28p_20mhz-375464?search=avr%2526%2524ea&; Hallo Johannes, Danke für die Info. Und ja, der MC als SPDIP-28 Version wäre auch eine Option für mein Projekt. Den werde ich mir mal zum Testen besorgen sobald
-
Thread
Bilineare Interpolation mit Festkomma
mul r31, r16 2e4: 90 0d add r25, r0 2e6: 11 24 eor r1, r1 2e8: 28 0f add r18, r24 2ea: 39 1f adc r19, r25 2ec: 24 9f mul r18, r20 2ee: 80 01 movw r16, r0 2f0: 25 9f mul r18, r21 2f2: 10 0d add r17
r0 31e: 11 24 eor r1, r1 320: 28 0f add r18, r24 322: 39 1f adc r19, r25 324: 64 1b sub r22, r20 326: 75 0b sbc r23, r21 328: 26 9f mul r18, r22 32a: c0 01 movw r24
-
Thread
Plasma Effekt
Cosinus-Landschaft wandert nach schräg oben. Mit einfacher Farbtabelle ist das nicht zu machen. Wie in alten C64-Demos wird hier wahrscheinlich mit Sin/Cos-Tabellen gearbeitet. Der AVR dürfte für die Pixelberechnung sicherlich schnell genug sein (be 16MHz mindestens 16 mal schneller als ein C64!) Gruss
0x7E4C, 0x7E53, 0x7E5B, 0x7E62, 0x7E6A, 0x7E71, 0x7E78, 0x7E7F, 0x7E87, 0x7E8E, 0x7E94, 0x7E9B, 0x7EA2, 0x7EA9, 0x7EB0, 0x7EB6, 0x7EBD, 0x7EC3, 0x7ECA, 0x7ED0, 0x7ED6, 0x7EDD, 0x7EE3, 0x7EE9, 0x7EEF, 0x7EF5, 0x7EFB, 0x7F01, 0x7F06, 0x7F0C, 0x7F12, 0x7F17, 0x7F1D, 0x7F22, 0x7F28, 0x7F2D, 0x7F32, 0x7F37
-
Thread
Optimierung Fehlerhaft?
ausgeführt. Da wegoptimiert. return adc_ergebnis; } [/c] und der passende ASMCode [avrasm]AVR-Assembler-Code 00000250 <adcwertermittlung>: 250: 28 2f mov r18, r24 252: 80 91 7a 00 lds r24, 0x007A 256: 80 64 ori r24, 0x40 ; 64 258: 80 93 7a 00 sts 0x007A,
+0x2a> 274: 64 e0 ldi r22, 0x04 ; 4 276: 01 c0 rjmp .+2 ; 0x27a <adcwertermittlung+0x2a> 278: 6a e0 ldi r22, 0x0A ; 10 27a: 0e 94 75 01 call 0x2ea ; 0x2ea <__udivmodqi4
-
Thread
TI Launchpad MSP430
cs :0A 0000 00 0F12D2E300003F410013 8D :10 0000 00 B240805A0000F2D030000000F2D00C00 64 :10 0010 00 0000D2D30000D2D30000824300008243 0C :10 0020 00 0000B24010000000B240FF010000B240 EA :08 0030 00 D001000032D0D800 1D :00 0000 01 FF n Anzahl Bytes im Datensatz
msp430-objdump -dSz xxx.x in einer Shell die einzelnen Dateien anschauen. Wenn ich bei mir mit avr-gcc aus [c] int main(void) { return 0; } [/c] ein main.o und main.elf erzeuge, bekomme ich mit avr-objdump -dSz main.o [code] main.o: file format elf32-avr Disassembly
-
Thread
Arduino: page-write in I2C eeprom verliert sporadisch ein Byte
23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 48 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 64 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 80 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 96 60 61 62 63 64
21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 48 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 64 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 80 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 96 60 61 62 63 64
-
Thread
problem mit intel hex file und bootlaoder
:1002C800AA93BA93EA93FA93EFB7EA9367D0F099AF :1002D800B5DFE991EFBFF991E991B991A9919991A8 :1002E800899179916991F9901990099018952497B5 :1002F80084E0A0E0B0E0EAE9F0E00E9415025ED0F8 :100308009884A984F09A64D00E94060266D028F4E2
8A93 9A93 AA93 BA93 EA93 FA93 EFB7 EA93 67D0 F099 B5DF E991 EFBF F991 E991 B991 A991 9991 8991 7991 6991 F990 1990 0990 1895 2497 84E0 A0E0 B0E0 EAE9 F0E0 0E94 1502 5ED0 9884 A984 F09A 64D0 0E94 0602 66D0 28F4 EE81 FF81 9E16
-
Thread
ATxMegaBoard 5 mit ATxMega128A1U
Achso, selbiges über SPI gesagte, gilt natürlich für das SPI Interface des ENC28J60 ebenso ... =)
? Gibt es da ein Beispiel zu? Vermutlich bezieht Basti sich darauf, daß in Deiner Schaltung: AVR 28J60 ============== MI(SO) ---> SO MO(SI) <--- SI "1:1" verbunden sind, im ENC28J60-Datasheet (bspw. in Figure 2-5 und 2-6) dagegen: MCU 28J60 ============ SO ---> SI SI <--- SO
-
Thread
Was benötige ich um einen 8086 in Assembbler zu programmieren ?
EPROMs kann man auch Statische RAMs (z.B. 6264) mit Pufferbatterie verwenden. Oder EEPROMs, wie den 28C64.
Percy N. schrieb im Beitrag #6481831: > Demnach wäre also die olle IBM eher akkufrei als AVR. AVR hat keinen Akku.
-
Thread
AVR und der Umgang mit C++
jmp 0x7c ; 0x7c <__bad_interrupt> 60: 0c 94 3e 00 jmp 0x7c ; 0x7c <__bad_interrupt> 64: 0c 94 3e 00 jmp 0x7c ; 0x7c <__bad_interrupt> 00000068 <__ctors_end>: 68: 11 24 eor r1, r1 6a: 1f be out 0x3f, r1 ; 63 6c: cf ef ldi r28, 0xFF ; 255
r24 ; 0x03 spi_init(); 282: 0e 94 04 01 call 0x208 ; 0x208 <_Z8spi_initv> __builtin_avr_delay_cycles(__ticks_dc); 286: 8f e3 ldi r24, 0x3F ; 63 288: 9c e9 ldi r25, 0x9C ; 156 28a: 01 97 sbiw r24, 0x01 ; 1 28c: f1 f7 brne .-4 ; 0x28a
-
Thread
Maskenprogrammierten 80c51BH auslesen?
Dazu bräuchte ich dann wohl noch ein Latch (welches?)? Was genau soll das Programm machen außer /EA wider auf Masse zu legen? Ich habe leider keine Möglichkeit EPROMs zu brennen. Ginge es auch mit einem AVR-µC (STK 500 ist vorhanden). Also praktisch dass der AVR-µC dem 80C51 ein EPROM vorgaukelt
Dieser Speicher sollte größer sein als der interne ROM, damit die Adressierung einfacher ist. Der AT28C64 (EEPROM) sollte passen. Diesen kannst du ohne EPROM-Brenner, wie ein normales SRAM beschreiben. Du springst beim Resetvektor in dein Programm, das im Speicher hinter dem internen Speicher stehen
-
Thread
Noch ein Taschenrechner auf ATMega Basis
und RCL benutzt und sich dieses Programm in einer Endlosschleife befindet, dann ist der EEPROM des AVR bald hinüber :-(
Diskussion. Als Randbedingungen halte ich mal die folgenden Komponenten fest. - Atemga 1284 - FRAM FM 24C64B-G - Micro-SD - USB (Mini/Micro/USB-C) incl. Ladeelektronik und USB/Seriell-Wandler - Display EA DOGS104-A - 5x8 Matrix für Keypad (somit gibt es HP42 oder WP34S Kompatibilität bezüglich der Tastenanordnung
-
Thread
[Sammelbestellung] µC-Board + RAM
zusammen, Preise für SRAM: 512 k x 8 (4 Mbit): ca. 3,00€ 512 k x 16 (8 Mbit): ca. 3,50€ 4 M x 16 (64 Mbit): ca. 4,75€ Besteht Interesse an einem "Breakout-Board" mit einem µC + RAM? Der CPU-Core wäre noch festzulegen: ARM, AVR, PIC, ... Ich kann mir vorstellen, dass man ab 1000 Stück in China
optional bestücken, mal sehen. Als "Formfaktor" bin ich immer noch bei der "Briefmarke", hier ca. 28 x 37 mm². Kosten für ein Einzelstück: Ca. 6,00€: ATXMEGA64A1U + 8MiB SDRAM + Spannungsregler + Hühnerfutter: Ca. 3,40€: PCB vom Platinensammler ≈ 8,40€ Klingt gut.
-
Thread
pointer struct parameter übergabe / fehler?
files/winavr-20070525/bin/../lib/gcc/avr/4.1.2/../../../../avr/lib/avr5\libc.a(mulsf3x.o) (__fp_nanx) c:/program files/winavr-20070525/bin/../lib/gcc/avr/4.1.2/../../../../avr/lib/avr5\libc.a(fp_split.o) c:/
ldi r24, 0x00 ; 0 e6: 90 e0 ldi r25, 0x00 ; 0 e8: df 91 pop r29 ea: cf 91 pop r28 ec: 08 95 ret 000000ee <square>: ee: 9b 01 ac 01 0c 94 7b 00 ......{. 000000f6 <__mulsf3>: f6: 67 d0 rcall .+206
-
Thread
Pac Man mit dem ATmega8
Na ja, der eine AVR muß ja nur Daten lesen und ausgeben und sollte nicht dabei gestört werden. Der 2. AVR muß zum Grafikaufbau nicht nur schreiben, sondern bei Bitverknüpfungen (OR, AND) für einzelne zu setzende Pixel
Also, ich hatte auch überlegt. Ein Chip liest Bilder von EEProm in RAM. Anderer AVR sendet Befehl mit Bildnummer u. Position an GrafikAVR. GrafikAVR fügt Bild ein und zeigt an. Bsp. Befehl: 1011010-111111-101010-1 BildNR.-Pos.X -Pos.Y -Tranzparenz?
-
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
anderen? Es ist ja eine große Familie. Mit entsprechender CLKCTRL-Anpassung läuft es auch auf einem AVR32EA28, legt man das TCA-Fragment still auch auf einem AVR16EB28; von den DA und DB ganz zu schweigen. Und sicher klappt es auch mit einem der neueren ATtinies. Allerdings halte ich ein Problem mit
-
Thread
Quarz und Clock bei AVR series 1 (z.B. Attiny 816)
Beitrag #7536305: > wenn das Upgrade sinnvoller auf eine andere CPU gehen > sollte (wobei ich in der AVR-Familie bleiben will) Für universelle Verwendung auf minimalem (aber bequem lötbaren) SMD Raum empfehle ich die neuen AVR64DD14 aufwärts, bei mehr Platz und Pinbedarf genauso die AVR128-DB Reihe
Beide Quarze möglich z.B. bei: AVR32EA28/32/48 AVR16EA28/32/48
-
Thread
Probleme win WinAVR 20081205
PWM_value; PORTD ^= (1<<PD6); // LED rot toggle cc: c2 e3 ldi r28, 0x32 ; 50 ce: d0 e0 ldi r29, 0x00 ; 0 d0: 00 e4 ldi r16, 0x40 ; 64 PWM_value = uart0_rx_getchar(); uart0_tx_putchar(PWM_value); if ( (PWM_value
rot toggle besteht insgesamt aus zwei verteilten Codeblöcken, einmal cc: c2 e3 ldi r28, 0x32 ; 50 ce: d0 e0 ldi r29, 0x00 ; 0 d0: 00 e4 ldi r16, 0x40 ; 64 als Initialisierung vor der Schleife, und dann e6: 88 81 ld r24, Y e8: 80 27
-
Thread
Ist das ein Bug im Compiler?
ldi r28, 0x43 ; 67 64c2: d7 e3 ldi r29, 0x37 ; 55 64c4: 6f e0 ldi r22, 0x0F ; 15 64c6: 7e e3 ldi r23, 0x3E ; 62 64c8: 41 e0 ldi
if (!mask) { mask = 1; 64ec: 41 e0 ldi r20, 0x01 ; 1 Pointerverschieben 64ee: 34 96 adiw r30, 0x04 ; 4 64f0: 24 96 adiw r28, 0x04 ; 4 64f2: 6f 5f
-
Thread
CP/M auf Atmega8515 mit XMEM
weil CP/M mit nur 32 KB RAM keinen Spaß macht. Deswegen auch der zusätzliche 74xx-Baustein (A15 vom AVR geht einmal auf /CS vom einen Baustein, und durch einen Inverter auf /CS vom anderen Baustein). Aber ja, das kann man auch besser machen, z.B. mit einem 64 KB oder 128 KB SRAM - dann reichen drei
belegt die Sektoren 24576 bis 40959 (12 bis 20 MB) C: belegt die Sektoren 40960 bis 57343 (20 bis 28 MB) D: belegt die Sektoren 57344 bis 73727 (28 bis 36 MB) Alle Laufwerke sind 8 MB groß und haben die gleiche Geometrie; die erste Spur (64 Sektoren x 512 Byte = 32 KB) ist für den Bootcode (BDOS
-
Thread
Was für eine Art von ROM?
Passend wäre wohl ein EEPROM - weil man die Löcheinrichtung spart. So etwas wie 28C64 (8 K x 8) bekommt man noch als DIP28. Wenn der Speicher seriell (SPI) sein darf, gibt es auch welche im DIP8 und sehr günstig.
Wenn ich 16 Bit benötige Eine TTL CPU mit 16Bit? Hut ab! > 3. Sind alle EEPROM-Programmer mit dem 28C64 kompatibel oder muss man > auf bestimmte Angaben im Datenblatt achten? Zwei Fragen, zwei Antworten: Nein. Ja: in der Liste der unterstützten Bausteine muss der 28C64 stehen. Idealerweise vom
-
Thread
Max233: Falsche Characters
A0 AF 30 19:09:19 hypertrm.exe IRP_MJ_READ Serial0 SUCCESS Length 80: BE 7D 72 65 7D 2F 28 70 6F 7D 73 69 7B 6D 6C A9 BB 23 20 BC 3F 31 19:09:19 hypertrm.exe IRP_MJ_READ Serial0 SUCCESS Length 80: B0 BF 3F 30 B0 BF 2D 20 64 BB 3F 30 B8 BF 3F 30 B8 BF 0D 8A ED 32 19:09:19 hypertrm.exe
AD BB BF B7 3F 47 19:09:24 hypertrm.exe IRP_MJ_READ Serial0 SUCCESS Length 80: 6D 61 6E 64 B0 6E 6D 6F 75 BB BF 7B 6F 6F 77 BD AF 77 75 77 AF 48 19:09:24 hypertrm.exe IRP_MJ_READ Serial0 SUCCESS Length 80: 3D 3D 35 32 30 30 EA ED 7B 5F 55 BB 3F 5B 5B 4D 35 33 35 32 BE 49 19:
-
Thread
Reziproker Frequenzzähler+ Optimierte 64bit uint Routinen
gerechnet werden - was mal eben locker den Bereich einer 32-Bit Zahl sprengt. Die libgcc-Routinen für 64 bit Zahlen sind leider viel zu groß für einen ATtiny, deshalb habe ich noch ein paar Spezialroutinen in Assembler geschrieben. Zu finden unter http://www.mshopf.de/proj/avr/uint64_ops.html * Bit
0120 38EC ldi r19,lo8(-56) 1183 0122 47E1 ldi r20,lo8(23) 1184 0124 58EA ldi r21,lo8(-88) 1185 0126 64E0 ldi r22,lo8(4) 1186 0128 70E0 ldi r23,lo8(0) 1187 012a 80E0 ldi r24,lo8(0) 1188 012c 90E0 ldi r25,lo8(0) 1189 012e
-
Thread
GCC Compiler + ATXMEGA E = Schrott?
ein atxmegaE unterscheidet sich bei mir nicht von einem A: [avrasm] 000000da <main>: #include <avr/io.h> uint8_t a=1; int main(void) { da: cf 93 push r28 dc: df 93 push r29 de: cd b7 in r28, 0x3d ; 61 e0: de b7 in r29, 0x3e ; 62 while
Bitte schön: [c] #include <avr/io.h> #include <avr/sleep.h> #include <avr/interrupt.h> uint8_t a=1; uint16_t Millisekunden; uint8_t Sekunden; uint8_t Trigger_Sekunde; uint8_t Trigger_Millisekunden; void initialisiere_System