-
Thread
Avrisp MkII vs. Avrdude
WinAVR 200607xx -> Avrstudio -> WinAVR 20070101 -> libusb-win32-filter... Der mkII Treiber ist in der Tat von Jungo (v7.0). Vielleicht hast du noch immer den 2006-snapshot Filter? Die libusb.dll im winavr
ich habe festgestellt, das nicht der Name der dll das Problem ist. Nach der Installation von WinAVR und libusb gibt es die libusb0.dll doppelt auf dem Rechner (zumindest bei mir). Eine liegt im Windows Verzeichnis: \Windows\system32\ die andere bei WinAVR: WinAVR\bin\ Sobald ich die Datei
-
Thread
µC Programmieren mit PII 300MHz
Ich würde dir AVR-Studio(Von Atmel.com) und WinAVR ( http://www.mikrocontroller.net/articles/WinAVR ) verwenden. Zum einfachen Programmieren über LPT kann man z.B. Yaap ( http://www.myplace.nu/avr/yaap/index.htm )
verkonfigurierten Fuses >programmieren/reparieren und ermöglicht das Debuggen auf vielen AVRs >mit <=32KB Flash. Damit besitzt er sogar mehr Leistungsmerkmale als der >wesentlich teurere JTAG ICE mkII. Ich benutze AVR-Dragon, AVR ISP MKII und JTAG ICE mkII. Und als Programmer ist der AVR ISP MKII der
-
Thread
Variabelnnamen evtl. durcheinander weil Speicher voll?
Fällen die [[Festkommaarithmetik]] tatsächlich der > sinnvollere Weg ist, zumal der auch beim WINAVR 64-bittig verwendet > werden kann. Wobei die natürlich keineswegs ressourcenschonender als 32-bit- Gleitkomma ist, sowohl hinsichtlich Rechenzeit als auch Speicherplatz- bedarf.
Fällen die [[Festkommaarithmetik]] tatsächlich der >> sinnvollere Weg ist, zumal der auch beim WINAVR 64-bittig verwendet >> werden kann. > > Wobei die natürlich keineswegs ressourcenschonender als 32-bit- > Gleitkomma ist, sowohl hinsichtlich Rechenzeit als auch Speicherplatz- > bedarf. In dieser
-
Thread
Heavy-Metal-Maschine von Elektor
den Overflows zur Verfügung stehen. Ohne ASM in Bascom m.E. nicht zu machen. [code] $regfile = "m32def.dat" $crystal = 8000000 $hwstack = 64 $swstack = 64 $framesize = 32 Const F1_preset = Fix(262 * 65536 / 31250) ' C Const F2_preset = Fix(294 * 65536 / 31250)
Melodie.elf: file format elf32-avr Sections: Idx Name Size VMA LMA File off Algn 0 .text 0000017e 00000000 00000000 00000094 2**1 CONTENTS, ALLOC, LOAD, READONLY, CODE
-
Thread
rs232 USBProg Problem
Wollts jezt mal kompilieren, aber: [pre]avr-gcc.exe -mmcu=atmega32 -Wall -gdwarf-2 -Os -fsigned-char -MD -MP -MT usbozi.o -MF dep/usbozi.o.d -c ../usbozi.c avr-gcc.exe -mmcu=atmega32 -Wall -gdwarf-2 -Os -fsigned-char -MD -MP -MT usbn2mc.o -MF dep/usbn2mc.o.d -c ../usbn2mc.c avr-gcc.exe -mmcu=atmega32 -Wall -gdwarf-2 -Os -fsigned-char -MD -MP -MT usbnapi.o -MF dep/usbnapi.o.d -c ../usbn2mc/tiny/usbnapi.c avr-gcc.exe -mmcu=atmega32 -Wall -gdwarf-2 -Os -fsigned-char -MD
-
Thread
Merkwürdige Compileroptimierung, wo liegt (mein) Denkfehler
konnte die Stelle lokalisieren und eingrenzen. Folgender Code zeigt das Problem: [C] uint8_t PufferB[32], PufferB1[32]; void SendZeich(uint8_t Zeich) { UDR = Zeich; } int main(void) { uint8_t zmax = 25; while (zmax--) {// hier absichtlich 64 reingeschrieben, um PufferB1 auch zu
Harald P. schrieb im Beitrag #3317143: > [C] > uint8_t PufferB[32], PufferB1[32]; > > > void SendZeich(uint8_t Zeich) > { > UDR = Zeich; > } > > int main(void) > { > uint8_t zmax = 25; > > while (zmax--) > {// hier absichtlich 64 reingeschrieben
-
Thread
How to: Snake
Snake kennt ja hoffentlich jeder :) Ich möchte dieses kleine Spiel auf einem Atmega48 mit einem 64*32 Display reaslisieren. Das Problem: Wie mache ich das möglichst ram freundlich? Natürlich soll man das ganze Spielfeld mit der "Schlange" füllen können. Der Inhalt des Displays passt zwar komplett
rechts. - kodiere man nun wie Peter vorgeschlagen hat die Länge eines Teilstücks in 6 Bits haben ich 64 Möglichkeiten, nun hat Eumel das Spielfeld auf 64*32 begrenzt. Wenn also das Teilstück 63 lang ist, beist sich die Schlange beim nächsten Zug selbst. -- Also kann ich mir die Richtung geradeaus sparen
-
Thread
Honeywell Rondostat HR20E per AVR steuern und konfigurieren
Display this information -v --version Display the program's version avr-size: supported targets: elf32-avr coff-avr coff-ext-avr elf32-little elf32- big srec symbolsrec tekhex binary ihex Report bugs to <http://www.sourceware.org/bugzilla/> [/pre] > ... das ebenfalls
Jens Müller wrote: > > Aber, nächster Fehler: > [...] > > avr-size: supported targets: elf32-avr elf32-little elf32-big srec > symbolsrec tekhex binary ihex > Damit hatte ich auch Probleme, ich habe mir jetzt damit geholfen: [pre] Index: /home/patrick
-
Thread
USBDMX-Nachbau von de
habe den USBDMX von DE nachgebaut. Nun funktioniert er nicht. Der USBN gibt die 4 MHz aus, die der AVR am Anfang als Takt hat. Allerdings die 3V3 sind nicht vorhanden (Pin 18). AVR ist korrekt geflasht. AVR ist wie auf dem Bild gefused, ist das richtig??? Vorlage nur von PonyProg! Sonnst
- 12.0MHz, 6CK +4ms Ext. Low-Freq. Crystal; 1k CK +4ms Ext. Low-Freq. Crystal; 1k CK +64ms Ext. Low-Freq. Crystal; 32k CK +64ms Ext. Crystal/Resonator Low Freq; 258 CK+4ms Ext. Crystal/Resonator Low Freq; 258 CK+64ms Ext. Crystal/Resonator Low Freq; 1k CK+0ms Ext. Crystal/
-
Thread
Bitmanipulation beschleunigen
c = __builtin_avr_insert_bits (0x55554444, in, 0); d = __builtin_avr_insert_bits (0xffff6666, in, 0); return (uint32_t) a + (((uint32_t) b) << 8) + (((uint32_t) c) << 16) + (((uint32_t) d) << 24); } [/c
> d = __builtin_avr_insert_bits (0xffff6666, in, 0); aha, nach 6 kommt f Eine andere Idee: [c] int8_t c=PORTD; //zum Test, damit nichts wegoptimiert wird register union{uint32_t i32;uint8_t b[4];}u; switch(
-
Thread
PC-Lint und <string.h> Fehlermeldungen
_t; typedef uint16_t uint_fast16_t; typedef int32_t int_fast32_t; typedef uint32_t uint_fast32_t; typedef int64_t int_fast64_t; typedef uint64_t uint_fast64_t; typedef int64_t intmax_t; typedef uint64_t uintmax_t;/*lint --flb*/ /*lint ++flb*/
_t; typedef uint16_t uint_fast16_t; typedef int32_t int_fast32_t; typedef uint32_t uint_fast32_t; typedef int64_t int_fast64_t; typedef uint64_t uint_fast64_t; typedef int64_t intmax_t; typedef uint64_t uintmax_t;/*lint --flb*/ typedef struct
-
Thread
LSB <----> MSB tauschen in c
=0x80;mask;mask/=2){ if (x&mask){y|=bit;} bit*=2;} Oder ohne Schleife: y=x&128?1:0 | x&64?2:0 | x&32?4:0 | x&16?8:0 | x& 8?16:0 | x&4?32:0 | x&2?64:0 | x&1?128:0; Inwieweit der Compiler das elegant löst?? Oder brute force: if(x&128){y=1;}else{y=0;} if(x& 64){y|= 2;} if(x& 32){y|= 4;} if(x& 16){y|= 8;} if(x& 8){y|= 16;} if(x& 4){y|= 32;} if(x& 2){y|= 64;} if(x& 1){y|=128;} Außerdem: for(h=1; h ; h<<1){ dürfte nicht die gewünschte Wirkung haben
-
Thread
[V] Wohnungsauflösung München Ramersdorf: Messgeräte, Funktionsgeneratoren, Oszi, Bauteile, PC uvm
4€; opvs, Komperatoren, Sensoren: 15€; dram, sram: 5€ 62 quarze: 10€ 63 dioden diacs triacs: 5€ 64 Z80 ctm 68B03, sockel, siemens 80c32, Z8400A, 80c535N-16: 10€ 65 logic ics: 5€ 66 gehäuse: 15€ 67 atmel xplained pro: sam d20, proto1, I/01, USBio, USB TTL: 40€ 68 AM27C256: 1€ 69 PEAK LCR45: 25
5xAT89C2051, 4xATMEGA6L, 3xAT89C52, 10x ATTINY11, ATINY15L, 2xATMEGA48, 5xATMEGA68V, 5x ATMEGA88, ATMEGA32: 10€? 54 audio bausatz e406: 3€ 57 hdmi kabel: 5€ 58 smd ics Überraschungspaket: 5€ 62 quarze: 10€ 64 Z80 ctm 68B03, sockel, siemens 80c32, Z8400A, 80c535N-16: 10€ 67 atmel xplained pro: sam d20
-
Thread
Frequenzteiler ohne Binary Counter
AVR internen Timer zu nutzen um das 1 KHz Signal zu teilen, und nur bei jedem 64. oder 42. Signal einen Interrut auszulösen. Beim Tiny85 wäre sogar Int0 und T0 der selbe Pin. Die Zeit ist aber relativ
, habe mich da scheinbar vertan zwischen den angebenen Daten im DB sowie der Datenrate. Ja, die 64Hz oder 32Hz sind für den Sekundenzeiger erstreckt über 6 Leds. Bei 64Hz sehe ich keine Abstufung mehr und er sieht sehr flüssig aus. 32Hz hatte ich bereits einmal getestet, jedoch ohne die derzeit genutzte
-
Thread
Arduino Betriebssystem
Anwenderprogramm ist mit 1 kByte RAM arg > limitiert. Ich würde heutzutage das Limit eher bei 16 oder sogar 32kByte > RAM sehen. Früher (tm), auf einem 6502, lief Basic auf 8kB ROM und 4kB RAM. Arduino gibt es mit 96kB RAM (64k+32k) und 512kB Flash. Merkst du was?
Arduino kennst, die keine blockierenden I/O Zugriffe machen. Die will ich sehen, zeige mir mal 20 für AVR oder 20 für STM32F3 (oder irgendeine andere single-core Architektur deiner Wahl), dann bin ich schon zufrieden.
-
Thread
Programmable Waveform Generator
und entsprechend die Toneinstellungen geändert. Das alles in PWM-Ausgang. Dafür brauche ich AVRs, wo 64 MHz-PLL für PWM zu haben ist. Mit Interrupts von einem anderen Timer, der von externen Frequenz gesteuert wird (um die Tonhöhe homogen zu haben, da bei fast allen AVR PLL nur von RC-Oszillator arbeiten
Stimme genug zu tun, und das Wichtigste ist ja, immer und wieder rechtzeitig neue Byte auszugeben. AVR in DIP28 kostet so wenig, daß es sich lohnt, eher mehr AVR zu benutzen, als komplizierte 8-bit-Bus auf einer Platte auf mehreren Verbraucher zu führen. D.h. einfach AVR-Port als Register für parallele
-
Thread
ATMEGA128 Texte im Bootsektor definieren
: > Im Bootcode des ATMEGA128 müssen für den Lesezugriff Befehle wie > pgm_read_byte_far(cp) mit 32-Bit-Adressen verwendet werden. Die Pointer-Arithmetik reicht doch für 64K Worte = 128 KBytes. *Far* bräuchte man erst für den ATMega256 etc.
const prog_char bootmsg[] = "ATMEGA324 Bootloader"; bootmsg wird als 16Bit-Adresse übersetzt. Im 64k+-Bereich habe ich es noch nicht geschafft, die Bootmessage als 32Bit-Adresse zu definieren.
-
Thread
Projekt: 200MHz DDS-Generator
und die 64dB nicht erreicht werden - so wurde dann halt ein 0 bis 95dB-Dämpfungsglied daraus, indem ich die letzte Stufe auf ebenfalls -32dB umbestückt hatte und die fehlenden -32dB extern dazuschaltete...
und die 64dB nicht > erreicht werden - so wurde dann halt ein 0 bis 95dB-Dämpfungsglied > daraus, indem ich die letzte Stufe auf ebenfalls -32dB umbestückt > hatte und die fehlenden -32dB extern dazuschaltete
-
Thread
Ich verstehe diesen Code nicht
PA_BASE im Süeicher liegt weiß der Compiler dann, dass PMD auf Adresse PA_BASE + 0, OFFD auf PA_BASE + 32, DOUT auf PA_BASE + 64 liegt, usw.
Hannes J. schrieb im Beitrag #7701316: > MD auf Adresse PA_BASE + 0, OFFD auf PA_BASE + 32, DOUT auf > PA_BASE + 64 Nö, es sei denn man zählt Adressen in Bits statt in Bytes.
-
Thread
(STM32) Register Lib mit define oder nicht define..
Ich komme aus der AVR Ecke und bin es jahrelang gewohnt meine Register selbst zu beschreiben. Nun gibt es ja für die STM32 die HAL Lib und die StdPeriph Lib. Die nehmen einen ja schon ne Menge Arbeit ab, aber ich mach
ausreichend header für die ARMs. Und die sind ordentlich angelegt, nicht wie dieser Shift-Scheiss aus der AVR Ecke. Sorry, musste sein. Hier ein Beispiel von den ARM Machern: http://www.keil.com/dd/docs/arm/st/stm32f10x/stm32f10x.h Schön alle Flags als Masken, wie es sich gehört.
-
Thread
Arduino Mega2560 mit externem RAM: linker flag für .data section geht nicht
vermurksten 2560er noch mit externem RAM zu erweitern - die werden dadurch nicht besser. Mehr als 64kB Kode+Daten wird mit 8-Bit-CPUs immer ein häßliches Gewurschtel - da sollte man doch mal den Schritt zu 32-Bit-CPUs wagen. Ist ja nicht so, dass die schwieriger zu kommen oder teurer sind ...
foobar schrieb im Beitrag #6925362: > Mehr als > 64kB Kode+Daten wird mit 8-Bit-CPUs immer ein häßliches Gewurschtel - da > sollte man doch mal den Schritt zu 32-Bit-CPUs wagen. Ist ja nicht so, > dass die schwieriger zu kommen oder teurer sind ...
-
Thread
AVR Atmega64-A ISP funktioniert nicht
Grundvoraussetzung, damit das überhaupt geht. Also: Du hast folgende VCC/GND Paare: 21/22 52/32 64/63 Jedes einzelne Paar braucht einmal 100n keramisch, und zwar so dicht an die Prozessorpins, wie es irgendwie geht. Jeder mm zählt. Natürlich müssen alle Versorgungspins angeschlossen sein.
100nF(am UNO) angeschlossen. Gleiche Fehlermeldung wie bisher. Ich habe bei MegaCore den Atmega64 ausgewählt, oder brauche ich extra eine Bibliothek für den Atmega64-A?
-
Thread
ATTiny25: unklare Interaktion PROGMEM <-> ADC
Timer1 kann man den ADC-Trigger nicht starten. Ev. Timer0 Prescaler auf 8 und OCRA im Interrupt auf 64 (bzw 256-64) setzen für 64 Takte á 500ns (16MHz / 8) und den Compare Match Interrupt verwenden? Könnte gehen ...
ungetestet. > Also näher an 'gerade so' als an 'ganz locker' :-) Wobei der oben gezeigte, von avr-gcc erezgte Code nahelegt, dass du eine ältere Compilerversion verwendest. Ich würde tippen nicht neuer als avr-gcc v4.6, also z.B. ein WinAVR.
-
Thread
warning: internal error: out of range error
/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib/avr6\libc.a(dtoa_prf.o): In function `dtoa_prf': (.text+0x6): warning: internal error: out of range error c:/programme/winavr/bin/../lib/gcc/avr/4.3.2/../../../../avr/lib
beiden Sprünge sind genau die beiden Dateien, die der Linker > bemängelt Pointer sind beim GCC für AVR nur 16 Bits breit, auch wenn sie auf Funktionen zeigen und der AVR mehr als 64KW/128KB Flash hat. Folglich müssen alle Funktionen, oder mindestens alle die irgendwo indirekt genutzt werden, eine Adresse
-
Thread
Grundsätzliches zum Atmega256
spess53 schrieb im Beitrag #2133147: > ... Alles im AVR zu haben ist doch wohl die einfachere Sache. Solange die Bilddaten da nur einmal rein müssen und sich nicht mehr ändern, hast Du sicher recht. Bei neuen Bilddaten jedesmal den AVR neu flashen zu
überhaupt den 100-pol. brauchst? Mit 256k-Flash gibt es auch noch den ATMega2851 im etwas freundlicheren 64-Pin-Gehäuse. MfG Spess
-
Thread
Wir haben ihn noch nicht gefeiert!
. Mit den Segmentregistern konnte man problemlos 4 x 64 KByte addressieren (CS SS, DS, ES) und mit wenig Aufwand auch 4x 1 MByte mit 32 bit far Zeigern. Man musste also nur alle 64 kByte ein 16 Bit Segmentregister laden... Muss wirklich furchtbar gewesen
, dass sie nur _eine_ 64-Bit x86 Version unterstützen. Weshalb Intel gezwungen war, AMD64 zu übernehmen, statt eigene Brötchen zu backen. Ohnehin hatte Intel eigentlich überhaupt keine Lust darauf, x86 jenseits der 32 Bit zu
-
Thread
Inkrementalgeber an CMOS Dekadenzähler CD4017
erzeugt Unsinn. Die IDE meckert dabei schon mit left shift overflows. Hierbei muss ein cast auf uint32_t erfolgen. [c] uint32_t temp = 0; temp = Wire.read(); // und zum 32 Bit Wert formen temp |= (uint32_t)Wire.read() << 8; temp |= (uint32_t)Wire.read() << 16; temp |= (uint32_t)Wire.read
Ausgangsimpulse mit feiner Auflösung erzeugen. Ein 16-bit Timer ist dafür ungeeignet. Auf einem STM32 dauert die ISR für die Verarbeitung von uint32_t Werten < 1 µs.
-
Thread
Nokia 6100 Grafiklibrary die Zweite
Fontroutinen wurden becleant und sind jetzt effizienter - Fontroutinen unterstützen nun auch Fonts mit 8,16,32,64,128 und 256 Farben, eg. 1,2,3,4,5,6,7,8 Bits per Pixel. Dazu muß aber in glcd.h der Wert COLOR_TABLE_BITS angepasst werden. - komprimierte Fonts werden schneller und effizienter angezeigt als nicht
or FITNESS FOR A PARTICULAR PURPOSE. Compiling: test.c avr-gcc -c -mmcu=atmega32 -I. -Os -mcall-prologues -funsigned-char -funsigned-bi tfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-adhlns=test.l st -std=gnu99 test.c -o test.o In file
-
Thread
Hilfe Bei Assembler Program
Hallo zusammen, mein Programm soll folgendes Erledigen: Ich habe 64 digitale Ausgänge die ich zu 8 Segmenten á 8 Ausgänge zusammenfasse. Die Segmente werden von einem ATmega32 an PortC in einem Timer-Interrupt ausgewertet. Die Segmente werden nacheinander von PortA aktiviert
Atmega32... PORTC... Wie ist eigentlich die JTAG Fuse eingestellt?
-
Thread
MC PIC - Warum diese Ungleichbehandlung?
Microcontrollerfamilien zu zählen und bin zu folgendem Ergebnis für den Monat Juli 2012 gekommen: AVR: 256 ARM: 81 PIC: 64 Arduino: 31 MSP430: 16 8051: 10 AVR32: 7 C16x: 5 TriCore: 2 PowerPC: 1 R8C/M16C/M32C
Artikel zu "PIC" bereits gibt! Warum gibt es keine Verlinkung darauf: AVR ARM PIC MSP430 8051 AVR32 --> Finde den Fehler! 3. Datenblätter: z.B. gängiger Typ 18F45K20 --> Warum kein Datenblatt zu dem Controller? Oder ganz doof gefragt: Wie lege ich dieses an -
-
Thread
Das passiert wenn...
Den Angaben nach sind immer 4 LEDs in Reihe. Das ganze 16 mal, macht also die 64 LEDs. Macht also 48 LEDs. Das ganze mal 2 macht 96 LEDs udn somit 96 FETs. Wie man die 96 LEDs ohne Schieberegister und ohne Multiplex an einen AVR bekommt, möchte ich mal sehen... Das sowas möglich
Die Bilder sind auf einer SD Karte die mit der Steuerung am Blatthalter hängt. Es sind 64 RGB LEDs mit 512 Farben. Pro Umdrehung 796 Zeilen. Ansteuerung mit einem PIC32MX796 (80MHz). LEDs werden mit 20MHz SPI angesteuert. Im Blatt sind 24 cPLDs Mein Problem war lange Zeit gleichzeitig
-
Thread
CAN-Bibliothek für den at90CAN128 und das AVRStudio
Hier ein Beispiel, um Daten mit variabler Laenge und extended ID zu verschicken: [c] #include <avr/io.h> #include <avr/interrupt.h> #include <inttypes.h> #include <stdbool.h> #define F_CPU 16000000ULL #include <util/delay.h> #include "can.h" void sleep(uint32_t i) { while(i--)
Ich habe in der Zeit meinen Rechner neu Installiert von XP (ich weiss ziemlich alt) auf WIN 7 Pro 64 bit und von AVR Studio 6.1 beta auf 6.1 normal gewechselt. Habe übrigens noch mehr CAN Projekte ebenfalls gut versioniert ist überall das gleiche, neu dompiliert keine CAN Botschaften, altes File und
-
Thread
AVR-Compiler
Hallo, suche einen AVR Compiler und Programmierumgebung, habe zwar einige gefunden komme aber nicht so klar mit. AVR-Studio 4 AVR GCC Oder kann mir mal jemand erklären wie die funktionieren? Gruss aNton
16 Ausgängen, die Seriell in den AT90S2313 eintreffen und augegeben werden. Dabei verhält sich der AVR mit den restlichen Ports (PB1,PB2,PB3,PB4) wie ein Zähler und Taktet die beiden De- und Multiplexer. Was meinst du ist es jetzt besser? Wenn ich z.B. jetzt 32 Ein/Augänge möchte benutze ich die restlichen
-
Thread
kompilieren eines c-programms ohne make für avr32
-D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 CCDEPMODE = depmode=none CFLAGS = -Os -pipe -Os -I/home/username/ICnova/build_avr32/staging_dir/usr/include -I/home/username/ICnova/build_avr32/staging_dir/include --sysroot=/home/username/ICnova/build_avr32/staging_dir/ -isysroot /home/username/ICnova/build_avr32/staging_dir -msoft-float -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -Wall target = avr32-unknown-linux-gnu target_alias
-
Thread
Suche geeignete Simulationssoftware
256 kB FLASH, das muss man erstmal sinnvoll mit Inhalt füllen. Für dich tuts wahrscheinlich ein MEGA32 (32 kB) oder MEGA64 (64kB). MFG Falk
Hallo Ich würde dir den den ATmega32 empfehlen. Da er in DIL Bauform erhältlich ist. Und zur anbindung vom AVR zu PC und zurück. Könnte man die Interne UART nehmen und mit hilfe eines USBtoRS232 adapter mit dem PC verbinden. Der
-
Thread
ADE7758 via SPI
"Mode" ich arbeiten muss für den Chip? Hier die Initalisierung (Arbeiten tue ich mit einem MEGA32U4) : [c] void spi_master_init(uint8_t prescaler, uint8_t clock_option) { /* ONLY FOR MEGA32! */ #if defined(__AVR_ATmega32__) { /* set MOSI and SCK output, all others input */
case 8: {SPSR |= (1<<SPI2X); SPCR |= (1<<SPR0); }break; // prescaler 8 case 32: {SPSR |= (1<<SPI2X); SPCR |= (1<<SPR1); }break; // prescaler 32 case 64: {SPSR |= (1<<SPI2X); SPCR |= (1<<SPR1) | (1<<SPR0); }break; // prescaler 64 default: {SPSR |= (1<
-
Thread
CPU & Speichertimings
, wie soll das gehen wenn der Datenbus nur 32 Bit breit ist und der Adressbus 32 Bit bzw. heutzutage 64 Bit. 4 Befehle in 1 Takt obwohl sie mehrere Takte lang sind?! Dann hätte das ganze ja einen Asynchronen Anteil. Ich dachte Befehle werden nacheinander
Sebastian T. schrieb im Beitrag #2975134: > Mhs, wie soll das gehen wenn der Datenbus nur 32 Bit breit ist und der > Adressbus 32 Bit bzw. heutzutage 64 Bit. > 4 Befehle in 1 Takt obwohl sie mehrere Takte lang sind?! Dann hätte das > ganze ja einen Asynchronen Anteil. Mit einem Takt
-
Thread
MyAVR Display
> #include <avr/io.h> > #include <util/delay.h> sind die nicht vom WinAVR? Gibt es die überhaupt bei dem komischen Workpad? Ich hab auch ein MK2 Board mit MyAVR Display, aber hab gleich WinAVR benutzt, und
Thomas D wrote: > Ahh, habs schon gecheckt. nur um sicher zugehen: den Mega8 habe ich auf dem myAVR-Board programmiert, in dem das USB-Teil dabei dort eingesteckt war, Mega32 und Mega644u auf meiner selber designten Platine und dem RN-Controlboard mittels des 10poligen Steckers auf dem Programmer
-
Thread
ATMega644p: Fuses Rätsel.
: load data lfuse data from input file 0x64: avrdude: input file 0x64 contains 1 bytes avrdude: reading on-chip lfuse data: Reading | ################################################## | 100% 0.00s avrdude: verifying ... avrdude: 1 bytes
recv(): checksum error avrdude: stk500v2_program_enable(): bad STK600 connection status: Unknown (0x64) avrdude: initialization failed, rc=-1 avrdude: AVR device initialized and ready to accept instructions avrdude: Device signature = 0x000000 avrdude: Yikes! Invalid device signature. avrdude: Expected
-
Thread
Ansteuern von 300 RGB-LEDs
avr
>einfach zuviel. Logisch. Na dann nimm einen Mega16 und die [[Soft-PWM]] aus dem Tutorial, auf 32 Bit aubohren (einfach von uint8_t auf uint32_t ändern, Interruptroutine anpassen) und schwups kann man mit einem AVR 10 RGB-LEDs steuern. Davon 30 Stück gebaut macht 300 RGB-LEDs. Kosten sollten sich
-
Thread
Fehler bei avr-gcc 4.8.1 und nicht bei 4.3.3
Wenn es nur um die Tools geht (avr-gcc + binutils + avr-libc), die hatte ich vor einiger Zeit mal für MinGW32 generiert: https://sourceforge.net/projects/mobilechessboar/files/avr-gcc%20snapshots%20%28Win32%29/ Das neueste ist
prompt eine "Fehlermeldung": [c] c:/gcc-8-avr-mingw32/bin/../lib/gcc/avr/8.5.1/../../../../avr/bin/ld.exe: address 0x801402 of Multitasking.elf section `.bss' is not within region `data' c:/gcc-8-avr-mingw32/bin/../lib/gcc/avr/8.5.1/../../../.
-
Thread
Atmel-µC mit USB-Controller im DIP-Gehäuse
werden würdest. Z.B. PIC18F4553(DIP40)/2553(DIP28), oder aus der 16 Bit Serie den PIC24FJ64GB002, oder aus der 32 Bit Serie den neuen PIC32MX220F032B. Den passenden USB-Stack gibts kostenlos bei Microchip zum Download. Ab und an lohnt sich ein Blick über den Tellerrand. fchk
? Ein PIC32 spielt in einer ganz /anderen/ Liga. Markus W. schrieb im Beitrag #2512995: > Ich werd einen AVR ATmega > verwenden, weil ich diese Serie besser kenne. Die Frage ist allerdings, kennst Du USB
-
Thread
Günstiges und einfaches Mini-Controller Board, was würdet ihr heute nehmen?
Hallo, also nach einigen Jahren, in denen ich mal mit AVR gebastelt hatte, bin ich vor einiger Zeit wieder eingestiegen mit dem ESP32 (mit einem inzwischen veralteten Dev Kit V4, ESP WROOM 32D). IMO ist das ein sehr gutes Board, der ESP hat sehr vielfältige
> verstehen. So sehe ich das auch. Die gibt es in guter Qualität für AVR und STM32 für Software und(!) Hardware.
-
Thread
Bascom Bootloader Atmega32 plu Fusebits
http://www.fam-markus.de/fotoforum/avr/flashen/flashen1.jpg Das sind meine Einstellungen zum Programmer: http://www.fam-markus.de/fotoforum/avr/flashen/settingsisp.jpg ich verwende eien passiven (mit Widerständen) ISP Adapter Das sind meine Fusebits die ich gesetzt habe http://www.fam-markus.de/fotoforum/avr/flashen/fusebits.jpg danach klicke ich wieder auf das grüne Chipsymbol und es wird geflasht http://www.fam-markus.de/fotoforum/avr/flashen/writing.jpg http://www.fam-markus.de/fotoforum/avr/
-
Thread
Problem mit zu großen Arrays im EEPROM
Hallo Forum, ich bekomme meine Arrays leider nicht in den internen EEprom (mega32) unter und suche daher eine gute Möglichkeit wie ich dies anders regeln kann. #include <avr/eeprom.h> #ifndef EEMEM #define EEMEM __attribute__ ((section (".eeprom"))) #endif uint16_t varay1
schaffen. Mir bleibt momentan nur, meinen Speicherbedarf soweit zu reduzieren um es in nen Mega32 und nen 24c512 unterzubringen. Ich denke mit Interpolation könnte das wohl klappen, am Ende merkts wohl nichtmal jemand wenn der AVR nur linear interpoliert und nicht als Spline wie mein PC-Programm
-
Thread
SPS Betriebssytem
gerade nochmal durch den Kopf gehen lassen und bin zu folgendem Entschluss gekommen! MCU: ATmega32-16 DIP mit 16MHz Quarz Inputs: 16 Stück (durch 2x 74HC595)ggf mit Optok. Outputs: 16 Stück (durch 2x 74HC165)ggf mit Optok. ADC: 8 ADC`s (die des AVR`s) PWM: 2 CAN: MCP2515 RS232:
, einen "mini-AWL-Parser" in meinem uC zu implementieren, so das ich das Programm nicht mit in den AVR Flashen muss, sondern es in ein externes EEProm (wie die I2C EEproms 24C64) drücken kann. @123 Nein, die Platine ist 1. Komerziell und keine Codeveröffentlichung 2. Meine Ideen lassen sich nicht
-
Thread
Experimente mir Controller im QFP- Gehäuse
oder auch sowas in der Art: http://cgi.ebay.de/AVR-ATmega-64-128-QFP64-TQFP64-ISP-Programmer-Adapter-/290406212659?cmd=ViewItem&pt=LH_DefaultDomain_0&hash=item439d8f2433
Wie wär's damit: http://www.olimex.com/dev/avr-m32.html
-
Thread
FFT mit ATmega88
mögliche das ich hier also wählen kann ist eine FFT_N = 128 -> (2Byte * 128 + 4Byte * 128 + 2Byte * 64) = 896 Byte das meine FFT als Speicher braucht. Richtig? 4. Mit der 128 Punkt FFT bekomme ich also 64 Spektrumbalken = 64 Koeffizienten (128 Messwerte wobei aber nur die ersten 64 relevant sind da
4. Mit der 128 Punkt FFT bekomme ich also 64 Spektrumbalken = 64 Koeffizienten (128 Messwerte wobei aber nur die ersten 64 relevant sind da die restlichen 64 gespiegelt sind) Richtig? 5. Auflösung = Samplingfrequenz / (FFT-Länge/2) = 22,154kHz
-
Thread
Arduino IDE 1.74 <-> 1.89
Uno und Mega. Meine IDE kennt den > noch nicht. Du musst in der Boardverwaltung "Arduino megaAVR Boards" nachinstallieren, aktuell v1.8.5 Wegen avr-gcc 7.3 mit der IDE. Ab IDE v1.8.12 wird das Paket "Arduino AVR Boards" automatisch installiert, aktuell v1.8.2. In älteren IDEs kann man das selbst nachinstallieren und hat den aktuelleren avr-gcc.
-
Thread
ATtiny85 kann nicht angesprochen werden.
4 0 no 512 4 0 4000 4500 0xff 0xff flash 65 6 32 0 yes 8192 64 128 4500 4500 0xff 0xff signature 0 0 0 0 no 3 0 0 0 0 0x00 0x00 lock 0 0 0
--- ---- ------ ----- ----- --------- eeprom 65 5 4 0 no 64 4 0 4000 4000 0xff 0xff flash 65 6 32 0 yes 1024 32 32 4500 4500 0xff 0xff signature 0 0 0 0 no 3