-
Thread
Aufwandschätzung für Cross-Assembler
Ausgangspunkt wäre hier: https://en.wikipedia.org/wiki/PicoBlaze Ein Treffer z.B. https://kevinpt.github.io/opbasm/
Speicher, äh sagen wir mal, ungewohnt?! Genauso wie ARM Cortex M ungewohnt war, nach Jahren PIC und AVR. > Nö, sowas ist nicht wirklich ein Assembler, mit dem man auch komplexe > Programme schreiben kann. Nun enttäusch mich bitte nicht, mein Gutester. Wir schaffen das. ;)
-
Thread
Programmieren lernen die 10.001
naja, schon mal das hier gelesen? https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
ja ein zusätzliches Adressregister und so waren wohl Zugriffe lahmer, https://www.mikrocontroller.net/topic/292775?page=single#3959220 https://www.mikrocontroller.net/topic/349206?page=single so musste ich einen schmutzigen Kunstgriff anwenden damit es mit dem m1284p eben doch läuft [c] #if F_CPU
-
Thread
I2C mit ATtiny 0/1-series (z. B. ATtin817)
sich mit dem Problem zumindest auf Seiten des Masters auseinandersetzen: https://www.avrfreaks.net/forum/tiny-avr-1-series-twi-woes https://www.avrfreaks.net/comment/2294056#comment-2294056 Der Code dort ist zumindest kurz und überschaubar. So richtig zufriedenstellend ist es aber nicht, wenn
Für die zwei oder drei am Thema interresierten: https://www.avrfreaks.net/forum/i2c-masterslave-code-attiny-series-1 Bitte das AVR-Forum nicht auch noch mit Gebrüll vollspammen, sondern dort nur sachdienliche Fachbeiträge. Danke
-
Thread
DAC-Verstärker
der Strom reicht. https://www.holger-klabunde.de/dcdc/picdcdc.htm das muss ja kein PIC sein AVR geht auch, vermutlich jeder µC der PWM erzeugen kann. Oder man zapft einen MAX3232 an
kriege ich das hin ?) muss man alles 2x schreiben? liest du auch? https://www.mikrocontroller.net/topic/473696#5831356
-
Thread
LPC/ARM-Cortex-M0, atomarer Zugriff
Suchfunktion: https://www.mikrocontroller.net/topic/312246
Speicher und man kann einen Pin atomar schalten: #define P0 0xA0000000 // Port 0 Adresse ... __IO_REG8(P0_0, P0 , __READ_WRITE); __IO_REG8(P0_1, P0 + 1, __READ_WRITE); ... #define LED P0_0 LED ^= 1; Funktioniert also genau wie beim 8051 es braucht hier keine AVR Tricks.
-
Thread
SimulAVR, GDB Programm mit ADC simulieren
0x04) #define ADCH _SFR_IO8(0x05) #define ADCSR _SFR_IO8(0x06) #define ADCSRA _SFR_IO8(0x06) /* Changed in 2486H-AVR-09/02 */ #define ADMUX _SFR_IO8(0x07) [/c] Wie kann ich _SFR_IO8(0x05) per set * .... setzen? Muss
teilweise gearbeitet. War mir aber zu groß und zu mächtig. mplab ide wird wohl ähnlich geartet sein. In avr-gcc geht das irgend wie so. [c] sbi((*(volatile uint8_t *)((0x04) + 0x20)), 5); [/c] Laut microchip [c] #define sbi(port,bit) \ (port) |= (1 << (bit)) Set bit in IO port port. [/c]
-
Thread
RS41 Wettersonde GFSK GPS dekodieren
Hier der Link für den Raspberry Pi3: https://www.qsl.net/oe1ffs/Sondenpage/Sondenraspi/Sondenraspi.html
FB Gruppe Radiosonde germany. > > Schön, leider bin ich nicht bei FB. https://youtu.be/ZQq8V73b4io?t=12m35s
-
Thread
4 Layer PCB: VCC Layer partitionieren? GND Layer auftrennen?
z.B. Schaltregler (PGND), CPU (DGND), analog (AGND). In Altium macht man die Verbindungen mittels Net-Tie. https://altiumpcbdesigner.blogspot.com/2012/05/net-ties-how-to.html
Transzorbdioden an den Filamentanschlüssen mit auf DGND gelegt. Bei Überschlägen ist nicht nur der AVR abgestürzt, sondern hatte auch seinen Flash teilweise gelöscht. Dann die Dioden auf den dafür vorgehehenen EGND gelegt und der AVR hat bei Überschlägen die Quelle wieder hochgefahren, wie vorgesehen
-
Thread
I2C-Bus: Zener-Diode 3,3 Volt - merkwürdiger Effekt - suche Erklärung
Vorgehensweise wäre die PullUps für SCL und SDA an die 3V3 des RasPi zu legen und nicht an die 5V des AVR
mit 6,6V lassen keinen Strom fliessen also gilt der pullup auf 3,3V https://www.mikrocontroller.net/topic/254199#2618575
-
Thread
Einstieg in die Welt der Mikrocontroller leicht gemacht: Onlinekurs zum ESP32 im Mai
Die ESP-Controller werfen wir zur Zeit auch mal gerne in die Klassen, die Schüler kommen beim Thema IoT immer auf tolle Ideen. Einige Schüler komme da auf den Geschmack und arbeiten sich tiefer in das Thema ein. Wenn dann Grundlagen in der Elektronik fehlen, merken die das schnell und fragen nach oder
. - welche Typen gibt es? - wie aufwendig ist die Programmierung bezüglich der Komplexität: z.B. AVR ATMEGA vs. TI TM4C Arm Cortex M4 - mache ich die Low-Level-Routinen full-custom oder greife ich auf BSP und HAL zu? 7. Die Kunst eine SW für Mikrocontroller zu entwerfen, die eine reibunslosen Ablauf
-
Thread
ADC-Kanäle wechseln bei Attiny24
[c] #ifndef F_CPU #define F_CPU 1000000UL // Interner RC-Schwingkreis #endif #include <avr/io.h> #include <util/delay.h> void port_init(); void init_adc(); uint16_t adc_lesen(uint8_t kanal); uint16_t adc_lesen_avg(uint8_t kanal, uint8_t messwerte); uint16_t adc_current_summe
Datenlatt des Attiny24 gibt es meines Erachtens kein ADCW. Hatte ich auch nicht geschrieben! Siehe avr gcc LibC - FAQ 8 https://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_16bitio https://www.nongnu.org/avr-libc/user-manual/index.html https://www.mikrocontroller.net/articles/AVR_16-Bit-Register
-
Thread
Servo verhält sich nicht wie erwartet
https://www.ripmax.de/ripmax-sb09-servo-9g-1-6kg.html [c] #define F_CPU 1000000UL #include <avr/io.h> #include <stdbool.h> #include "util/delay.h" int main(void){ DDRB = 0xff; DDRC = ~(1<<5); DDRD = 0xff; PORTB = 0; PORTC = 0; PORTD = 0; TCCR2 = (1<<COM21)
https://www.mikrocontroller.net/articles/AVR-Tutorial:_Servo
-
Thread
low-power Oszillator mit 74HC1G14 : Reinfall !
Spannung merklich länger, falls sowas noch erwünscht sein sollte. https://www.mikrocontroller.net/topic/472817#5813857 https://www.mikrocontroller.net/topic/472817#5813897
sogar hängen. Die folgenden Modifikation konnten das Problem umgehen: https://www.mikrocontroller.net/topic/472817?goto=5816085#5816021 https://www.mikrocontroller.net/topic/472817?goto=5816085#5815895 Nachdem es nicht möglich ist im inneren des Chips an den verdächtigen MOSFETs oder Transis zu
-
Thread
Wahl des Mikrocontroller für Kalendar Darstellung auf E-Ink
ein Terminkalender der sich über eine Netzwerkverbindung updated. Dann ist ein Arduino, selbst NetIO, und ESP8266 völlig unzureichend. Da wirst du einen RaspberryPI benötigen, gerade Google ist ja für gigantomanische Netzwerkschnittstellen bekannt. Dann geht auch: Jan R. schrieb im Beitrag
Schlumpf schrieb im Beitrag #5811395: > Du setzt Arduino automatisch mit AVR gleich. Und das ist nicht richtig. Das tu ich nicht. Deshalb nenne ich den AVR ja auch AVR und nicht Arduino. Schlumpf schrieb im Beitrag #5811395: > Der ESP kann in Arduino programmiert werden
-
Thread
SD-Karte Platine mit 3.3V und 5V kompatibel?
korrekt einen Host der mit 5V läuft nur 3,3V-Signale anzubieten. Es genügt, hier einfach mal die Input IO-Pegel zu prüfen. Da ihr beide dazu nichts sagt, kann ich für mich nur sagen "ein nogo".
"besonderer" Adapter nötig. Ein solches Ding ist voll ausreichend: https://www.mikrocontroller.net/attachment/405519/SdHalter.jpg
-
Thread
Byte auf verteilten Ausgängen ordnen
42 Takte, die mit 2 LUT braucht 25 Takte und auch minimal weniger Flash (6 Byte): [c] #include <avr/io.h> #include <avr/pgmspace.h> #include <stdint.h> const uint8_t lut1[16] PROGMEM = { 0x00, 0x80, 0x40, 0xC0, 0x20, 0xA0, 0x60, 0xE0, 0x08, 0x88, 0x48, 0xC8, 0x28, 0xA8, 0x68, 0xE8 }; const uint8
-O3 -Wall -Wextra -c -o foo.o foo.c: [c] #include <avr/io.h> #include <inttypes.h> void pinout(uint8_t out) { PORTD = __builtin_avr_insert_bits(0x0123ffff, out, PORTD); PORTC = __builtin_avr_insert_bits(0xffff4567, out, PORTC); } [/c]
-
Thread
Frage zu AVR-Datei
Hi, hierzu gab es einen älteren Thread: https://www.mikrocontroller.net/topic/219011#2187728 ciao gustav
? Jein. Globale Variablen sind 0, wenn du keinen anderen Startwert vorgibst: [c] #include <avr/io.h> int i; int j=3; int main() { int k; printf("i=%d j=%d k=%d", i,j,k); } [/c] i Startet mit dem Wert 0. j Startet wird dem Wert 3 (der Startwert wird aus dem Flash kopiert).
-
Thread
Empfehlung Equipment für Einstieg in uP Entwicklung
mit einem (Atmel) uP zu entwickeln. Ich habe hier im Forum schon einiges darüber gelesen(zB. die AVR Tutorials) jedoch beantwortet es nicht alle meine Fragen, zB: - für einfache Schaltungen(wie zB. https://www.mikrocontroller.net/topic/472341), wo der uP einfach nur über einige wenige dig. Ein/Ausgänge
https://www.mikrocontroller.net/articles/Absolute_Beginner-AVR_Steckbrettprojekte
-
Thread
Attiny13A 2 PWM Ausgänge
Nur falls mal einer nach sucht und ne Lösung finden will: [c] #include <avr/io.h> #include <avr/interrupt.h> #include <inttypes.h> uint8_t richtung; int main( void ) { // Analog Comparator deaktivieren ACSR |= (1 << ACD); // Analog to Digital Converter
// defines #define F_CPU 9600000 #define LED PB1 #define LED1 PB0 // includes #include <avr/io.h> #include <util/delay.h> void pwm_setup (void) { // Set Timer 0 prescaler to clock/8. // At 9.6 MHz this is 1.2 MHz. TCCR0B |= (1 << CS01); // Set to 'Fast PWM'
-
Thread
Rotary-Encoder mit Arduino als Konzentrator
"transmit buffer" ist genau der 2-Byte-Fifo, den ich oben > beschrieben habe. Für die üblichen AVR Arduinos gilt: #define SERIAL_TX_BUFFER_SIZE 64 Siehe: https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/HardwareSerial.h https://github.com/arduino/ArduinoCore-avr/blob/master
steht, kann er nicht sehen. Man kann float-printf aber aktivieren: https://www.mikrocontroller.net/articles/FAQ#Aktivieren_der_Floating_Point_Version_von_sprintf_bei_WinAVR_bzw_AVR-Studio Hat 1 Minute Google gekostet. wie lange hast du gesucht? Kostet natürlich mehr Speicher. Ob man das wirklich
-
Thread
LED-Streifen stroboskop mit mosfet
vorgeschlagen. Zum Mosfet habe ich eine Frage. Wo finde ich im Datenblatt (https://www.mikrocontroller.net/part/IRLZ44) wie viel der Mosfet schaltet, wie viel Spannung zum schalten benötigt wird und wie schnell maximum ist?
und wie schnell > maximum ist? das wiederum ist schwierig. Hängt davon ab, wieviel Strom dein AVR im Umschalt-Moment in das Mosfet-Gate schieben kann und darf. Es sind deutlich mehr als die 20mA/40mA Dauerstrom, AVR ist CMOS und damit von Grund auf für das Verbinden von Ausgängen an Mosfet-Gates
-
Thread
Code-Beispiele für ATtiny841
FJC schrieb im Beitrag #5796648: > Wo finde ich Code-Beispiele für den ATtiny841? [c] #include <avr/io.h> int main(void) { uint16_t val = 0; DDRA = 0xFF; DDRB = 0xFF; while (1) { val++; PORTA = val; PORTB = val>>8; } } [/c]
Hier: https://www.mikrocontroller.net/topic/377448
-
Thread
Avr 8bit VGA
könnte ich für > die VGA Ausgabe auch einen esp nutzen. Kennst du das? https://www.linusakesson.net/scene/craft/ Da sind aber bei weitem keine 800x600 drin. Dafür ist alles auf einem AVR in Software implementiert. Ich finde das immer noch beeindruckend, was der da aus einem AVR rausholt, ganz ohne
Pixeltaktfrequenz (etwas über 25 MHz), die auch im einfachen Textmodus verwendet wird. Die kann Dein AVR nicht ohne Nachhilfe zusätzlicher Hardware verarbeiten. Hier hat mal jemand entsprechende Hardware (mit einem übertakteten AVR) gebaut: https://www.mikrocontroller.net/topic/143445 Rolf
-
Thread
ARM Cortex M0+ Startupcode Minimal
Hm vielleicht sollte ich doch lieber mit avr beginnen, lese gerade das Make AVR Buch, ich habe selten was gelesen wo so gut und ausführlich erklärt wird. Sorry dass ich grade so umschwenke, ist voll am Threadthema vorbei.
denn auch Literatur die einem den ARM anhand von Projektbeispielen beibringt? So wird das in Make Avr gemacht.
-
Thread
Ansteuerung von 4x50W LEDs mit ESP Bluetooth und mobiler APP
Relais-Modul direkt dran hängen kannst. Oder du nimmst ein nicht programmierbares und hängst einen kleinen AVR Mikrocontroller dran. Ich habe das mal gemacht: http://stefanfrings.de/serial_io/index.html Bei Bluetooth musst du auch das Protokoll achten. Das Serial Port Profile (SPP) ist Programmtechnisch so
Relais-Modul direkt dran hängen kannst. Oder > du nimmst ein nicht programmierbares und hängst einen kleinen AVR > Mikrocontroller dran. Ich habe das mal gemacht: > http://stefanfrings.de/serial_io/index.html Die Bluetooth Module sind doch alle recht teuer oder lieg ich da falsch? https://www.mikrocontroller.net
-
Thread
[V] div. Bausätze und Module
Pollin DFC-Modul (https://www.pollin.de/p/dcf-empfangsmodul-dcf1-810054) neu, unbenutzt 5€ 1x Pollin AVR Net-IO-Bausatz V1.0 (https://www.pollin.de/p/bausatz-avr-net-io-810058) unbenutzt 15€ 1x Pollin AVR Net-IO-Bausatz V1.0 (https://www.pollin.de/p/bausatz-avr-net-io-810058) gebraucht, aufgebaut mit
www.pollin.de/p/led-konstantstromquellen-bausatz-810037) plus eine zusätzliche Platine 1€ 1x Pollin AVR Net-IO-Bausatz V1.0 (https://www.pollin.de/p/bausatz-avr-net-io-810058) unbenutzt 15€ 1x Pollin AVR Net-IO-Bausatz V1.0 (https://www.pollin.de/p/bausatz-avr-net-io-810058) gebraucht, aufgebaut
-
Thread
Probleme mit C Code und hilfe bei änderung
mit Strings. Ich habe mit folgende Funktion gebastelt: [code] #include "main.h" #include <avr/io.h> #include <avr/interrupt.h> #include <stdint.h> #include "mylcd.h" #include <avr/interrupt.h> #include <stdint.h> #include <inttypes.h> #include <avr/pgmspace.h> #include <stdlib.h> #include
: Falls wichtig, beim compilieren bekomme ich keine Fehler oder Warnings.. [code] make all avr-gcc -c -Os -std=gnu99 -mmcu=atmega128 main.c -o main.o avr-gcc -c -Os -std=gnu99 -mmcu=atmega128 mylcd.c -o mylcd.o avr-gcc -c -Os -std=gnu99 -mmcu=atmega128 gen.c -o gen.o avr-gcc -c -Os -std=gnu99
-
Thread
Rückgabewert einer Funktion
ich hierbei falsch mache? Schöne Grüße! hier mein bereits gekürztes Projekt: [c] #include <avr/io.h> #include <stdio.h> //aufsteigend sortieren (funktioniert wie gewollt) char sortiere (char zahlen[], uint8_t anzahl) { uint8_t i = 0, j = 0, tmp; for (i = 0; i < anzahl; i++) {
oje...der Fehler ist offensichtlich..schau mal #include <avr/io.h> #include <stdio.h> das klingt mega nach C.. Der Fehler: falsche Programmiersprache..damit passiert sowas sehr schnell
-
Thread
Wie viel Prozent des Gehalts sparen und wie anlegen? Gesperrt
und sie haben geringe Nebenkosten. Viel Spass bei der Geldvernichtung: https://www.finanzen.net/aktien/TUI-Aktie
man sollte wirklich auf FB hören: https://www.mikrocontroller.net/topic/432422
-
Thread
Neue Wanderkiste Kittler
DANKE An Den Spender ! Diese Ehre gebührt Sven. Gruß ic_tester https://www.mikrocontroller.net/articles/Neue_Wanderkiste_Kittler
Entwicklungsboard für ATMega16 (oder kompatible uCs- Schaltplan liegt bei) 1x: Leerplatine Display myAVR 1x: LC Display HD44780 kompatibel mit Beleuchtung 3x: ESP12F - Espressif ESP8266 uC Modul mit WLAN 1x: Code Mercenaries IO-Warrior 40 IC mit entsprechender Leerplatine 2x: IC DRAM 53c256 1x: 2GB
-
Thread
Programmänderungen
keine Lib, keine GPL! Dann scheinen wir unterschiedliche Auffassungen von lib zu haben: #include <avr/io.h> #include <util/delay.h> #include <avr/interrupt.h> #include <avr/pgmspace.h> wendelsberg
, keine GPL! > Dann scheinen wir unterschiedliche Auffassungen von lib zu haben: > > #include <avr/io.h> > #include <util/delay.h> > #include <avr/interrupt.h> > #include <avr/pgmspace.h> Die AVR-Libc ist nicht unter der GPL lizenziert, sondern hat ihre eigene Lizenz, die weniger restriktiv
-
Thread
Erste 65C02 Basteleien.
/B01IO2JP60
viewtopic.php?f=4&t=3458&hilit=romulus+1st da es für 11MHz beim ROM schwierig wird habe ich dem 6502 einen AVR spendiert der ihm beim Booten ein paar Instruktionen liefert und so das "BootROM" liefert. Der AVR kontrolliert den Takt, d.h. da hat der AVR keine Eile. Sobald das "BootROM" über diesen Weg geladen
-
Thread
Atmega ADC Impedance matching
Der liefert auch > ziemlich genau 3.3(27)V... VORSICHT! Da bin ich schon mal reingefallen! Mein AVR-Dragon hat irgendwelche Pull-Up-Widerstände! Wenn die Programmierung beendet ist, sind die ISP-Pins NICHT total hochohmig! Da liegen ein paar kOhm gegen VCC! Das hat mir eine Analogmessung verfälscht
ggf. noch analogReference() aufrufen: https://www.arduino.cc/reference/en/language/functions/analog-io/analogreference/ MfG, Arno
-
Thread
Mikrocontroller - die Qual der Wahl, oder doch die Wahl der Qual?
AVR (Attiny und ATmega, jedoch nicht Xmega) finde ich zum Basteln sehr attraktiv, allerdings wäre das im Vergleich zu deinen PIC kein großartiger Fortschritt. Zudem sind die Debugger für AVR recht teuer
ermöglicht. Wenn man aber nur die größere Rechenleistung nutzen möchte, die Peripherie aber nur auf "AVR-Niveau", dann ist das so gut wie gar nicht komplexer als beim AVR. Der einzige signifikante Unterschied ist, dass man im Gegensatz zum AVR ein paar Hundert Seiten zuvor lesen (und natürlich auch verstehen
-
Thread
SCN8049H Prozessor
https://www.mikrocontroller.net/topic/40435
die Intel MC begreifen. Hab mir das Buch "Das 8051er Lehrbuch" gekauft und war geheilt. Bin beim AVR geblieben.
-
Thread
Schalter über Internet steuern
Ist zwar schon älter aber sollte für deinen Zweck ausreichen, der gute alte AVR-NET-IO https://www.pollin.de/p/bausatz-avr-net-io-810058
Raspi-Lösung immer noch genug Bastelei enthält ;-) ) Bei mir werkelt seit einiger Zeit ein Raspi mit ioBroker, der mehrere Sensoren/Aktoren von Shelly verwaltet. Das schöne daran ist dass sich Geräte unterschiedlicher Hersteller über ioBroker homogen verwalten lassen. ioBroker bietet auch einen Cloudservice
-
Thread
Schnellere MCU als der ESP8266 zu einem guten Preis?
Bild, sondern auch ein einfaches Videospiel darzustellen - mit Ton, versteht sich. http://bitluni.net/esp32-color-pal/
avr schrieb im Beitrag #5768933: > tgdfgdf schrieb im Beitrag #5768874: >> je nach aufgabengebiet ist das eben besser als ein ESP >> denn auch so ei ESP hat seine grenzen. > > Der ESP ist vor allem
-
Thread
Vorüberlegung: Syslog (UDP) aufzeichnen
ATmega328 + Ethernet. Nur sollten die Daten nicht zu schnell eintrudeln. Bis du allerdings mit dem AVR die Wattstunden wieder raus hast, die du in Form von Kaffee erst einmal rein steckst (denk an die 2kW der Kaffeemaschine!), wirds eine Weile dauern. Der RPi bringt das fix und fertig mit.
verfügbare Programmspeicher > kneifen? Besser zu einem Mega 2560 greifen? Das hat, wie man am Pollin NetIO oder Ulrich Radigs ETH M32 sieht, schon mit dem ATMega32 geklappt. Mit Mega644, ENC28J60, einem 128x128 Pixeldisplay und SD-Karte hab ich schon einen Syslog-Server laufen gehabt, allerdings prä
-
Thread
[C] Böse Falle: Datentyp korrekt angegeben, falscher verwendet
nach Optimierungsstufe muss man sich sonst jedesmal fragen: "Rechnet das jetzt der Compiler oder der AVR?!?" Ich hatte das Argument bereits hier angeführt: https://www.mikrocontroller.net/topic/470221?page=1#5764919 Es gab nur keine Reaktion darauf. Vielleicht muss ich es auch etwas schärfer formulieren
Test unter Windows, übertragen auf den AVR aber nicht mehr. BTDT.
-
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