-
Thread
AVR Bootloader
Bootloader sollte prinzipiell auch 128k einlesen können, ich konnte es nur noch nicht testen. Die unteren 64k funktionieren. Getestet habe ich auch noch nicht das EEprom, aber da habe ich eigentlich nichts verändert. Als Assembler habe ich den "AVR Assembler 2" des AVR Studio 4.11 verwendet. Gruß Gerd
Hallo Peter, Danke für die schnelle Antwort! Ich habe im AVR Studio, unter Projekt, Assembler Optionen, von AVR Assembler 2 auf AVR Assembler 1 umgestellt. Danach war der Fehler weg. Eine Frage noch, womit erstellt man so ein Komandozeilen Programm? Kenne
-
Thread
250 kHz PWM -> ¿Filter? -> micro speaker
0x93, 0x90, 0x8C, 0x89, 0x86, 0x83, 0x80, 0x7D, 0x7A, 0x77, 0x74, 0x70, 0x6D, 0x6A, 0x67, 0x64, 0x61, 0x5E, 0x5B, 0x58, 0x55, 0x52, 0x4F, 0x4D, 0x4A, 0x47, 0x44, 0x41, 0x3F, 0x3C, 0x39, 0x37, 0x34, 0x32, 0x2F, 0x2D, 0x2B, 0x28, 0x26, 0x24, 0x22, 0x20, 0x1E, 0x1C, 0x1A, 0x18,
0x0D, 0x0F, 0x10, 0x11, 0x13, 0x15, 0x16, 0x18, 0x1A, 0x1C, 0x1E, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2B, 0x2D, 0x2F, 0x32, 0x34, 0x37, 0x39, 0x3C, 0x3F, 0x41, 0x44, 0x47, 0x4A, 0x4D, 0x4F, 0x52, 0x55, 0x58, 0x5B, 0x5E, 0x61, 0x64, 0x67, 0x6A, 0x6D, 0x70, 0x74, 0x77, 0x7A, 0x7D
-
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
16x2 LCD Langsamer Displayaufbau
benutzen darf. _delay_ms(dauer); MÖÖÖP! FALSCH! https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Warteschleifen_.28delay.h.29 Wenn es variabel sein soll, dann so. [c] void var_delay(uint16_t time_ms) { while(time_ms--) _delay_ms(1); } [/c]
mehrere Werte aufmitteln, notfalls schneller ! [c] ADCSRA |= (1 << ADPS2) | (1 << ADPS1); // 64 prescale for 4Mhz [/c] könnte man ja auf kleineren prescale setzen http://www.mikrocontroller.net/articles/AVR-Tutorial:_ADC Beispiel 8 MHz Prozessortakt: 8.000.000Hz / 200.000Hz = 40
-
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
innerhalb weniger Stunden erste Schritte beibringen. Ein PC ist auch unheimlich komplex (übrigens 64 Bit heutzutage meistens), trotzdem fangen die meisten Menschen dort an, weil sie es leichter empfinden als die AVR-Programmierung.
-
Thread
Update von Winavr2010 auf gcc 4.8 Howto
%20%28Win32%29/ bzw. zzt. aktuellesten link http://sourceforge.net/projects/mobilechessboar/files/avr-gcc%20snapshots%20%28Win32%29/avr-gcc-4.8_2013-03-06_mingw32.zip/download Entpacken und kurz auf
Version reingestellt. Hier der link für 4.9.2 http://sourceforge.net/projects/mobilechessboar/files/avr-gcc%20snapshots%20%28Win32%29/avr-gcc-4.9.2_2014-09-12_mingw32.zip/download Ich habe aber noch nix getestet, keine Zeit. Wird wohl jemand anderes schaffen ;)
-
Thread
IC für RC5 Code
Hi Malte, Hi Leo9, danke für die flinken Antworten. Tiny AVR klingt nicht schlecht. Ich müsste über Lötbrücken 64 RC5 Befehle fest programmieren können. Denke mal, das ist machbar. Aber es käme dann doch wohl auch noch eine Schaltstufe für die LED dazu oder
Beim Passieren einer Abfragestelle kann nun anhand des Codes ein Zug identifiziert werden. Ein AVR mit 64 oder 128 Byte EEProm und mit einem Mäuseklavier ist wohl eine gute Möglichkeit. Platzmäßig dürften 6 Lötbrücken weniger Raumbedarf haben als ein 6fach Dipschalter. Danke euch, Günter
-
Thread
Assembler wieder auf dem Weg nach vorn Gesperrt
Peter D. schrieb im Beitrag #4352036: > Shit happens: > > Beitrag "Re: AVR ASM soll AVR GCC aufrufen" > > Assembler ist ne tickende Zeitbombe. Ohne AVR GCC wär das alles nicht passiert...
AVR" machen wir "AVR auf ARM" oder "AVR auf JS" und die Assenbler-Sause kann weiter gehen. Aber eigentlich sollte man die Diskussion mit einem so unfairen Typen lassen: - M.: ASM ist besser, weil man
-
Thread
AVR bootloader kernel ATmega32 *nix
Hi @ all, im anhang findet ihr eine funktionstüchtige asm file, die ich mit dem avr studio debuger (cooles teil muss ich mal sagen) zewcks simulation durchlaufen lassen habe. es funktioniert: (mit 64 cycles) ANDI CBR RJMP SUBI SBR ORI TST wär nett wenn ihr noch ein
kein spezialschaltprog, ich nutze eagle :P ) also, thema ist bekannt, nun habe ich (endlich): enc28j60, at45DB161d-SU, HALO isolation module TG42 1406N1, und eine stinknormale 8p8c buchse, an folgenden schaltplan habe ich mich orientiert: http://avr.auctionant.de/img/avrETH1_schematic_fullsize.png
-
Thread
40x SPI-Chipselect?
jeweils ein PT100 hängt an einem dieser ICs? Und Du willst alle 40 ICs dannn durch einen Master-IC (AVR?) steuern und jeweils die CS Leitungen vom Master-IC durchsteuern und die Messwerte dann per SPI auslesen? Mit einem Port-Extender (MCP23017 et al.) oder einem TQFP64 AVR (z.B. ATMega644 oder ATMega128
einen größeren uC nehmen oder aber mit einem 2. uC einen "Treiber" bauen. Müsste dann wohl ein TQFP64/QFN64 sein. Der muss ja ansich nichts können. Dem kannst du via SPI, I2C, UART oder auch 1wire sagen, welche Leitung er aktiv schalten soll. Es ginge natürlich auch mit 2 uCs in DIP28/SOIC28/SSOP28..
-
Thread
PWM multiplexen?
Flackerorgie sollte das nicht ausarten. Vor kurzem gabs mal einen Thread hier. Im Titel war was mit 28 LED. Der beschäftigte sich mit dem Dimmen von 28 Led - also 28 PWM Kanäle.
Hast mit einem Takt von 24MHz bei 4Steps immerhin 500kHz update netto. Wenn Du 25 Hz fahren wills auf 64 Stufen (mehr sieht man eh nicht) wären das 1600 updates ergo 0,03% CPU-Last fürs Schreiben. Mit dem Rechnen zusammen 0,1% geschätzt. Die 64 Stufen packst Du in 8 Bytes x 8 Bit (Bitmuster).
-
Thread
Microchip und ON Semi wollen ATMEL kaufen -- AVRs in Gefahr??
Oder TQFP32, z.B. Atmega88, siehe Anhang. Die Platine hat 34mm Durchmesser, mit AVR, FT232, 64kB EEPROM und Mini-USB Buchse. MFG Falk
Brunner wrote: > Oder TQFP32, z.B. Atmega88, siehe Anhang. Die Platine hat 34mm > Durchmesser, mit AVR, FT232, 64kB EEPROM und Mini-USB Buchse. Was ist das eigentlich für eine Schaltung? USB + AVR + EEPROM + Batterie + Taster ergibt für mich irgendwie keinen Sinn.
-
Thread
Pollin MOTOROLA VIP1710
_64_MB.html
unter dem Namen mediamall. [code]ping mediamall PING mediamall (192.168.X.Y) 56(84) bytes of data. 64 bytes from mediamall.intra.thinksilicon.de (192.168.X.Y): icmp_req=1 ttl=64 time=0.396 ms 64 bytes from mediamall.intra.thinksilicon.de (192.168.X.Y): icmp_req=2 ttl=64 time=0.379 ms[/code] Hat hier
-
Thread
Mikrocontroller Rechenleistung reicht für aktuelles Projekt nicht?
place<<1); } root = root>>1; place = place>>2; } return root; } uint32_t sqrt64_floorC(uint64_t square64) { register uint64_t root=0; register uint64_t remainder=square64; register uint64_t place=0x4000000000000000ULL; while(place > remainder) place = place>>
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
-
Thread
Akku Überwachung so machbar ?
mit dem 10k und 6k8 verwendest muesste die Grundgleichung folgendermassen lauten: ADvalue/(Ubat/1.64) = 1023/2.56 => ADvalue = (1023/2.56)*(Ubat/1.64) => ADvalue = 400 *(Ubat/1.64) Setzt man fuer Ubat verschiedene Werte ein,erhaelt man entsprechende ADvalues Der Wert 1.64 ergibt sich aus dem
mit der > Spannungsteilergeschichte werkeln zu lassen. Sehe ich auf jeden Fall so. > Der Wert 1.64 ergibt sich aus dem Spannungsteilerverhaeltnis,bzw dem > Spannungsverhaeltnis von 4.2V/2.56V (= 1.64) > Der 6k8 muesste korrekterweise etwa 6k betragen - dies ist aber kein > Standardwert - gerechnet
-
Thread
2x Sram - geht das so!?
finde nirgends einen 64k oder 128k sram mit 15ns... sonst wär das viel leichter
32kB SRAMs haben meist nur einen CE\, da das 28Pin Gehäuse keinen freien Pin hat. Bei 8kB (28Pin), 64kB und 128kB (32Pin) gibt es dagegen freie Pins, daher auch mehrere CE Anschlüsse.
-
Thread
Serielle Visualisierung mit Comvisu
Wird in der nächsten Version kommen. Es ist auch noch ein Fehler beim Parsen drin, die Zeilen '28 28 28 28 28 28 28 28' dürften nicht in den gefilterten Befehlen erscheinen. das schau ich mir noch an. Grüße
Hallo Est Est E. , Neue Version Comvisu V1.80 gibt's nur in 64 Bit? Grüße Rodnas
-
Thread
G-LCD bei Pollin
> ... Auf die Rückseite der Platine habe ich eine Platine mit einem S1D13305 LCD Controller und 64kByte SRAM geklebt. > Was möchtest du denn noch wissen ? Gibt es dazu einen Schaltplan? Oder kann man bei Dir gar eine entsprechende Platine käuflich erwerben (sah auf dem Foto so aus). AVR-Programmieren
übertragen werden. Eine 1 bedeutet dabei ein aktiver Pixel. Im Beispiel im Datenblatt werden 16x4Bits=64Bits=64Pixel pro Zeile übertragen.
-
Thread
Neue MegaAVR 0-Series jetzt auch in DIP Version
40poligem Gehäuse (ATMega4809) : http://ww1.microchip.com/downloads/en/DeviceDoc/40-pin-Data-Sheet-megaAVR-0-series-DS40002104A.pdf
UART flöten geht. Doch verbleiben immer noch drei- und damit immer noch mehr als in jedem anderen DIP-AVR.
-
Thread
Atmel Studio 6 kompiliert Nixie Programm für ATmega8 nicht
cbi(PORTC, group); } Error List: Warning 1 #warning "This header file is obsolete. Use <avr/interrupt.h>." [-Wcpp] c:\program files (x86)\atmel\atmel toolchain\avr8 gcc\native\3.4.1056\avr8-gnu-toolchain\avr\include\avr\signal.h 36 2 ATMEGA-8-NIXIE-USBasp Error 2 attempt to use poisoned
. Use <avr/interrupt.h>." ^ C:\Users\DanielC\Documents\Atmel Studio\6.2\ATMEGA-8-NIXIE-USBasp\ATMEGA-8-NIXIE-USBasp\ATMEGA-8-NIXIE-USBasp.cpp(28,8): error: attempt to use poisoned "SIG_OUTPUT_COMPARE1A
-
Thread
Byte auf verteilten Ausgängen ordnen
42 Takte, die mit 2 LUT braucht 25 Takte und auch minimal weniger Flash (6 Byte): [c] #include <avr/io.h> #include <avr/pgmspace.h> #include <stdint.h> const uint8_t lut1[16] PROGMEM = { 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8 }; const uint8
-O3 -Wall -Wextra -c -o foo.o foo.c: [c] #include <avr/io.h> #include <inttypes.h> void pinout(uint8_t out) { PORTD = __builtin_avr_insert_bits(0x0123ffff, out, PORTD); PORTC = __builtin_avr_insert_bits(0xffff4567, out, PORTC); } [/c]
-
Thread
Interrupthandling
Timer0-Overflow Interrupt (ca. jede us) Geht's noch? Das ist 1 MHz! Mit welchem Takt läuft dein AVR? >Wenn die Timer0 ISR auskommentiere (also den Zähler nichtmal laufen >lasse), dann habe ich einen schönen Abstand von meinen 200µs. Gut. Siehe [[Interrupt]]. Der AVR hat keine echten Prioritäten
dann Zyklus genau. Grob kann man für kleine Interrupts 50..100 Zyklen Bearbeitungszeit rechnen (AVR-GCC).
-
Thread
Projet um die Kapazität von Akkus zu messen
Hallo frewer 1. Hast du im AVR Studio eingestellt, dass das vorhandene makefile verwendet werden soll oder lässt du dir eins von AVR Studio erstellen? Ansonsten wenn du WinAVR installiert hast sollte auch ProgrammesNotepad mitinstalliert
seien, aber der ADC darf ja nur zwischen 50 und 200kHz laufen, daher könnte man bei 8MHz maximal auf 64 runter gehen.
-
Thread
Frequenz errechnen
Ja, hier: http://www.mikrocontroller.net/articles/AVR-Tutorial:_Timer
http://www.rn-wissen.de/index.php/Timer/Counter_%28Avr%29#CTC_Modus_.28Clear_Timer_on_Compare_Match_mode.29
-
Thread
ADC - Wert berechnen
Ich hab mal gemessen. Einmal im Simulator im staubigen AVR-Studio mit dem ollen 2010er avr gcc (der noch einen "Bug" hat und sich in einigen Situationen viel RAM gönnt, so auch hier) und einmal mit Arduino UNO. Im AVR-Studio mit Optimierung -Os (minimale Codegröße
Falk B. schrieb im Beitrag #7458811: > Ich hab mal gemessen. Einmal im Simulator im staubigen AVR-Studio mit > dem ollen 2010er avr gcc (der noch einen "Bug" hat und sich in einigen > Situationen viel RAM gönnt, so auch hier) und einmal mit Arduino UNO. Der Ramverbrauch its das eine, aber daß
-
Thread
Casting: was mache ich falsch?
Typen. AVR Studio 4 ist weit von Vollkommenheit. Z.B. hier ist gar nicht möglich, in Watch-Fenster die Variablen uint24_t zu beobachten, die bei heutigem GCC längst möglich sind. Aber einfache IDE, für AVR ausreichend
Kernelhacker und macht sich typedefs nach dem Vorbild in linux/types.h u8 s8 u16 s16 u32 s32 u64 s64
-
Thread
Sinusberechnung auf Controller STM32F030
fürs > Programm. Im AVR wäre das so nicht ein Problem, weil ein 8 Bit breit, bei einem ARM dieses jedoch 32 Bit breit. Es wäre mal einen Vergleich wert, wie groß der Code auf einem AVR und wie groß der Code auf einem ARM
Die Tage habe ich auch auf einem STM32F030 für ein eichfähiges System eine interne Berechnung in int64_t statt in double durchgeführt. Plötzlich reichen auch 16k statt 32k Flash. Und int64_t war schon der Ansatz für Faule. ;)
-
Thread
Stacktiefe AVR-Controller
Hallo, gibt es ein Tool, dass durch statische Codeanalyse die maximale Stacktiefe für AVR-Controller berechnen kann? Gruß Matthias
warum simulierst Du das nicht im AVR-Studio? mfg Jens
-
Thread
ATmega644P - Programmierung
ok das wär einmal das hier: http://www.my-irshop.de/catalog/product_info.php?cPath=28&products_id=158 Kann das klappen? hab mit avrdude und burnAVRburn-GUI mal probiert was zu flashen --> kommt das hier (Gerät AVR910): //------------------------------------------------------------- Connecting to programmer: . Found programmer: Id = "AVR ISP"; type = S Software Version = 3.9; Hardware Version = 1.2 Programmer supports auto addr increment. Programmer supports buffered memory access with buffersize=64 bytes. Programmer supports
-
Thread
GCC 4.1.1 + -minit-stack
funsigned-char -funsigned-bitfields -std=gnu99 -save-temps -dB -DUART_RX_BUFFER_SIZE=512 -DUART_TX_BUFFER_SIZE=64 -o"main.o" "../main.c" && \ echo -n 'main.d' ./ > 'main.d' && \ Ich nutze Eclipse unter WinXP mit dem AVR Plugin aus dem Thread http://www.mikrocontroller.net/topic/31008#238348 habe mir mal
: frame size=5 */ push r16 push r17 push r28 push r29 in r28,__SP_L__ in r29,__SP_H__ sbiw r28,5 in __tmp_reg__,__SREG__ cli out __SP_H__,r29 out __SREG__,__tmp_reg__ out __SP_L__,r28 /* prologue end (size=12) */
-
Thread
Reichweite von Pointern
mich entschlossen für solche Fragen gcc, ich bin mit Ubuntu unterwegs, zu benützen und zu üben. Für AVR bin ich noch in XP mit dem AVR-Studio 4.18 unterwegs.
Kommt auch nen bischen auf die Speciehrorganisierung drauf an. z.B. beim AVR hat der Flasdh ja ein 16Bit Datenbus zum Speicher und mit jedem increment des Adresszeigers um 1 würde nicht ein Byte sondern incrementiert werden sondern 2 ! Also wenn ich das Register Z mit 64 Lade
-
Thread
32 bit Zeiger auf Flash AVR 8-Bit GCC
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Programmspeicher_.28Flash.29 Pointer sind im AVR eher 16 Bit, nur in Ausnahmen größer.
Hi. Soweit mir bekannt ist, stellt die AVR-toolchain sicher, dass PROGMEMs in die oberen 64K deiner firmware gelinkt werden. Insofern du also deine Firware ab Adresse 0x0000 installierst, müsstest du bis zu (fast) 64KB PROGMEMs ganz normal
-
Thread
I2C bei Attiny13
to the asm file -mtiny-stack Change only the low 8 bits of the stack pointer AVR options: -mmcu=[avr-name] select microcontroller variant [avr-name] can be: avr1 - AT90S1200, ATtiny1x, ATtiny28 avr2 - AT90S2xxx, AT90S4xxx
with 8K wrap-around (default for avr3, avr5) Known MCU names: avr1 avr2 avr3 avr4 avr5 avr6 at90s1200 attiny10 attiny11 attiny12 attiny15 attiny28 at90s2313 at90s2323 at90s2333 at90s2343 attiny22 attiny26 at90s4433 at90s4414
-
Thread
Taschenrechner in Hex/binär
an deiner Fragestellung etwas vorbei geht, > ich verwende immer noch einen einen HP 16C mit intern 64Bit > Berechnungen. Ich habe noch einen HP28C in der Schublade, den ich seit dem Studium nicht mehr benutzt habe. Muß den mal wieder mit Batterien befüttern und schauen ob der so etwas kann. Aber
Typ: unsigned char [/pre] Floating-Point-Arithmetik: [pre] > 1.1*1.1 = 1.21 = 0x1.35c28f5c28f5dp+0 Typ: double > 1.1f*1.1 = 1.21 = 0x1.35c28fccccccdp+0 Typ: double > 1.1f*1.1f = 1.21 = 0x1.35c29p+0 Typ: float > 1/0.0 = inf Typ: double > sqrt(-1) = -nan
-
Thread
VW-Werbebeilage mit Display (vidipri)
Anscheinend nicht.... http://www.techfieber.de/green/2009/12/28/der-spiegel-produziert-sondermull-bzw-bewegtbild-werbung-in-print/
/64, error -62 [ 8920.232556] usb 4-6: device descriptor read/64, error -62 [ 8920.520147] usb 4-6: new full speed USB device using ohci_hcd and address 32 [ 8920.942553] usb 4-6: device not accepting
-
Thread
AVR Eval Board Projekt!
Daher würde mein Evalboard etwa so aussehen : Dies wäre alles OnBoard : - einfacher serieller AVR Programmer (AVR910 => AVRStudio kompatibel) - USBProg - Evertool - Sockel für 8pin (ATiny) , 28pin (ATmega xx8) und 40pol (Atmega 16/32/644) (mehr nicht!!!) - I2C Bus (z.B. Port-Expander
was meinst du mir vorzugsrichtung??? Leiterbahnbreite ist 1,27mm Packages DIP - 40 - 28 -8 Vias ind alle gut groß
-
Thread
PICs mit USB
64KB /s = 512.00 bit /s . Wenn man dann noch den Overhead dazu rechnet, dann hast du einen recht guten Datendurchsatz...
schon ausgiebig getestet. Allerdings hänge ich immer wieder an meiner Grenze. Ich kann genau ein 64Byte Block übertragen und das alle 1ms. Schneller werd ich nicht und ich weiss nicht warum.
-
Thread
OpenMCP Board lässt sich nicht per ISP flashen
zwischen dem 10 pin ISP Header und dem Mikrocontroller. Versuche ich jedoch mit dem STK500 mittels AVR Studio oder auch mit avrdude eine Verbindung auf zu bauen scheitert dies. Mit avrdude kann ich die fuse bits z.B. nicht mal auslesen. ("double check connection..."), und im AVR-Studio ist es auch nicht
dadurch nicht richtig. SOrry, kann ja nix dafür - aber ich habe meine Probleme mit der Platine! Im AVR-Studio (mit JTAG MKII) wird mir im Debugmodus angezeigt, dass der SPI-Master Mode bei USART0 nicht möglich ist.
-
Thread
LPC1102, jetzt wird's winzig. 32-bit auf 5 mm2
dieser Art Software umgänglicher. Deshalb sind für mich die PIC24 noch leidlich interessant. Wo AVR zu klein ist oder mich softwareseitig nervt, aber ARM mechanisch unpraktisch. Die PIC24 gibt's nämlich in 18 und 28 Pins.
einen 32 Bit > Prozessor in DIP40: Parallax Propeller Chip. Bitte den MC68000 nicht vergessen ... 64-Pin DIP.
-
Thread
C++ oder C auf uc
benötigt man den letzten Punkt? Viele 8- oder 16-Bit Mikrocontroller haben mehrere Adressräume. Etwa AVR mit Flash/RAM/EEPROM oder M16C mit 64K/1M, die seitens der Maschine verschieden angesprochen werden müssen und daher eine entsprechende Attributierung der Adressen und Pointer erfordern. Bislang kam
> Viele 8- oder 16-Bit Mikrocontroller haben mehrere Adressräume. > Etwa AVR mit Flash/RAM/EEPROM oder M16C mit 64K/1M, die > seitens der Maschine verschieden angesprochen werden müssen > und daher eine entsprechende Attributierung der Adressen und > Pointer erfordern.
-
Thread
Frontplattendesign für "8 bit Computer"
voneinander abgesetzt und gliedern dadurch die Eingabe. https://static.wixstatic.com/media/ce503a_28b23ab5475e4616a14c93abf28d1328~mv2_d_1988_1225_s_2.jpg > 32 Schalter > =========== > ... > - Einzugebende Werte müssen erst in binäre Werte umgerechnet werden Du brauchst jetzt nicht ernsthaft
32 kB RAM 62256 https://cdn-reichelt.de/documents/datenblatt/A300/62256-80.pdf 32 kB EEPROM 28C256 https://www.reichelt.de/eeprom-256-kb-32-k-x-8-5-v-150ns-pdip-28-28c256-150-p1945.html
-
Thread
Datentypen in C
Zwar nicht im Forum, aber nur drei Klicks entfernt: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Ganzzahlige_.28Integer.29_Datentypen
effizient auf die Hardware abbildet. Aber einem C-Compiler ist es nicht verboten, int für einen AVR als 64 Bit zu implementieren oder auf einem Itanium-64 als 16 Bit.
-
Thread
AVR ASCII Video Terminal - 40 x 25 - BAS Signal
Dier Weg über SPI ist genial, keine Frage - aber nicht neu: http://www.serasidis.gr/circuits/AVR_VGA/avr_vga.htm - das Selbe in C.
google mal nach AVR+OSD
-
Thread
short != int16_t
in der stdint.h steht: /** \ingroup avr_stdint 8-bit signed type. */ typedef signed char int8_t; /** \ingroup avr_stdint 8-bit unsigned type. */ typedef unsigned char uint8_t; /** \ingroup avr_stdint 16-bit signed
128 .. +127 einstellen. Ich glaube sogar, das war die Default Einstellung. Und wie ist's bei ner 64 Bit Maschine ?
-
Thread
AtMega16 Timer Problem
Hat jemand eine Idee dazu? Den Code habe ich meist von Vorlagen aus diesem Forum. Ich benutzte das AVR Studio 6.2 auf einem XP Rechner. Den AtMega16 hab ich über EBay bezogen. Ist es möglich, das ich hier fehlerhafte Chips bekommen habe? Grüße Michael [c] #include <avr/io.h> #include <avr/interrupt.h
einer ISR in diesem Forum "unbemeckert" geblieben ist: [c]TCNT0 = (uint8_t)(int16_t)-(F_CPU / 64 * 10e-4 + 0.5); // preload for 1ms [/c]
-
Thread
CH32V003, float wirklich langsam?
4.9.2 | 2.950 | 4.528 | 5.273 | 5.130 avr-gcc 5.4.0 | 2.850 | 4.478 | 5.273 | 5.130 avr-gcc 7.3.0 | 3.150 | 4.628 | 5.413 | 5.163 avr-gcc 8.5.1 | 3.150 | 4.628 | 5.413 | 5.163 avr-gcc 13.4.1 | 3.150 | 4.631 | 5.333 | 5.235 avr-gcc 14.3.1
4.8.1 | 2.943 | 3.231 | 4.973 | 4.961 avr-gcc 4.9.2 | 3.043 | 3.234 | 4.973 | 5.200 avr-gcc 5.4.0 | 2.850 | 3.281 | 4.973 | 5.200 avr-gcc 7.3.0 | 3.150 | 3.340 | 5.113 | 5.227 avr-gcc 8.5.1 | 3.243 | 3.340 | 5.113 | 5.227 avr-gcc 13.4.1
-
Thread
ATmega8 kann keinen Code übermitteln
/itm/ATMEGA-8-16pu-Atmel-ATmega-8-AVR-controller-dip28s-/292775416196?hash=item442ac65184 -im Anhang ist seht ihr wie ich den ATmega an den usb ips angeschlossen habe, um die Daten zu übertragen. soweit so gut (hoffendlich) Ich habe
für 28€ gekauft. https://www.ebay.de/itm/USB-Programmer-myAVR-MK2/361194045527?ssPageName=STRK%3AMEBIDX%3AIT&_trksid=p2060353.m2749.l2649 Mir Fhelen einfach zuviele grundlagen, das ich glaube auch wenn
-
Thread
Dauer FFT berechnen
bekomme einfach keine andere Entwicklungsumgebung von meinem Fachbreich. Würde auch liebendgern einen AVR32 mit 64-bit SPI-Bus programmiere, aber ich sehe da wenig Bereitschaft zu. Ist aber nicht so und deswegen wäre es schön wenn mir jemand seine Erfahrungen in bezug auf AVR mit FPGA berichten könnte
richtet sich leider nach dem debugger aus, denn wir haben nur bei uns im Fachbreich einen 8-Bit von AVR. Die Taktgeschwindigkeit begrenzt den SPI. Bei 25MHz und 2 AD sind das 1024 kbyte die er in 1,28µs (mit 262144=2^18=4^9 Punkten) transportieren kann. Meine Überlegung wäre nun mit einen FPGA zu
-
Thread
Liste von AVR mit PDI Programmierschnittstelle gesucht
28i:81041,v:!%281,2,3,4,5,6,7,8,9,10,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79%
29%29,%28i:8392,v:!%280,1%29%29,%28i:8378,v:0%29,%28i:8445,v:!%281,4,5,6,7,9%29%29,%28i:8236,v:!%280,36%29%29,%28i:8449,v:!%281,11%29%29,%28i:8474,v:!%280%29%29,%28i:8248,v:!%280,1%29%29,%28i:8264,v:!%280,5%29%
-
Thread
PIC 32 schneller Basic Interpreter
blinkt dann schon, während dein Compiler noch compiliert und das Flash beackert..., 8/16/32 oder 64 Bit ist Latte Ein Compiler kann einfach schneller sein, >> wie gesagt... und mehr Fehler vorab finden. >> NACK ;-)
Tollen (Trollen), die ihre Meinung (!= Wissen) überall einstreuen. Bald kommt noch der Vergleich PIC-AVR ins Spiel...