-
Thread
Funk-Dimmer und -Schalter mit ESP8266 - wer will mitbauen?
aus bedienen! Oder halt mit Touch-Screen an der Wand, siehe Bild und http://www.mikrocontroller.net/topic/349219#3973053 "IoT" = Internet of Things: http://de.wikipedia.org/wiki/Internet_der_Dinge
angeschlossen ist. Evtl. könnte man ja einfach ein ESP8266 Modul stattdessen einbauen und per SPI an den AVR anschließen. Die AVR-FW regelt den Phasenabschnitt und erhält die Befehle vom ESP8266 auf dem die Nodemcu-FW läuft.
-
Thread
Probleme mit Bootloader
Etherrape-Board mit Erfolg verwende (War beim Kauf schon drauf). Neuerdings besitze ich ein Pollin AVR-NetIO, auf dem ein AtMega32 sitzt. Für den habe ich den Foodloader auch kompiliert und per ISP aufgespielt. Er meldet sich einwandfrei und reagiert auch auf die Kommandos, die ich per RS232 und minicom
der foodloader auf meinem Etherrape board überhaup keine Probleme macht. Ich glaube ich werde den Avr-NetIO heute abend mal mit einem AtMega644 bestücken und die ganze Sache damit probieren... Gruß Pit
-
Thread
Wer hat Erfahrung mit HAP?
:) schau Dir das mal an: "http://www.mikrocontroller.net/articles/AVR-Tutorial:_Equipment" Wobei Du in einem Punkt aufpassen mußt: Mit z.B. einem STK500 und dem Avr-Studio kann man erst den Bootloader programmieren und dann direkt hinterher die Firmware
scheduler) stop 3) SVN Installieren [c]apt-get install subversion wget http://packages.netmb.net/PublicKey apt-key add PublicKey echo "deb http://packages.netmb.net/ubuntu ./" >> /etc/apt/sources.list apt-get update [/c] Lib: [c]apt-get install perl mysql-server avr-libc gcc-avr binutils-avr
-
Thread
Neue Tiny x14 können richtig was
https://www.mikrocontroller.net/topic/434984#new
Hi >Erst kommen die Arbeitsregister, dann die IO Register, dann die ext. IO >Register usw. Die Zählen eigentlich zu RAM und nicht zum Flash. Haben auf das Programm keinen Eifluss. Und ein AVR ohne dieses Bootloadergedödel startet immer bei Flashadresse
-
Thread
DCF77 - mir unerklärliches Verhalten
>was sagt uns das? Das du einen Pullup am DCF Eingang vom AVR vergessen hast ?
http://www.mikrocontroller.net/topic/83596#701185
-
Thread
GCC-Assembler und EEPROM
out _SFR_IO_ADDR(EEARL), ZL out _SFR_IO_ADDR(EEDR), r16 ; Daten schreiben in r17, _SFR_IO_ADDR(SREG) ; SREG sichern cli ; Interrupts sperren, die nächsten
Schau halt, welchen Code avr-gcc erzeugt, und dann schreib ab :-) > in r17, _SFR_IO_ADDR(SREG) > cli > ... > sei <-- hä? > out _SFR_IO_ADDR(SREG), r17
-
Thread
RWE Smarthome
transport module. NetWinder Floating Point Emulator V0.97 (double precision) JFFS2 version 2.2. (NAND) (SUMMARY) © 2001-2006 Red Hat, Inc. msgmni has been set to 119 io scheduler noop registered (default) atmel_usart
Toolchain für die CCU ist hier. > > http://www.eq-3.de/software.html Das Funkmodul hängt nur am AVR. TRX868 <-SPI-> AVR <-UART-> ARM Ich gehe davon aus, dass die unteren Protokollschichten im AVR sind. Ich kann mich aber auch irren. Vielleicht kann sich ja mal jemand die Mühe machen und
-
Thread
Uhr mit ATmega16
@ Thomas: Hmm .. isses net egal, wieviele IO Ports er dafür ver(sch)wenden möchte? Zumal er ja klipp und klar Hilfestellungen zum Thema: Wie programiere ich eine Uhr haben wollte.
keine komplizierte Sache, wenn man erst einmal die Grudzüge der AVR-Programmierung verstanden hat.
-
Thread
Taster auf "1" abfragen in AVR-C
doch drin sein, wegen dem Pullup. Was mache ich falsch? [c] #define F_CPU 3686400 #include <avr/io.h> #include <util/delay.h> int main() { DDRB=0x00; //PortB Eingänge DDRC=0xFF; //PortC Ausgänge PORTB=0xFF; //Pullup do { PORTC = 0; } while(!(PINB &
beginnen (Endlosschleife) [c] #define F_CPU 3686400 #include <avr/io.h> #include <util/delay.h> int main(){ DDRB = 0x00; //PortB Eingänge DDRC = 0xFF; //PortC Ausgänge PORTB = 0xFF; //Pullup PORTC = 0; while(1){
-
Thread
FT245 Verständnisproblem
bidirektional aneinander vorbei. Mit uni/bidirektional meinte ich die Kommunikation zwischen PC und AVR. Was du an den restlichen Pins vom AVR dranhast, ist ja davon unabhängig... Ralf
komponenten vorschlagen? Hm... Also doch wieder µC :) Wenn ich FT245 rumliegen hätte, und nur ein bisschen IO-technisch experimentieren will, würde ich auf den µC verzichten. Ich würde einfach vier Taster und vier LEDs an das Ding pappen und gut ist. Wenn ich ein etwas größeres IO-Monster haben will, würde
-
Thread
RTOS mit Arduino
basierend auf arrays -soft echtzeitfähig -binäre semaphore -messaging system http://sourceforge.net/projects/nanoos/ Es gab hier auch mal einen thread dazu https://www.mikrocontroller.net/topic/190388?page=single
spielen auch gut miteinander. https://gcc.gnu.org/wiki/avr-gcc
-
Thread
Handycamera MCA-25 ansteuern - ip webcam mit mega32
board - Ansteuerung über rs232 @460800baud Ursprünglicher Thread: http://www.mikrocontroller.net/forum/read-1-232801.html#new Sourcecode: http://avr.auctionant.de/avr-ip-webcam/avr-webserver-software.html Generelle Infos zur HW/Ansteuerung: http://avr.auctionant.de/avr-ip-webcam/ Viel
avr-ip-webcam_based_on1.38_241005.tar [/code] ___ Viele Grüße. --- *1) http://avr.auctionant.de/avr-ip-webcam/avr-webserver-software.html *2) http://avr.auctionant.de/source/avr-ip-webcam_based_on1.38
-
Thread
ASM und C in AVR Studio
Hallo, habe schon in einem anderen (alten) Thread (http://www.mikrocontroller.net/topic/68683)schon einmal die Frage gestellt, da dieser aber scheinbar schon länger tot ist, hier jetzt noch einmal in einem neuen Thread Mir sind im AVR-Gcc Tutorial bei dem Einbinden von Assembler-Dateien 2 Dinge unklar (http://www.mikrocontroller.net/articles/AVR-GCC-Tu...) beide Fragen beziehen sich auf die Datei useful.S 1)warum wird hier auf die Register über eine einfache Zahl zugegriffen? (siehe workreg=16, workreg2=17, ...) und nicht
-
Thread
stk500, erstes programm
okay seh schon, bin echt noch so was von nullchecker, hab ich natürlich alles net gemacht, gibts vielleicht ne seite wo alles etwas ausführlicher erklärt wird, weil vorher muss ich ja gar net anfangen grüße
Hi Noch einfacher: AVR-Studio-Hilfe STK500 MfG Spess
-
Thread
CAN in analog umwandeln
lassen sich Informationen über CAN Protokoll und Bitfelder finden. https://www.mikrocontroller.net/topic/429807
den Fall dass die Homematic IP Multi IO Modulplatine kein PWM mag.
-
Thread
ATmega32 AVR C Programmierphänomen Codefehler
. Wie stellst > Du sicher, das mix einstreut? Schaltplan? Wie meinst du das? Ich verwende das AVR-NET-IO Board und am INT1 Pin vom ATmega32 liegt der Ausgang des Sensors an. Alle Kabel sind vernünftig gelötet und mit Schrumpfschläuchen abisoliert. Ein Wackeln an den Kabeln beeinflusst auch nicht
Wie stellst > Du sicher, das mix einstreut? Schaltplan? > > Wie meinst du das? Ich verwende das AVR-NET-IO Board und am INT1 Pin vom > ATmega32 liegt der Ausgang des Sensors an. Alle Kabel sind vernünftig > gelötet und mit Schrumpfschläuchen abisoliert. Ein Wackeln an den Kabeln > beeinflusst
-
Thread
ATMega8 PWM Programme funktionieren nicht
schonmal ausgetauscht, und genau das selbe Problem gehabt. Hier ein Biespielcode: [c]#include <avr/io.h> int main( void ) { uint8_t pwm_soll = 20; uint8_t pwm_phase = 0; DDRB |= (1<<PB0); while( 1 ) { if( pwm_soll == pwm_phase ) { PORTB |= (1<<PB0
Anpassung sieht das nicht ganz linear aus. Probiere es aus. [c] // https://www.mikrocontroller.net/topic/523867#6800925 #include <avr/io.h> #include <util/delay.h> uint8_t pwmTimer; uint8_t pwmPulsweite; const uint8_t pwmPeriode = 200; int main( void ) { DDRB |= (1<<PB0);
-
Thread
Mikrocontroller Einstieg
r2, r2, r1, lsl #16 str r2, [r3, #0x418] bx lr[/code] Ist sogar kürzer, und das obwohl die IO-Register-Zugriffe bei den ARMs komplexer sind, weil der einfach viel mehr davon hat (größerer Adressraum). Die eigentliche Datenverarbeitung ist beim M4 kürzer&schneller (3-4 Takte vs ca. 8 beim AVR,
Naja, dann kann man auch einfach alles auf dem ESP32 laufen lassen. Relativ sinnlos da noch einen AVR dran zu schnallen außer man hat ganz spezifische IO-Anforderungen. Die allermeiste Peripherie ist heute auf 3,3V (und weniger) ausgelegt.
-
Thread
Atmel Studio 7: Assembler
Wie muss ich es anstellen, damit die Assemblerdatei übersetzt wird? *1 http://www.avrfreaks.net/sites/default/files/minidds_asm_Jespers_htm.ASM
Auch wenn es komisch klingt, es gab eine Zeit vor Atmel Studio, in der auch schon Programme für den AVR geschrieben wurden. Oliver
-
Thread
Hilfe bei GAL für Anfänger
Naja, der AVR hat den Charme, daß er auch in Assembler leicht zu verstehen ist. Z.B. braucht er keine ständigen Bankumschaltungen, wie beim PIC für RAM und IO-Zugriffe. Und der Support ist auch nicht zu verachten
LaunchDisco schrieb im Beitrag #3993176: > Der Einstieg mit avr ist viel teurer als bei anderen. Das ist dein erster Beitrag bei mikrocontroller.net, aber musst du gleich so einen Unsinn schreiben ? > Und es gibt die Klinke mit den Fuses. Bei Microchips
-
Thread
Grosse Probleme mit STK500 (betrifft Ansteuerung von LEDs)
r16,0xFF ;0xFF ins Arbeitsregister r16 laden out DDRB, r16 ;Inhalt von r16 ins IO-Register DDRB ausgeben ; ldi r16, 0b11111100 ;0b11111100 in r16 laden ldi r16,0b01010101 out PORTB, r16 ;r16 ins IO-Register PORTB ausgeben ende: rjmp ende
aus dem Tutorial uebernommen und nicht abgeaendert. Ebenfalls habe ich mir den Sourcecode aus dem AVR-ASM-Tutorial aus der Linksammlung geschnappt: http://www.avr-asm-tutorial.net/avr_de/quellen/test1.asm Leider leuchten auch mit diesem Source nicht alle Lampen; ebenfalls blinken sie nicht. Stattdessen
-
Thread
Unnötige Warteprozedur?
Warteprozedur als benötigt angegeben: [c] #define F_CPU 3686400 #include <util/delay.h> #include <avr/io.h> //... void wait_ms(int miliSec) { _delay_loop2(1*(F_CPU/(1000/4))*miliSec); //4 Zyklen Warteschleife } [/c] wäre folgendes nicht viel einfacher: [c] #define F_CPU 3686400 #include <util/delay.h> #include <avr/io.h> //... //und dann an jeder betreffenden Stelle //statt wait_ms(miliSec) _delay_ms(miliSec) [/c] Ich verstehe nicht ganz den Sinn der oberen Anweisung. Zuersteinmal könnte man die Zeile
-
Thread
PWM beim AT MEGA 88
Datenblatt Siete 101 ff, in Verbindung mit meiner letzten Dummen Frage http://www.mikrocontroller.net/topic/280982#new müsste ich doch die PWM für OC0A un OC0B folgendermassen anschalten. [c]#include <avr/io.h> #include <avr/iom8.h> int main( void ) { DDRB=0xff; OCR0A = 0xff; // zum einstellen
Theater sucht schrieb im Beitrag #2977206: > Jedoch hat er ein Problem mit der [c]#include <avr/iom8.h> > [/c]Biblotehksdatei. Dieser include sollte da gar nicht stehen. Du includierst die avr/io.h Den Rest machst du dadruch, dass du in der Entwicklungsumgebung den korrekten µC-Typ einstellst
-
Thread
Lichtsensor am MyAVR MK2 auslesen
ausgegangen, Teilungsfaktor = 16MHz/200kHz=80 also ADPS = 111 Nochmal eine kurze Übersicht Board: MyAVR MK2 µC: Atmega8A-PU Belegung: PC0(ADC0) = Sensor PB0 - PB5 = LED's Der Code sieht wie folgt aus: [c] #include <avr/io.h> int main(void) { DDRB = 0b00111111; // Ausgabe des ADC-Messwertes
könnt mir sagen was ich falsch gemacht/verstanden habe. :) Alles ;-) https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Analoge_Ein-_und_Ausgabe
-
Thread
[S] C64 im Bereich Berlin-Köpenick
weniger Ergebnis. Das ganze aber nur als Zwischenschritt, für komplexere Aufgaben dürfte C64 und AVR ähnlich schwierig werden, und da ist ein AVR/Arduino zukunftsträchtiger.
Vielleicht käme für Dich auch ein Simulator in Frage? Konkret beispielsweise dieser hier: http://www.avr-asm-tutorial.net/avr_sim/avr_sim-download.html Damit kannst Du einen kleinen Mikrocontroller (z.B. attiny13) simulieren und ihm bei der Arbeit zuschauen. Der Simulator ist einsteigerfreundlich und
-
Thread
extrem kleiner Analog=>USB Konverter
lange und unter welchen umständen ;-) also für gewerbliche/industrielle Lösungen würde ich lieber zB. IO-Warrior mit externen ADC nehmen - oder irgend einen MC der Hardware USB eingebaut hat ( Pic,PSOC usw.) IO-Warrior gibts bei www.codemercs.com hf
Er meint .NET auf der PC-Seite, nicht im µC!
-
Thread
Anlage über RJ45 steuern
noch alternative Firmwares fürs Net-IO, wie z.B. Ethersex usw. Gibt hier im Wiki auch eine Auflistung. mfg mf
hier isses: http://www.mikrocontroller.net/articles/AVR_Net-IO_Bausatz_von_Pollin
-
Thread
PC-Tastatur mit AVR ersetzen
(15); PS2_PORT &= ~(1 << PS2_CLOCK) IO_set(PS2_CLOCK,1); PS2_PORT |= (1 << PS2_CLOCK) IO_set(PS2_CLOCK,0); } void PS2_send(uint8_t data) { uint8_t tmp = data; uint8_t i; //Startbit PS2_PORT &= ~(1 << PS2_DATA)
durchführen oder nicht. Studiere doch das mal, da wird das genau so benutzt: http://www.mikrocontroller.net/articles/AVR-Tutorial:_Schieberegister#Softwarem.C3.A4ssige_direkte_Ansteuerung
-
Thread
AT Mega 88 Interrupt
möchte ich aber aus dem Interrupt raus und die LED ausmachen. Wie setze ich das um? [c] #include <avr/io.h> #include <avr/interrupt.h> #define __enable_interrupt() __asm__ volatile ("sei") #define __disable_interrupt() __asm__ volatile ("cli") int main(void) { DDRB = 0x06;
die fallende Flanke aus? [C] #include <avr/io.h> #include <avr/interrupt.h> volatile unsigned int Merker; int main(void) { DDRB = 0x06; PORTB = 0; DDRC = 0x3F; PORTC = 0; DDRD = 0x00
-
Thread
Intertechno Funksteckdosen per AVR steuern
Hier findest Du weiteres zum Code und zum Oszillogramm: http://avr.börke.de/Funksteckdosen.htm http://avr.börke.de/ARCTECHsteckdosen.htm Gruß Joachim
dem Intertechno-Sender. Eine Frage habe ich aber noch. Gehe ich richtig in der Annahme, dass Du den IO Pin vom Arduino/AVR mit 5V direkt auf die angelötete Leitung des Funksenders gibst und dass der Funksender keine eigene Versorgung mehr erhält. D.h. ja dann, dass der IO Pin den 433 MHz Sender komplett
-
Thread
VT100-Terminal (VGA+PS2)
http://www.mikrocontroller.net/svnbrowser/avr-cp-m/trunk/VT100/docs/VT100_sheet.pdf?sortdir=down&view=log
. Die Repository-URL wäre dann: svn://mikrocontroller.net/avr-cp-m Ansonsten nur den interressierenden Teil. z.B: svn://mikrocontroller.net/avr-cp-m/trunk/VT100/source/work 2. Dateien editieren, oder Deine geänderten Dateien drüber kopieren.
-
Thread
AVR: Pointer in Register - wie definieren?
Stefan U. schrieb im Beitrag #4884434: > Genau das geht zumindestes bei AVR nicht, da alle Register über RAM > Adressen erreichbar sind, IO-Register sind auch über RAM-Adressen erreichbar, und die stehen noch nach den CPU-Registern. Die kann man unmöglich in einen
der CPU-Register dann übrigens fallen gelassen. Dadurch ist dort auch der Offset 0x20 bei den IO-Registern verschwunden, den man sonst beim AVR zwischen Adressierung per IN/OUT und Adressierung per STS/LDS hatte.
-
Thread
Mit Pic32 anfangen
Schau dich mal hier um: http://www.mikrocontroller.net/articles/AVR-Tutorial http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial oder http://www.sprut.de/
scripter schrieb im Beitrag #2169768: > Was würdet ihr eher empfehlen und weshalb: PIC oder AVR (oder sonst > was)? Da ich mit AVR angefangen habe, ist meine Antwort klar AVR. Die Tutorials zum AVR hier sind erste Sahne. Außerdem kannst du hier mit schnellerer Hilfe zum AVR als zum PIC rechnen
-
Thread
asm Portpin schalten
zu schalten? Hast du schon die zahlreichen Tutorials gelesen, e.g. https://www.mikrocontroller.net/articles/AVR-Tutorial:_Logik Du sagst nicht ueber deine Architektur, hier also mal AVR. > Ersteres geht ja noch > relativ einfach mit schieben, wie ist es aber beim Zweiten? Mit Schieben hat
Du kannst mit cbi sbi alle wichtigen IO-Register umschalten. Je weiter weg du vom Elementaren kommst, desto höher ist die Wahrscheinlichkeit, dass es fehlschlägt. Welche Register via cbi/sbi zugreifbar sind findest du zum jeweiligen AVR-Bauteil
-
Thread
STK501 variablen problem
#include <avr/io.h> #include <stdint.h> #include <stdio.h> #include "test.h" volatile uint8_t var; volatile uint32_t i; int main (void) { DDRB = 0xFF; //init PORTB = 0xFF; //ausschalten
2; i==0; i--){;} var--; } while(var != 0); } SO funktioniert alles: #include <avr/io.h> #include <stdint.h> #include <stdio.h> volatile uint8_t varib; volatile uint8_t var; volatile uint32_t i; void main (void) { DDRB = 0xFF; //init PORTB = 0xFF; //ausschalten
-
Thread
LCD (HD44780, Displaytech 162C) macht Probleme
Hier mal meine komplette main.c: [c] #include <avr/io.h> #include "lcd-routines.h" int main(void) { // Hier funktioniert alles ... lcd_init(); lcd_string("Hallo Welt!"); lcd_setcursor(0, 2); lcd_string("Hall"); // ... und beim nächsten Befehl
Properties, die ihr Verhalten steuern, mit den korrekten Werten belegt, _bevor_ man sie benutzt. Z.B. Dot.Net's System.IO.Ports.Serialport wird (bestenfalls) nur dann von allein korrekt kommunizieren, wenn dein Kommunikationspartner zufällig an COM1 angeschlossen ist und zufällig auch in jeder Beziehung mit
-
Thread
WordClock mit DCF77, Photodiode und ATMega8
auch überall sonst >verwende. Kann funktionieren, muss aber nicht. http://www.mikrocontroller.net/articles/DCF77-Funkwecker_mit_AVR#DCF77-Modul_von_Reichelt MfG Falk
jemanden interessiert. [code]#include "dcf77.h" #include <stdio.h> #include <math.h> #include <avr/io.h> #include <avr/interrupt.h> typedef struct { unsigned start_minute : 1; unsigned weather : 14; unsigned call : 1; unsigned summer_time : 1; unsigned cest : 1;
-
Thread
mehrere MOC3041 ansteuern Erfahrungen?
. Es geht immmer nur um irgendeine IO-Karte die irgendein IO-Signal ausgibt, das irgendwie zu wenig Strom bringt. Für eine halbwegs brauchbare Schaltungsauslegung fehlen hier mindestens Spannungs- und Stromangaben.
Salamischeibchen an Information, > die er hier im Thread zum Fraß vorgeworfen hat, > lässt auf einen AVR schließen. Das ist richtig. > Es geht immmer nur um irgendeine IO-Karte die irgendein > IO-Signal ausgibt, das irgendwie zu wenig Strom bringt. Typisch geht man davon aus, dass Digitalschaltungen
-
Thread
LCD - Datei einbinden (".")
meiner Frage: Da ich Anfänger bin habe ich mir den C Code vom GCC Tutorial http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung ins AVR Studio kopiert. Beim Compilieren kommt die Fehlermeldung ../LCD.c:49:26: error: lcd-routines.h: No such file or directory Der Compiler kann mit
Verwende den Code aus dem Wiki http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung Habe einfach den Code ins AVR Studio hineinkopiert. LCD.c befand sich automatisch in den Source Files. Welche Schritte muss ich noch machen, nachdem
-
Thread
Port alle 200ms ein-/ausschalten
ein-/auszuschalten. Compiler-Fehermeldungen habe ich keine. [c]#include <stdlib.h> #include <avr/io.h> #include <avr/interrupt.h> #include <avr/sleep.h> volatile uint8_t i=0; ISR(TIMER1_OVF_vect) { i++; if(i>200){ i=0; PORTB ^= (1<<PB0); } } int main() { DDRB |= (1<<
1000000*64*1000) => 156 Das gibt mir doch dann folgenden Code: [c] #include <stdlib.h> #include <avr/io.h> #include <avr/interrupt.h> #include <avr/sleep.h> volatile uint8_t i=0; ISR(TIMER1_OVF_vect) { i++; if(i>20){ i=0; PORTB ^= (1<<PB0); } } int main() { DDRB |= (1<<PB0
-
Thread
UART "kauderwelsch"
müsste ich gehen das es läuft? im Tutorial machen sie das auch mit 1MHz http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART
gehen das es läuft? > im Tutorial machen sie das auch mit 1MHz > > http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART Du hast leider einen wesentlichen Teil weggelassen, nämlich die Umschaltung auf double speed:[c]#include <avr/io.h> #define F_CPU 1000000 /* evtl. bereits via
-
Thread
MSP430 vs. AVR: Welches Konzept ist besser?
nicht auch interessant? Hast du folgenden Artikel schon durchgelesen: http://www.mikrocontroller.net/articles/AVR_PIC_51-Vergleich Ein grosser Nachteil an den MSP430 ist der, dass sie nicht 5V kompatibel sind, was für den Einstieg vl etwas stören kann, da man hier dann manchmal auf spezielle Bauteile
Zugriff auf Flash, RAM, Peripherie)). Nachteil der Flexibilität ist, daß bei gleichem Takt Bit-Bang-IO langsamer ist, als beim AVR (z.B. Software-SPI/UART-Routinen). Die reine Rechenleistung der MSPs ist dagegen aufgrund der 16-Bit Architektur in vielen Fällen deutlich höher. Von der verfügbaren Peripherie
-
Thread
Stoßt man mit C an Grenzen?ASM von Vorteil?
[c] int bit; for (int i = 0; i < 8; i++) { bit = 1 << i; /* machwas */ } [/c] auf einem AVR Scheiße ist, eben solche Sachen zeigt einem C einfach net :-)
Und andersrum wäre nichts angebrannt, denn was in undefinierten Datenadressen drinsteckt war bei AVR noch nie definiert.
-
Thread
AtMega128: Längenbegrenzung bei "strcat"?
avr-libc Doku die Zweite: http://www.nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html Tutorial: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Programmspeicher_.28Flash.29
dem > Compiler, daß es eine Adresse vom Flash ist? pgm_read_byte() http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Programmspeicher_.28Flash.29 [C] void strcpy_XRAM_P( char* XRAMAddr, const char* FlashAddr ) { char c; do { c = pgm_read_byte( FlashAddr++ ); XRAM_write_byte
-
Thread
Object Oriented Forth
Mecrisp Forth von Matthias Koch angepasst ist. Nennt sich Mecrisp-Ice (https://mecrisp.sourceforge.net/#fpga) und liegt auf https://sourceforge.net/projects/mecrisp/files/ Viel Spass /regards
> eigenen Faden für Pico 2 & Micropython aufmachen. Gute Idee: https://www.mikrocontroller.net/topic/581775
-
Thread
250 kHz PWM -> ¿Filter? -> micro speaker
habt ihr mich ja evtl. schon messtechnisch beraten... :-) Verwandt: https://www.mikrocontroller.net/topic/485881 https://www.mikrocontroller.net/topic/331296 https://www.mikrocontroller.net/topic/200543 https://www.mikrocontroller.net/topic/467851 https://www.mikrocontroller.net/topic/474376
W". Hier mal das Testprogramm: [c] #define F_CPU 16500000 #include <stdint.h> #include <avr/io.h> #include <avr/pgmspace.h> //#include <avr/sleep.h> #include <avr/interrupt.h> #include <avr/wdt.h> #include <util/delay.h> const uint8_t PROGMEM sine[256] = { 0x80, 0x83, 0x86, 0x89
-
Thread
Uhr bauen-I2C,
Woche Lesestoff bieten.... Weiter.. Das Pollin-Board und der darauf gesteckte Controller ist aus AVR- Studio nicht direkt ansprechbar. Es bedarf einer echten seriellen Schnittstelle und einem Programm namens PonyProg. Gibt's aber auch zum kostenlosen Download. Der Nachteil, ein Programm wird in AVR-Studio
Macht mal eine Skizze der Hardware und versucht zum Beispiel mit den 22 nutzbaren, mit ext. Quarz 20 IO auszukommen. Bedenkt, das die Uhr ja auch gestellt werden muß und deshalb auch Taster benötigt werden. Wenn es euch nicht gelingt, dann schaut euch mal den Atmega16 an. der hat schon mal 32 IO-Leitungen
-
Thread
LL-MOSFET an AVR Pin: max. PWM Freq?
Hi! Ich möchte einen N-Ch-MOSFET (IRF7403) als low-side Schalter direkt an einem AVR Pin per PWM ansteuern. Mir ist nicht wirklich klar, wie ich ausrechnen (abschätzen) kann, welche Schaltfrequenz ich realistisch ohne Treiber mittels des AVR-Pins realisieren kann. Die Gate-Kapazität
mal mit einem dicken FET (100nC Total-Gate-Charge) und der max. PWM-Frequenz (250kHz) aus, die ein AVR liefert. Physikalische Grundlage: Bahnwiderstand. Der Puls-Strom wird nicht so groß, dass er dem AVR gefährlich wird. Was der internen IO-Schaltung gefährlich werden kann, ist Erhitzung. Für
-
Thread
ATMEGA 8515 UART sendet Mist statt string
einen AtMega 8515 mit 8Mhz externem Quarz, eine Baudrate mit 38400 Baud und den Quelltext aud dem AVR-GCC UART Tutorial. [c] #include <avr/io.h> #include <stdio.h> #include <stdint.h> #define BAUD 38400ul // baud rate #define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1) #define BAUD_REAL (F_CPU
Zwischenzeit mal ein neues Projekt angelegt und den Code reinkopiert, um sicherzustellen dass ich net irgendwas verstellt hab. Und siehe da es läuft. Woran liegts? Ich hab das Projekt mit AVR-Studio 4 erstellt nutzte aber mittlerweile AVR-Studio 5, weil mir der Editor besser gefällt, ob dass die Ursache
-
Thread
Raspberry Pi 4 vorgestellt
er bei der Speicherverwaltung eh schon. Der Kernel selbst braucht ja kaum 4 GB RAM. https://lwn.net/Articles/415190/
schrieb im Beitrag #6053544: > Ich nutze den RPI4 als Desktopersatz, was mich stört ist das es kein > AVR-Studio für den RPi gibt Programmieren in Lazarus / FreePascal und Brennen mit Burn-O-Mat / AVR-Dude. Funktioniert super.