-
Thread
Fehler bei avr-gcc 4.8.1 und nicht bei 4.3.3
Wenn es nur um die Tools geht (avr-gcc + binutils + avr-libc), die hatte ich vor einiger Zeit mal für MinGW32 generiert: https://sourceforge.net/projects/mobilechessboar/files/avr-gcc%20snapshots%20%28Win32%29/ Das neueste ist
prompt eine "Fehlermeldung": [c] c:/gcc-8-avr-mingw32/bin/../lib/gcc/avr/8.5.1/../../../../avr/bin/ld.exe: address 0x801402 of Multitasking.elf section `.bss' is not within region `data' c:/gcc-8-avr-mingw32/bin/../lib/gcc/avr/8.5.1/../../../.
-
Thread
Günstiges und einfaches Mini-Controller Board, was würdet ihr heute nehmen?
Hallo, also nach einigen Jahren, in denen ich mal mit AVR gebastelt hatte, bin ich vor einiger Zeit wieder eingestiegen mit dem ESP32 (mit einem inzwischen veralteten Dev Kit V4, ESP WROOM 32D). IMO ist das ein sehr gutes Board, der ESP hat sehr vielfältige
> verstehen. So sehe ich das auch. Die gibt es in guter Qualität für AVR und STM32 für Software und(!) Hardware.
-
Thread
Atmel-µC mit USB-Controller im DIP-Gehäuse
werden würdest. Z.B. PIC18F4553(DIP40)/2553(DIP28), oder aus der 16 Bit Serie den PIC24FJ64GB002, oder aus der 32 Bit Serie den neuen PIC32MX220F032B. Den passenden USB-Stack gibts kostenlos bei Microchip zum Download. Ab und an lohnt sich ein Blick über den Tellerrand. fchk
? Ein PIC32 spielt in einer ganz /anderen/ Liga. Markus W. schrieb im Beitrag #2512995: > Ich werd einen AVR ATmega > verwenden, weil ich diese Serie besser kenne. Die Frage ist allerdings, kennst Du USB
-
Thread
Bascom Bootloader Atmega32 plu Fusebits
http://www.fam-markus.de/fotoforum/avr/flashen/flashen1.jpg Das sind meine Einstellungen zum Programmer: http://www.fam-markus.de/fotoforum/avr/flashen/settingsisp.jpg ich verwende eien passiven (mit Widerständen) ISP Adapter Das sind meine Fusebits die ich gesetzt habe http://www.fam-markus.de/fotoforum/avr/flashen/fusebits.jpg danach klicke ich wieder auf das grüne Chipsymbol und es wird geflasht http://www.fam-markus.de/fotoforum/avr/flashen/writing.jpg http://www.fam-markus.de/fotoforum/avr/
-
Thread
SPS Betriebssytem
gerade nochmal durch den Kopf gehen lassen und bin zu folgendem Entschluss gekommen! MCU: ATmega32-16 DIP mit 16MHz Quarz Inputs: 16 Stück (durch 2x 74HC595)ggf mit Optok. Outputs: 16 Stück (durch 2x 74HC165)ggf mit Optok. ADC: 8 ADC`s (die des AVR`s) PWM: 2 CAN: MCP2515 RS232:
, einen "mini-AWL-Parser" in meinem uC zu implementieren, so das ich das Programm nicht mit in den AVR Flashen muss, sondern es in ein externes EEProm (wie die I2C EEproms 24C64) drücken kann. @123 Nein, die Platine ist 1. Komerziell und keine Codeveröffentlichung 2. Meine Ideen lassen sich nicht
-
Thread
Problem mit zu großen Arrays im EEPROM
Hallo Forum, ich bekomme meine Arrays leider nicht in den internen EEprom (mega32) unter und suche daher eine gute Möglichkeit wie ich dies anders regeln kann. #include <avr/eeprom.h> #ifndef EEMEM #define EEMEM __attribute__ ((section (".eeprom"))) #endif uint16_t varay1
schaffen. Mir bleibt momentan nur, meinen Speicherbedarf soweit zu reduzieren um es in nen Mega32 und nen 24c512 unterzubringen. Ich denke mit Interpolation könnte das wohl klappen, am Ende merkts wohl nichtmal jemand wenn der AVR nur linear interpoliert und nicht als Spline wie mein PC-Programm
-
Thread
FFT mit ATmega88
mögliche das ich hier also wählen kann ist eine FFT_N = 128 -> (2Byte * 128 + 4Byte * 128 + 2Byte * 64) = 896 Byte das meine FFT als Speicher braucht. Richtig? 4. Mit der 128 Punkt FFT bekomme ich also 64 Spektrumbalken = 64 Koeffizienten (128 Messwerte wobei aber nur die ersten 64 relevant sind da
4. Mit der 128 Punkt FFT bekomme ich also 64 Spektrumbalken = 64 Koeffizienten (128 Messwerte wobei aber nur die ersten 64 relevant sind da die restlichen 64 gespiegelt sind) Richtig? 5. Auflösung = Samplingfrequenz / (FFT-Länge/2) = 22,154kHz
-
Thread
Arduino IDE 1.74 <-> 1.89
Uno und Mega. Meine IDE kennt den > noch nicht. Du musst in der Boardverwaltung "Arduino megaAVR Boards" nachinstallieren, aktuell v1.8.5 Wegen avr-gcc 7.3 mit der IDE. Ab IDE v1.8.12 wird das Paket "Arduino AVR Boards" automatisch installiert, aktuell v1.8.2. In älteren IDEs kann man das selbst nachinstallieren und hat den aktuelleren avr-gcc.
-
Thread
Experimente mir Controller im QFP- Gehäuse
oder auch sowas in der Art: http://cgi.ebay.de/AVR-ATmega-64-128-QFP64-TQFP64-ISP-Programmer-Adapter-/290406212659?cmd=ViewItem&pt=LH_DefaultDomain_0&hash=item439d8f2433
Wie wär's damit: http://www.olimex.com/dev/avr-m32.html
-
Thread
ATtiny85 kann nicht angesprochen werden.
4 0 no 512 4 0 4000 4500 0xff 0xff flash 65 6 32 0 yes 8192 64 128 4500 4500 0xff 0xff signature 0 0 0 0 no 3 0 0 0 0 0x00 0x00 lock 0 0 0
--- ---- ------ ----- ----- --------- 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
-
Thread
32-Bit Arithmetik mit dem AVR
Hi! Kann es sein, dass der GCC es noch nicht so ganz drauf hat mit 32-Bit Arithmetik im AVR? cplex_data ist eine 32-Bit Variable, seconds, minutes und hours sind 8-Bit Variablen. Das ganze ist für eine Binär-Uhr und soll das Ausgaberegister für den Charlieplexer zusammenbauen
"-Os" 86 Bytes. > Eigentlich hat der AVR da kaum Arbeit. Der AVR hat keine Asm-Befehle für mehrfaches Schieben, also muss "<< 6" und "<< 12" über Schleifen realisiert werden und das auch noch mit 32-Bit Werten. Da kommt halt einiges zusammen
-
Thread
Unterschiede zwischen Emulator und Virtueller Maschine?
unterscheidlich sind, da geht dann nur noch die Emulation aber eben keine Virtualisierung. Kurz IA-32, x86-64 und IA-16 sind alle drei x86.
Virtualisierung und trotzdem nicht die gleiche Architektur. Nano schrieb im Beitrag #6296490: > Kurz IA-32, x86-64 und IA-16 sind alle drei x86. Thumb, Thumb2, ARM32 und ARM64 sind verschiedene Befehlssätze, obwohl ein ARM-Prozessor wahrscheinlich mindestens zwei davon ausführen kann. Ebenso sind IA-16
-
Thread
Projekt mit Tiny 13
Stil gottseidank keine Rücksicht nehmen, auf Portablität der Programme auch nicht. Ich schreibe keine AVR-Programme, die hinterher auf '8051ern, PICs, MSP430 oder dem Rest der Welt laufen müssen. Und für den Einstieg in die AVR-Mikrocontrollertechnik halte ich einen kleinen AVR wie Tiny13 oder Tiny2313
wird, nicht im Simulator von AVR STudio? Wenn ja, wie?
-
Thread
uC - kennst du einen, kennst du alle
blutigen Anfänger > heutzutage raten anzufangen? Wenn du schnelle Erfolge brauchst, dann die AVR Serie (z.B. ATmega328P auf Arduino-Nano Board), ansonsten etwas mit ARM Cortex M3 oder M4 drin (z.B. STM32F103C8T6 auf Blue-Pill Board oder STM32F103RBT6 auf Nucleo-64 Board). Wir reden hier von
Programmierschnittstelle und Fang an. Hier gibt es Infos: https://www.mikrocontroller.net/articles/AVR-Tutorial:_Equipment Hier gibt's die verschiedenen Studio IDE-Versionen: https://www.microchip.com/mplab/avr-support/avr-and-sam-downloads-archive Dann eben den USB-zu Rs232 Konverter, der auch
-
Thread
Mega128 + gcc + 32k externes SRAM --> läuft nicht
Warnung (außer den "this file has moved"-Warnungen infolge der neueren avr-libc-Version), ansonsten compiliert es. Ja, eine Variable muss beim AVR-GCC wohl kleiner als 32 KiByte sein, ich denke, das hängt damit zusammen, dass die Indizierung des Speichers über einen `
Ich hab auf einem Mega64 extern 32kB RAM, das einzige was ich gemacht habe war im Makefile: EXTMEMOPTS = -Wl,--defsym=__heap_start=0x801100,--defsym=__heap_end=0x8090ff und bei Programstart: MCUCR = _BV (SRE) | _BV
-
Thread
Projekt Schaufelraddampfer
Bürstenlosen Motoren wirklich so genau? Gibt es Empfehlungen für ein Einsteigerboard für die Atmega32? Hier im Shop habe ich das gefunden: http://shop.embedded-projects.net/product_info.php/info/p78_AVR-Entwicklungsplatine-fuer-40-polige-AVRs--AVR-P40-853.html Reicht es um so etwas zu entwickeln?
AVR's gedacht, aber auch für Mega32 oder Tiny verwendbar. Das Carrier Board für den 500er sollte gerade eben erlauben, die moderneren AVR's verwenden zu können. Nimm ein Steckbrett, und wurstel einen
-
Thread
xmega128a1 EBI SDRAM
"-Wl,-defsym=__heap_end=0x80ffff" * sind Pflicht! * avr-size berücksichtigt den dazubekommenen Speicher * nicht! * * 32KHz/32MHz RC-OSC Starten * PLL mit 64MHz Starten * ClkCpu auf
EBI_CS_SDINITDONE_bm)); // warten bis fertig // System Clock initialisieren OSC.PLLCTRL = OSC_PLLSRC_RC32M_gc | OSC_PLLFAC3_bm;// 32MHz/4 * 8 = 64MHz OSC.DFLLCTRL = OSC_RC32MCREF_bm; // 32MHz Rc kalibrieren DFLLRC32M.CTRL = DFLL_ENABLE_bm; // Kalibrierung ein OSC.CTRL |= OSC_RC32MEN_bm
-
Thread
Max233: Falsche Characters
AD BB BF B7 3F 47 19:09:24 hypertrm.exe IRP_MJ_READ Serial0 SUCCESS Length 80: 6D 61 6E 64 B0 6E 6D 6F 75 BB BF 7B 6F 6F 77 BD AF 77 75 77 AF 48 19:09:24 hypertrm.exe IRP_MJ_READ Serial0 SUCCESS Length 80: 3D 3D 35 32 30 30 EA ED 7B 5F 55 BB 3F 5B 5B 4D 35 33 35 32 BE 49 19:
37 hypertrm.exe IRP_MJ_READ Serial0 TIMEOUT Length 52: 55 73 6D 6F 77 23 2F 6C 6D 7B 2F 6D 6F 64 75 6E 75 7B 2F 32 2E 84 19:09:37 hypertrm.exe IRP_MJ_READ Serial0 TIMEOUT Length 46: 55 7B 69 6E 67 B8 AF 6F 6D 7B 2F 6D 6F 64 75 6F 75 7B 2F 32 2E 85 19:09:37 hypertrm.exe IRP_MJ_READ
-
Thread
Anfänger - Embedded C Programmierung lernen - Welche Hardware -
pro Sekunde ausführen konnten. Verglichen damit ist ein Atmega168 schon ratten-schnell - selbst bei 32bit Operationen. Am Beispiel Intel habe ich gelernt, dass man mehr Mhz und cleverem Cache mehr anfangen kann, mit mehr Busbreite. Der Wechsel von 32bit auf 64bit hat im PC Bereich ungefähr gar nichts
http://www.peter-cockerell.net/aalp/html/frames.html Hosenmatz schrieb im Beitrag #4681959: > AVR oder PIC für den Anfang Es spricht gar nichts gegen 32-Bit ARM für den Anfang, aber wenn doch 8-Bit dann wohl eher ein Industrie-Standard 8051 Board mit professionellem J-Link Debugger z.B. http
-
Thread
AVR128DB - Clock Failure Detection
Danach alle .bat ausführen lassen. Zum Schluss noch die µC in die io.h eintragen. [c] /* begin new AVR128DBxx */ #elif defined (__AVR_AVR128DB28__) # include <avr/ioavr128db28.h> #elif defined (__AVR_AVR128DB32__) # include <avr/ioavr128db32.h> #elif defined (__AVR_AVR128DB48__) # include <avr/ioavr128db48.h> #elif defined (__AVR_AVR128DB64__) # include <avr/ioavr128db64.h> /* end new AVR128DBxx */ [/c] Wenn die µC irgendwann im avr-gcc schon eingebaut sind, ist das kopieren der specfiles nicht mehr notwendig. Darüber
-
Thread
Arduino - SPI über lange Leitung
Prozessor, dann brauchst Du keine Pegelwandler. Da Du ja mit PICs Erfahrungen hast, wäre ein kleiner PIC32MX170F256B mit 50 MHz und 128k Flash/64k RAM genau das richtige dafür. Dann brauchst Du zwischen Display, Touch, SD und Prozessor auch keine Pegelwandler, und über die kurze Strecke kannst Du den SPI
, dann brauchst Du keine Pegelwandler. Da Du ja mit PICs >> Erfahrungen hast, wäre ein kleiner PIC32MX170F256B mit 50 MHz und 128k >> Flash/64k RAM genau das richtige dafür. Dann brauchst Du zwischen >> Display, Touch, SD und Prozessor auch keine Pegelwandler, und über die >> kurze Strecke kannst
-
Thread
Microcontroller aussuchen
Ahnung, das ist nicht mein Fachgebiet. Aus dem Bauch heraus geraten würde ich vermutlich deutlich mehr 32 Bit Controller finden, als 8 Bit. Wobei STM32 und AVR wiederum nur einen kleinen Teil der gesamten 8/32 Bit Palette ausmachen. 16 und 64 Bit Controllern sind vermutlich besonders selten im Einsatz
hat eine viel größeren Einfluss auf meine Entwicklungsaufwände. Bei AVR und STM32 gefällt mir daher, dass die Peripherie der ganzen Serien ähnlich ist. Wenn man einen verstanden hat, kommt man schnell mit einem anderen Modell zurecht. Hier im Forum werden AVR und STM32
-
Thread
Wurzefunktion für uint32_t in C
; avr-gcc ABI ;; #include <stdint.h> ;; extern uint16_t sqrt32_avr (uint32_t); .global sqrt32_avr .text ;-------------------------------------------------------------------- ; R25:R24
e = sqrt32_avr(i); // <= Zeile 12 asm volatile("nop"); } return 0; }[/c] "avr-nm sqrt32.o": [code]00000001 a __zero_reg__ 00000000 T sqrt32_avr[/code] Ideen?
-
Thread
AVR-Net-IO und Grafik-lcd möglich?
Für Text allemal. Durch die Farben eröffnen sich doch ganz andere Möglichkeiten als bei einem 128*64. Peter Zinn schrieb im Beitrag #3913051: > ponny-prog... .. nimmt man wohl besser nicht mehr. usbasp-Programmer + winAVR + avrdude. AVR-Studio hat mich bislang noch nicht so überzeugt. Umständlicher
hallo gemeinde. komm jetzt nicht recht auf den Namen - ist aber von winstar 128x64. muss ich mal runter gehen in mein reich-da liegt ein AVR-ozilloskop von serasidis. des geht wunderbar. wie gesagt, das 16x2 war schon mal dran - hat auch funktioniert, uhrzeit und so. jetzt soll
-
Thread
Problemm mit Compiler?
Problem, weil sich Atmel entschieden hat 'Funktionen' als Makros zu definieren. Zumindest mein WinAvr ist mit Psc1_use_64_mega_pll_clock nicht glücklich. Ein Umarbeiten des Makros in psc_drv.h auf eine inline Funktion behebt das Problem allerdings ganz schnell [C] ... #define Psc1_use_io_clock() (PCNF1 &= ~(1<<PCLKSEL0) ) //! Start the PLL at 64MHz and connect it to PSC1 inline void Psc1_use_64_mega_pll_clock() { Start_pll_64_mega(); Wait_pll_ready(); Psc1_use_pll_clock(); } //! Start the PLL at 32MHz and connect it to
-
Thread
Suche Eprommer 2732 27C32 für kleines Geld
tolles wie einen SD Kartenleser oder ähnliches fürn C64, dann ists ganz einfach. Hab erst vor kurzem ein 32kB EProm für ein KfZ-Steuergerät kopiert und die alte Kiste dazu endlich mal wieder in Betrieb genommen, läuft einwandfrei!
Da hast Du Dir aber zuvor einen AVR-Brenner bauen müssen oder eben den AVR von jemanden brennen lassen müssen...
-
Thread
NXP verschenkt ARM-Chips
Von Micron gibt es den kleinsten MT48LC2M32B2P-7 64Mb 2Mb x32 3.3V TSOP 86-pin 7ns 0C to +70C @Tobias: Ich arbeite professionell, und die 720 hatte mich gut 2000 Euro gekostet, nur würde ich NIEMANDEN raten, von Ayoue was zu kaufen
TME? Habe nur "TME electronic GmbH" gefunden, aber da ist nichts auf der Webseite. > MT48LC4M32B2 SDRAM 3V3 4Mx32 167MHz TSOP86 Also den oder auf die 64Mbit variante fürde ich sowieso nur 25 Stück weise direkt einkaufen... Was kostet der bei TME? Bei Micron über DigiKey 142,69 US$ für 25 Stück
-
Thread
AVR LED Dimmen mit Logarithmus
Ich verwende für meine LED folgende Tabelle mit 64 8bit-PWM-Werten: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 22, 25, 28, 30, 33, 36, 39, 42, 46, 49, 53, 56, 60, 64, 68, 72, 77, 81, 86, 90, 95, 100, 105, 110, 116, 121, 127, 132
exaket 23 clock-cycles (ohne aufruf-overhead). In C dauert alleine die Sicherung der Register etwa 64 cycles. Mein PWM hat eine Frequenz von etwa 64Hz (2^23Hz = 8MHz / (2^12 * 32=2^5) => 2^6=64Hz). Dabei dauert der kürzeste PWM impuls 32 cyles, für Maximale Auflösung von 16bit PWM liesse sich das auf
-
Thread
Delphi nicht zukunftsicher?
die 32-Bit-Ausführung, und für 64-Bit-Programme eine 64-Bit-Ausführung.
Rufus Τ. Firefly schrieb im Beitrag #2270938: > Hängt vom verwendeten Windows ab. Unter 32-Bit-Windows gibt es nur die > 32-Bit-Ausführung, unter 64-Bit-Windows gibt es für 32-Bit-Programme die > 32-Bit-Ausführung, und für 64-Bit-Programme eine 64-Bit-Ausführung. Genau das war die Frage
-
Thread
Basic Interpreter für uC ?
UART Interface und einem einfachen Terminalprogramm, was keine Cursorsteuerung braucht. Hatte der C64 auch nicht im Editor. Glaube da musste man jede Zeile neu schreiben, wenn man sie ändern wollte? Ganz sicher bin ich mit aber nicht mehr, zu lange her. Zielsystem STM32F103, dafür habe ich alles, meinetwegen
http://geoffg.net/maximite.html Es existieren angeblich auch von dritter Seite Ports auf STM32, Der Source Code ist auf Anfrage erhältlich und in C geschrieben. Mit diesem Grundgerüst könnte man etwas hinsichtlich C64 Befehlssatz machen.
-
Thread
EEPROM avr-libc Read/Write-Funktionen Warnung
eine Bildungslücke) mit den eeprom_read_dword(..) bzw. eeprom_write_dword(..). Entwicklungsumgebung: AVR Studio 7.0 mit ATxmega32A4u. Hier mein Programmcode (der Sinn der Funktion ist nicht weiter wichtig): [c] uint8_t FLASH_LoadAddressPointer(uint32_t *pReturnAddress, uint32_t uC_FlashReadFrom)
der Wert der Variablen dem Zeiger zugewiesen werden: [c] uint8_t FLASH_LoadAddressPointer(uint32_t *pReturnAddress, uint32_t uC_FlashReadFrom) { uint32_t temp1=0, temp2=0; //Get actual EEPROM Read address //Erst den übergebenen Wert nach 16-Bit (uint16_t) casten, da pointer im AVR = 16
-
Thread
64 Punkte FFT auf guenstigem Mikrocontroller
Für LunaAVR gibt es eine FFT-Library (ATMega und ATXMega) für 64 bis 1024 Punkte. http://avr.myluna.de/doku.php?id=de:lib-fft
Bastler schrieb im Beitrag #4348757: > Für LunaAVR gibt es eine FFT-Library (ATMega und ATXMega) für 64 bis > 1024 Punkte. das ist aber zu 99.9% von elm-chan abgekupfert. Warum sollte das jetzt besser sein, abgesehen von der unportablen, exotischen
-
Thread
ATmega644 /64 SPI
". Nun dachte ich mir, das liegt sicherlich an dem neuen ATmega644 und hab deswegen auf den ATmega64 umgestellt. Ergebnist: Das gleiche. Seltsamerweise funktioniert der Code, wenn ich auf einen ATmega32 stelle. Hat irgendjemand eine Idee? Hier der Code: #include <avr/io.h> #include <avr/interrupt.h
Fehler gemacht haben. Nun zu Fehler beschreibung. Es ist wahr, dass der ATmega644 eher zum ATmega32 verwand ist. Der SPI Port ist beim 644 gleich dem vom 32er. Jetzt haben die für den Simulator anscheinend den 64er zum Vorbild genommen. Soll heißen /SS ist beim 644er auf PB4, beim 64er ist es PB0.
-
Thread
Nachbaubares Funkmodul auf Basis des RFM12
? Das Funkboard ist eine kleine Platine und setzt sich im Wesentlichen aus dem RFM12, einem ATmega32 und etwas Peripherie zusammen. Der AVR übernimmt die komplette Ansteuerung und verwandelt die Schaltung in eine Art Funkmodul-"Blackbox". Dieses kann man dann sehr einfach in den verschiedensten Projekten
avr-libc 1.6.2 avr-gcc ist noch der letzte 3er
-
Thread
"Riesen Array" sortieren, RAM knapp.
sortierten Array die Zeilen zusammensetzen. Noch was anderes, was mir gerade kam... Das Board hat 32k RAM drauf. 64k sind beim 8051 möglich. Ich habe noch einen 32k RAM Chip hier. A15 vom Controller ist frei. Kann ich den zweiten RAM Chip huckepack auf den ersten löten und A15 dann für den Chip-Enable
gleichzeitig gelesen, wenn A15 als Chip Enable dient?. Wie wird sowas angeschlossen, wenn man statt einen 64k RAM zwei 32er hat?
-
Thread
Microcontroller mit Python
festes Muster die Kernaufgabe einer einfachen EEPROM-Steuerung: 1 4060 mit Quarz und ein EEPROM, z.B. 64k*8 Damit man mit einem Uhrenquarz z.B. im ms-Takt einen Kanal bis zu 64s steuern, 2 bis zu 32s … 8 bis zu einer halben Sekunde. Für jemanden ohne µController ein guter erster eigener Schritt
Zellen Taktversorgung: Externer Quarz Oszillator 4 MHz über 220Ω mit XTAL1 verbunden Fuse für 32kHz Quarz einstellen: [pre] stefan@stefanpc:/opt/AVR8-Burn-O-Mat$ sudo avrdude -c avrispmkii -P usb -B 200 -p attiny85 -U lfuse:w:0x66:m avrdude: AVR device initialized and ready to accept instructions
-
Thread
Ultra Low Power MCU gesucht
emf32 stm32l1 etc.
normalerweise so: Sensor platform mit low power Trx - low power trx Gateway Wifi Sensor platform: ATmega64RFR2 oder ATxmega32E5 + AT86RF231 Ethernet/Wireless Gateway: ATmega256RFR2 Die Kommunikation zwischen Sensor und Gateway machst Du entweder proprietär oder nutzt den Lightweight Mesh stack von Atmel
-
Thread
OLED Display ssd1306 mit SPI arbeitet nicht
Hallo, ich versuche gerade das OLED Display 128x64 (SSD106 Controller) über SPI mit einem ATMega88 in Betrieb zu nehmen. Dafür verwende ich die Library u8glib: https://code.google.com/p/u8glib/wiki/avr mit dem Beispielcode: [c] #include "u8g.h
sw_spi >> >> Woher kommt diese Angabe? Du hast weder einen ST7565 Displaycontroller >> noch ein 132x32 Display. >> >> MfG Spess Ich habe die Funktion nun angepasst und mit SW-SPI und HW-SPI getestet. SW-SPI: [c] u8g_InitSPI(&u8g, &u8g_dev_ssd1306_128x64_sw_spi, PN(1, 5), PN(1, 3), PN(1, 2),
-
Thread
BinaryFile to IntelHex für win7 64bit
Hä? Ich dachte, 32-Bit Code ist aufwärtskompatibel, d.h. 32-Bit Code ist auch auf 64-Bit ausführbar. Oder hab ich was falsch verstanden?
Komisch ich benutze das Keil Tool unter Win 7 x64 ohne Probleme. Klar ist nicht nativ x64 aber im WoW läuft doch jedes Win32 Programm auch unter x64. Wo genau liegt denn das Problem?
-
Thread
Schneller Mikrocontroller mit Ethernet gesucht
fällt mir kein MC ein, der das alles erfüllt (soweit ich die > Anforderungen verstanden habe). AT32UC3C bis zu 512 kiB Flash, 64 kiB SRAM, USB Device und Host, 10/100 Ethernet MAC, 16 Kanal 12-Bit ADC (max 1.5 MS/s), 2x 12-Bit DAC eCOG1X bis zu 512 kiB Flash, 24-kiB SRAM, USB 2.0 Device Host (
STM32F107: 72MHz CPU, 256K ROM, 64K RAM. 2x 12-Bit ADCs je 1MS/s, insgesamt 16 Kanäle. 2x 12-Bit DACs. Ethernet MAC. USB Device/Host/OTG. STM32F207: 120MHz CPU, 1M ROM, 128K RAM. 3x 12-Bit ADCs
-
Thread
ENC28J60 (Mikro-)Web-Server die Nächste
sich leicht portieren lässt, wie man hier im Falle des AVR-NET IOs sehen kann. Dass das Konzept so gut aufgeht freut mich sehr, muss ich zugeben :D Das AVR NET IO hat meines Wissens nach einen Mega32 (und geht bis maximal Mega644, was 64kiB Flash wären).
Ich kenne mich mit PICs nicht aus. Aber PIC32 klingt nach nem 32 Bitter, wohingegen der hier verwendete AVR nur ein kleiner 8 Bitter ist und von der Rechenleistung her um einige Potenzen unter den 32 Bittern liegt. Ansonsten ist der Umfang von
-
Thread
Drehteller mit festen Winkeln
ein foto usw.. und das brauche ich am besten wählbar für 8, 32 und 64 winkel die möglichst exakt sind. Da kam mir bisher nur die idee das mit photodioden und LEDs zu machen (dort könnte man die LEDs gruppieren und je nach winkelanzahl abschalten/ zuschalten)
externen Auslöser haben ziemlich einfach. Einmal auf "Start" gedrückt und kurze Zeit später hat man 8, 32 oder 64 Bilder auf der Speicherkarte ohne groß was zu tun und dazu wohl recht reproduzierbar.
-
Thread
Taktfrequenz ATXmeaga128A1
irgendwie werde ich daraus nicht ganz schlau. Mit der folgenden Oszi_Init möchte den ClkPer4 = 64MHz, ClkPer2 = 64MHz und ClkCPU = ClkPer = 32Mhz einstellen. [c] //Oscillator auf 32Mhz einstellen PIN1 = OSC_RC32MEN wird gesetzt OSC.CTRL = 0x02; // Wenn Oscillator stabil wird das Flag
OSC_PLLEN_bm; while (!(OSC.STATUS & OSC_PLLRDY_bm)); // CLK-Prescaler A/1 B/2 C/2 -> 128MHz -> 64MHz -> 32MHz CCP_Write(&CLK.PSCTRL, CLK_PSADIV_1_gc | CLK_PSBCDIV_2_2_gc); // PLL nun als Systemclock auswählen CCP_Write(&CLK.CTRL, CLK_SCLKSEL_PLL_gc); // 2MHz und 32MHz RC abschalten
-
Thread
Umstieg von ATmega16 auf ATmega32
Im include-Verzeichnis von avr sind neben dem iom32.h noch viele weitere für den 32er, zb. iom32c1.h oder iom32hvb.h . Gibt es da einen Unterschied zwischen verschiedenen Controllern, oder wofür existieren so viele verschiedene?
TIMSK_TOIE2_FLAG 0x40 #define TIMSK_OCIE2_FLAG 0x80 [/c] Laut http://www.gaw.ru/pdf/Atmel/app/avr/AVR089.pdf sind die Timer-Register im 32er und 16er aber identisch.
-
Thread
atngw100- buildroot stirbt beim verpacken ab..
config.status: executing depfiles commands config.status: executing default commands touch /root/build/build_avr32/genext2fs-1.4.1/.configured /usr/bin/make -j1 CFLAGS="-Wall -O2 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE \ -D_FILE_OFFSET_BITS=64" -C /root/build/build_avr32/genext2fs-1.4.1 make[1]: Entering
-Wall -O2 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -o genext2fs genext2fs.o make[2]: Leaving directory `/root/build/build_avr32/genext2fs-1.4.1' make[1]: Leaving directory `/root/build/build_avr32/genext2fs-1.4.1
-
Thread
suche Terminalprogram welches Binär leserlich darstellt
cannot open shared object file: No such file or directory xxxx@xxxx:~$ locate libgtk-x11 /usr/lib/x86_64-linux-gnu/libgtk-x11-2.0.so.0 /usr/lib/x86_64-linux-gnu/libgtk-x11-2.0.so.0.2400.32 xxxx@xxxx:~$ [/code]
Kaj schrieb im Beitrag #5739113: > Könnte daranliegen, das hterm eine 32 Bit Anwendung ist und mit 64 Bit > Libs vielleicht nicht viel anfangen kann. kann man mit 32-bit auf einem 64-bit-System leider nicht installieren
-
Thread
AVR128DA per USB flashen?
das debuggen, sondern um ohne > Programmiergerät das Modul flashen zu können, so wie es mit dem ESP32 > möglich ist. Nimm doch den ESP32, der kann eh viel mehr. Wobei die älteren ESP32, also nicht ESP32-S2/3, auch keinen USB haben und nur über einen USB-Seriell-Adapter (oder JTAG) geflasht werden
Programmierer schrieb im Beitrag #7191178: > Nimm doch den ESP32, der kann eh viel mehr. Und er verbraucht auch viel mehr. Dazu kommt, daß er weniger I/O-Leitungen hat; den AVR128DA gibt es im 64-Pin-Package mit 55 I/O-Pins. Der ESP32 hat nur 34 I/O-Leitungen.
-
Thread
Attiny2313 Timer16 Bit, Normal Mode, unsauber
Teil von: SLdt 210308 (Disclaimer: None. Sue me.) ATtiny2313: DDS 440 Hz Sinus */ #include <avr/io.h> #include <avr/interrupt.h> #include <avr/pgmspace.h> #define F_CPU 10000000 #define ICR 256 #define PWM F_CPU/ICR #define A4 440 #define A4_Phasendelta 2684 // (A4/PWM*65536) #define
69, 68, 68, 67, 67, 67, 67, 66, 66, 66, 65, 65, 65, 65, 65, 65, 65, 65, 64, 64, 63, 63, 64, 64, 65, 65, 65, 65, 65, 65, 65, 64, 64, 64, 64, 64, 64, 64, 64, 65, 65, 65, 66, 67, 68, 69, 71, 72, 73 }; [/c]
-
Thread
uint64 und sprintf
> Was bedeutet PRIu64? ISO-C99 Formatspezifikation für exact-width integer types. RTFM: http://www.nongnu.org/avr-libc/user-manual/group__avr__inttypes.html (URL wird nicht anklickbar sein in Folge eines Forum-Bugs
eigentlich klar und deutlich, dass es derzeit *keine* Implementierung eines printf-Formats in der avr-libc gibt, die es gestatten würde, einen uint64_t in eine Zeichenfolge umzusetzen. Das ist ein `nice to have' feature, ich werde das sicher bei Gelegenheit mal angehen, aber wie sagen die Amis so
-
Thread
uart optokoppler LTV 817 klappt nicht.
> man sollte vielleicht Widerstandssortimente im 64 Pin TQFP-Gehäuse > anbieten. http://www.dpma.de/ möchte von dir hören :-)
ES KEINE ANDERE LÖSUNG >gibt!! DU musst es ja wissen ;-) Mal so als Überschlag. Wenn man 64V mit einem 12 Bit AD-Wandler misst, macht das 15,6mV Auflösung. Für ne Akkuüberwachung mehr als ausreichend. Also kleiner AVR + einfacher (=billiger) 12 Bit AD-Wandler + MUX, fertig. Und selbst 16 Bit