-
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
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
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
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
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
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
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
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
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
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
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
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
"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
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
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
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
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
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
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
-
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
LM75 am Atmega32
whole_number_degrees; Mein Code: [c] #define F_CPU 16000000UL //Takt 1,6MHz #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #include <util/twi.h> /* Programm Libs */ #include "defines.h" #define LM75_ADR 0x4F // 7-bit, cf datasheet #define F_SCL 100000
Also dat2 ergibt Wert 32,64 usw. Dh, ich muss den Wert einfach durch 32 Dividieren, dann hab ich die Kommastelle, korrekt?
-
Thread
Externes RAM am atmega128
Muss es denn UNBEDINGT ein AVR sein? Da lohnt sich schon fast der Umstieg auf was vernünftigeres, wie etwa stm32...
Adreßleitungen) und Port G (ALE, RD(OE), WR) und ein Latch, >> zB 74HC574. Rest steht im Datenblatt des AVR. > > Untere 8 bit und obere 8 bit gibts ja auch nicht, da ich nur 13 > adressleitungen habe. Der AVR hat 16 Adreßbits für 64k, Du brauchst aber nur die unteren 13. Den Rest läßt Du offen.
-
Thread
Frequenzanzeige Spektrumanalyzer
25,6uSek = 25 Zählschritte 10KHz Auflösung = 6,4mSek/ 25,6uSek = 250 Zählschritte 1KHz Auflösung = 64mSek/ 25,6uSek = 2500 Zählschritte 100 Hz Auflösung = 640mSek/25,6uSek = 25000 Zählschritte Die benötigte Stabilität wäre dann 640mS : 2*10exp7 = 3,2*10exp-8 Sek = 32nSek Es werden dann direkt
Gut, wenn Du es mit passender Hardware hinbekommst, dann mache es. Ich hätte einen STM32F411 (Nucleo-Board) genommen, der mehrere Kanäle gleichzeitig und hinreichend schnell messen kann. Eine Alternative wären zwei AVR, die jeweils eine Frequenz messen und einer von beiden die Verrechnung
-
Thread
AVR Studio 4 mit Win7 64
jemand bestätigen, dass das avr studio 4 unter win7 64 bit funktioniert? ich benutze avr studio 4 weil in der version 5 der attiny85 nicht unterstützt wird. gibt es auch dafür eine abhilfe? herzlichsten dank für eure hilfe :
your 8– > and 32-bit AVR projects into one, easy-to-use environment. Ist das unwahr? (Frage weil ich bald einen attiny85 bekomme und den eigentlich damit programmieren wollte ...)
-
Thread
AtMega64 on board programmieren
Warum redest Du einmal vom Mega64 und das andere mal vom Mega644? Was denn nun? Außerdem war nie die Rede davon, das Du mit BASCOM programmieren willst. Im übrigen sollte das von Bascom genau so funtionieren, wie mit dem Mega16,32
hier noch mal der genaue link, falls jemand anders etwas ähnliches vorhat: http://www.rowalt.de/mc/avr/progd.htm @Klaus R.: (klaus2) äh, ist das überhaupt erlaubt, was du da schreibst (wg. jugendschutz)? @krulli: macht es wirklich einen Unterschied, ob Mega64 oder Mega644? Letzter paßt mir
-
Thread
avr-gcc 6.3 für Windows
Hier ist ein avr-gcc-6.3.1 dabei, generiert unter Linux für MinGW32: https://sourceforge.net/projects/mobilechessboar/files/avr-gcc%20snapshots%20(Win32)/ Binutils von git master zu dieser Zeit und avr-libc entsprechend
absolutem Pfad oder indem das bin-Verzeichnis zu PATH hinzugefügt wird. configure ist: [pre] $ avr-gcc -v ... Configured with: ../../gcc.gnu.org/gcc-6-branch/configure --target=avr --prefix=/local/gnu/install/gcc-6-avr-mingw32 --host=i386-mingw32 --build=x86_64-linux-gnu --enable-languages=c,c+
-
Thread
Mehrmonatsprojekt - Elin Stromgenerator 8kW 231V 50Hz@1500U zum Leben erwecken
Generator mit Stator-Erregung. Grobe Schätzung der Erregerleistung: 100-500 Watt, bei 8 Ohm wären das 32V 4A 128W 40V 5A 200W 48V 6A 288W 56V 7A 392W 64V 8A 512W
einphasige Generator funktioniert. 230V 2,2kVA <<-- diese ist die Ausgangsspannung/Leistung Err. 32V/1,5A <<-- diese Angabe gibt die Erregerspannung wieder dort ist die Erregerleistung 48W bei 2200VA, also 4,4%. Bei 8kVA sind 4% 320W. Zeno: AVR bedeutet hier Automatic Voltage Regulator
-
Thread
unbekannte Quarz Frequenz
Zwischenlektion die Funktionsweise von FixedPoint: Bit Wertigkeit 15 32768 14 16384 .... 7 128 6 64 5 32 4 16 3 8 2 4 1 2 0 1 Die Wertigkeit wird also immer um 2 geteilt. Warum nicht einfach ein Byte "dranhängen" und weitermachen? -1 1/2=0,5 -2 1/4 -3 1/8 -4 1/16 -5 1/32 -6 1/64 -7 1/128 -8 1/256=0,00390625 Wenn Du diese 16+8=24 Bits als zusammenhängende 24-Bit-Zahl siehst und damit rechnest, hast Du sozusagen um 256 skaliert. So, und nun zurück zum
-
Thread
Syntax-Highlighting Test
[C]int main() { return 64; }[/C][C] int main() { return 64; }[/C]
[C] int main() { return 64; } [/C] bla bla [C] int main() { return 64; } [/C]
-
Thread
Library KS0108
welche Bibliothek > du umbauen willst. > Welchen Compiler, welchen µC? Ich benutze einen Atmega32 / AVR - GCC / Bibliothek habe ich mal als .ZIP angehangen
Max H. schrieb im Beitrag #3492342: > Welches Programmiergerät hast du? AVR ISP MKII