-
Thread
Atmega8 PWM Leds
sicher der bursche "platine" macht des mit "PWM in Software" wie hier: http://www.mikrocontroller.net/articles/AVR-Tutorial:_PWM erklärt. Mit Transistoren größere lasten Schalten: http://www.mikrocontroller.net/articles/AVR-Tutorial:_IO-Grundlagen Unter punkt 8. Im Tutorial werden BC 338 Transistoren
0,5A. Dahinter kann platine LEDs auch paralel anklemmen bei 5V wird hier http://www.mikrocontroller.net/articles/AVR-Tutorial:_IO-Grundlagen 1kOhm als Vorwiderstand genommen. Also wenn ich nicht irre kann platine einen größeren Transistor nehmen und dann auch 7 LEDs dranhängen weil beim BC338 / 337
-
Thread
LPC1100, superguenstig, 8-bit? Wird immer unnoetiger
Hm, das widerspricht sich dann aber - Programme mit viel IO brauchen also auch viel Platz - Aber grade die Mikros setzt man doch hauptsächlich für IO-Lastige Sachen ein. So gesehen wird der verfügbare Flash aber sehr sehr schnell knapp - wodurch kein Platz
>Untersuchung angestellt und den C code aus dem c't-Bot (target: AVR) >für den Cortex-M3 übersetzt -- wohlgemerkt ohne ihn vorher auf die >speziellen Eigenschaften der ARM Architektur anzupassen. Das Ergebnis >war dennoch niederschmetternd für den AVR. Was mir
-
Thread
Fortlaufender Zähler in C
Timerfunktion einarbeiten (ist nicht wirklich schwer) und es hiermit umsetzen. http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Die_Timer_und_Z%C3%A4hler_des_AVR
sicher eleganter aber für dieses Problem geht es auch noch genausogut ohne Interrupt: [c] #include <avr/io.h> #include <avr/delay.h> #ifndef F_CPU #define F_CPU 3686400UL #endif void WaitAndCheck(*i) { int e; for(e=100; e>0, e++) // 100 x 10ms = 1s { _delay_ms(10);
-
Thread
Kosten eines ADC im günstigsten Fall
Also für ca 30€ kriegst du ein NET-IO mit Zusatzboard, wenn du das selbst lötest. Auf das NET-IO kannst du mit Hilfe von Ethersex ein Skript packen, dass ADC ausliest und auf die SD Karte schreibt. Dann hast du die möglichkeit die
der USB Standard nicht > vollständig (korrekt) implementiert ist. Dann nimm nen PIC statt nem AVR... Oder nen AVR mit USB...
-
Thread
Nokia 6100 Grafiklibrary die Zweite
ATMEGA162 als ATMEGA16 compiliert. Jetzt hab ich die glcd.inc erweitert um #elif defined (__AVR_ATmega162__) #define LCD_PORT _SFR_IO_ADDR(PORTB) #define LCD_PIN _SFR_IO_ADDR(PINB) #define LCD_DDR _SFR_IO_ADDR(DDRB) #define LCD_CS
beiden Makefiles - 8 MHz in das Makefile der Library - Eintrag in die GLCD.H: #elif defined (__AVR_ATmega162__) #define LCD_PORT _SFR_IO_ADDR(PORTB) #define LCD_PIN _SFR_IO_ADDR(PINB) #define LCD_DDR _SFR_IO_ADDR(DDRB) #define LCD_CS
-
Thread
GCC Funktion wird manchmal nicht aufgerufen
Ich habe nun die Zeit nachgemessen. [c] #include <avr/io.h> #include <util/delay.h> #define F_CPU 16000000UL int main(void) { //Pullups und Ausgangssignale für die Ein- und Ausgänge setzten. PORTA = 0b11111111;//Pullups aktivieren PORTB
jemand mit dieser Bibliothek bezüglich SD-Karten gearbeitet? Bibliothek: http://www.mikrocontroller.net/articles/AVR_FAT32#Der_Status Thread: http://www.mikrocontroller.net/topic/105869#new Ich habe nun die Header wie folgt eingefügt: [c] //Includes für SD-Karte #define __AVR_ATmega644__
-
Thread
NEC Protokoll für Harman AVR3550
geht das genauer? Folgenden Code habe ich dazu geschrieben: [c] #include <stdint.h> #include <avr/io.h> #include <avr/interrupt.h> int main(void) { TCCR1 |= (1<<PWM1A)|(1<<COM1A0)|(1<<CS11)|(1<<CS10); OCR1A = 0x0D; DDRB = 0xff; } [/c] Lass ich diesen aber laufen, bekomme
So, Code geändert: [c] #include <stdint.h> #include <avr/io.h> #include <avr/interrupt.h> int main(void) { TCCR1 |= (1<<PWM1A)|(1<<COM1A0)|(1<<CS10); OCR1A = 0x35; DDRB = 0xff; while(1) { PORTB |= (1<<PB5); } }
-
Thread
Microcontroller und Netzwerk
hiermit: http://www.pollin.de/shop/dt/Nzg4OTgxOTk-/Bausaetze_Module/Bausaetze/Bausatz_Add_on_fuer_AVR_NET_IO.html http://www.pollin.de/shop/dt/NzcyOTgyOTk-/Bausaetze_Module/Bausaetze/Bausatz_PC_Relaiskarte_K8IO.html - gerd
http://www.pollin.de/shop/dt/MTQ5OTgxOTk-/Bausaetze_Module/Bausaetze/Bausatz_AVR_NET_IO.html
-
Thread
UART & ATmega324P20PU
HTH [1] http://atmel.com/dyn/resources/prod_documents/doc8011.pdf [2] http://www.mikrocontroller.net/articles/AVR_Checkliste#UART.2FUSART
systemischen Fehler von etwa 7.5% ein [3], das ist zu viel. HF [1] http://www.mikrocontroller.net/articles/AVR_Fuses [2] http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART [3] http://www.wormfood.net/avrbaudcalc.php
-
Thread
Bitte um Hilfe! Wer kennt ein geeignetes Controllerboard ?
sehr gut aus, Preis und Möglichkeit zum Anschluß an I2C-Bus o.ä. wären sehr interessant. (?) Bzgl. AVR-NET-IO --> auch sehr interesant, konnte auf die schnelle jedoch keinen Preis ausfindig machen. Auch die Frage nach der Möglichkeit für I2C ist hier wieder gegeben.(?) Bzgl. AMtel 810074 --> super
Tom schrieb: > Bzgl. AVR-NET-IO --> auch sehr interesant, konnte auf die schnelle > jedoch keinen Preis ausfindig machen. Bausatz 20€; Fertigplatine 28€ plus Porto. > Auch die Frage nach der Möglichkeit für I2C ist hier
-
Thread
Der kleinste µC mit Linux
Das geht... Oder du nimmst was fertiges. Z.B.: Den NETIO von Pollin http://www.mikrocontroller.net/articles/AVR_Net-IO_Bausatz_von_Pollin Kostet 20Euro und es gibt (meines Wissens) auch schon Open Source dafür. So was macht zwar nur halb so viel Spaß, geht aber klar schneller :) Gruß Jürgen
Naja, Linux würde die Sache mit einem guten TCP/IP Stack und Webserver > ganz schön vereinfachen. AVR-NET-IO & Ethersex. Alles schon fertig. Wieso das Rad unnötig neu erfinden?
-
Thread
EEPROM Schreibfrequenz auf eine Adresse
SUT[1-0] auf [01] für langsamsten Startup // F_CPU in Makefile auf 9.600.000 definiert #include<avr/io.h> #include<util/delay.h> #include<avr/interrupt.h> #define OUTBIT 0x02 // Treiber an PB1 void Write_EE(unsigned char adr, unsigned char data) { while (EECR & (1<<EEPE)); // warten
Gewisse Probleme mit dem EEPROM sind bekannt: http://www.mikrocontroller.net/topic/8420 Zitat aus http://www.rn-wissen.de/index.php/Avr-gcc/Interna: "Manche AVRs haben einen Silicon-Bug, der bei Verwendung der EEPROM-Adresse 0 zu Fehlern führt." Zitat aus http://www.rn-wissen.de
-
Thread
EEPROM bei Atmega 8
der Fehler liegt. Hat jemand eine Idee ??? [c] #define F_CPU 3686400 // Taktfrequenz des myAVR-Boards #include <avr\io.h> //---------------------------------------------------------------------- // Specherplatzreservierung im FLASH des AVR char Text[] = "Hallo EEPROM! \0"; //----------
durch einen Interrupt unterbrochen wird! Deshalb rate ich dazu, die bewährten Routinen aus der avr-libc zu benutzen. Die gehen beiden Problemen aus dem Weg: [C] #define F_CPU 3686400 // Taktfrequenz des myAVR-Boards #include <avr\io.h> #include <avr/eeprom.h> #define false 0 #define
-
Thread
Anfänger braucht Hilfe Amtel32 mit Amtel8
Hallo zusammen, vorab wollte ich kurz anmerken das ich noch nicht so viel Ahnung von AVR's und C Programmierung habe wie manch anderer hier im Forum. Deshalb bitte nicht gleich schlagen. Bin vor ca 2 Monaten mit diesem doch sehr komplexen Thema angefangen. Jetzt habe ich einen AVR-Net-IO
Lösung (wenn doch auch gut) ich steh nämlich gerade ein wenig auf dem Schlauch und weiß eben als C und AVR Beginner gerade nicht mehr weiter bzw. in welche Richtung ich suchen kann. Falls nicht bekannt: 1.Pollin AVR-Net-io Best.Nr. 810 058 2.Touch mit amtel8 Für eventuelle Hilfe jetzt schonmal vorab
-
Thread
LED ATMEGA8 schnell ansteuern
Hier die Fehlermeldung (ist ziemlich lang) Wo sind beim avr MacPack die Bibliotheken? Macintosh:firmware Flops$ make avr-gcc -Wall -Os -DF_CPU=8000000 -mmcu=atmega8 -c main.c -o main.o main.c:10:21: error: io2313v.h: No such file or directory main.c:11
so vor, als hättest du kein einziges include verwendet... standard includes wie zb: #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #include <stdlib.h> . . . und sicher noch irgendwelche speziellen lg
-
Thread
SPWM auf Atmega8, bitte um Feedback hinsichtlich Optimierung
sondern eine C-Datei. Auf dem AVR packt man die in den PROGMEN, sonst verschwendet man nur sinnlos RAM. http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Programmspeicher_.28Flash.29 Deine Funktion void CarrierCalculation
normal, es ist noch kein Meister vom Himmel gefallen. Am Ball bleiben ist wichtig. [c] #include <avr/io.h> #include <util/delay.h> #include <avr/interrupt.h> #include <avr/pgmspace.h> #include "SineLookupTable.h" void CarrierCalculation(void); //void SineCalculation(void); volatile uint8
-
Thread
Arduino hilfreich bei Bewerbungen?(kein Trollversuch!!)
Bereich beherrsche. Du hast das AVR Datenblatt gelesen und weisst was er kann (PWM,Fuse bits, UART-Parameter, IO-Modi, Unterschiede Timer/Counter, IRQ-handling) und wo Du nachlesen musst um die vorhanden Config-bits zu finden? Du könntest
Berufsrevolutionär schrieb im Beitrag #5131928: > Du hast das AVR Datenblatt gelesen und weisst was er kann (PWM,Fuse > bits, UART-Parameter, IO-Modi, Unterschiede Timer/Counter, IRQ-handling) > und wo Du nachlesen musst um die vorhanden Config-bits zu finden? Du
-
Thread
Automatische Stalltür, Sensorabfrage, Atmega8 GCC
trotzdem lesbar. C Beautifier sind längst erfunden. ADC beim Atmega8 in C http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#ADC_.28Analog_Digital_Converter.29 [C] #define F_CPU 1000000UL #include <avr/io.h> #include <util/delay.h> // Schaltung soll bei 1,2V+-10% an ADC1 schalten //
Widerstand (10k ) -> Fotowiderstand -> Akku1,2V-> PortC1 Das ist auch nix. http://www.mikrocontroller.net/articles/AD-Wandler http://www.mikrocontroller.net/articles/AVR-Tutorial:_ADC (rechte Schaltung) [pre] ^ Vcc | # # Fotowiderstand # | +-----o PINC.1 (ADC1) |
-
Thread
Atmega328p wacht nicht auf, wo steckt der Fehler?
Sensor reagiert nicht mehr und der Stromverbrauch ist konstant bei 42µA. [c] #include <avr/io.h> #include <stdint.h> #include <avr/interrupt.h> #include <avr/sleep.h> #include <util/delay.h> #define F_CPU 8000000L volatile uint8_t flag; int main(void) { DDRC |=
tatsächlich an den Kondensatoren! Eine Stolperfalle hast du noch drin: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Die_Timer_und_Z%C3%A4hler_des_AVR#Wenn_er_die_Minute_in_20s_schafft mfg.
-
Thread
USART Initialisierungs Problem Gesperrt
machst, ist Leichenfledderei. Bessere Lösung s. aktuelles Tutorial: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Auszug: [c] #include <avr/io.h> #define F_CPU 1000000 /* evtl. bereits via Compilerparameter definiert */ #define BAUD 9600 #include <util/setbaud.h> [
Danke, bin über Google nur auf das alte (http://www.mikrocontroller.net/articles/AVR-Tutorial:_UART) gestoßen...
-
Thread
ATmega88: Ports, PINs und DDR
schauen, welchen Zustand ein Eingang hat, also ob High oder Low? Ich nehme mal den Code aus dem AVR-GCC-Tutorial (http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Zugriff_auf_IO-Ports) [c]#include <avr/io.h> ... /* Fuehre Aktion aus, wenn Bit Nr. 1 (das "zweite" Bit) in PINC gesetzt (
es aber trotzdem nochmals durch. Eigentlich steht da alles dazu drin. http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Zugriff_auf_IO-Ports http://www.mikrocontroller.net/articles/Bitmanipulation Und ja, eine 1 im entsprechenden Register entspricht einem "high" am Hardware-Pin. Oliver
-
Thread
Suche Tutorial zum Assembler schreiben eines eigenen Webservers Gesperrt
Programmierung (ehr weniger aber genug) und Computertechnik. Mein Vorhaben: Ich habe vor für mein AVR-Net-IO einen Eigenen Webserver zu schreiben, wenn möglich in Assembler oder aber auch in C. Dieser soll ein Display mit Textausgabe haben, Porterweiterung, 1-Wire und Infarot (RC5) sowie viele weiter
Mirte schrieb im Beitrag #2332640: > Mein Vorhaben: Ich habe vor für mein AVR-Net-IO einen Eigenen Webserver > zu schreiben, wenn möglich in Assembler oder aber auch in C. Dieser soll > ein Display mit Textausgabe haben, Porterweiterung, 1-Wire und Infarot > (RC5) sowie viele
-
Thread
Welche Programmiersprache?
Orientierung hier meine Erfahrung: Mit Bascom gehen einfache, nicht komplexe Sachen sehr schnell. Also IO-Funktionen, ADC, LCD, SPI, I2C, RC5.. alles vorgefertigt. Nur lernt man bei plain-bascom nichts über die Hardware. Du kommst damit weit, nur wenn es z.B. mal darum geht, 2 LCD am AVR anzusteuern, sehen
beherrsche einige Assemblerdialekte vom guten alten 8080,80x86 angefangen ueber 6502,68000,68hc11 bis zu AVR,MSP430,ARM. Nur wenn du nicht immer wieder alles neu schreiben willst dann mach man das in C. Ich meine jetzt nich Lowlevel IO/Routinen sondern die Schichten die darueber liegen. Also Menusteuerungen
-
Thread
AVR so einfach wie möglich im Netz
Hallo, ich möchte ein Board bauen, das im Prinzip wie das Pollin AVR-Net-IO funktioniert. Hierfür würde ich gerne einen ATmega einsetzen, der allerdings MOSFETs ansteuert und somit - im Gegensatz zum AVR-Net-IO - Leistung schalten kann. Auch möchte ich PWM-Ausgänge
Anforderungen und funktionieren nur in Spezialfälle dafür mit weniger Aufwand. Wenn du meinst, daß der AVR im AVR Net IO schon überlastet ist (obwohl der immerhin einen extra Ethernetcontroller beigestellt hat), und du keinen zweiten uC einsetzen willst der das NetIO lediglich als Interface verwendet
-
Thread
Möglichkeiten den Kontroller anzusprechen
Schnittstelel sehe ich nicht. Jedoch steht in der Anleitung etwas von JTAG bei den Fuse Bits. Ich hab das AVR-Net-IO Board mit einem ATMega 32 von Pollin.
Der ATmega32 kann JTAG, das ist aber beim AVR-Net-IO nicht auf einen entsprechenden Stecker gelegt, kann damit also nicht so einfach genutzt werden. Programmiert wird der ATmega32 im AVR-Net-IO über die ISP Schnittstelle, die jedoch kein Debugging
-
Thread
Embedded System - STM32F429
besonders hohe Prozessorleistung >gefordert wird, fange eine Nummer kleiner an; meinetwegen mit AVR oder >einem Arduino. Hmmm, lass mal sehen ... ... sieht gut aus ;-)
Speicherbereich sitzt, wo die Applikation hinkommt, und der Bootloader wird auch nur ausgeführt, wenn zwei IO-Pins entsprechend von außen gesetzt werden.
-
Thread
Diverses Entwicklungszeug für AVR
, die ich nie genutzt habe und wahrscheinlich auch nicht mehr brauche. Es geht los mit "Bausatz AVR NET-IO" von Pollin, unbenutzt noch in Einzelteilen. Da ist ein ATmega32 drin, ein ENC28J60, und alle Kleinteile mitsamt Platine. Davon habe ich 2 komplette Sätze, vielleicht je 10€. Außerdem
auch noch andere :-) Antwort ist unterwegs, aber "alles" geht nicht mehr... Jetzt sind noch die AVR-NET-IO da. Alles andere ist schon mehr oder weniger auf dem Weg. Paket an Adam schon bei der Post.
-
Thread
AVR Programmierung C++
declared in this scope". Aber warum? TxBuffer wurde doch in der Klasse angegeben? [c] #include <avr/io.h> #include <avr/interrupt.h> class cSerialComm { public: // variables volatile cRingBuffer TxBuffer; // constructor -> setup cSerialComm(); // write string in tx
den mal hier, Meinung, Kritik und Verbesserungsvorschläge erwünscht. Main File: [c] #include <avr/io.h> #include <avr/interrupt.h> #include "SerialComm.h" // pin definitions #if 1 // Switch #define pin_sw PINB0 // PLL SPI Communication #define pin_SPI_pll_lo_En PINB1
-
Thread
Spuk oder Programmfehler?
Hallo das nachfolgende Programm funktioniert nur eingeschränkt: [c] #include <avr/io.h> #include <util/delay.h> int main(void) { DDRA = 0xFF; while (1) { PORTA =0xFF; _delay_ms(1000); PORTA =0x00; _delay_ms(1000); }; } [/c]
am Resetpin messen können. Wenn hier was blinken würde, dann ist der Wurm drin: [c] #include <avr/io.h> #include <util/delay.h> int main(void) { DDRA = 0xFF; PORTA =0x00; _delay_ms(1000); while (1) { PORTA =0xFF; _delay_ms(1000); }; } [/c] Wenn
-
Thread
Arduinopreise? WTF?
Zu Fälschung, Klone, Opensource, alles nur gekaut Siehe hier:https://arduinohistory.github.io/de.html
es WIRKLICH schnell braucht macht direkte Portzugriffe oder nutzt DirectIO. https://github.com/mmarchetti/DirectIO
-
Thread
Quick&dirty - schnelle Problemlösungen selbst gebaut Bilder
benutze z.B. OpenCamera, dort kann man alles manuell einstellen. https://opencamera.sourceforge.io/ https://play.google.com/store/apps/details?id=net.sourceforge.opencamera&hl=de
Um nochmal hier drauf zu kommen : https://www.mikrocontroller.net/topic/327158?page=single#5612035 Hast du die hier beschriebene ATMEL AppNote AVR442 das als Vorlage genommen ? https://www.mikrocontroller.net/topic/435884#5694177 Bernd_Stein
-
Thread
Timer zählt zu langsam
Abend zusammen, ich schmore gerade über folgendem Code: [c] #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #include "lcd-routines.h" #include <stdlib.h> //Variablen für die Zeit volatile unsigned int millisekunden=0; volatile unsigned
thx für die schnelle Hilfe, nun gehts habs noch n bissle mehr abgeändert.^^ [c] #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #include "lcd-routines.h" #include <stdlib.h> //Variablen für die Zeit volatile unsigned int millisekunden=0; volatile unsigned
-
Thread
LCD Display Ansteuerung mit Atmega169P
Atmega169_Display_Ansteuerung.c * * Created: 13.01.2023 15:34:51 * Author : */ #include <avr/io.h> #include "avr/io.h" #include "avr/interrupt.h" #include "avr/wdt.h" #include <string.h> #include <math.h> #include <stdlib.h> void LCD_Init(void) { /* DDRA = (1<<DDA0)
Hast du schon mal ins GCC Tutorial geschaut? https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial Vor allem: https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung Da steht alles gut erklärt drin. Komm, Peiler, komm schrieb im Beitrag #7324272
-
Thread
Servo Problemm
Bist du sicher das das richtig ist, ich habe das anders in Erinnerung. http://www.mikrocontroller.net/articles/AVR-Tutorial:_Servo http://www.rn-wissen.de/index.php/Servos
[c]#define F_CPU 4000000UL #include <avr/interrupt.h> #include <avr/io.h> #include <util/delay.h> #define SERVOPIN 7 #define SERVOPORT PORTD #define DDRSERVO DDRD volatile unsigned char servopos; void servo_init() { TIMSK|=
-
Thread
atmega64 8 bit timer läuft nicht
was ist denn das M103C-Fuse ? hab das noch nie gehört. Datenblatt?? http://www.mikrocontroller.net/articles/AVR_Fuses#Kompatibilit.C3.A4tsfuses_und_manchmal_l.C3.A4stige_Defaults
Na denn, zum Testen ob der Timer überhaupt anläuft, sollte das reichen [C] #include <avr/io.h> #include <avr/interrupt.h> unsigned char count; ISR( TIMER0_OFV_vect ) { PORTB = count++; } int main() { DDRB = 0xFF; TIMSK = ( 1 << TOIE0 ); TCCR0 = ( 1 << CS00 ) |
-
Thread
AVRstudio5: ich werde wahnsinnig - Funktionen werden nicht aufgerufen
habe folgenden Code, mittlerweile minimalisiert, da ich gar nicht voran komme: [code] #include <avr/io.h> #include <avr/interrupt.h> #include <stdint.h> volatile uint8_t yy=0x03; ISR(TIMER1_COMPA_vect) { yy++; } ISR(TIMER1_COMPB_vect) { yy +=2; } void timer_init(void) {
ersten Teil war er auskommentiert Den Code habe ich als erstes schon gepostet: [code] #include <avr/io.h> #include <avr/interrupt.h> #include <stdint.h> volatile uint8_t yy=0x03; ISR(TIMER1_COMPA_vect) { yy++; } ISR(TIMER1_COMPB_vect) { yy +=2; } void timer_init(void) {
-
Thread
RC Empfänger PWM Signal Mosfet Motorregler
ich bin froh das ich es überhaupt geschafft habe den Motor zum laufen zu bringen. [c] #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #define F_CPU 4000000UL volatile int flanke=0; volatile int aktuell_pwm_l=0; volatile int aktuell_pwm_h=0; ISR(TIMER1_CAPT_vect
http://www.mikrocontroller.net/topic/74861 http://www.ulrichradig.de/home/index.php/avr/avr_-_rc http://www.ulrichradig.de/home/uploads/File/RC/RC_Sum_Encode.zip
-
Thread
[V] Diverse Boards AVR, Renesas, ST
Und weiter geht's mit paar Boards. - AVR NetIO mit Firmware von Ulrich Radig -- 15€ - ELV 05522 LCD-Steuerung mit Textspeicher und Text-Eingabe -- 16€ - AVR Butterfly (1x benutz) -- 13€ - STR9-comStick Web Server mit ARM STR912FA44 -- 15
Das AVR NetIO ist Ebenfalls weg. Dazu kommt ein AVR-USB-STK Board von Olimex, neu und unbenutzt. µC drauf ist ein AT90USB162 - USB connector - Joystick, - RS232 - SD-MMC card, so wie - Audio output
-
Thread
ADC-Wert über RS232 übermitteln
Habe noch von hier (Schreiben von Zeichenkette: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Der_interne_ADC_im_AVR Das versucht: [c] int uart_putc(unsigned char c) { while (!(UCSRA & (1<<UDRE))) /* warten bis Senden moeglich */ { }
alle Funktionenen zusammen, die ich eigentlich brauche. Danach kann man ausbauen. Habe - C++ .Net, Ron Nanko - Programmiertechniken für AVR-Mikrokontroller, Manfred Schwabl-Schmidt Gruss Fox
-
Thread
RGB-LED Ansteuerung mittels PWM in AVR Studio 4 (C-Programmieren)
https://www.mikrocontroller.net/articles/AVR-Tutorial
LEDs in der Helligkeit steuern kannst. Eine ganz wichtige Hilfe ist https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial und https://www.mikrocontroller.net/articles/AVR-Tutorial Da steht im Prinzip (ADC-, UART- und PWM-Programmierung) alles drin, was du zum Lösen deiner Aufgabe wissen
-
Thread
Arduino Bibliotheken funktionieren nicht beim AVR128DB-Prozessor
Sebastian H. schrieb im Beitrag #7628941: > Prozessor AVR128DB28 AVR128DB28 ist kein Prozessor, sondern ein Controller.
die Launchpads von großem Interesse, weil man da auch mit dem Debugger arbeiten kann, was bei den AVR Arduinos nicht möglich ist. https://www.mikrocontroller.net/attachment/610877/IMG_9787.jpeg In Anbetracht aller Alternativen finde ich die Situation nicht zu schlimm. Ansonsten ist der DIL ATMEGA1284P
-
Thread
[V] div. Module (AVR, MSP430, NET-IO, Raspberry Pi)
Verkaufe folgende Dinge als Bundle: 1x AVR NET-IO mit ATmega 644 1x AVR NET-IO Add-On Board (Mit aufgelötetem Funkmodul) 1x Funkmodul RFM12 (unbenutzt original verpackt) 2x Funkmodul RFM02 (unbenutzt original verpackt) 2x MSP430 Launchpad
-
Thread
Attiny13 erstes Programm. Hilfe gesucht !
mir jemand > bei dem Programm auf die Sprünge helfen ? Starte hier: https://www.mikrocontroller.net/articles/AVR und mach dann mit dem AVR Tutorial weiter. Wenn du eine LED blinken lassen kannst, bist du in der Lage Ausgangspins zu steuern. Weiterhin brauchst du für dein Projekt eine Art Uhr, die
Ich hab da grad mal Bock drauf: [c] #include <avr/io.h> #include <avr/interrupt.h> #define KARTE1 PB0 #define KARTE2 PB1 #define TASTER PB2 int main(void) { // Timer TCCR0A |= (1<<WGM00) | (1<<WGM01); // CTC OCR0A
-
Thread
Betriebssystem für 32 Bit µCs?
MC.net Mods sind feige.
ist weil urspr. mit 32kB RAM zufrieden) - <https://www.mikrocontroller.net/articles/AVR_CP/M> - <http://www.projekte.daleske.de/prog/11_EMUZ80_RPI/prog_EMUZ80_RPI_en.htm>
-
Thread
Arduino "static const uint16_t PINK= 0xF81F" failed
noch die Definitionsdatei des Mega2560 als Link mit rein: https://github.com/arduino/ArduinoCore-avr/blob/master/variants/mega/pins_arduino.h Jemand fragte bei AVR-Freaks.net nach ähnlichem: Hier ging es darum, einen PING zu speichern, also quasi die Antwort oderso in einer variablen abzulegen. Er
redefined #define PINK 0xF81F In file included from c:\program files (x86)\arduino\hardware\tools\avr\avr\include\avr\iom2560.h:38:0, from c:\program files (x86)\arduino\hardware\tools\avr\avr\include\avr\io.h:174, from c:\program files (x86)\arduino\hardware\tools
-
Thread
2 Signale abwechselnd per RS232 einlesen?
. Ich habe ein Frage bzgl. des Einlesens von zwei verschiendene Datenquellen via RS232 in _einem_ AVR Net-IO von Pollin. Konkret geht's mir darum, dass von zwei verschiedenen Quellen alle Nase lang Daten geschickt werden, ich aber nur *einen* Net-IO aufhängen will, der diese Daten abwechselnd einfängt
Wenn die Datenrate nicht allzu hoch ist, kannst Du dem AVR auf der Net-IO-Platine eine zweite in Software implementierte UART spendieren. Du könntest auch per I2C eine externe zweikanalige UART wie die SC16IS762* anschließen. *) http://ics.nxp.com/products
-
Thread
ATMega: Reboot per Software auslösen?
H.Joachim S. schrieb im Beitrag #5531949: > Zeige mal EINEN AVR, der > einen internen watchdog hat und dessen Reset kein vollwertiger Reset > ist. https://www.mikrocontroller.net/articles/AVR_Typen Wie ich schon dem mit dem billigen Whiskey mitteilte:
für einen ESP aus einem LE33CV im TO92 genügte ein BC547 War aber eher als Scherz gemeint. Beim AVR tut es der Watchdogreset einwandfrei, um in den Bootloader zu kommen. Der Bootloader weiß ja, welche IO-Register er angefaßt hat (z.B. UART) und muß nur diese zurück setzen, bevor er die Applikation
-
Thread
suche beispielcode für 16-Bit Timer (Mega 8)
Test <c> #define F_CPU 8000000UL #include <stdlib.h> #include <avr/io.h> #include <avr/interrupt.h> //#include <util/delay.h> // ab avr-libc Version 1.2.0 möglich und empfohlen: #include <stdint.h> // veraltet: #include <inttypes.h> ISR( TIMER1_OVF_vect
[c] #define F_CPU 8000000UL #include <stdlib.h> #include <avr/io.h> #include <avr/interrupt.h> //#include <util/delay.h> // ab avr-libc Version 1.2.0 möglich und empfohlen: #include <stdint.h> // veraltet: #include <inttypes.h> ISR( TIMER1_OVF_vect
-
Thread
Zu großer Code, obwohl winziges Programm
[c]#include <avr/io.h> //Grundfunktionen #ifndef F_CPU //Vordefinieren für delay.h #define F_CPU 1000000UL //Definition von F_CPU in Herz #endif #include <util/delay.h> //Warteschleifen
Timer-Version ist natürlich die sauberere Lösung. Aber wie Kürbis schon sagte, so wärs auch gegangen: AVR Memory Usage Device: attiny2313 Program: 198 bytes (9.7% Full) [c] #include <avr/io.h> #include <util/delay.h> void my_delay_us(unsigned int ms) // delay ms {
-
Thread
ATmega16 - 'MCUCSR' undeclared
Es fehlt ein #include <avr/io.h>, und das Programm muß mit -mmcu=atmega16 compiliert werden.
Johann L. schrieb im Beitrag #3240632: > Es fehlt ein #include <avr/io.h>, und das Programm muß mit > -mmcu=atmega16 compiliert werden. Die #include <avr/io.h> ist im Header dabei, das Problem bleibt aber bestehen. Meinst du damit, dass im AVR-Studio im Fenster