-
Thread
Versuch einer Millis Funktion für AVR
Veit D. schrieb im Beitrag #7940506: > https://github.com/modm-io/avr-libstdcpp So wie ich die dortigen Maintainer verstehe, ist dieses Projekt auf modm-io designed. Mann kann sich damit also nicht einfach eine avr-g++ Toolchain basteln. Siehe auch dortige Bugreports
. schrieb im Beitrag #7940515: > Veit D. schrieb im Beitrag #7940506: >> https://github.com/modm-io/avr-libstdcpp > > So wie ich die dortigen Maintainer verstehe, ist dieses Projekt auf > modm-io designed. Mann kann sich damit also nicht einfach eine avr-g++ > Toolchain basteln. Siehe auch
-
Thread
Commodore C128
https://www.zimmers.net/anonftp/pub/cbm/maps/index.html
ich benutze auch die AVR´s aber der C64 und der 128 macht einfach mehr Spaß.
-
Thread
Ansteuern ws2812 mit dem SuperMini ESP32-C3
Information. MfG ein 80 jähriger erwartungsvoller alter knacker P.S. https://www.mikrocontroller.net/topic/560572#7517662
Tablet ist > dann sehr hilfreich. Ach komm, da geht doch noch was. https://www.mikrocontroller.net/topic/goto_post/7255683
-
Thread
direkt in ein Register des Tiny5 schreiben
Svensson schrieb im Beitrag #7935266: > Ich habe in meiner IDE keine vorgegebene io.h für den Tiny5. Aber die avr-libc bringt die Header mit. [c] #define __SFR_OFFSET 0x00 #define _SFR_IO8(io_addr) ((io_addr) + __SFR_OFFSET) #define PCMSK _SFR_IO8(0x10) #define PCINT0 0
schrieb im Beitrag #7935411: > aktuell ist gcc-15.2.0 von 2025-08-08 [pre]~$ find /usr/lib/gcc/avr/ /usr/lib/avr -iname "iotn5*.h" -exec grep -E "tiny|PCMSK" {} \; /* avr/iotn5.h - definitions for ATtiny5 */ #ifndef _AVR_ATtiny5_H_ #define _AVR_ATtiny5_H_ 1 #define PCMSK _SFR_IO8(0x10) #endif
-
Thread
AVR128DB USART Transmit Buffer
zu eins zum USART eines ATMega mit dem DRE interrupt und so war es einfach nur ein Übersetzung der IO Adressen und der Status bits. Gewisse Treiber auf der PDP-11 Seite haben sich darauf verlassen, dass es nur ein Byte war und das funktioniert dann natürlich nicht wenn ich den Code auf einen AVR DA oder
5usec. Das schafft der AVR auch.
-
Thread
Günstige Möglichkeit 10 Räume Temperaturmäßig zu überwachen
Telefonadern, die Software selbst geschrieben mit Hilfe von einigen Sourcen in einem Webserver auf AVR (NETIO). Hat sich aber überholt, müßte man heute auf was Stärkeres aufsetzen als AVR.
Ich habe so etwas ähnliches realisiert und getestet: https://www.mikrocontroller.net/topic/537955#new In den ersten zwei Jahren (2022 und 2024) lief das alles ohne Probleme. Die eingestellte Temperatur zum Einschalten war 4 Grad und zum Ausschalten 5 Grad.Als Heizungslüfter habe
-
Thread
8 mal 1bit zu einmal 3bit zusammenfassen
kann. Obwohl sein eigener Screenshot das ebenso so belegt, wie meiner. https://www.mikrocontroller.net/topic/580003#7930691
Peter D. schrieb im Beitrag #7931678: > Ich wollte erst einen AVR nehmen, der kennt aber keine Repeat-Macros. Natürlich kennt ein AVR keine Makros. Der richtige AVR-Assembler (GNU) aber schon!
-
Thread
Schrittmotor und Treiber für Drehkondensator
Bedarf einige Schritte vor und zurückdrehen um nachzuregeln. Das kannst Du gut mit einem kleinen AVR machen. Viel Erfolg Gruß Carsten
1.8° daneben ungefähr cos(1.8) oder so. Güte ist mir klar! Siehe auch: https://www.mikrocontroller.net/topic/146415 Gruss Chregu
-
Thread
DIY IR Receiver USB
https://web.archive.org/web/20160401061231/http://www.cesko.host.sk/IgorPlugUSB/IgorPlug-USB%20%28AVR%29_eng.htm#Download
basierende Lösungen auf der Website. https://www.huitsing.nl/irftdi/ https://usbirboy.sourceforge.io/ https://dicks.home.xs4all.nl/avr/usbtiny/ Mit IRMP kann man das IR-Protokoll aber auch komplett im µC abhandeln und zum Host hin sich als USB-Keyboard ausgeben. Dann spart man sich LIRC.
-
Artikel
KiCad
Widerstand, wo der "Widerstand" als Kupfer auf der Leiterplatte existiert. Es ist sinnvoll, zu den "Net tie" Footprints auch entsprechende Schaltplansymbole zu definieren. Zu Net ties siehe: (in Englisch) "KiCad zwei verschiedene Netze verbinden in Pcbnew" hier im Forum. Etwas aktueller (geht auch auf
Perversionen. Stehend, liegend, rumgedreht von der Rückseite usw.... LPC21xx / LPC22xx / LPC23xx | EINE AVR ATmega-Bibliothek, wo ALLE Controller drin sind. * AVR XMegas | AT90CAN128 / allgemein mehr AVRs (MEGA & TINY) * Wegen der AVRs und ATMEGAs: Bitte hier mal schauen, und den Wunsch auf den Typ konkretisieren
-
Thread
Z80 - Bytedefinition mitten in Assemblerdatei
Hallo, ich bin auf https://wikiti.brandonw.net/index.php?title=Z80_Routines:Math:Square_root auf ein Assemblerprogramm zur Wurzelberechnung gestoßen. Dabei ist mir Bytedefinitionen mitten im Programm aufgefallen, auf die ich mir keinen Reim machen
Wiedermal ein geiler Thread auf mikrocontroller.net! Im Osten wurden Programme oftmals mit ner Sprungtabelle am Anfang des Programmes mit Sprüngen auf die einzelnen Funktionen implementiert. War das damals ne Ost-Mode oder war soetwas auch
-
Thread
Problem mit ADUM1201 und FT232
beteiligt sein, denn das STK500 hat einen normalen RS232 Anschluss. https://www.mikrocontroller.net/articles/Netiquette#Klare_Beschreibung_des_Problems > Es gibt keine Verbindung zwischen J3 und U2 und auch keine zwischen U2 > und U3. Bei J3 steht TXout und RxOut. Die sind nur ausschließlich an
finde übrigens einige der erhältlichen 328PB Module etwas enttäuschend, weil man meist nicht die extra IO-Pins zugänglich machen will. Ein Manko beim Pro-Mini ist auch der fehlende Zugang auf den AREF-Pin. Gruß, Gerhard
-
Thread
Speicherverwaltung bei modularer Echtzeitsoftware
weniger Programmspeicher und weniger Laufzeit, wie bereits hier ausgeführt: https://www.mikrocontroller.net/topic/579838#7925576 Ich hatte auch schon erwähnt, dass neuere C-Versionen VLAs nicht mögen. > Johann L. schrieb im Beitrag #7925667: >> Zum Beispiel >> könnte man mit avr-gcc in allen Teilmodulen
RAM-Verbrauch erst zur Laufzeit ergibt. Zur Abschätzung hilf dann z.B. https://avrdudes.github.io/avr-libc/avr-libc-user-manual-2.3.0/group__util__ram__usage.html
-
Thread
Ampelschaltung für Hot Wheels Bahn
Man braucht keinen STK500 wie für das oben von mir gepostete Beispiel. https://www.mikrocontroller.net/topic/579809#7925614 Das war die Kernaussage. Aber ausprobiert habe ich den Digispark noch nicht. Kann noch ein kleiner Typo auf der Webseite sein. Sieht aber so auf den ersten Blick schon recht gut
-----------------' [/pre] Und der Code samt Powerdown nach 5 min sieht so aus: [c] #include <avr/interrupt.h> #include <avr/io.h> #include <avr/sleep.h> #define F_CPU 128000L // Oszillator: Watchdog #include <util/delay.h> #define TASTER 0x08 int main(void) { PORTB = 0b1000;
-
Thread
Atmega640 (5V) an Flash SOIC (3,6V)
Ich würde einen aktuelleren AVR wie den AVR64DB64 verwenden. Der kann auch bei niedrigeren Betriebsspannungen mit voller Geschwindigkeit laufen. Zusätzlich hat der Multivolt-IO, d.h. Du kannst den Prozessor selber mit einer Spannung betreiben und einen Teil der IO-Pins mit einer anderen. Außerdem: Der ATMEGA640-16AU kostet bei Digikey 8.87€ Der AVR64DB64T-I/PT kostet bei Digikey 1.81€ Die alten Teile kann man immer noch kaufen, aber Microchip macht sie
-
Thread
Meinung zu dieser Produktidee?
obwohl von der IDE unterstürzt. Alleine die Anzahl verschiedener µC macht es arg/zu vielfältig. AVR, ARM, ESP, RISC-V, Intel usw. Aus dem Nähkästchen: Habe meiner Arduino IDE beigebracht, wenigstens für AVR, bei jedem Compilerlauf auch gleich eine ASM Datei zu erzeugen. War schon in einigen
Karl B. schrieb im Beitrag #7919481: > Z.B. ALU. Mit 74181 Dazu passt: https://cdn.hackaday.io/images/1555791600527264361.JPG ...später vielleicht mehr dazu
-
Thread
"Radio-Buttons" in TTL/CMOS-Logik
#7918725: > Muss ich nachher in der Mittagspause mal kurz ausprobieren... Habe fertig: [c] #include <avr/io.h> #define F_CPU 16000000L #include <util/delay.h> int main(void) { DDRB = 0x0F; // B3..0 = Taster uint8_t pb = 0; while(1) { if (pb != (PINB&0xf)) { // hat sich
bit-Controller die letzten Bits abzutrotzen, der möge hier weiterlesen: https://www.mikrocontroller.net/topic/571835
-
Thread
AVRisp mkII (und STK 500) wird nicht erkannt
läuft unter Win10 Pro mit dem libusb-w32 von Zadig. Und zwar mit MC Studio 7 als auch mit PlatformIO.
Nemopuk schrieb im Beitrag #7918432: > Lohnt sich der Aufwand? Wie oft hast du dir einen AVR verfused? Mir ist > es 2 mal passiert, danach nie wieder. Nunja... Dank unangenehmer Realität musste ich mal (bei einer t85 Kleinserie) den Reset als Zusatz IO nutzen. Kein Platz für einen Bootlader
-
Thread
S: kleinen Mikrocontroller ohne Hühnerfutter für einmaligen Einschaltimpuls
USBasp-Firmware drauf ist, dann geht das. Wichtig: Beim USBasp liegt TPI-Data auf MOSI, beim Atmel AVR ISP mkII auf MISO (das hat mir mal viele graue Haare spendiert) https://www.mikrocontroller.net/topic/564134#new Ich mache recht viel mit dem Attiny10: https://github.com/SebiR/ATTiny10_Playground
Wie wäre es mit 6 Pins? https://www.electronicspecifier.com/products/micros/atmel-expands-6-pin-avr-microcontroller-family
-
Thread
Compileroptionen
; [/c] [pre] In file included from c:\arduino_portable_1.8.13\portable\packages\arduino\tools\avr-gcc\7.3.0-atmel3.6.1-arduino7\avr\include\avr\io.h:99:0, from c:\arduino_portable_1.8.13\portable\packages\arduino\tools\avr-gcc\7.3.0-atmel3.6.1-arduino7\avr\include\avr\pgmspace.h
mir tat es halt "ALTROSA", was ich als pragmatische Lösung empfand. https://www.mikrocontroller.net/topic/536231#new
-
Thread
Alarmton/Buzzer-Dreiklang erzeugen
Hab jetzt was ausprobiert, das geht ungefähr in die Richtung. [code]#include <avr/io.h > #define F_CPU 16000000L #include <util/delay.h> const int button_pin = 1; void A (void) { for (int i = 0; i < 20; i++) { // A: 2kHz, 50ms PORTB |= _BV(0); _delay_us(5000)
[c] #include <avr/io.h > #define F_CPU 16000000L #include <util/delay.h> const int button_pin = 2; void A (void) { for (int i = 0; i < 20; i++) { // A: 2kHz, 50ms PORTB = 0x01; _delay_us(3000);
-
Thread
Wie ist PORTB implementiert?
avrlibc. Für den ATmega8 steht sie in der Datei iom8.h und lautet 0x18. [code]#define PORTB _SFR_IO8(0x18)[/code] Das Makro _SFR_IO8 ist in der Datei sfr_defs.h definiert und addiert je nach verwendeten AVR noch einen Offset hinzu, in meinem Fall beträgt der Offset 0x20. Danach wird diese Zahl (
_.h enthält die class PortImplementation{}, die die Funktionalität enthält. Das Makro AUTO_IO_REG_WRAPPER stellt die Verbindung zu avr.io her. . der PortC wird deklariert mit: [c] namespace Private { AUTO_IO_REG_WRAPPER (PORTC, OutC, uint8_t); AUTO_IO_REG_WRAPPER (DDRC, DirC
-
Thread
Elektronische steuerung von 3 Relais.
den Tiny85, sogar mit "richtiger" Tastenentprellung per Mehrfachabfrage des Tasters: [c] #include <avr/io.h> #define F_CPU 8000000L #include <util/delay.h> int main(void) { int ec = 0; // Entprellcounter DDRB = 0x0e; // B0 = Taster / B1,2,3 = Schaltausgang 1,2,3 while(1) { PORTB
ganz zum Schluss nun die Variante mit einer Funktion, die auf den Tastendruck wartet: [c] #include <avr/io.h> #define F_CPU 8000000L #include <util/delay.h> void Warte_auf_Tastendruck(void) { while (!(PINB&1)); // Warten, wenn Taster gedrückt _delay_ms(50); // "Entprellzeit" while (
-
Thread
SPI Display am Attiny 3216
ausschalten korrekt funktinieren, leider geht es nicht: [c] #define F_CPU 10000000UL #include <avr/io.h> #include <util/delay.h> #define DC_PIN PIN1_bm // PA1 #define DC_PORT PORTA #define RESET_PIN PIN1_bm // PC1 #define RESET_PORT PORTC #define CS_PIN PIN3_bm // PC3
brauchst eine Source die gleich ohne CPP daherkommt. Hier im Anhang ist ein komplettes Projekt fürs AVR Studio und den ATMega2560. Es stammt aus diesem Thread: https://www.mikrocontroller.net/topic/327600#5215281 Dort kann man übrigens auch noch einiges lernen ... Natürlich musst du die SPI-
-
Thread
ATTiny85 als Oszillator (8.192 MHz XTAL, output 2.048 MHz)
PB1 oder PB2. Da > sollte ja eigentlich eine Interrupt-Routine mit OCR0x genügen. [c] #include <avr/io.h> void setup_timer0_toggle_2048mhz() { // Set PB0 (OC0A) as output DDRB |= (1 << PB0); // Timer0 in CTC-Modus (Clear Timer on Compare Match) TCCR0A = (1 << COM0A0) | (1
> darstellt. Dafür reicht die von WK verlinke Variante dicke aus. https://www.mikrocontroller.net/topic/578869#7902953
-
Thread
24V 1ms Impuls verlängern
Optokoppler Auswerten und Nein, der schaltet keine femtosekunden, sondern immer behäbig genug damit ein AVR PinChange auf jeden Fall mitkommt. Also Lutz: lern programmierrn.
Mit den aktuellen AVR ist alles viel einfacher. https://www.mikrocontroller.net/attachment/615726/AVR_TCB.png
-
Thread
Anzeige wen Briefkasten geöffnet wurde.
ist Stromversorgung und Meldung nach innen möglich. 2. Es gibt sparsame weitreichende Funken mit AVR auf 433MHz. 3. Es gibt ESP32 mit Cam & LED zur Beleuchtung, die an den AVR das Sende Kommando absetzen können. Speisung kann im Briefkasten durch eine LiIo erfolgen, gleich mit Spannungsmessung auch
Relaxationsoszillator praktisch ständig der Fall ist. Siehe auch den https://www.mikrocontroller.net/topic/576457. Ebenfalls relevant: https://www.mikrocontroller.net/topic/576144 und https://www.mikrocontroller.net/topic/511772#7850323 ff
-
Thread
Arduino CH32V003
Speicherverbrauch des Framworks scheint exorbitant: Der Grund dafür: https://www.mikrocontroller.net/topic/577068#7861664
Arduino-IDE nutzen, um Bare-Metal Assembler zu programmieren: Code: https://www.mikrocontroller.net/topic/578335?goto=7899234#7889328 Assembler-Script: https://www.mikrocontroller.net/topic/578335?goto=7899234#7899234
-
Thread
Einschalten der Mikrocontroller-Betriebsspannung
Es gibt dann noch solche, die per Fusebit den externen Reset disablen können, um einen zusätzlichen IO-Pin zu erhalten.
Hier ist dann zu sagen, dass das Konzept des Bootsektors von WCH ein anderes ist, als bspw. bei den AVR's oder den STM32. Bei AVR ist der Bootbereich hinter dem Userbereich und ist ein Userprogramm zu lange und man hat irgend etwas "verbockt", kann man den Bootbereich beim AVR locker überschreiben (und
-
Thread
ATMega328PB lässt sich nur noch programmieren. Sonst keine Funktion mehr
Sicherungswiderständen ... Sicherungswiderstände? Was sollen das für spezielle Dinger sein? Die Widerstände in AVR042 Fig. 4-2 sind ganz normale Widerstände.
10k-Widerstand reicht normalerweise völlig aus und ist auch keine "minimalistische Notlösung", siehe AVR042. Felix N. schrieb im Beitrag #7892759: > Wobei die Schutzdiode ja HV-Programming nicht mehr möglich macht > korrekt? Solange man vor dem Setzen der Fuses nachdenkt, braucht man HV-Programming
-
Thread
Wie baut man in C Strings zusammen?
Abhängigkeiten von sprintf, allerdings kein Startup-Code und keine Vektortabelle. https://avrdudes.github.io/avr-libc/avr-libc-user-manual/benchmarks.html Die 16k von Pandur sind also aus dem Finger genuckelt. Aktuellere Benchmarks mit AVR-LibC v2.3 + avr-gcc v15 bleiben bei ca 3 KiB für sprintf + float
man strncat() https://linux.die.net/man/3/strncat
-
Thread
Attiny 412 ext. Interrupt triggert ohne event
Oh, da hab ich wohl vergessen den Code hochzuladen. [c] #include <avr/io.h> #include <util/delay.h> #include <avr/interrupt.h> #include <avr/sleep.h> // Required for sleep modes #include <stdint.h> // For standard integer types, e.g., uint8_t // --- Pin Definitions
IrgendSoEinTyp I. schrieb im Beitrag #7886697: > Bin ich noch relativ neu in der AVR Programmierung und weiß nicht wie > ich ein Byte ohne großen Overhead versende. ATtiny402/412 send byte: [c] #include <avr/io.h> uint8_t data[13] = {72,101,108,108,111,44,32,87,111,114,108,100,33
-
Thread
Messwerte mit 8266 an InfluxDB übertragen
Lichtschaltern kommt beim Tastendruck eine entsprechende cmnd/... Meldung. https://tasmota.github.io/docs/MQTT/#fulltopic Etliche DS1820 sowie Wechselrichter habe ich noch an einem AVR (Pollin AVR-NET-IO) in meiner HA. Diese senden ebenfalls über ethersex MQTT Nachrichten (https://github.com/rPraml
-
Thread
"Arduino kompatibler" MC für 2025
Soweit ich weiß, dümpelt Arduino noch mit der AVR-GCC Version 7.3 rum. Mit C++11 Bei mir, meiner Arduino IDE, ist mittlerweile eine AVR-GCC Ver. 15.x im Einsatz. Mit C++20 Also selbst wenn es keine 16er GCC Version für AVR geben wird, wird die AVR Unterstützung in der Arduino IDE nicht sterben, sondern nur (noch mehr) Staub ansetzen.
-
Thread
FPGA Feedforward-System in Quantenoptik-Experiment
Takt-Verdrahtung und Banknutzung gibt es zwischen den Laufzeiten dann durchaus 200ps zwischen zwei IO-Pins, wenn man parallel anschließt. Die gehen dann direkt vom budget ab. Wenn man damit Video machen will (BTDT) kommt man schon bei 148MHz in Bedrängnis und muss den Betriebsbereich der Temperaturen
neuer Spass. Dann muss man schauen, ob man das mit Regelschleifen hinbekommt, Trainingsphasen für die IO-delays an den Spartan6 Pads bspw..
-
Thread
ADC-Kanäle sukzessive abfragen
und speicherst es z. B. in einer globalen Variable. 📜 Beispielcode in C (für Atmel Studio oder avr-gcc)" [c] #define F_CPU 16000000UL #include <avr/io.h> #include <avr/interrupt.h> volatile uint16_t adc_result = 0; void adc_init(void) { ADMUX = (1 << REFS0); // AVcc als Referenz,
erleichtern. Vielleicht liest der Autor dieser Seite ja gerade mit? https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Analoge_Ein-_und_Ausgabe#Der_interne_ADC_im_AVR
-
Thread
Welchen SmartMeter für DC (PV und Speicher)
Ich habe es mal aufgezeichnet. Zeichne das mal in deinen Plan ein: https://www.mikrocontroller.net/topic/577940#7880002 fehlt ja der ESP Netzteil Ground verbindungen etc...
www.pollin.de/p/aktiver-stromsensor-vacuumschmelze-t60404-n4646-x66282-15-a-5-v-180070 Danach kleiner AVR mit LC-Display (Smarthome brauche ich nicht) Der Sensor stimmt fast bis aufs mA mit dem Strom überein, den mir der Modbus meines WR liefert.
-
Thread
Arduino Uno Bootloader verwenden
diese nicht benutzen kann. Man muss nur wissen wie es geht, wie immer. https://www.mikrocontroller.net/articles/AVR_In_System_Programmer#ISP-Pins_am_AVR_auch_f%C3%BCr_andere_Zwecke_nutzen
https://www.mikrocontroller.net/articles/AVR_Bootloader_FastBoot_von_Peter_Dannegger Oliver
-
Thread
Suche IO over IP
Verteilerdose" aber recht ungenau ist und auch mal etwas größer sein kann wäre hier vielleicht schon ein AVR Net-IO ausreichend. Software könnte natürlich in Eigenbau ausarten.
Ich habe sowas schon auch mal in ein einer anderen Anwendung mit der Kamera von Mobotix über deren IO Karte gemacht. Eine Mobotix Kamera kostet 400 Euro und die IO Karte dazu noch mal 80. Einfache IO Funktionalitäten mit und ohne Kamerabezug kann man dort auch über ein Menü konfigurieren. Aber ich bin
-
Thread
Arduino Nano Störungen und Durchbrennen
mal einen 10k Widerstand davorschalten, damit eine Überspannung nicht die Eingangsschutzdioden im AVR killt.
dabei gedacht ... Nö, die haben dumm kopiert, incl. der Fehler. https://www.mikrocontroller.net/articles/Relais_mit_Logik_ansteuern#230V_Netzspannung_schalten
-
Thread
ESP32-WROOM-32 Flash-Größe
Schaltkreise gibt, die ich einsetzen wollte > (I2C ADC und DAC). Schau dir mal VS Code + PlatformIO an.
ADC2 verträgt sich nicht > mit WiFi. aber das weißt Du ja bereits https://www.mikrocontroller.net/topic/558387#7476677
-
Thread
=== GCC v15 ===
98 cbi 0x08, 0 ; 8 // pull CS 3de: f5 df rcall .-22 ; 0x3ca <Fl::AvrIO::AvrSpiMaster<Fl::AvrIO::PinX<(unsigned char)0, Fl::AvrIO::PortX<38> > >::txRaw(unsigned char)> 3e0: 8c 2f mov r24, r28 3e2: f3 df rcall .-26 ; 0x3ca <Fl::AvrIO
<Fl::AvrIO::AvrSpiMaster<Fl::AvrIO::PinX<(unsigned char)0, Fl::AvrIO::PortX<38> > >::txRaw(unsigned char)> 3fe: 40 9a sbi 0x08, 0 ; 8 // release CS 400: 21 96 adiw r28, 0x01
-
Thread
6502 Emulator Arduino
6502/6502_instruction_set.html#INX Online Simulator und Tutorial: https://skilldrick.github.io/easy6502/
Endergebnis drucken. Das ganze bezieht sich auf den Wettbewerb hier: https://www.mikrocontroller.net/topic/577155 edit: Die Rechenzeit, wenn man nur das Endergebnis ausgibt: 0.79 Sekunden
-
Thread
AVR ATtiny Serie 1: Input Capture TCD0
Hat mal jemand auf den AVR ATTiny der Serie 1 einen Input Capture auf Timer/Counter D, also TCD0 umgesetzt? Man muss das im datasheet spärlich dokumentierte Event-System konfigurieren. Wollte ausgehend von einem Flankenwechsel
AVR32EA32-I/RXB VQFN-32 5×5mm Two 16-bit Timer/Counters type A (TCA) Four 16-bit Timer/Counters type B (TCB) (DigiKey: 1,04 € + MwSt.)
-
Thread
Tiny1 Serie Bootloader Segmentierung Flash geht nicht?
Halbsekundentakt getoggelt. An einem der GPIOs hängt eine LED, die blinken sollte: [c] #include <avr/io.h> #include <avr/cpufunc.h> #include <util/delay.h> #include "fuses.h" int main(void) { // 16 MHz / 4 = 4 MHz ccp_write_io((uint8_t *) &(CLKCTRL.MCLKCTRLB), CLKCTRL_PEN_bm | CLKCTRL_PDIV
Wortadresse 0x80 im Loader und sprngst dahin, das ist aber Byte-Adresse 0x100. Anstatt ccp_write_io würde ich lieber _PROTECTED_WRITE, weil kein Funktionsaufruf im Loader: https://avrdudes.github.io/avr-libc/avr-libc-user-manual/group__avr__io.html#gaaaa396e67cc85f68fa0474d70edf3d4c
-
Thread
CH32V003, float wirklich langsam?
Ich gehe mal davon aus, dass es um float geht. Eine float Addition braucht 108 Cycles. Core avr2 braucht geringfügig mehr, nämlich 113 Cycles. Multiplikation kostet übrigens 138 Cycles (mit 8*8=16 MUL Instruktion bzw. 375 ohne MUL. https://avrdudes.github.io/avr-libc/avr-libc-user-manual
float-Werte hin-und-herschaufelt. https://avrdudes.github.io/avr-libc/avr-libc-user-manual-2.3.0/benchmarks.html#bench_libm Weil die Benchmarks keine Harware brauchen, kann man sie komfortabel auf einem Simulator ausführen. Hat dann den Vorteil, dass man keine
-
Thread
Moderne AVR (Nachfolger Atmega und Attiny)
, AVR32DU14, AVR32DU20, AVR32DU28, AVR32DU32. AVR-Ex: AVR16EA28, AVR16EA32, AVR16EA48, AVR16EB14, AVR16EB20, AVR16EB28, AVR16EB32, AVR32EA28, AVR32EA32, AVR32EA48. AVR-SD: AVR32SD20, AVR32SD28, AVR32SD32
, AVR64DA48, AVR64DA64, AVR64DB28, AVR64DB32, AVR64DB48, AVR64DB64, AVR64DD14, AVR64DD20, AVR64DD28, AVR64DD32, AVR64DU28, AVR64DU32, AVR64EA28, AVR64EA32, AVR64EA48, AVR64SD28, AVR64SD32, AVR64SD48, AVR128DA28
-
Thread
Bootloader mit Microchip Studio
ich. Dieses Verständnis mit zum Beispiel diesem Artikel abgeglichen? https://www.mikrocontroller.net/articles/AVR_Bootloader_in_C_-_eine_einfache_Anleitung#Der_%22echte%22_Bootloader
> Dieses Verständnis mit zum Beispiel diesem Artikel abgeglichen? > https://www.mikrocontroller.net/articles/AVR_Bootloader_in_C_-_eine_einfache_Anleitung#Der_%22echte%22_Bootloader Ja.
-
Thread
Atmega32 - PortPin geht nicht auf High wenn Pullup gesetzt
] * * Atmega32_Test.c * * Created: 06.04.25 20:20:37 * Author: Thomas */ #include <avr/io.h> int main(void) { DDRC = 0b11011111; // PortC Ausgänge - Bit 5 Eingang - Chip Quitierung PORTC |= (1<<PC5); // Pull Up an Pin27 - Chip issue aktivieren while(1) {
kein Problem, die Pins nachträglich zu ändern. Hier mal ein Beispiel: https://www.mikrocontroller.net/topic/292251#3113090