-
Thread
Speicherbausteine Grundkenntnisse
Betriebsspanugnen und wird bei Millisekunden eventuell knapp AT25DF256-XMHNGU-B (niedrige Spannung) oder S25FL128SAGMFI003
erstmal lernen, eine CPU zu programmieren. Wenn Du nen AVR mit 64KB SRAM brauchst, nimm z.B. einen ATmega162 und pappe 64kB SRAM dran. Der Schaltplan dazu steht im Datenblatt: "Figure 12. External SRAM Connected to the AVR"
-
Thread
Defekte XMEGA32D4
die Boards mit XMEGA32D4. Es sind ca. 100 Boards bereits produktiv im Einsatz. Zum Großteil mit ATMEGA644, die vor den XMEGAS zum Einsatz kamen. Die laufen alle einwandfrei. Da ist nix mit Fehler in der Außenbeschaltung. Du gehst blind davon aus, dass die Hersteller der Prozessoren keine Fehler machen
sind, bzw. die Charge, die Farnell geliefert hat. Habe gerade das gleiche Board mit einem XMEGA128D4 bestückt. Läuft einwandfrei. Auch in der Nähe einer Leuchtstoffröhre und einem Heizlüfter.
-
Thread
Anfängerproblem: Gespeichertes Signal auf Basis einer definierten Frequenz auf einen Ausgang legen
mit Deiner Samplerate von 5 MHz getaktet und muss mit 625 kHz Takt nachgeladen werden. Die 64 bis 128 kByte Sampledaten passen bei größeren AVRs auch in den Programmspeicher, der ATmega2560 hat beispielsweise 256 kByte.
-
Thread
Fehler vermeidung (Beschaltung) - AVRs, Pegelwandler + DOGL-LCD
. (Die Alten Typen dienen Hauptsächlich als Platzhalter und um mich zu erst mit alten Typen wie ATmega8 und Atmega16 warm zu machen, ehe ich an die Neueren Typen gehe: Basis-Features zu erst, um den Überblick nicht sofort zu verlieren, sondern auf die Basis-Features aufbauend die neueren Features später
Nun mal angenommen die Dateneingänge bekommen (da zwischen z.B. ATmega16 und Dateneingängen der Pegelwandler sitzt) auch 3,3 Volt. Dabei ist mir eben beim vergleichen der Datenblätter vom EA DOGL128-6 und EA DOGM 128X-6 etwas "Merkwürdiges" wieder ins Auge gesprungen
-
Thread
Anfänger: Atmel 8 beschaltung ?
Lies einfach das Datenblatt (http://www.atmel.com/images/atmel-2486-8-bit-avr-microcontroller-atmega8_l_datasheet.pdf), da steht alles drin. rhf
Reset" angeschlossen ist gehört ein GND ran, der Reset vom SPI gehört direkt mit dem Reset-Pin des ATMega verbunden
-
Thread
Ist diese elektronische Last praxistauglich?
+5+0%0AL+-400+128+-400+144+0+1+false+5+0%0AL+-416+128+-416+144+0+1+false+5+0%0AL+-432+128+-432+144+0+1+false+5+0%0AL+-352+128+-352+144+0+1+false+5+0%0AL+-368+128+-368+144+0+1+false+5+0%0AL+-384+128+-384+144+0+1+false+5+0%0Ar+-528+112+-528+128+0+2000%0Ar+-512+112+-512+128+0+2000%0Ar+-480+112+-480+128+0+2000%0Ar+-496+112+-496+128+0+2000%0Ar+-416+112+-416+128+0+2000%0Ar+-448+112+-448+128+0+2000%0Ar+-432+112+-432+128+0+2000%0Ar+-464+112+-464
-
Thread
FIR Filter auf PIC
Hardware. Dazu benötigt man noch I2S ADC und DAC. Ich schlage mal folgenden Typen vor: PIC32MX150F128B: https://www.reichelt.de/PIC-32-Controller/32MX150F128B-ISP/3/index.html?ACTION=3&LA=446&ARTICLE=121326&GROUPID=4509&artnr=32MX150F128B-ISP&SEARCH=PIC32MX150 Es gibt ihn im THT-Bastler-freundlichen
du zwischen "From Spreadsheet" und deinem nächsten Element noch ein "Sub-Block" machen, bei dem du 128 abziehst. So erhällst du dann im restlichen System einen wirklichen signed Wert (-128 bis 128). Ausserdem sieht es nach einem Fehler zwischen ADC und CSV aus: Ich sehe keine Werte, die grösser als
-
Thread
ADC-Messung ATmega64M1
Hallo zusammen, ich habe einen ATmega64M1 und möchte mit diesem eine ADC-Messung durchführen. Ich arbeite mit einem externen 16MHz-Quarz. Habe hierfür auch die Fuse-Bits richtig eingestellt. Mein Problem ist, dass ich eine 10-Bit-ADC
Enable Interrupt ADCSRA |= (0<<ADLAR); ADCSRA |= (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0); // /128 prescale ADCSRB = (0<<ADTS3) | (0<<ADTS2) | (1<<ADTS1) | (0<<ADTS0); // Triggersource Timer/counter0 compare match A ADCSRB = (1<<ADHSM); // ADC-High Speed Mode DIDR0 = (1<<ADC0D
-
Thread
Arduino Pro Micro
mit dem ATmega128 zu kaufen? Herzlichen Dank!
bleiben willst: Bei Chip45 (https://www.chip45.com/categories/avr_mikrocontroller_module_boards_atmega.php) kannst du Module mit ATmega128, ATmega644 und ATmega2560 kaufen. Für diese brauchst du allerdinsg einen ISP Programmieradapter (dazu kann man auch einen Arduino zweckentfremdem, mit dem ISP Sketch
-
Thread
Interrupt Latenzzeit eines 8-bit AVRs
Hallo zusammen, bin gerade dabei die Interrupt Latenzzeit eines Standard Mikrocontrollers wie dem ATmega8 oder vergleichbarem zu berechnen. Wo verstecken sich denn die Hinweise auf die Interrupt Latenzzeit in den Datenblättern ? Scheine den richtigen Suchbegriff noch nicht gefunden zu haben. Kann man
UweLoh schrieb im Beitrag #5086850: > den richtigen Suchbegriff "atmega interrupt latency" bringt gut 30.000 Beiträge. Im Datenblatt unter "Interrupt Response Time" findet man auch Hinweise. Hier im Forum "Wie viele Taktzyklen benötigt ein Interruptaufruf beim AVR INT0
-
Thread
AVR F_CPU kalibrieren
Schwankungen zu erwarten > sind, ist klar. nein. Man ändert F_CPU nicht aber, sondern Kalibriert den m128!. Schau ins Datenblatt wie das geht.
der TO dabei nicht beachtet: Die Sender einer IR-Fernbedienung sind noch unzuverlässiger als sein ATMega328: Jede NEC-Fernbedienung liefert ein abweichendes Timing - teilweise mit Abweichungen um bis zu 30%. Auch wenn der TO die nächsten 10 Jahre dieselbe Fernbedienung zur "Kalibrierung" nutzen wird,
-
Thread
Unterschied zwischen TXCn und UDREn beim USART eines Atmega128
Hallo ich habe mal ein Frage zum UCSRnA Register eines Atmega128. Dort gibt es unter anderem die zwei folgenden Bits: TXCn: Wird 1 wenn die Daten im TXBn Register erfolgreich gesendet wurden. UDREn: Wird 1 wenn UDRn Register bereit ist für neue Daten
-
Thread
STM32 Header
aber doch nicht am ersten Tag, an dem ich eine LED blinken lassen will, um zu sehen, ob ich vom ATmega auf einen größeren Prozessor umsteigen kann/will. (Auch beim ATmega hab ich mich vor einigen Jahren nie um die Toolchain kümmern müssen. WinAVR mit dem Standard-Include und gut war. Damit hab ich sogar
der STM32L152RBT hat 128kB Flash und 16kB RAM, das Projekt belegt kompiliert - auf Größe optimiert 6556 Byte - auf maximale Geschwindigkeit 6944 Byte Das Blinky mit aller Initialisiertung des uCs braucht also ca 5% des
-
Thread
SD-Card an NUCLEO Board
habe ich intensiv getestet. http://www.chip45.com/products/crumbx1-net_avr_xmega_module_board_atmega128d3_embedded_internet_ethernet_webserver_usb.php
Ach ja, eine 128MB von SanDisk hatte ich auch noch dran und es ging natürlich nicht.
-
Thread
12V Tiefentladeschutz ohne Eigenverbrauch
Bug drin, der mir die Batterie kaputt macht. Zweitens ist der Rest mit 12V versorgt, d.h. für den ATmega muss noch ein kleiner 5V Regler hin... laufen 78L05 ohne einen mindeststrom zuverläßig? Nicht umsonst sind auf Arduino boards rote LEDs, die den "Ruhestrom" für den Regler bereitstellen. Einen Atmega
> Atmega an einem 7805 in standby schicken mit 1µA Strombedarf? Ob das gut > geht? Da gehört auf jeden Fall noch eine min. Last dahinter, damit der > 7805 einwandfrei funktioniert. Und dann sind wir schon
-
Thread
Interrupt Unterschiede beim 8-Bit Timer vom Atmega 128
ich bin ein Neuling im Bereich Mikrocontroller und habe eine Frage zum Timer. Der Timer0 vom Atmega 128 funktioniert ja indem er in dem Register TCNT0 Register hoch zaehlt bis maximal 255. Die Frequenz mit der hoch gezaehlt wird kann mit einem Prescaler reduziert werden. Nun kann man den Wert von
-
Thread
ATmega1284P: Daten für FFT sammeln mit ADC Abtastrate
Moin zusammen, Kurz zu meinem Setup: - Der ATmega1284P läuft mit einer Taktfrequenz von 16MHz - Der interne ADC tastet ein Audiosignal mit 125kHz ab - Innerhalb einer Schleife werden 256 Werte gesammelt (für eine FFT Berechnung) [c] void capture_wave
sollte die passende Programmiersprache zum Problem waehlen. Bei einer Vorgabe von: Darf hoechstens <=128 Takte dauern, wird das nicht unbedingt C sein. Ich zitier' mal aus meinem LED-"Spektrumsanalyzer" aufm atmega16: [avrasm]adc_irq: in r6,0x3f ; save flag register ldi r25,0x08 ;
-
Thread
Statusregister
Flag bei folgnden Rechnungen: 255 + 1 127 + 1 200 - 300 200 - 500 -128 - 1 Welche Fälle sind noch interessant ? Vielen Dank im Voraus. Liebe Grüße Luke
Wohl wahr, es geht um den ATmega128. • Bit 3 – V: Two’s Complement Overflow Flag The Two’s Complement Overflow Flag V supports two’s complement arithmetics. >??? • Bit 2 – N: Negative Flag The Negative Flag N indicates
-
Thread
[V] MikroElektronika "EasyAVR6 Development System"
AT90PWM3B AT90S1200 AT90S2313 AT90S2323 AT90S2343 AT90S4433 AT90S8515 AT90S8535 ATmega16 ATmega161 ATmega162 ATmega163 ATmega164P ATmega164PA ATmega165 ATmega165P ATmega168 ATmega168P ATmega169 ATmega169P ATmega32 ATmega323 ATmega324 ATmega324P ATmega324PA ATmega32A ATmega48 ATmega48P ATmega48PA ATmega644 ATmega644P ATmega644PA ATmega8 ATmega8515 ATmega8535 ATmega88 ATmega88P ATmega88PA ATmega8A ATtiny12 ATtiny13 ATtiny15 ATtiny2313
-
Thread
PIC 16F84 geeignet ?
in das Thema "C auf PIC" ? > Ich dachte an einen 16F84, bin mir aber unsicher. Ein PIC32MX150F128B wäre ganz angebracht. Es muss ja kein 8-Bit PIC sein, oder? http://www.microchip.com/wwwproducts/en/PIC32MX150F128B Lade Dir das MPLABX und den XC32 von microchip.com herunter und besorge Dir
fürs C-Lernen nützlich ist. Eine Preisfrage ist das nicht, der von mir vorgeschlagene PIC32MX150F128B kostet bei Reichelt 4.10€, ein PIC 16F84A-20P 3.99€. Da weiß ich aber genau, was ich nehmen würde. fchk
-
Thread
While(1) wird nach setzen des Timer-Interrupts nicht mehr aufgerufen
Der Atmega läuft mit 8MHz, deine ISR wird alle 1us, also mit 1MHz Takt aufgerufen. Das lässt dem Atmega nur 8 Takte Zeit um in die ISR zu springen, die Register auf dem Stack zu sichern, read-modify-write
schrieb im Beitrag #5071116: > Wieso ist das nur standardmäßig gsetzt, ist ja idiotisch -.- Der ATmega128 ist dadurch ein funktionskompatibler Nachfolger vom ATMega103. So konnte man den M103 direkt durch den M128 ersetzen, ohne etwas ändern zu müssen. Beim M64 ist das bloss ein Schmutzeffekt.
-
Thread
AVRISP MKII nicht mehr lieferbar - Alternativprodukt?
läuft wie das original mit AVR Studio. Auch ein Firmware-Update ist kein Problem. Ich habe damit Atmega328 und 16U2 programmiert. Grüße!
bloße Platine des Atmel-ICE gibt's sogar noch billiger als den > Dragon. Ich sehe schon, beim ATmega bin ich nicht mehr auf dem neuesten Stand. Ich bin vom Preis des Komplett-ICE ausgegangen und wusste nicht, dass es von dem noch eine abgespeckte Variabte gibt. Danke für den Hinweis. Wenn es vom
-
Thread
[V] STK600 + TQFP100 + DIP + JTAG ICE MK II
schon zu sehen stehen folgende Sachen zum Verkauf: 1. Atmel STK600 ohne OVP, mit allen Kabeln und ATMEGA2560 Platine Preisvorstellung 175€ 2. Atmel STK600-TQFP100 mit Routing Cards + 1xATXMEGA128A1 + 1xATMEGA2560 16AU Preisvorstellung 85€ 3. Atmel STK600-DIP Package mit Routing Cards + 1xATMEGA32L
-
Thread
Loxone Link - CAN-Bus
dafür dann mehrer Relay Extensions in der Config anlegen könnte... Verwende hier aktuell ein ATmega328... Werde es mal mit einem SPI CAN Controller und einem Transceiver versuchen. Habe aktuell 1-Wire, Tree und RS485 Extension. Interessant wäre auch der Tree Bus. Leider gibt es hier aktuell
Händchen hat. Grundlegende Forschungsarbeit zu DI und DO wurde von mir ja schon betrieben. ATMega + MCP2515 sind dabei so meine Controller gewesen. Dank der can_lib läuft's aber auch auf AT90CAN128.
-
Thread
Robuste Datenkommunikation für beliebige Kabel und Topologien nach Vorbild CAN
einzige Nachteil von CAN ist, daß Atmel nur wenige MCs mit CAN im Programm hatte (AT89C51CC03, AT90CAN128). Und die ATmega64C1 waren lange Zeit schwer zu beschaffen.
Nachteil von CAN ist, daß Atmel nur wenige MCs mit CAN im > Programm hatte (AT89C51CC03, AT90CAN128). Und die ATmega64C1 waren lange > Zeit schwer zu beschaffen. Dafür haben Renesas und Freescale umso mehr.
-
Thread
Timer CTC Mode
//CTC Modus TCCR2B |= (1 << CS22) | (1 << CS21); //Prescaler 256 // 32768 / 256 / 1 = 128 Intervall = 1s OCR2A = 128 - 1; TIMSK2 |= (1<<OCIE2A); //Enable Compare Interrupt GTCCR &= ~(1 << TSM); //Timer starten sei();
ausgeben werden*/ } } /* Der Compare Interrupt Handler wird aufgerufen, wenn TCNT2 = OCR2A = 128-1 ist (128 Schritte), d.h. genau alle 1s */ ISR (TIMER2_COMPA_vect) { TCCR2B = TCCR2B; //Wird weiter unten im Text erklärt! sekunde++; if(sekunde == 60) {
-
Thread
Arduino Leonardo Pro Micro - keine Verbindung
20 4 0 no 1024 4 0 9000 9000 0x00 0x00 flash 65 6 128 0 yes 32768 128 256 4500 4500 0x00 0x00 lfuse 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00 hfuse 0 0 0 0 no
20 4 0 no 1024 4 0 9000 9000 0x00 0x00 flash 65 6 128 0 yes 32768 128 256 4500 4500 0x00 0x00 lfuse 0 0 0 0 no 1 0 0 9000 9000 0x00 0x00 hfuse 0 0 0 0 no
-
Thread
8 Bit nach 3x BCD umwandeln
Da 128Byte EPROMS kaum zu kriegen sind, könnte man gleich noch den 7-Segment Dekoder mit einprogrammieren und 2 Adreßbits zum Multiplexen nehmen.
berücksichtigt, das das LSB direkt durchgeht und die beiden MSB auf der BCD-Seite immer Null sind - eine Matrix 128 auf 9. Und man müßte die 7 höherwetigen Bits auf der Binärseite erstmal zu 128 Einzelsignalen decodieren. Das wird bestimmt ein Spaß!
-
Artikel
Modellbauservo Ansteuerung
nur um ihre Pulszeit und richten sich entsprechend aus. Das nachfolgende Programm ist für einen ATmega16 geschrieben, der mit 11.056Mhz getaktet wird. Benutzt wird der Timer 2 (ein 8 Bit Timer), der dazu im CTC-Modus betrieben wird. Bei anderen Taktfrequenzen muss der Prescaler des Timers entsprechend angepasst werden, so dass der Ausdruck F_CPU / PRESCALER / 1000 einen Wert nahe an 128 aber auch nicht größer als 128 ergibt. Ist auch logisch: Es wird der 8-Bit Timer verwendet, der von 0 bis 255 zählt. Mit diesen 256 möglichen Timerwerten muss eine Zeit von 2ms abgebildet werden, daher
-
Thread
Energiesparende Lösung zur Langzeitmessung und Speicherung eines Pinzustandes gesucht.
Hardware kann man das umsetzen? Hier würde ich mir ggf. mal die msp430 mit fram anschauen (bis 128kb), vielleicht ist da was dabei.
schlafende atmega aber beim pinwechsel auch wissen wie viel zeit vergangen ist. kann der dat?
-
Thread
SPI empfaengt nur 0xFF
Widerständen habe ich die Logic Level angepasst, da der Sensor mit 3V3 arbeitet. Der µC ist ein AtMega 328P auf dem Entwicklungsboard xplained mini. Bis dahin funktioniert auch alles. Ich kann mit Multimeter die eingestellten Pegel messen. Leider habe ich kein Oszi. Software seitig gibt es
press = 0x00; // initialize SPI as Master, MSB first, Interrupt off, clock rate: f(osc)/128, Mode: 00 spi_master_init (); // SPI wird nicht eingeschaltet (SPE nicht gesetzt) PORTB |= (1 << DDB2); // zur Sicherheit nochmal auf VCC ziehen SPCR |= (1 << SPE); /
-
Thread
CLKDIV8 programmiertechnsich setzen, nicht manuell
CLKPS2|1<<CLKPS1; /* Prescaler auf 64 */ // CLKPR = 1<<CLKPS2|1<<CLKPS1|1<<CLKPS0; /* Prescaler auf 128 */ // CLKPR = 1<<CLKPS3; /* Prescaler auf 256 */ [/c] Geprüft für ATmega88PA. Interrupts müssen disabled sein. Es ist auch möglich, für kurze Zeit, für besonders schwere Berechnungen, Taktfrequenz
|1<<CLKPS1; /* Prescaler auf 64 */ > // CLKPR = 1<<CLKPS2|1<<CLKPS1|1<<CLKPS0; /* Prescaler auf 128 */ > // CLKPR = 1<<CLKPS3; /* Prescaler auf 256 */ > Geprüft für ATmega88PA CLKPCE hast du vergessen!
-
Thread
Arduino - Pins beim Einschalten
Ich hatte mal bei einem ATmega128 den Unterschied im Power-Down Mode bei 5V verlgichen: Alle I/O Pins offen lassen: Stromaufnahme ca 0,5mA Alle I/O Pins mit internem Pull-Up: Stromaufnahme unter 1µA
Eigentlich ganz einfach: Das Ur-Programm für diese Anlagen wurde von mir Ende der 90er Jahre für einen ATMega103 geschrieben. Da waren irgendwelche Stromsparmodi kein Thema, und den Absatz über die 'Unconnected pins' im Datenblatt gab es natürlich auch nicht. Später sind die Programmvarianten über den ATMega128
-
Thread
Maximale Sampling Rate Atmega 20 MHz, mit parallelem externem ADC
Hallo Mikrocontroller.net Forum, ich denke derzeit über eine einfache Möglichkeit nach, mit einem Atmega möglichst "schnell" (in Atmega-Zeitskalen, Samplingfrequenz von mehreren 100 kHz, evtl sogar. 1 MHz?) über einen externen, parallelen ADC ein analoges Signal mit 8 bit Genauigkeit aufzunehmen. Dabei
Hendrik schrieb im Beitrag #5043580: > mit einem Atmega möglichst "schnell" (1 MHz?) > über einen externen, parallelen ADC ein > analoges Signal mit 8 bit Genauigkeit aufzunehmen. Habe ich vor ca. 10 Jahren schon mal gebaut: Ein Atmega32 mit 18,4
-
Thread
Bringt ein Serieller SRAM überhaupt was? Oder ist das nur ein größer flüchtiger EEPROM?
vorhandenen Speicher umgeht. Dann kann man einen möglichst pinkompatiblen Controller nehmen, z.B. den ATmega1280 (8kB SRAM) oder gar ATmega1284, der hat satte 16kB SRAM! >Da fand ich bei reichelt für glaubig 1,55 Euro ein Seriellen SRAM von >Microchip mit 512 Kbits(~64 Kbytes), dank des SPI Interfaces
programmieren. Dein AVR hat IIRC keinen >externen Bus für RAM. DIESER AVR nicht, einige haben es. ATMEGA162 ATmega128 ATmega128A ATmega64 ATmega64A ATmega1280 ATmega1281 ATmega2560 ATmega2561 ATmega640
-
Thread
Gedankenexperiment Bildgenerator
durch Aufwendung von immer mehr Rechenzeit. Im Rahmen diverser Projekte zum Number-Crunching auf Atmega2328 (Arduino UNO) habe ich mir mal grob überschlagen, wie lange der 8-Bit /16MHz Controller wohl rechnen müßte, um die Zahl PI auf hunderttausend Stellen genau zu berechnen, oder um eintausend Primzahlen
Wobei eine Trilliarde ja gerade mal eine Eins mit 21 Nullen ist. Dafür bräuchte man schon einen128-Bit Integer-Datentyp, den der AVR GCC nicht unterstützt. I ch glaube, meine Ambitionen beim Number-Crunching mit Arduino UNO muss ich etwas zurückschrauben.
-
Thread
Code for grösseres, 1.3"-Display anpassen (u8glib)
include "U8glib.h" //U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE); // I2C / TWI //U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_DEV_0|U8G_I2C_OPT_FAST); // Dev 0, Fast I2C / TWI U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NO_ACK); // Display which does
Screen::Screen() { #ifndef u8glib_h #define u8glib_h #include <u8glib.h> #endif //U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE); // I2C / TWI //U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_DEV_0|U8G_I2C_OPT_FAST); // Dev 0, Fast I2C / TWI U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NO_ACK); // Display which
-
Thread
6 Sinuskurven mit 400Hz - welcher DDS?
Spannungen denn erzeugen? Ggf. reicht es ja, 6 Soft-PWM-Kanäle mit bsp. 8kHz zu erzeugen? Sollte mit dem Atmega kein Problem sein.
ubrrh:=hi(ubrr_val); ubrrl:=ubrr_val and $FF; UCSRB:= (1 shl RXEN) or (1 shl TXEN) or 128;// empfangen , senden und IRQ wenn Zeichen empfangen wird. // ucsrb:=ucsrb or 128; // UART interrupt wenn zeichen gelesen ... // 8 data bits, 1 stop bit UCSRC:= (1 shl
-
Thread
Unnütze Registersicherungen in ISR
unglücklich herausgestellt hat. Die stammt wohl noch aus Zeiten, als es nur einen AT90S1200 und einen ATmega103 gab, die noch nicht multiplizieren konnten.
f = (struct AppFlags*) &GPIOR0; f->expired = 1; } int main;[/c] [pre]avr-gcc-8 -mmcu=atmega88 isr.c -Os && avr-objdump -d a.out[/pre] [pre]00000056 <__vector_14>: 56: f0 9a sbi 0x1e, 0 ; 30 58: 18 95 reti[/pre]
-
Thread
Grafikdisplay für AVR Controller
Hallo zusammen, ich suche ein Grafikdisplay welches man mit einem Atmega ansteuern kann. Wichtig wäre mir, dass es eine überschaubare Bibliothek in C oder C++ gibt. Das Display braucht nicht farbig zu sein, es sollte eher einfach in der Ansteuerung sein. Ein Tutorial
http://www.ebay.de/itm/1-44-Colorful-SPI-TFT-LCD-Display-ST7735-128X128-Replace-Nokia-5110-3310-LCD-/382121587331 https://github.com/adafruit/Adafruit-ST7735-Library und viele weitere Quellen für alle möglichen Controller
-
Thread
Bestückungsservice für Mikrocontroller.net
komplettes Modul kosten? momentan gibt es nur einen Verkäufer http://www.ebay.de/itm/Mighty-Mini-ATMega1284p-compatible-with-Arduino-/331463717483 und ich hätte noch gerne die 6-polige FTDI Schnitte gespiegelt damit ein FTDI nicht immer auf dem Kopf steht wenn eine winklige Buchsenleiste verbaut ist
ich das Potential eines solchen Boards nicht sehr gut. es ist ein genialer Arduino (clone) mit 128KB flash und den größten SRAM 16KB der ATmega Serie und breadbordtauglich, 2 € nanos 328p auch China scheinen ja zu laufen wie geschnitten Brot nur es gibt nichts größeres für ein Breadboard
-
Thread
Welches Potentiometer
woher weiß ich welches Potetiometer ich verwenden kann? Hat jemand einen Tipp? Ich verwende einen ATMega2561: http://www.atmel.com/Images/Atmel-2549-8-bit-AVR-Microcontroller-ATmega640-1280-1281-2560-2561_datasheet.pdf Vielen Dank. Grüße Datatom
Was guckst Du, oida? Guckst du Schaltplan: https://www.alvidi.de/data_sheets/pdf/products/eram128/eram128_v20_schematic.pdf guckst Du richtig.
-
Thread
Welche Programmiersprache auf µC
wunderschön in C++ daher kommt. Nach dem Kompilieren habe ich eine 3,2kB große Datei, die ich auf meinen Atmega flashen muss. Ich habe den Treiber mit gleichem Funktionsumfang in ASM implementiert und habe nun eine 1,5kB große Datei...
dynamischen Speichers, 1.808 Bytes für lokale Variablen verbleiben.[/pre] Die IDE nutzt intern avr-size. 128 Byte Ram gehen alleine für die Serial FiFos drauf
-
Thread
Daten in Struct langsamer? C++
int test1 (X* x) { return x->b; } int test2 (int* b) { return *b; }[/c] kompiliert für ATmega8, ergibt: [code]00000000 <test1>: 0: fc 01 movw r30, r24 2: e0 5c subi r30, 0xC0 ; 192 4: ff 4f sbci r31, 0xFF ; 255 6: 80 81 ld r24, Z
[/code] Hingegen für ARM Cortex-M3: [code]00000000 <test1>: 0: f8d0 0080 ldr.w r0, [r0, #128] ; 0x80 4: 4770 bx lr 00000006 <test2>: 6: 6800 ldr r0, [r0, #0] 8: 4770 bx lr[/code] Und für AMD64: [code]0000000000000000 <test1>: 0: 8b 87 80 00
-
Thread
Zimmer/Bereichs Kontroller
Moment auf diesen gestossen der klingt interessant : https://www.olimex.com/Products/AVR/Header/AVR-H128-CAN/ kostet 20 Euro
Gut. Wenn nur CAN, dann schau Dir den hier an: http://www.microchip.com/wwwproducts/en/dsPIC33EP128GP502 gibts als 28-pin DIL, 70 MHz, 128k Flash, 16k RAM, 1*CAN. > Wie gesagt ein so ein Controller, soll so 3-6 Taster haben und > entsprechen 3-6 Relais. Kein Problem. > Die Infos sollen
-
Thread
QR Code lesen mit ATMega oder STM32F1
Speicher analysieren. µC mäßig habe ich eigentlich die ganze Palette da, also vom Arduino Nano über ATMega128A Development-Boards (Viel I/O) zum STM32F103 Blue-Pill Board. Nun die Frage, mit welchem Kamera-Modul fange ich am besten an? Und hat jemand mit dem Thema schon Erfahrung oder ggf. Links?
Einen EAN-128, GS1-128, Code-128 stelle ich mir da einfacher vor.