-
Thread
avr-gcc 6.3 für Windows
Hier ist ein avr-gcc-6.3.1 dabei, generiert unter Linux für MinGW32: https://sourceforge.net/projects/mobilechessboar/files/avr-gcc%20snapshots%20(Win32)/ Binutils von git master zu dieser Zeit und avr-libc entsprechend
War relativ schwierig, aber hier ist ein Beispiel: [c]#include <avr/io.h> void foo(char unused) { while (GPIOR0) GPIOR0 = 0; } char bar(void) { if (GPIOR0) return 0; foo(0); foo(0); return 1; } int main(void) { if (bar()) goto end;
-
Thread
Einkaufsliste für die Einrichtung eines Elektronik-Labors
lieber. Und hier sind auch noch einige Artikel mit wertvollen Tips: https://www.mikrocontroller.net/articles/Elektronik_Allgemein
gesehen. Aber für LAN solltest Du Dir mal die Crumb-X1 Module (http://www.chip45.com/products/crumbx1-net_avr_xmega_module_board_atmega128d3_embedded_internet_ethernet_webserver_usb.php) anschauen. Die funktionieren fast genau so, wie die ESP Module denn sie basieren ebenfalls auf einem IP Stack von Adam
-
Thread
IO-Pins als Bitfeld zusammenfügen und maskieren (AVR)
threads/59212-Ports-nach-Bitmaske-setzen) fand ich eine Lösung, die funktioniert: [c] #include <avr/io.h> #define ARRAY_LENGTH 9 //wieviele Pins sollen angesteuert werden //welche Ports werden für die Motoren verwendet volatile uint8_t * Port_Mask[ARRAY_LENGTH] = { &PORTC, &PORTC, &PORTC, &PORTC
auf int-Datentypen definiert sind. Bitfields sind dafür gedacht, Speicher zu sparen - nicht für IO. Kurzum, laß es einfach.
-
Thread
Unterschied RAM und Register?
diese Aussage einfach schlichtweg inkorrekt? Fast. Es gibt SFRs. https://www.mikrocontroller.net/articles/Speicher#Register Bei manchen Controllern liegen die SFRs so wie RAM im Adressraum, nennt sich dann memory mapped IO. >Ich meine, wenn Register im RAM-Bereich liegen, dann kann ich mir
Aussage einfach schlichtweg inkorrekt? > > Fast. Es gibt SFRs. > > https://www.mikrocontroller.net/articles/Speicher#Register > > Bei manchen Controllern liegen die SFRs so wie RAM im Adressraum, nennt > sich dann memory mapped IO. Meinen allerherzlichsten Dank! :-) Man muss allerdings
-
Thread
Schieberegister - Anschluss über PCB Verbinder?
messen, wie schnell das SR mit Daten beschickt wird. Im Code mache ich es so: [c] #include <avr/io.h> #define SR_PORT PORTB #define SR_DDR DDRB #define SR_DS PB0 #define SR_SHIFT_CLK PB1 #define SR_STORE_CLK PB2 #define SRHigh() (SR_PORT |= (1<<SR_DS)) #define SRLow
Überschwinger als 2 Takte erkannt werden. Zum Thema Serienterminierun siehe den https://www.mikrocontroller.net/topic/110550 und besonders auch das letzte Drittel des https://www.mikrocontroller.net/topic/402587
-
Thread
C Objekte als Struct effizient kapseln
ganz schön wie man mit C++ kleine uC's effizient programmieren kann. Zwar ist das Zielsystem kein AVR oder ARM, aber klein -- nach heutigen Maßstaben -- ist es schon :-) https://www.youtube.com/watch?v=zBkNBP00wJE
Zu dem Thema hatte ich schon mal ein paar Links zusammengestellt: https://www.mikrocontroller.net/topic/412052 Da ist der o.g. Beitrag auch drin ...
-
Thread
Wie kommt es, dass es Arm SoCs für unter 10 € gibt, aber keine x86 SoCs zum gleichen Preis?
auf einem Runtime Environment. In Android eine androidisierte JVM und in Windows 10 Mobile eine .Net Umgebung. Die Apps Sache hat nur was mit den verwendeten Bibliotheken zu tun, die von der Usability her Smartphone tauglich sind. Das OS selbst und wichtige Systemkomponenten, wie eben die .Net
damals nicht gab. Die 8086 bis 80386 Prozessoren (vielleicht sogar die 486er) war kaum komplexer als AVR's. Sie hatten nur mehr Pins und breitere Register. Und natürlich war der Befehlssatz besser, aber nicht komplizierter - eher einfacher.
-
Thread
ATTiny85 an einer einzelnen AAA Batterie 1 Jahr mindestens
Stromverbrauch bei aus 20nA ist mit der Transistortesterschaltung möglich https://www.mikrocontroller.net/wikifiles/f/f0/Schaltplan_transistortester.png das muss dann den booster starten und der den AVR aber wie? mit einer RTC DS3231 die vom AVR die Alarmzeit gestellt bekommt und am INT Ausgang
wie AVR, beide sind einigermaßen parallel entwickelt worden. Auch im Betriebsstromverbrauch sind die Unterschiede eher gering. MSP430 hat ein paar Vorteile gegenüber einem AVR, der mit einem Quarz getaktet
-
Thread
Auslesen eines Feuchtigkeitssensors (catnip moisture sensor)
github.com/Miceuz/i2c-moisture-sensor (Beispiel 3) [3] http://homepage.hispeed.ch/peterfleury/doxygen/avr-gcc-libraries/group__pfleury__ic2master.html [c] #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #include <string.h> // i2c #include <i2cmaster.h> #define moisture
// set device address and Aber das Problem hatten wir gerade: https://www.mikrocontroller.net/topic/424131
-
Thread
Stromverbrauchs-Vergleichstabellen von Atmel Mikrocontroller
Verschlagwortung dazu kommt. Die ist eher unheinheitlich. Ich war neugierig und habe mal nach "uC Atmel AVR Power Current consumption comparison table" gesucht bzw. "AVR Strom verbrauch vergleich" Alles, was ich fand war etwa das http://rn-wissen.de/wiki/index.php?title=Stromspar-Modi%28AVR%29 und das https://www.mikrocontroller.net/articles/Leistungsaufnahme_von_Mikrocontrollern Diese Tabellen umfassen nur einige wenige Typen. Ohnehin wird man für eine Arbeit solche Tabellen überprüfen, also mit den Datenblättern vergleichen
-
Thread
Anfängerfrage zur Ansteuerung asynchroner RAMs (C64)
Du kannst dir ja mal das AVR-CP/M-Projekt anschauen. Das hat zwar nichts mit FPGAs zu tun, aber da wird mit einem AVR in Software ein DRAM (256k x 4) angesteuert. Der AVR simuliert dann noch einen Z80 dafür. ;-) Der Monsterthread (knapp 1700 Posts) ist hier: https://www.mikrocontroller.net/topic/177481
-
Thread
AVR Anfang / Flash geht aber Programm scheint nicht zu laufen
ohne Mega8 ausprobiert, sind alle da. Mein erstes Programm ist ganz einfach /* */ #include <avr/io.h> void main () { uint8_t cnt = 0; DDRC = 0xFF; DDRD = 7; while (1) { cnt++; PORTC = cnt; } } Bei den Fuses
Hier ist eine Beschreibung wie man avrdude einbinden kann: https://www.mikrocontroller.net/articles/Code::Blocks#Erstellung_eines_AVR-Projekts
-
Thread
Assembler Grundlagen
Zum Nachschlagen immer praktisch - der AVR Befehlssatz: http://www.atmel.com/images/Atmel-0856-AVR-Instruction-Set-Manual.pdf
Zum Nachschlagen noch praktischer - der AVR Assembler Tutorial: https://www.mikrocontroller.net/articles/AVR-Tutorial und hier direkt zum Stack: https://www.mikrocontroller.net/articles/AVR-Tutorial:_Stack
-
Thread
AVR versus ARM Gesperrt
hast den STMCube oder die Standard Peripheral Libray benutzt? Und gleichzeitig programmierst du den AVR mit den Standard IO Funktionen per Hand. Und dann mit einem einfachen Hallo Welt? Der Startup Code eines ARMs ist rießig im Vergleich zum AVR... Bei Hallo Welt zählt der Startup Code schon etwas mehr
Hilfestellungen du zurückgreifen konntest. Wenn ich auf dieser Seite mal den Artikel https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial mit dem Artikel https://www.mikrocontroller.net/articles/STM32_f%C3%BCr_Einsteiger vergleiche, dann würde ich wohl auch eher mit einem AVR anfangen wollen. Auf der einen Seite
-
Thread
Orange Pi 2G-IoT: Einplatinencomputer mit integriertem Mobilfunkmodem
orangepi.jpg) Nur etwa einen Monat nach der Vorstellung des [Raspberry Pi Zero W](http://www.mikrocontroller.net/topic/420368#new) zeigt die Konkurrenz, dass man ebenfalls nicht schläft. Der [Orange Pi 2G-IoT](https://de.aliexpress.com/store/product/Orange-Pi-2G-IOT-ARM-Cortex-A5-32bit-Support-ubuntu-linux-and-android-mini-PC-Beyond
durch drahtlose Konnektivität auf. Gegenüber dem [Raspberry Pi Zero W](http://www.mikrocontroller.net/topic/420368#new) bietet der [Orange Pi 2G-IoT](https://de.aliexpress.com/store/product/Orange-Pi-2G-IOT-ARM-Cortex-A5-32bit-Support-ubuntu-linux-and-android-mini-PC-Beyond/1553371_32802458477.html)
-
Thread
AVR über ethernet ansprechen
Hallo, gibt es eine AVR, mit der ich über das Internet ansprechen kann? Oder einen anderen Chip den ich dann ans AVR binde und über das Internet anspreche? AVR-IO ist nicht so mein ding. vg Frank
Frank N. schrieb im Beitrag #4953478: > AVR-IO ist nicht so mein ding Vermutlich meinst du AVR-NetIO. Was missfällt dir? Was fehlt? Arduino mit Ethernet Shield ist für Anfänger gut geeignet.
-
Thread
ARM-Cortex als Anfänger?
Anfangen. Recht orthogonale Prozessorstruktur mit 16 16Bit Registern, deutlich leistungsfähiger als ein AVR (die Teile gibts bis zu 70 MHz und bis zu 512k Flash), gibts auch in DIL, Pincount von 14 bis 144, nur zwei IO-Pins zum Programmieren und Debuggen erforderlich, man kann sich nicht wie bei AVR versehentlich
trotzdem eine proprietäre Architektur ist. Die gibt es nur von >> Microchip. > > Das ist bei xAVR (xMega, jetzt Legacy, siehe Microchip-Website), AVR32 > (wohl bald auch Legacy) und AVR (?) nicht anders. Das ja. Aber die Toolchain ist Open Source. Und konkret beim avr-gcc gab es Verbesserungen
-
Thread
STM32 Arduino
hatte da mal was: https://www.mikrocontroller.net/topic/388495#4448812
uralten Thread dazu, der vor etwa einem Jahr wieder etwas aufgewärmt wurde: https://www.mikrocontroller.net/topic/179189
-
Thread
Leiterplatte herstellen lassen
-am Backlight des Displays könnte man ein Poti vorsehen Schau Mal: https://www.mikrocontroller.net/articles/AVR-Tutorial:_IO-Grundlagen
-
Thread
STK500 und AVR Studio 5
Board über einen RS-232 - USB Converter an den PC angeschlossen, Spannungsversorgung angeschlossen und AVR Studio 6 gestartet. Neues Projekt erstellt und den AtMega 8 ausgewählt. Nun ein Programm reingeschrieben: #include <avr/io.h> int main(void) { DDRC = 0x01; for(;;) {
default installation location is C:\Program Files\Atmel\AVR Tools\AvrProg\AvrProg.exe or C:\Program Files (x86)\Atmel\AVR Tools\AvrProg\AvrProg.exe on 64-bit OS.
-
Thread
Welche ICs aus der 74HC Reihe sollte man als Grundaustattung auf jeden Fall Zuhause haben?
Privatperson geht das ja leider nicht. Farnell: https://hbe-shop.de/ Mouser: https://www.mikrocontroller.net/topic/415670
geht das ja leider nicht. > > Farnell: https://hbe-shop.de/ > Mouser: https://www.mikrocontroller.net/topic/415670 Danke, werde ich mir mal anschauen.
-
Thread
MiniNetzwerk Steuerung
> > Als Netzwerkcontroller sollte ENC28J60 verbaut sein. Du hast dir schon mal bei Pollin den AVR-NET-IO angesehen?
etc.) Schon fertig montiert ist - quasi ein Ethernet Basic Board ohne schnikschnak.... ;-) Das AVR-NET-IO ist interessant. Gerne hätte ich dies genommen ABER... ... Es gibtein paar Dinge diemir nicht gefallen: - Netzteil auf Platine - Sub Steckverbindung und Schraubklemmen statt Pins bzw. Steckerleiste
-
Thread
I2C Bus funktioniert manchmal
Programm zu erstellen, geht leider nicht, hier der Code: [c] #define F_CPU 16000000 #include <avr/io.h> #include <stdbool.h> #include <stdint.h> #include <avr/pgmspace.h> #include <util/delay.h> #include "i2cmaster.h" int main(void) { i2c_init(); while (1) { i2c_start
Hallo, das gab es hier schon mal: https://www.mikrocontroller.net/topic/409138 MfG
-
Thread
3,5" TFT an PC anschließen
das LCD ansteuern? Grafikkarte mit VGA/DVI-Anschluss wird direkt nicht gehen? Also einen Arm oder AVR als Controller und Signale per USB oder Com an den Controller? Gibts dafür brauchbaren Code oder muss ich das selbst zusammenstoppeln? Müsste es eigentlich ja aus dem Raspberry-Pi-Bereich geben.
ist in etwa das, was ich suche. Leider vom Aufbau her nicht ganz einfach. usb-to-usart-Adapter an AVR/ARM. Wie das auf mcu-Seite funktioniert ist mir relativ klar. Jetzt bräuchte ich code für die Auswertung per vb.net. Marcus W. schrieb im Beitrag #4938708: > Oder einfach per SPI. Wenn der
-
Thread
GPS Daten in Tonspur speichern!?
http://unsigned.io/micromodem/
http://elektronik-labor.de/AVR/Soundprog2.html WTF?
-
Thread
LED blitzen auf, Transistor an Attiny2313
schalten. Eigentlich solltest du hier alles finden was du brauchst. https://www.mikrocontroller.net/articles/AVR-Tutorial https://www.mikrocontroller.net/articles/AVR-Tutorial:_IO-Grundlagen
die Schaltung unempfindlicher gegen äußere Einflüsse wird. http://www.atmel.com/images/atmel-2521-avr-hardware-design-considerations_applicationnote_avr042.pdf Ließ dir das durch das erklärt einiges.
-
Thread
100ohm wiederstand für led beim atmega16
Schaltungen ohne diese, sonst hilft dir keiner und alle ziehen darüber her! https://www.mikrocontroller.net/articles/Kondensator Hier gibts mal was für den AVR: https://www.mikrocontroller.net/articles/Absolute_Beginner-AVR_Steckbrettprojekte Hier über Transistor: https://www.mikrocontroller.net/articles/Transistor Hier über LEDs: https://www.mikrocontroller.net/articles/LED Dort findet man ein Schaltbild wo ein AVR über ein Transistor eine LED schaltet: https://www.mikrocontroller.net/articles/AVR-Tutorial:_IO-Grundlagen#Hardware
-
Thread
KiCAD ist im Kommen
wundern, wenn er mit diesen Eigenschaften auf die Nase fällt. [1] https://www.mikrocontroller.net/topic/317654#3441515 [2] https://www.mikrocontroller.net/topic/326344#3561091
F.Cu) (net 1) (tstamp 58CAFD51)) Dann wird eingelesen (NET 0 ) angezeigt beim unveränderten Abspeichern steht im File GND_name_none.kicad_pcb fehlerhaft net 0 (segment (start 59.055 29.845) (
-
Thread
AVR Attiny10 External Interrupt in C
-------------------------------------------------- * */ #define F_CPU 1000000UL #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> ISR(INT0_vect) { //OCR0B = 1000; PINB = 0x02; } int main(void) { int i; // CPU-Clock settings:
-------------------------------------------------- * */ #define F_CPU 1000000UL #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> ISR(INT0_vect) { //OCR0B = 1000; PORTB &= (1 << 1); _delay_ms(500); } int main(void) { int i; //
-
Thread
ATMega1284P + EA-DOGL128 mit Library von Jan M.
Leider stosse ich mit meinem geringen Wissen an der Library von Jan M.(https://www.mikrocontroller.net/topic/144500) hier aus dem Forum an meine Grenzen. Den ATMega1284P habe ich wie folgt mit dem LC-Display verbunden: MOSI (PB5) -> SI SCK (PB7) -> SCL A0 (PB0) -> A0 PB1 -> RST SS (PB4) ->
Die main.c sieht wie folgt aus: #define F_CPU 8000000UL #include <util/delay.h> #include <avr/io.h> #include "dogm-graphic.h" int main(void) { //lcd_init(); lcd_init(); while (1) { lcd_put_string_P(FONT_FIXED_8, NORMAL, PSTR("Hallo
-
Thread
Attiny45/85 38 KHz Signal erzeugen
Wo liegt der Fehler bzw. was fehlt? Folgender Code bisher: #define F_CPU 8000000UL #include <avr/io.h> #include <avr/interrupt.h> int main (void) { DDRB |= (1<<PB0); TCNT0 = 0; TCCR0A=0; TCCR0B=0; TCCR0A |= (1 << WGM01) | (1 << COM0A0); TCCR0B |= (1 << CS00); OCR0A
<avr/io.h> #include <avr/interrupt.h> #define F_CPU 8000000UL #include <util/delay.h> volatile int timerCount = 0; int main(void) { DDRB |= (1 << PB1); PORTB |= (1 << PB1); DDRB &=
-
Thread
Sleep Mode + Pin Change Interrupt
[c] #define F_CPU 8e6/8 #include <avr/io.h> #include <avr/interrupt.h> #include <avr/sleep.h> #include "debounce_2.h" // Peter Dannegger Routine typedef struct { // Flag Register unsigned sleep:1; } flagbytes; volatile
https://www.mikrocontroller.net/topic/223079#2259281
-
Thread
ESP8266 - und nun?
und Seriell. Ich fand es auch recht unsinnig den ESP mit AT-Befehlen zu steuern - besonders vom AVR aus - wenn doch der ESP-µC viel leistungsfähiger ist. Ich bin dann bei den Wemos oder NodeMCU Boards gelandet.
Mittels async.WS https://www.mikrocontroller.net/topic/398806#4598054 von me-no-dev kann man SPIFFS auch über den Browser händeln, ohne die "data" neu progr. zu müssen..
-
Thread
ATTiny24 und Bascom
Danke MWS! Unter >>> https://www.mikrocontroller.net/articles/AVR-Tutorial:_IO-Grundlagen#Zusammenfassung_der_Portregister kann man es nachlesen. Eine Interessante Funktion! Viele Grüße HJH
Blitzmerker, aber das solltest Du jetzt schon > verstehen können ;D Hier: https://www.mikrocontroller.net/topic/403554#4673607 und hier: https://www.mikrocontroller.net/topic/403554#4673624 Oder einen von der älteren Beiträgen versuchen: https://www.mikrocontroller.net/topic/344405#3804810 Lesen
-
Thread
AtMega8 Anzahl I/O
im Beitrag #4926195: > Eine 5-Stellige 7-Segmentanzeige 74HC595 https://www.mikrocontroller.net/topic/416844 (Spannend, das Du da schon dabei warst ...)
Ich habe direkt hier im Forum ein Tutorial (https://www.mikrocontroller.net/articles/AVR-Tutorial:_Schieberegister) darüber gefunden. Dort steht geschrieben, dass der SER Eingang mit den 8 Bits nacheinander angespeist werden müssen und mit einem 0-1-0 Puls nach jedem Bit an
-
Thread
Erfahrungen mit Arduino
. Diese Platine braucht als Resourcen nur einen I2C Port, einen ext, Interrupt und Spannung um die IO-Pins zu erhalten. Damit kann man schon mal viel machen. Für Peripherie Erweiterungen wähle ich grundsätzlich nur I2C oder SPI um die übrigen IO Pins für die alternativen Funktionen frei zur Verfügung
Teil auch auf andere uC wie PIC, 8051 geportet. Als Entwicklungsumgebung arbeite ich meist mit AVR Studio, CodeVision AVR und natürlich geht es auch mit der Arduino IDE;-) Damit hat man ziemlich viel Spielraum. Grüsse, Gerhard
-
Thread
MIDI - BaudProblem - ATmega644p
_0 * 16UL))) -1) #define BAUD_PRESCALER_1 (((F_CPU / (USART_BAUDRATE_1 * 16UL))) -1) #include <avr/io.h> #include <util/delay.h> #include <avr/interrupt.h> void uart0_init(void); void uart1_init(void); int main(void) { _delay_ms(1000); uart0_init(); uart1_init(); sei();
solltest Du verstanden haben, wie ein UART überhaupt funktioniert. https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Wenn Du nicht mal prüfst, ob Du senden darfst, kommt da nur Müll raus.
-
Thread
Atmega328P ADC Problem
************************************************************************************* #include <avr/io.h> #include "lcd-routines.h" #include <util/delay.h> #define F_CPU 8000000 //8.000.000 uint16_t readADC(uint8_t channel) { uint8_t i; uint16_t result = 0; // Den ADC aktivieren
dezimaler Schreibweise { // ... umwandeln siehe FAQ Artikel bei http://www.mikrocontroller.net/Articles/FAQ // WinAVR hat eine itoa()-Funktion, das erfordert obiges #include <stdlib.h> char Buffer[20]; // in diesem {} lokal itoa( variable, Buffer, 10 ); // ... ausgeben
-
Thread
ATmega328p - Input Capture - Flanke wird übersehen
aufgerufen. Ich kann mir dieses Verhalten wirklich nicht erklären, weiß jemand Rat? [c] #include <avr/io.h> #include <avr/interrupt.h> #include <avr/pgmspace.h> //Ueberlaufzaehler volatile uint8_t ovf_t1 = 0; //Initialize timer void InitTimer1(void) { //cnt init TCNT1=0; //
{ PORTB ^= (1 << PB5); } //Overflow ISR ISR(TIMER1_OVF_vect) { ovf_t1++; } void io_init() { DDRB |= (1 << PB5); } int main(void) { io_init(); //Frequenzmessung mit Timer1 an D8 initialisieren und starten InitTimer1(); //globale Interruptfreigabe sei();
-
Thread
r2r DAC an Box
www.youtube.com/watch?v=tUapZ_JdHLE Habe es zuerst an einem Arduino UNO R3 versucht und nun an einem AVR32 Irgendwie ist das aber stark verrauscht.. Habe schon verschiedene Boxen verwendet. Jemand einen Tipp? #include <avr/io.h> #include <util/delay.h> #include <avr/pgmspace.h> const unsigned
/vsc/de/ch/11/cmt/vlus/da.vlu/Page/vsc/de/ch/11/cmt/simulationen/da/r2rda.vscml.html http://www.avr-asm-tutorial.net/avr_de/avr_dac.html https://wiki.analog.com/university/courses/electronics/electronics-lab-14
-
Thread
2x Atmega8 SPI Schaltung / Raspberry Pi - Atmega8 SPI Schaltung
habe. [c] ###### Master ###### #ifndef F_CPU #define F_CPU 16000000UL #endif #include <avr/io.h> #include <util/delay.h> #include <avr/interrupt.h> #define ACK 0x7E #define LONG_TIME 10000 void spi_init_master (void) { DDRB = (1<<5)|(1<<3); SPCR = (1<
[/c] [c] ###### Slave ###### #ifndef F_CPU #define F_CPU 16000000UL #endif #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #include "lcd.h" #define ACK 0x7E void spi_init_slave (void) { DDRB=(1<<6); SPCR=(1<<
-
Thread
Nested Interrupt - Atmega2560
Jetzt habe ich doch mal für Dich gesucht. https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Unterbrechbare_Interruptroutinen
> Jetzt habe ich doch mal für Dich gesucht. > https://www.mikrocontroller.net/articles/AVR-GCC-T... Vielen Dank! Das habe ich selber nicht gefunden, weil ich nach "nested" gesucht habe :P
-
Thread
cooles Arduino Projekt gesucht
was noch niemand geschafft hat, aber wenn man eine Vorlage braucht: http://petersieg.bplaced.net/?AX81_-_ZX81_auf_AVR_Basis http://petersieg.bplaced.net/?AVR_CP%2FM
Hitliste, wenn man auf dem Attiny85 den AudioBootLoader installiert hat: https://8bitmixtape.github.io/
-
Thread
Wegen Projektaufgabe, Günstige Platinen für AVR Webserver & Co
dass ich mich von einigen Sachen trenne. Kurz zu den Eckdaten: Software weitestgehend die vom AVR Net Io oder von Ulrich Radig kompakte Digitalplatine universell einsetzbar Vorgesehen: ATMEGA 644 / 1284p ENC28J60 (Ethernet Treiber) Weitbereichseingang 12V DC - 52V DC robuste Spannungsversorgungen
-
Thread
Attiny417/814/816/817 und avr-gcc, avr-libc
/usr/local/CrossPack-AVR-20131216/avr/include/avr kopieren In /usr/local/CrossPack-AVR-20131216/avr/include/avr/io.h [c] #elif defined (__AVR_ATtiny814__) # include <avr/iotn814.h> [/c] einfügen Im Makefile --specs
wenn man ein bereits unterstütztes Device so behandelt als sei es nicht unterstützt. > In $INSTALL/avr/include/avr/io.h > #elif defined (__AVR_ATtiny814__) > # include <avr/iotn814.h> > > einfügen avr/io.h braucht man nicht zu hacken, siehe Kommentare im specs-File.
-
Thread
AVR -> STM8/32. Was ist anders? Was zu beachten? Was benötigt? Gesperrt
vorzustellen" kann mir da mal jemand eine beispiel machen? Sagen wir PA1 soll High, dann würde man bei AVR machen: [c] #include <avr/io.h> DDRA |= (1<<PA1); // pin als Ausgang PORTA |= (1<<PA1); // PIN auf HIGH [/c] Wie würde das nun bei ST sein? Sagen wir direkt für einen 32Bitter, sagen
Das ist doch gar keine "Werbung" sondern ein "offizieller" Artikel der extra hier im "ehemaligen" AVR Forum gebracht wurde :-) Seit wann ist übrigens das AVR Logo oben links auf mikrocontroller.net verschwunden?? > Wieso sollten sich die Eigenschaften des AVR auch nur in der > geringsten Weise
-
Thread
Atmelstudio 7 kein Compilieren möglich
so: /* * Blinky1.c * * Created: 20.02.2017 22:41:38 * Author : Klaus */ #include <avr/io.h> int main(void) { /* Replace with your application code */ while (1) { } } Es ist egal was ich mache, ich bekomme immer diese Fehlermeldung oder dieses Output.
irgendwelche Updates am Studio gemacht. Lösung: Deinstallieren aller Studio-Versionen, Kontrolle .Net-Versionen Deinstallieren Atmelstudio Verzeichnisse per Hand leeren Installieren Atmelstudio... Siehe da, Erfolge O_o Danke