-
Thread
ATmega328 Timer 1 Input capture auf 32 Bit verlängern
Ich würde mich über Beispiel-Code freuen. Bitte sehr: https://www.mikrocontroller.net/topic/avr-timer-mit-32-bit#371564
AVR_TIMER_DIVIDER 1L #elif AVR_TIMER_DIVIDER_CODE == 2 #define AVR_TIMER_DIVIDER 8L #elif AVR_TIMER_DIVIDER_CODE == 3 #define AVR_TIMER_DIVIDER 64L #elif AVR_TIMER_DIVIDER_CODE == 4 #define AVR_TIMER_DIVIDER
-
Thread
Kürzest möglichen Puls mit AVR bei 20MHz erzeugen
besser geeignet? Die Counter laufen auch nur mit maximal dem System-Takt. Es gibt ein paar wenige AVR mit PLL, da kann der Peripheral-Clock bis zu 64 MHz hoch sein, etwa beim Tiny45. Ich bin aber nicht sicher, ob der Timer dann auch entsprechend schnell mit den Pins wackeln kann.
Rudolph R. schrieb im Beitrag #4405852: > Es gibt ein paar wenige AVR mit PLL, da kann der Peripheral-Clock bis zu > 64 MHz hoch sein, etwa beim Tiny45. > Ich bin aber nicht sicher, ob der Timer dann auch entsprechend schnell > mit den Pins wackeln kann. Kann
-
Thread
LC-METER / LC-Messgerät ATmega8 Assembler
werden mit 97.993pF angezeigt, soweit noch plausibel. Lege ich nun einen 0,22µF Kondensator an, werden 64.214pF angezeigt, ein kleiner Elko mit 10µF wird mit 156.858pF gemessen. Da der AVR die Frequenz richtig misst, muß der Fehler ja an der Eingangsbeschaltung liegen. Da wundert mich aber, warum Spulen
@Bernhard: Vielleicht helfen Dir meine 64bit Routinen, die ich für meinen Frequenzzähler geschrieben habe - siehe Beitrag "Reziproker Frequenzzähler+ Optimierte 64bit uint Routinen" . Das ganze ist zwar C-Code, aber die uint64_t Routinen sind
-
Thread
Wer nutzt das Nucleo-64 und kann mir
einen Fehler melden. Warum er sich > anders verhält, sehe ich gerade nicht. Moment! Beim STM32 macht er ja irgendwas! Ich bekomme über 100 Adressen wenn ich scanne. Nur beim AVR und ESP funktioniert es. Bedeutet durch den Switch auf STM32 nimmt er eine .h die gar nicht (richtig) funktioniert.
ist die Softwareentwicklung einfacher, man kann damit aber nicht alle Features der µC nutzen. Was STM32 angeht, ist in Arduino die Unterstützung der STM32F1 Serie am weitesten fortgeschritten. Deswegen würde ich Dir empfehlen, Arduino nur mit STM32F1 zu verwenden. Von Deinem Nucleo-64 könntest du den ST-Link
-
Thread
Frage zu IR-Remote+LED-Strips an AVR
bekommt - mit 64 KB Flash und 20 KB RAM, dann will man keinen AVR mehr anpacken, jedenfalls nicht für so eine Aufgabe. https://www.ebay.de/itm/1-2-5-10Stks-STM32F103C8T6-ARM-STM32-Minimum-System-Development-Board-Module-New
klemmst du dich dahinter und löst das Problem ELEGANT! Und JA, das geht auch mit einem "kleinen" AVR nicht allzuschwer. Fette 32 Bitter mit DMA und anderen Geschützen braucht man da nicht wirklich. Brain 2.0 ist immer noch up to date!
-
Thread
LunaAVR 2012.r7.2.build 3893 erschinen
Hallo, Richard der Entwickler von LunaAVR ist sehr fleißig, so dass die Nutzer von LunaAVR nun mit der Version 2012.r7.2 auch Zugriff auf 64Bit Mathematik, als unsigned 64Bit, haben. Bisher wurde implementiert: _Quelle:_ http://avr.myluna.de/doku.php?id=de:arithmetik&s[]=64bit *64 BIT INTEGERARITHMETIK* Befehl Beschreibung Add64() Addition Add6432() Addition 64bit mit 32bit Decr64() Dekrementierung (-1) Div64() Division Div6432() Division 64bit mit 32bit
-
Thread
AVR32 Studio Problem
Beim Starten des AVR32 Studio 2.0.2 bekomme ich immer die folgende Meldung. ******************************** avr32program: <not found> (Need version 3.0 or newer) avr32gdbproxy: <not found> (Need version 3.0 or newer) avr32-gdb: <not found> (Need version 6.7 or newer) avr32-g++: <not found> (Need version 4.2 or newer) avr32-gcc: <not found> (Need version 4.2 or newer) avr32-as: <not found> (Need version 2.17 or newer
-
Thread
Welche STM32 sind interessant?
Hier im Artikel [[STM32]] habe ich unten einige Links. TME hat z.B. vom "STM32F103RE" noch 10 auf Lager. Der R8 hat kein SDIO und nur 64KB Flash. Ist zum debuggen etwas dünn. Also nur die Speichervariante ab "C" also >=
Markus Müller schrieb im Beitrag #1779989: > Hier im Artikel STM32 habe ich unten einige Links. TME hat z.B. vom > "STM32F103RE" noch 10 auf Lager. > > Der R8 hat kein SDIO und nur 64KB Flash. Ist zum debuggen etwas dünn. > Also nur die Speichervariante ab "C"
-
Thread
Pascal Compiler für PIC - ist wirklich Freeware
Gibt es auch ein freies PASCAL für AVR ? Danke Joe
Dokumentation ist der Flash-Pointer 3 Byte groß, das sind doch 24 Bit, deswegen wundert mich das ja. http://avr.myluna.de/doku.php?id=de:datentypen http://avr.myluna.de/doku.php?id=de:pointer
-
Thread
ATmega32 noch zeitgerecht?
als ein großes Projekt gesehen, wo man für irgendeinen Käse meinte, einen "zeitgemäßen" LPC oder STM32 oder wasauchimmer zu nutzen und sich damit drölf Baustellen ins Nest geholt hat, die monatelang gekracht und das Projekt aufgehalten haben. Wenn ein AVR8 ein Problem ohne Bauteilzoo drum rum, der mit
Vorteile wie "On-Chip Debugging" Das konnte aber seit dem ATmega16 (und damit auch dem größeren Bruder 32) jeder „echte“ ATmega ohnehin. :) (ATmega8 und Nachfolger sind in dieser Hinsicht keine Mega-AVR-Architektur, weshalb man bei den Nachfolgern dann auf das vom ATtiny stammende debugWIRE gesetzt hat.)
-
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
Monitor als Ausgabe für Microcontroller
Alpha-LCD hast, reicht ein ATMega o.ä. aus, wenn es ein Grafik-LCD ist, dann solltest du eher einen 32 Bitter vorsehen. Für derartige Zwecke reichen die üblichen 128x64 oder ähnliche Größen aus. 4. Suche dir ein Sortiment an sinnvollen Steckverbindern aus, mit denen du die diversen Pins des µC, die
dargestellt werden. > Das Gerät soll rechnen können, Na sicher. Etwa 10x so schnell wie der alte C64. Wenn das nicht reicht, kann man seine Funktionen auch in C/Assembler schreiben, und dann im Programm aufrufen. Mit 32 bit und 80 MHz. > PWM ausgeben Ja. > I²C und SPI Man kann auf fast beliebigen
-
Thread
atmega8 uhr
serve as an independent clock source for Timer/Counter2. The Oscillator is optimized for use with a 32.768 kHz crystal. Applying an external clock source to TOSC1 is not recommended. For Timer/Counter2, the possible prescaled selections are: clkT2S/8, clkT2S/32, clkT2S/64, clkT2S/128, clkT2S/256, and
@Sven Schau mal auf die MCS Seite unter Application-Notes. Dort ist eine AN für ne AVR-Uhr.
-
Thread
Probleme beim Schreiben in den Flash-Speicher
boot_page_fill(i, data[i/2]); } boot_spm_busy_wait(); boot_page_write(0); boot_page_write(32); boot_page_write(64); boot_page_write(96); sei(); } [/c] leider enthält die Hex-Datei jetzt folgenden (falschen) Inhalt: [c] :100000008000800880088004400080048000C000D8 :10001000C0108001C000C00700088001C00080013E
Jetzt hast du beim page_write ja wieder eine "Page-Nummer". Und warum eigentlich immer "32"? Deine Rückleseversuche legen eigentlich nahe, dass eine Page 64 Bytes hat.
-
Thread
EPROMs, SRAM & Parallel-EEPROMs..
Am Besten nimmst Du einen AVR mit externem Memory Interface, z.B. Einem Mega 64/128/640/641/1280/1281/2560/2561. Die Datenleitungen kommen an Port A, die unteren Adressleitungen über einen hc573 auch an Port A und die oberen an
es eigentlich nicht. Es gibt auch entsprechend grosse Bausteine, > z.B. RAM mit 2M x 8, das sind 32 Seiten a 64k. genau. > Bei Daten ist das unproblematisch, Paging des Programmspeichers > erfordert dagegen sehr viel Sorgfalt. Beim AVR gibts ohnehin keinen externen Programmspeicher, damit
-
Thread
Time Slot erzeugen - wie am besten
} } [/c] Da ist noch ein Denkfehler drin mit millisekunden1. Wie meinst du das mit der 32 Bit Variablen?
versuchen den > Eröffnungs-Post zu lesen? Dort ist unschwer zu erkennen dass > es sich um einen AVR Controller handeln muss. Der Code sieht schon sehr nach AVR aus, aber es gehört trotzdem eigentlich dazu, dass man zumindest mal erwähnt, worauf das nachher laufen soll.
-
Thread
250 kHz PWM -> ¿Filter? -> micro speaker
0x13, 0x15, 0x16, 0x18, 0x1A, 0x1C, 0x1E, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2B, 0x2D, 0x2F, 0x32, 0x34, 0x37, 0x39, 0x3C, 0x3F, 0x41, 0x44, 0x47, 0x4A, 0x4D, 0x4F, 0x52, 0x55, 0x58, 0x5B, 0x5E, 0x61, 0x64, 0x67, 0x6A, 0x6D, 0x70, 0x74, 0x77, 0x7A, 0x7D }; volatile uint8_t
irgendwie phasenstarr miteinander verkoppelt? Nein, der schnelle Timer mit PWM wird von der asynchronen 64 MHz PLL getaktet: > Timer/Counter1 and the prescaler allow running the CPU from any > clock source while the prescaler is operating on the fast 64 MHz > (or 32 MHz in Low Speed Mode) PCK clock in
-
Thread
Drehgeber auslesen
kommt man mit 16 Drehgebern ganz gut hin, denkbar wäre noch eine Erweiterung auf 24 oder höchstens 32 (ja, dann bin ich schon bei 7 Leitungen + zwei weiteren 1aus8-Decodern). Es gibt zwar auch Geräte mit mehr Drehreglern (z.B. Drehbank mit 64), aber da wird das schon leicht unübersichtlich. Ich würde
und dann in den Profibus umsetzt. Dürfte wesentlich billiger sein als der HCTL2020. Ob Du dann 32 oder 64 Bit zählst ist auch egal. Ist der HCTL2020 nicht außerdem abgekündigt (last order 06/2005) ? Peter
-
Thread
Problem mit mySmartUSB light
Leider kann man mit der AVR910 Firmware keinen ATmega328p proggen ... sagt zumindestens avrdude.
So, ich gebs auf! Nachdem mit den Tools "Support Box" und "myAVR ProgTool", die direkt vom Hersteller myAVR.de stammen, auch nicht (vernuenftig) funktioniert, gehe ich davon aus das mein Programmer einen (Dach-)Schaden hat. Werd also morgen wieder ins Geschaeft fahren
-
Thread
LCD, HD44780 und KS0076
***************************************************************/ #include <inttypes.h> #include <avr/io.h> #include <avr/pgmspace.h> #include "lcd.h" /* ** constants/macros */ #define DDR(x) (*(&x - 1)) /* address of data direction register of port x */ #if defined(__AVR_ATmega64
*/ #define LCD_E_PIN 4 /**< pin for Enable line */ #elif defined(__AVR_AT90S4414__) || defined(__AVR_AT90S8515__) || defined(__AVR_ATmega64__) || \ defined(__AVR_ATmega8515__)|| defined(__AVR_ATmega103__) || defined(__AVR_ATmega128__) || \ defined(__AVR_ATmega161
-
Thread
SHARP LJ640U34 von Pollin?
Mit einem AVR direkt wirds schwer: 640x400x70Hz=18MHz. Da man 2 Leitungen hat, reicht die Hälfte, also 9MHz. Man müsste also etwas Logik zusammenbauen um mit einem AVR 8bit ausgeben zu können, die dann als 2x 4bit seriell übertragen werden. Der AVR selbst müsste nur 2,25MByte/s liefern, was kein Problem sein sollte.
-
Thread
Dragon ISP Win 7 Problem
4.18 + SP2 oder? hast du den Jungo Treiber installiert? sollte normallerweise gehen, ich benutzte WinAVR + AVRDUDE unter 32Bit aber ich habe vor kurz zum Testzwecken AVRStudio auf ein 64Bit System installiert und war alles ok, kann noch mal morgen gucken.
Zuhause habe ich nur Windows 7 mit 64 Bit, werde aber in der kommenden Woche das Dragon Board an einem anderen System testen. Was ich auch schon gelesen habe, dass ein downgrade zum AVR Studio 4.17 helfen soll. Auch das werde ich in der
-
Thread
KiCad unter Linux. Anwendungsdatei wird nicht gefunden
[code] christopher@CC-64-LI:/opt/kicad/bin$ objdump -f kicad kicad: file format elf32-i386 architecture: i386, flags 0x00000112: EXEC_P, HAS_SYMS, D_PAGED start address 0x08192adc [/code] Also ich hab ein x86_64
Christopher C. schrieb im Beitrag #3307625: > Achso habe Elementary OS (Ubuntu 12.04) x86_64. Ich würde denken es könnte gehen mit 32 Bit, eventuell beachten >http://askubuntu.com/questions/297151/how-to-run-32-bit-programs-on-a-64-bit-system-ubuntu-13-04 >sudo apt-get install ia32-libs
-
Thread
MEGA324, MEGA644 Bezugsquelle?
für einen MEGA324 bzw. MEGA644. (die haben doppelt soviel EEPROM und RAM) und sind pinkomp. zum MEGA32, MEGA64...
"sind pinkomp. zum MEGA32, MEGA64..." ... und mehr. Immerhin ist der Mega64 nicht als PDIP40 verfügbar.
-
Thread
Höchstmögliche Schaltfrequenz an einem normalen AVR Ausgangs-Pin
AtMegas herum zu schlagen. Dort war es für Dich nicht möglich, jetzt schon? Die Adapter von TQFP32/48/64 bekommst Du bei ebay problemlos für ein paar Cent. Macht Dein Hobby auch nicht exorbitant teuerer.
Du die vielen, ernstgemeinten Vorschläge verstanden hättest, wären > es 6 x ATmegaxxx oder ein STM32 oder RP2040 oder ... gewesen Der hat jetzt aber 7 16-Bit Timer, heißt ich kann es einfach von der Hardware machen lassen, und brauch keine CPU Leistung dafür. Und ich würde generell gerne bei AVR
-
Thread
GCC - Rundungsfehler ?
M. K. schrieb im Beitrag #4805519: > das wird aber immer ein float sein Um es zu präzisieren: AVR-GCC verwendet für float und double den gleichen Datentyp; sizeof float == sizeof double == 4. Es hat sich bislang niemand die Mühe gemacht, 64-Bit-floatingpoint-Aritmetik auf den AVR zu portieren
: > AVR-GCC verwendet für float und double den gleichen Datentyp; sizeof > float == sizeof double == 4. > > Es hat sich bislang niemand die Mühe gemacht, > 64-Bit-floatingpoint-Aritmetik auf den AVR zu
-
Thread
GCC Funktionen "umbiegen"
> könnte man so dem AVRGCC echtes double-Format (64 bit) beibringen ? Ich vermute (ohne es zu wissen), dass der double auch beim AVRGCC 64 bit hat, nur die Rechenoperationen in der Library nur 32bit rechnen. Wenn das tatsächlich so ist, kannst du
Funktion ja auch Ausgabe statt ner Addition implementieren und damit dann einfach mal nachschauen ob 32 oder 64 bit ankommen.
-
Thread
USBbrog Problem
avrdude: Version 5.5, compiled on Jun 9 2008 at 14:32:04 Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/ System wide configuration file is "C:\WinAVR-20080610\bin\avrdude.conf" Using Port : usb
5.5, compiled on Jun 9 2008 at 14:32:04 Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/ System wide configuration file is "C:\WinAVR-20080610\bin\avrdude.conf" Using Port : usb
-
Thread
Ist Arduino verpönt?
Mikrocontrolelr Welt sind wesentlich näher an der Hardware (z.B. die http://www.mikrocontroller.net/articles/AVR_FAT32). > Ich möchte mich schon gern darauf verlassen, dass der C++ > Compiler auch den schnellsten Code erzeugt. Das ist unmöglich. Den *schnellsten* Code erhälst Du nur mit Assembler, wenn
meißten Käufer werden nur kurz damit rumspielen, aber einige werden dann zu den härteren Drogen (PIC, AVR, ARM etc in C, asm, Bascom, Pascal...) greifen. Übrigens: ist euch schonmal aufgefallen, daß es zu den meißten ARMs kaum Assembler-Beispiele gibt? USB am STM32? Da seht ihr selbst bei ST lange Gesichter
-
Thread
Kleiner Einsteiger Mikrocontroller
Wenn du eine billige Lösung suchst und dein Rechner einen Parallel-Port hat: AVR-Controller, z.B. den Atmega88 Den gibts in der Form: http://www.ebay.de/itm/ATMEGA88-20AU-Atmel-Microcontroller-AVR-Mega-TQFP-32-/160992807625?pt=Bauteile&hash=item257beb4ac9 oder so: http://www.ebay.de/itm/ATMEGA88PA-PU-Atmel-Microcontroller-AVR-Mega-DIP-28-/161159728711?pt=Bauteile&hash=item2585de4e47 Programmieren kannst du ihn mit dem kostenlosen Programm BASCOM AVR (eine Art BASIC für Mikrocontroller): http://www.mcselec.com/index.php
-
Thread
attiny asm: 8x8bit signed multiply
Recht alt 1999-2003), für AVR ohne Multiplizierbefehle in Assembler https://avr-asm.tripod.com/math32x.html allerdings eher 32 bit und unsigned
Christoph db1uq K. schrieb im Beitrag #7521349: > Recht alt 1999-2003), für AVR ohne Multiplizierbefehle in Assembler > https://avr-asm.tripod.com/math32x.html > allerdings eher 32 bit und unsigned Da ist nur das primitive Schiebe- und Addierspiel drinne. Was rechenzeittechnisch
-
Thread
1000 und mehr LEDs einzeln ansteuern?
Abstand in mm an, also z.B. Module mit P2, P3, P5, P8, P10, P15 Die Matrix-Größe beträgt 8x8, 16x16, 32x32 oder auch rechteckig, z.B. 32x64. Dann muss man noch unterscheiden, ob indoor oder outdoor (wasserdicht). Es gibt Treiber-Platinen für Raspi, Arduino, ESP und auch "richtige" Rechner (z.B. Hersteller
unterstützt, indem diese mehrere HUB75-Buchsen haben. Beispiel: Matrix 128 x 96 Pixel wird mit 32x64 Modulen (quer) erstellt, dann braucht man 3 parallele Chains zu je 4 Modulen (also 12 Module). Das wären dann immerhin 12288 RGB-LEDs. Zm Glück weden die gemutiplext, sonst bräuchte man armstarke
-
Thread
LCD 1x16 HD44870 kompatibel will einfach nicht mit der library von Peter Fleury funktionieren
der init routine zu ersetzen. So wurde aus: [c] lcd_command(LCD_FUNCTION_DEFAULT); delay(64); lcd_command(LCD_DISP_ON_CURSOR); delay(64); lcd_command(0x06); delay(64); [/c] Jetzt dieser Code: [c] LCD_PORT = 0x20; lcd_e_toggle(); delay(64
*)&(x)) #define vu16(x) (*(volatile u16*)&(x)) #define vs16(x) (*(volatile s16*)&(x)) #define vu32(x) (*(volatile u32*)&(x)) #define vs32(x) (*(volatile s32*)&(x)) [/c] Okay, hier wird jetzt anscheinend irgendeine Struktur erstellt. Aus unsigned chars. Aber hat diese Structur 8 unsigned chars
-
Thread
MiniLA Version MockUp
bösen Überschwinger :-). Zum anderen ein 136 Kanal Logic Analyzer Modul mit einer Speichertiefe von 64M, 2 GHz Timing und 200 MHz Stateanalysis. Ich kann Andreas Pretzsch nur voll zustimmen. Besonders, was die Speichertiefe angeht, es müssen ja keine 136 Kanäle sein, 32 reichen völlig. Mein Vorschlag
Hab es nochmal unter Arch Linux (x86_64) getestet: [root@laptop lin32]# ./xc3sprog -c ftdi -v -j Release $Rev: 401 $ Free software: If you cContribute nothing, expect nothing! Please provide feedback on success/failure/enhancement requests
-
Thread
avr-gcc: _spawnv: No such file or directory
-o test.elf): Using built-in specs. Target: avr Configured with: ../gcc-4.1.1/configure --prefix=/c/WinAVR --target=avr --enable-languages=c,c++ --with-dwarf2 --enable-win32-registry=WinAVR --disable-nls --disable-libssp --disable-fixincludes --
Original aus dem gcc 4.1.1-Quellcode zum Vergleich hier abgelegt: http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/winarmtests/pex-win32_patch_gcc411.zip Die Code darin hat nichts mit dem Target zu tun, sondern nur mit dem Host (hier also Win32) ist also nicht ARM- oder AVR-spezifisch. Mit
-
Thread
AVR Hardware PWM - ich raffs nicht
mach mal hier weiter ;-) Das nächste absolut unerklärliche Problem für mich: [c] #include <avr/io.h> #include <util/delay.h> #include <avr/pgmspace.h> uint8_t pwmtable[32] PROGMEM= {0, 1, 2, 2, 2, 3, 3, 4, 5, 6, 7, 8, 10, 11, 13, 16, 19, 23, 27, 32,
=(1<<CS01)|(1<<CS00); //Prescaler 1/64 OCR0A=0; uint8_t i =0; //Hauptschleife while(1) { for(i=0;i<32;i++) { OCR0A=pgm_read_byte(&pwmtable[i]); _delay_ms(100); } for(i=31;i>=0;i--)
-
Thread
uint32_t Problem
es denn überhaupt funktioniert), wundert mich übrigens nicht wirklich. Timer-Reload macht man beim AVR einfach nicht. Jeder AVR hat mindestens einen Timer, der mindestens eine Compare-Einheit besitzt. Und wenn man die im CTC-Modus betreibt, dann wird das ganze auch genau.
/////////////////// /****************/ /* Bibliotheken */ /****************/ #include <avr/io.h> #include <avr/interrupt.h> #include "led.h" /****************/ /* Prototypen */ /****************/ void initAll (void); uint32_t CLOCK_SystemTime2(void); /*****************
-
Thread
Wie programmiert man einen STM32?
beschränkt, die Register direkt zu befüllen und auszulesen und mich so Schritt für Schritt an den uC (STM32F411RE nucleo-64) rangetastet. Nachdem ich nun (nach einigen Wochen) so weit gekommen bin, dass ich LEDs blinken lassen, via I2C Sensorwerte einlesen und mittels PWM Servos ansteuern kann, beginne
beschränkt, die Register direkt zu befüllen und > auszulesen und mich so Schritt für Schritt an den uC (STM32F411RE > nucleo-64) rangetastet. Ja, sure, das ist besonders für Anfänger geeignet. Da kann man so viel bei der Init-Routinen falsch machen bzw. vergessen, dass es einfach lachhaft ist, den Anfängern
-
Thread
WS2812 Ansteuerung per Bitbanging für AVR und ARM von 4 Mhz-60 Mhz
No initialization required *Carefully optimized to use instructions which are available on all AVR cores and have the same instruction timing across all devices. *Supports standard AVR, reduced core AVR (Attiny 4/5/9/10/20/40) and XMEGA (untested) without special case handling. *New:Supports
wieder eine Sache der Einstellung. Habe den Test mit nem atmega8 gemacht und eingestellt war ein 32er.
-
Thread
TIMER für IRMP
anscheinend nicht auf den Empfänger. Dazu gesagt habe ich für die ISR-Routine den Timer2 meines Atmega32 benutzt. Diesen habe ich folgendermaßen initialisert: [c] #include <avr/io.h> #include <util/delay.h> #include <avr/interrupt.h> #include <stdlib.h> #include "lcd.h" #include "irmp.h"
); // switch CTC Mode on, set prescaler to 1 #if defined (__AVR_ATmega8__) || defined (__AVR_ATmega16__) || defined (__AVR_ATmega32__) || defined (__AVR_ATmega64__) || defined (__AVR_ATmega162__) TIMSK = 1 << OCIE1A;
-
Thread
LCD-Modul EPSON ECM-A0428 von Pollin
Seltsam.... Es scheint, als würde ein Eingang vom hc32 eine Spannung liefern ?!
vom linken Latch ist die oder-Verknüpfung (Pins 1, 12 und 13 des '32) von Ader 8 (/RD) und Pin 8 des '32 (Verknüpfung von /CS und der zusätzlichen Adresse). Wer das Display schon irgendwo angeschlossen hat, kann also versuchen, vom Touchscreen zu lesen. Wahrscheinlich
-
Thread
Display Reichelt TFT-DIS 4,3 LCD-Modul Fragen zum Timing
Graphiken machen kann. In deinem Post geht es um Text. Und schon dafür brauchst du schon einen riesigen AVR, mindestens 64k Flash. Die haben dann in etwa 60 Pins, wenn du das in DIP nimmst hast du schonmal einen riesen Displaycontroller. Ich sage nicht dass es mit einem AVR nicht möglich ist, ich sage
Schluss hast du dann ein flimmerndes Textdisplay oder so. Uzebox läuft übrigens auf einem gut 28MHz AVR.
-
Thread
Betriebssystem auf Grundlage des Linux-Kernels selbst schreiben
[code] objcopy -O binary -j .interp /bin/bash /dev/stdout; echo [/code] Dann steht dort: "/lib64/ld-linux-x86-64.so.2". Wenn ich also /bin/bash aufrufe, ist dass das selbe, wie wenn ich "/lib64/ld-linux-x86-64.so.2 /bin/bash" starten würde. (also /lib64/ld-linux-x86-64.so.2 als Program und /bin
immer, dass quemu nicht gefunden wird > es ist aber installiert! Der Befehl wäre "qemu-system-x86_64". Ich empfehle es mit "qemu-system-x86_64 -m 2G --drive media=cdrom,file=hello_world_distro.iso,readonly" zu starten.
-
Thread
Geschwindigkeit ATMega
Aufgabenstellung zu lösen? Man kann ja nur ganzzahlige Taktunterteilungen nutzen. Warum nicht einen AVR mit 64 MHz I/O Takt nutzen?
Atmel Betrüger schrieb im Beitrag #5963045: > Ich plädiere jetzt schon mal für einen STM32F103 (Bluepill) STM32 ist gut, aber nicht immer und nicht überall. Mit 3,3 Volt gibt es Problem, MOSFET direkt zu steuern, und das ist gerade bei Verwendungen für Motorregler wichtig. AVR mag etwas
-
Thread
Grafik-Display zeigt nichts an
Ich werde mit einem ATmega32 probieren
$lib "glcdKS108.lib" $hwstack = 64 $swstack = 64 $framesize = 40 initlcd '============================================================== 'Grafikdisplay KS108 | Atmega32 ' 01| VSS GND ' 02| VDD
-
Thread
USB - seitens des PCs - GUI auf Windows
im Forum) für AVR gibt. Für Hobbybastler sind immer entweder AVR oder PIC zu empfehlen. (Ein kleiner Rat am Rande: Frage *HIER* nie nie nie nach PIC vs. AVR hier - das gibt den dritten Weltkrieg). Wie gesagt für AVR
Tutorials und Beispielprojekte. Ein Einstieg wäre hier: http://www.mikrocontroller.net/articles/AVR-Tutorial http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial Ich kann dir schweren Herzens nur AVR empfehlen. Selbst komme ich aus dem PIC-Lager =) Achja also einen FTDI IC kann man mit
-
Thread
Galep3, Atmega EEPROM / FUSES programmieren.
man die 64-Bit Version der glpntdrv.sys: https://heha.fwh.is/hs/glpntdrv.zip/ Aus der ZIP muss man die glpntdrv.sys welche sich im Verzeichnis AMD64 befindet nach C:\Windows\System32\Driver kopieren, keine aus einem anderen Verzeichniss. Dazu ist demnach ein x64 Kopierprogramm nötig. Ich hab dazu den Total Commander in X64 genutzt: https://www.ghisler.com/deutsch.htm Danach kann man Galep32 schonmal ohne Fehlermeldung starten :) Unter ->Options->Application
-
Thread
PIC Microcontroller
> > typ RISCs (auch AVR,ARM,MIPS) bräuchten dafür mehrere Befehle. Du hast ja grundsätzlich recht, das war jetzt von mir auch anders gemeint. Eher aus "Wirtschaftlicher Sicht" gedacht. Die 16/32 Bit Pics sind schon relativ
jedesmal schauen ob man den überhaupt programmieren kann. Einen Erschwinglichen Programmer der jedem AVR (8Bit, ATMEGA, ATTINY,XMEGA ATMEGA32) programmieren kann gibt es nicht (bzw. gab es bis vor kurzem nicht. Wenn man jetzt mal die Schnittstellenvariante anschaut die wirklich "ISP" genannt wird Anschaut
-
Thread
Was ist mit dem avr-gcc 12.x passiert? Internal Compiler Errors Gesperrt
irgendwas. Ich hab mir Sorgen gemacht und nachgesehen. Es ist doch nur ein *-*-*-*-gcc-11.2.1-1.2-win32-x64.zip. Nochmal Glueck gehabt.
/bugs/> for instructions. lto-wrapper.exe: fatal error: C:\avrToolchain\avr-gcc-12.2.0_mingw32_binutils2.40_avrLibc2.1GitHub/bin/avr-gcc returned 1 exit status compilation terminated. c:/avrtoolchain/avr-gcc-12.2.0_mingw32_binutils2.40_avrlibc2.1github/bin/..
-
Thread
ATmega32 läuft nicht richtig an
can't be checked here */ /* repeat last command */ lcd_e_toggle(); delay(64); /* delay, busy flag can't be checked here */ /* repeat last command a third time */ lcd_e_toggle(); delay(64); /* delay, busy flag can't be checked here
lcd_write(LCD_FUNCTION_8BIT_1LINE,0); /* function set: 8bit interface */ delay(64); /* wait 64us */ lcd_write(LCD_FUNCTION_8BIT_1LINE,0); /* function set: 8bit interface */ delay(64);