-
Thread
Problem mit I2C bei atmega328p (arduino uno)
Bus zu tun, aber ich hänge mal die Projektdatei an. [c] for (i=0;i<5;i++) { Atmega328pStopWatchStart(1000); while(!Atmega328pStopWatchCheck()); } test[0] = 0x01; test[1] = 0x02; test[2] = 0x03; UartPrintLine("I2C init",0,0); UartPrintNewLine;
TWCR = (1<<TWINT)|(1<<TWEN); } } //Main loop Master: for (i=0;i<5;i++) { Atmega328pStopWatchStart(1000); while(!Atmega328pStopWatchCheck()); } test[0] = 0x01; test[1] = 0x02; test[2] = 0x03; i2cTxMaster(&test[0], 3, 0x01); //Main loop Slave:
-
Thread
DS18B20 Sensor
DS18B20 output temperature data is calibrated in degrees Celsius. The temperature data is stored as a 16-bit sign-extended two’s complement number in the temperature register (see Figure 4). The sign bits (S) indicate if the temperature is positive or negative: for positive numbers S = 0 and for negative
Moin, ich habe jetzt mal aus der Bastelkiste 9 DS18S20 auf einem Breadboard mit LCD und Atmega32 gesteckt. Also keine (B) sondern (S), die aber meines Wissens nach den selben Inhalt aber ein etwas anderes Frontend haben und lediglich etwas anders ab Werk konfiguriert sind. Man möge mich korrigieren
-
Thread
AVR Async Timer2 will nicht
schrieb im Beitrag #6641592: > Das kannste knicken. Der TOSC-Oszillator ist nicht in der Lage, einen > 16Mhz-Quarz zuverlässig zum Schwingen zu bringen. Der ist für genau den > einen Zweck optimiert, einen 32kHz-Quarz möglichst energiesparend zu > betreiben. Hier ausnahmsweise schon, beim ATmega88 sind
> Doch, die sind für den ATmega88 notwendig. Nur beim 88A und 88P > sind sie intern. ? Siehe Anhang. Wobei mir nicht klar ist, welchen Dragan verwendet: im Text steht ATmega88, im Schaltplan ATmega88PA.
-
Thread
Zeichenkette über UART empfangen
Texteditor, die Avr Gcc Toolchain mit Makefile auf einem Macbook, und mein Mikrocontroller ist ein Atmega 328 P, und ich programmiere in C. Die Uart Bibliothek ist die von P. Fleury. Es soll vom Terminalprogramm Coolterm das Wort „Start“ über Uart geschickt werden, und der uC drauf reagieren (momentan
CMD_FMT wird so definiert, daß die Stringpuffer nicht überlaufen können, z.B. [c] #define CMD_FMT "%16s" // for array size 17 [/c] Soll die Schreibweise egal sein, nimmt man statt strcmp das strcasecmp.
-
Thread
[V] AtMega16, AT89C51, P87C52
Verkaufe folgende uC : - Tapeabschnitte (50, 50, 66, 33) des ATMega16 als QFN, Vorstellung Stückpreis 50 Cent - insgesamt 10 Stück AT89C51, Vorstellung Stückpreis 80 Cent - 2 Stück P87C52EBFFA, Vorstellung Stückpreis 1,50 Euro Dazu käme noch Versand, Brief oder
Die 89C51 und die 87C52 sind verkauft. Aber die ATMega16 sind noch zu haben...
-
Thread
Problem 16Bit Timer auslesen und zurücksetzen für Frequenzzähler ATmega1284p Assembler
Für den ATmega328 gilt: "The Timer/Counter (TCNT1), output compare registers (OCR1A/B), and input capture register (ICR1) are all 16-bit registers. Special procedures must be followed when accessing the 16-bit
Der Capture-Mode geht bei ATmega1284 (und ATmega328 et al) leider nur mit einem 16-bit-Counter (nur für diesen gibt es einen ICP-Eingang), der aber andererseits auch sehr hilfreich wäre, um ein exaktes 2-Sekunden-Capture-Signal zu
-
Thread
NHD-0420CW-AY3 4x20 Zeilen OLED in Betrieb nehmen
Wenn ich mir die Beispiellistings ansehe, dann kann ich Pin 15 /CS dauerhaft auf Masse und Pin 16 /RES dauerhaft an +5 V legen. Das war es wohl. Allerdings macht das Teil mit dem selben Code, der beim EAW204-XLG ohne Probleme läuft, nicht einen Mucks. Es gibt da ein Code void init()-Beispiel
Initialisierung und 10 µS für Enable reichen. Noch weniger habe ich nicht ausprobiert. Breadboard, ATMEGA644, 16 MHz. 5. Ja, man muss die gesamte abgedruckte Initialisierungsroutine durchlaufen. Grmmmpf. 6. Zur Initialisierung: [code] void init(){ RES = 1;//reset HIGH - inactive
-
Thread
Auslastung Mikrocontroller bei Vollauslastung I2C
häufig ab und können für das Verständnis zunächst mal ignoriert werden. Bei einer Genauigkeit von 16 Bit komm ich so rein rechnerisch auf eine Datenrate von: 1 kHz * 16 Bit * (3 + 3) = 144 kBit/s Wenn ich nun jeweils zwei der Sensoren an den Bus hänge, komme ich auf dann auf 288 kBit/s reine Daten
streift, dann hol' Dir jemanden ins Boot, das das (besser?) kann. I2C läuft selbst auf 'nem ollen ATMEGA16 interruptbasierend spielend im Hintergrund. Dafür ist das Ardoino nicht gemacht, der Anspruch war hier ein klein wenig anders. Die Plattform richtet sich an Kunstschaffende, denen man ein kreatives
-
Thread
PWM Frequenz ATMega328P einstellen
Hallo Leute, hab eine Frage zur Einstellung der PWM-Frequenz beim ATMega328P. Ich will mit dem 16 und 8 Bit Timer zwei PWM Signale ausgeben. Beim 16 Bit Timer passt die Frequenz, die ich einstellen wollte. [c] TCCR1A = (1<<WGM11) | (1<<WGM10) | (1<<COM1A1); //Fast PWM
Einstellungen, gleiche Frequenz usw., aber unterschiedliche Tastgrade? Ja, das kann man. Der Atmega328P hat insgesamt 6 PWM Pins die alle unabhängige PWM-Tastgrade ermöglichen. Der 16 Bit Timer ermöglicht hierbei zwei unabhängige PWM-Signale. Erstmal fällt mir kein signifikanter Fehler auf bis
-
Thread
Regelstrecke erfassen (Temperaturregelung)
Wheatstonebrücke mit einem LM358n um Ub der Brücke von 0 - 5V zu verstärken. (https://www.ti.com/lit/ds/snosc16d/snosc16d.pdf Figure 40/Seite 21 mit Vref = 5V R = 10kOhm; Rf = 1MOhm; Sigma_max = 200Ohm, Vcc_op = 12V, alles Metallwiderstände 1% Toleranz) Den Abgleich habe ich gemacht indem ich den PT100 kurzgeschlossen
Newbie schrieb im Beitrag #6643571: > Meine Wahl als uC fällt auf einen atmega328p Prozessortyp ist für diese Problematik ohne Bedeutung (egal)...
-
Thread
CRC Polynom für EnDAT Encoder
2008 habe ich in meiner Bachelor-Arbeit eine Auswerteschaltung für EnDat-Geber mittels Atmega gebaut. Die CRC-Berechnung habe ich damals anhand der EnDat Spezifikation in Assembler implementiert... Aber ein explizites Polynom habe ich in meinen Unterlagen auch nirgends gefunden. Möglicherweise
are stored at the address specified by pTable. Definition: void PM_endat22_generateCRCTable(uint16_t nBits, uint16_t polynomial, uint16_t *pTable) Usage: #define NBITS_POLY1 5 #define POLY1 0x0B #define SIZEOFTABLE 256 uint16_t table1[SIZEOFTABLE]; // Generate table for poly 1 PM_endat22_
-
Thread
Wasserzähler Impulszählung (Batteriebetrieb)
dieser Zeit Impulse zu zählen. Man muss da nichtmal nach irgendwas Exotischem Ausschau halten, jeder ATmega kann das, nämlich mit Timer2 (bzw. TCDn bei den neueren Teilen).
Zeit Impulse zu zählen. Man muss da > nichtmal nach irgendwas Exotischem Ausschau halten, jeder ATmega kann > das, nämlich mit Timer2 (bzw. TCDn bei den neueren Teilen). Der µC muss dann nur hin- und wieder "aufstehen" und versuchen die Daten los zu werden. Bei einem Puls pro Liter könnte ein 16Bit-Zähler
-
Thread
Programm Simulation für Schaltung bei geringer Spannung vom Akku
io.h> #include <avr/interrupt.h> #include <avr/sleep.h> volatile unsigned char zaehler; uint16_t adc_read() { uint16_t adc_measurement = 0; ADCSRA |= (1 << ADSC); //Startet Konvertierung while(ADCSRA & (1 << ADSC)){ } //Wartet bis Konvertierung fertig ist
unbedingt Mikrosekundengenauigkeit und die Clock vom Watchdog wird dir reichen. Problem ist halt beim ATmega8, dass er dir den µC wieder resettet und du nicht wie beim ATmega328p einfach nur ein Interrupt auslösen kannst. Das sollte man eventuell im Programm irgendwie lösen.
-
Thread
Bootloader auf Atmega328 PCB
Sketch drauf. Einstellungen im Arduino IDE: Board: Arduino Pro oder Pro Mini Prozessor: Atmega328P 5V 16Mhz Port: mein Uno Programmer: Arduino as ISP Dann bootloader brennen. Das Ergebnis sieht IMHO auch gut aus. ________________ Hier der Log dazu: /private/var/folders/x1/01k3w63s0bx567bd7zl218280000gq
daran dann die entsprechenden Pins 10,11,12,13, VCC und GND vom UNO an die entsprechenden Pins vom Atmega328. 10 an Reset (PIN 29) 11 an MOSI(PIN 15) 12 an MISO (PIN 16) 13 an SCK (PIN 17) VCC an VCC GND an GND Beim FTDI232. diesen habe ich auch per USB an den Rechner angeschlossen. Dann die
-
Thread
ATmega32u4 OCR1BH nicht setzbar
frequenz % 256; Serial1.println(OCR1BL); Serial1.println(OCR1BH); [/c] Frequenz ist eine 16Bit Variable in der ich den Wert abgespeichert habe, der in das Compare-Register geladen werden soll. Falls ihr weiter informationen zum Code braucht, bitte bescheid sagen. Schon mal danke fürs Lesen
Genauso ist das. Zusätzlich kann man sich das Gehampel mit low und high Byte schenken. OCR1B = '16Bitwert' ist einfacher.
-
Thread
Schrittmotorrampe für Konstante Beschleunigung
#6633262: > Um welche Architektur es geht hat der TO ja nicht verraten Es handelt sich um einen Atmega328p 16 MHz. Lothar M. schrieb im Beitrag #6633065: > man rechnet die Sachen möglichst "binär" mit Integern in 2er-Potenzen. Mit 2er Potenzen kann ich da ja nicht wirklich viel rechnen ausser
Wenn die Geschwindigkeit z.b. nur 0...100 mit einer Nachkommastelle ist, dann gibt sie halt in 16tel oder 32tel an.
-
Thread
5V Spannungsversorgung aus 2x AA Zellen für ein kleines Projekt mit ATmega328p
Tastenbetätigung auch selbst ausschalten können soll. Als Controller möchte ich übrigens einen ATmega328p verwenden, aber das ist für die Spannungsversorgung erstmal unwichtig. Und ja ich weiß dass es Möglichkeiten gibt den Controller schlafen zu legen, aber ich möchte es gerne elektrisch lösen. ;
oder? Oder muss die Spannung sehr konstant sein? Noch zur Ergänzung: - der Controller soll ein Atmega328p-pu sein (DIP28-Gehäuse) - die 7-Segment-Anzeigen sollen keine LCD sondern LED sein (gute Sichtbarkeit um dunkeln erforderlich) Schöne Grüße Domenik
-
Thread
ATtiny85 ADC differentiell 20x gain 1.1 int. Ref.
uint16_t convert(void) { ADCSRA |= (1 << ADSC); while (!(ADCSRA & (1 << ADSC))) ; return ADC; } void debugadc(void) { // _delay_us(1000); // convert(); uint16_t x = convert();
uint16_t convert(void) { ADCSRA |= (1 << ADSC); while (!(ADCSRA & (1 << ADSC))) ; return ADC; } void debugadc(void) { // _delay_us(1000); // convert(); uint16_t x = convert(
-
Thread
STM32: I2C-Master setzt ARLO-Flag (arbitration lost)
* @retval HAL status */ HAL_StatusTypeDef HAL_I2C_Master_Transmit(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout) empfangen: /** * @brief Receives in master mode an amount of data in blocking mode. * @param hi2c Pointer to a I2C_HandleTypeDef
* @retval HAL status */ HAL_StatusTypeDef HAL_I2C_Master_Receive(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint8_t *pData, uint16_t Size, uint32_t Timeout)
-
Thread
Vorstellung und erstes Projekt
14 3e: 82 bb out 0x12, r24 ; 18 40: 81 9b sbis 0x10, 1 ; 16 42: 04 c0 rjmp .+8 ; 0x4c 44: 82 9b sbis 0x10, 2 ; 16 46: 02 c0 rjmp .+4 ; 0x4c 48: 90 9a sbi 0x12, 0
benutzen. Wird kleiner (und dadurch auch billiger) als THT, und bei den von dir angedachten Elementen (ATmega8 und sowas) ist das auch alles hobbymäßig problemlos zu löten.
-
Thread
Softwareversion im Flash hinterlegen.
meiner Frage. Andreas B. schrieb im Beitrag #6632419: > Hier: > Beitrag "MMC/SD Bootloader füt ATMega16" > wurde so etwas schon gemacht. Oliver
BCr_einen_ATtiny-Bootloader_in_C#Speicherlayout_des_Bootloaders Ist zwar für ATTiny, aber sollte auch für ATmega gelten.
-
Artikel
Word Clock Variante 1
Elektrolytkondensator 47 µF; 100 V RM 2.54, Ø=5 mm 1 G1 Lithium-Knopfzelle, Printmontage CR2032P-H; liegend RM 10.16, RM 17.78 1 IC1 Mikrocontroller ATmega168-20PU DIP-28 1 IC-Sockel 28-polig; schmal RM 7.62 [1] optional IC2, IC3, IC4 Schieberegister, 8-Kanal 74HCT595N DIP-16 3 IC-Sockel 16-polig RM 7.62 [3] optional
Wert / Ausführung Gehäuse / Rastermaß Anzahl Kommentar C15 SMD-Vielschicht-Keramikkondensator 100 nF; 16 VDC SMD-0603 (1,6 x 0,8 mm²) 1 C16, C17 SMD-Elektrolytkondensator 10 µF; 16 V SMD-Size B (4,3 x 4,3 mm²) 2 IC11 Positiver Spannungsregler REG1117; +3,3 VDC; 800 mA SOT-223 1 IC12 Operationsverstärker
-
Thread
ATMega4809 EVSYS, total überfordert
/ 4 */ TCA_SPLIT_CLKSEL_DIV8_gc = (0x03<<1), /* System Clock / 8 */ TCA_SPLIT_CLKSEL_DIV16_gc = (0x04<<1), /* System Clock / 16 */ TCA_SPLIT_CLKSEL_DIV64_gc = (0x05<<1), /* System Clock / 64 */ TCA_SPLIT_CLKSEL_DIV256_gc = (0x06<<1), /* System Clock / 256 */ TCA_SPLIT_CLKSEL_DIV1024
System Clock / 4 */ TCA_CLKSEL_DIV8_gc = (0x03<<1), /* System Clock / 8 */ TCA_CLKSEL_DIV16_gc = (0x04<<1), /* System Clock / 16 */ TCA_CLKSEL_DIV64_gc = (0x05<<1), /* System Clock / 64 */ TCA_CLKSEL_DIV256_gc = (0x06<<1), /* System Clock / 256 */ TCA_CLKSEL_DIV1024_gc = (
-
Thread
Atmege Hardware UART und I/O
Hi Ich muß an einem ATmega den UART benutzen aber auch den TX-Pin "händisch" beeinflussen. Beides getrennt funktioniert. Aber sobald ich den UART initialisiere, werden Änderungen am Pin-Level nicht mehr umgesetzt. Im Datenblatt
Kann ich mir nicht vorstellen, und das Datenblatt, z.B. vom ATmega1284, scheint mir Recht zu geben: 'When the Transmitter is enabled, the normal port operation of the TxDn pin is overridden by the USART'
-
Thread
Wettbewerbe für kleinste Programme
archives/579 [c] int main(void) { // Prepare value to load into PINB asm volatile("LDI R16, 1"); // DDRB0 to Output asm volatile("OUT 0x17, R16"); while (1) { // It's Saturday: // Set bit 0 of PINB to toggle PB0 asm volatile("OUT 0x16, R16"); // Sunday has come asm volatile("OUT 0x16, R16"); // Loop JMP will take 2 cycles, // so we need 3 more... asm volatile ("NOP"); asm volatile ("NOP"); asm volatile ("NOP"); } }[/
-
Thread
Suche richtig miesen Drehimpulsgeber
sehe ich das auch so. Ich habe nichts außer die internen Pull-Ups. Ich habe hier etwas mit einem ATMEGA644 gemacht und arbeite mit Tabelle und Auswertung beider Spuren. Mit einem Akkuschrauber in höchster Stufe bringe ich das nicht aus dem Tritt. Die Spuren A und B liegen an PC0 und PC1. Ich kann in
Bucht wird gerade ein Waldorf Q Rack für sage und schreibe fast 1.700,00 gehandelt. Und das für einen 16 Stimmen-Klangerzeuger. Unfassbar.
-
Thread
Chipmangel überall Gesperrt
Gerichte ausgeliefert werden, und auch das nur, wenn es durch ein Gesetz ausdrücklich erlaubt ist (Art. 16 GG). Vor Einführung des europäischen Haftbefehls war die Auslieferung Deutscher an das Ausland durch das Grundgesetz generell verboten."
das es ähnlich auch für Asylsuchende gehandhabt > wird: Das hat nun überhaupt nichts mit Art 16 GG zu tun. Es wäre allerdings auch überraschend, wenn Du tatsächlich einmal etwas Sinnvolles abgesondert hättest.
-
Thread
DIY Fernsteuerung (Der Griff nach der EierlegendenWollMilchSau)
Programmierung und Verarbeitung läuft auf der Senderseite, dann wird es durch den "Flaschenhals" von 16 (oder mit Tricks 32) Servo-Kanälen auf den Empfänger übertragen. Empfängerseitig kann zwar sehr universell alles mögliche kaufbare verwendet werden, aber eben nur der Betrieb von Servos, oder nachfolgender
Platinchen, das z.B. 8 Lämpchen bedient, stelle ich mir eher einen ATTiny oder meinetwegen auch einen ATMega328 oder so vor. Controller mit CAN sind eher schon dicke Brocken.
-
Thread
[V] Atmel STK503 (Erweiterung für STK500) mit ATmega1280-16AU
Hallo, ich biete ein unbenutzes Aufsteckboard AVRATSTK503 für das Atmel STK500, um mit ATmega1280 (und andere, wie z.B. ATmega2560 und ATmega640) zu entwickeln, mit einem 100-pin ZIF-Sockel, wo man diese ICs einfach einsetzen kann. Ein ATmega1280-16AU sitzt dort auch noch im Sockel, wie
-
Thread
AD7177 SPI Kommunikation durch Schleifringe
Hallo Forum, es geht um AD7177 ADC und SPI-Kommunikation durch Schleifringe. Ich habe einen Atmega 1284, der mittels Flachbandkabel mit einer Platine verbunden ist, auf der ein 7177 sitzt. Das Flachbandkabel kann getrennt (DSUB-15) und beide Platinen dann an einem Rotationstisch betrieben werden
zuerst 47 Ohm, da hat's doch etwas geklingelt, also habe ich sie auf 420 erhöht. Treiber ist Atmega 1284. Ic dachte es funktioniert wie ein Schmitt-Trigger. Müssen die Flanken eine Mindeststeilheit besitzen?
-
Thread
Software Serial für mega644
Timer geht es nicht. Ich weiß nicht, welche Baudraten der TO verwenden will. Ich habe aber auf einem ATMega mit 16MHz schon mal acht Software-UARTs mit 9600 Bd realisiert - zugegebenermaßen nur für RX. Dabei wurde auf einen PCINT verzichtet und lediglich der 8-Bit-Port 28800 mal pro Sekunde über eine Timer-ISR
Frank M. schrieb im Beitrag #6622942: > Ich habe aber auf einem ATMega mit 16MHz schon mal acht > Software-UARTs mit 9600 Bd realisiert - zugegebenermaßen nur für RX. > Dabei wurde auf einen PCINT verzichtet und lediglich der 8-Bit-Port > 28800 mal pro Sekunde über
-
Thread
LED für 20 Sekunden blinken (Magnetschalter)
Sekunden 3. Magnet wird nach z. B. 4 Sekunden angedockt 4. Blinksequenz läuft in dem Fall noch weitere 16 Sekunden 5. Blinksequenz abgeschlossen. Kann man das Ganze ggf. mit Reedschaltern und Kondensatoren lösen? Ich möchte es gerne so einfach wie möglich halten.
> 3. Magnet wird nach z. B. 4 Sekunden angedockt > 4. Blinksequenz läuft in dem Fall noch weitere 16 Sekunden Habe den Post zu spät gesehen, also habe ich es doch missverstanden. Dann kannst du in meiner Beschreibung das UND-Gatter weglassen und den Oszillator mit dem Monoflop aus NANDs direkt
-
Thread
ATmega8U2 Quarz
habe ich mal nachgeschaut, beim Arduino wird ein 16MHz eingesetzt. Einerseits nutzen die den ATmega8U2 auch bei 5V während ich ihn bei 3,3V einsetze. Jetzt bin ich ein wenig verwirrt da man bei 16MHz ein nicht funktionieren des Oszillators riskiert. (
Die Transistoren schalten bei 5V eben schneller als bei 3V, und deswegen reicht es bei 5V noch für 16MHz, während bei 3V nur 8MHz drin sind. Wenn Dir das nicht reicht, musst Du halt was moderneres nehmen. Ein PIC24F64GB002 geht auch bei 16MHz, ein PIC32MX250F128B läuft mit 50MHz, und so viel teurer sind
-
Artikel
SensorLogger
Als Hardware kommen folgende Komponenten zum Einsatz: 868MHz Empfangsmodul mit PCB Antenne ATMEL ATmega1284P + ENC28J60 für 100base-T microSD Adapter Empfangsmodul. Für dem Empfang (und wenn mal will auch für das Senden) gibt es ein preiswertes 868MHz Modul RFM12. Es ist ein Universal ISM Band FSK Transceiver
ausgiebig beschrieben RFM12. Die Kommunikation erfolgt über eine gewöhnliche SPI Schnittstelle im 16-bit Transfer. Die Einstellmöglichkeiten sind so vielseitig, sodass man am Anfang schier verzweifelt, bis der Empfang dann endlich gelingen will. Daher hier mal die bei mir erfolgreiche Init-Sequenz:
-
Thread
32 GPIO Sender und Empfänger via Bus/Ethernet
dürfte die Programmierung an einem Tag erledigt sein. Als Board kann ich https://www.chip45.com/atmega644-usb-rs485-modul.html?language=de empfehlen, da ist der RS-485 Transceiver sogar mit drauf. Dieses auf eine Lochrasterplatine packen, die gewünschten I/O Anschlüsse und Überspannungsschutz (für die
udp_data_t buffer; while(1) { buffer.port0_15 = portE; buffer.port16_31 = portF; buffer.aIn; // send data err = sock.sendto(remoteAddr, &buffer, sizeof(buffer)); // receive data (receiver should echo data err = recvfrom
-
Thread
Schuhkarton beheizen
Hefeweizen. Dieses Gelumpe ist allerdings für einen normalen Menschen ungenießbar. Übrigens ist im Atmega328 selbst ein Tem,peratursensor enthalten, der für diesen Zweck bestimmt auch genüen würde.
die China-1602 plus I2C-Adapter bekommt man unter 3 Euro. Schade nur, dass man die zwei Zeilen zu je 16 Zeichen bei dieser Anwendung kaum sinnvoll befüllt bekommt. Was die Regelung angeht, würde ich vermutlich einen ChinaNano einsetzen, der A/D des ATMega328 ist ziemlich gut und kostet irgendwas um
-
Thread
Akausales Verhalten von Atmega328p
> Akausales Verhalten von Atmega328p Akausal? Was man hier für wunderschöne Worte finden kann...
Array wird genutzt. Was allerdings wohl scheppern *muss*, ist dieses: [c] uint8_t micBlock[16] = {0}; // schnipp for (i=0; i<lengthOfMessage; i++) { micBlock[(16+i)] = *(firstElementOfMessage+i); } [/c]
-
Thread
Rechnen mit große integer Zahlen beim ATMega328P
Hallo Leute, Ich versuche mich grad in C und die Entwicklung von Programmen für den ATMega328P einzuarbeiten. Jetzt habe ich ein kleines Problem mit dem Casten von großen Integer Zahlen bzw. mit dem Rechnen großer Integer Zahlen. Konkret geht es um diese beiden Zeilen: [c] uint16_t pwm1
Sebastian S. schrieb im Beitrag #6616457: > Wo um alles in der Welt gibt es bei einem ATMega Analogwerte? Ich hab z.B. eine Strommessung über mehrere Dekaden. Ein 16Bit-ADC wird in 4 Bereiche umgeschaltet. Für jeden Bereich erfolgt eine Kalibration mit float-Werten (Gain, Offset) im EEPROM
-
Thread
AVR Ardunino Nano ATMega328P Timer OVF (Overflow) Interrupt
zurückgesetzt) eine Endlosschleife durch den Int bauen. So oder so: (wenn es denn klappt) sind 64 Teile von 16MHz zu schnell um die LED blinken zu sehen.
ausgewählt? Deine ISR wird auf jeden Fall zu schnell aufgerufen, um die LED blinken zu sehen: 16E6Hz/16/256 = 976,5625Hz Du solltest den 1024 Prescaler verwenden -> 61 Hz und dann mittels Zählvariable auf Deinen Blinktakt teilen
-
Thread
Flachbandkabel mit PC verbinden
wird normal 16Bit (565RGB) parallel anzusteuern sein. Kann der PC von Hause aus erstmal nicht. Also Antwort in grob: "eher nicht ohne weiteres möglich" Alle anderen Antworten, wie "Heisskleber", "Antackern" zeugen
Axel R. schrieb im Beitrag #6613075: > wird normal 16Bit (565RGB) parallel anzusteuern sein Wodurch wird das für dich ersichtlich?
-
Thread
ATMega168: kein SPIF nach SPI-Transfer
transmission of data (r16) ldi r16,0xA5 ; Beispielwert out SPDR,r16 Wait_Transmit: ; Wait for transmission complete in r17, SPSR call DEBUG_BYTE ; Byte auf dem LA ausgeben (b7...
Hallo, das war es ! Der ATMega 8 belegt nur ein Wort pro Vektor, der ATMega 168 aber zwei. Bei den nicht benötigten Vektoren stand nur RETI. Dieser Befehl belegt aber nur ein Wort im Interrupt-Vektor. Ein NOP nach jedem RETI hat's
-
Thread
Woran kann man erkennen wie DRUCHGESCHREIBEN ein Controller schon ist?
Hallo Die atmega Controller setzte ich sehr Gerne ein. Habe einige Broads auf welchen ich erstmal teste bis alles so weit läuft wie gewünscht. dabei kann der Programmspeicher des Test Broad schon ein paar hundertmal
.100 (oder auch 1000...) Schreibvorgängen. Du brauchst also 1...3 Exemplare mehr vom jeweiligen atmega-µC, als du davon verbauen willst. Macht dich um 2...30 EU ärmer, aber erspart JEDE MENGE Ärger.
-
Thread
Programm läuft nur mit JTAG Fuse
JTAG wieder einschalte geht alles wieder (nur die PortC halt nicht). Woran kann das liegen? Atmega1284P / Atmelstudio7 / C
------------------------ Variablen uint8_t pos = 0; uint8_t Taster = 0; char Wert[10]; uint16_t Test = 0; uint8_t menuaktiv = 0; //Init //------------------------------------------------------------------------------------------------------------------------------------------------ Init
-
Thread
IGBT schon bei kleiner Last durchgebrannt
https://asset.conrad.com/media10/add/160267/c1/-/en/000160629DS01/datenblatt-160629-ixys-mcc95-16io1b-thyristor-scr-modul-to-240aa-1600-v-116-a.pdf
ne ich meine eher soetwas wie einen AVR ATMega https://www.mikrocontroller.net/articles/AVR-Tutorial In einer Sekunde macht der 16 Millionen Befehle, absolut ausreichend für deinen Anwendung. Mit der Wegmessung bekommst du ja raus wo sich
-
Thread
asm 16 Bit in BCD
method "shift-plus-3". I have written the sample code as below. The input hex value put in R17:R16, and this function will return R20:R19:R18 with the BCD value. [avrasm] ; r17:r16 = HEX value ; r20:r19:r18 = BCD value hexToBcd: push r16 push r17 push r21 push
ATmega328 in 17,41 µsec @16MHz (inkl. rcall, ret und einem I/O-Befehl zum Messen per Scope). In der usprünglichen Version sind es 23,17 µsec. Diese Zeiten sind unabhängig von der zu konvertierenden Binärzahl