-
Thread
David Jones über PIC vs AVR
sind gleich gut, schwer, oder schlecht. Wenn die alle so gleich wären, warum findet man dannbei AVR keine uC mit eingebautem LCD Treiber die NICHT 64 pins gross sind, Warum findet man unter den gefühlt 10000 Varianten keine AVR mit 100mA Treibern für LED-Multiplexanzeigen. Warum kann ein AVR
, oder was sonst auch speziell ist. > > Wenn die alle so gleich wären, warum findet man dannbei AVR keine uC mit > eingebautem LCD Treiber die NICHT 64 pins gross sind, > > Warum findet man unter den gefühlt 10000 Varianten keine AVR mit 100mA > Treibern für LED-Multiplexanzeigen. Weil das dann
-
Thread
ATtiny13A bzw. allgemein AVRs: was passiert beim Reset? Gesperrt
meiner Rente noch problemlos kaufen kann. Ich erwarte, dass einzelne Typen (zum Beispiel der ATMega32) abgeschafft werden, aber für die wird es Ersatz geben. Nichts desto Trotz ist für mich offensichtlich, dass alle Hersteller auf 32 und mehr Bits setzen. Die 8 bit AVR Kerne betrachte ich als ausgereift
Grundlagen dann spielt die Menge der Bits einer Architektur auch keine Rolle mehr. > Die 8 bit AVR Kerne betrachte ich als > ausgereift und daher langweilig. mmhhh ausgereift auf jedenfall langweilig ?? Sicher nicht! Vom Prinzip her ist es egal ob die Architektur 4/8/16/24/32/64/128...Bit verarbeiten
-
Thread
CAN-Sender im Mini-Format
Eine weitere Möglichkeit wäre das Olimexino-STM32: https://www.olimex.com/Products/Duino/STM32/OLIMEXINO-STM32/open-source-hardware Nicht die kleinste Variante, dafür aber geringer Aufwand, weil alles schon fertig aufgebaut ist (Mikrocontroller mit
Dr. Sommer schrieb im Beitrag #5495474: > Eine weitere Möglichkeit wäre das Olimexino-STM32: > https://www.olimex.com/Products/Duino/STM32/OLIMEXINO-STM32/open-source-hardware > Nicht die kleinste Variante, dafür aber geringer Aufwand, weil alles > schon fertig aufgebaut ist (Mikrocontroller
-
Thread
xmega Taktfrequenz
Folgender Code ergibt die Messung im Anhang (gemessen am Ausgangspin): [code] #include <avr/io.h> #define F_CPU 32000000UL #include <util/delay.h> int main( void ) { OSC.CTRL |= OSC_RC32MEN_bm; while(!(OSC.STATUS & OSC_RC32MRDY_bm)); CCP = CCP_IOREG_gc; CLK.CTRL = CLK_SCLKSEL_RC32M_gc
Nimm die PLL. 64MHz vertragen die xmegas noch..
-
Thread
Schiebetür Steuerung
soweit funktioniert er! würde mich auf verschiedene Lösungsvorschläge freuen LG [code] avr.device = atmega328p //Controller-Typ festlegen avr.clock = 8000000 //Dem Compiler mitteilen mit welcher Taktrate der Controller läuft avr.stack = 64 //Den Programmstack
Timer1 ***** Timer1.Clock = 256 '* Clock divider auf 1: 256 (8 Mhz = 125ns * 256 = 32uSec) Timer1.CmpA.Value = 3124 '* Outputcompare-Register auf 3125 ( 3125 * 32uSec =100mS) Timer1.CmpA.Isr = timer1_compare '* Compare-Interrupt aktivieren Timer1.CmpA.Clear.Enable
-
Thread
Linux Distribution für Mikrocontroller Programmierung?
Mint installieren, dann apt-get install acc-avr avrdude avr-libc kate konsole dann hast Du alles was Du (zumindest für AVR) brauchst. Als Editor dann Kate und dort unter plugins die terminal tools aktivieren.
Programmiert werden können: - nahezu alle AVR (Avrdude und AVR-GCC machen es möglich) - STM32: F030, F051, F103, F401, F411, F429 - STM8: STM8S103 / 003, STM8S105 - PIC16F: 16F887, 16F648, 16F630 - PIC18F: 18F52 - MCS51: AT89S51 / 52, AT89S8253
-
Thread
Serieller Plotter gesucht
Schnittstelle reinkommen ordentlich als Graph darstellen kann. Erzeugt werden die Daten durch einen AVR, d.h im Eingabeformat wäre ich recht frei. Zur Zeit verwende ich hierfür den Plotter der Arduino IDE. Damit bin ich aber weniger zufrieden, da sich im Nachhinein die Daten nicht mehr betrachten lassen
10. http://serialcominstruments.com/serial.php Kompatibel mit Window XP / Vista / 7 / 8 , 32 oder 64 bit Herbert schrieb im Beitrag #5487414: > Nur leider kommt > immer Buffer Overflow als Meldung sodass keine Verbindung möglich ist. Scheinbar wird Windows 10 (noch) nicht unterstützt
-
Thread
Wie und wie oft Bibliotheken benutzen?
auf den Markt kamen und das Datenblatt mehr den Namen Rätselheft verdient hätte. Ich hätte den ESP32 wohl kaum angefasst ohne Bibliotheken und Beispiele wenn ich da nur mit dem IDK alles hätte selber machen müssen. Gruß aus Berlin Michael
Base64 U. schrieb im Beitrag #5486895: > Einerseits erspart es dir die Arbeit und Zeit alle peripheriebausteien > in einem µC manuell über die Register an zu sprechen, Das spart weder Zeit noch Arbeit.
-
Thread
ATMEL SAM3X8 (Arduino Due) printf auf beliebiges Device umleiten?
da auch der gcc-arm-embedded mit newlib genutzt wird: https://www.mikrocontroller.net/articles/STM32_Eclipse_JLink_Linux/Windows#Optional:_Syscalls_implementieren
FVAR -0.0000 Die Kiste-Maggi Frage: wo liegt das Problem? Ach, wie war die Welt mit libc und dem AVR doch so schoen.... VG yogy
-
Thread
TIMER0 Normal Mode bei 2560
gCbi .if @0<32 cbi @0,@1 .else xIn WL,@0 cbr WL,(1<<@1) xOut @0,WL .endif .endmacro .macro gSbi .if @0<32 sbi @0,@1 .else xIn WL,@0 sbr WL,(1<<@1) xOut @0,WL .endif .endmacro[/c] Für spezielle Zugriffe sind diese auch sinnvoll: [c].macro gSbic .if @0<32 sbic @0,@1 .else xIn WL,@0 sbrc WL,@1 .endif .endmacro .macro gSbis .if @0<32 sbis @0,@1 .else xIn WL,@0 sbrs WL,@1 .endif .endmacro[/c] Wir nutzen darüber hinaus noch folgende
-
Thread
Maiskolben Lötstation Fehler beim Kompilieren
-DF_CPU=16000000L -DARDUINO=10805 -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR "-IC:\Users\Holger\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.6.21\cores\arduino" "-IC:\Users\Holger\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.6.21
0b11111000) | 6; //PWM Prescaler = 128 245Hz TCCR2B = (TCCR2B & 0b11111000) | 5; //PWM Prescaler = 64 490Hz //TCCR2B = (TCCR2B & 0b11111000) | 4 //PWM Prescaler = 32 980Hz //TCCR2B = (TCCR2B & 0b11111000) | 3; //PWM Prescaler = 8 3.9kHz //TCCR2B = (TCCR2B & 0b11111000) | 2 //PWM
-
Thread
Digitaler Bilderrahmen, ePaper, Batteriebetrieb, portabel
gar nicht. https://youtu.be/znfEyW1eg7Y Als Controller habe ich einen Pro-Micro-Clone (Atmega 32u4, 3,3 V, 8 MHz, 32 k Flash, 2.5 k RAM) eingesetzt, im Prinzip ginge es mit jedem Atmega ab 32 k Flash und 2 k RAM, wenn die Sektor-Puffergröße für das Lesen von der SD-Card reduziert wird. Der Programmcode
versorgt und kann damit komplett abgeschaltet werden. Die dekodierten Bilddaten werden in einem SPI-RAM (64 kByte, 23LC512) zwischengespeichert, es ist nicht möglich, sie gleich im Framebuffer des ePaper-Moduls abzulegen. Mittels Fotodiode BPW34 wird die Umgebungshelligkeit geprüft und das Display-Update
-
Thread
Programmdurchlauf auf Atmega - Frequenz
Funktionen sitzen 2,66MHz Ausgabe Frequenz drin. Auf einem 16MHz Uno. Ein Toggle braucht auf einem AVR Arduino also 3 Taktzyklen, incl Endlosschleife.
> ausgegeben werden soll. Der Puffer ist dann ratz-faz voll. Richtig! Arduino Serial hat eine 64 Byte FiFo. Die ist Ruckzuck voll, und danach blockieren die Print Methoden, bis wieder Platz ist.
-
Thread
Enum oder #define?
Prüfst du ob alle 100 Programme den nirgends nutzen? Sowas hab ich total gern: [c]#include <stm32f4xx.h> // Klasse zur Behandlung der RCC-Peripherie class RCC { // <- Hier kryptische Fehlermeldung };[/c]
leider hatten die Erfinder von C ganz andere Prioritäten Vor allem: ganz andere Möglichkeiten. 64 KiB für Code und 64 KiB für Daten (sofern sie glücklich genug waren, den Hack für "Split I&D" in ihrer PDP-11 nachgerüstet zu haben). > und auch > diejenigen die all die Jahre den C Standard
-
Thread
SPI Flash Programmer
PS: Gerade vergessen: Dein AVR ist ja ein Microchip AVR, der per UPDI programmiert wird. Daher bitte das "wie den AVR auch" streichen. Du bräuchstest ein 10-poliges TagConnect Kabel. GND VTarget AVR Reset SPI CS SPI SCK
Frank K. schrieb im Beitrag #5481249: > PS: Gerade vergessen: Dein AVR ist ja ein Microchip AVR, der per > UPDI > programmiert wird. Daher bitte das "wie den AVR auch" streichen. > > Du bräuchstest ein 10-poliges TagConnect Kabel. > > GND > VTarget > AVR Reset
-
Thread
IRLML2244 und IRLML6244 als "normale" Mosfet
Habe im Netz einen Schaltplan für einen Solar-LED-Strahler gefunden http://www.elektronik-labor.de/AVR/LEDstrahler.html Das Löten traue ich mir zu, jedoch die beiden SMD Mosfets IRLML2244 und IRLML6244 bereiten mir etwas Kopfzerbrechen. Gibt es denn "normale" Mosfets als Ersatz? Danke schon mal im
Schaltfrequenz (Timer1, 32 oder 64 Mhz) - Statt Spannungsregelung mit Vorwiderstand direkt den Strom durch die LED regeln. Der Tiny45 hat netterweise einen 20× Verstärker mit drinnen, damit der Shunt klein ausfallen kann.
-
Thread
Drehgeber Tutorial
// power on state enc_delta = 0; TCCR1B = (1<<CS11) | (1<<CS10); // prescaler 64 TCCR1B = (1<<WGM12) ; // CTC OCR1A = (uint8_t)(XTAL / 64.0 * 1e-3 - 0.5); // 1ms TIMSK1 |= (1<<OCIE1A); } ISR( TIMER1_COMPA_vect ) // 1ms for manual movement {
überschreibst die Timer-Konfiguration in TCCR1B: [c] TCCR1B = (1<<CS11) | (1<<CS10); // prescaler 64 TCCR1B = (1<<WGM12) ; // CTC [/c]
-
Thread
Warum Pascal/Delphi/Lazarus oft unbeliebt?
Der AVR wird auch unterstützt ;-) http://wiki.freepascal.org/AVR_Embedded_Tutorial/de
://electronics.stackexchange.com/questions/200055/most-efficient-way-of-creating-a-bool-array-in-c-avr
-
Thread
Problem mit INT0 auf Attiny24A
in den Powerdown und wacht auch beim auslösen des INT0 wie gewünscht wieder auf! [c] #include <avr/io.h> #include <avr/sleep.h> #include <avr/interrupt.h> #include <inttypes.h> const uint8_t Muster[] = {0x08, 0x44, 0x4C, 0x55, 0x5D, 0x77}; volatile uint8_t Zahl = 1; int main(void) {
PORTB = (1<<PB2); // Prescaler 8 => 128.000/8 = 16.000 Hz TCCR0B = (1<<CS01); // Prescaler 64 => 128.000/64 = 2.000 Hz TCCR1B = (1<<CS11) | (1<<CS10); // Overflow Interrupt für Timer0 erlauben TIMSK0 |= (1<<TOIE0); // Overflow Interrupt für Timer1 erlauben TIMSK1 |= (1<<TOIE1);
-
Thread
RasPi Daseins-Berechtigung?
fragte ich mich, was man damit (hardwarenah) machen kann und was der > killer Vorteil ggü den üblichen AVR Basteleien (hier) ist? Versuche mal, mit einem AVR irgendwelche Zeitrafferaufnahmen mit der zugehörigen Kamera zu machen.
ich mich, was man damit (hardwarenah) machen kann und was der > killer Vorteil ggü den üblichen AVR Basteleien (hier) ist? Leider kann man nur relativ wenig machen, was man nicht auch mit einem AVR8-System hinbekommen könnte. Umgekehrt kann man aber mit einem AVR8-System vieles machen, was mit
-
Thread
Modelleisenbahn Weichen Ansteuern
Michael_SS schrieb im Beitrag #5466706: > Ich würde gern mit einem ATMEGA64 die Weichen einer Modellbahnanlage > ansteuern. ATMEGA64 auf einen Waggon platzieren und den Zug von den Schienen leiten lassen. Dann braucht man gar nicht steuern. > Danke für eure Ideen.
Michael_SS schrieb im Beitrag #5467476: > nullsteuer schrieb im Beitrag #5467100: >> ATMEGA64 auf einen Waggon platzieren > Gute Idee, danke. Werde ich machen nimm lieber den 32 der ist kleiner, wenn du Platz hast, Spur 0 dann geht natürlich auch ein 1284p
-
Thread
Ähnlicher (gleicher) ersatz für 80c537
fuer ein copy von A nach B muss man immer wieder das Indexregister neu befuellen. Waehrend zB ein AVR 3 Indexregister hat. Der 8051 hat einen clock div 12 Teiler, waehrend die AVR keinen Teiler benoetigen. Bedeutet, beim 8051 hat man mit einem 12MHz Clock 1 MOps, waehrend es beim AVR 12 MOps sind
Vielleicht magst du mit STM32 einsteigen. http://stefanfrings.de/stm32/index.html
-
Thread
Probleme mit Multiplexen
Ausgabe = (Ausgabe + 16 ); } if (PIND3 == 0) { Ausgabe = (Ausgabe + 32 ); } if (PIND4 == 0) { Ausgabe = (Ausgabe + 64 ); } if (PIND5 == 0) { Ausgabe = (Ausgabe + 128 ); } if (Ausgabe >= 100) { Ausgabe
== 0) { Zahl = (Zahl + 16 ); } if (PIND3 == 0) { Zahl = (Zahl + 32 ); } if (PIND4 == 0) { Zahl = (Zahl + 64 ); } if (PIND5 == 0) { Zahl = (Zahl + 128 ); } if (Zahl >= 100) { Zahl = 99 ; }
-
Thread
Attiny85 Timer1 PWM: Keine Duty-Cycle-Formel (da nichtlinear?)
sieht eigentlich das Programm aus? Mein Testprogramm sieht im Moment so aus: [c] #include <avr/io.h> #include <avr/interrupt.h> #include <avr/cpufunc.h> // "nop" #include "tinyProj.h" #define IDX0 6400 ISR(TIMER1_OVF_vect){ static uint16_t idx = IDX0; static uint8_t val = 0;
haben sich beim umschreiben ein paar Fehler eingeschlichen.. Jetzt sollte es passen: [c] #include <avr/io.h> #include <avr/interrupt.h> #include <avr/cpufunc.h> // "nop" #define IDX0 6400 ISR(TIMER1_OVF_vect){ static uint16_t idx = IDX0; static uint8_t val = 0; if(!(--idx)){ OCR0B
-
Thread
myAVR Board light und myAVR Workpad arbeiten nicht zusammen
Empfehlung, wenn die Benutzung des Workpad nicht im Rahmen einer Schulung vorgeschrieben ist: - Atmel AVR-Studio 4.19 Build 730 (für Windows XP mit SP3, Vista, Win7, x32/64) installieren. Diese IDE ist das Original, kostenlos, von Haus aus für 8-Bit-AVR-Assembler, mit Quellcode-Editor, Simulator, Debugger. - WinAVR-20100110 für C/C++ mit GCC separat installieren und im AVR-Studio einbinden (oder die geeignete AVR-Toolchain verwenden). Das zu einem GCC-Projekt passende Makefile herauszufinden, falls die IDE das
-
Thread
Registerzugriff C Code frage
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)[p/32] |= 1 << (p % 32)[/c] [c](&RCC_AHBENR)[p/32] | [/c] Ich weiß es handelt sich um einen Pointer aber wozu [p/32]? und was macht
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
PWM Frequenz erhöhen
>> Hochauflösende PWM gibt es u.a. beim PICCOLO. >Oder beim ATtiny25/45/85 wenn der Timer 1 mit 64 MHz aus der PLL >versorgt wird. Naja, dann schau dir mal an, welche Zeitauflösung der PICCOLO kann. Dagegen sind 64 MHz PWM-Takt ein Witz.
Beitrag #5450177: > Naja, dann schau dir mal an, welche Zeitauflösung der PICCOLO kann. > Dagegen sind 64 MHz PWM-Takt ein Witz. Ok, dann rechnen wir mal nach: 1. ATtiny25/45/85: Taktfrequenz 8 MHz, nach PLL: 64 MHz bei einer 8-Bit PWM (256 steps) bleibt eine PWM-Frequenz von 250 kHz. Der Abstand
-
Thread
Unterschiedliche defines zwischen Atmel Studio und dem Datenblatt
Start - 1.0.116.0 Atmel Start Version: 1.0.116.0 Package GUID: F8853255-9C7B-4DC2-8E0F-64D9324AEB0E Company: Atmel Installed Packages: LiveWatch - 2.0.65 LiveWatch Version: 2.0.65 Package GUID: 7DF6DCFD-2BCA-41C7-9C0E-1B7F606B008E Company: Atmel Installed Packages: GdbConsole
in dem einen Register an einer anderen Stelle steht als im anderen Register. AFAIR war das bei de AVR-Timer gerne mal der Fall.
-
Thread
Lötstationen
du Kühlkörper, > Leistungsrelais ... Hier steht auch eine Rolle 1,5mm auf dem Tisch. > Mit SW32 machst du erst mal keinen Fehler. Ich habe neben F-SW32 63/37 auch noch F-SW26 Cu2 - das 26er geht deutlich besser, wenn die Oberflächen nicht mehr frisch sind. Aus der Fertigung wurde SW26 schon
zu senden so daß man graphisch die Step PID Antwort analysieren kann. Ich habe vor entweder einen AVR 1284P oder STM32F103 einzusetzen. Mit dem letzteren habe ich relativ viel Erfahrung. Mit Atollic Truestudio arbeitet es sich damit recht gut und der Debugger ist natürlich auch nicht zu verachten.
-
Thread
LCD 7-segment für Uhr hh:mm:ss gesucht (I2C oder SPI)
? Bei 100 Pins würde der dann aber > sicher auch einiges mehr verbrauchen? Z.B. MSP430F4x, STM32L4Rxxx Die brauchen auch nicht mehr, als 1 AVR und 11 Schieberegister.
Bei 100 Pins würde der dann aber >> sicher auch einiges mehr verbrauchen? > > Z.B. MSP430F4x, STM32L4Rxxx > Die brauchen auch nicht mehr, als 1 AVR und 11 Schieberegister. Mhh Abseits der Arduinos habe ich mich noch nicht so mit anderen µC beschäftigt. Wie leicht lassen die sich im Vergleich mit
-
Thread
Noch so ein Arduino-Diskussions-Thread.
Maik M. schrieb im Beitrag #5441944: > ist der Umstieg zu AVR-GCC doch ein > Quantensprung Arduino ist reines echtes AVR-GCC C++, nur mit ein paar Blümchen dran, auf die man auch verzichten kann
jemand etwas von seiner Entwicklung erzählt. Wie lange habt ihr z.B. für die Basics im Umgang mit AVR/-/GCC/-libc etc. gebraucht?
-
Thread
Code unleserlich schreiben um Zeilen zu sparen.
avr-gcc Pakete für Windows: https://sourceforge.net/projects/mobilechessboar/files/avr-gcc%20snapshots%20%28Win32%29/ http://blog.zakkemble.co.uk/avr-gcc-builds/
bestimmte Architektur die Größe ist, die auf dieser Maschine am besten verarbeitbar ist (auf einem AVR sind es daher 16 Bits, auf einem ARM 32, auf anderen können es auch 64 sein). Aber ich gebe dir Recht: genau /solche/ Abwägungen müsste man natürlich besser unter die Leute bringen.
-
Thread
Code(SRAM steuern) verbessern. Arduino mega 2560
Maxim B. schrieb im Beitrag #5441364: > Dafür gibt es interne SRAM. Zeige mir den AVR mit 32 oder 64 KB internem SRAM.
S. R. schrieb im Beitrag #5441366: > Zeige mir den AVR mit 32 oder 64 KB internem SRAM. Wenn man so viel SRAM für die Aufgaben braucht, die man mit AVR machen will - dann liegt das Problem nicht in SRAM sondern woanders. Z.B. man könnte Programmlogik
-
Thread
schnelle Serielle Schnittstelle mitloggen
Auch wenn die Baudrate bei 2.4MBit liegt muss man ja nicht MByte ueberteragen, sondern kann mal mit 32 Byte probieren. Das kann HTerm dann auch. Weshalb ich einen 16 oder 32 Bitter vorschlage .. weil die mit MHz klotzen koennen. Ein AVR auch mit 20MHz geclockt kann keine 2.4MBit am UART. Auch wenn er's
://stefanfrings.de/stm32/usb_test2.zip
-
Thread
N64 ruckelt auf meinem Raspberry Pi 3B +
mit 256, 2048 oder noch mehr Bits - auch auf einem 8 Bit-AVR, wenn es nötig ist. Es ist nur langsamer. Ein Raspberry Pi hat einen 32 Bit-Prozessor mit ungefähr 700 MHz, der N64 hat einen 64 Bit-Prozessor mit knapp 100 MHz, d.h. der Raspberry hat schonmal 7
Emulation. Die neueren RasPis haben zwar eine 64-Bit-CPU, laufen aber normalerweise mit 32-Bit-Systemen, um die Kompatibilität mit älteren Geräten sicherzustellen.
-
Thread
Interne Uhr Microcontroller
Million Sekunden gibt es eine Maximalabweichung von 2s. Ein Jahr hat 86400*365=31'536'000s, also etwa 32 Millionen Sekunden. Heißt also 64s Maximalabweichung nach einem Jahr oder etwa eine Minute. Übliche Quarze für Microcontroller etc haben eine Genauigkeit von 10...50ppm, wenn sie spezifikationsgemäß
Vermutlich dort, wo es auch ATmega32 gibt, die mit 20 MHz spezifiziert sind (statt mit 16).
-
Thread
xmega verhält sich mit Debugger anders
Jörg S. schrieb im Beitrag #5430262: > Ich setze einen ATxmega64A4U (getaktet auf 64MHz) Wie kriegst du das hin? Afaik kann der Xmega nur 32MHz, evtl. etwas mehr bei Übertaktung. Bitte korrigieren, wenn ich mich da irre.
läuft das Programm, wenn Du den Controller mit 32MHz betreibst? mfg
-
Thread
(B) hausgemachtes Controller Board mit ATmega32
Biete hier mein hausgemachtes AVR Controller Board an. + Tastenmatrix + SD Shield. Es läuft mit CDC232 welches auf einen ATTiny2313 geflasht ist. Beachtet bitte das CDC232 wohl unter Windows 7 64bit nicht mehr geht und nur bis Windows 7 32bit. Unter Linux dagegen kein Problem. Darauf steckt ein Mega32 welcher mit einen Bootloader via avrdude über CDC232 flashbar ist (USB). avr910 oder mk2/mk1 weiss ich nicht mehr genau. Das Board
-
Thread
Neue Arduino-Module vorgestellt
Spezifikationen des [MKR Vidor 4000](https://store.arduino.cc/arduino-vidor-4000): * SAMD21 Cortex-M0+ 32bit low power ARM, 48 MHz, 256 KB Flash, 32 KB SRAM * Cyclone 10 LP (10CL016YU256C8G), 15408 Logikelemente, 963 LABs, 504 Kbit RAM * WiFi und Bluetooth Low Energy * 8 Digitale IOs
Irgendwann mal so einen eigenen kleinen FPGA Computer zu entwickeln ist ein großer Traum. Forum64? hehe...da bin ich auch angemeldet(ckoe).
-
Thread
Atmega 32 mit 16Mhz
Verfused und zugenäht... Mit großer Sicherheit sind die Fuses falsch eingestellt, wie man AVR mit externem Quarz betreibt steht hier: https://www.mikrocontroller.net/articles/Quarze_und_AVR Mögliche falsche Fuseeinstellungen -------------------------------------------- Fuses sind auf
Quintessenz: Für den Atmega 32 ist AVRProg zum Setzen der Fuses nicht geeignet.
-
Thread
Sprache C - > long oder besser immer long long
string); printf("%s\n", ptr); return 0; } [/c] Funktioniert mit Bitbreiten von 8, 16, 32, 64 und 128. Wenn die ersten Maschinen mit 256 Bit rauskommen, kannst Du Dich nochmal melden. P.S. Das obige kann man auch noch um einiges performanter machen. Aber das ist jetzt hier nicht die Aufgabe
zukünftig z.B. auf 128Bit Maschinen gegen > die Wand laufen: Der läuft auch schon bei gängigen X86_64 Maschinen schief, denn int ist da oft nur 32-bittig. Anderes Beispiel wären 8051 Compiler, dort ist i.d.R. sizeof(void*) = 3 (bytes), weil man so die unterschiedlichen Speichertypen (code, data, xdata
-
Thread
PC - USB - ATmega (ohne Extra-Treiber)
PC über USB (CDC, HID???) auf den ATmega und zurück zu übertragen. Vor mir liegt aktuell ein ATMega32U4 mit integrierter USB-Hardware, anderer AVR wäre möglich. Wichtig ist mir: - am besten keine Extra-Treiber (Windows) nötig, oder zumindest welche die "einfach funktionieren" - Gerät eindeutig identifizierbar
Seriennummer (der Chip hat doch selbst ein bisschen speicher, braucht man den eeprom unbedingt?) - ATMega32u4 mit CDC-ACM, libwdi
-
Thread
Arduino Code am PC testen
machbar. Die kannst du übrigens auch für deine Mikrocontroller nutzen. Hier ist eine Anleitung für AVR µC: http://stefanfrings.de/avr_tools/index.html (runter scrollen) Aber obacht: int hat auf dem PC 32 oder 64bit, während es auf 8bit Mikrocontroller nut 16bit groß ist. Um Seiteneffekte zu vermeiden
> as ging schon im Simulator von AVR-Studio. Ach ja, der Simulator vom AVR Studio eignet sich natürlich auch, um Code-Fragmente zu testen. Hatte ich ganz vergessen.
-
Thread
Mikro-Controller vs. -Prozessor
man einen TI AM3352 Cortex-A8 mit 1GHz und einer Unmenge an Peripherie für ca. 8$, während ein STM32F7 mit 200MHz 12€ aufwärts kostet. Bei Rockchip bekommt man GHz-Quadcores für 5$ während manche Händler mehr für einen AVR verlangen! Es hängt natürlich stark davon ab wo man kauft, aber irgendwie stehen
damit den Chip teuer. Die genannte CPU AM3352 hat neben üppigen Caches (die auch RAM sind) gerade mal 64K On-Chip RAM. Zusammen mit den Caches sind das insgesamt 384K RAM und 176K On-Chip Boot-ROM (vermutlich Flash). Der STM32F7 hat mindestens 256 RAM und 256K Flash. Ein Derivat mit dieser Speichergröße