-
Thread
Mikrocontroller Einstieg
Programmierer in Hochsprachen sehr wenig zu tun. Ich empfehle Dir: - Arduino Nano Clone = 8bit AVR Controller und USB Interface - ESP8266 = 32Bit ARM Controller mit serieller Schnittstelle und WLAN - STM32F103C8T6 Board = 32Bit ARM Controller mit USB und seriell Als zusätzliche Hilfsmittel
gerne vorbei kommen und ich zeig dir das. Ich kann dir am laufenden Beispiel Dinge für LPC, STM32, STM8, AVR und MCS-51 zeigen
-
Thread
Probleme beim Schreiben in den Flash-Speicher
0; char n = 0; for (i = 0; i < 4; i++) { boot_spm_busy_wait(); for (n = 0; n < 32; n+=2) { boot_page_fill(i * 32 + n, data[32 * i + n]); } boot_page_write(i); } sei(); } [/c] Wenn ich allerdings den Flash auslese, nachdem der Bootloader das Programm
char i = 0; for (i = 0; i < 128; i+=2) { boot_page_fill(i, data[i/2]); if (i % 32 == 0 && i > 0) { boot_page_write(i / 32); } boot_spm_busy_wait(); } sei(); } [/c] Ergebnis: [c] :100000008000800880088004400080048000C000D8 :10001000C0108001C000C00700088001C00080013E
-
Thread
CCFL - Inverter
2,25 W Output Voltage: min. 550 Vrms Start Voltage: 650 Tube Current: 5,7 mA Working Frequency: 32-42 kHz Life Time: 20.000 hrs Zweitens, will ich das Display mit einem Mega128 und zwei 32kb Cachebausteine (61256A-15) ansteuern. Meine ersten Versuche will ich erstmal auf reine Textdarstellung
jemand ein SP14Q002-A1 bei eBay ersteigert? Wenn ja, dann könnte man sich in einem neuen Thread ergiebig darüber austauschen. Schönen Gruss... Hans
-
Thread
static global
, da der Zugriff schneller als SRAM ist. Viele Funktionen kommen beim AVR daher ohne Variablen im Stack aus (der wird dann nur zum Pushen der /callee saved registers/ gebraucht). > Hm, und was passiert (rein akademisch betrachtet) wenn man mehr als > 32bytes an Funktionsargumenten
Unterscheidung zwischen kleinen und großen Strukturen das > ABI verkomplizieren würde. Zumindest für AVR und ARM EABI scheint man die Argumente einfach als "flache" Folge von "CPU-Worten" (AVR: Byte, ARM: 32bit-Word) zu betrachten (unabhängig davon welches der Worte ein "int" oder Teil eines struct ist
-
Thread
Über Funktionen "loopen" (Arduino IDE)
Einzelfall kann man das falls nötig optimieren. Karl schrieb im Beitrag #5303831: > Besser noch 32 oder 64. Je nach Plattform sind größere Integer effizienter als kleinere. ARM kann z.B. mit 32bit besser als mit 16bit rechnen. i.A. ist size_t optimal effizient, da sind Plattformen wie AVR der Sonderfall
Auch die Java Geschichte muss uns hier nicht belasten. Der ESP rechnet übrigens gerne mit 32 Bit.
-
Thread
Starterkitt für Anfänger,
Da Du mit AVR anfangen willst: ATmega88, ATmega168, ATmega328 Mehr Pins: ATmega324, ATmega644
) http://www.mikroe.com/eng/home/index/ Gibt auch Boards, wo man den uC tauschen kann (Arm <-> AVR <-> PIC)
-
Thread
Verschiedene Bits effizient auslesen
Michael K. schrieb im Beitrag #2308266: > source ist ein uint64_t Wenn Du den AVR-GCC benutzt, schließen sich Effizienz und 64 Bit gegenseitig aus. 64 Bit ist sogar noch langsamer und größer, als float. Zerlege die 64 Bit in 2 * 32 Bit und Dein Programm läuft mindestens 10-mal
#2308473: > Michael K. schrieb im Beitrag #2308266: >> source ist ein uint64_t > > Wenn Du den AVR-GCC benutzt, schließen sich Effizienz und 64 Bit > gegenseitig aus. > 64 Bit ist sogar noch langsamer und größer, als float. > > Zerlege die 64 Bit in 2 * 32 Bit und Dein Programm läuft mindestens
-
Thread
Glühwürmchen in Rotkohlglas gefangen
, laden, speichern und als Header Datei exportieren kann. Aktuell benutzt das Projekt 32 verschiedene Waves zusammengesetzt aus einem Wave mit 827 samples. Damit stehen im AVR noch rund 1.5Kb an FLASH ungenutzt zur Verfügung. Die Leuchtdauer dieser Waves geht von 0.22 bis 2.88 Sekunden.
noch die firefly.h [c] #ifndef FIREFLY_H #define FIREFLY_H #include <inttypes.h> #include <avr/eeprom.h> #include <avr/pgmspace.h> #include "lfsr32.h" #include "wave.h" /* PB2 = = InOut = LED0 PB1 = = InOut = LED1 PB0 = = InOut = LED2 PB5 = = InOut =
-
Thread
-
Thread
CH32V003: Selbstbauprogrammer und "Getting started"
aber einmal nur der Vergleich der Codegrößen Arduino IDE 18 (und ich bin immer mehr entsetzt): - CH32V003: 9572 Byte (riscv-none-elf-gcc 14.2.0) - UNO R3 (ATmega328): 2040 Byte (avr-gcc 7.3.0) - UNO R4 (RA4M1): 52576 Byte (arm-none-eabi-gcc q7-2017, für mich absoluter negativ-Wahnsinn) - STM32F401: 12836 Byte (arm-none-eabi-gcc 13.2.1) - STM32F103: 12136 Byte " Das Programm als C-Programm mit den Funktionen aus denen die Arduino-Class erzeugt wurde: - CH32V003: 1316 Byte (risc-none-elf-gcc 14.2.0) - ATmega328p: 1712 Byte (AVR-GCC
-
Thread
Arduino->WS2812B-> Arduino
sieht man das die > Adafruit Neopixel sehr wohl targetspezifische Implementierungen hat. > Beim ESP32 wird das RMT verwendet, beim RP2040 die PIO. Es geht aber nunmal in diesem Thread um einen Arduino NANO, sprich: AVR8, siehe OT! Dein dümmliches tendenzielles Geschwalle geht also vollkommen am
Al. K. schrieb im Beitrag #6888077: > Welche vom ESP32 verwendet werden. Hast du https://github.com/FastLED/FastLED/blob/master/src/platforms/esp/32/fastspi_esp32.h angeschaut? LG, Sebastian
-
Thread
Midi Keyboard im Selbstbau
mit Pins ist. Bist du aber noch lange, lange nicht. Und falls doch irgendwann: Nimmst du halt zwei AVR, von denen einer nur als Key-Controller werkelt. Dann bist du bei einem 16-Pinner (2x Supply, 14x IO für die Keyboardabfrage und 2 Pins für die Komunikation mit dem Rest deines Werkes). Also z.B. ATtiny24
beide Einzelmatrizen, halbiert sich der Bedarf an IOs. Sind wir also bei 18 IOs. Ein Mega16 z.b. hat 32, bleiben also 14... Mal sehen, was dir einfällt, um die sinnvoll zu benutzen...
-
Thread
Division zu ungenau
meisten Compiler benutzen die gleiche Genauigeit, wie ANSI C Compiler, z.B. der Keil beim 8051 für 32 Bit Zahlen. Ich selber hab es nicht getestet, aber in mehreren anderen Quellen wurden gesagt, daß der AVR GCC dahingehend Abstriche macht, d.h. zwar relativ schnell ist, aber mit geringerer Genauigkeit
mit 5-stelliger Genauigkeit verrechnen will, kommt man mit 32bit-float völlig aus, wie Du selber oben festgestellt hast.
-
Thread
Aufwachzeit von ATmegas
clocks, also (bei 8 MHz) 32 us, 125 us und 2 ms. Womit muss ich rechnen, wenn ich eine zu kurze Einschwingzeit habe? Stürzt mir der AVR ab? Oder ist nur die Frequenz ein bisschen daneben? In meinem konkreten Beispiel muss ich
Es gibt auch die Möglichkeit den AVR mit dem internen RC-Oszillator laufen zu lassen und an den asynchronen Timer einen 32kHz Quarz zu pappen. Der kann sogar im Power-Save ständig laufen. Damit kann man dann den RC-Oszillator fein justieren
-
Thread
4x Nibbles auf 16 Bit Wert packen
uint8_t d){ return (a&0xf)|(b<<4)|((uint16_t)(c&0xf)<<8)|((uint16_t)d<<12); } [/c] macht der avr-gcc zu: [avrasm] 000001ca <concat>: 1ca: 4f 70 andi r20, 0x0F ; 15 1cc: 30 e0 ldi r19, 0x00 ; 0 1ce: 32 2f mov r19, r18 1d0: 22 27 eor r18, r18
Richi D. schrieb im Beitrag #4615587: > Also das hier dauert gemessene 2µs bei 32MHz, 16 Bit PIC: > SENSORWERT_32 = MAKE32(DIGITALWERT[2], DIGITALWERT[3], DIGITALWERT[4], > DIGITALWERT[5]); > Zeigt mir mal wie ihr das mit schieben schafft... unmöglich! Bei 16MHz AVR und GCC
-
Thread
S65 Display Unterschiede zw LPH88* und LP-88* ?
aber noch nichts außer der Hintergrundbeleuchtung entzaubern. Ich habe auf einem Steckbrett den Atmega32 bei 5V und 8MHz laufen. Über einen LM317 hab ich 2.75V (soll: 2.9V/1.8V) für den Displaycontroller bereit gestellt. Pinning ist über U-Teiler (3k9/4k7) so ausgelegt: LCD Atmega32 1 RS
>Jeder AVR kann bei 3V Versorgungsspannung nur bis 8MHz Takt… Falsch, ATMega168 kann zb. 14Mhz, 19Mhz mit 3.75V, fast alle neueren AVRs die mit 20Mhz angegeben sind können das. Bei 5V sogar 24Mhz. Gruß hagen
-
Thread
avrdude bauen, libusb?
STREQUAL "FreeBSD") set(HAVE_LIBUSB_1_0 ${HAVE_LIBUSB}) endif() find_library(HAVE_LIBUSB_WIN32 NAMES libusb0.a usb0) if(HAVE_LIBUSB OR HAVE_LIBUSB_1_0 OR HAVE_LIBUSB_WIN32) check_include_file(usb.h HAVE_USB_H) check_include_file(lusb0_usb.h HAVE_LUSB0_USB_H) check_include_file
HAVE_LIBUSB_H) check_include_file(libusb-1.0/libusb.h HAVE_LIBUSB_1_0_LIBUSB_H) if((USE_LIBUSBWIN32 OR NOT HAVE_LIBUSB) AND HAVE_LIBUSB_WIN32) set(HAVE_LIBUSB ${HAVE_LIBUSB_WIN32}) set(LIB_LIBUSB ${HAVE_LIBUSB_WIN32}) unset(HAVE_USB_H CACHE) elseif(NOT HAVE_USB_H)
-
Thread
Atmel ist unter "Profis" nicht gerade beliebt - Warum?
eine Stelle. ;-) Indirekt schon, wenn du den Begriff des AVR-GCC etwas weiter fasst. Eric Weddington ist seit einiger Zeit bei Atmel angestellt und hat nunmehr damit die dienstliche Aufgabe, WinAVR zu betreuen. Für den AVR32 ist das anders, dort ist die
fällt. Als Bastler ist die Auswahl deutlich eingeschränkter! Persönlich bin mal gespannt wie der AVR32 sich behaupten kann...
-
Thread
Orange Pi - 15$ Quadcore SBC
. [ 14.164333] systemd[1]: Listening on udev Kernel Socket. [ 14.175305] systemd[1]: Starting udev Kernel Socket. [ 14.191542] systemd[1]: Created slice User and Session Slice. [ 14.203097] systemd
[ 14.312429] systemd[1]: Starting Journal Socket. [ 14.461076] systemd[1]: Starting udev Coldplug all Devices... [ 14.590645] systemd[1]: Starting Setup Virtual Console... [ 14.613591] systemd[1]
-
Thread
Orientierungshilfe ATXMega oder ARM (ST, NXP)?
Es ist wie immer eine Sache der Anforderung. Wir arbeiten uns gerade in die STM32-Familie ein und werden kurzfristig komplett von AVR auf diese umsteigen. Für das gleiche Geld hat man eben echte 32Bit, ordentlich Speicher und vor allem Geschwindigkeit. Beispiele und kostenlosen
mal neben dem Mythos ein paar handfeste Punkte. Ich zähle mal ein paar Dinge auf, welche in der 32-Bit-Welt einfacher sind (dazu gehören noch PIC32/MIPS und Renesas RX, AVR32 kenne ich nicht), das gilt teilweise auch für MSP430 und PIC16): - Die Hardware beim AVR passt leider nicht zum GCC -
-
Thread
uClock - Matrix-Uhr mit WS2812 LEDs
und einen kleinen AVR zur Ansteuerung der LEDs nimmst? Ich meine es ist viel einfacher, als die Parameteraustauscherei und dieses Protokoll zwischen ESP8266 und dem STM32. Den AVR könnte man mit SPI ansteuern oder I2C wobei
900ss D. schrieb im Beitrag #5639495: > Wie wäre es denn, wenn du den ESP32 als Hauptcontroller nimmst und einen > kleinen AVR zur Ansteuerung der LEDs nimmst? AVR wäre ein klarer Rückschritt. Der kommt bei WS2812-Übertragungen schon arg ins Schwitzen. Das würde ich mir
-
Thread
(STM32) Register Lib mit define oder nicht define..
Ich komme aus der AVR Ecke und bin es jahrelang gewohnt meine Register selbst zu beschreiben. Nun gibt es ja für die STM32 die HAL Lib und die StdPeriph Lib. Die nehmen einen ja schon ne Menge Arbeit ab, aber ich mach
ausreichend header für die ARMs. Und die sind ordentlich angelegt, nicht wie dieser Shift-Scheiss aus der AVR Ecke. Sorry, musste sein. Hier ein Beispiel von den ARM Machern: http://www.keil.com/dd/docs/arm/st/stm32f10x/stm32f10x.h Schön alle Flags als Masken, wie es sich gehört.
-
Thread
Übersicht Controller und Einstiegskosten (Debugger, Compiler)?
Hinweis: Algorithmus enthält auch float und double Berechnungen u.a. sqrtf(). Leider kein open source. AVR nur so schnell, weil dort double nur 32 Bit haben und dem float entsprechen.
Statt newlib die optimierte Lib verwendet: RX610, gcc -O2 -std=c99 -m32Bit-doubles, KPIT: 292 Cycles @20 MHz 14,6 µs @100 MHz 2,92 µs
-
Thread
Projekt Microcontroller
überschaubares Projekt. Allerdings IMHO bzgl. der Elektronik auch herausfordernd! Ich würde einen AVR dafür nehmen und in C programmieren. Zum AVR gibt es hier und anderswo viel Infos (Tutorials und Forum) und zu AVR/C gibt es freie Entwicklungstools, haufenweise Pläne für Hardwareaufbauten (Targetboard
2.0 - Bausatz (www.pollin.de, Best.Nr. 810 038) 14,95€ als Bausatz + ATmega8 für 1,85€ (auch bei Pollin) Beide Boards eignen sich gut, da sie bereits einen integrierten ISP (myAVR parallel, ATMEL seriell) und auch Taster und LEDs zur Eingabe/Ausgabe
-
Thread
Entwicklerboard für PIC
doch lieber Zeit verschwenden und mit dem AVR-usbasp und ca. 2 kBytes/s vorlieb nehmen. [code] $ avrdude -p m328p -c usbasp -P usb -v -U flash:w:dummy32k -B 0.5 avrdude: Version 6.3, compiled on May 8 2019 at 19:46:05 Copyright
des Herstellers. > Gibt es da einen, der z.B. einigermaßen aktuelles C++ kann? Also z.B. > C++14 oder C++17? Basiert beides auf gcc. Keine Ahnung, wieviel Aufwand MCP da in ihre Ports steckt bzw. wieviel Aufwand jeweils überhaupt nötig ist. Bei PIC32 (vulgo: MIPS) dürfte der Codegenerator praktisch
-
Thread
Problem bei Temp-Messung Rasp. Pi Pico & Pt1000
langen Jumpern. Schade ist, dass Schwankungen nicht so klein blieben wie sie schon mal waren (s. 14.03.2022 23:32). Warum waren sie bereits mal klein? Warum Änderung? :-( 60 Messungen mit R = 1k509 statt Pt 1000 ergeben (gem. Spannung über R und errechneter Widerstand), Stromquelle war 3V3 (gemessen
Samples pro Sekunde. Auf dem RP2040 kann man über 32 Samples mitteln und ist immer noch so schnell wie der megaAVR. Die höhere Geschwindigkeit bedingt natürlich auch eine kleinere Kapazität in der Samplingstufe, im RP2040 Datenblatt steht "The ADC input
-
Thread
Anfängerfrage: 40 Stück Atmega328 an einem Quarz?
Uwe D. schrieb im Beitrag #6680390: > Die betreibe ich jenseits der 32MHz mit externem Oszillator. Über > Monate. Und was hast Du davon? Nimm doch einen 100MHz C8051, der rennt Deinem 32MHz AVR aber sowas von davon. https://www.silabs.com/mcu/8-bit/c8051f12x-f13x
Allerdings hab ich wohl noch einen Bug drinn. Denn mit der Erhöhung des Buffers auf 144 werden trotzdem nur 32 übertragen. -> hmmm... !? Zeile 29: #define BUFFER_LENGTH 32 https://github.com/arduino/ArduinoCore-avr/blob/master/libraries/Wire/src/Wire.h @derguteweka: Den SMBUS hatte ich im Blick, weil
-
Thread
Welcher PIC ist der beliebteste ?
meiner eigenen Textmode-IDE für verschiedene Controller. Bisher kann ich einige Vertreter aus MCS51, AVR, STM32 und STM8 programmieren (und ich habe auch dienstlich mit ein paar davon zu tun). Noch nie hatte ich einen PIC in der Hand (außer vor Unendlichkeiten einen mit Fenster zum Löschen mit UV Licht
der momentan beliebteste PIC ist und welcher wohl der momentan günstigste aus China ist ? (bei AVR hätte ich wohl gesagt ATmega8 und ATmega328p, bei STM32 wohl den F103)... bei PIC habe ich keine Ahnung !
-
Thread
gebräuchlichste Standard-AVRs?
bzw. die ersten Ziffern bezeichnen immer den Speicherplatz für Programme in Kbyte: 1, 2, 4, 8, 16, 32, 64, 128. Die restliche Ziffer (machmal auch 2 Ziffern) stehen für den Typ. Veraltete AVRs habe ich nicht in die Liste aufgenommen. Eine interessante Aufstellung findest du auch hier: [[AVR Typen]
das reichen. Geld ist wie immer knapp... Danke für die zahlreichen Hinweise, jetzt blicke ich im AVR-Wald etwas besser durch. :-)
-
Thread
Tackt ATtiny2313 einstellen
Ist da noch ein Rettung möglich oder kann ich den AVR nun als 1 verzeichnen?
Ist anscheinend ein Fehler in obiger Datenblattversion (2543F–AVR–08/04). In der ältern Datenblattversion (2543I–AVR–04/06, Table 6) ist Int. RC 8 MHz \8 => 1MHz angeben und in der neueren, bei Atmel downloadbaren Version (2543L–AVR–08/10, Table 6) auch.
-
Thread
Reziproker Frequenzzähler+ Optimierte 64bit uint Routinen
/www.mshopf.de/proj/avr/uint64_ops.html * Bit Shifts (Ersparnis: ca. 200bytes vs. libgcc) * Multiplikation 64bit x 32bit -> 64bit (Ersparnis über 200bytes in Vergleich zu C, viele KB zu libgcc) * Division 64bit / 32bit
nom); // Frequenzbereich festlegen auf E {Hz, kHz, MHz, GHz} uint32_t freq_range = FREQ_RANGE(); if ((uint8_t)freq_range == 1) { frq = uint64_mul32(frq, (uint32_t)prescale); } else { frq = uint64_mul32(frq, (uint32_t)prescale); frq = uint64
-
Thread
Vor- bzw. Nachteile AVR / 8051
liegen derzeit die Leistungsgrenzen bei 100MIPS und 4MB Programmspeicher. Nur nach unten hin ist der AVR besser, den gibts ab 8-Pin-Gehäuse. Der kleinste 8051 hat 14 Pins. Peter
Add./Sub./Vergleich von 32-Bit Zahlen zeigt, daß diese beim AVR elegant und schnell erledigt werden. Der 8051 hat z.B. nicht einmal einen compare-Befehl. Bei gleicher Taktfrequenz ist ein AVR ein Vielfaches schneller als ein 8051
-
Thread
Led Matrix mit 1 5x7 LED Modul
mega32 meinte ich damit. du hast doch nen mega32 anstatt des 2313
Radig C=2001" Print "" Print "Ende mit (RETURN)" Print "" Print "Text: " ; Y = Waitkey() Y = 32 For Z = 0 To 14 Writeeeprom Y , Z Next Z Testa: Y = Waitkey() Print Chr(y); If Y = 13 Then Goto Testb Writeeeprom Y , Z Z = Z + 1 If Z < 110 Then Goto Testa Testb: Y = Z + 13 For W
-
Thread
µC mit Uhrenquarz betreiben
geht nicht um 16 vs 8. avr gibt es auch mit 32 bit, das weisst du? Es geht um die Handhabung und die Fehlermöglichkeiten für Anfänger. Der MSP hat eine gut durchdachte Architektur und das launchpad ist für kleines Geld zu
16 bit schrieb im Beitrag #3257675: > Es geht nicht um 16 vs 8. avr gibt es auch mit 32 bit, das weisst du? Klar weiß ich das. Das war auch nur eine Provokation ;-) Ich hätte gerne einen konkreten Wink was denn wirklich besser sein könnte. Das sind immer die beschriebenen
-
Thread
Mikrocontroller umprogrammieren? (Sportuhr)
den Programmer her geschweige denn einen Assembler oder gar Disassembler von dem Ding. Das ist kein AVR / PIC / STM32 für den man den Programmer auf ebay für 30€ schießen kann. Habt ihr eine Ahnung was der passende Assembler kostet? Entweder ihr ersetzt den Controller durch einen den ihr programmieren
Lösung. Wenn der Taster "- 1s" sich schnell betätigen läßt, dann würde ich ganz klar einen kleinen AVR programmieren, der wie bereits vorgeschlagen 10 mal die Taste "- 1s" (vermutlich) auf Masse zieht. Zum Auslösen der Sequenz würde ich eine weitere Taste ("14s") ins Bedienpult einbauen. Wird diese betätigt
-
Thread
Einstiegsfragen AVR
den ATmega32-16PU nehmen. Ich weiß, etwas oversized, aber auch langfristig nutzbar. Ansonsten halte ich mich ans AVR-Tutorial hier im Forum. Vile Grüße aus Berlin Christian
Aber C kannste schon? Das AVR-GCC Tut beschreibt ja nur nen paar Feinheiten zum C für AVRs. C generell sollte man schon ein bissel kenne, aber da gibs auch genug tuts für. Wenn dich das AVR Studio erschlägt kannste ja noch WinAVR
-
Thread
LCD Display Off - On - Befehl
verstanden. Was mich etwas verwundert ist, in dem Beispiel http://www.mikrocontroller.net/articles/AVR_-_Die_genaue_Sekunde_/_RTC Echtzeituhr mit Uhrenquarz steht * ATmega88 mit internem 2 MHz Oszillator + 32,768 kHz Quarz Wenn ich den Uhrenquarz verwende und die Fuses ändere, wie läuft der
man in diesem Fall bei den Fuses gar nichts beachten, weil der ja nicht als clock source für den AVR dient. Mit den fuses stelt man doch nur ein, wie der AVR getaktet wird.
-
Thread
Gemeinsames Haussteuerprojekt in Wien/Umgebung
Heiße auch Helmut und möchte Dir zu dem Mikroe-PIC32-Compiler raten. Das TFT von Mikroe mit dem PIC32 hat soviel Reserve in ROM und RAM. dass ich es nur empfehlen kann. Ältere Videos dazu auf Youtube: http://www.youtube.com/watch?v=e703G_Qa19Q
> "selberbastler" noch ewig träumen werden, ... Da liegst aber falsch. Das habe ich mit einem AVR-NET-IO, ein bisserl Software und meinem iPhone bzw. iPod in ca. 14 Tagen geschafft. Ist zugegeben eine einfache, aber definitiv funktionierende Lösung. Und da war mein größtes Problem, daß ich zu dem
-
Thread
Zeitschaltuhr + PWM
Lösung" einfach nur Schwachsinn > für die eigentliche Aufgabe ist? Und dann hast du selbst einen AVR empfohlen. Ob er nun einen AVR, einen STM32 oder einen ESP Chip mit Arduino Programmiert - da gibt es prinzipiell keinen allzu großen Unterschied. Außerdem hast du die einzige deutliche Anforderung
einfach nur Schwachsinn >> für die eigentliche Aufgabe ist? > > Und dann hast du selbst einen AVR empfohlen. Ob er nun einen AVR, einen > STM32 oder einen ESP Chip mit Arduino Programmiert - da gibt es > prinzipiell keinen allzu großen Unterschied. Nein, ich hab keinen AVR empfohlen, ich
-
Thread
Loxone Link - CAN-Bus
In der Doku :-) Such z.B. auf AliExpress nach STM32 und CAN.
leider offline -> https://github.com/sarnau/LoxLink ich meinte den STM32 source code. hab ein paar zuhause herumliegen.
-
Thread
GPS - MOUSE - MINI- NAVIGATOR (Assembler) ATmega8
wäre die ideale Hardware dafür nicht ein AVR Butterfly?
Welchen controller ich genau verwende kann ich noch nich genau sagen aber der M32 wirds wohl sein ... sonst kanns ja nich passen :)
-
Thread
Mikrocontroller + Zubehör?
drauf und eben die ISP Software zum Brennen des anderen. Fertig. Als Entwicklungssoftware dann z.B. AVR Studio 4 mit WinAVR oder eben Studio 6.
) 24FJ16GA002-ISP 2.20€ (PIC24) ATMEGA 328P-PU 4.20€ Der Unterschied in der Rechenleistung AVR-PIC32 ist etwa Faktor 20, bei AVR-PIC24 etwa Faktor 2-3 (bei den PIC24EP noch mehr). So viel zu den mehrfachen Kosten. >> und die Fuses der AVRs, mit denen sich schon so mancher Neuling >> ausgesperrt
-
Thread
AX82 - ZX Spectrum Emulator mit AVR + CPLD
3 Interrupt-Modi unterstützt. Neben dem AVR (Mega644) werden noch ein CPLD (XC9536) und zwei 32Kx8 (Cache-) RAMs benötigt. Die Ausgabe erfolgt umschaltbar auf TV (RGB) oder auch VGA, die Eingabe über eine PS2-Tastatur.Sound geht leider nicht,
meistens etwas mehr übertakten. Beim SwinSID (vielleicht ist dir das ein Begriff; SID-Nachbau mit AVR) wurde ein ATmega88PA-AU benutzt, weil dieser sich besser übertakten ließ. 32MHz sind idR kein Problem. Gruß
-
Thread
Registerzugriff C Code frage
) Address offset: 0x14 Reset value: 0x0000 0014 der Zugriff erfolgt über den Befehl [c]__enable_peripheral(SPI1EN); // wobei SPI1EN = 44[/c] im stm32f100.h steht dann [c]#define __enable_peripheral(p) (&RCC_AHBENR
0x004 von einer > Registeradresse zur nächsten Registeradresse zustande, wenn die > Registerlänge 32 Bit ist? Ja, per Konvention sind alle Adressen Byte-Adressen. Das ist aber nicht überall so. Ein Gegenbeispiel sind Flash-Adressen auf dem AVR, die zeigen immer auf einen 16 Bit-Wert und werden
-
Thread
Kleinen uC gesucht
mit fast allen aktuellen Microchip Controller über diverse Interfaces. (MIPS EJTAG 4wire, ARM SWD, AVR32 JTAG 4wire, PDI, UPDI, TPI, ISP Programming, DEBUGWIRE, AWIRE)
https://de.farnell.com/microchip/attiny10-ts8r/mcu-8bit-attiny-10mhz-sot-23-6/dp/2443183 ATXMEGA32C4-CU: https://de.farnell.com/microchip/atxmega32c4-cu/ic-8bit-mcu-avr-xmega-32mhz-vfbga/dp/2353907 MSP430FR2632IYQWT: https://de.farnell.com/texas-instruments/msp430fr2632iyqwt/mcu-msp430-16bit-16mhz-dsbga
-
Thread
Pollin Display Optrex F-51154NF-FW-AA
kann man den Aufbau erkennen bzw. desto schmaler ist der waagerechte Strich. Nach dem Debugger vom AVR Studio braucht mein Mega48 aber schon 111ms um den Frame einmal aufzubauen. Meinst du es liegt nur dadran? Denn könnte ich es, wenn mein Kram von Reichelt kommt, mal mit einem schnelleren AVR probieren
nicht befriedigend gelöst, aber es erscheint durchaus "einfach" lösbar. Die Hauptaufgabe des ATMEGA32 ist der Datenempfang / Verarbeitung und Weitergabe an andere AVR´s so auch an den o.g. Display ATMEGA8. Dafür benötigt er nicht die Ports, sondern nur Rechenleistung, RX/TX, SDA/SCL sowie AIN0/AIN1.
-
Thread
C-Script sieht den Wald vor lauter Bäumen nicht
DDRC=0b11111111; DDRD=0b11111111; //Tag-Nacht-Schleife while(1) { int remaining[32];// 32 Lichter //Nacht for(i=0;i<nighttime;i++) { _delay_ms(10); } //�bergang // f�r jedes Licht mal eine zuf�llig Zeitdauer festlegen srand(remaining[10]);
DDRC=0b11111111; DDRD=0b11111111; //Tag-Nacht-Schleife while(1) { int remaining[32];// 32 Lichter //Nacht for(i=0;i<nighttime;i++) { _delay_ms(10); } //�bergang // f�r jedes Licht mal eine zuf�llig Zeitdauer festlegen for(i=0;i<32;i++)
-
Thread
ARM ist die Zukunft?
es heute ist. Für den µC-Bereich ist Thumb wirklich wichtig, und da hat ja Atmel lange mit seinem AVR32 gestänkert, dass die mehr Mips/MHz schaffen. Seit Thumb-2 ist das vorbei. Gibt ja auch keine wirkliche Weiterentwicklung bei AVR32 mehr. Und x86 ist einfach zu komplex, nichtmal der Atom wäre eeignet
Peripherie ist von Hersteller zu Hersteller völlig > unterschiedlich - teilweise ist es einfacher, von AVR32 auf AT91SAM3U zu > portieren als von STM32 auf LPC18xx.
-
Thread
error: expected identifier or '(' before 'volatile' bei AVR Programmierung
" // Define data types typedef uint8_t BYTE; typedef uint16_t WORD; typedef uint32_t DWORD; typedef uint64_t QWORD; // define switch Positions fopr various Antenna testing #define Ant12 0b00100000; #define Ant13 0b10000000; #define Ant14 0b11000000; #define Ant21 0b00000100
" // Define data types typedef uint8_t BYTE; typedef uint16_t WORD; typedef uint32_t DWORD; typedef uint64_t QWORD; // define switch Positions fopr various Antenna testing #define Ant12 0b00100000; #define Ant13 0b10000000; #define Ant14 0b11000000; #define Ant21 0b00000100
-
Thread
Langzeittimer per RC-Glied?
sleep modes and/or interrupt the device at regular intervals. The reference clock is typically the 32.768 kHz output from an external crystal. The RTC can also be clocked from an external clock signal, the 32.768 kHz Internal Oscillator (OSC32K), or the OSC32K divided by 32. The RTC peripheral includes
Wolfram F. schrieb im Beitrag #7339562: > d.h. es müsste ein 32KHz Quarz mit an den Controller? > wie lange wären dann die maximalen Zeiten? > Hatte bislang nur von den magischen 8 Sekunden gelesen... Dass ein AVR auch zählen kann ist Dir bekannt? Man konfiguriert