-
Thread
Mit Arduino und Schieberegister 74HCT595
Guckst du hier: http://www.mikrocontroller.net/articles/AVR-Tutorial:_Schieberegister mfg.
und ich will LED31 (Q7 am letzten > IC) HIGH und alle anderen LOW muss ich das eine Bit mit Clock 32mal > schieben? Für 32 Bit, musst du 32 mal schieben. Das musst du aber losgelöst von dem einen einzigen in diesem Fall betrachten. Denn die anderen 31 Pins müssen ja auch zu ihrem Recht kommen. Bit31
-
Thread
Buffer auf SD/MMC Speichern?
Bei der code am anhang kriege ich 34334 als Ausgabe wert. Ich habe mir auch schnell eine ATmega32 beim Conrad gekauft für großere RAM Tool: stk 500 und ATmega32 4MHz intern eingestellt.
soo geht doch:) habs jetzt erstmal mit 240x64 probiert foto is nich besonders gut im Anhang mfg
-
Thread
IDE EMbitz tot?
und direktem Aufruf des Compilers via make sollte definitiv gehen. Der Prozessor unterstützt zwar 64bit, aber bei 1 GB RAM solltest du ein 32bit-System nehmen. Dann müsstest du dir eine 32bit-Version des Compilers bauen. Aber finden sich nicht bei ebay & Co billige RAM-Riegel die da passen? Aber,
dass man in seiner "IDE" komplett frei in der Wahl des Mikrocontrollers ist. Ich habe QT-Creator für AVR, STM32, LPC, STM8, ESP32, NRF51, etc. genutzt. Bin gerade dabei an RISC-V rumzuspielen und auch das ist kein Problem. Das wichtigste ist jedoch, dass ich mir überhaupt keine Sorgen machen muss ob QT-Creator
-
Thread
Flash probleme
... Kann es an der größe des Projekts liegen? wobei es nicht zu groß ist siehe die Ausgabe von "avr-size"... Habe ich mein STK500 zerschossen?? hir mal die ausgaben: /projects/dcf77/src$ avr-size --mcu=atmega8 -C main.hex AVR Memory Usage ---------------- Device: atmega8 Program:
sorry, habe falsche avr-size angegeben! hier der Richtige: avr-size --mcu=atmega8 -C main.elf AVR Memory Usage ---------------- Device: atmega8 Program: 1972 bytes (24.1% Full) (.text + .data + .bootloader)
-
Thread
Mikrocontroller mit 16-Bit-UART
Die AVR haben kein DMA, also kann es nicht gut sein.
auch weniger verbreitete. Der Parallax Propeller 2 kann das zum Beispiel. Da kannst du jeden der 64 Pins als UART RX oder TX konfigurieren. Mit 1 bis 32 Bits pro übertragenem Wort, plus Start- und Stoppbit. Ist halt ein sehr spezieller Mikrokontroller mit vielen Eigenheiten, aber auch ganz neuen Möglichkeiten
-
Thread
ATMega 32 mit USBasp und Arduino IDE programmieren
System wide configuration file is "C:\Users\fuhrm\AppData\Local\Arduino15\packages\MightyCore\hardware\avr\2.0.5/avrdude.conf" Using Port : usb Using Programmer : usbasp Setting bit clk period : 32.0 AVR Part
16000 Hz avrdude: warning: cannot set sck period. please check for usbasp firmware update. avrdude: AVR device initialized and ready to accept instructions Reading | ################################################## | 100% 0.01s avrdude: Device signature = 0x1e9502 (probably m32) avrdude: NOTE
-
Thread
WinAVR und neue Toolchain
genau 25 Versionen installiert, von 3.4.6 bis 5.2.1, darunter WinAVR, Atmel-Toolchains und selber generierte Canadian Crosses von http://sourceforge.net/projects/mobilechessboar/files/avr-gcc%20snapshots%20(Win32)/ > oder sagt was ihr machen würdet und nicht was ihr
von Atmel. 3. Löschen aller Verzeichnisse in WinAvr ausser pn und utils. 4. Kopieren aller Verzeichnisse der Toolchain in das WinAvr Verzeichnis. 5. Umbenennung des Verzeichnisses WinAvr20100110 in WinAvr. 6. Änderung der Pfadeinträge von WinAvr20100110
-
Thread
MSP430 : Wie viel Speicher kann maximal verwaltet werden?
weiß, gibt es keinen MSP430 mit externen Speicherinterface. Der Adressraum selbst ließe wohl maximal 64 kByte RAM zu. ARM7 ist ein 32-Bit-RISC-Prozessorkern, der in verschiedenen µCs verschiedener Hersteller verwendet wird, so beispielsweise LPC22xx von Philips, AT91SAM7Sxx von Atmel, M67Q5003 von OKI
und 8k SRAM? Siehe http://www.atmel.com/dyn/products/product_card.asp?family_id=607&family_name=AVR+8%2DBit+RISC+&part_id=3631 Hat allerdings TQFP100 und ist noch nicht wirklich verfügbar (Volumenproduktion ab Q4/2005 Siehe auch http://www.ineltek.at/artikel_html?artid=AVR%20-%2028.09.2005
-
Thread
Taster-Entprellung am Tiny13 in Assembler
out SREG,r16 > pop r16 > reti Warum machst Du das so? Der AVR hat 32 Register, da kann man es sich leisten, die Register, die in der Mainloop verwenet werden, in Ruhe zu lassen. Selbst zum Sichern des SREG kann man ein Exklusivregister vereinbaren. Die ganze Push-Pop-Orgie
. Das scheint mir auch so. Und dabei kann man es sich doch wirklich einfacher machen. Der AVR hat 32 Register, da kommt man bei kleinen Programmen sogar ohne RAM aus. Da kann man es sich leisten, ein unteres (dummes) Register exklusiv für die SREG-Sicherung im Interrupt zu verwenden. Da
-
Thread
Zimmer/Bereichs Kontroller
auf diesen gestossen der klingt interessant : > https://www.olimex.com/Products/AVR/Header/AVR-H128-CAN/ kostet 20 Euro Der hat halt kein LAN, und wenn, dann ist das LAN sehr lahm, so 50..100 kByte/s. Der PIC32 kann per TCP/IP und mit dem Microchip TCP/IP-Stack fast 3 MByte/s übertragen
ist die 64 Pin Version des PIC32. Hat weniger Pins, kann aber ansonsten prinzipiell das gleiche. LAN musst Du Dir da irgendwie ranbasteln.
-
Thread
GLCD Fonts (64x128)
kann der Compiler da auch nicht auf 16 bit Breite optimieren. Bleiben wir mal beim Beispiel mit dem AVR und dem 128*64er Display, wenn ich jetzt alle Pixel per Funktion setzen will (z.B. CLRSCR) brauche ich 8192 Aufrufe meiner setPixel(...)-Funktion, nehmen wir mal an, diese operiert auf einem internen
wenn wirklich Grafik ansteht, dann den Controller danach auswählen. Wenn die Grafik nur so etwa 128x64 oder gar nur 96x32 oder so beträgt, dann muß der Controller nur genügend RAM mitbringen, in diesem Fall so etwa 1K für den Display-RAM und nochwas obendrauf für den Rest des Ganzen. Die Geschwindigkeit
-
Thread
C++ Funktions Template für __flash
im Flash in einen Zeiger auf diese neue Klasse "umformt": https://github.com/arduino/ArduinoCore-avr/blob/c8c514c9a19602542bc32c7033f48fecbbda4401/cores/arduino/WString.h#L37 Der Zeiger _F("bla") ist dann ein Zeiger auf einen anderen Typ.
Harper B. schrieb im Beitrag #7837637: > memcmpf Klingt nach CodeVisionAVR, aber der kann kein C++? __flash gibt's doch gar nicht in C++ beim AVR-GCC?
-
Thread
ADF4351 Windows Applikation
Artikels: https://www.mikrocontroller.net/topic/512619 Getestet ist das Programm auf Windows 7/32 und Windows 10/64. Was dazwischen liegt sollte auch funktionieren. Aufpassen sollte man bei Installation und Betrieb dass man mit genügend (Administrator-) Rechten arbeitet. Wer das nicht kann
Fractional-N synthesizer and integer-N synthesizer Low phase noise VCOProgrammable divide-by-1/-2/-4/-8/-16/-32/-64 output Typical jitter: 0.3 ps rmsTypical EVM at 2.1 GHz: 0.4% Power supply: 3.0 V to 3.6 V Logic compatibility: 1.8 V Programmable dual-modulus prescaler of 4/5 or 8/9 Programmable output power
-
Thread
Einstieg in die Welt der Mikroprozessoren
klar. Und wenn du schon C kannst ist es ja noch besser! ARMs (nicht AMRs *G*) sind viel schneller (32 Bit) und für den Hobbybereich unnötig würd ich sagen. Ob PIC oder AVR ist glaubensfrage denke ich, aber hier aufm Forum benutzen die meißten AVRs und du wirst mit denen sehr gut unterstützt. Wenn
ach ja: kann man den Mega32 eigentlich auf dem STK500 programmieren und was ist eigentlich der Unterschied zwischen Mega16 und Mega32?
-
Thread
Wer schreibt mir einen Bootloader für ATMEGA32M1 + SPI Eeprom (Jobangebot)
Hallo Zusammen Ich suche jemanden, der mir einen Bootloader für einen AVR ATMEGA32M1 in C schreibt, welcher die Firmware aus einem SPI EEPROM holt und diese updated (natürlich gegen Bezhalung, siehe weiter unten) Die Datenblätter: ATMEGA32M1: http://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-7647-Automotive-Microcontrollers-ATmega16M1-32M1-64M1-32C1-64C1_datasheet.pdf EEPROM 25AA640-I/P (SPI, 64k) https://www.mouser.ch/datasheet/2/268/21223G-70499.pdf Hintergrund: Ich möchte künftig ein Gerät so erweitern, dass ein Kunde ggf
-
Thread
Schneller Mikrocontroller
nicht der allerschnellste "Mikrocontroller" der Welt sein. Wenn 100x so viel Rechenleistung wie vom AVR reicht, dann reicht vielleicht auch ein "kleiner" Cortex-M4 wie die LPC oder STM32 oder Atmel SAM4.
über welche z.B. die ARM verfügen. Diese Systeme nehmen einem mittels Hardware Dinge ab, für die ein AVR CPU Zeit braucht, ADC Wert holen, SPI Wert holen etc. Es gibt da das stm32F3 discovery mit Beschleunigungssensor, Gyro und Magnetometer - alles 3D versteht sich :-) Dazu schöne Firmware Examples
-
Thread
Eklatanter Fehler im Handbuch zu ATtiny87 / ATtiny167
63, obwohl für ein Bit dann 63 mal getaktet werden muss, mit weniger Takt versorgt als z.B. LBT = 32, das für jedes Bit nur 32 Takte braucht. Kann natürlich nicht sein und das geht auch aus dem Text hervor, der bei der Formel steht: > LBT ... is the number of samplings in a LIN or UART bit
AVR's sind keine amerikanischen produkte...
-
Thread
Na wunderbar - Fusebits: Ausgesperrt aber mit den richtigen Eingaben?
. schrieb im Beitrag #3486612: > Man verzeihe mir bitte an dieser Stelle mein Unwissen... ist der 32kHz > Quarz für UART sinnfrei oder sinnvoll? Völlig sinnfrei. Was du jetzt erst einmal benötigst ist http://www.mikrocontroller.net/articles/AVR_Fuses#Reaktivieren_bei_fehlerhaften_Taktquellen-Fuse-Einstellungen
2. AVR erzeugen oder einem 555. Den 32kHz Quarz mußt Du eh auslöten, der AVR hat keine PLL, d.h. mit nur 32kIPS kannst Du keinen Blumentopf gewinnen.
-
Thread
µC, der sich als virtueller COM port ausgibt?
Hallo. Wie waere es mit http://matrixstorm.com/avr/avrstick/. Im Speziellen mit der Beispielfirmware: http://matrixstorm.com/avr/avrstick/examples/USBtoUARTs/ Bzw. zum (sogar online!) selbst modifizieren: http://matrixstorm.com/avr/avrstick/#bideavr
Stephan B. schrieb im Beitrag #3781785: > Hallo. > > Wie waere es mit http://matrixstorm.com/avr/avrstick/. > Im Speziellen mit der Beispielfirmware: > http://matrixstorm.com/avr/avrstick/examples/USBtoUARTs/ > > Bzw. zum (sogar online!) selbst modifizieren: > http://matrixstorm.com/avr
-
Thread
ATtiny13 und "mySmartUSB light" einfache ISP Programmierung funktioniert nicht!
. Das habe ich gemacht: * USB-Treiber installiert (Windows 7 hat das automatisch gemacht) * WinAVR installiert * myAVR ProgTool 1.35 geladen * Alle Anschlüsse aus dem 6-Poligen Wannenstecker des "mySmartUSB light" an den ATtiny13 im Sockel geführt (siehe Anhang) * myAVR ProgTool gestartet, COM-Port
------ ---- ------ ----- ----- --------- eeprom 65 5 4 0 no 64 4 0 4000 4000 0xff 0xff flash 65 6 32 0 yes 1024 32 32 4500 4500 0xff 0xff signature 0 0 0 0 no 3 0 0
-
Thread
delay us: Wie reparieren?
# define cpu_ms_2_cy(ms, f_cpu) \ (((uint64_t)(ms) * (f_cpu) + (uint64_t)(14e3-1ul)) / (uint64_t)14e3) # define cpu_us_2_cy(us, f_cpu) \ (((uint64_t)(us) * (f_cpu) + (uint64_t)(14e6-1ul)) / (uint64_t)14e6) #endif #define delay_cycles
Uwe Bonnes schrieb im Beitrag #3315153: > void NutMicroDelay(uint32_t us) > ... Das ist ja ganz schön viel Holz. Es geht auch deutlich einfacher. Hier ein Delay mit Timer auf dem AVR: [c] void delay( int16_t d ) // d = 0 ... 32000 ticks { d +=
-
Thread
segger J-Link EDU
und gewerblich sollte man sich einen 'guten' Segger leisten können. Mit BMP habe ich schon LPC, STM32 und nRF µC programmiert, das ist schon ein große Palette. Und Hobby ist heute ja nahezu only STM32, ESP und jetzt ein bisschen noch der RP2040.
kann die richtigen Stellen mit ein wenig Erfahrung im Debuggen von PC Assembler Code (x86 und/oder x64) ziemlich schnell finden.
-
Thread
Atmel Xmega synchrone ADCs / Quantisierungs + Schwingungs Problem
muessen, bis ich brauchbare Messwerte bekommen habe. Dies funktioniert nur, wenn den ADC A mit 32MHz/64 und ADC B mit 32MHz/128 betreibe. Stelle ich dad ADC Timing anders ein, bekomme ich eine Schwinung auf wenigstems einen der ADC Kanaele. (siehe A_64_B128.png und A_64_B_64.png) Die Frequenz und
auch nicht mit VCC/1,6 als Referenzspannung (3,3V / 1,6 = 2,0625V). Schoenen Gruss, Balze aka AVR Noob
-
Thread
Sinus sehr seltsam
von 3,9kHz/32=122Hz.
<-- abgerundet 256 array entspricht 8 mal verschieben 128 array entspricht 9 mal verschieben 64 array entspricht 10 mal verschieben 32 array entspricht 11 mal verschieben das habe ich verstanden. wie siehts mit der Geschwindigkeit aus? Gehts das?
-
Thread
Warum liest man hier so wenig von Renesas?
aber auch noch STM32F7xx und STM32H7xx im Ärmel ;-)
noch etwas finden ;) Auf jeden Fall sind sie viel übersichtlicher als STM32F1 u.ä., auch wegen der besseren Doku. Weil alles in einem Adressraum memory mapped ist, sind sie sogar einfacher als die AVR, also auch für Anfänger geeignet. Es würde direkt Spaß machen, die in Assembler
-
Thread
50+ LED Treiber / Multiplexer
Dann nimm einen AVR deiner Wahl und papp zwei ULN2803 dran, fertig ist der 16 Bit LED-Treiber. Alternativ zwei TPIC6B595, das spart viele IO-Pins und man kann einen kleinen AVR nutzen. MFG Falk
daten seriell über >eine d-leitung nehmen? Ja, Ansteuerung wie ein normales Schieberegister. [[AVR-Tutorial: Schieberegister]] MFG
-
Thread
Suche Empfehlung für zukunftssicheren ATMEGA Gesperrt
, wäre der ATMEGA16 (oder 164 oder 168) eine gute Wahl? Habe ich etwas übersehen oder wären die 32x und 64x dazu kompatibel im Sinne daß ich dann den Code nur neu assemblieren aber nicht teilweise neu schreiben müßte wie beim -8 ?
AVR war gestern schrieb im Beitrag #3036566: > Nein, Atmel setzt bei 32 Bit auf ARM und nur bei 8 Bit auf AVR. Genau das stand obendrüber. Warum also "nein"?
-
Thread
Anfänger, 10 Led programmieren
die Programiersprache C auf einem PC zu > lernen - die Grundlagen genügen. ich kenne aber nur LCC32 man arbeitet sich schnell ein einfach und leicht mit LCC32 oder 64 https://en.wikipedia.org/wiki/LCC_(compiler) http://www.bei-ekke.de/htmltidy/mfischer/lcc32-index.html https://lcc-win32.de.uptodown.com/windows https://www.heise.de/download/product/lcc-win32-1059 http://lcc-win64.software.informer.com/4.0/
-
Thread
atmega läuft nicht
Menge. http://www.sics.se/~adam/uip/index.php/Main_Page Aber ist halt ersteinmal nicht für den AVR. Und es gibt keine Fehlermeldung. > Passt das ganze überhaupt noch in Deinen AVR? Optimierung eigeschaltet? jup, brauche 20kb von 64 > Das Programm startet immer wieder neu. Nach der Initialisierung
Weißt Du schon, an was es gelegen hat? Ich habe den selben Fehler mit einem Atmega32 auf dem Pollin AVR NET I/O-Board mit der Firmware von Ulrich Radig. Auch ich programmiere mit Code::Blocks. Teils entscheiden nur kleine und unwichtige Details später im Code darüber, ob der Atmega
-
Thread
Hilfe für einen Kompletten Anfänger
Kann man denn auch mit AVR Studio Assemblieren und wenn ja wie?
nicht auf Postings mit dieser Ausdrucksweise. Warum doch, hat nur mit dieser Zeile zu tun: > avr-gcc (WinAVR 20080402rc1) 4.3.0 Anscheinend gibt es einen Versuchsballon für ein neues WinAVR. Diese Zeilen sehen allerdings nicht gut aus: >> "make.exe" all > 0 [main] sh 2868 sync_with_child
-
Thread
Einplatinencomputer mit ATTiny/Mega/xMega
2 Anschluss (Tastatur) Was willst Du mit dem Flash und SDRAM machen? Ist Dir klar, dass Du bei AVR im RAM keine Programme laufen lassen kannst. Dafür bräuchtest Du eine andere Prozessorarchitektur wie ARM oder PIC32 (MIPS). Wie viel SDRAM willst Du haben? Warum SDRAM? Wenn Dir 512k reichen (das ist für AVR schon reichlich viel), ist SRAM einfacher. Du weisst, dass ein AVR mehr als 64k nicht am Stück verwalten kann, sondern nur mit Bankswitching. Ein 32 Bit Prozessor braucht so eine Krücke nicht. fchk
-
Thread
Was braucht man alles als Anfänger?
das alles funktionier hab ich mir vorgenommen eine 8x8 RGB LED >Matrix zu bauen, bei der sich alle 64 LEDs einzeln ansteuern lassen. Nicht mit einem AVR.
holger schrieb im Beitrag #1757088: > Nicht mit einem AVR. Aber mit 64 AVRs!
-
Thread
0-10v in Pwm umsetzen für Konstantstromquelle
CS12); [/c] durch [c] TCCR1B = (1<<WGM13) | (1<<WGM12) | (1<<CS11) | (1<<CS10); //Prescaler 64 [/c] ersetzen.
einfach den Prescaler ändern ;) Ansonsten, das hier https://www.mikrocontroller.net/articles/AVR_Fuses und das Datenblatt lesen.
-
Thread
[V] Compiler-Lizenz (Dongle): MikroElektronika "mikroC PRO for AVR"
ATmega328 ATmega328P ATmega329 ATmega3290 ATmega3290P ATmega329A ATmega329P ATmega329PA ATmega32A ATmega32C1 ATmega32HVB ATmega32M1 ATmega32U2 ATmega32U4 ATmega32U6 ATmega406 ATmega48 ATmega48A ATmega48P ATmega48PA ATmega64 ATmega640 ATmega644 ATmega644A ATmega644P ATmega644PA
ATxmega16A4 ATxmega16D4 ATxmega192A3 ATxmega192D3 ATxmega256A3 ATxmega256A3B ATxmega256D3 ATxmega32A4 ATxmega32D4 ATxmega64A1 ATxmega64A3 ATxmega64D3 ATxmega128A3U ATxmega16A4U ATxmega192A3U ATxmega256A3BU ATxmega256A3U ATxmega32A4U ATxmega64A3U
-
Thread
Welches ist der beste Microcontroller für Modellbau
Ich würde gerne mal noch was ganz anderes in die Runde werfen: Den LPC2104. Denn: AVR, 8051, und Pic sind bald tot. - Arm7tdmi-Core - 128Kb Flash - 64Kb Ram - bis zu 60MHz - 2 UART, SPI, I2C- 32-Bit Timer, Pwm, RTC, Watchdog - SINGLE-CHIP-LÖSUNG!! - 44-pol Gehäuse - Auch mit
den großen im TQFP64 gehäuse mfg mike
-
Thread
STM32 Tutorial
endlich das Tutorial, das ich in den letzten Wochen gesucht habe... ;-) Ich steige auch gerade von AVR auf STM32 um und werde mir das in den nächsten Tagen mal genauer ansehen. Danke!
VIEL komplexer als AVRmega ...") > > Frage: glaubst (oder weißt) Du, ob Dein Tutorial auch für STM32F4 geht? > Also STM32F407VGT6 32 Bit ARM Cortex-M4F. http://www.mySTM32.de ;-) für wirklich blutige Anfänger ist ein AVR aber schon verständlicher. Gruß J.
-
Thread
zeitfunktion "_delay_ms()"
Bei einem Takt von 1Mhz kannst du mit der Funktion also maximal 262,14ms warten, bei 8Mhz nur noch 32,768ms.
und kann daher nicht > bitorientiert angesprochen werden. Ah richtig. cbi und sbi gehen nur bis 32, nicht bis 64, wie in und out. > Damit das SREg trotzdem schnell manipuliert werden kann, enthält der > ASM-Befehlssatz die Befehle SEx und CLx, wobei x für das Bit im SREG > steht, beim Interrupt-Bit
-
Thread
PWM 40 khz ?
gekommmen. Also: RC5 arbeitet mit 36KHz und Manchaster Codierung. Ein Datenbit wird innerhalb von 64 Impulsen übertragen, macht also 1.77778 ms pro Bit. Die Information ob ein Bit einen 1 oder 0 ist wird exakt nach 32 Impulsen übertragen. Je nachdem ob zuerst 32 mal geblitzt wurde und danach 32 Impulse
eben umgekerht, handelt es sich um eine 1 oder 0 beim datenbit. Somit blitzt die IR Diode maximal 64 mal am Stück und maximal 64 Impulse kann Ruhe sein. Minimal blitzt die Diode 32 mal und auch 32 Impulse ist die kürzeste Ruhepause. Das ist der Vorteil der Manchastercodierung. Somit heist das für
-
Thread
Drehencoder für Anfänger
Hallo liebes Forum. Ich habe vor, einen Drehencoder STEC11B03 an den Atmega32 anzuschliessen. Es gibt bereits viele aufschlussreiche Beiträge im Forum zu diesem Thema (Natürlich auch vom AVR-Meister peter dannegger) jedoch sind diese eher für Fortgeschrittene und Profis. Mein
schneller Hack: [c] #include <stdbool.h> #include <stdint.h> #define F_CPU 16000000ul #include <avr/io.h> #include <avr/interrupt.h> static void ioinit(void) { TCCR0 = (1<<CS01) | (1<<CS00); //divide by 64 * 256 => ~ 1 ms clock ticks TIMSK = 1<<TOIE0; //enable timer overflow interrupt
-
Thread
Display Programmierung mit GCC 16x4 Display
Pojekt gemacht, dann auf "Edit Configuration Options" und dort dann eine Frequenz eingestellt... In AVR Studio War das richtig? Oder muss ich meinem Code noch was hinzufügen?
sich im Brennprogramm (zumindest war das in AVR-Studio 4 noch so)
-
Thread
Einsteigerfragen
zufrieden mit dem gerät! Hab Windows 7 64 bit und es läuft einwandfrei! 4.Atmega 8 reingesteckt und angefangen zu programmiernen! ich finde dieses Tutorial sehr hilfreich hat mir bis jetzt die meisten Fragen beantwortet! http://www.avr-asm-tutorial.net
machen mit mehr Bit anzufangen!? Aber ich habe das > AVR-Studio nur in der 8-Bit Version kostenlos gefunden - kostet die > 32-Bit Entwicklungsumgebung? Klar, 16-Bitter. Aber ich hatte oben schon geschrieben: Fang mal mit den kleinen AVR an, am besten
-
Thread
Atmel mit oder ohne Arduino oder ganz anderer µC für Batteriemanagement
Bei Battery-Management ist LowPower oft sehr wichtig: Mein Tip: Nimm einen STM32L152 http://www.st.com/content/st_com/en/products/microcontrollers/stm32-32-bit-arm-cortex-mcus/stm32l1-series/stm32l151-152/stm32l152vb.html?redi=no Oder gleich das Eval-Board ink. Programmer+9Debugger
oh da ist sie wider, die alte leier mit dem msp430 ... dabei sind die aktuellen avr's ja sogar die stm32L genauso stromsparend wenn sie richtig eingesetzte werden ... vergiss die ratschläge, nimm wass dir am besten behagt und mit was du am schnellsten zum ziel kommst...
-
Thread
Windows-Programmierer umschulen
Selbst erlebt: Linux hat die harten Timings nicht hinbekommen, also wurde dem Embeddet PC ein STM32 zur Seite gestellt. Weils doch so super ist, bekamm der STM32 ein RTOS für das ganze lästige Gesummse drummherum. TATA!!!! Das RTOS packte das harte Timing nicht. Der STM32 bekam einen AVR zur Seite
Threads kommunizieren. Klingt aber dennoch stark nach Kompetenzproblem. Selbst mit RTOS ist ein STM32 größtenteils schneller als ein AVR... Wenn man taktgenaues Bitbanging braucht kann man das auch in einem Thread machen, der muss dann halt höchste Priorität haben oder nicht-unterbrechbar sein.
-
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
Funktion wird nicht aufgerufen
standen die "DDn" Makros drin. Verwendet wird ein ATMega8-AU. Die Fuses sind auf internen 8MHz Takt 64ms Delay gestellt, ansonsten auf Auslieferungszustand. Compiliert wurde mit dem AVR-Studio 6. Zuvor hatte ich mit Xcode in Verbindung mit AVR-GCC aus dem AVR-Crosspack gearbeitet. Das Resultat war
Ok, hier mal das Listing. [avrasm] Builds/main.elf: file format elf32-avr Sections: Idx Name Size VMA LMA File off Algn 0 .text 0000007a 00000000 00000000 00000074 2**1 CONTENTS, ALLOC, LOAD, READONLY, CODE
-
Thread
STM32 alias cortex m3 brauchbar?
http://www.st.com/mcu/familiesdocs-110.html Bin interessiert besser zu verstehen deine Vergleich AVR vs STM32 Docs, und was wir verbessern könnten. Am bestens wir telefonieren darüber. Zu Andreas Frage, ob die Teile schon gibt, kann ich es bestätigen. Die meisten Distributor haben den STM32 seit
wird. Macht Sinn, ist aber gewöhnungsbedürftig. @T.E.: Das mit dem Vergleich der Datasheets AVR/STM32 muss ich mir mal genau ansehen. Die Sache ist die, dass ich im Grunde mit dem AVR das "Controller-Laufen" gelernt habe, und das auch grösstenteils ohne fremde Hilfe. AVR ist auch um einiges
-
Thread
externes RAM am ATMEGA64
Interface early during device initialization */ void init_memory_mapped(void) { #if defined(__AVR_AT90S4414__) || defined(__AVR_AT90S8515__) \ || defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__) || defined(__AVR_ATmega103__) /* enable external memory mapped interface with one wait state */ MCUCR = _BV(SRE) | _BV(SRW); #elif defined(__AVR_ATmega161__) || defined(__AVR_ATmega162__) || defined(__AVR_ATmega8515__) /* enable external memory mapped interface with one wait state for the entire external address space*/ MCUCR =
-
Thread
DEBO OLED2 0.96 0,96" OLED-Display SSD1306 SSD1312 Initialisierung TWI I2C AVR ATmeg8 Assembler ASM
Angehangen :-) habe ich ein 128x64 Blau-Gelb I2C/TWI 128x64 Display. https://www.roboter-bausatz.de/p/0.96-oled-display-blau-gelb-i2c-iic-twi-128x64-pixel-fuer-arduino Kennt jemand Bezugsquellen für 128x128 RGB *I2C TWI* OLED Display
den Bildspeicher aufteile. Zum Beispiel in 4Segmente und 8Pages. Dann ist ein solches Segment nur 32Byte gross. (bei 128x64Pixel) Ausserdem hab ich noch ein paar Byte in dem ich mir merke wenn sich in einem Segment etwas gaendert hat. Dann macht man einen Ticker-IRQ und sorgt dafuer das alle 5ms ein
-
Thread
Externer Speicher
Noch eine Frage: Dieses EEPROM kann über das TWI des Mega32 angesteuert werden, korrekt?
z.B. ein Mega-32 sein kann...
-
Thread
Zilog Z80 CPU
STM32F4 Discovery kit
irgendwann einmal.. nur zurzeit brauche ich soetwas nicht^^ pito schrieb im Beitrag #2615054: > STM32F4 Discovery kit Danke, ich werde mir mal das durchlesen: http://www.mikrocontroller.net/articles/STM32F4-Discovery