-
Thread
ARM gibt Cortex-M-Prozessoren für Xilinx FPGAs frei
](/articles/ARM) mit einer eigens [für diesen Zweck kreierten Website](https://www.mikrocontroller.net/topic/455212) auf die vermeintlichen Nachteile der offenen Architektur hingewiesen, diese jedoch nach kurzer Zeit wieder vom Netz genommen.
Prozessor der ARM-A-Klasse > - 2 Kerne kleine Ergänzung: - bis zu 800 MHz CPU-Takt - bis zu 300 MHz IO-Takt kleiner Wermutstropfen: - keine low-power Modi, geringste Leistungsaufnahme ~30mW mit beiden Kernen im WFI
-
Thread
Kontaktmeldung fernübertragen, wie?
anschliessen? Und wie die Kontrollampe am anderen Ende? Möglichkeit 1: Du baust du aus bspw. dem AVR-NET-IO von Pollin einen kleinen Webserver, den du dann in der Wohnung abfrägst oder durch ein zweites Net-IO mit Lampe abfragen lässt. Möglichkeit 2: Du schaltest einfach den PowerLAN-Adapter mit
-
Thread
Arduino-C: Unklarheit bei '<< Operator'
ja, von wem dieser "Expertentip" kommt . . . Hier mal mein Tip. https://www.mikrocontroller.net/topic/394065#4527806
aber damit verliert man den Vorteil des Bitfeldes (welches sowieso unportabel ist, aber das ist bei AVR eher irrelevant). Außerdem funktioniert so ein Ansatz nur mit IO- oder MMIO-Registern vernünftig, aber nicht mit externen Registern (die via I2C, SPI oder sonstwas angesprochen werden).
-
Thread
Marlin Firmware mit dem ATMEL STUDIO 7 auf das Arduino Mega 2560 Board flashen
E:\Projekte AVR-Studio\ATmega\ATmega88\TWI_3\TWI_3\Debug\TWI_3.obj" "" -I "G:\AVR Studio\7.0\Build1188\7.0\toolchain\avr8\avrassembler\Include" AVRASM: AVR macro assembler 2.2.7 (build 69 Jul 26 2017 16:25:
hier, der seine AVR8-Mikrocontroller in Assembler per PlattformIO ( PIO ) programmiert? Mein Rechner macht zur Zeit schon genug Probleme, da will ich nicht noch tausend Programme herunterladen, die ich dann nicht mehr
-
Thread
Frage zu MSP430 Dokumentation für Einstieg
in einem Adressraum hat und keine gesonderten Befehle für den Flash-Daten-Zugriff braucht wie beim AVR.
Und lass dir keinen falschen Floh ins Ohr setzen. Der MSP ist ein super Controller. Da kommt der AVR Quatsch nicht mit.
-
Thread
Unterbrechung eines Interrupts durch einen Interrupt
Ein Xmega ist auch ein AVR, aber da sind die Interrupts unterbrechbar, AFAIK.
: Die AVR Interrupts sind unterbrechbar. Wenn man das will. MfG Willi
-
Thread
DS18B20 Verkabelungs od Software Problem
can take place on the 1-Wire bus while the pullup is enabled." Das macht meine Lib direkt mit dem AVR-IO Pin, das reicht für ne Handvoll mA.
statt arduino.lib mal https://www.mikrocontroller.net/topic/14792 oder "mein" AVR Code in pure C versuchen, geht auch in Arduino, da nutze ich es auch
-
Thread
Attiny85 Servo
Allerdings will der Code nicht funktionieren. Könnt Ihr mir da auf die Sprünge helfen? [c] #include <avr/io.h> #include <avr/interrupt.h> #define ICP PINB0 #define CLK_F 1.0/16000000.0 //Der "Overflow-Counter" wird immer um eins erhöht, wenn der Timer einmal durchgelaufen ist int ov_counter
der vielleicht auch einmal ein PWM-Signal mit einem Attiny85 einlesen möchte :D [c] #include <avr/io.h> #include <avr/interrupt.h> #include <util/atomic.h> #define VORTEILER 256.0 #define CLK_F VORTEILER/F_CPU //Der "Overflow-Counter" wird immer um eins erhöht, wenn der Timer einmal durchgelaufen
-
Thread
Nuvoton N76E003
, ist billiger, und kommt mit seriellem Bootloader. Eval Board gibt es auch: https://jaycarlson.net/pf/stcmicro-stc8/ Die EFM8 8051 sind besser, gibt es aber nicht mehr als DIP: https://jaycarlson.net/pf/silicon-labs-efm8/
STM8 bei 16 Mhz erzielt auch deutlich höhere Scores als ein MCS-51 bei 98 Mhz: https://sourceforge.net/p/sdcc/code/HEAD/tree/trunk/sdcc-extra/historygraphs/dhrystone-mcs51-size.svg https://sourceforge.net/p/sdcc/code/HEAD/tree/trunk/sdcc-extra/historygraphs/dhrystone-stm8-size.svg https://sourceforge.net
-
Thread
9 Rollos und Jalousien steuern
https://www.mikrocontroller.net/topic/454118#new https://luani.de/projekte/esp8266-hvio/ Davon muss du zwar mehrere machen, aber alles über WLAN bedienbar.
Falls die mangelnde Anzahl an IO-Pins das einzige Problem Deiner Experimente mit Arduino und Raspberry Pi waren, dann genügen mglw. ein paar einfache Schieberegister: https://www.mikrocontroller.net/articles/AVR-Tutorial:_Schieberegister
-
Thread
C++ Toolchain AVR
Quick and dirty geht es wie schon genannt mit Arduino, auf AVR, einigen STM32 und ESP. Das ist aber ein Gemisch aus Prozeduren und OO, IO Pins werden mit Prozeduren wie digitalWrite(Pin) bedient und SPI z.B. ist ein Objekt. Ich benutze lieber mbed, da sind alle
: 7.3.1-1.1 https://www.mikrocontroller.net/topic/458569#5543238 Eine C++ hardware abstraction library für Microcontroller ist verfügbar, letzte Erweiterung 13.09.2018 https://github.com/KonstantinChizhov/Mcucpp für AVR8, Stm32 und
-
Thread
beim Multitasking Tasterwert speichern
Beispielcode: [c] #define F_CPU 2000000 #define LED PC1 #define taster PB1 #include <avr/io.h> #include <avr/delay.h> #include <avr/interrupt.h> uint8_t taste_lesen(void) { if (PINB & (1<<taster)) return 1; else return 0; } void led_blinken(uint8_t taste) {
schrieb im Beitrag #5558157: > Allerdings hilft mir das nicht weiter. https://www.mikrocontroller.net/articles/Statemachine
-
Thread
"Moderner" PLLC 84 CPLD?
#5555263: > Reset ginge nur mit einem geheimen "High voltage" Programmiermodus > ähnlich wie bei den AVR. geheim??? Mein Galep kann das ... Wir haben in einem Design alle verfügbaren IO gebraucht. Auch die JTAG als IO. Wenn man das Design schreibt, gibt es danach kein JTAG mehr. Will man
#5555263: >> Reset ginge nur mit einem geheimen "High voltage" Programmiermodus >> ähnlich wie bei den AVR. > > geheim??? > > Mein Galep kann das ... > > Wir haben in einem Design alle verfügbaren IO gebraucht. > Auch die JTAG als IO. > > Wenn man das Design schreibt, gibt es danach kein JTAG
-
Thread
Step Up oder Step Down? Vorteile?
Augensicherheit nach DIN EN 62471 beachtet). Dann nimm nur eine Zelle ohne Regler direkt an nen AVR für 1,8..5,5V. Und die LED wird über einen Schaltregler mit Konstantstromausgang gepeist. Dafür gibt es LED-Treiber-ICs oder mit etwas Programmieraufwand kann das auch der AVR über einen PWM-Ausgang
>> gepeist. Dafür gibt es LED-Treiber-ICs oder mit etwas Programmieraufwand >> kann das auch der AVR über einen PWM-Ausgang mit machen. > > Diese Variante hielte ich auch für die praktikabelste. Wie ich oben > schon schrieb, kann man dann den AVR komplett „unter Spannung“ lassen, > er kann dann
-
Thread
Arduino - UNO Flashershield (Linux)
Installation ist "flashershield" Systemweit verfügbar und wird mittels: flashershield gestartet. AVR ---- Als Flasherprogramm für AVR dient AVRDUDE. Hinweis: bei Arduino-UNO Klone aus China funktioniert AVRDUDE aufgrund des CH340G Chips der Klone bis Version 5.8 und ab Version 6.3 Das Ausgangsprojekt
stammt aus: http://rweather.github.io/ardpicprog/index.html --------------------------------------------------- Die Firmwares von AVR500 und PIC16F wurden modifiziert und dem Flashershield angepasst. Mittels des Buttons kann der USB2UART
-
Thread
Einfach zu implementierende CPU in VHDL
Ausgabe bzw. erzeugung der VGA Signale > - Ausgabe der Tonsignale https://www.mikrocontroller.net/articles/16/32Bit_Computer/Konsole
Mein gedachter Hardware-Tile/Sprite-Renderer von https://www.mikrocontroller.net/topic/447316 scheint niemanden zu beeindrucken, doch vielleicht hast du Lust das zu entwickeln :-)
-
Thread
delay Funktion mit IRS ersetzen
könnte mit einer IRS. Wie funktioniert das genau in meinen Anwendungsbeispiel ? [c] #include <avr/io.h> #include <util/delay.h> #define taster PB1 int jj=0; int main(void) { DDRB &= ~(1<<taster); DDRD |= 0xff; while (1) { PORTD=jj; jj+
Pin PC0 (Arduino A0) // LEDs Current Source angeschlossen #include <avr/io.h> #include <avr/interrupt.h> // sei(), cli(), ... volatile unsigned long timer0_millis = 0; // Zeit in ms seit Reset unsigned long time_prev; int time_interval
-
Thread
Floppy FDD Diskette an AVR Mikrocontroller ATmega Beispiele Assembler
zusätzliche Hardware. Einige hilfreiche Beiträge fand ich u.a. hier: https://www.mikrocontroller.net/topic/17839 https://www.mikrocontroller.net/topic/60079#new https://www.mikrocontroller.net/topic/71858#new Anmerkung: Im Video ist das hin- und herfahren des Kopfes sehr schön zu sehen und
Datenbuch zu bekommen). Die einfacheren hatten noch eine externe PLL. https://www.mikrocontroller.net/topic/71858 https://www.mikrocontroller.net/topic/223147 Zur Soft-Dekodierung, falls es unbedingt ein AVR8 sein soll und die Zeit nicht ausreicht: die laufen bei sauberem Aufbau auch bis 24 / 28
-
Thread
Nixie Uhr Probleme :-(
eigenen Oszillator weiter. > > Und genau sowas bräuchte ich auch. https://www.mikrocontroller.net/topic/58769#456232
Danke für die Antworten, das mit dieser AVR Geschichte muss ich mir nochmal genauer anschauen, ich habe sowas noch nie gemacht :-(, hab aber nächste Woche Urlaub :D Ja ich habe neue Platinen machen lassen, die alten haben ja nicht funktioniert
-
Thread
Fragen zu schrittmotor Treiber
versorgt wird ? Hier gibt es weitere Informationen bzw. Fragen. https://www.mikrocontroller.net/topic/462719#5620799 Bernd_Stein
Konnte es hiermit kompriemieren : https://www.veed.io/de-DE/werkzeuge/videokompressor/avi-komprimieren Bernd_Stein
-
Thread
Uart Terminal Monitor open source
Displays gibt es derzeit für € 3,95 bei Pollin. Um den Bedarf zu erhöhen müßte man allerdings noch freie IO-Pins auf Pfostenstecker legen und auch einige Schnittstellen RS232, SPI, CAN, IIC, ... "sinnvoll" herausführen. Aber hier werden sich dann die Geister scheiden, je nach Vorliebe der einzelnen Nutzer.
Mit VGA-Ausgang hat so etwas hier schon mal jemand vorgestellt: https://www.mikrocontroller.net/topic/143445 Das könntest Du hiermit verheiraten https://www.mikrocontroller.net/topic/92704?goto=new#new um damit LC-Displays anzusteuern.
-
Thread
Helligkeit analog messen mit Fotowiderstand analog an AtTiny
Schaltung für AVR 0...10000 Lux oder mehr.
#5545154: > Ja Joachim, du hast wieder Recht. ich hoffe auch hier :) https://www.mikrocontroller.net/topic/458668#5545316
-
Thread
diskrete CPU
Schau mal hier rein: https://www.mikrocontroller.net/topic/226606
] Link zur Homepage: http://www.bo8h.de/ Link zu den Threads: https://www.mikrocontroller.net/topic/297603 https://www.mikrocontroller.net/topic/407050 Ist aber nicht jedermans Sache.
-
Thread
ESP32 : 1-2nF messen
... und wenn ich statt nur den IO auf GND zu setzen, zwischen den Messungen auch den ADC auf GND setze entlädt sich der Kondensator sofort und ich brauche für eine Mittelung der Werte über z.B. 5 Messreihen nur die hälfte der Zeit, da ich nicht warten muss mis sich der Kondensator über R entladen hat. Hält das ein ESP-IO aus oder grille ich den damit, wenn ich worst-case die Ladung von 2nF ohne R direkt durch den IO nach GND jage? :D Gruß Gerd
-
Thread
ATMega: Reboot per Software auslösen?
H.Joachim S. schrieb im Beitrag #5531949: > Zeige mal EINEN AVR, der > einen internen watchdog hat und dessen Reset kein vollwertiger Reset > ist. https://www.mikrocontroller.net/articles/AVR_Typen Wie ich schon dem mit dem billigen Whiskey mitteilte:
für einen ESP aus einem LE33CV im TO92 genügte ein BC547 War aber eher als Scherz gemeint. Beim AVR tut es der Watchdogreset einwandfrei, um in den Bootloader zu kommen. Der Bootloader weiß ja, welche IO-Register er angefaßt hat (z.B. UART) und muß nur diese zurück setzen, bevor er die Applikation
-
Thread
stromsparender Raspberry Pi als Webserver
an einen - Pi modell B oder - Pi Zero + irgendeinen USB->LAN Adapter Was meint ihr? Eine AVR+EthernetShield - Lösung habe ich bereits ausgeschlossen.
nutzt aber nicht viel weil die Logdateien irgendwann die SD killen! https://www.mikrocontroller.net/topic/457614#5528423
-
Thread
AVR 7-segment Multiplex Probleme
vierstelliges 7-Segment Display gemultiplexed ansteuert. So wie hier: https://www.mikrocontroller.net/articles/AVR-Tutorial:_7-Segment-Anzeige Das Programm habe ich in C geschrieben und mit AVR-GCC kompiliert. Soweit alles ganz simpel. Einzelne Digits anzusteuern funktioniert wie erwartet. Ebenfalls
> PORTB |= ((segment & 0b00000001)); Und wo wird der Pin wieder rückgesetzt? [c] #include <avr/io.h> void _7seg(uint8_t segmentnum, uint8_t segment){ PORTD |= 0b00111101; // all digits off if( !(segment & 0b01000000) ) PORTD &= ~0b01000000; PORTB = PORTB & 0b11000000
-
Thread
Probleme mit LED blinken lassen, Frequenz ändert sich nicht
einschalte, flackert diese ?!?! Also Programm auf ein Minimum lesbar reduziert. [code] #include <avr/io.h> #include <util/delay.h> #define LED_PIN (PD6) #define LED_PORT (PORTD) #define LED_DDR (DDRD) #define SET_LED_ON (LED_PORT |= _BV(LED_PIN)) #define SET_LED_OFF (LED_PORT &= ~_BV(LED_PIN
} } [/code] compiliert und geladen wird es mit (Zum test sogar ohne Makefile): [code] avr-gcc -mmcu=atmega1284p -Os -c main.cpp -o main.o -DF_CPU=16000000 avr-gcc -mmcu=atmega1284p main.o -o main.elf avr-objcopy -O ihex -j .text -j .data main.elf main.hex avrdude -c stk200 -p atmega1284p
-
Thread
3 CH Pseudo Software PWM reagiert nicht auf Kanal 3.
Hat da jemand eine Idee ? Hier der Code: [c] #define F_CPU 4800000UL #include <avr/io.h> #include <util/delay.h> #include <avr/interrupt.h> #include <stdint.h> #include <avr/eeprom.h> void pwmblau(); void pwmweiss(); void pwmluefter(); void delay_us(); void load(); uint16
Les dich mal hier ein: https://www.mikrocontroller.net/articles/Soft-PWM
-
Thread
Flankenauswertung bei vielen Tasten
anschließen und den ganzen Port entprellen. Die ARM haben ja mindestens 16Bit breite Ports und beim AVR nimmt man 2 Ports, die man in ein uint16_t kombiniert. Oder man nimmt einen ADC-Eingang und ein paar Widerstände: https://www.mikrocontroller.net/topic/64731#517001
generisches Beispiel, wie man Inputs wild durcheinander auf eine 16bit-Variable einliest: [c] #include <avr/io.h> typedef uint16_t keyvar_t; #define INKEY0 PINB, 0 #define INKEY1 PINC, 7 #define INKEY2 PINA, 4 #define _KEY_SET(port, bitin, bitset) port & 1<<bitin ? 1<<bitset : 0 #define KEY_SET
-
Thread
stm32f103-bluepill-peripherie
Fehlermeldung? [c] digital_write_bit() [/c] gibbet scheinbar nicht mehr, ersetze es durch [c] digital_io_write() [/c]
würde ich Eclipse nehmen weil man damit dann für alles kompilieren kann. Die Nutzung aller Pins als IO kann nur eine sportliche Herausforderung sein, es wurde ja schonmal nach der Anwendung gefragt. Fehlende IO kann man durch Portexpander wie Schieberegister oder I2C Bausteine erweitertn oder man nimmt
-
Thread
AVR8ASM TWI Interrupt
Hi Nach meinen Dokementen: Rev. 2564B-AVR-09/04 Rev. 2564C-AVR-01/10 In AppNote 2564B steht der Satz mit den <10 drin, ab 2564C fehlt er. In den Datenblättern ist diese Einschränkung nie aufgetaucht. Also sind die Angaben "2564A 04
Hi >Siehe Anhang, aus dem Preliminary 2545B–AVR–01/04. Ok. Dann nehme ich das zurück. MfG Spess
-
Thread
Programm meckert (bei den setzten von Ein-& Ausgängen)
Chris S. schrieb im Beitrag #5513461: > Die Bibliothek (#include <avr/io.h>) wurde davor natürlich eingebunden. Das sollte auf einem ARM aber einen dicken Fehler werfen.
ATSAM4S4C. Das ist ein ARM, Du mußt also ins ARM-Tutorial schauen: https://www.mikrocontroller.net/articles/ARM_Cortex_Mikrocontroller Die ARM sind einiges komplexer als die AVR. In der Regel wird beim ARM nicht direkt auf IO-Register zugegriffen, sondern ein HAL benutzt. Gebräuchlich sind hier
-
Thread
Rust als Embedded-Programmiersprache Gesperrt
S. R. schrieb im Beitrag #5514409: > aber auf dem AVR kannst du das Thema vergessen. Warum? An dem Projekt wird aktiv gearbeitet: https://github.com/avr-rust/
https://ziglang.org/ [C] const builtin = @import("builtin"); const std = @import("std"); const io = std.io; const fmt = std.fmt; const os = std.os; pub fn main() !void { var stdout_file = try io.getStdOut(); var stdout_file_stream = io.FileOutStream.init(&stdout_file); const stdout
-
Thread
Wie Messwerte über Wlan auslesen?
(ATmega) habe ich früher mit Assembler oder Bascom programmiert und jetzt mit LunAVR. Kleinere Windowsprogramme mit vb.net. Ja, ein Operationverstärtker mit Schutzschaltung wird vorgesehen und auch eine schaltbare Versorgungsspannung für den Sensor. Diese kleinen Wlan-Module sind
ESP12 NodeMcu Dev-Kit WiFi Modul Board WeMos Arduino > oder > WeMos D1 mini ESP8266 NodeMCU ESP12 IoT LUA WLAN WiFi Arduino Technisch geben die sich nichts - beide haben ESP12. Das Wemos hat etwas angenehmere Abmessungen.
-
Thread
bis 72V mit ATMEGA328 ADC messen
gehen kann. Ein Spareffekt ist allerdings nicht vorhanden. Wozu auch, da der Versorgungsstrom des AVR die größte Last darstellt.
Gate-Steuerspannung). siehe auch: [[Batteriewächter]] bzw. T2 im Schaltplan: https://www.mikrocontroller.net/articles/Datei:BMON_1048_PIC.PNG Gruß Anja
-
Thread
Shakti: Indiens erster RISC-V basierender Prozessor bootet Linux
hier bekannten Microcontrollern, aber auch Broadcom mit seinen SOCs für Embedded. Atmel hat immerhin AVR32 erfunden umd irgendwelchen Grenzen oder Lizenzen zu entgehen.
Etwas, das quelloffen ist, kann durchaus patentiert werden. Microsoft macht sowas z.B. in seinem .NET-Umfeld.
-
Thread
Suche LTE-Modul für µC Betrieb, weltweit
Sieh Dir auch einmal die "fertigen" Terminals bei MC-Technologies an: https://www.mc-technologies.net/de/Produktgruppen/Datentechnik/Downloads/ Dort gab es einmal die MC55Terminal oder MC66Terminal, usw. Viel Erfolg und Glück! Bernd
letztends etwas neues heraus gebracht: https://www.nordicsemi.com/eng/Products/Low-Power-Cellular-IoT mfg Torsten
-
Thread
Programmierung Hitachi
...woher wusste er, welche iO sind? ;) Klaus.
Klaus R. schrieb im Beitrag #5501339: > woher wusste er, welche iO sind? Haben sich vermutlich danach noch programmieren lassen, die zerschossenen Teile nicht mehr...
-
Thread
AVR Assembler Trick gesucht Gesperrt
Achja, der easyAVR! Wie kompliziert das doch alles bei ARM ist: [code]adds r10, #10[/code] duch und wech.
glaubt, dass er ein Vöglein wär, so irrt sich der..." die lange Version kann sich jeder ohne Mühe im Net ansehen.
-
Thread
Controller mit Ethernet
auf irgendwelchen Bastelboards gemacht, aber immerhin nicht nie: https://www.olimex.com/Products/IoT/ESP32-GATEWAY/open-source-hardware https://www.olimex.com/Products/IoT/ESP32-EVB/open-source-hardware
CrumbX1-Net Module, falls du AVR Mikrocontroller bevorzugst.
-
Thread
Atmega328P ADC Problem
>Was soll das tun? Das habe ich aus dem [[ADC Tutorial]] - https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Analoge_Ein-_und_Ausgabe#ADC_.28Analog_Digital_Converter.29 aus Verzweiflung übernommen, da es nicht funktionierte.
[c] #define F_CPU 8000000 #include <avr/io.h> int main(void) { // ADC-Setup Register komplett hingeschrieben, dann muss ich nur noch 1 und 0 eintragen ADMUX = 0<<REFS1 | 1<<REFS0 | 0<<ADLAR | 0<<MUX3 | 0<<MUX2 | 0<<MUX1
-
Thread
RS485 Differenz simulieren mit Atmega360p
> Mit 2 IO-Ports kommt irgendwie Mist bei raus. Was passiert konkret? Wie sieht die Generierung der Signale aus?
einzige gültige Flanke. Sieht trivial aus aber nur mit der negation der bits läuft das. #include <avr/io.h> DDRD = B00111000;//outport mask //RS485 Trigger void Trigger(void) { PORTD = (1<<PIN4) | ~(1<<PIN5); delayMicroseconds(10);//ggf. anpassen PORTD = ~(1<<PIN4) | (1<<PIN5);
-
Thread
xmega scanf gcc nutzbar machen
den Beiträgen, hier im Forum, kann ich schon printf benutzen. (Danke) https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Die_Nutzung_von_sprintf_und_printf Das füge ich mit "include uart_putchar.h" in meinen Projecten ein. Als "Anfänger" reicht mir das. Hauptsache es funktioniert. #ifndef UART_PUTCHAR_H #define UART_PUTCHAR_H #include <avr/io.h> #include <stdio.h> #include <stdint.h> //----------------------------------------------------------------------------------------- // damit geht dann auch "printf" // C:\Program Files (x86
-
Thread
PWM mit 455kHz
Trägerfrequenz von 455kHz. Im Moment schaffe ich nur 245kHz. Ich benutze einen Atmega 328p. [c] #include <avr/io.h> #include <avr/interrupt.h> #define F_CPU 16000000 int main(void) { DDRB =0b00000001; DDRB = (1<<PB0); // Timer 0 konfigurieren TCCR0A=(1<<WGM02) | (1<<WGM01)| (1<<WGM00);
IRMP unterstützt wird, oder die FB namens "Video Terminal Bang&Olufsen": https://www.mikrocontroller.net/articles/IRMP#B.26O Und ja, B&O verwendet wirklich 455kHz. Es wird aber einfacher sein, IRMP zu kompilieren, als alles selbst zu erfinden.
-
Thread
Schaltplan PWM-BTS555
https://www.mikrocontroller.net/attachment/170351/Akkusaver.GIF Hier ist der BTS555 über einen Schutzwiderstand direkt am IO Pin eines ICL... Das kannst du so an einen AVR packen.
Safari schrieb im Beitrag #5484579: > https://www.mikrocontroller.net/attachment/170351/... > > Hier ist der BTS555 über einen Schutzwiderstand direkt am IO Pin eines > ICL... Das kannst du so an einen AVR packen. Danke! Das wäre natürlich die bequemste Lösung!
-
Thread
UV LED Belichter
KEY_M 2 #define KEY_SP 1 #define KEY_START 0 /********** knopf.c***********/ #include <avr/io.h> // Muss immer sein #include <inttypes.h> // Fuer Datentype #include <avr/interrupt.h> // Fuer Interrupt #include "knopf.h" #include "main.h" void init_knopf(void){ PORT_KN_U
Diskussion für den "Besseren LED-Belichter" immer wieder auftaucht. https://www.mikrocontroller.net/articles/Belichter https://www.mikrocontroller.net/articles/LED-Belichter Es ist einfach falsch, was da geschrieben steht. Das Licht muss möglichst paralell sein und sollte möglichst senkrecht
-
Thread
SPI Flash Programmer
PS: Gerade vergessen: Dein AVR ist ja ein Microchip AVR, der per UPDI programmiert wird. Daher bitte das "wie den AVR auch" streichen. Du bräuchstest ein 10-poliges TagConnect Kabel. GND VTarget AVR Reset SPI CS SPI SCK
Frank K. schrieb im Beitrag #5481249: > PS: Gerade vergessen: Dein AVR ist ja ein Microchip AVR, der per > UPDI > programmiert wird. Daher bitte das "wie den AVR auch" streichen. > > Du bräuchstest ein 10-poliges TagConnect Kabel. > > GND > VTarget > AVR Reset
-
Thread
Custom Microcontroller Board (Cortex M4 oder ATMega2560)
Varianten. Es gibt dafür reichlich Hardware, z.B. St-Link. Die emöglichen oft auch Debugging, was bei AVR den teuren Atmel-ICE benötigt. Keine Ahnung was davon in der Arduino-IDE funktionert - ich bin Eclipse-User.
, daher werde ich den USB-Anschluss wohl nur optional drauf machen. (Quelle: https://www.hackster.io/turtle-rover/wireless-programming-and-debugging-with-stm32-and-rpi-bddfa5) Vielen Dank für eure Unterstützung, ich werde das mal die Tage ausprobieren, sobald die Teile da sind.
-
Thread
irsnd Callback function
8000000UL -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -MD -MP -MT irsnd-main-avr.o -MF dep/irsnd-main-avr.o.d -c ../irsnd- main-avr.c ../irsnd-main-avr.c: In function 'main': ../irsnd-main-avr.c:96:5: warning: implicit declaration of function 'irsnd_set_callback_ptr' avr-gcc
uint8_t; typedef unsigned short uint16_t; # endif #endif #if defined(ATMEL_AVR) # include <stdint.h> # include <stdio.h> # include <avr/io.h> # include <util/delay.h> # include <avr/pgmspace.h> # include <avr/interrupt.h> # define IRSND_OC2 0