-
Thread
Brauche Hilfe bei der Auswahl von programmern für den Atmega8
besorge ich mir noch folgendes nur zum Austesten: https://de.aliexpress.com/item/1LOT-New-USBASP-USBISP-AVR-Programmer-USB-ISP-USB-ASP-ATMEGA8-ATMEGA128-Support-Win7-64/32724669918.html Danke schonmal
ich mir noch folgendes nur zum Austesten: > https://de.aliexpress.com/item/1LOT-New-USBASP-USBISP-AVR-Programmer-USB-ISP-USB-ASP-ATMEGA8-ATMEGA128-Support-Win7-64/32724669918.html Das ist technisch genau das gleiche.
-
Thread
AVR32 Buildroot Versionen + Grasshopper
pages: 16256 Kernel command line: root=1F02 rootfstype=jffs2 mtdparts=physmap-flash.0:128k(boot)ro,64k(env)ro,-(root) PID hash table entries: 256 (order: 8, 1024 bytes) avr32_comparator: irq 0, 140.000 MHz Console: colour dummy device 80x25 console [tty0] enabled console [ttyS0] enabled Dentry
0xfff03400 NET: Registered protocol family 16 pdc pdc.0: Atmel Peripheral DMA Controller enabled at32_eic at32_eic.0: External Interrupt Controller at 0xfff00100, IRQ 19 at32_eic at32_eic.0: Handling 4 external IRQs, starting with IRQ 64 AVR32 AP Power Management enabled ICnova: 9 Leds bio: create
-
Thread
ATMega2560 und VGA-Verbindung
0xFF hält ganz genau einen Takt, also 64µs an, bis PORTL wieder umgedreht wird. Dadurch entsteht ein horizontales Signal, das 64µs auf 0xFF und 16ms auf 0x00 steht.
Timermode 14 oder 15. Top mit OCR1 oder OCR1A auf die 16,..ms gestellt und OCR1A oder OCR1B auf die 64µs
-
Thread
(Chip8 / gameboy) Emulator für AVR AVR32
?v=OyuSLipXvNk Ist keine Portierung, alles selbst geschrieben. Als Prozessor nutze ich einen AVR32UC3 512kbyte Flash 64kbyte SRAM 66Mhz (84Mhz overclock) Und als nächstes wollte ich mich mal an einen GameBoy Emulator machen. Da dieses aber etwas komplexer ist, bräuchte ich vielleicht etwas
nur die Grundfunktionen angepasst werden). Vorraussetzung sind natürlich Tasten(am besten 16st) + (64X32px) Display. Gruß Zippi
-
Thread
Serielle Visualisierung mit Comvisu
einem WinXP 5.1 SP3 System. Dort gibts aber die Fehlermeldung "Der Prozedureinsprungpunkt "GetTickCount64" wurde in der DLL "kernel32.dll" nicht gefunden. Damit kann bei mir das Programm nicht gestartet werden. Ist es evt. erst ab Win7 geeignet?
Kann es sein, dass da der 32/64 Bit Zugriff auf die Schnittstelle nicht korrekt gelöst ist und jeweils freigegeben wird? Da scheinen irgendwie manchmal 2 Prozesse auf einander zu warten, jedenfalls hängt sich das bei mir auch oft
-
Thread
ATMegas vernetzen ?
stelle ich mir eine "Vernetzung" mehrerer AVRs vor. Ich habe, sagen wir mal 4 Mega16, mit je 8-32 LEDs. Nun bekommt der erste AVR einen ExtInt, und lässt seine LEDs in einem bestimmten Bitmuster leuchten. Die anderen haben nun auch je 8-32 LEDs, und sollen zur gleichen Zeit "Ihr" Bitmuster auf
EEPROM zu beschalten ist mit kompletten Schaltplan im Forum einfach mal suchen glaube das war ein 28C64
-
Thread
Welcher Mikrocontroller?
Ich denke für diese Aufgabe wäre ein STM32F103VC interessant. RAM 64KB, Flash genügen, auch 100 Pins. Intern 3 AD Wandler, die unabhängig betrieben werden könen mit 12 Bit Auflösung. 72 MHZ Geschwindigkeit, also der kann die Daten auch verarbeiten
im Beitrag #1821293: > Was ist denn unklar? Nun, für den ATmega8 hatte ich das STK500 Board mit AVR-Studio verwendet. Was muss ich denn für den STM32 benutzen? Welche Hardware und welche Software??? Gibt es vllt sogar ein Buch oder eine ausführliche pdf? Am besten mit einem Beispielcode. Gruß
-
Thread
Neues Eval-Board für Atmel-ARM
> von ST ... bisher waren die ja immer recht teuer. Ich habe vor ein par Moanten ein Nucelo-64 mit STM32F103RBT6 für 16 Euro inclusive Versand gekauft (und zwar direkt von ST bei Amazon). Wenn ich bei Atmel ein AVR Evaluation Kit und einen Debugger kaufen würde, müsste ich dafür fast 200 Euro
> von ST ... bisher waren die ja immer recht teuer. > > Ich habe vor ein par Moanten ein Nucelo-64 mit STM32F103RBT6 für 16 Euro > inclusive Versand gekauft (und zwar direkt von ST bei Amazon). > > Wenn ich bei Atmel ein AVR Evaluation Kit und einen Debugger kaufen > würde, müsste ich dafür
-
Thread
Auswahl des richtigen µc
davon nichts beschrieben. Hier ein Link zu Farnell: http://de.farnell.com/stmicroelectronics/stm32f103rct6/mcu-32bit-cortexm3-256k-flash-64lqfp/dp/1624136?Ntt=STM32F103RC Den habe ich auch in meinem Display im Einsatz. 256 KB Flash sollten völlig ausreichen, denn es kommt kein Grafikdisplay dran
und möchte natürlich eure Meinungen dazu hören. Prozessor soll wahrscheinlich werden ein STM32f103rc -Er hat 6Timer die ich für Steuerungsaufgaben benutzen kann -2 Mal Spi Buss -Genug AD Ports FM25CL64 -64Kb FRAM eventuell reichen auch 32kb -genug Platz für 200 Werte Zündung (200*8Bit
-
Thread
Linux >> simpler ISP Programmer für ATTinys mit avrdude?
jedem halbwegs aktuellen Linux (i386, amd64 oder 32bit Arm) so mit avrdude zum Laufen zu bekommen sein? Gruß und Dank Markus
der unter jedem halbwegs aktuellen Linux > (i386, amd64 oder 32bit Arm) so mit avrdude zum Laufen zu bekommen sein? > > Gruß und Dank Markus Also doch nicht die ware Lösung, der Atmel AVR ISP mkII Programmer?
-
Thread
Universelle Mikrocontroller Toolchain (Linux)
die Implementierung meist nur mit 1 oder 2 Typen testen konnte: - Diverse MCS51 - Espressif ESP32 - Microchip/Atmel AVR (nur ATMega) - Microchip PIC14 (PIC12xx, PIC16xx) - Microchip PIC16 (PIC18xx) - NXP/Freescale HCS08 - NXP/Freescale HCS12X (auch banked) - NXP/Freescale MPC57xx - NXP/Freescale S9KEA - NXP/Freescale S32K11x - NXP/Freescale S32K14x - Renesas R8C - Renesas 78K0R - Renesas RL78 - Renesas RH850 - Renesas RA6T1 - ST/NXP/Freescale SPC56xx/MPC56xx - ST SPC584 - ST STM32F0xx - ST STM32F1xx - ST STM32F4xx
-
Thread
Wie bestimmte GCC Version nutzen? Docker?
mingw.*i686|grep "win32.*i386" p g++-mingw-w64-i686-win32:i386 - GNU C++ compiler for MinGW-w64, Win32/Win32 p gcc-mingw-w64-i686-win32:i386 - GNU C compiler for MinGW-w64, Win32/Win32 p gcc-mingw-w64-i686-win32-runtime:i386 - GNU Compiler Collection for MinGW-w64, i686/Win32 p gfortran-mingw-w64-i686-win32:i386 - GNU Fortran compiler for MinGW-w64, Win32/Win32 p gnat-mingw-w64-i686-win32:i386 - GNU Ada compiler for MinGW-w64, Win32/Win32 p gobjc++-mingw-w64
-
Thread
Logik Analyzer
Jitter), 819 us buffer 40MSP 1.6ms buffer 20MSP 3.3ms buffer 10MSP 6.5ms buffer 10MSP-1MSP Avr generiert Takt 1MSP-.... Avr interpoliert. Für LA, das gleiche, nur daß 160MSP mit 8Kanälen gemacht werden kann. Jedoch keine Kompression, die kann nur über AVR realisiert werden, das heisst
mal die Grundschaltung für das LA. Dargestellt sind nur 16 bits, aber das Verwendete RAM ist ein 64x32bit mit 5.5nS. Der Verwendete Osc kann bis 170Mhz. Die Latches sind nur als DIL Sockel dargestellt, da es gedacht ist, zwischen 8x RCR Filtern, TTL und Cmos Latches zu wechseln. Es ist gedacht
-
Thread
data |= (1<<16) funktioniert nicht
Auf einem 32 bitter würde das übrigens mit den meisten Compilern so gehen. Ohne Casting wird eben immer vom Standart Datentyp int ausgegangen und der ist beim Avr nunnmal 16 Bit. Ein Integer ist in der Regel so
Rolf Magnus schrieb im Beitrag #3000657: > Aber auch auf 64-Bit-Plattformen selten 64 Bit. Für AVR-GCC war dies der *wichtigste und treffendste Hinweis*.
-
Thread
Rust oder Nimrod als neue Hobbyprogrammiersprache?
noch kleinere Executables, die finde ich aber gerade nicht. Ist wohl dann gcc mit -Os. stefan@AMD64X2 ~ $ ldd convex_hull linux-vdso.so.1 (0x00007fff3c3ff000) libdl.so.2 => /lib64/libdl.so.2 (0x00007f25acb2b000) libc.so.6 => /lib64/libc.so.6 (0x00007f25ac784000) /lib64/ld-linux-x86-64.so
/viewvc/*checkout*/trunk/avr-libc/libc/stdlib/malloc.c?root=avr-libc&content-type=text%2Fplain http://svn.savannah.nongnu.org/viewvc/*checkout*/trunk/avr-libc/libc/stdlib/stdlib_private.h?root=avr-libc&content-type=text%2Fplain
-
Thread
M16C samt Dev-Kit für lau!
weiss jemand die nummer von dem SKP32C84 ?
/skp/skp32c84/starter_kit/SKP32C84_BOM.pdf *und hier:* http://america.renesas.com/products/tools/introductory_evaluation_tools/starterkits_evaluation_boards/skp/skp32c84/starter_kit/SKP32C84_Schematic.PDF *und
-
Thread
Überlauf bei 255 + 1?
char" 0..511. > explizit heißt "long ist immer größer als int") Dann wäre kaum ein Compiler für 32bit Maschinen ANSI-konform, denn dort gilt meistens sizeof(int)==sizeof(long). Ebenso Microsofts Maschinenmodell für AMD64. Mein Kennstnisstand: sizeof(short) <= sizeof(int) <= sizeof(long) Ob für
> Compiler gcc und nur gcc > Architektur AVR und nur AVR > Datentyp unsigned char Es ist gewährleistet, dass ein Compiler, der wie WinAVR ein "unsigned char" als 8-Bit Byte implementiert, bei 255+1 den Wert 0 speichert. Eventuelle Compilerfehler
-
Thread
Falsche Deklaration in pgmspace.h ?
prog_int16_t PROGMEM; typedef uint16_t prog_uint16_t PROGMEM; #if !defined(__USING_MINT8) typedef int32_t prog_int32_t PROGMEM; typedef uint32_t prog_uint32_t PROGMEM; #endif typedef int64_t prog_int64_t PROGMEM; typedef uint64_t prog_uint64_t PROGMEM; [/C] Wenn ich nun eine Konstante
[c] #include <avr/signal.h> ... #include <avr/delay.h> [/c] deutet darauf hin, dass du eine ziemlich alte Version der Bibliothek nimmst. <avr/signal.h> ist ersatzlos gestrichen und sein vormaliger Inhalt in <avr
-
Thread
[V] USB-AT(X)MEGA- und STM32-Boards im Dual-In-Line-Format
braucht. Nicht mehr und nicht weniger! Es gibt folgende Module: U2DIL: AT90USB162 oder ATMEGA32U2, 28-polig U4DIL: ATMEGA32U4, 40-polig U6DIL: AT90USB1286, 64-polig X4DIL: ATXMEGA32A4U oder ATXMEGA128A4U, 40-polig X3DIL: ATXMEGA256A3U, 64-polig B1DIL: AT32UC3B1256 (AVR32), 40-polig B0DIL: AT32UC3B0512 (AVR32), 64-polig S64DIL: STM32F103RGT6 (ARM Cortex-M3) oder STM32F405RGT6 (ARM Cortex-M4), 64-polig Darüber hinaus gibt es noch den "AVR-Stick", einen AT90USB162 oder ATMEGA32U2 in einem
-
Thread
Einstieg Mikrocontroller AVR vs ARM? Gesperrt
#4697201: > Gerät (ST-Link v2) kostet > original um die 30 Deswegen wurd' ja oben auch schon das STM32 Discovery (oder auch Nucleo) vorgeschlagen. Da ist der "original" ST-Link schon drin und nach Abbrechen sogar standalone nutzbar. Ich bin vor 2 Jahren angefangen von AVR auf STM32 umzusteigen und
man an den ARM-Controllern nicht vorbei. Zudem ist der Preis-Leistungsverhältnis zwischen einem AVR 8 Bitter und ARM 32 Bitter einfach unschlagbar. Da können sich die AVR-Leute drehen und wenden, wie sie wollen. Beide haben allerdings ihre Daseinsberechtigung. Industriestandard ist nun mal Windows
-
Thread
Deklaration von external memory
, aber dann kam die Idee, es doch mal mit C zu versuchen. Ich habe derzeit ein Array[64] (in Zukunft [255]) in Verwendung, welches für jeden Satz 32 Aktionen enthält. Die Entscheidung über Aktiv oder Inaktiv wird über Bedingungen getroffen, die zu jedem Satz mit zweimal uint16_t [4] hinterlegt
#3990386: > Geht nur, wenn Du zufällig in Assembler die gleiche Byteorder benutzt > hast, wie der AVR-GCC. > Wieviel Byte sind es denn? Unter anderem deshalb habe ich mit der Anordnung der Daten in den strutc so herumgerudert. Sind knapp 32k an Daten. > Mir reichte bisher auch der internen EEPROM
-
Thread
30 Khz min 16BIT ADC und dann FFT welcher µC?
Eine FFT kann im Prinzip schon ein AVR. Wie lange darf's denn dauern ? Und bei welcher Blockgroesse.
Siggi wrote: > Wie verhält sich die Rechenleistung des dsPIC33FJ64GP802 zum ATMega644 Etwa Faktor 2-3 bei einfachen Sachen wie Bittoggeln usw. (da 40MIPS beim dsPIC und nur 20MIPS beim AVR) und mindestens Faktor 4 bei DSP Sachen wie FFT (da 16bit + DSP Kern mit speziellen
-
Thread
Blöder Compiler - Optimieren in C?
66 df rcall .-308 ; 0xe6 <twi_readack> 21a: c8 2f mov r28, r24 21c: 64 df rcall .-312 ; 0xe6 <twi_readack> 21e: 2c 2f mov r18, r28 220: 30 e0 ldi r19, 0x00 ; 0 222: 32 2f mov r19, r18 224: 22 27 eor r18, r18
-MP -MF "gh_main.d" -MT"gh_main.d" -MT"gh_main.o" -o "gh_main.o" ".././gh_main.c" Invoking: AVR/GNU Linker : 4.9.2 "C:\Program Files (x86)\Atmel\Studio\7.0\toolchain\avr8\avr8-gnu-toolchain\bin\avr-gcc.exe" -o gh.elf gh_main.o -Wl,-Map="gh.map" -Wl,--start-group -Wl,-lm -Wl,--end-group -Wl
-
Thread
Problem mit C struct auf ARM
speicherst. Wenn keine besonderen Maßnahmen vorgesehen sind, - und dafür spricht, dass der Code von einem AVR portiert wird, der das Problem ja nicht hat -, dann kann es sein, dass die Bytefolge der Struktur im Buffer nicht an einer 32-Bit-aligned Adresse beginnt. Ein cast dieser Adresse und der Versuch dann
habe eine Leerzeile eingefügt alle 8 Bytes zur Übersicht: int8_t int8_t int16_t int32_t int32_t int16_t int16_t int64_t [/c] aber zum Beispiel *NICHT* [c] int8_t // ok int8_t // ok int32_t // falsch, offset 2 ist keine 4-er Zahl, Compiler würde zwei Bytes Padding
-
Thread
Problem mit Eclipse: kennt DDRA etc. nicht
Guten Abend zusammen Folgende Situation... Ich habe auf einem Win7 Ultimate x64 Rechner Java x64 und Eclipse Indigo x64 Eclipse IDE for C/C++ Developers Version: Indigo Service Release 1 Build id: 20110916-0149 Installiert Dazu habe ich in Eclipse das neuste AVR Plugin
Ich hatte bei meinen Projekten die bisher auf einer 32 Bit Maschine liefen auch Probleme nach dem Umstieg auf 64 Bit und Indigo. Viele Portdefinitionen wurden von Eclipse nicht gefunden. Aber die Probleme liesen sich mittels Rechtsklick auf Projekt -> Index
-
Thread
Timerinterrupts howto
u64 _time; void setTime(u64 time) { u8 tmpSREG = SREG; cli(); _time = time; SREG = tmpSREG; } u64 getTime() { u8 tmpSREG = SREG; cli(); u64 ret = _time; SREG = tmpSREG;
blinkt" mit einer nicht mehr wahrnembaren Frequenz? Ich verwende Linux + Eclipse + CDT-Plugin + AVR-Plugin(->avr-gcc + avrdude) + AVRISPmkII + RNControl + ATmega32
-
Thread
Ethernet auf IEEE-488 Gateway
kommt noch der ENC28J60 für 2-4 Euro je nach Bauform. Ein TI/Luminary Micro LM3S8930 kostet dort 9.32 Euro und damit etwa die Hälfte, hat gleich 10/100 Ethernet inkl Phy(!), 2*CAN, 256k Flash und 64k RAM eingebaut und ist viel viel leistungsfähiger. fchk
bei 1mbit can ist ein avr ein wenig zu langsam... der enc ethernet controller ist auch steinzeitlich.. sinnvoller wäre ein aktueller 32bit prozessor mit integrierten can+ethernet
-
Thread
AVR Assembler relative jump
direkt unterstützt. Viel einfacher als beim AVR... ;-)
Das dürfte erheblich schneller sein, als ein schnarchlahmer Interpreter. Du brauchst auch keinen 2. AVR, der AVR kann sich selber programmieren (SPM-Befehl).
-
Thread
Ein sachlicher Vergleich Pascal <-> C
einfach irgendwann unuebersichtlich wird. Nö. Du schielst da nur auf die Embedded Computer mit dicken 32 Bit ARM CPUs. Es gibt ein Leben jenseits von 32 Bit. > Da bietet sich eine >Objektorientierte Sprache an, einfach weil die Aufgaben die man heute >loesst SEHR weit vom blinken einer LED entfernt
übersichtlicher als der C-Code. (Siehe mein Programm EleLa, in Lazarus geschrieben, kompiliert für Win32/64 und Linux32/64.) Ich würde für Mikrocontroller niemals Pascal nehmen, denn Codevorlagen und Infos sind im WWW alle samt (meistens) in C. Oder bei Fragen im Forum für Mikrocontroller besteht auch
-
Thread
Bitwackeln mit USB to Seriell Wandler (Schnelligkeit)
Werde den Cod mal in mein Zukunftverzeichnis kopieren. Ist schon allerhand vorhanden. Habe auch eine AVR-Prog Karte von Pollin. Seriell und Billig. Eigentlich will ich mich nicht mehr mit "Großen AVR oder Pic -Programmen beschäftigen. vom Pc ser Out/in zum Controller habe ich schon 98/99 gemacht
wirklich übersehen. Aber _lukrativ_ sind die Preise für den Bastler auch nicht. Da bin ich mit 'm AVR besser bedient. ...
-
Thread
Atmega64L ISP - Problem
- China Klon geschossen. Nun versuche ich über den Mega2560 als ISP für meinen Ziel - Chip AtMega64L über AvrDude (integiert in die IDE) den bootloader zu brennen. Da die IDE den AtMega64L nicht anbietet musste ich zuvor noch einen zusätzlichen Board Support laden. Nun taucht auch der ATMega64 auf
ich das /RESET wackelt. SCK wackelt und MOSI wackelt auch. Allerdings MISO (der output des AtMega64L) ist nicht zum Leben zu erwecken. AvrDude erzählt mir etwas von falscher Chip - Kennung - Klar der OUTPUT floated ja. Da kommt jedes mal was anderes raus, es sei denn ich setze noch einen pullup
-
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
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
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
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