-
Thread
Atmega 328 Timer 2: Hilfe für Frequenzerzeugung
nachzuvollziehen. Alledings ohne Arduino-Framework, und ohne serielle Ausgabe. [c] #include <avr/io.h> #include <avr/interrupt.h> void setTimer2() // CTC, Mode 2 { cli(); // Interrupts ausschalten TCNT2 = 0; // Reset Register OCR2A = 249; // Compare
[C] #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #include <util/atomic.h> #define AtomicSection ATOMIC_BLOCK(ATOMIC_RESTORESTATE) void setTimer2_Arduino_PWM() { AtomicSection
-
Thread
gcc Kompiler
Wenn du in C programmieren willst, dann brauchst du avr-gcc: https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
/driver/linux/ethernet.c 23 src/config/board/avr-net-io.c 1054 total [/code] Wobei der 618 Zeilige enc28j60 Treiber sowie der dummy ethernet Treiber eigentlich auch Hardwareunabhängig sind, und der Rest ja Treiber für mehrere Plattformen umfasst
-
Thread
PWM mit ATtiny13 liefert SIN und COS
etwas Funktionalität hinzufügen (2 unabhängige Frequenzen, die 2. eben als COS): [c] #include <avr/io.h> #include <avr/pgmspace.h> #include <stdint.h> #define F_CPU 9600000UL // Quarz mit 9.600.000 MHz #define TIMERRELOAD 256 // Nachladewert des Timers 0-255 #define AUFLOESUNG
Hut. Den Vogel hat Atmel aber bei einigen neueren AVRs abgeschossen! https://www.mikrocontroller.net/topic/453218#5454730
-
Thread
Defekter CGRAM in HD44780 ?
> benutzt? Hi, Du meinst wahrscheinlich das ominöse Busy-Flag? https://www.mikrocontroller.net/topic/444803#5314513 ciao gustav
Busy-Flags (im Idealfall sogar deutlich) kürzere Transferzeiten gegen die Notwendigkeit eines zusätzlichen IO-Pins. Falsch ist nur, weder das eine noch das andere zu tun. Das geht dann halt oft schief...
-
Thread
Header .c .h einbinden funktioniert nicht ?
Tim T. schrieb im Beitrag #5754274: > Es fehlen #include <avr/io.h> und #include <stdint.h> Letzters fehlt nicht weil es schon in Ersterem enthalten ist. Also im Prinzip fehlte nur das #include <avr/io.h> in der I2C.h ;)
M. K. schrieb im Beitrag #5754300: > Tim T. schrieb im Beitrag #5754274: >> Es fehlen #include <avr/io.h> und #include <stdint.h> > > Letzters fehlt nicht weil es schon in Ersterem enthalten ist. Also im > Prinzip fehlte nur das #include <avr/io.h> in der I2C.h ;) Prinzipiell richtig, aber
-
Thread
ESP8266 mit Kabel
und fertig mit Ethernet ähnlich > dem ESP8266 bei WLAN? https://www.chip45.com/products/crumbx1-net_avr_xmega_module_board_atmega128d3_embedded_internet_ethernet_webserver_usb.php?de Aber bitte mit meiner aktuellen Firmware von http://stefanfrings.de/net_io/index.html Ansonsten gibt es noch
Dank eurem Suchbegriff: https://www.mikrocontroller.net/topic/442157
-
Thread
Messungen von Funksignalen auf Pikosekunden genau
Laufzeitunterschieden arbeiten und die weit unterhalb der 10k€ anzusiedeln sind: https://www.localino.net/de/
einer Raumsonde auch ein Arduino > nehmen. Sind halt aber nicht gehärtet gegen Strahlung. Der alte AVR mit seinen vergleichsweise klobigen Strukturen wird aber wahrscheinlich länger durchhalten als ein moderner ARM von heute.
-
Thread
sketch stört webserver - wer kann helfen?
bei mir auf pic16/18, avr, stm, arm oder auch auf jeden host. http://www.cocoos.net der stefan hat unter dem link mit viel mühe alles schön erklärt! mt
die > Strings nur im Flash Speicher liegen, nicht im RAM. > https://arduino-esp8266.readthedocs.io/en/latest/PROGMEM.html Das sollte beim ESP32 doch eigentlich egal sein, da dieser anders aufgebaut ist als z.B. AVR Controller. Wenn ich mich richtig erinnere werden die von dir genannten Marcos durch
-
Thread
VU-Meter, aber korrekt!
möchte gerne ein VU-Meter als korrektes Messgerät bauen. Insperiert von hier: https://www.hackster.io/ericBcreator/stereo-neopixel-ring-vu-meter-b28e78 Da wird der anzuzeigende Wert per leftValue = map(leftAnalogValue, minValue, maxValue, 0, maxSegments); rightValue = map(rightAnalogValue,
zusammengespaxt; das www ist voll davon. Ich nehm' mich da mal nicht aus:-) https://www.mikrocontroller.net/topic/419372 Gruss WK
-
Thread
Welchen CAN-Bus Microcontroller/Platine
http://www.chip45.com/products/crumb128-can-5.0_avr_atmega_modul_board_at90can128_usb_rs232_can.php
Sowas wie mein Unterputz IO Modul? http://www.kreuzers.home.dic.at/elektronik/E_CANopen.php Christian_RX7
-
Thread
ATmega8 mit Quarz 2MHz
Taktquelle musst du die Fuse Bits anpassen. Ist hier beschrieben: https://www.mikrocontroller.net/articles/AVR_Fuses Dabei kommts auf dein Programmiertool an, deswegen Vorsicht. Der Quarzanschluss ist hier beschrieben: https://www.mikrocontroller.net/articles/Quarze_und_AVR brauchst also
Hallo, habe jetzt Folgendes gemacht: fuse.c: #include <avr/io.h> FUSES = { .low = 0b11101101, .high = HFUSE_DEFAULT }; main.c: #define F_CPU 2000000 #include <avr/io.h> int main (void) { DDRB =0; DDRB |= (1<<PB1);
-
Thread
LM35 Temperature Error
ich initial eine Formel, um diese in Excel zu berechnen. 2. Hier... https://www.mikrocontroller.net/topic/415727#4849119 https://www.mikrocontroller.net/topic/45573#347724 ...ist die rede von Erwärmung durch Verlustleistung beim "power-pollen" Muss ich beim ADC mit dem LM35 ebenfalls aufpassen,
entsprechen. Macht sich natürlich am einfachsten als Gleitkommarechnung, aber das ist auf einem AVR an sich ja kein Problem (hast du möglicherweise ohnehin schon drin).
-
Thread
HDD Fragen zu DMA, Features usw.
Nostalgie^^ Derzeit beschäftige ich mich mit IDE/ATA Festplatten, https://www.mikrocontroller.net/topic/454789#new https://www.mikrocontroller.net/topic/449624#new Sektoren im CHS und LBA-Modus read/write funktioniert, nur bei 2 Platten read nicht möglich, trotz langer Wartezeiten, Ursache unklar
Geschwindigkeitsgewinn. Was Du jetzt nutzt, ist der PIO-Mode und der ist eben eine Folge einzelner IO-Zugriffe und entsprechend langsamer. PS: man war ich wieder langesam... ;) Gruß aus Berlin Michael
-
Thread
ATmega mit mehr Leistung?
Drama finde ich da ganz repräsentativ[1]. Auch wenn ich den STM32, wie ich oben ja schrieb, dem AVR aus vielen Gründen vorziehen würde, muss ich ja trotzdem nicht mit dessen Ressourcen arg verschwenderisch umgehen. [1] https://www.davidhaney.io/npm-left-pad-have-we-forgotten-how-to-program/
Version 4.19 von 2011. https://www.mikrocontroller.net/articles/Atmel_Studio#Direktlinks_Installer
-
Thread
AVR ADC Gain 2x gleicher Kanal
ausdenken. Datenblatt (Seite 145): http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-8495-8-bit-AVR-Microcontrollers-ATtiny441-ATtiny841_Datasheet.pdf Scheint aber nicht so zu sein, kommt immer 0x3ff raus. Einen Hinweis dazu habe ich hier gefunden: https://www.mikrocontroller.net/topic/285496
gegenüber GND), so dass es wohl nicht reicht, an einem anders genutzten IO-Pin Low auszugeben.
-
Thread
AS7 "recipe .elf failed" bei neuem Projekt
Solution. Ergebnis: "recipe for target 'Empty.elf' failed" Testweise selbst das "#include <avr/io.h>" rausgeworfen, keine Änderung. Virenscanner abgestellt und AS7 als Administrator gestartet, keine Besserung. Neustart habe ich natürlich auch probiert. In den Pfad-/Directorynamen sind keine
moderne Toolchain ist hier verfügbar: ----------------------------------------- http://blog.zakkemble.net/avr-gcc-builds/ PS: Der Ordner \shellutils von AS7 heisst in AS6.2 \shellUtils Ein normales Build schaut so aus: ******************************** ------ Build started: Project: AVR_Toggle,
-
Thread
Abfrage Taster durch USI vom Slave mit zwei AVR
komplette Code vom Slave: [c] #define F_CPU 16000000UL #include <stdlib.h> #include <avr/io.h> #include <avr/interrupt.h> #include <avr/pgmspace.h> #include "usiTwiSlave.h" #define slave_adresse 0x52 // Adresse Slave uint8_t byte1, byte2, byte3, byte4; uint16_t buffer
, T2 hole byte vom Slave, Anzeige am Port A */ #include <stdbool.h> #include <avr/pgmspace.h> #include "main.h" #include <util/delay.h> #include "i2clcd.h" #include "i2cmaster.h" #include "avr/io.h" #include "util/delay.h" #include "avr/interrupt.h
-
Thread
STM32 Umfang
Da gibt's alle möglichen Varianten und auch vorhandene Ansätze, z.B.: https://github.com/kvasir-io/Kvasir
fürchten, dass irgend etwas in den eigenen Projekten > kaputt geht. Im Prinzip ist das aber bei der avr-gcc toolchain ganz genauso. Natürlich brauchen auch die AVR einen Startup-Code und ein Linker-Script haben sie auch aber es ist halt alles Bestandteil des avr-gcc und der sucht sich dann die passenden
-
Thread
max. Input Frequenz ATMEGA328
Meint ihr das mit dem Interupt so: [c] // Definition of interrupt names #include < avr/io.h > // ISR interrupt service routine #include < avr/interrupt.h > // LED connected to digital pin 13 int ledPin = 13; // This is the INT0 Pin of the ATMega8 int sensePin = 2; // We need
doch nötig war. So geht es mir jedesmal (Ich rede jetzt nicht von uC Programmen sondern auf PC/.net/java/shell/etc).
-
Thread
Gibt es schon skalierbare Arduino 16-Segent Font-Lib ?
verlassen und es ginge mit 0b1110000 weiter. Bei dem "S" aus https://d144mzi0q5mijx.cloudfront.net/img/L/E/LED-16-SegmentA.png hingegen würde es nach 3x 0b11100000 mit der Überlagerung von 0b11100000 und dem Anfang der Diagonale weiter gehen. Einfach wird das sicher nicht !
Anfänger sogar hilfreich sind: - Der STM32 keinen speziellen Programmieradapter. Damit fangen bei AVR ja schon oft die Probleme an. Zu viel Auswahlmöglichkeit und die billigen taugen nicht für alle Fälle. - Der Adapter zum Debuggen kostet original ab 12€, aus Asien ab 2,50€ (bei AVR jedoch ab 50€)
-
Thread
W5100 Modul und SD-Card-Modul gleichzeitig an Mega 2560
Achim A. schrieb im Beitrag #5718783: > gibt es dazu (Soft-SPI) eine Anleitung? Die AVR FAT32 Library ist dafür bereits vorbereitet, dort ist es lediglich ein Konfigurationsparameter. https://www.mikrocontroller.net/articles/AVR_FAT32
Spannungsregler für die 3,3V der SD-Karte. Die Billigversionen ohne Pegelwandler sind bestenfalls für 3,3V IO gut, dann braucht man aber auch keine Längswiderstände.
-
Thread
Freier + kleiner Softcore gesucht.
Wie wärs mit https://www.mikrocontroller.net/articles/8bit-CPU:_bo8
Wobei SOC etwas übertrieben ist: Das ist nur die 6502 mit RAM, ein 32x32 VGA-Framebuffer und etwas IO-Hardware. Gerade genug, um die Beispiele laufen zu lassen. Das Programm wird beim konfigurieren des FPGA ins RAM geladen.
-
Thread
Ausgang auf "1" schalten, wenn Eingang auf "0" ist
definierten Eingangszustand! Den Rest kannst du dir hier mal anschauen: https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Zugriff_auf_IO-Ports Ansonsten: Was genau funktioniert denn nicht?
Richtig! bzw. passiert das meist automatisch Jörg B. schrieb im Beitrag #5716234: > und nicht die avr/io.h? Falsch! In der Arduino.h wird die avr/io.h eingebunden. Also Gesamtmaussage leider falsch. Jörg B. schrieb im Beitrag #5716234: > Letzteres ist namlich die avr-libc. Die AVR-LIBC steht
-
Thread
Librarys einbinden - glcd (Ks0108) Test
empfehlen? ich habe für dieses Projekt die Lib von Thiele gefunden: https://www.mikrocontroller.net/articles/KS0108_Library Meine Vorgehensweise war bisher wie folgt: - Zip von Thiele entpackt und in Ordner abgelegt - Neues Projekt mit mega8 in AtmelStudio erstellt - Code aus "ks0108Test.c"
1.1 * Description: KS0108 Library Demo Program * */ #include <inttypes.h> #include <avr/io.h> #include <avr/pgmspace.h> #include "ks0108.h" #include "arial_bold_14.h" #include "corsiva_12.h" int main(void) { // Wait a little while the display starts up for(volatile uint16
-
Thread
Atmega8A UART sendet nur Müll
String-Endezeichen(Terminator)" */ uart_putc(*s); s++; } } [/c] [c] //main.c: #include <avr/io.h> #include "uart.h" int main(void) { uart_init(); while (1) { uart_puts("Hallo"); } } [/c]
Lars schrieb im Beitrag #5713275: > //uart.c: > > #include <avr/io.h> > #include "uart.h" > > void uart_init(void) > { > UBRRH = UBRR_VAL >> 8; > UBRRL = UBRR_VAL & 0xFF; > > // UART TX einschalten > UCSRB |= (1 << TXEN); > //Frame Format:
-
Thread
ATmega2560 - LED blinkt nicht
ein einfache Blinky Programm zum Laufen zu bekommen. [c] #define F_CPU 1600000UL #include <avr/io.h> #include <util/delay.h> int main (void) { DDRB |= (1 << PB7); while(1) { PORTB ^= (1 << PB7); _delay_ms(500); } return 0; } [/c] Die Zeile in der
https://www.mikrocontroller.net/articles/AVR_Bootloader_in_C_-_eine_einfache_Anleitung
-
Thread
Von 2,4V auf 3V
https://www.mikrocontroller.net/articles/Pegelwandler
MCU ist es nur (Software-)SPI. UART findet zwischen SC16IS760 und Bluetooth-Chip statt. Da die AVR-Platine gegeben ist (Erweiterungs-Buchsenleiste mit: 3,3V, GND und 4 IO direkt vom AVR) muss das Erzeugen eines ausreichenden Pegels auf der zu entwickelnden 3,3V-Tochterplatine gelöst werden - optional
-
Thread
Nachfolger für ATMega gesucht
Aber braucht das eine Vielzahl der Anwendungen überhaupt? > Nein. Und deshalb reicht denen auch ein AVR. Der Bereich IO hat genau dafür gesorgt, dass ich mit den STM32 nie über das LED-Blinky hinausgekommen bin. Ich habe mir damals ein Discovery-Board gekauft, mir die Toolchain aufgesetzt und das mal
Appropos AVR kann nix und die 32er haben die besseren IO Möglichkeiten, also appropos "ihr habt alle keine Ahnung": IO Register des xmegas: PORTA_OUT PORTA_OUTSET PORTA_OUTCLR PORTA_OUTTGL PORTA_DIR PORTA_DIRSET
-
Thread
China SUPER Bauteile-Schnäppchen Thread [V4]
brauchbar. Offenbar werden Geräte mit falscher Meß-Induktivität verkauft. Zum Vergleich habe ich zwei AVR328 Multitester wie hier diskutiert: https://www.mikrocontroller.net/topic/345717. Diese können Kondensatoren im Bereich 100pF bis 100nF und Spulen im Bereich 100uH gut messen und die Werte aller drei
https://www.mikrocontroller.net/topic/546715#7270065
-
Thread
Arduino Custom Firmware für Fitness Armband mit NRF52
Ok, werde ich dann merken. Muss auch erstmal soweit sein. Ich versuch egerade mir etwas mit PlatformIO zu basteln da ich die Arduino Umgebung nicht mag. Und mit PlatformIO hab ich noch nie gearbeitet ;) Aaron C. schrieb im Beitrag #5798743: > Schrittzähler ist leider nicht einfach Hab ich auch
werde ich dann merken. Muss auch erstmal soweit sein. Ich versuch > egerade mir etwas mit PlatformIO zu basteln da ich die Arduino Umgebung > nicht mag. Und mit PlatformIO hab ich noch nie gearbeitet ;) PlatformIO habe ich bissher auch nicht verwendet, ich mag es da etwas einfacher, Arduino IDE
-
Thread
PORT/Register Beschreibung in AVR
https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Ausg.C3.A4nge
. https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#IO-Register_als_Parameter_und_Variablen Datenrichtung bestimmen. Da stehts. "... // übersichtliche Alternative - Binärschreibweise, aber kein ISO-C DDRB = 0b00011111
-
Thread
Welchen Parameter muss ich nutzen, um mit Arduino und DS18S20 ein Relais zu steuern?
glaube ich dir das du das total ernst meinst mit dem veräppeln. https://www.mikrocontroller.net/topic/467092?goto=5705518#5705372 kein loop in Sicht https://www.mikrocontroller.net/topic/467092?goto=5705518#5705517 loop in Sicht aber immer noch kein Serial.print
en/language/functions/digital-io/pinmode/ >
-
Thread
Makro für: PORTD |= (1<<PD1)
ist der Code ohne die sbit.h 106 Bytes und mit der Sbit.h nur 104 Bytes groß. Das sagt zumindest "myAVR ProgTool" beim brennen. eigentlich müsste der Code doch größer werden ?
Schau dir das mal an: https://www.mikrocontroller.net/topic/466560#5697577 Basic und C sjnd nunmal unterschiedliche Sprachen mit unterschiedlicher Syntax.
-
Thread
Attiny85 PWM
Als würde er nicht in den ISR springen. Manueles eischalten in der main klappt. [code] #include <avr/io.h> #include <avr/interrupt.h> int main(void) { DDRB |= ((1<<DDB0) | (1 << DDB1)); // Output // Timer Konfiguration TIMSK = (1<<TOIE0); //When the TOIE0 bit is written to one
Klappt es mit einem anderen AVR8 (so denn einer, hoffentlich, vorhanden ist)?
-
Thread
Rust - ist das hier um zu bleiben?
Den Code von crates.io kannst du forken und wie das mit den Mirrors geht steht auch auf der Github Seite von crates.io https://github.com/rust-lang/crates.io Deploying & using a mirror https://github.com/rust-lang/crates.io
crate.io abgelegt sind" Quelle: https://www.heise.de/developer/meldung/Programmiersprache-Rust-1-34-erlaubt-Alternativen-zu-crates-io-4398171.html
-
Thread
Terminal = Terminal?
unterschiedlich verhalten ... ein deutliches JEIN, ich "simuliere" hier Dinge, die eigentlich auf einem AVR ablaufen. Also möchte ich Eingaben wie Knopfdrücken über die Tastatur abhandeln. https://www.mikrocontroller.net/topic/466778 Grüße David
Linux nachbildet. Unter Linux kann man man das getch() von ncurses verwenden. https://linux.die.net/man/3/getch
-
Thread
LCD an MyAVR Board
Hallo Forum, Habe ein Problem. ich will das myAVR LCD-Zusatzgerät, mit dem myAVR Mikrocontroller und einem Programm (unten), hochzählen lassen. Habe nicht viel Ahnung vom Programmieren mit dem AtmelStudio. Es wird mir beim Überspielen einfach das
Dischinger //-------------------------------------------------------------------------- #include <avr/io.h> #include <util/delay.h> #define F_CPU 3686400 //------------------------------------------------------------------------- // lcd_enable() - setzt das Enable-Signal für eine Millisekunde
-
Thread
ESP8266-AT Firmware - TCP Verbindung - NetIO APP - Daten senden
Datum über NTP in meine Steuerung => FERTSCH * App-Entwicklung zur Bedienung meiner Steuerung über NetIO app: https://netioapp.com/de/projects/ Der ESP ist nur das Sende- und Empfangsglied zwischen meinem Tablet/Handy und der Steuerung. Die Datenübertragung geht vom ATmega über rs232 zum ESP und
index.html#atcommands In dem folgenden Buch am Ende von band 3 gibt es ein konkretes Beispiel mit AVR Mikrocontroller: http://stefanfrings.de/mikrocontroller_buch/index.html
-
Thread
Welches Display für µC? möglichst viereihig mit IIC
Zeilen a 14 Zeichen, sparsam, tageslichttauglich günstig Nokia5110 https://www.mikrocontroller.net/topic/neue-arduino-module-vorgestellt#5435352
jede Lib ist dazu fähig, notfalls geht man weit zurück aus der Arduino Umgebung raus zu pur C für AVR, auch da gibt es LIBs.
-
Thread
Arduino Librarys - Wer prüft diese ?
Hallo, da der Mega1284 als Arduino ja Ausgangspunkt war: bei lagen noch Pollin NetIO rum. Die habe ich kurzerhand zum Arduino erklärt. Aufwand: eine Verbindung vom seriellen Sub-D zum MAX auftrennen und mit DTR verbinden, vom Ausgang des MAX über 100n an den Reset des AVR. Bootloader
Arduino" mit Mega16/32/644/1284, was man gerade raufgesteckt hat. LAN hat man gleich mit drauf, die IO sind brauchbar verfügbar, teilweise auf dem 25pol. Sub D. Gruß aus Berlin Michael
-
Thread
[rant] Schleifen ohne Seiteneffekte - Jeden Tag steht ein neuer Amateur auf :-(
Optimizer hatte. Ich sehe moderne Varianten dieses Codes z.B. auf Github: [c] void Delay(__IO uint32_t nCount); /** * @brief Inserts a delay time. * @param nCount: specifies the delay time length. * @retval None */ void Delay(__IO uint32_t nCount) { for(; nCount != 0; nCount--); } [/c] Das unscheinbare __IO Makro steht natürlich fürs *volatile* Keyword. Schlechter Stil ist das trotzdem, denn bei modernen MCUs dreht man auch gerne mal am CPU Takt.
-
Thread
GIGATRON Emulator im STM32
SD-Karte) zu benutzen und könnte den zweiten CS für I/O Erweiterungen nutzen. https://forum.gigatron.io/viewtopic.php?f=4&t=64 Jörg
//www.mikrocontroller.net/articles/AVR_CP/M Die Frage wäre, ob es noch Optimierungsmöglichkeiten für den CPU-Code gibt: [c] CpuState cpuCycle(const CpuState S) { CpuState T = S; // New state is old state unless something
-
Thread
Linux-ähnliches Betriebssystem für AVR
this function) set_sleep_mode(MCUCR_SM_IDLE); \ ^ ./arch/avr/include/asm/io.h:9:51: note: in definition of macro ‘out’ #define out(reg, val) ((*(volatile u8*)reg) = val) ^ ./arch/avr/include/asm/system.h
^ ./arch/avr/include/asm/system.h:23:25: error: ‘MCUCR_SE’ undeclared (first use in this function) out(MCUCR, in(MCUCR) | MCUCR_SE); \ ^ ./arch/avr/include/asm/io.h:9:51: note: in definition
-
Thread
Viele Kippschalter (ca. 40) auslesen / Mikrocontroller wake-up
zusätzliche Stromaufnahme im Schlafmodus. Vielleicht erwägst du so eine Möglichkeit. Es wurden nur 7 IO-pins + den Int Eingang benötigt. Die Keypad Eingänge wurden mit dem LCD Modul geteilt, so daß fast kein IO für die Keypad verschwendet werden mußte. Es war kein Problem den Keypad scan und LCD Service
RC-Gled entprellt, wird man nicht beliebig kurze Reaktionszeiten erreichen. Und man braucht nur den AVR und eventuell einen Uhrenquarz.
-
Thread
Tiefpassfilter für VCC und AVCC von Atmega - suche Praktische Erfahrungswerte
mit 100nF, Spule mit 10uH. Nun habe ich das Design hier vorgestellt: https://www.mikrocontroller.net/topic/465300#new und den Rat bekommen, noch einen "großen Elko", einen "mittleren MLCC" und eine "Ferritperle in der Versorgungsspannungszuleitung" zu ergänzen. Jetzt habe ich aber keine Ahnung,
Hmm, Vcc bekommt der AVR bei mir immer direkt vom Netzteil. Wenns ein Schaltregler ist, dann packe ich da meistens noch einen Filter hinter, bei Linearreglern (für wenig Leistung, wo keine hohe Verlustleistung auftritt) nicht
-
Thread
Interrupts in C++
Interrupts zu informieren. Folgenden Artikel habe ich darüber gefunden: https://www.mikrocontroller.net/articles/AVR_Interrupt_Routinen_mit_C++ Den Ansatz finde ich schon nicht schlecht, die ISR kann auf das Objekt (mit dem es registriert wurde) direkt zugreifen ohne das das Objekt global sein muss
; #endif //SERVO_HPP [/code] [code] #include "Servo.hpp" #include <stdint.h> #include <avr/interrupt.h> #include <avr/io.h> ServoManager* ServoManager::Timer::owner = nullptr; Servo::Servo() { ServoManager::getInstance().attach(this); } void Servo::update() { //doSomething
-
Thread
Noch ein Taschenrechner auf ATMega Basis
warum das? eine miniUSB hätte genügt, andere schaffen das auch: https://www.mikrocontroller.net/topic/364055#4708328
und RCL benutzt und sich dieses Programm in einer Endlosschleife befindet, dann ist der EEPROM des AVR bald hinüber :-(
-
Thread
LED- Schaltung
es nicht bei Reichelt und er ist in SMD. Alternative zu Reichelt: https://www.mikrocontroller.net/articles/Sammelbestellungen(Mouser)
LPT-Schnittstelle und BASCOM-AVR. Billiger und leicht verständlicher wird es nicht werden! Meine Hilfe ist Dir gewiss. VG Micha
-
Thread
Ansteuerung eines unbekannten Servomotors
Baustein. Das ist der Witz am "LIN-Bus": man kann konstengünstigerweise einen normalen Tristate-IO-Pin zur Busankopplung verwenden (wie z.B. beim I2C).
Baustein. > Das ist der Witz am "LIN-Bus": man kann konstengünstigerweise einen > normalen Tristate-IO-Pin zur Busankopplung verwenden (wie z.B. beim > I2C). Oder auch jeden GPIO (sofern dieser die Möglichkeit bietet, "TriState" zu arbeiten). Bei AVR8 also fast jeden. Man "moduliert" halt einfach