-
Thread
Toolchain neuere AVRs
keine Unterstützung anbietet. Angeblich soll das ja die gleiche Toolchain wie beim Studio 7 sein. avr-gcc --target-help liefert mir (u.a.): avr1 avr2 avr25 avr3 avr31 avr35 avr4 avr5 avr51 avr6 avrxmega1 avrxmega2 avrxmega3 avrxmega4 avrxmega5 avrxmega6 avrxmega7 avrtiny at90s1200 attiny11
Andreas B. schrieb im Beitrag #6149635: > avr-gcc --target-help liefert mir (u.a.): > avr1 avr2 avr25 avr3 avr31 avr35 avr4 avr5 avr51 avr6 avrxmega1 [...] Das sieht stark nach Assembler-Optionen aus, die beim genannten Kommando mit aufgelistet
-
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
GCC erzeugt zu kurze Interrupttabelle auf ATTiny24
Ich versuche seit Stunden verzweifelt folgenden, kleinen Programmabschnitt mit avr-gcc unter Windows auf einem ATtiny24V zum laufen zu kriegen: [c] #include <avr/interrupt.h> #include <avr/io.h> #include "Tools.h" ///<summary>ADC Interrupt</summary> ISR(ADC_vect) { volatile
-adhlns=./BUILD/test.lst -std=gnu99 -MMD -MP -MF ./BUILD/test.o.d test.c -o BUILD/test.o test.c:28: warning: function declaration isn't a prototype test.c:27: warning: return type of 'main' is not 'int' avr-gcc -Wl,-Map=./BUILD/main.map,--cref ./BUILD/test.o -o ./BUILD/main.elf avr-objcopy
-
Thread
Pollin LCD1602 keine Anzeige
dann die Anzeige 'TESTABCDEFGHIJKL Das passt aber nicht ganz, 32 + 8 Zeichen sind 40(dezimal!)=$28 $40 = 64(dez) $28+$80=$A8 Dann versuche doch mal bitte: ldi ZL, LOW(text1*2) ldi ZH, HIGH(text1*2) rcall lcd_flash_string ;text1 ausgeben ldi temp1 , $A8 rcall lcd_command
die Anzeige 'TESTABCDEFGHIJKL > > Das passt aber nicht ganz, 32 + 8 Zeichen sind 40(dezimal!)=$28 > $40 = 64(dez) Der Controller hat aber keine zwei mal 64 Bytes DD-RAM sondern nur zwei mal 40 Bytes. Unter diesem Aspekt passt das schon. Auch wenn die Adressen einen Versatz von 64 Bytes haben.
-
Thread
C-Aufgabe: bedingtes Inkrementieren
= Ausgangswert - 0 32 - 47 => 0 - 15 = Ausgangswert - 32 48 - 63 => 32 - 47 = Ausgangswert - 16 64 - 79 => 0 - 15 = Ausgangswert - 64 80 - 95 => 48 - 63 = Ausgangswert - 32 96 - 111 => 0 - 15 = Ausgangswert - 96 112 - 127 => 64 - 79 = Ausgangswert - 48 Wenn ich nun das obere Nibble des Ausgangswert
62 63 64 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 [/
-
Thread
Ethernet Anbindung
Sebastian W. schrieb im Beitrag #4306837: > das Gefrickel mit ENC28J60 und AVR NETIO hat den Vorteil, dass es hier und an vielen anderen Ecken des Netzes etliche Leute gibt, die sich damit auskennen und helfen können. Auch das Angebot an funktionsfähiger Software
mindestens Faktor 5 schneller als per Bitfriemel-Software. Die genannten AVRs sind aber alle im TQFP64 oder TQFP100 Gehäuse, der Ethernet-Controller ebenso. Plus: Wenn der AVR mit voller Geschwindigkeit laufen soll, braucht er 5V und damit am External Memory Interface zwei Pegelwandler wie zB 74LVCC4245
-
Thread
Huhu - AVR XMEGA-Eval-Board für 29 US-$
ATxmega192D3 ATxmega256A3 ATxmega256A3B ATxmega256D3 ATxmega32D4 ATxmega64A1 ATxmega64A3 ATxmega64D3 ATxmega64D4
AVR Dragon and a PDI device.
-
Thread
Bitmanipulation beschleunigen
eProfi schrieb im Beitrag #4849532: >> d = __builtin_avr_insert_bits (0xffff6666, in, 0); > aha, nach 6 kommt f > in diesem Fall schon: Input hat 7 (nicht 8!) Bits, Output daher 28 (nicht 32). Daher wollte ich in diesem Fall die obersten 4 Bits auf
47a: 3f e0 ldi r19, 0x0F ; 15 47c: 28 2f mov r18, r24 47e: 20 7c andi r18, 0xC0 ; 192 480: 20 34 cpi r18, 0x40 ; 64 482: 41 f7 brne .-48 ; 0x454 <variant_eprofi+0x4a>
-
Thread
DTMF decoder
scheint das (ohne Goertzel!) zu gehen: http://www.elo-web.de/elo/mikrocontroller-und-programmierung/avr-anwendungen/dtmf-decoder
der einmaligen Leistungsberechnung. Das wird wahrscheinlich drauf rauslaufen, dass man vielleicht 64x oder 128x vor sich hin goertzelt und danach die Leistungsberechnung vornimmt. Also hab' ich 64 oder 128 Samples vorliegen, beim AVR bestenfalls mit 10bit Aufloesung. Da kann ich mir gut vorstellen,
-
Thread
floating point coprocessor
Aber man sollte eigentlich VORHER die Rechenleistung abschätzen und dann erst den µC auswählen. avr
Dataflasch mit SPI eine Lösung: http://www.atmel.com/products/DataFlash/default.asp avr
-
Thread
Erzeugung von reduntantem Code in AVR-GCC
Versinen gibt's keine, da ich kaum noch zu avr-gcc beitrage.
r17, r15 step >>= 1; 1fa2: 06 95 lsr r16 1fa4: 21 97 sbiw r28, 0x01 ; 1 }while(step > 0); 1fa6: a1 f7 brne .-24 ; 0x1f90 <calibrateOscillator+0x12> [/code] Interessanterweise erzeugt AVR-GCC einen eigenen Schleifenzähler in r28/r29
-
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
Digitaluhr mit geringem Stromverbrauch
designen. Beim Ali gibt es diese LCDs auch mit 6 Stellen (du wolltest gerne 6 Stellen?). Und statt des AVR128DA48 nimmst du einen AVR128DA64 damit du mehr IOs für das Display hast. Die Platine musst du natürlich neu machen. Da einen DCF77 Empfänger dran und diesen dann einmal am Tag einschalten zum synchronisieren
Beim Ali gibt es > diese LCDs auch mit 6 Stellen (du wolltest gerne 6 Stellen?). Und statt > des AVR128DA48 nimmst du einen AVR128DA64 damit du mehr IOs für das > Display hast. Die Platine musst du natürlich neu machen. Sehe ich das richtig, dass der avr128da64 zwar mit 3V läuft, aber dann auf
-
Thread
64 Stall- Laternen mit dimmbarer LED ansteuern
Mit Schieberegistern: http://mino-elektronik.de/AVR_PWM_64/AVR_PWM_64.htm
m.n. schrieb im Beitrag #5348041: > Mit Schieberegistern: > http://mino-elektronik.de/AVR_PWM_64/AVR_PWM_64.htm sehr geil! Ich bin offenbar zu blöd zum googeln. oder zu müde. Muss jetzt schlafen, falls man sich wundert, warum ich nicht reagiere. Vielen Dank erstmal für Eure Antworten
-
Thread
Neue AVR-Tiny Generation, neue B-ATMegas, neue Entwicklungstools
Ich arbeite viel mit 32 Bittern. Oft greife ich aber immer noch zu einem AVR oder PIC. Weil ich das DIP18 oder DIP28 Gehäuse mag. Wie der rechnet ist mir egal.
Pinner. 12bit ADC wäre auch nicht schlecht. Da wir CAN (fast) immer benötigen, ist unser standard AVR notgedrungen der AT90CAN128. Ist zwar alt, aber gut beschaffbare Lagerware. Die neueren ATmega64M1 waren zum Zeitpunkt der Entscheidung immer noch nur sporadisch zu erhalten.
-
Thread
Frequenzberechnung bei PWM
zu sein. Hab mich mal ein bisschen eingelesen und folgendes Programm geschrieben: [c] #include <avr/io.h> #include <avr/interrupt.h> #include <stdint.h> void Init_Timer_2(void) { //440,1408Hz TCCR2 = (1 << WGM21)|(1 << CS22)|(1 << COM20); //CTC-Modus, Teiler auf 64, Toggel des Pins D7
142 Wenn der Timer von 0 bis 141 zählt, dann braucht er dazu 142 Zyklen. 125000 / 142 = 880,28 880,28 / 2 = 440.14
-
Thread
avr-gcc-4.1.1 verweigert sich dem ATtiny13
:43:11 13.10.2006) binutils=2.15 (13:20:58 26.01.2007) gcc --target-help: Known MCU names: avr1 avr2 avr3 avr4 avr5 at90s1200 attiny10 attiny11 attiny12 attiny15 attiny28 at90s2313 at90s2323 at90s2333 at90s2343 attiny22 attiny26 at90s4433 at90s4414 at90s4434 at90s8515 at90s8535 at90c8534
atmega8515 atmega8535 atmega16 atmega161 atmega162 atmega163 atmega169 atmega32 atmega323 atmega64 atmega128 at94k no emulation specific options. avr-as --target-help Known MCU names: avr1 avr2 avr3 avr4 avr5 at90s1200 attiny10 attiny11 attiny12 attiny15 attiny28 at90s2313 at90s2323 at90s2333
-
Bild
Software-Fenster zur Mikrocontroller-Programmierung
ATML2795042700001909) - Device Programming Tool Device Interface Device signature Target Voltage mEDBG AVR64DD28 UPDI 0x1E961B 5,0 V Interface settings Detected device Device name AVR64DD28 Device signature 0x1E961B Revision T Device identifier AVR NVM version 2 OCD version 1 Startup oscillator frequency 3M2 Metal revision A3 Datasheet information CPU AVR8X Flash size 64 KB EEPROM size 512 bytes Reading device ID...OK Close
-
Thread
Zeigt her Eure Kunstwerke! Gesperrt Bilder
ist teil einer Funk-Fernbedienung, mittlerweile ist das Ding stark gewachsen ;-) So ne art eigenbau AVR PDA mit Funkmodul, 128x64 GLD mit Backlight, SD-Card, Soundausgabe, Mikro, USB und noch so einigen Spielereien... Alles an nem LiPo Akku im In-Circuit Ladeschaltung und Spannungsregler auf 3.3v
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. 512K Ram ist drauf, für
-
Thread
Neuer ATtiny104?
j@uriah 78% avr-as -mmcu=attiny10 -c foo.s j@uriah 79% avr-objdump -d a.out a.out: file format elf32-avr Disassembly of section .text: 00000000 <.text>: 0: 00 a1 lds r16, 64 [/pre
sich LDS/STS also bestenfalls dann verwenden, wenn das RAM explizite beschrieben wird:[c]#include <avr/io.h> typedef struct { int x; char c; } ram_t; #define RAM (*(ram_t*) RAMSTART) int get_x (void) { return RAM.x; }[/c] [avrasm]get_x: lds r24,64 lds r25,64+1
-
Thread
Zugriff verweigert
Was sagt denn: https://www.whatsmyua.info/ Steht da: Mozilla/5.0 (Windows NT 11.0; Win64; x64; rv:152.0) Gecko/20100101 Firefox/152.0 oder nicht?
https://forum.classic-computing.de/forum/index.php?thread/29870-native-gw-basic-fuer-32bit-x86-und-64bit-x64/ ciao gustav
-
Thread
Update von WinAVR2010
Oliver S. schrieb im Beitrag #5888026: > Eine wirklich aktuellen avr-gcc mit make gibt es hier: > http://blog.zakkemble.net/avr-gcc-builds/ hier gibt es 2 Pakete zum Download: avr-gcc-9.1.0-x64-mingw.zip (56.48 MB) AVG-GCC 9.1.0 Windows x64 (64 bit) Downloaded
so geht das auch mit ********************************************************** AVRStudio 4.19 avr-gcc-9.1.0-x64-mingw\bin\avr-g++.exe avr-gcc-9.1.0-x64-mingw\bin\make.exe mit -std_c++2a -fconcepts Das generierte Makefile als Beispiel angeheftet... --------------------------------------
-
Thread
Welchen µC-Typ für neues Projekt?
Anwedungen sein werden. Definiere "viel" und "zeitkritisch". Ich benutze häufig auf AVRs float und 64Bit integer ohne Probleme. Der AVR-GCC unterstützt leider kein double.
werden. Meine Möglichkeiten die > ich bis jetzt so sehe wären folgende: > > Atmel ATxmega > Atmel AVR32 > Atmel ARM > ST ARM Du kannst auch einen dsPIC33EP (140 MHz/70 MOPS, 16 Bit mit DSP-Erweiterungen) oder einen PIC32MX (32 Bit 80 MHz/80 MOPS, MIPS-Kern) verwenden. Die gibts von klein (28 Pin
-
Thread
avr-gcc: mal lds, mal ld rd, Z
=co Vielleicht liefert -fdump-rtl-cprop-details o.ä. noch detailiertere Infos. Kosten können im avr-gcc mit -mlog=rtx_costs ausgegeben werden.
A. K. schrieb im Beitrag #3308453: > Nur hat IAR ziemlich sicher keine 64-Bit Integers. Doch, signed und unsigned. Und selbst, wenn man sich alle freien Register reserviert, geht noch 64-bit double. Die Variablen werden wohl auf einem separaten CSTACK (Y) abgelegt, wodurch
-
Thread
Warum besitzt der AVR keine Division-Funktion?
Hallo Die Frage ist vielleicht ein bisschen komisch. Aber warum besitzt der AVR keinen Befehlssatz mit einer Divisionfunktion? Ich finde eigentlich dass gerade so einen Funktion sehr nützlich für einen AVR wäre. Es gibt ja sicher andere Befehle die nicht so wichtig sind.
> hat der AVR ja ein einiges grösseren Befehlsatz... Man muss aber auch beachten, dass viele AVR-Befehle eigentlich keine eigenen Befehle sind, sondern nur eigene Mnemonics für bestimmte Kombinationen anderer
-
Thread
Heavy-Metal-Maschine von Elektor
derzeit, mir auch so ein Teil zu bauen (allerdings >eventuell statt mit vier mit acht Oszis und einem AVR als >Hüllkurvengenerator). Die Rechteckfrequenzen kannst du auch mit dem AVR machen, falls du lieber programmieren statt löten willst: [c] #include <avr/io.h> #include <avr/interrupt.h> unsigned
hermy schrieb im Beitrag #1684729: > braucht man das winAVR > zum C-programmieren Ja, musst du runterladen und installieren. Ist der Compiler. Wenn du dann bei AVR Studio 4 ein neues Projekt aufmachst, hast du die Wahl zwischen Atmel AVR Assembler und
-
Thread
C++?!?
C++ zu portieren. Vom Quelltext her sieht C++ wesentlich ordentlicher aus. Größen gemessen mit avr-size *.o <elfdatei> Programm in C: text data bss dec hex filename 28 0 0 28 1c asmfkt.o 1093 38 2 1133 46d avrreflex1.o 961
? Wenn der avr-gcc sowieso c++ schluckt, wofür gibt es dann den avr-g++?
-
Thread
Display Programmierung mit GCC 16x4 Display
sich im Brennprogramm (zumindest war das in AVR-Studio 4 noch so)
testvariable); dürfte nicht funktionieren, siehe http://www.mikrocontroller.net/articles/FAQ#itoa.28.29_.28utoa.28.29.2C_ltoa.28.29.2C_ultoa.28.29.2C_ftoa.28.29_.29
-
Thread
Womit anfangen?
einfach mal den Artikel zu AVR https://www.mikrocontroller.net/articles/AVR und die beiden Tutorials https://www.mikrocontroller.net/articles/AVR-Tutorial https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial durch.
Bausaetze/ATMEL_Evaluations_Board_Version_2_0_1_Bausatz.html Dazu hab ich mir dann noch ein 128x64 LCD gekauft und schon viele Bastelein durchgeführt. Auf Arbeit habe ich mit den Atmel ARM µc zu tun (SAM4), jedoch würde ich nicht direkt mit ARM µc beginnen. Meine Meinung: C + Atmel AVR = guter
-
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
"expected ')' before '*' token" -- Was ist da los?
Also das sind die Ausgaben (nur die includes) [c] typedef uint64_t uint_least64_t; # 213 "c:/winavr-20070525/bin/../avr/include/stdint.h" 3 typedef int8_t int_fast8_t; typedef uint8_t uint_fast8_t; typedef int16_t int_fast16_t; typedef
typedef int32_t int_fast32_t; typedef uint32_t uint_fast32_t; typedef int64_t int_fast64_t; typedef uint64_t uint_fast64_t; # 273 "c:/winavr-20070525/bin/../avr/include/stdint.h" 3 typedef int64_t intmax_t; typedef uint64_t uintmax_t; # 38 "c:/winavr
-
Thread
ethersex im etherrape
atmega165 atmega168 atmega169 atmega32 atmega323 atmega325 atmega3250 atmega64 atmega645 atmega6450 atmega128 at90can128 at94k avr1 at90s1200 attiny11 attiny12 attiny15 attiny28 In file included from clock.c:30: ../config.h:30:2: error
atmega165 atmega168 atmega169 atmega32 atmega323 atmega325 atmega3250 atmega64 atmega645 atmega6450 atmega128 at90can128 at94k avr1 at90s1200 attiny11 attiny12 attiny15 attiny28 In file included from adc.c:30: ../config.h:30:2: error
-
Thread
USB-Interface an MSP430
solltest du vielleicht eher in Richtung ARM gehen. So'n fetter 100MHz Cortex M3 mit 512kB Flash und 64kB RAM von NXP kostet 9€ (LPC1758).
die Software-DDS den AVR dann dicht. Was anderes kann dann da nicht mehr sinnvoll laufen. Müsste dann noch ein weiterer AVR dazu. > Wenn du so einen Berg Flash und RAM brauchst, brauch ich momentan ja gar nicht
-
Thread
AVR Assembler-Frage
match_bit-128: out PortB,output128 ; Portausgabe für Bit 128 ldi tmp,0b01000000 ; CompareMatch auf 64 setzen out PortB,tmp ; 64 auf OCR0A schreiben nop ; ich muss hier den nächsten Interrupt von .org 0x0006 auf nop ; timer0_match_bit-64 lenken reti timer0_match_bit-64: out PortB,output64
Output128 ror Channel5Value ror Output128 ror Output128 ror Output128 ror Channel0Value ror Output64 ror Channel1Value ror Output64 ror Channel2Value ror Output64 ror Channel3Value ror Output64 ror Channel4Value ror Output64 ror Channel5Value ror Output64 ror Output64 ror Output64 ror
-
Thread
Optimierung Fehlerhaft?
Hier noch der passende Assembler Code: [avrasm] 00000250 <adcwertermittlung>: 250: 28 2f mov r18, r24 252: 81 e0 ldi r24, 0x01 ; 1 254: 80 93 02 01 sts 0x0102, r24 258: 80 91 7a 00 lds r24, 0x007A 25c: 80 64 ori r24, 0x40 ; 64 25e: 80
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,
-
Thread
SD-Karte Problem Grasshopper
mehr. Habe folgenden boot-log: [c] ## Booting image at 11000000 ... Image Name: Linux-2.6.28.4 Image Type: AVR32 Linux Kernel Image (gzip compressed) Data Size: 1396596 Bytes = 1.3 MB Load Address: 10000000 Entry Point: 90000000 Verifying Checksum ... OK Uncompressing Kernel Image ... OK Starting kernel at 90000000 (params at 13fa5008)... Linux version 2.6.28.4 (root@ANT-PC5) (gcc version 4.2.2-atmel.1.1.3.avr32linux.1) #2 Tue Oct 27 12:56:41 CET 2009 CPU: AT32AP700x chip revision C CPU: AP7 [01] core revision 0 (AVR32B arch revision 1) CPU: MMU configuration
-
Thread
Frage zur C Syntax
Ruuud wrote: > Kann der µC (AT91SAM7) auch mit 64 bit Werten umgehen? Das muss er ja nicht native können, es genügt, wenn der Compiler das emuliert. Da das sogar der AVR-GCC auf einem 8bitter kann, gehe ich stark davon aus, dass der ARM-GCC das
so, als ob Float doch besser ist? Nein, denn erstens rechnet Float nur mit 24 Bit Mantisse 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
-
Thread
SD Karte(FatFs) verträgt sich mit ENC28J60 nicht
#4882917: > Warum wird dein ENC, der > anscheinend mit 3,3V betrieben wird, direkt an deinen 5V AVR > angeschlossen? Die Eingänge des ENC28J60 sind 5V Tolerant, die brauchen nicht umbedingt ein Pegelwandler. Falk B. schrieb im Beitrag #4882917: > Für MISO fehlt ein Pegelwandler von 3,3 auf
am CS Signal nicht, 10k gegen +5V. Dann kann man den AVR auch ohne Probleme uns sinnlose Längswiderstände am SPI programmieren. https://www.mikrocontroller.net/articles/AVR_In_System_Programmer#ISP-Pins_am_AVR_auch_f.C3.BCr_andere_Zwecke_nutzen
-
Thread
ATMEGA mit XRAM?
Geh mal vom 64er aus. 64kb ist der gesamte Adressraum. Nun ist statt einem ROM und RAM nur ein 64k RAM Baustein am Datenbus - Alles voll. Das entspricht 16 Adressleitungen. Wenn der Chip nun 128kb hat, dann hat
8051 mit ihrem Flash. Habe z.B. das Wickenhäuser Flash M1, das hat 512kb Flash, obwohl der 8051 nur 64kb Adressraum hat.
-
Thread
10 bit ADC wert verarbeiten
> 614 befinden sich in ADRESH und ADRESL. > Kann mir jemand da ein beispiel geben? http://www.avr-projekte.de/rechnen.htm#Rechnen_mit_Festkomma_ Das Programmbeispiel ist zwar für AVR, trifft aber genau auf dein Problem zu.
köstlich deine Argumentation... Was empfiehlst du denn als > waschechte Hochsprache für einen kleinen AVR mit 1k Flash? Keine. Alles unterhalb 8k (Code+konstante Daten) macht man natürlich immer in Assembler, ohne auch nur ansatzweise über eine Alternative nachzudenken. Im Bereich 16..64k wird man
-
Thread
GCC Optimierung?
Ja, der GCC 4.3 hat ein AVR-Dilemma. Das liegt vor allem daran, dass die GCC-Entwickler keine Möglichkeit haben, ihre neuen Entwicklungen überhaupt daraufhin zu testen, ob diese auf einem AVR u. U. eine nennenswerte Verschlechterung
einen passenden Simulator, mit dem man eine Testumgebung für den AVR-GCC so aufbauen kann, dass sie bei Veränderungen am Compiler ermitteln können, ob der AVR-Code dadurch schlechter wird. Mit einer solchen Umgebung hätte der AVR-Port die Chance, aus der Kategorier
-
Thread
Prinzip grafische darstellung/diagramme etc
Beitrag #3569601: > Ich müsste also im Grunde auf dem uC erstmal nen Bildpuffer anlegen? > int LCD[64] [128] = > {{0,0,0,0,0,0,0.........0,0,0,0} ... Nein. *So* schonmal nicht. Du willst ja 128x64 *Bits*, nicht 128x64 *int* mit je 16 Bits. Du wirst also wohl oder übel einzelne Bits in einem entsprechend
Organisation sprechen: * man kann Besonderheiten des Controllers wegabstrahieren, etwa daß ein 128x64 LCD mit KS0108 in Wirklichkeit aus zwei unabhängigen 64x64 LCD besteht. * man kann die Grafikroutinen für verschiedene LCD-Controller gleich lassen und muß nur die eine Funktion, die den Grafik-Buffer
-
Thread
ILI9325 oder doch etwas anderes?
eines zurückgegeben!! Besser: Firma Reichel C-Berry 28 (Sonderangebot) http://www.reichelt.de/RASP-C-BERRY-28/3/index.html?&ACTION=3&LA=446&ARTICLE=144719&artnr=RASP+C-BERRY+28&SEARCH=c-berry+28 Das Display ist qualitativ hochwertig, hat nur Spi und
Ich habe dieses.. allerdings noch nicht selbst in Betrieb da Atmega zu langsam. Nennt sich HY28B. http://www.hotmcu.com/28-touch-screen-tft-lcd-with-all-interface-p-63.html
-
Thread
USBasp Firmware wie aktualisieren
nicht, wie man da eine Bitclock-Option (-B) einhängt. Btw. gibts einen billigen Arduino-Clon mit 64k AVR?
batman schrieb im Beitrag #5222862: > Btw. gibts einen billigen Arduino-Clon mit 64k AVR? Es gibt noch den ATMEGA1284. Mit dem gibt es wohl auch einen Arduino Clone und auch einen Bootloader, aber meines Wissens nichts aus China oder im Massenmarkt.
-
Thread
MMC/SD ansteuern mit AVR
Atmega are not equal to sector numbers accessed using a PC card reader! Sector 0 on PC is sector 39 on AVR, sector 1 on PC is 40 on AVR and so on. It means that sector 0-38 are not accessible on PC. What is the purpose of this area? How can I check how big is it? 64MB SanDisk didn't have this. Darek
ob 4bit mmc = 4bit bei sd ist, aber ich nehme es mal an. http://www.ulrichradig.de/site/atmel/avr_mmcsd/pdf/hitachi_hb28b128mm2.pdf Ab seite 22.. Nik
-
Thread
Unbenutztes Register im 8-Bit Atmel?
. Da gabs doch mal bei Pearl für 20 EUR diesen C64-"Joystick" mit eingebautem "Singlechip-C64", mit TV-Ausgang und ca. 30 Spielen auf ROM. >Inzwischen gefällt mir AVR-ASM aber auch besser als > 6502-ASM. > > ...
muss man das im AVR-Studio > einstellen. Habe es gerade nicht vor mir, musst halt selber mal suchen. Yep. > >> Da gabs doch mal bei Pearl für 20 EUR diesen C64-"Joystick" mit >> eingebautem "Singlechip-C64",
-
Thread
AVR Simulator mit grafischer Benutzeroberfläche für Linux
amd64 1.3.2-6+b1 amd64 Fast Light Toolkit - OpenGL rendering support ii libfltk-images1.3:amd64 1.3.2-6+b1 amd64 Fast Light Toolkit - image loading support ii libfltk1.1:amd64 1.1.10
Neuigkeitem mehr gab: Ich habe gerade src_20190427-1040.tar.gz unter Debian 5.10.179-1 (2023-05-12) x86_64 GNU/Linux compiliert und erhalte eine Warnung: [c] ~/AVR/avrsim/src$ ./c In file included from avrsim.cpp:326: config.c: In function ‘void writeConfig()’: config.c:185:11: warning: ‘%s’ directive
-
Thread
(dauerhaft) aktuelle Toolchain
dem Utils-Verzeivhnis von WinAVR-Version dahin kopiert. Läuft ohne Probleme unter W8.1, 64bit.
/files/avr-gcc%20snapshots%20%28Win32%29/ Ist eine Toolchain mit avr-gcc 6.1.1, ist aber ohne make & Co. Dafür läuft diese mit WinAvr 4.18 - jedenfalls bis Win7.
-
Thread
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.
brauchen 64 Bildschirme zur Anzeige, was bei 50Hz PAL 1,28s dauert. Sprich, die Berechnung im Videoram ist schneller als die Anzeige ;-) Siehe Anhang, Quelltext und PRG zum selber ausprobieren auf dem Emulator
