-
Thread
Wie Objekte in einem Array aktuell halten und umgekehrt?
make_unsigned<int16_t> { typedef uint16_t type; }; template<> struct make_unsigned<int32_t> { typedef uint32_t type; }; template<> struct make_unsigned<int64_t> { typedef uint64_t type; }; //---------------------------------------------------------------
make_unsigned <int16_t> { typedef uint16_t type; }; template <> struct make_unsigned <int32_t> { typedef uint32_t type; }; template <> struct make_unsigned <int64_t> { typedef uint64_t type; }: //-------------------------------------------------------------------------------
-
Thread
Raspberry Pi 5 – schnellere CPU, PCIe, aktive Kühlung und höhere Preise
Prozessordesign, das die Dokumentation folgendermaßen beschreibt: [c] Broadcom BCM2712 2.4GHz quad-core 64-bit Arm Cortex-A76 CPU, with cryptography extensions, 512KB per-core L2 caches, and a 2MB shared L3 cache -via https://datasheets.raspberrypi.com/rpi5/raspberry-pi-5-product-brief.pdf [/c] ![](
einfallslos, weil ich bisher keine weitere Verwendung dafür gefunden habe und bisher "meine" Dinge mit STM32, AVR und ESP32 erledigt habe.
-
Thread
ATmega328/Arduino und weiter?
USB-Interface überfordert scheinbar die Zielgruppe. Dann gibt es noch den Arduino Micro mit ATMEGA32U4.
. Wenn nicht genug Beine vorhanden sind, helfen natürlich die bekannten IO-Expander. Auch wenn der AVR als der Schnee von gestern in gewissen Camps ankommt, spiele ich immer noch ganz gerne mit ihnen. Sind halt schön einfach gehalten und leicht zu verstehen. STM32 erinnern mich ein bisschen zu sehr an
-
Thread
DAC Dithering
Bits geliefert. Mehr aber nicht, da sonst die Nichtlinearität größer war. Ich habe das stur nach AVR-121 gemacht: Oversampling von 16 Werten, d.h. 16 Werte addiert, 2Bit-Rechtsshift und Teilen durch 4 sollte ein Ergebnis mit 12Bit Auflösung, d.h 0,27mV bei Vref=1,1V ergeben. Auch das Rauschen wurde
Angeregt durch die PWM DACs der Keysight Dinger habe ich mal eine Simulation "angestoßen". Ein STM32 erzeugt mir 2x 8Bit PWM (1x MSB und 1x LSB) bei (aktuell) 250kHz, die über Buffer gejagt auf Hi(2,5V)/Lo(0V) gesetzt werden. Hierzu würde ich auch 74LVC04 Hex Inverter nehmen. In der Simulation habe
-
Thread
Drehgeber und Tastenentprellung für Arduino
bessere Optimierung möglich ist, sonst wäre bspw. in Os bei PeDa: 398 text-segment. Compiliert mit avr-g++-13.2.0, der 14.0.0 schmiert bei Deinem Code mit einem ICE ab.
kommerzielle Entwicklungswerkzeuge gewöhnt und schlage Hobbymässig eigentlich nur mit Arduino und sein avr-gcc aus der Art, obwohl STM32 mit dem Atollic Tools natürlich auch gcc verwandt ist. Aber mit dem machte ich schon 10 Jahre kaum noch etwas. Und wenn, dann heutzutage mit Cube IDE . In der Arbeit muß
-
Thread
Attiny85 (SMD) Device signature = 0xffffff
12 4 0 no 512 4 0 4000 4500 0xff 0xff flash 65 12 32 0 yes 8192 64 128 30000 30000 0xff 0xff signature 0 0 0 0 no 3 0 0 0 0 0x00 0x00 lock 0 0 0 0 no
Chips reagieren nicht auf der ISP Schnittstelle. Lies dazu mal die Tipps auf http://stefanfrings.de/avr_verfused/index.html
-
Bild
Übersicht der AVR EA Familien-Mikrocontroller
Family Overview The figure below shows the AVR EA Family devices, laying out pin count variants and memory sizes: Vertical migration is possible without code modification, as these devices are fully pin and feature compatible Horizontal migration to the left reduces the pin count and, therefore, the available features Figure 1. AVR EA Family Overview Flash 64 KB AVR64EA28 AVR64EA32 AVR64EA48 32 KB AVR32EA28 AVR32EA32 AVR32EA48 16 KB AVR16EA28 AVR16EA32 AVR16EA48 Pins 28 32 48
-
Thread
ATtiny85 mit PlatformIO und Arduino Uno als Programmer
Using Programmer : stk500v1 Overriding Baud Rate : 19200 AVR Part : ATtiny85 Chip Erase delay : 4500 us RESET disposition : possible i/o RETRY pulse : SCK
0 no 512 4 0 4000 4500 0x00 0x00 flash 65 10 64 0 yes 8192 64 128 4500 4500 0x00 0x00 lfuse 0 0 0 0 no 1 1 0 9000 9000 0x00 0x00 hfuse 0 0
-
Thread
Serial RX Buffer Arduino
\Local\Arduino15\packages\arduino\hardware\avr\1.8.6\cores\arduino/HardwareSerial.h:53:0: note: this is the location of the previous definition #define SERIAL_RX_BUFFER_SIZE 64[/code] aber compiliert, und - tataa, funktioniert nicht. Bleibt bei
alles ungeeignet. Da muss ich precompilieren und zum Batch greifen, Arduino macht das ja auch mit AVR-Dude oder so... Gruss Chregu
-
Thread
Peter Dannegger´s ( PeDa ) Entprellroutine in ein Arduino Sketch einbinden
Fehlermeldung : In file included from C:\Users\Ich\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.8.6\cores\arduino/Arduino.h:30:0, from G:\AVR-Projekte\Arduino\MEGA2560 Board\GLCD_ST 7920\Entprellen\GLCD_entprellen\GLCD_entprellen.ino:1: G:\AVR-Projekte\Arduino\MEGA2560 Board
Ich vermute, dass diese Zeile fehlt: [c] #include <avr/interrupt.h> [/c] Die Doku dazu: https://www.nongnu.org/avr-libc/user-manual/group__avr__interrupts.html
-
Artikel
AVR-Tutorial: ADC
Eingangsspannung anpassen kann. ADPS2 ADPS1 ADPS0 Vorteiler 0 0 0 2 0 0 1 2 0 1 0 4 0 1 1 8 1 0 0 16 1 0 1 32 1 1 0 64 1 1 1 128 Beispiel: 8 MHz Prozessortakt: 8.000.000 Hz / 200.000 Hz = 40 Da mit 200 kHz gerechnet wurde (maximale Frequenz), nimmt man den nächsthöheren Wert, also 64. 8.000.000 Hz / 64 = 125.000
Letzt werden die Berechnungen nur mit der minimal notwendigen Wortbreite durchgeführt. Am Anfang mit 32 Bit, dann nur noch mit 16 bzw. 8 Bit. Literatur. Datenblatt des verwendeten Controllers Application Note AVR127: Understanding ADC Parameters (PDF; 777 KB) Application Note AVR121: Enhancing ADC resolution
-
Artikel
Umstieg von Arduino auf AVR
kleine, aber hilfreiche Schritte aufgezeigt. Diese Anleitung ist nur für die Arduinos mit einem 8bit-AVR als Prozessor (Uno, Mega, Leonardo, ...) gedacht und nicht für 32bit-Mikrocontroller (Due, ...). Der Mikrocontroller wird in dieser Anleitung in C programmiert. Grund dafür ist die Verteilung von Programmiersprachen
Typen definiert: Größe Vorzeichenlos Vorzeichenbehaftet 8 bit uint8_t int8_t 16 bit uint16_t int16_t 32 bit uint32_t int32_t 64 bit uint64_t int64_t Die Nomenklatur ist eigentlich ganz einfach: [u]int[bits]_t, wobei das [u] für unsigned, also vorzeichenlos, steht und [bits] eben die Anzahl der Bits für
-
Artikel
AVR-GCC-Tutorial/Die Timer und Zähler des AVR
eine Auflösung von 256 (2^8) aufweisen und 16-Bit Timern mit einer Auflösung von 65536 (2^16). Alle AVR-Modelle verfügen über mindestens einen, teilweise sogar zwei, 8-Bit Timer. {| class="wikitable" style="text-align:center" AVR-Typ Timer/Counter0 Timer/Counter1 Timer/Counter2 AT90S2313 8 16 - ATtiny2313
8- oder 10-Bit-High-Speed-Timer, der von einer besonderen internen Taktquelle (RC-Oszillator) mit 64 MHz (bei 5 V Betriebsspannung) bzw. 32 MHz (bei 3 V Betriebsspannung) getaktet werden kann. Im Datenblatt PCK genannt. Sein Hauptanwendungsgebiet ist die (BLDC-)Motorsteuerung mit Halbbrücken-Endstufen
-
Thread
Linkerscript verstehen lernen - Wo fängt man an?
ihren Startup-Code und das Linkerscript selber. Z.B. https://vivonomicon.com/2018/04/02/bare-metal-stm32-programming-part-1-hello-arm/
"Figure 1" an, dann verstehst Du warum. https://www.st.com/resource/en/reference_manual/rm0394-stm32l41xxx42xxx43xxx44xxx45xxx46xxx-advanced-armbased-32bit-mcus-stmicroelectronics.pdf Du wirst vermutlich aber trotzdem keinen großen oder gar keinen Vorteil daraus ziehen, die Funktion in den RAM zu
-
Thread
Firmware entschlüsseln, Updateprogramm als Hilfe?
Siehe Bild, das zeigt mir "meine" Suchmaschine bei "AVRE32 SVD", markiert ist der interessante Bereich. Mein Browser speichert keine Daten zwischen den Sitzungen, sonst gibt es keine besonderen Maßnahmen für Anonymität.
Dieter S. schrieb im Beitrag #7502966: > Siehe Bild, das zeigt mir "meine" Suchmaschine bei "AVRE32 SVD", > markiert ist der interessante Bereich. Jetzt kommen wir der Sache näher! Ich hab nur nach AT32F2/AT32F421 SVD gesucht. Mit und ohne Hersteller dazu usw.. Oliver S. schrieb im Beitrag
-
Thread
DS3231SN RTC Module mit DS3231M (MEMS) Typ installiert
Problem? Sind die Module für deine Verwendung als RTC zu ungeau? Brauchst du unbedingt den genauen 32kHz Ausgang? Wenn nein -> Enjoy life!
conversion is completed. Temperature conversion occurs on initial application of VCC and once every 64 seconds afterwards. Der DS3231M hat einen MEMS Resonator der über einen festen Teiler den 32kHz Ausgang treibt. Das 1 Hz Signal wird daraus, der Temperatur und bei der Herstellung abgelegten Kalibrierwerten
-
Thread
for-Schleife - Bit verschieben
++ und bringt das QByte in eine menschenlesbare Darstellung: [code] newtype QByte = QByte Word32 deriving (Eq, Bits, Ord, Show) [/code] Ähnliche Datentypen kann man natürlich auch für 8, 16 oder 64 Bits definieren.
Funktionalitäten, die der Standard so nicht bietet. Er wird sowas abgesehen davon vermutlich auch nicht für AVR brauchen, denn der hat eher wenige 32-Bit-Register. Damit kann er dann eh nicht auf deine AVR-Umsetzung der Standardbibliothek zurückgreifen. > 8) Meine Realisierung des Typs std::byte umfasst zwei
-
Thread
ESP32: Wie das beste aus dem ADC herausholen?
nur 4fach gibt's bei der Arduino-Fraktion gute Lösungsansätze. Aber dann brauche ich auch keinen ESP32, dann kann ich die eigentliche Regelaufgabe auch mit einem AVR machen und zur Kommunikation den einfacheren ESP8266 verwenden.
Yep, sehe das schon kommen... aber wenns schiefgeht kann ich die Platine mit dem ESP32 immer noch wieder runternehmen und stattdessen eine mit AVR oder externen ADCs draufpacken, dann würde die Schaltung immerhin trotzdem funktionieren. Was ich mit dem ESP32-Board mal testen werde:
-
Thread
Aktuelle 8051-Clone - so kompatibel wie möglich
der DS80C320 aktuell war, mal einige Schaltungen re-designed, seitdem habe ich eigentlich nur noch AVR und ARM benutzt. Bei der Zielanwendung ist aber so viel trickreich in MCS51 Code gelöst und es muss nur so wenig ergänzt werden, dass der Aufriss, ein AVR- und ARM-Board in den 8051 Sockel zu adaptieren
2kB SRAM kannst Du zur Laufzeit umschalten und so die gesamten 64kB XDATA nach extern mappen.
-
Thread
Wertzuweisung Arduino - Kann mir das jemand erklären?
sketch_aug06f.ino:2:42: warning: overflow in constant expression [-fpermissive] [/c] Compiler: avr-gcc-11.1.0-x64-windows
macht wenig Sinn, auf einem AVR für alle Variablen immer 64-Bit-Breiten zu nutzen. Umgekehrt werden viele 32-Bit-Prozessoren ausgebremst, wenn sie eine zu kleine Wortbreite zum Rechnen verwenden. Ebensowenig macht es Sinn, für verschiedene
-
Thread
Wie benutze ich die Timer vom AM64x von TI
verbinde ich einen Timer mit einem Interrupt? In der API (https://software-dl.ti.com/mcu-plus-sdk/esd/AM64X/latest/exports/docs/api_guide_am64x/group__KERNEL__DPL__TIMER.html) finde ich so etwas, wie [c]uint32_t TimerP_isOverflowed(uint32_t baseAddr)[/c]. Um das zu benutzen, müsste ich ja selber aktiv auf
als uint definierst, dann geht es so (zum besseren Verständnis etwas umständlich): [c]const uint32_t basisadresse = <irgendwas>; const uint32_t offset = <irgendwas>; uint32_t *REG_adresse; // Hier mit * REG_adresse = basisadresse + offset; // Hier ohne * *REG_adresse |= 0x01; while (*REG_adresse
-
Thread
Probleme mit Werten vom BME280
sollte auch das Handling von Multi-Byte Registern vorgenommen werden damit diese mit int16 und int32 Werten ohne Klimmzüge klar kommen. Testen gegen Datenblatt + Read/Write Tests. Implementiert nach Datenblatt des Sensors. Beispiele: int8_t reg_read(), int32_t reg_read, reg_write(int16_t) 3.)
es zusammen mit TurboPascal in der Schule gelernt habe (>25 jahre). Ich weiß das 8086 Assembler und AVR unterschiedlich sind, hat mich aber damals (als ich AVR entdeckte) mehr angesprochen als C. Auch habe ich die Sensorregister gelesen (z.B. die ID) und dazu muss ich das Register ja entsprechend adressieren
-
Thread
ADC - Wert berechnen
Lothar M. schrieb im Beitrag #7457590: >> Es gibt ja auch noch double (64 Bit) und long double (80 Bit). > Klar. Aber das macht den 8-Bit-Andruiden nicht schneller Und auch FPU der ARM Coretx-M Controller kann nur 32 Bit float.
Beim Arduino wurde die Zeit per Oszi gemessen. In beiden Fällen mit 16 MHz CPU-Takt. [pre] WinAVR-20100110 FLASH /B RAM /B Zeit /us float 2860 264 197,0 int32 186 0 4,1 Arduino 1.8.13 FLASH /B RAM /B Zeit /us float 1666 9 23,0
-
Thread
Falsche Signature Bytes bei von mir gekauften China Nano mit 328PB
] Ja, natürlich *kann* man das auch anders machen, wenn man möchte (und einen hinreichend neuen AVR hat – zu Zeiten von AVR109 ließ sich sowas gar nicht im Programm auslesen), aber man *muss* es eben auch nicht, wenn man einen Bootloader hat, der eh nur auf genau einem vorher bekannten Controller
Bords sind sauber gelötet und vom Flußmittel befreit. Kann mich eigentlich nicht beklagen. Für USD5.64 das Stück, nehme ich das BL Problem ohnehin ohne Murren in Kauf.
-
Thread
Index von Array: welcher Datentyp in C
, der native > "zur Maschine passt" und damit effizient ist (von kleinen Architekturen > wie dem AVR abgesehen, bei denen ein "int" zwei Byte benutzt). … und abgesehen von großen Architekturen, wo die native Breite 64 Bit ist und int nur 32 Bit. Wilhelm M. schrieb im Beitrag #7455231: > Arduino
include <stdint.h> int foo_char(int array[], char index) { return array[index]; } int foo_i32(int array[], int index) { return array[index]; } int foo_u32(int array[], unsigned index) { return array[index]; } int foo_i64(int array[], int64_t index) { return array[index]; } int foo_u64
-
Artikel
AVR-Tutorial
Ausser diesem Tutorial gibt es noch das AVR-GCC-Tutorial sowie die Artikel in der :Kategorie:avr-gcc Tutorial. Aufbau des Tutorials. Einleitung: Worum geht es überhaupt? Benötigte Ausrüstung: Welche Hard- und Software brauche ich, um AVR-Mikrocontroller
Artikel Entscheidung Mikrocontroller zusammengefasst. Viele dieser Anforderungen werden von den 8-bit-AVR-Controllern von Atmel erfüllt. Deshalb werde ich einen AVR, genauer gesagt den ATmega8, in diesem Tutorial einsetzen. Und damit kein Missverständnis aufkommt: So etwas wie den "besten" Controller gibt
-
Thread
8-Bit CPU Selbstbau
einen Beitrag (https://www.mikrocontroller.net/topic/21734 ) in diesem Forum. Tobias wollte aber eine 32bit CPU bauen, ich nicht. Meine Fragen an euch: was haltet ihr von meinem noch nicht fertigen Design, und was kann ich verbessern? Vg Florian Ich bin übrigens 16 Jahre alt.
von Florian T. schrieb: >Tobias wollte aber eine 32bit CPU bauen, ich nicht. Die Grundlagen sind immer die selben, egal ob 4Bit, 8Bit oder 32Bit. Als erstes brauchst du Logig-Schaltstufen, AND, OR, NAND, NOR. Davon tausende. Die kann kann man mit
-
Thread
ATtiny Typenchaos bei Microchip Gesperrt
| AVR128DA48 | AVR128DA64 ___________|____________|____________|_____________ AVR32DB28 | AVR32DB32 | AVR32DB48 | AVR64DB28 | AVR64DB32 | AVR64DB48 | AVR64DB64 AVR128DB28 | AVR128DB32 | AVR128DB48
| AVR32DD32 AVR64DD14 | AVR64DD20 | AVR64DD28 | AVR64DD32 28 Pin | 32 Pin | 48 Pin | ___________|____________|____________| AVR64EA28 | AVR64EA32 | AVR64EA48 | [/c]
-
Bild
Ausschnitt aus einem Datenblatt von AVR Mikrocontrollern
AVR64DD28_32.pdf (SECURED) - Adobe Reader Memory Overview Table 1. Memory Overview AVR16DD14 AVR32DD14 AVR64DD14 AVR16DD20 AVR32DD20 AVR64DD20 AVR16DD28 AVR32DD28 AVR64DD28 AVR16DD32 AVR32DD32 AVR64DD32
-
Bild
Microchip Packs Repository Webseite
Device Support (3.0.158) Download Microchip ATtiny Series Device Support (3.0.151) Download Microchip AVR-Dx Series Device Support (2.3.272) Download AVR128DA28 AVR128DA32 AVR128DA48 AVR128DA64 AVR128DB28 AVR128DB32 AVR128DB48 AVR128DB64 AVR16DD14 AVR16DD20 AVR16DD28 AVR16DD32 AVR32DA28 AVR32DA48 AVR32DB28 AVR32DB32 AVR32DB48 AVR32DD14 AVR32DD20 AVR32DD28 AVR32DD32 AVR64DA28 AVR64DA32 AVR64DA48 AVR64DA64 AVR64DB32 AVR64DB48 AVR64DB64 AVR64DD14 AVR64DD20 AVR64DD28 AVR64DD32 2.3.272 (2022-12-16) - MPLAB X600
-
Bild
Microchip Packs Repository Webseite
Series Device Support (2.0.401) Download Atmel ATtiny Series Device Support (2.0.368) Download Atmel AVR-Dx Series Device Support (2.2.253) Download AVR128DA48 AVR128DA32 AVR128DA48 AVR128DA64 AVR128DB28 AVR128DB32 AVR128DB48 AVR128DB64 AVR16DD14 AVR16DD20 AVR16DD28 AVR16DD32 AVR16DA32 AVR16DA48 AVR32DB28 AVR32DB32 AVR32DB48 AVR32DD14 AVR32DD20 AVR32DD28 AVR32DD32 AVR64DA28 AVR64DA32 AVR64DA48 AVR64DA64 AVR64DB28 AVR64DB32 AVR64DB48 AVR64DB64
-
Thread
AVR64DD20 - USART stürzt bei großem Buffer ab
Hallo liebes mikrocontroller.net - Forum, ich habe heute die USART meines AVR64DD20 programmiert und mit ein paar Änderungen von der Bibliothek von Microchip selbst ( https://github.com/microchip-pic-avr-examples/avr64dd32-getting-started-with-i2c-mplabx , lediglich anderer Pin
ein paar Änderungen von der Bibliothek von Microchip selbst ( > https://github.com/microchip-pic-avr-examples/avr64dd32-getting-started-with-i2c-mplabx > , lediglich anderer Pin) verwendet. Die ganz gewöhnliche > printf-Funktion, die jetzt den USART-stream verwendet, Ist das denn geklärt, dass
-
Artikel
Reichelt-Wishlist
TQFP-Gehäuse zu haben sind wie z. B. XC3S400 oder XC3S500E (PQFP208)) | | | | | | * Microchip megaAVR 0-series, z. B. ATmega809/1609/3209/4809 in TQFP-48 Microchip AVR128DB…, AVR64DD… in SOIC und TQFP Microchip dsPIC33FJ128GP802 | Microchip PIC12F1822 | Microchip PIC24HJ64GP202-I/SP | NXP LPC1114 (auch
mehrere tage. (In der Zwischenzeit realisiert ) | | | (oder klare Anzeige wie viel noch vorhanden ist) AVR mit USB: AT90USB1287 (AT 90USB1287 TQ, TQFP64), dazu passendes Demoboard AT 90USB KEY; AT90USB162TQ (AT 90USB162 TQ, TQFP32), AT90USB646 (AT 90USB646 TQ, TQFP64), AT90USB1286QFN (AT 90USB1286 QFN, QFN64
-
Thread
PIC-Programmierung, analoger Input, Debugging
Wird nicht einfach. Mach dein leben nicht schwer, kauf dir etwas was schneller ist. dsPIC oder PIC32.
bereits 6 bit... > Ich bin Neuling, kannst du das bitte ein wenig mehr ausführen ? 6 bit enspricht 64 unterscheidbaren Signalpegeln. Das reicht, um eine Uebersteuerung oder grundsaetzliche Fehler in Algorithmen zu erkennen. Mehr kann man auf den ueblichen Oszis ohnehin kaum erkennen.
-
Thread
Arduino Uno R4 im Handel erhältlich
Pinout-Daten.  Bildquelle: Arduino ### Arduino Uno R4 WiFi – mit ESP32 und LED-Matrix Unter https://store.arduino.cc/products/uno-r4-wifi wechselt die größere Variante um 25 EUR den Besitzer. Neben einem auf einem ESP32-S3 basierenden Funkmodul bringt sie eine LED-Matrix
Heute könnte man sich so etwas mit den etwas einfacheren Varianten der RISC-V-µCs von WCH bauen, der CH32V103x8x6 wäre da ein Kandidat. Kann mit 5V betrieben werden (also nicht nur 5V-tolerante I/Os), 20 kiB RAM, 64 kiB Flash, bis zu 72 MHz CPU-Takt, LQFP/QFN48 und LQFP64. Ist wohl was die Peripherie angeht
-
Thread
Lesen/Schreiben FRAM klappt nicht
verwenden könnte, statt "void"? Ich weiss ja nicht mal, mit was für einem MC du da rummachst. Wenns AVR wäre, verlasse ich mich da auf die bei mir sehr bewährte Library von PFleury. Für STM32 habe ich hier was für die SPL, was auch Fehler meldet. Harald K. schrieb im Beitrag #7442779: > Und wo ist
. mit EEPROM-Puffer. Für Deine Anwendung etwas verfehlt. SPI-RAM aber gibt es (z.B. 24LC512 mit 64 kiB).
-
Thread
I2C-Bus: SDA und SCL an ATMEGA328p
> Oje, der arme PCF8591 kann doch nur max 100kHz. Ohne Delays wird das > nichts bei nem 16MHz AVR. Hab egerade einen ATtiny2313MU mit 8Mhz und en 64x32 OLED am laufen. Das geht komplett problemlos, obwohl ja eigentlich "ein wenig zu schnell", Stimmt schon. Ging ja auch eher um die Makros von
Axel R. schrieb im Beitrag #7445111: > Hab egerade einen ATtiny2313MU mit 8Mhz und en 64x32 OLED am laufen. Das OLED ist ja auch kein PCFxxx. Die alten PCFxxx kann man vielleicht bis 200kHz triezen, aber das wird schon instabil. Neuere ICs können dagegen oft über 1MHz I2C Takt.
-
Thread
Windows - CP2012 USB to UART Bridge Controller
schauen... Die IDE kann nur anzeigen, was sie erkennt. Eine USB-Bridge ist erstmal kein ESP8266/ESp32 o.ä. Wenn sie einen ESP32 mit nativem USB erkennt, wird sie das auch verraten. War bei den AVR auch schon so, nur die USB-AVR konnten identifiziert werden. Gruß aus Berlin Michael
... > Die IDE kann nur anzeigen, was sie erkennt. Eine USB-Bridge ist erstmal > kein ESP8266/ESp32 o.ä. Wenn sie einen ESP32 mit nativem USB erkennt, > wird sie das auch verraten. War bei den AVR auch schon so, nur die > USB-AVR konnten identifiziert werden. > > Gruß aus Berlin > Michael
