-
Thread
Interupt mit Timer
zwischen XTAL 1 und XTAL 2 Dein Quarz schwingt nicht mit exakt 8000000 Hz. http://www.mikrocontroller.net/articles/AVR_-_Die_genaue_Sekunde_/_RTC
http://www.mikrocontroller.net/articles/AVR_Fuses
-
Thread
An alle Logiker
Mensch Müller (Gast) >Habt ihr eine Idee, wie man das vereinfachen könnte, um es dem Compiler >(avr-gcc) einfacher zu machen? Warum? Ist es zu komplex? Ist die Ausführungszeit zu groß? https://www.mikrocontroller.net/articles/AVR-GCC-Codeoptimierung#Prinzipien_der_Optimierung > Ich ziele
du deinen Einwand ad absurdum führtst! Ich verweise nochmals auf https://www.mikrocontroller.net/articles/AVR-GCC-Codeoptimierung#Prinzipien_der_Optimierung Mit der Betonung auf "Verfrühte Optimierung ist die Wurzel allen Übels"
-
Thread
Library für EA-DOGM Grafikdisplays inkl. Font-Generator
sagen inc. Includes, was zu tun ist um "Hello Word" anzuzeigen? Bisher (nur) [c] #include <avr/io.h> int main(void) { while(1) { DDRC=0xFF; DDRA=0xFF; } }} [/c] Schönen Dank, jo
teilweise). Eine Schrift oder ähnliches konnte ich nicht ausgeben. [c] #include <stdbool.h> #include <avr/pgmspace.h> #include "main.h" #include "i2cmaster.h" #include "avr/io.h" #include "util/delay.h" #include "avr/interrupt.h" #include <stdlib.h> #include "string.h" // Adressen für XL160 0x7a
-
Thread
Eigenartiges Verhalten bei Interrupts (Arduino)
zwischen 10 und 50Hz. Hier der Programmcode, nur für die steigende Flanke: [code] #include <avr/io.h> #include <stdlib.h> #include <math.h> #define F_CPU 16000000UL #include <util/delay.h> #include <avr/interrupt.h> void interrupt_init(); int main(void) { DDRB |= (1<<DDB4); //
aktuelles Programm - und beschreibe, wie Du den > Komparator beschaltet hast. [c] #include <avr/io.h> #include <stdlib.h> #define F_CPU 16000000UL #include <util/delay.h> #include <avr/interrupt.h> void comparator_init(); int main(void) { DDRD &= ~(1<<DDD6); DDRD &= ~(1<
-
Thread
ADC Messung mit dem Attiny 841
habe ich dazu nicht und es geht damit. [c] #include "main.h" // CPU 16MHz #include <avr/interrupt.h> // dient zur Behandlung der Interrupts #include <avr/io.h> // Integer-Definitionen #define I2C_SLAVE_ADDRESS 0x52 // Slave Adresse 0x52 #define I2C_DATA_INTERRUPT
Frequenz, wichtig für die Zeit #include <util/delay.h> // Einbindung Datei Pause #include <avr/io.h> // Einbindung Datei Ausgänge #include <stdio.h> #include <avr/interrupt.h> #define I2C_SLAVE_ADDRESS 0x52 #define I2C_DATA_INTERRUPT 0x80 #define I2C_BUS_COLLISION
-
Thread
Potentiometer auslesen
* GccApplication1.c * * Created: 01.03.2014 19:14:48 * Author: user */ #include <avr/io.h> int main(void) { float messung; DDRD = 0b00111111; while(1) { messung = read_adc(0); messung = messung *5/1023; if( messung<=1 ){ PORTD =
*gesamter (sry ich schreibe mit Handy ;)) http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Analoge_Ein-_und_Ausgabe Hier extra für dich rausgesucht. Das nächste mal bitte erst googeln bzw es selber versuchen und dann fragen. Denn: von nichts kommt nichts!
-
Thread
Wieviel mehr an Strom braucht man für 64 Bit fähige Mikrocontroller?
zeptobars.com/en/read/atmel-attiny13a in 500nm gefertigt, also gehe ich mal davon aus, dass die meisten AVR Controller in 500nm gefertigt sind.
PICs hat Microchip das auch gemacht. Die neuere laufen intern nur noch mit 2.5 oder 1.8V, und nur der IO-Ring läuft noch mit 3.3 oder 5V. Atmel hats bei den AVRs verpennt. So kleine Designs sind aber pad-bound. Heißt: Die Bondpads und die IO-Treiber bestimmen die Die-Größe, d.h. auch eine kleinere Technologie
-
Thread
[Projektaufruf] Lasst uns eine Kompaktsteuerung bauen
Erweiterungen, oder auch zwei solche Platinen zusammenschließen (mit i2c slave code), dies ist aber bei avr-io einfacher, da HW-I2C an den Pins vorhanden.
über RS-232 Pegel mit der Basis. Ansonsten hat Jonathan Westhues einen Ladderlogic Compiler für AVR (und PIC?), das geht ja auch in Richtung SPS.
-
Thread
Dosieranlage über AVR Mega8
sprich zwischen Vcc und GND oder was hat das mit diesem AREF auf sich??? http://www.mikrocontroller.net/articles/AVR-Tutorial:_Equipment
AVR abspeichern, dann aber nicht im S-RAM sondern im EEProm. http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#EEPROM Lennart Jöhnk schrieb im Beitrag #2306350: > Das heißt dann ja, dass ich
-
Thread
Wartezeiten effektiv (Scheduler)
. Wenn ich test() ausführe passiert dies auch. Mit timmeradd passiert aber nichts. [c] #include <avr/io.h> #include <util/delay.h> #include <avr/interrupt.h> #include <avr/pgmspace.h> #include "MAIN.h" int main (void) { //Für Scheduler TCCR0 = 1<<CS02; //divide by
} [/c] Die SCHEDULE.c habe ich nicht verändert und die MAIN.c sieht so aus: [c] #include <avr/io.h> #include <avr/interrupt.h> //#include <signal.h> #define XTAL 16e6 #define TIMERTICK (XTAL / 256 / 256) // timer ticks per second #define SECONDS(x) ((uint)(TIMERTICK * x + 0.5))
-
Thread
mega8 Timer Interrupt funktioniert nicht.
nicht aufgerufen. Ich weiß einfach nicht wo der Fehler sein soll. Hier mein Code: [c] #include <avr/io.h> #include <stdlib.h> #include <avr/interrupt.h> ISR(TIMER0_OVF_vect) { PORTD = 0x00; } int main(void) { DDRC = 0b00111100; DDRD = 0b11111111; TCCR0 |= (1 << CS00) | (1
Frage zur Timerverwendung. Und zwar habe ich versucht dieses Beispiel ( http://www.mikrocontroller.net/mc-project/Pages/AVR/Software/timer_bsp_interrupts.c ) auf meinen Atmega8 und AVR-Studio 4 anzupassen. Es wird zwar ohne Fehler compiliert, aber der Simulator meckert: AVR Simulator: Uninitialized
-
Thread
Bitte um Hilfe bei Timerprogrammierung
Basis des Programms ist übrigens der Code hier, danke dafür an den Autor: https://www.mikrocontroller.net/attachment/highlight/77856 Hier ist der Code: [c] #ifndef F_CPU #define F_CPU 1000000 #endif #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #include <stdlib.h
TICIE1) | (1<<TOIE1); // Interrupts akivieren, Capture + Overflow Hier https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Die_Timer_und_Z%C3%A4hler_des_AVR steht ganz unten etwas von einer Global Enable Interrupt Flag. hat es etwas damit zu tun?
-
Thread
Alternative Firmware für Philips Fernseher
http://sitsec.net/blog/2013/09/16/jointspace-server-directory-traversal-vulnerability-on-a-philips-6000-series-smart-led-tv/
meinen Philips zu pimpen. Muss mich aber auch erst einmal belesen. Bin Software(Delphi)/Hardware(AVR/PIC)-Programmierer. Bis jetzt habe ich noch nicht soviel Erfahrung mit Linux gemacht, Bei Assembler-Programmierung kann ich auch nur mit x86(inkl. SSEx) bzw. AVR-Assembler dienen. Weiß denn schon jemand
-
Thread
TIMER16Bit beim ATmega128 anders als beim ATmega32 ?
anders voreingestellt werden? Die Datenblätter zeigen keine große Unterschiede :( #include <avr/io.h> #include <avr/interrupt.h> //globale variablen volatile uint8_t sekunde=0; volatile uint8_t minute=0; volatile uint8_t stunde=0; // prototyps void timer1_init(); void uhrzeit();
#1773283: > Was ist das und wo findet man das? im Datenblatt... und http://www.mikrocontroller.net/articles/AVR_Checkliste#Besonderheiten_bei_ATmega128_und_seinen_Derivaten_im_64-Pin-Geh.C3.A4use
-
Thread
Luminary LM3S6965 Ethernet Eval board
haben und nicht so ohne weiteres davon loskommen. Ein AVR bietet nicht die entscheidenen Vorteile.
Nur blöd, dass es unter KEIL net geht. da ist extra ein keil projekt file aber der linker macht net mit, da 23kb.... die iar version würde ja 32kb mitmachen, die habe ich nun auch installiert aber leider bekomm ich es nicht ohne
-
Thread
C in Assembler einbetten (also andersrum!)
= 21 r22 = 22 r23 = 23 r24 = 24 r25 = 25 r30 = 30 r31 = 31 sreg = _SFR_IO_ADDR(SREG) ucsra = _SFR_IO_ADDR(UCSRA) ucsrb = _SFR_IO_ADDR(UCSRB) ucsrc = _SFR_IO_ADDR(UCSRC) udr = _SFR_IO_ADDR(UDR) // usw. [/avrasm] dann kannst du programmieren, wie gewohnt
durchbeißen". (Das o.g. Makro z.B. ließ sich unverständlicherweise, trotzdem ich den "\()"-Tipp auch in den AVR-Freaks-Foren wiedergefunden habe, nicht weiter optimieren, schade, ich hab's soweit vergraben, dass ich es hoffentlich nie wieder sehen muss). - Auch essentiell: Alle Zugriffe auf den unteren IO-Bereich
-
Thread
Bluetooth-Modem HB300 bei Pollin
Freiheit genommen, die 5.2MB-png-Datei durch eine JPG-Datei zu ersetzen. http://www.mikrocontroller.net/articles/Bildformate! -rufus
Sorry, der Link oben funktioniert nicht - die Seite ist hier: http://www.mikrocontroller.net/topic/121785
-
Thread
muArt - Der zuverlässige und universelle UART-Konverter
zu realisieren. Das hat bisher immer prima funktioniert [1,2,3]. [1] https://www.mikrocontroller.net/topic/329265?page=1 [2] https://www.mikrocontroller.net/topic/354785?page=1 [3] https://www.mikrocontroller.net/articles/AVR_CP/M
die werde ich auch weiter verwenden, für Experimente an kleinen Linux Rechnern z.B. mit niedrigen IO Leveln ist sowas wie der µArt schon besser. Und bevor hier auf µC.net ein gemeinsames Projekt dafür entsteht wird eine Frauenmannschaft von Saudi Arabien Fussball Weltmeister.
-
Thread
Dallas Sensoren HexCode für AVR
Hallo Ich habe folgendes Problem... Zur Zeit nutze ich ein AVR-NET-IO von Pollin (Teilbestückt) mit einer Software, in der der HexCode der Adresse des Sonsors in die Config eingetragen werden muss. Nun wollte ich ein paar Sachen neu machen und neue Sensoren verwenden
fangen mit 10- an ... Sind das ds18S20? Dann ist hex 10 der Family-Code. Wenn der Sensor, der am NetIO hing, an den RasPi geklemmt wird, was sagt dieser dann?
-
Thread
Padauk PFS154 Programmer mit Arduino Uno / ATmega88 - 328
bleiben) hab ich hier auch mal ein "Flashershield" veröffentlicht gehabt https://www.mikrocontroller.net/topic/459194 welches 3 verschiedene Derivate von MCS-51 programmieren kann, natürlich die AVR Serie mit ISP und ein paar wenige (alte) PIC16F Controller. Wenn man sich anschaut, was zum Programmieren
: https://www.mikrocontroller.net/topic/461002?page=1
-
Thread
avr-as Problem mit include und allgemeiner Syntax
Du kannst die Atmel-.inc-Files nicht mit avr-as verwenden, dazu ist die Syntax zu unterschiedlich. Ein [c] #include <avr/io.h> [/c] am Beginn Deines Assembler-Programms holt Dir alle Definitionen für den momentanen µC. Welcher das ist, bestimmt
> Welche Datei muss ich nun für den Include nehmen? avr/io.h Wenn der MCU korrekt auf dein Target Atmegam1281 definiert ist, includiert die automatisch avr/iom1281.h. Und du musst die richtige Endung für die Sourcen haben, damit vor dem gnu-as der
-
Thread
LCD-Modul TC1602E-01 von Pollin ansteuern
/**< pin for Enable line */ [/code] Mein Code sieht wie folgt aus: [code] #include <avr/io.h> #include "lcd.h" int main(void) { lcd_init(LCD_DISP_ON_CURSOR); lcd_clrscr(); lcd_home(); lcd_putc('c'); while(1) { } } [/code] Auf dem Display ist
ausprobiert. Jedenfalls muss irgendwo die Fehlinformation mit den 'Pins auf Ground' rumschwirren. Im AVR-Tutorial LCD stehts aber richtig. http://www.mikrocontroller.net/articles/AVR-Tutorial:_LCD
-
Thread
Muss man einen Optokopplerpin Low ziehen?
Joachim B. schrieb im Beitrag #5280109: > es gibt auch AVR die 40mA treiben aber das hält nicht jede LED aus und > ist auch absolut unnötig, man sollte also immer an einen RV denken Hi, da steht auch etwas... https://www.mikrocontroller.net/articles/AVR-Tutorial:_IO-Grundlagen bis auf "...Ausgänge benutzen, wenn mehr Strom benötigt wird..." runterscrollen. Wie nun praktische "Portanschlüsse" aussehen (bei mir) ist aus den Bildchen zu entnehmen
-
Thread
SchulProjekt mit Mikrcontroller ,RaumtemperaturSensor ertellen
/AVR_In_System_Programmer#USB http://www.rn-wissen.de/index.php/AVR-ISP_Programmierkabel So Hardware sollte Rennen nun noch das Display http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung
gerade die Sonne ins Fenster scheint noch, für die Eingabe. http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Zugriff_auf_IO-Ports http://www.mikrocontroller.net/articles/Entprellung#Komfortroutine_.28C_f.C3.BCr_AVR.29 Das alles kannst du ohne Probleme auf einem Atmega8 anwenden
-
Thread
Peter Fleury LCD Lib für AT90USB162?
ja auch keine Rolle spielen. Als Entwicklungsumgebung benutze ich das AVR Studio 5 und meine Code übertrage ich mit Filp. Meine Code besteht aus dem Startbeispiel mit der Blinkenden LED und der LCD Lib von Peter Fleury hier LCD_Test.c [c]#include <avr/io.h> #include
*************************************************************/ #include <inttypes.h> #include <avr/io.h> #include <avr/pgmspace.h> #include "lcd.h" /* ** constants/macros */ #define DDR(x) (*(&x - 1)) /* address of data direction register of port x */ #if defined(__AVR_ATmega64
-
Thread
Creative-Soudcips mit AVR zu Synth recyclen?
aufgesetzt, das die Signale und 5V bereitstellt. Derzeitige Verbindungen: - Datenbus D0-D7 auf AVR-Port PA0 bis PA7 - A0 und A1 an AVR Port PC0 und PC1 (Base+0 bis Base+3) - Reserve für evtl. Versuche mit A2 und A3 (nicht nötig) - /IOR udn /IOW-Leitung mit PullUp an AVR Port PC4 und PC5 - AEN-Leitung
Bascom-Code ebenfalls beigefügt. Der OPL-Chip wurde in Adresse 220h parametriert, und über A1 (IO-Port 221h-Base und 223h-Extended) angesprochen. Lesezugriffe machen keinen weiteren Sinn, die Timer sind nicht weiter interesant, da der AVR so oder so genug eigene Resourcen dafür hat. Der OPL-Chip
-
Thread
WS2812B 800KHz PWM mit Transistor Pegelwandler
Mosfet einsparen kann Das Bild dazu hatte ich oben schon angehängt: https://www.mikrocontroller.net/attachment/532229/Pegelwandler_2_.png
500mV statt 3,3V. Liegt das an der Eingangsbeschaltung sprich Widerstand + Kondensator oder ist der IO Pin des STM32 jetzt wirklich so stark belastet das die Spannung so stark einbricht? Was auf dauer den IO des STM zerstören könnte? Mfg
-
Thread
Suche günstiges "Lernpaket" für Einsteiger
Ich empfehle: http://www.mikrocontroller.net/articles/AVR-Tutorial:_Equipment#Selbstbau Dazu den zugegeben etwas teuren aber dafür originalen AVRISP mkII von Atmel. Ich selbst bin Anfänger und habe mit Fertigboards nur Probleme gehabt. Mit
Starterkits. Das Pollin Board ist überflüssig zumal zumindest die Taster blöd verschaltet sind, aber das NetIO Board ist nett da man den ENC nicht ins Steckbrett bekommt und die Funkmodule machen Spass.Die ARM-Prozessoren sind grösseres Zeug. Braucht man selten.
-
Thread
Taster über RS232 abfragen
Pollin-Boards, die gibt es auch fertig aufgebaut: * [[Pollin ATMEL Evaluations-Board]] * [[Pollin Funk-AVR-Evaluationsboard]] * [[AVR Net-IO Bausatz von Pollin]]
verständlich sind. Ich bin auch noch Schüler und bin da gut durchgestiegen. http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Eing.C3.A4nge_.28Wie_kommen_Signale_in_den_.C2.B5C.29 http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Warteschleifen_.28delay.h.29 Gruß Jannis
-
Thread
Hilfe zu AVR-Assembler-Befehl
Hi Du kannst keine IO-Register direkt kopieren. Das geht nur über ein Register (r16-r31). in r16,io1 out oi2,r16 MfG Spess
> Du kannst keine IO-Register direkt kopieren. Das geht nur über ein > Register (r16-r31). > in r16,io1 > out oi2,r16 Nur zur Vollständigkeit: Das geht auch mit den unteren Registern r0-r16. Denn es finden dabei
-
Thread
Atmega programmieren mit AVR Studio
Guck Dir mal http://www.mikrocontroller.net/articles/AVR-Tutorial:_IO-Grundlagen An, da ist doch ein konkretes Beispiel Und wenn Du Dir die einzelnen Links in http://www.mikrocontroller.net/articles/AVR-Tutorial Durchließt, wirst
Schau mal hier das Tutorial an: http://www.avr-asm-tutorial.net/avr_de/index.html Sollte für einen Vortrag genug Material enthalten. AVR
-
Thread
USART RS485 Daten empfangen über ISR
Microchip MPLAB X IDE 5.45 Hier die Initialisierung der UART Schnittstelle: [code] #ifndef __AVR_ATtiny3217__ #define __AVR_ATtiny3217__ #endif #define F_CPU 3333333UL #include <avr/io.h> #include <avr/interrupt.h> #define USART0_BAUD_RATE(BAUD_RATE) ((float)(F_CPU * 64 / (16 *
noch nicht hin, ich komme einfach nicht weiter :( [code] #define F_CPU 3333333UL #include <avr/io.h> #include <util/delay.h> #define USART0_BAUD_RATE(BAUD_RATE) ((float)(F_CPU * 64 / (16 * (float)BAUD_RATE)) + 0.5) void uart_init() { USART0.BAUD = (uint16_t)USART0_BAUD_RATE(9600)
-
Thread
Steuerung über Lan & WLan
http://www.mikrocontroller.net/topic/109988 www.mikrocontroller.net/articles/AVR_Net-IO_Bausatz_von_Pollin
ich_eben schrieb: > http://www.mikrocontroller.net/topic/109988 > www.mikrocontroller.net/articles/AVR_Net-IO_Bausatz_von_Pollin Das find ich sehr interessant, welche ip hat das ganze den dann? Wenn ich nun einen Sensor anklemme krieg ich das
-
Thread
Codeblähungen beim Rechnen mit globaler Variable
folgendem Code der Vergleich einkommentiert wird, gibt es zusätzliche globale Zugriffe [c]#include <avr/io.h> static inline uint8_t f (void) { uint8_t x; __asm __volatile__ ("; =%0,%=" : "=r" (x)); return x; } extern uint8_t X; void X_init (void) { X = 0; X += f();
Hier nochmal ein weiteres Beispiel [c]#include <avr/io.h> uint8_t Flags; int __attribute__((OS_main)) main(void) { int16_t value = GPIOR1; #if 0 static uint8_t A = 0; uint8_t tempA = A; if (value > 10) { if (tempA > 7) Flags
-
Thread
Porterweiterung
-usw... Jetzt bitte nicht hauen! *aua* ;) Nach aktuellem Stand würde ich das mit einem kl. AVR und ein paar Parallel-TTL-IC's realisieren. Der AVR soll dann die Daten per SPI entgegennehmen und dann einen 8Bit-Datenbus mit 3State-Latches und 3State-Buffers auf 8 Ports verteilen. Werden dann zwar
79 also ich muss sagen, das Bauteil gefällt mir. Es ist fast so einfach zu Programmieren wie der IO-Expander(PCF8574) von Philips. Zu meinem Projekt: Mein LCD (HD44780 kompatibel)hängt an dem IO-Expander und ich schreib mir gerade einen Treiber dafür, damit ich eben das LCD über den IO-Expander
-
Thread
Mit Servosignal & uC schalten
Hier ! http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Interruptgesteuerter_Programmablauf
So, auch mit Interrupt klappt es nicht. Interrupt reagiert auf steigende Flanke. [c] #include <avr/io.h> #include "util/delay.h" #include <avr/interrupt.h> int main() { DDRB = 0b11111111; //PORTB auf Ausgang schalten PORTB = 0b11111111; GICR = (1 << INT0); //INT0-Interrupt
-
Thread
Telnet Ulrich Radig
Hallo Forum, ich habe seid längerem das Pollin Net IO Mikrocontroller Board. Alles funktioniert tadellos. Nun wollte ich die Software von Ulrich Rahdig testen. Da gibt es bei mir ein paar Probleme vor allem wenn wes um Telnet geht wenn ich beim Pollin
================================ # Connecting to device / initializing: print 'Connecting to AVR NET-IO with telnet at IP %s on port %d' % (telnethost, telnetport) #Connect on telnet port netio = telnetlib.Telnet(telnethost, telnetport) def sg(netio, cmd): netio.write(cmd + '\n') return
-
Thread
welchen c Compiler?
https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Ben.C3.B6tigte_Werkzeuge Atmelstudio
Matthias x. schrieb im Beitrag #4193145: > https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Ben.C3.B6tigte_Werkzeuge > > Atmelstudio Danke Kurt
-
Thread
Inline Assembler übersetztung
= uiAddress & 0x00FF; // siehe #) EEDR = ucData; EECR |= (1<<EEMWE); // EEMWE == 2 lt. avr/iom8.h EECR |= (1<<EEWE); // EEWE == 1 while(EECR & (1<<EEWE)); } [/C] #) Das ist wahrscheinlich zuviel des Guten und EEAR = uiAddress; geht auch http://www.mikrocontroller.net/articles
Referenzcode angibt. Der Vollstänigkeit halber eine 1:1 Übersetzung in Inline-ASM für C [C] #include "avr/io.h" #define TEST void __attribute__ ((noinline)) EEPROM_write(unsigned int uiAddress, unsigned char data) { asm volatile ( "out %0+1,%B3" "\n" "out %0,%A3" "\n"
-
Thread
USART und Interrupt
Interrupt Routine angesprungen, obwohl der andere µC was schickt, ebenfalls mit 2400 Baud. [c] #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> void delay_ms(int delay) { int i; for (i=0;i<=delay;i++) { _delay_ms(1); } } void init_usart
dass ich eigentlich ganze Strings empfangen sollte, leider klappt es wieder nicht... [c] #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #define PUFFER_GROESSE 100 volatile char *schreibzeiger; volatile char *lesezeiger; volatile char puffer[PUFFER_GROESSE]; void delay_ms
-
Thread
Scönes/modernes Web UI für ESP32?
Moin, man mag es mögen oder nicht. Das Programm ist sicher gut zu verstehen und anzupassen. Für den Net-IO sieht eine meiner Seiten ähnlich aus. Ich würde klein anfangen mit Programmen, die ich überblicken kann. Gruß Carsten
man mag es mögen oder nicht. Das Programm ist sicher gut zu verstehen > und anzupassen. Für den Net-IO sieht eine meiner Seiten ähnlich aus. Ich > würde klein anfangen mit Programmen, die ich überblicken kann. > Gruß > Carsten Nimmt es mit beide nicht übel. Aber wie oben schon gesagt hat das
-
Thread
board gekauft aber was nun?
du brauchst einen isp-adapter: http://www.mikrocontroller.net/articles/AVR_In_System_Programmer
nur mist an.... :-P liegt es vielleicht an der usb-serial schnittstelle? /*gcc*/ #include <avr/io.h> #include <avr/delay.h> #define F_CPU 1000000 #define USART_BAUD_RATE 9600 #define USART_BAUD_SELECT (F_CPU/(USART_BAUD_RATE*16)-1) //------------------------------------
-
Thread
Platinen mit GPS - Empfänger bei ebay
den Wiggler kann man sehr einfach nachbauen: http://jtag-arm9.sourceforge.net/circuit.txt
Ich meine den hier: http://jtag-arm9.sourceforge.net/circuit.txt
-
Thread
Free running mode ADC
Abhängigkeit des ADC-Wertes leuchten sollen. Hier mein Code [c] #define F_CPU 7372800UL #include <avr/io.h> #include <avr/signature.h> #include <avr/interrupt.h> #include <avr/sleep.h> static uint16_t ADCresult; // beinhaltet den Inhalt des ADC Registers // Interrupt Handler ISR(ADC_vect
folgenden Code lande ich im Interrupt und das LED toggelt: [c] #define F_CPU 4000000UL #include <avr/io.h> #include <avr/signature.h> #include <avr/interrupt.h> #include <avr/sleep.h> #include <util/delay.h> //volatile uint16_t ADCresult; // beinhaltet den Inhalt des ADC Registers // Interrupt
-
Thread
Wo sucht man Microcontroller nach IO-Anzahl, Takt und Funktionen aus?
passenden Microcontroller? Die Suche bei den Händlern berücksichten nicht das Datenblatt. Z.B. bei AVR nur 10MHz bei 3,3V. Ich suche z.Z. einen mit: - externen 16,1xx MHz Takt - 3,3V - 11 IO frei - UART - SPI - ca. 8k Flash - für Hobbyanwender lötbar (also kein QFN mit 0,5mm) Eigentlich
nach den Parametern des TE filtern. Und wenn es zu Taktraten kommt, würde ich ganz schnell weg von AVR gehen. Bei STM32 machen schon die kleinsten zwischen 48 MHz (F0) und 64 MHz(G0) bei 3,3V. Die lachen über die 8 MHz Grenze der AVR. Und ich auch.
-
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
Welcher Controller für Unterrichtszwecke?
wenn man etwas in 'klein' - ohne Quarz mit geringer Stromaufnahme - oder etwas in 'groß' mit viel IO, externem Businterface, TFT-Controller usw. aufbauen will. Ein ausführliches Datenblatt gibt es nicht. Da sind schon die AVR-Datenblätter informativer. Wenn man nichts anderes kennt, mag das Pico-SDK
Das MSP430 Projekt: https://www.mikrocontroller.net/topic/550292#7677696
-
Thread
Pin Interrupt löst Reset aus
falsch ist, dann wird nur eine normale funktion angelgt und keine ISR. http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#ISR
Biblioteken #include <avr/io.h> #include <avr/interrupt.h> #include <stdbool.h> #include <stdio.h> #define F_CPU 16000000 // processor clock frequency #define TASTER ( 1
-
Thread
Einfachste USART ansteuerung funktioniert nicht.
#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010)) #error BAUDRATEN ERROR! #endif #include <avr/io.h> #include <stdlib.h> void uart_init(void) { UBRRH = UBRR_VAL >> 8; UBRRL = UBRR_VAL & 0xFF; UCSRB = (1<<RXEN)|(1<<TXEN); UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); }
V 2.0.1 an (bzw. programmiere den µC auch mit diesem (via ISP Schnittstellenadapter - mit AVRDude (AVR8 Burn o Mat v2) Den String sende ich mittels hTerm als auch mit einem von mir programmierten Tool (in VB.net - erfolgreich getestet mittels virtual Serial Port) an das Board (und ja, natürlich nutze
-
Thread
uart int ausgeben
[C] #define F_CPU 3686400 #include <avr/io.h> #include <stdlib.h> char buffer[5]; // 16-Bit => 4 Hexadezimalstellen + 1 Nullbyte void USART_Init() { UBRRH = 0; /* 9600 Baud */ UBRRL = 23; UCSRB = (1<<RXEN)|(1<<TXEN);
in String einer 4-steligen Hexadezimalzahl s = buffer; /* siehe: http://www.mikrocontroller.net/articles/FAQ#itoa.28.29 http://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html#g4f6b3dd51c1f8519d5b8fce1dbf7a665 */ itoa(x, s, 16); // String ausgeben while (*s)