-
Thread
PIC 32 schneller Basic Interpreter
Basic-Interpreter für MCUs geschrieben. Einige erinnern sich vielleicht: http://www.mikrocontroller.net/articles/AVR_BASIC Der Interpreter läuft auch auf einer 8-Bit-MCU wie z.B. einem ATmega168 oder ATmega328 ohne Probleme, allerdings keine Floating-Point-Variablen und ein paar weiteren Beschränkungen
Neue Version Micromite MkII: http://geoffg.net/Downloads/Micromite/Micromite_Firmware.zip
-
Thread
mikrocontroller, board, etc. für anfänger
Beitrag #2205240: > Ich bin für jede Frage dankbar! Auch für Links auf andere Beiträge! Für die AVR-Ecke siehe: http://www.mikrocontroller.net/articles/Absolute_Beginner AVR-Tutorial AVR-GCC-Tutorial :-)
nachdem ich so gegen assembler gewettert habe: Hab diese Seite gefunden (übers Forum) http://www.avr-roboter.de/controller/befehle/beschreibung/l.html#ldi mir scheint so, als ob alle avr das gleiche (größtenteils da register und io verschieden) assembler verstehen. Ist das richtig? Läuft der Code
-
Thread
Z80 Mikrocomputer Bastelei
mal den Z280. Ein sehr schönes Teil ist der eZ80L92 oder mit Flash der eZ80F91-93, kann sich jeder AVR hinter verstecken. Ist eine andere Liga. Bevor AVR-Freaks sich beleidigt fühlen, wir setzen AVR und eZ80 ein...
...Bevor AVR-Freaks sich beleidigt fühlen, wir setzen AVR und eZ80 ein...... mit dem z80 kannste heute kein mehr aus dem sessel reissen, weil es da keine platinen gibt zum testen bzw zum bestücken die den anfänger
-
Thread
Auswertung RS232-Befehle
Lesezeiger ist. Die Auswertung des Commando wird dann in der Switch Anweisung bearbeitet. [c] #include <avr/io.h> #include <avr/interrupt.h> //#include "uart.h" #define BUFLEN 20 #define COMMAND0 1 #define COMMAND1 2 #define COMMAND2 3 #define COMMAND3 4 volatile unsigned char rx_buffer
man koennte es so machen (ist ungetestet und ich hoffe es ist kein Fehler drin) [c] #include <avr/io.h> #include <avr/interrupt.h> //#include "uart.h" #define BUFLEN 20 #define COMMAND0 1 #define COMMAND1 2 #define COMMAND2 3 #define COMMAND3 4 #define READY 0 typedef unsigned
-
Thread
Ping mit Webserver von U. Radig ausführen. Aber wie?
Hallo Zusammen Ich nutze den von G. Menke angepassten Webserver von U. Radig auf meinem AVR NET IO: http://www.mikrocontroller.net/articles/AVR_Net-IO_Bausatz_von_Pollin#Webserver_von_G._Menke Das funktioniert soweit auch ganz gut. Nun möchte ich, dass der NET IO regelmäßig eine IP bei
Grunde genommen ist es eigentlich ganz einfach. Man muss einfach über ein Terminal via RS232 an den Net-IO den Textstring "ping 192.168.1.107" senden (gefolgt von einem \CR). Lässt sich die IP anpingen kommt im Terminal die Pong-Antwort. @kbuchegg: danke für deinen Hinweis, der hat mich darauf gebracht
-
Thread
erst programmieren, dann schalten
Verteilen läuft über einen Schiebevorgang. Das ist hier richtig gut erklärt: http://www.mikrocontroller.net/articles/AVR-Tutorial:_Schieberegister Wie Du das Ganze räumlich anordnest, hängt stark von den Gegebenheiten ab. Ich könnte mir vorstellen, dass Du mit 4 Strängen vom Arduino ausgehst und dann je
Programmzeilen erledigt. Dazu liesst man(n) sich das hier durch: http://www.mikrocontroller.net/articles/AVR-Tutorial:_Schieberegister http://www.mikrocontroller.net/articles/Porterweiterung_mit_SPI Versteht es und setzt es um. EINFACHER geht es nur noch mit ner Platine voll Jumpern die
-
Thread
uC GPIO Output und 12V
Beispiel erlaubt der ESP8266 bis zu 3,6 Volt auch während er selbst keine Versorgungsspannung hat. Die AVR erlauben es nicht.
https://www.mikrocontroller.net/articles/Basiswiderstand
-
Thread
Speicher erweitern AT-MEGA
die ausgabe von den guten alten Nintendo-gepiepse. jetzt will ich nur das ganze NES-system auf nen AVR portieren und die ROMS dann per SD-Karte laden. Natürlich werde ich für dieses projekt nicht nur einen AVR sondern mehrere verwenden. Für den AVR der den CPU darstellen soll will ich eben jetzt die
Aufbau von Parallelrechnern konstruiert. > Bischen was kann man mit synchroner UART zaubern, aber ein AVR kann in > diesem Tempo entweder reden oder arbeiten, nicht beides. Nein, ich meinte eigentlich dass ich eine kommunikation zwischen 2 AVRs über die IO-PINS herstellen möchte. Eigentlich wollte ich
-
Thread
Anfänger in C und welcher PIC (evtl. uno32) ist geeignet ?
zu PICs gesehen, die nicht gelöst werden konnte, auch wenn hier 10 mal mehr AVR Leute unterwegs seien sollten. Axel Schwenke schrieb im Beitrag #3922524: > Das ist sicher nicht verkehrt. Auf jeden Fall wirst du zu AVR hier mehr > Hilfe bekommen als zu PIC Wie gesagt würde
eigenen Bords. Manche Bords sind so etwas von einer Eier legenden Vollmilchsau dass man kaum noch IO für externe Anschlüsse übrig hat. Da war der STK500 für AVR besser im Konzept. Naja, ich will nicht zu weit vom Thema abschweifen... Preislich ist CCS günstiger als die MCHP Tools. Ohne Optimierungen
-
Thread
Touchscreen Treiber für Embedded Linux
. Ist aber auch Geschmackssache... google mal nach denen, vielleicht hilft das ein wenig drivers/net/pci-skeleton.c drivers/net/isa-skeleton.c drivers/video/skeletonfb.c drivers/pci/hotplug/pcihp_skeleton.c drivers/usb/usb-skeleton.c
>Das verbreitest du jetzt schon geraume Zeit hier. >Aber weder auf der Atmel-Seite noch auf AVR-freaks kann man bis heute >etwas davon lesen. (Außer deinen Kommentar auf AVR-freaks). >Dagegen sieht man, dass immer mehr Firmen dafür Entwicklungsboards >anbieten. Jeder kann sich von mir aus
-
Thread
Plattformübergreifend Programmieren - welche Sprache?
Da kommt eigentlich nur C# in Frage. Damit kannst du - für Windows entwickeln (Visual Studio, .NET oder .NET Core). - für Linux/Pi entwickeln (Mono Develop oder Xamarin Studio, Mono oder .NET Core). - für Android entwickeln (Visual Studio oder Xmarain). - für Mac entwickeln (Mono Develop oder
Community - Visual Studio Code - MonoDevelop - Xamarin Studio Frameworks: - .NET (Windows) - .NET Core (Alle Platformen) - Mono (Mac, Linux, ...) - Xamarin (Mobile Platformen: Android, iOS usw.)
-
Thread
ATMEGA32, 16PU, RS232, Testprogramm
Quarzfrequenz eingetragen werden. [c] #define F_CPU 14745460 // Quarz 14.74546 MHz #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #include <string.h> #include <stdbool.h> void uart0_init(int BaudRate) { int ubrr0 = (F_CPU / 16 / BaudRate - 1); // Baudrate
Programm jetzt aus, nachdem ich es für ATMEGA32 abgeändert habe. [c] #define F_CPU 8000000 #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #include <string.h> #include <stdbool.h> unsigned char leds = 0x04; void uart0_init(int BaudRate) { int ubrr0 = (F_CPU / 16 / BaudRate
-
Thread
Spielgerät gesucht
dir empfehlen, weil es dazu hunderte Tutorials gibt (hier:http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial) Um ein bischen rum zu probieren ist das sehr einfach und günstig (MK2 ca.25€; Atmega8 ca.3€) Wenn du allerdings keine Lust hast, mit all den Komponenten rum zu spielen
Stimmt^^quasi von jedem :) Ich persönlich nutze dafür das AVR Studio. man merkt, ich bin AVR Fan ;)
-
Thread
Frequenzberechnung bei PWM
ich dann auf meinen Piezo-Piepser loslasse. Folgedes Programm hab ich dazu geschrieben: #include <avr/io.h> #include <avr/interrupt.h> #include <stdint.h> void port_init(void) { PORTD = 0xFF; DDRD = 0xFF; } void timer1_init(void) { TCCR1A = 0x00; //Timer stoppen TCCR1B = 0x00;
zu sein. Hab mich mal ein bisschen eingelesen und folgendes Programm geschrieben: [c] #include <avr/io.h> #include <avr/interrupt.h> #include <stdint.h> void Init_Timer_2(void) { //440,1408Hz TCCR2 = (1 << WGM21)|(1 << CS22)|(1 << COM20); //CTC-Modus, Teiler auf 64, Toggel des Pins D7
-
Thread
Compiler-Fehler bei ISR
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Programmieren_mit_Interrupts am besten das mal lesen. SIGNAL ist scheinbar nicht mehr ganz richtig, das wurde in neueren avrlibc-Versionen durch ISR ersetzt. mfg, Stefan
. defines nicht, könnte genau diese Felhermeldung provozieren. (sollte dann aber eine Warnung von avr/io.h generiert werden) /Ernst
-
Thread
Arduino oder
vielleicht was falsches angewöhne" :P Schaut doch einfach mal bei https://www.mikrocontroller.net/articles/AVR-GCC https://www.mikrocontroller.net/articles/STM32#Tutorials_f.C3.BCr_diverse_Tool-Kombinationen oder google vorbei. Das ist alles kein "muss", sondern ein "kann" und ist nur nen klick
Also eher ein AVR
-
Thread
GCC : NAMEN statt Pinnummern?
': DDRD = direction; break; } }[/c] hal.h: [c]#include <inttypes.h> #include <avr/io.h> #include "lcd.h" void initPort(uint8_t port, uint8_t direction); void setPort(uint8_t port, uint8_t value);[/c] Die hal.h macht man dann der Anwendung bekannt. Dinge, die die Anwendung
Anmerkung; Ports als Funktionsparameter funktionieren so nicht; das ist ausführlich abgehandelt im "avr-libc Reference Manual" (Abschnitt "How do I pass an IO port as a parameter to a function"), die u.a. im WinAVR enthalten ist.
-
Thread
Daft Punk Tisch
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#IO-Register_als_Parameter_und_Variablen Hier steht eigentlich schon alles genau beschrieben. Mit Hexadezimalzahlen musst du nicht unbedingt arbeiten. Es ist nur eine abkürzende
Pin an 12V > 1 Pin an GND > 1 Pin an VCC des µC > > so richtig? http://www.mikrocontroller.net/articles/AVR-Tutorial:_Equipment#Stromversorgung
-
Thread
Suche einen µC / Serie
klassischen 8015 brauchen 12 Takte pro Instruktion. Das macht bei 40MHz ca so so viel Leistung wie ein AVR bei 8MHz. Viel Spaß.
vom Z80 gibt es auch Varianten mit eingebauten IO und Timer, sozusagen Z80-µC ... TMPZ84C015 und Z84C15
-
Thread
Strom von Fahrraddynamo am PC auslesen
für Möglichkeiten zru Verfügung stehen? Könnte ich das hier verwenden? http://www.mikrocontroller.net/articles/AVR_Net-IO_Bausatz_von_Pollin ? Da ein Fahrraddynamo anscheined 6V Spannung hat, bräuchte ich für das Teil oben auch einen Spannungswandler. Könnt ihr da was empfehlen? Und wie gesagt muss
Möglichkeiten zru Verfügung stehen? > Könnte ich das hier verwenden? > http://www.mikrocontroller.net/articles/AVR_Net-IO_Bausatz_von_Pollin ? Sollte schon damit gehen. Du musst lediglich noch die Dynamospannung digitalisieren (also in MC gerechte Pegel umwandeln) und dem AVR beibringen, das er diese
-
Thread
ADC Wandlung mit Interrupt geht nicht
Ausgabe wird nicht mehr erreicht. Kann mir bitte wer helfen? Danke! andi [c]#include <avr/io.h> #include <avr/interrupt.h> #include "lcd.h" char buffer[7]; int adc_value; void ISR_ADC(void) { while (ADCSRA & (1<<ADSC)) { } adc_value= ADCL; adc_value+= (ADCH<<
schrieb im Beitrag #2431769: > void ISR_ADC(void) Kreativ, aber falsch. http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#ISR
-
Thread
Quarz zu ungenau? Bugfix?
zu tief angesetzt. Am besten schaust du dir mal den Artikel hier an: http://www.mikrocontroller.net/articles/Quarze_und_AVR Du müsstest jeweils einen Kondensator mit ~54 pF verwenden, dann sollte der Quarz auch innerhalb seiner Spezifikation von +/- 80 ppm liegen.
Rückkopplung auf den Oszillator. Genau so macht man es sinnvollerweise. http://www.mikrocontroller.net/articles/AVR_-_Die_genaue_Sekunde_/_RTC#Echtzeituhr_mit_Uhrenquarz
-
Thread
ATMega644 UART
sollte. Hier der Code: #ifdef F_CPU #undef F_CPU #define F_CPU 16000000UL #endif #include <avr/io.h> #include <inttypes.h> #include <util/delay.h> // Diese Beispiel zeigt die Anwendung des ADC eines ATmega169 // unter Verwendung der internen Referenzspannung von nominell 1,1V. //
Fuses vom Controller, wo du die Taktquelle, Brownout usw einstellst. https://www.mikrocontroller.net/articles/AVR_Fuses Hast du an den was geändert ? Mit was programmierst du ? Was für einen ISP Programmer hast du ? Gruß JackFrost
-
Thread
Anfängerfrage:AVR mit ISP/HVSP unter Linux mit STK500 und Platfor.io programmieren
Da platform.io im Hintergrund auch nur auf avrdude zurückgreift, kann ich schonmal sagen, dass das STK500 damit nutzbar ist. Zumindest für ISP habe ich es getestet. Ansonsten nutze ich Eclipse mit dem AVR-Plugin
Auf der entsprechenden Seite sind leider die die Hälfte der Links tot. https://www.mikrocontroller.net/articles/AVR_HV-Programmer
-
Thread
epson rtc72421 zum arduino
SPI oder 1-Wire Anschluß. Der ATmega328 hat kein Interface für externes SRAM, man muß beliebige IO-Pins opfern.
und müssen mit > mindesten sieben I/O-Ports verbunden werden. Komisch, ich benutze immer nur 6 IO-Pins. Rücklesen braucht man ein LCD nicht. Es gehen aber auch 3 IO-Pins und ein 74HC164.
-
Thread
Fehler im Unterprogramm - Verständnisfrage (Taster entprellen)
" #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #include <stdint.h> #include <avr/eeprom.h> // Prototypen uint8_t Taster_einlesen(void); void Taster_entprellen(void); int main(void
(); if(Taster_Status == 1) IO_PORT ^= (1<<LED_Untergrenze); if(Taster_Status == 2) IO_PORT ^= (1<<LED_Obergrenze); if(Taster_Status == 3) IO_PORT |= (1<<LED_Untergrenze)| (1<<LED_Obergrenze); } [/c] IO.c [
-
Thread
DynDNS ENCWeb
Hallo, der AVR-Webserver ist ein Computer wie jeder andere in dieser Beziehung und muß in der Freigabeliste auch mit seiner MAC und IP angezeigt werden. Dem einen sinnvollen Namen geben (meiner heißt AVR...) und
Ich hab auf meinem die Version von NetIO und da weiß ich grad die MAC nicht, ich guck mal im Code ob ich die da find, und die trag ich dann einfach bei NAT ein oder wo? Da gibts Port Weiterleitung , Port Freigabe und Port Umleitung Wo trag
-
Thread
In Bewerbung Arduino Stand im Jahre 2022
Max schrieb im Beitrag #7100786: > Er meinte, > dass Sachen wie AVR und so veraltet wären. Ich hab noch keinen STM32 in irgendwelchen Steuerungen gesehen, dafür aber jede Menge PIC's und auch AVR. Wir haben Infineon in den Steuerungen (ältere Steuerungen).
sich nicht selbst > beschäftigen kann, dann ist das echt ein Problem. Deswegen hängst du im uc.net ab mit deinem best friend Senfy
-
Thread
ATtiny45 Ein- Ausgänge konfigurieren
O.k. ich wußte jetzt nicht das die Anzahl der IO Pins einen Einfluß auf die Software hat. Bislang bin ich einfach davon ausgegangen das die "großen" AVRs (14, 20, 28Pins) lediglich mehr IO-Pins und bei den megas auch mehr Peripherie bieten. Und
Anfänger damit klarkommen. Karsten hat dafür mal ne Anleitung geschrieben: http://www.mikrocontroller.net/articles/AVR_Bootloader_FastBoot_von_Peter_Dannegger Peter
-
Thread
6502 Prozessor wer kennt den noch?
Aus so einem Nostalgiegefühl heraus hatte ich mal einen 6510-Echtzeitemulator für den AVR geschrieben und in dem KIM-1-Thread hochgeladen: http://www.mikrocontroller.net/topic/193632#1952893 Vielleicht kann's ja in dem Zusammenhang hier mal jemand gebrauchen. Ist eigentlich eine lustige Sache da sich der AVR-IO verwenden lässt (bspw. USART) und man so eine Art 6510-µController hat. Mark
-
Thread
Power-down mit Taster
Schalter abfragt damit die LED leuchtet. Das müßte doch den Schalter abfragen ob 0 anliegt. #include <avr/io.h> #include <avr/interrupt.h> #include <avr/wdt.h> #include <stdint.h> #include <avr/sleep.h> int main(void) { DDRB |= (1 << PB1); PORTB |= (1 << PB1); DDRB |= (0 << PB2); PORTB
Kommentare in deinem Programm an, besonders wenn du "exotische" Sachen machst. [C] #include <avr/io.h> #include <avr/interrupt.h> #include <avr/wdt.h> #include <stdint.h> #include <avr/sleep.h> int main(void) { /* The ATtiny24/44/84 system clock can be divided by setting the
-
Thread
ATmega mit mehr Leistung?
Drama finde ich da ganz repräsentativ[1]. Auch wenn ich den STM32, wie ich oben ja schrieb, dem AVR aus vielen Gründen vorziehen würde, muss ich ja trotzdem nicht mit dessen Ressourcen arg verschwenderisch umgehen. [1] https://www.davidhaney.io/npm-left-pad-have-we-forgotten-how-to-program/
Version 4.19 von 2011. https://www.mikrocontroller.net/articles/Atmel_Studio#Direktlinks_Installer
-
Thread
Anfänger Will ATtiny2313 mit Display uber I2C verbinden
is implemented as a compact assembler software implementation of the I2C protocol which runs on any AVR (i2cmaster.S) and as a TWI hardware interface for all AVR with built-in TWI hardware (twimaster.c)...." Geht nicht - gibt's nicht. ciao gustav
Die LCD-Initialisierung im Tutorial hier funktioniert da nämlich nicht. https://www.mikrocontroller.net/articles/AVR-Tutorial:_LCD Man kann nämlich nicht ein oder mehrere Portbits direkt setzen in I2C, weil ja kein Port in dem Sinne vorhanden ist, sondern nur zwei Leitungen. Die Steuerbits müssen demzufolge
-
Thread
Atmega32 - 8-Bit-Timer
Blinkimpuls von ca. einer Sekunde sein) Hier mein Code: [c] // Timer Testprogramm #include <avr/io.h> #include <avr/interrupt.h> #include <stdint.h> volatile unsigned int Counter = 0; // Zähler für Timer uint16_t i = 0; // Zähler bei Bedarf verwendet ISR(SIG_OUTPUT_COMPARE0
> Nur den Overflow Interrupt wollte ich. Warum nimmst du dann nicht den Overflow Interrupt? AVR-GCC-Tutorial http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Die_Timer_und_Z%C3%A4hler_des_AVR#Overflow_Interrupt
-
Thread
Bei Tastendruck -> UART
versuchen?!? Ohne Pull-Ups wird dein PA7 nie mehr HIGH sehen. Siehe http://www.mikrocontroller.net/articles/AVR-Tutorial:_IO-Grundlagen#Pullup-Widerstand Und auch [[Bitmanipulation]] wäre lohnenswert für dich. MFG Falk
in der >If-Anweisung festhängt. Du solltest dich mal mit den Grundlagen vertraut machen. [[AVR-Tutorial: UART]] Und planloses Rumändern im Quellcode ist sinnlos. [c] #include <avr/io.h> void main (void) { DDRA = 0x00; //PORTA = Eingang DDRC = 0xFF;
-
Thread
Programmierung
klammheimlich mal ein wenig an und überlegst dir selbst eine Lösung. http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial Da steht alles was du brauchst.
Tutorial http://www.mikrocontroller.net/articles/AVR-Tutorial und http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial durch und versuche erstmal die Beispiele nachzuvollziehen, also auch selbst einzugeben, zu kompilieren und zu flashen
-
Thread
Bootloader für ATMega128
muss, probiere ich es mit dem MegaLoad GCC von Werner von dem Thread: http://www.mikrocontroller.net/forum/read-4-183976.htm Gerade weil dieser schon mit dem ATmega128 getestet wurde. Folgende Konfigurationen wurden im Makefile vorgenommen: MEGALOAD_NET = -DMEGALOAD_NET EEPROM = LOCKBIT
Das File ist in Ordnung. Eine Erklärung wäre, dass es nicht in den AVR passt. Sprich, das es für einen anderen AVR erzeugt wurde, als du verwendest. Übertrage das File doch einfach mal mit ISP, dann siehst du ja ob der AVR rennt wie Sau. Ferner kannst du natürlich
-
Thread
8048 Assembler für aktuelle Windows-Versionen
naken asm", der sehr klein, sehr schnell ist und einige andere MCU's dazu auch kann (wie bspw. MCS-51, AVR, STM8 etc.) https://www.mikekohn.net/micro/naken_asm.php
asm", der sehr klein, sehr schnell > ist und einige andere MCU's dazu auch kann (wie bspw. MCS-51, AVR, STM8 > etc.) > > https://www.mikekohn.net/micro/naken_asm.php Sieht interessant aus. Leider fehlen dem die TI-DSPs.
-
Thread
sleep oder NOP in asm
ASM-Neuling, wo ist denn das andere AVR-Tutorial wovon du soviel faselst?
http://www.avr-asm-tutorial.net/ ...
-
Thread
Umfrage zu installierten Hausbussen
Bustechnologie: Lan (AVR Net IO) kombiniert mit UDR (RS232) Buslänge: Lan(Wlan zur Zeit 5 Km) UDR max 1m Buskommunikation: dezentral, UDR hat vorrang 230V Verkabelung: Sterntopologie je Zimmer
Gerätedose) LED-Treiber (1 High-Power RGBW + 6*20mA RGB) NetIO-Boards mit 2 MCP2515 als Gateway PC mit Control-Server Anzahl Knoten am Bus: derzeit ~30, Endausbau ~70 (wenn ich endlich die LED-Decke eingebaut habe
-
Thread
Atmega8 über Arduino programmieren in Linux
bin Anfänger was Mikrocontroller angeht und versuche, über das Tutorial http://www.mikrocontroller.net/articles/AVR-Tutorial:_IO-Grundlagen zu lernen. Leider bekomme ich das kleine 1. Programm (2 LEDs leuchten lassen) nicht auf den Atmega8. Mit einem usbAsp habe ich es versucht, es funktioniert
etwas mit den Programmen leds.asm und leds+buttons.asm aus dem Tutorial https://www.mikrocontroller.net/articles/AVR-Tutorial:_IO-Grundlagen experimentiert - klappt einwandfrei :-)
-
Thread
LCD-Modul TC1602E-01 von Pollin wie anschließen an Pollin AVR
AVR-NET-IO-Board Best.Nr. 810 058 das habe ich, liegt ebenfals neben mir. Wannenstecker EXT soll woll LCD rankommen?
> 14 DB 7 > 15 A ?? > 16 K ?? Da steht doch die Pinbelegung vom Display. Und auf Seite 6 vom AVR-Net-IO steht die Belegung des ext.
-
Thread
simulavr: invalid io reg
Kennt hier jemand schon eine Lösung? Ich verwende folgende Makefile: http://www.mikrocontroller.net/attachment/57243/Makefile Habe auch schon simulavr-0.1.2.6 kompiliert und probiert. Der Sourcecode für das Programm, das ich testen will: [c] #include <avr/io.h> #include <avr/interrupt.h>
return 0; } [/c] simulavr shell Ausgabe [code] ... devsupp.c:354: MESSAGE: TODO: attach IO Reg 'GICR' at 0x005b devsupp.c:354: MESSAGE: TODO: attach IO Reg 'OCR0' at 0x005c devsupp.c:348: MESSAGE: attach: IO Reg 'SPL' at 0x005d: created devsupp.c:332: MESSAGE: attach: IO Reg 'SPH' at 0x005e
-
Thread
Eclipse mit AVR Plugin und Atmega328PB
von Eclipse funktioniert es eben nicht, z.B. wird innerhalb der io.h immer noch der __AVR_ATmega328P__ als definiert angezeigt anstatt __AVR_ATmega328PB__. Das kann natürlich nicht funktionieren weil sich einige Bezeichnungnen geändert haben bzw. neue dazugekommen
Dann gehts hier weiter: https://sourceforge.net/p/avr-eclipse/mailman/message/24654029/ Oliver
-
Thread
Fragen zur IR-Informationsübertragung
bestehenden IR-Codes, das ist deutlich einfacher und funktioniert. https://www.mikrocontroller.net/articles/IRMP > Welche Module sollte ich für Raspberry Pi > dazu nutzen? Vermutlich geht jedes beliebige IO-Pin. Kann sein, daß der UART Vorteile hat. > Könnt ihr mir diese Fragen zumindest
https://www.elektronik-keller.de/index.php/atmel-projekte/ir-nec https://www.sbprojects.net/knowledge/ir/nec.php
-
Thread
OSCCAL extrem?
. Das lief schon gefühlte 100.000x im uC net. Bemühe doch mal die Suchfunktion.
## Programm zur Bestimmung von OSCCAL ohne Frequenzgenerator ### #include <stdlib.h> #include <avr/io.h> #include "uart.h" int main(void) { uartSetup(9600); //UART auf 9600 Baud einstellen, keine Paritaet, ein Stoppbit char valueToSend[5]; for (uint8_t i=0x00; i<0x7f; i++) {
-
Thread
Funk-Heizungsregler-System MAX!
Auch ein interessanter Link: http://blog.hekkers.net/tag/elv-max/
Ah OK, dann werde ich wohl doch was eigenes mit RFM und AVR-Net I/O basteln müssen. Vielen Dank!
-
Thread
Senden von "Zahlen" über UART
habe jetzt folgenden Code: #include <inttypes.h> #include <avr/io.h> #include <util/delay.h> void enableTx(void) { while (!(UCSRA & (1<<UDRE))) /* warten bis Senden moeglich */ { } } /////////////////// Im Terminalprogramm wird
die UART auch bereit ist ein Zeichen entgegen zu nehmen (Das steht aber eigentlich auch alles im AVR-gcc Tutorial http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Senden_mit_dem_UART ) [C] int uart_putc(unsigned char c) { while (!(UCSRA & (1<<UDRE))) /* warten bis Senden moeglich
-
Thread
Sockel für sehr viele AVR's entwickeln
die Doppel- oder Mehrfachbelegung diverser AVR-Pins, speziell die Tinys. Ist es nur möglich mittels eines CPLD's die AVR Funktionen auf einen einheitlichen Sockel zu routen? Ziel soll es also sein einen Adapter zu entwickeln der aus einer
schreiben, der auf allen AVRs optimal läuft. Wenn Du nur eine Plattform suchst, die mit mehreren AVR-Typen umgehen kann, dann schau Dir das STK500 (und seine Aufsetzplatinen) an. Achja, die Hardwarefeatures sind so unterschiedlich, dass man auch nichtmal jeden kleinen AVR durch einen großen AVR