-
Thread
Code(SRAM steuern) verbessern. Arduino mega 2560
Maxim B. schrieb im Beitrag #5441364: > Dafür gibt es interne SRAM. Zeige mir den AVR mit 32 oder 64 KB internem SRAM.
S. R. schrieb im Beitrag #5441366: > Zeige mir den AVR mit 32 oder 64 KB internem SRAM. Wenn man so viel SRAM für die Aufgaben braucht, die man mit AVR machen will - dann liegt das Problem nicht in SRAM sondern woanders. Z.B. man könnte Programmlogik
-
Thread
ATtiny Typenchaos bei Microchip Gesperrt
| AVR128DA48 | AVR128DA64 ___________|____________|____________|_____________ AVR32DB28 | AVR32DB32 | AVR32DB48 | AVR64DB28 | AVR64DB32 | AVR64DB48 | AVR64DB64 AVR128DB28 | AVR128DB32 | AVR128DB48
| AVR32DD32 AVR64DD14 | AVR64DD20 | AVR64DD28 | AVR64DD32 28 Pin | 32 Pin | 48 Pin | ___________|____________|____________| AVR64EA28 | AVR64EA32 | AVR64EA48 | [/c]
-
Thread
Frage zur C Syntax
auf dem AVR und zweitens scheint die Arithmetik mit grossen Zahlen auf dem AVR-GCC noch EINIGES an Optimierungspotential zu haben. Schauen wir mal genau hin. [c] uint32_t ftw_fix_1 (uint32_t freq) { uint64
): ftw.U64 = ftw.U32[HI] * 0xF1A1BF39ULL;
-
Thread
AVR64DD28, mEDBG, Studio 7.0 - Fehler beim Schreiben von Fuses
Hallo, Aufheiterung ist immer gut. Danke. Habe soeben meinen AVR64EA32 mit pyupdi probiert, funktioniert. [code] pymcuprog.exe write -d avr64ea32 -t uart -u com8 -f blink.hex --erase --verify [/code] [code] Connecting to SerialUPDI Pinging device... Ping response
Mit dieser Änderung lässt sich, zumindest bei mir, die Signatur auslesen von ATtiny412, ATmega4809, AVR128DB28, AVR16DD28, AVR32EA28 und AVR16EB14.
-
Thread
Peter Danneggers Bootloader (fastboot) für AVR-GCC-Toolchain
lib/ COLLECT_GCC_OPTIONS='-mmcu=atmega32' '-o' 'X' "/usr/lib/gcc/avr/4.5.1/collect2" "-m" "avr5" "-o" "X" "/usr/lib/gcc/avr/4.5.1/../../../../avr/lib/avr5/crtm32.o" "-L/usr/lib/gcc/avr/4.5.1/avr5" "-L/usr/lib/gcc/avr/4.5.1/../../../../avr
replaced when bootload.x is generated (see sed part in Makefile). */ OUTPUT_FORMAT("elf32-avr","elf32-avr","elf32-avr") OUTPUT_ARCH(avr4) MEMORY { text (rx) : ORIGIN = 0x1e00, LENGTH = 0x1fe + 2 bss (rw!x) : ORIGIN = 0x8000000 + , LENGTH = } /* PHDRS { stub PT_LOAD
-
Thread
AVR Bootloader in C - Artikel
der avr-libc bin ich nun noch auf den uint_farptr_t gestoßen: http://www.nongnu.org/avr-libc/user-manual/group__avr__inttypes.html#ga72b6692e3f3123903c1a0d9a960c59b1 [c]typedef int32_t int_farptr_t[/c] >
Hallo Jan, die "memcpy_PF"-Funktion ist in der Tat teil der avr-libc: http://www.nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html das "..F" bedeutet "far" für Kopieraktionen in Speicherbereichen >64k. Du kannst die auch eine Routine mit "pgm_read_byte
-
Thread
Arduino: Größe eines Pointers
Die Größe des Pointers hängt ausschließlich mit der Architektur zusammen. Beim AVR oder ARM kann man von 16bit bzw. 32Bit ausgehen. Auf einem PC wird die Sache schon schwieriger, Long, Long Long ... usw..32bit oder 64bit Architektur..
164PA/324A/324PA/644A/644PA/1284/1284P Program Counter (PC) is 15/16 bits wide, thus addressing the 32/64K program memory locations. [/pre]
-
Thread
Retro Fieber: Z80 oder 68000 ?
AVR als I/O Bus "Device", eingemapped mit fixere Adresse für maximal 32 Bytes möglich.
Christian J. schrieb im Beitrag #3889644: > AVR als I/O Bus "Device", eingemapped mit fixere Adresse für maximal 32 > Bytes möglich. Mit welchem AVR geht das?
-
Thread
Update von WinAVR2010
aus Arduino - remove_giveio.bat aus Arduino - status_giveio.bat aus Arduino - cygwin1.dll aus WinAVR - itcl32.dll aus WinAVR - itk32.dll aus WinAVR - libiconv-2.dll aus Arduino - libusb0.dll aus Arduino - srec_cat.exe aus WinAVR - splint.exe aus WinAVR - tcl84.dll aus WinAVR - tclpip84.dll
generiertem Code bzgl. v8. mein Test ergab für ein LED-Blink-Beispiel data+text 1886 bytes mit AVR-GCC8.2.0 64bit im Vergleich zu 1940 bytes für AVR-GCC9.1.0 32bit. WINAVR2010 sind 1720 bytes. Der totale Speicher (incl. Debug-Infos) wuchs bei allen neueren Versionen gegenüber WINAVR2010 stark
-
Thread
Mini-Farbdisplay (+mehr) für 1 Euro
man auch auf diesem Display die einzelnen Schritte. 32 bzw 64 unterschiedliche Stufen sind nicht wirklich viel wenn man Farbverläufe hat.
'R DATA 0,38,73,73,73,50 'S DATA 0,1,1,127,1,1 'T DATA 0,63,64,64,64,63 'U DATA 0,31,32,64,32,31 'V DATA 0,63,64,60,64,63 'W DATA 0,99,20,8,20,99 'X DATA 0,7,8,112,8,7 'Y DATA 0,113,73,69,67,0 'Z 'Font-Quelle: 6x8 Zeichensatz aus dem Verzeichnis "C:\BASCOM
-
Thread
ATmega Development Boards (Sind die OK?)
interessant. Aber sie werden vermutlich deutlich > mehr Strom verbrauchen als ein ESP8266 oder ESP32. Nee, eher weniger. Bei 8Mhz ist ihre Stromaufnahme sogar ungefähr auf gleichem Niveau, wie die AVR's. Allerdings ist die Ruhestromaufnahme der STM32F1 Serie höher als bei AVR. Für Langzeit-Betrieb
wie schnell man den unbrauchbar machen kann. Zudem hat dieser auch weniger Pins und IO als die ATmega64/ATmega32A ... Bei keinem Arduino mit AVR ist ein JTAG Anschluss, da der ATmega328 keinen JTAG hat. Ich würde die einen von denen empfehlen, welcher einen JTAG bereits onboard hat (3. Link ...) mit
-
Thread
32-Bit-µC: Möglichst viel uint8_t verwenden?
er. Genau genommen tut es allerdings derjenige, der das Include-Files dazu schreibt, und bei einer 32-Bit RISC für int_fast8_t einen 32-Bit Typ einsetzt, bei 8-Bit AVR aber einen 8-bit Typ.
avr schrieb im Beitrag #7119523: > Das passiert aber nur auf einer 32-bit Architektur und dort sind 8-bit > Zugriffe bei mir bekannten Architekturen niemals schneller als 32-bit. Ja?! Deswegen hat
-
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
16 Grasshopper: 2 PWMs Grasshopper: 6 Leds pdc pdc.0: Atmel Peripheral DMA Controller enabled at32_eic at32_eic.0: External Interrupt Controller at 0xfff00100, IRQ 19 at32_eic at32_eic.0: Handling 4 external IRQs, starting with IRQ 64 AVR32 AP Power Management enabled dw_dmac.0: DesignWare DMA
-
Thread
Z180-Stamp Modul
sollten nunmehr die folgenden Varianten möglich sein: Z180-Stamp + EPROM Z180-Stamp + Bootprozessor (AVR, Propeller, STM32) Z180-Stamp + Bootprozessor + ECB-Bus Im nächsten Schritt folgt der Bootprozessor (AVR, STM32) als Huckepackvariante zum Z180-Stamp. Alle Unterlagen wie immer hier: http://
.0 ..0 ..01FCF| 00d0 3b 46 91 46 99 46 99 46 ac 46 ac 46 08 08 08 25 |;F.F.F.F.F.F...%| 00e0 32 64 20 00 48 69 74 20 61 6e 79 20 6b 65 79 20 |2d .Hit any key | 00f0 74 6f 20 73 74 6f 70 20 61 75 74 6f 62 6f 6f 74 |to stop autoboot| 0100 3a 20 25 32 64 20 00 23 23 23 20 6d 61 69 6e 5f
-
Thread
Welchen µC-Typ für neues Projekt?
sein werden. Meine Möglichkeiten die ich bis jetzt so sehe wären folgende: Atmel ATxmega Atmel AVR32 Atmel ARM ST ARM Die AVR32 sehe ich irgendwie auf einem toten Ast bei Atmel und fallen deshalb schon für mich raus. Die ATxmega hätten war höheren Takt aber wenn ich da eine 16 bit MUL 16 bit
mitnichten was mit deinem Gurkenvergleich von 20 Mhz zu 32 Mhz zu tun. Bei 32 MHz ist ein XMEGA doppelt so schnell wie ein normaler AVR bei 16 MHz oder, um bei der Kümelkackerei zu bleiben 1,6 Mal so schnell wie ein AVR @ 20 MHz.
-
Thread
Stack Überschreiber beim Rechnen mit uint64_t
auch eine 64-Bit Lib geschrieben - http://www.mshopf.de/proj/avr/uint64_ops.html Damit ist die FTW Berechnung auch schnell möglich. 64-Bit M. Hopf: *4,592ms* Hier der Code [c] const uint32_t dds_takt32 = F_MHZ(180); uint32_t freq32 = F_MHZ(10); uint64_t ftw = 0; start_t1_counter(); ftw = 0; // U64_UNION_O(ftw, 0) = 0; U64_UNION_O(ftw, 1) = freq32; // entspricht ftw = (1ull<<32) * freq32 ftw = uint64_div32(
-
Thread
Assembler wieder auf dem Weg nach vorn Gesperrt
Moby A. schrieb im Beitrag #4363316: > Unfug. Register hat jeder AVR die gleichen 32 an der Zahl. /Fast/ jeder.
> Moby A. schrieb: >> A. K. schrieb: >>> Moby A. schrieb: >>> Unfug. Register hat jeder AVR die gleichen 32 an der Zahl. >>> >>> Fast jeder. >> >> Ok, fast jeder. Ändert aber jetzt auch nix. > > Fast nix. Typische 8-Bit-MSR-Projekte nutzen kein 6-Pin-AVR's. Da funktioniert ja der
-
Thread
Wieviel mehr an Strom braucht man für 64 Bit fähige Mikrocontroller?
die man für den Compiler haben will? Immer noch: Wozu soll das gut sein? Die meisten Daten auf 64-Bittern sind 32 Bits breit, weil das LLP64- oder LP64-Modell genutzt wird, bei den Ints 32 Bits breit sind. Lediglich die Pointer sind routinemässig 64 Bit breit, was aber unterhalb einiger GB Adressraum
, dass 64bit > Operationen als 2 sequentielle 32bit Operationen gemacht werden. Welchen Vorteil hätte man dann noch von den 64 Bit? Abgesehen davon: Wie machst du eine 64-Bit-Multiplikation mit nur zwei 32
-
Thread
Mit was in die Mikrokontrollerwelt einsteigen?
seriellen Port öffnet und darüber Daten mit dem Mikrocontroller austauscht, ist kein Hexenwerk. Einen "64-bit tauglichen" Compiler brauchst Du nicht, da Windows x64 ja weiterhin 32-Bit-Anwendungen ausführen kann. AVR-Studio 6 mit dem AVR-GCC läuft z.B. einwandfrei unter Windows 7 x64. Die Zielplattform ist
mit Debugger kann man die Prozessor-Register und die Register der Pheriperie lesen (beim AVR und STM32 gleichermaßen).
-
Thread
AVR: float nach uint/Vorkomma und uint/Nachkomma
gerri schrieb im Beitrag #3043735: > Wo wir beim Thema sind, im AVR-Studio bedeutet > > float => Gleitkommazahl 32 bit > > und > > double => Gleitkommazahl 64 bit > > oder? Da da noch keiner drauf genatwortet hat: Nein. double is beim avr-gcc auch 32
gerri schrieb im Beitrag #3043735: > Wo wir beim Thema sind, im AVR-Studio bedeutet > > float => Gleitkommazahl 32 bit > > und > > double => Gleitkommazahl 64 bit > > oder? nö, double und float sind im AVR gcc identisch 32bit
-
Thread
The Siemens S65 132x176, 65536 color display with AVR
Verwende die embedded Workbench von IAR, war bei dem Bundle von MSC mit dabei für 149 Euro, ist aber auf 32KB Code beschränkt. Finde die zwar lange nicht so gut wie Codevision für den AVR aber man kann mit arbeiten.
: #include <avr/pgmspace.h> // AVR specific functions to access the program memory // ascii table, starting with character blank (32) // size is 8x14 const uint8_t ascii_tab[96][14] PROGMEM = { { 0x00, 0x00
-
Thread
Reziproker Frequenzzähler+ Optimierte 64bit uint Routinen
/www.mshopf.de/proj/avr/uint64_ops.html * Bit Shifts (Ersparnis: ca. 200bytes vs. libgcc) * Multiplikation 64bit x 32bit -> 64bit (Ersparnis über 200bytes in Vergleich zu C, viele KB zu libgcc) * Division 64bit / 32bit
); } else { frq = uint64_mul32(frq, (uint32_t)prescale); frq = uint64_div32(frq, freq_range); } /* Find precision (auto-range) */ uint8_t s = MIN_RES; while (s && frq >= (uint64_t)pow(10, MAX_RES)) {
-
Thread
Arduino: Ist boolean intern als Bit oder byte (char) organisiert?
schätzungsweise aus ganz anderen Gründen :) > Die Register heutiger CPUs haben eine Breite von 32 > oder auch 64Bit, je nach CPU und deren Mode, in dem > sie arbeitet. Zumindest ein klassischer MSP430 hat keine 32-Bit-Register, 64 Bit schon gar nicht -- und der ist sehr "heutig".
Egon D. schrieb im Beitrag #5593818: >> Die Register heutiger CPUs haben eine Breite von 32 >> oder auch 64Bit, je nach CPU und deren Mode, in dem >> sie arbeitet. > > Zumindest ein klassischer MSP430 hat keine 32-Bit-Register, > 64 Bit schon gar nicht -- und der ist sehr "heutig".
-
Thread
ItoA mit Uint64_t
Noch eine interessante Beobachtung (für uint32_t, uint64_t geht mit ltoa() ja nicht mehr): [c] text data bss dec hex filename 252 0 87 339 153 bm02a.elf 374 0 87 461 1cd bm03a.elf
Wilhelm M. schrieb im Beitrag #5009934: > Noch eine interessante Beobachtung > (für uint32_t, uint64_t geht mit ltoa() ja nicht mehr): > > [c] > text data bss dec hex filename > 252 0 87 339 153 bm02a.elf > 374 0 87 461
-
Thread
8 Kanal 50Ms/s AVR Logic-Analyzer
kleiner ATMega mit Schieberegistern > - großer ATMega > - 16 und 20MHz CPU-Takt > - 4 bis 16k RAM 4-32k Ram, eigentlich bis 64k, übliche Cache-Rams waren aber ohnehin meist 8kx8 oder 8kx32. > > Da sollte die Software ebenso flexibel sein ;-) Soll sie. Es wird auf PC-Seite nur eine Version geben, zum
Hallo, wer ein Ram im SDIP sucht, kann auch den CY7C199C-15 (32kx8) nehmen, den U. Radig http://www.ulrichradig.de/ in seinem AVR-DSO eingesetzt hat. (Kostet in seinem Shop ~5€)
-
Thread
Atmel kündigt AVR XMEGA-Mikrocontroller an
Naja das gibts doch schon -> AVR32, ARM
wie 'virtual port' läßt (letzte) Schwächen entfallen Vielleicht hat sich Atmel per 'Konkurrenz' AVR32 selbst Limits auferlegt - http://www.ineltek.com/de/products/AT_AVR32.php Deren Daten bzgl. Takt, RAM, Flash und Anzahl PINs sind sehr nahe an der XMEGA Linie und wohl als weiterer Aufstieg gedacht
-
Thread
AVR Bootloader
Hier noch die Meldungen: AVRASM: AVR macro assembler version 1.77.3 (Dec 20 2006 14:29:41) Copyright (C) 1995-2005 ATMEL Corporation Creating 'M32BOOT.hex' Assembling 'M32BOOT.ASM' Including 'm32def.inc' Including 'bootload.h
output vom assembler. lg, thomas <------------------- snip ------------------> AVRASM: AVR macro assembler version 1.77.3 (Sep 21 2005 08:43:03) Copyright (C) 1995-2005 ATMEL Corporation Creating 'm32boot.eep' Creating 'm32boot.hex' Creating 'm32boot.lst' Assembling 'm32boot.asm
-
Thread
ATMEL billiger und leistungsfähiger als PIC
16bit? -> Es gibt AVR32 mit 32bit. <Ironie> Was Ethernet betrifft, kann man ja auch nen AVR mit nem ENCxxxx von Microchip verbinden. Dann hat man auch Ethernet ;-) </Ironie>
auf AVR32 abfärbt -- was wohl nicht ganz gelang.
-
Thread
Grafikfähiger LCD Controller für 320x240 LCD mit 4 Graustufen
Avr Nix wrote: > Noch eine andere Frage welche Zahl ist bei dir Grau und Hellgrau? Die Farben sind 8bit Werte, man kann jeden Wert senden, es werden aber nur die 2 MSB verwendet: 0, 64, 128, 192 sind
3*32KByte für 640*480? Das stimmt aber nur für Graustufen. Und da wär ich mir nicht sicher, ob das noch vernünftig aus nem AVR zu holen ist. Lass mich aber auch gerne vom gegenteil überzeugen. Wieso nicht
-
Thread
Kann man folgenden Code platzsparender schreiben
/files/avr-gcc%20snapshots%20%28Win32%29/
mit 64 bit Multiplikation / Division */ /*******************************************************/ uint32_t Calc_FTW (uint32_t freq) { const uint64_t cSysClock = 125000000; uint32_t dds_word;
-
Thread
Zeigt her Eure Kunstwerke! Gesperrt Bilder
Änderungen mehr geben. Die Webseite aktualisiere ich am Wochenende. AVR ist jetzt ein Mega88 (Mega48 war geradenicht zur Hand, reicht aber). Zusätzlich kommen 2x 74LS164 dazu (oder HC oder ...). 1x 74ACT161 mehr sollte man haben weil dann 8k oder 32k Samplespeicher möglich
entgegen nimmt. Programme werden von SD Karte geladen. Das Monitor Programm kommt vom ersten I2C Eeprom (32K) und im zweiten Eeprom (64K) liegt momentan noch nichts. Eigenen Flash/ROM hat der Controller nicht. ISP wie beim AVR gibts nicht, Rx, Tx und DTR für Reset an der ganz "normalen" Seriellen reichen
-
Thread
WinAVR vs. Atmels Toolchain
Link den du unten angabst in einem Fall schon ein Jahr alt > ist, und im zweiten Fall sich auf das AVR32 Studio bezieht, nicht AVR > Studio 4. AVR32-Studio bringt nach der Atmel-Website auch AVR-Tools mit. Wobei ich nicht nachvollziehen kann, warum man AVR mit AVR32 verbäckt, was ja bereits bei jüngeren
Aufwand. > AVR32-Studio bringt nach der Atmel-Website auch AVR-Tools mit. Wobei ich > nicht nachvollziehen kann, warum man AVR mit AVR32 verbäckt, was ja > bereits bei jüngeren Releases won WinAVR der Fall war.
-
Thread
Neue ATTINY3226 usw. gar nicht mitbekommen
| 32 Pin | 48 Pin | 64 Pin ___________|____________|____________|_____________ AVR32DA28 | AVR32DA32 | AVR32DA48 | AVR64DA28 | AVR64DA32 | AVR64DA48 | AVR64DA64 AVR128DA28 | AVR128DA32 | AVR128DA48 | AVR128DA64 ___________|____________|____________|_____________ AVR32DB28 | AVR32DB32 | AVR32DB48 | AVR64DB28 | AVR64DB32 | AVR64DB48 | AVR64DB64 AVR128DB28 | AVR128DB32 | AVR128DB48
-
Thread
Netzwerkkarte mit RTL8019
Im aktuellen Code ist alles mit #if defined gemacht: #if defined (__AVR_ATmega32__) GICR|=0x40; MCUCR=0x03; MCUCSR=0x00; GIFR=0x40; #endif #if defined (__AVR_ATmega103__) EICR = 3; #endif #if defined (__AVR_ATmega128__)
DDRB = OUTPUT; //Interrupt 4 oder 0 Einschalten (für die Netzwerkkarte) #if defined (__AVR_ATmega103__) enable_external_int (1<<INT4); #endif #if defined (__AVR_ATmega128__) enable_external_int (1<<INT4); #endif #if defined (__AVR_ATmega32__) enable_external_int
-
Thread
Näherung für ArcusTangens?
rationalen Approximationen basierende Implementierung aber auch besser als die Konkurrenten, als da wären avr-f64 und fp64lib von https://www.mikrocontroller.net/topic/85256 Von der Genauigkeit bin ich bei asin, atan in etwa wie avr-f64 (Cordic) und besser als fp64lib (ebenfalls Cordic). Siehe untere Zeile
zu PATH hinuifügen, oder avr-gcc / avr-g++ per absolutem Pfad aufrufen. Das Verzeichnis kann nach dem Auspacken verschoben oder umbenannt werden. Es gibt 2 neue Optionen -mlong-double=32/64 (default: 64) -mdouble=32/64
-
Thread
Toolchain neuere AVRs
atmega6490 atmega6490a atmega6490p atmega64rfr2 atmega644rfr2 atmega16hva atmega16hva2 atmega16hvb atmega16hvbrevb atmega32hvb atmega32hvbrevb atmega64hve at90can32 at90can64 at90pwm161 at90pwm216 at90pwm316 atmega32c1 atmega64c1 atmega16m1
atmega2561 atmega256rfr2 atmega2564rfr2 atxmega16a4 atxmega16a4u atxmega16c4 atxmega16d4 atxmega32a4 atxmega32a4u atxmega32c4 atxmega32d4 atxmega32e5 atxmega16e5 atxmega8e5 atxmega32x1 attiny416 attiny417 attiny816 attiny817 atxmega64a3 atxmega64a3u atxmega64a4u atxmega64b1 atxmega64b3 atxmega64c3
-
Thread
AVR Ethernet Platine
Devices eben linear den kompletten externen SRAM einblenden kann. Nun zum SRAM: reichen wirklich die 64Kb aus ? Heutzutage ist es scon fast schwierig 32kb-64Kb SRAM's preiswert zubekommen. 128Kb sind meistens preiswerterund verfügbarer. Der Vorschlag vom Matthias zielt primär darauf ab eben solche größeren
gelesen das das mit den Xilinx CPLDs zu Problemen führen kann. (war aber widersprüchlich). Falls VQFP64 kein Problem wäre dann müsste man nur noch in Erfahrung bringen wo's den XC9572XL in VQFP64 zu kaufen gibt. Das Memory Banking ist im Grund einfach. In WinAVR zb. definiert man sich einfach eigene
-
Thread
Neue AVR-Tiny Generation, neue B-ATMegas, neue Entwicklungstools
Ich glaube 32 Bit Mikrocontroller werden in naher Zukunft verdrängt werden, durch 64 Bit ARM Systemen wo direkt Linux drauf läuft mit Echtzeit Modulen. 32 Bit ohne Linux ist so was wie 16 Bit. Eine Zwischenlösung
lange. Wofür ein Umschalten der Quelle? Das man den Takt zur Laufzeit auf einen Teiler 1/2/4/8/16/32/64/128/256 einstellen kann ist doch schon sehr schick. > Da wir CAN (fast) immer benötigen, ist unser standard AVR notgedrungen > der AT90CAN128. Ich benutze den 90CAN32 und den 16M1. Während
-
Thread
Mikrocontroller Rechenleistung reicht für aktuelles Projekt nicht?
root +(place<<1); } root = root>>1; place = place>>2; } return root; } uint32_t sqrtXX_floorC (uint64_t square64) { if(square64<65536ULL) { return sqrt16_floorC(square64); } else if(square64<4294967296ULL) { return sqrt32_floorC(square64); } else
{ return sqrt64_floorC(square64); } } int32_t x=0; int32_t y=0; int32_t z=0; int32_t a=0; int32_t zColumn1=0; int32_t zColumn2=0; int32_t zColumn3=0; void linearMoveTo(int32_t x1, int32_t y1, int32
-
Thread
AVR-GCC 4.8.1 tiny841 nicht bekannt
atxmega192d3 atxmega256a3 atxmega256a3b atxmega256a3bu atxmega256a3u atxmega256c3 atxmega256d3 atxmega32a4 atxmega32a4u atxmega32c4 atxmega32d4 atxmega32e5 atxmega32x1 atxmega384c3 atxmega384d3 atxmega64a1 atxmega64a1u atxmega64a3 atxmega64a3u atxmega64a4u atxmega64b1 atxmega64b3 atxmega64c3 atxmega64d3
atxmega192d3 atxmega256a3 atxmega256a3b atxmega256a3bu atxmega256a3u atxmega256c3 atxmega256d3 atxmega32a4 atxmega32a4u atxmega32c3 atxmega32c4 atxmega32d3 atxmega32d4 atxmega32e5 atxmega384c3 atxmega384d3 atxmega64a1 atxmega64a1u atxmega64a3 atxmega64a3u atxmega64a4u atxmega64b1 atxmega64b3 atxmega64c3
-
Thread
PC-ersetzen, welcher Prozessor f. 16-bit-Prgr.?
kann. > Ob 32 bit oder 64 bit ist egal. Es ist nicht egal: Win7-32 führt 16-Bit Programme aus, Win7-64 tut das nicht.
schrieb im Beitrag #7025516: >> Ansonsten eine beliebige Box nehmen, die noch Win7 SP1 kann. >> Ob 32 bit oder 64 bit ist egal. > > Es ist nicht egal: Win7-32 führt 16-Bit Programme aus, Win7-64 tut das > nicht. Ei gewiss fuehrt ein Virtual PC auch unter Win7-64 16 bit Programme aus. Und das
-
Thread
AX81 - ZX81 im AVR
es nicht ;-) Der ZX81 hat ja auch noch 8K ROM und sowohl ROM als auch RAM tauchen mehrfach in den 64K Adressraum auf. Gelöst habe ich das mit einer Memory-Map Tabelle, wo ich 256-Byte-weise den Z80 Adressraum auf AVR Flash oder AVR-Ram mappe. Leider bekommt am auf diese Weise keine 16K sondern nur 15,75K
Hello All I'm using avrdude via a UsbtinyIsp to program the avr 1284p, but is limited by the 64k file size barrier, what programmer have other poeple used, can some one please supply a programmed 1284p avr for me. thanks David
-
Thread
AVRs mit USB?
/ { print $2; }' avr-mcus.def[/pre] spuckt aus: [pre] atxmega32c3 atxmega16a4u atxmega16c4 atxmega32a4u atxmega32c4 atxmega64a3u atxmega64a4u atxmega64b1 atxmega64b3 atxmega64c3 atxmega64a1u atxmega128a3u
ATxmega16A4U ATxmega16C4 ATxmega192A3U ATxmega192C3 ATxmega256A3BU ATxmega256A3U ATxmega256C3 ATxmega32A4U ATxmega32C3 ATxmega32C4 ATxmega384C3 ATxmega384D3 ATxmega64A1U ATxmega64A3U ATxmega64A4U ATxmega64B1 ATxmega64B3 ATxmega64C3 AVR64DU28 AVR64DU32 [/pre]
-
Thread
Unbenutztes Register im 8-Bit Atmel?
dafür 32 Register, 64 I/Os, bei einigen AVRs 192 Bytes Extended-I/O und dann etwas SRAM... ...
ob >> man von der "Zeropage" (C64 anyone?), noch zwei weitere Bytes für einen >> Pointer abzwackt. > > Zeropage gibt es beim AVR nicht, Lang lebe die Zeropage! > dafür 32 Register, 64 I/Os, bei einigen > AVRs 192 Bytes Extended-I
-
Thread
I2C Display einfache Frage
eingebunden habe (die auf meiner Platte liegen) und so lief ein OLED-Display auch auf einem CH32V003, einem STM32F030 / F103 / F411. Hier jedoch nur die Datei, bei der AVR und STM8 eingebunden sind. Bei Verwendung für AVR ATmega328 und AVR-GCC als Compiler, hat das erzeugte Kompilat bei mir eine
AVRStudio.exe > Anwendungsversion: 4.19.0.730 > Anwendungszeitstempel: 4e569ce0 > Fehlermodulname: COMCTL32.dll Dann vielleicht könnte dir auch helfen: https://www.mikrocontroller.net/topic/316052#3420336 Ich mache es mit AVRStudio 4.19 so: avr-toolchain-installer-3.4.2.1573-win32.win32.x86.exe installieren
-
Thread
Besteht Interesse an einfacher Experimentierplatine fuer den Xmega128a1? Gesperrt
noch nicht mit PHYs gearbeitet. Schau mal unter ... http://www.ulrichradig.de/home/index.php/avr/eth_m32_ex http://www.ulrichradig.de/home/index.php/avr/avr-webmodule Ich hab die zwei Platinen selbst noch nicht ausprobiert, aber scheinbar funktionieren sie ja. Da kannst Du die Beschaltung für
atmega6450 atmega6490 atmega16hva at90can32 at90can64 at90pwm216 at90pwm316 atmega16u4 atmega32c1 atmega32m1 atmega32u4 atmega32u6 at90usb646 at90usb647 at94k atmega128 atmega1280 atmega1281 atmega1284p atmega128rfa1 at90can128 at90usb1286
-
Thread
millis denkproblem Gesperrt
Intervalzeiten größer als 49 Tage benötigt, muss man eben eine Extrawurst backen. Aber meist, reichen die 32 Bit völlig aus. [c] uint64_t wideMillis() { union { struct { uint32_t lo; uint32_t hi; }; uint64_t zeit; } static daten; uint32_t jetzt = millis
4320000000 ms = 0x1017DF800 ms [c] //#include "INTERVAL.h" const byte LED = LED_BUILTIN; uint64_t wideMillis() { union { struct { uint32_t hi; uint32_t merker; }; uint64_t zeit; } static daten; uint32_t jetzt {millis()}; if(jetzt < daten.merker
-
Thread
AVR Mikrocontroller Lohnenswert?
. Auch beim PC dachten viele, daß ihre Programme mit 64 Bit CPU schneller laufen als mit 32 Bit CPU.
daneben liegen hatte, das ich bis heute nicht benutzt habe (sogar mit zusätzlichem STK501, um LQFP64 ohne Löten nehmen zu können), und JTAG-ICE, auch bis heute unbenutzt. Falls jemand löten will: hier liegen auch noch von Pollin 3 Bausätze AVR-Net-IO. Da ist jeweils ein atmega32 drin, das Netzzeug
-
Thread
GCC Statische initialisierung.
__) || defined(__AVR_AVR64DB48__) || defined(__AVR_AVR128DB48__) #include "include\Pin\AVRxDB48_PinRegister.h" #include "include\Pin\AVRxDB48_PinNamen.h" #elif defined(__AVR_AVR32DB64__) || defined(__AVR_AVR64DB64
__) || defined(__AVR_AVR64DB48__) || defined(__AVR_AVR128DB48__) #include "include\Pin\AVRxDB48_PinRegister.h" #include "include\Pin\AVRxDB48_PinNamen.h" #elif defined(__AVR_AVR32DB64__) || defined(__AVR_AVR64DB64
-
Thread
Brauche Unterstützung beim OV7670 (bzw. SCCB)
Das mit dem Pegelwandler würde ich mir ersparen. Wenn du den AVR mit 8 Mhz betreibst, reichen für diesen auch 3Volt. Für eine gescheite Auflösung ist der avr eh zu langsam. Ein stm32f407-board mit dcmi-camera-Schnittstelle kostet um die 10€. Auch damit ist der Betrieb
Hallo, OT: damit es nicht langweilig wird: ESP32 mit OV2640 vom neuen LED-Display 64x64 in 1600x1200. Gruß aus Berlin Michael