-
Thread
Flash-Speichergröße bestimmen
Was? schrieb im Beitrag #3748647: > Zur Speicherung der fast 5 milliarden Ticks benötigst Du eine 32 Bit > integer Variable. Äh, uint32_t geht nur bis 4.294.967.295. Da liegt er drüber, man müsste also ein uint64_t mit 64 Bits nehmen. Das kennen gängige C Compiler aber auch. Die eigentliche Frage
läuft auch nichts über. Dann schreibe ich den 32- oder 64-bit Wert ins EEPROM. Wo ist das Problem um zu brüllen? Schreibe ich 8 verschiedene 64bit Werte doppelt ins EEPROM, sind 8x8x2 byte, sind 1024kbit. Jede Zelle wird dabei 500k*5/8 =600k mal
-
Thread
"beat" erkennung mit Atmega1284
noch folgende Zeilen anpasst, sollte es auch für den Mega1284 hinhauen. fftest.c[c]#if defined (__AVR_ATmega8__) ADCSRA = _BV(ADEN)|_BV(ADSC)|_BV(ADFR)|_BV(ADIF)|_BV(ADPS2)|_BV(ADPS1); #elif defined (__AVR_ATmega32__) || defined (__AVR_ATmega644__) || defined (__AVR_ATmega1284__) || defined (__AVR_ATmega1284P__) ADCSRA = _BV(ADEN)|_BV(ADSC)|_BV(ADATE)|_BV(ADIF)|_BV(ADPS2)|_BV(ADPS1); #endif [/c] mydefs.h[c]#if defined (__AVR_ATmega644__) || defined (__AVR_ATmega168__) || defined (__AVR_ATmega1284
-
Thread
2x Sram - geht das so!?
Hallo ich habe vor, 2x32k sram zusammenzufassen (um 64k zu erreichen) ich habe mir überlegt, die adressleitungen zusammenzulegen, und die 16te adressleitung an den /CS eingang zu legen, bei einem SRAM allerdings invertiert.
32kB SRAMs haben meist nur einen CE\, da das 28Pin Gehäuse keinen freien Pin hat. Bei 8kB (28Pin), 64kB und 128kB (32Pin) gibt es dagegen freie Pins, daher auch mehrere CE Anschlüsse.
-
Thread
AVR FTDI ISP-Prog (AVR-8 Programmersoftware für den FT232R)
http://www.r-tron.de/uatmel.htm Der Softwaredownload erfolgt unter: http://www.r-tron.de/download/AVR_FTDI_ISP-Prog.zip Die folgenden Definitionsdatein (.dev) für die AVR-8 sind nun enthalten: ATTini13(A) ATTini2313(A) ATMega8(A) ATMega8515 ATMega32(A) ATMega1284(P) ATMega2560(L) ATMega2561
Ich habe Windows 7 64bit AVR Studio5.1 + Framework4.0 Achja wenn ich danach das AVR Studio öffne ist es auch nicht eingepluggt Hast du eine Idee woran es liegen könnte?
-
Thread
Mini-Computer mit BASIC
Oder mega128 mit externem ram. da kann man 64kb ranhängen, das dürfte potent genug sein, oder?
Hier ist ein ähnlicher Kollege: http://www.kmit.sk/~peto/AVR/smallpmd/index.php MfG Paul
-
Thread
MPLAP Snap halb im Nirvana
importiert. Genau das kann MPLAB-X allerdings offenbar nicht. Da ich seit diesem Versuch mehr mit STM32 und ESP Modulen zu tun hatte und für AVR eh keinen Debugger habe, ist das MPLAB-X für mich bisher weitgehend uninteressant geblieben. Ich finde aber gut, dass die neue IDE auch für Linux angeboten wird
schicke mir ganze > ASCII-Textpassagen in Echtzeit, nicht nur bei den AVRs, sondern auch bei > den STM32-µControllern. Ja das mache ich auch sehr gern. Bei den STM32 nehme ich aber lieber SWO als die Uart. Da hat jeder so seine Vorlieben. Bei den Avr nehme ich auch gern die Softuart mit delay von Peter
-
Thread
Windows 8 potthäßlich
war in der Übergangsphase von 32 auf 64 Bit in der Lage, mit einem 32-Bit-Kernel (und folglich auch 32-Bit-Treibern) 64-Bit-Prozesse laufen zu lassen, für den Anwender vollkommen transparent, und ohne irgendwelche mehrfach vorhandenen
für die nur 32Bit-Treiber existieren -> lange Gesichter. Daher Kommando zurück, auf Firmenrechner installiere ich grundsätzlich wieder die 32-Bit-Version, auf privaten nur nach Wunsch 64-Bit. 2. die Softwareproblematik
-
Thread
Bekomme das mit dem ADC nicht hin :(
vergessen? [C] #include <avr/io.h> #include <inttypes.h> uint16_t readADC(uint8_t channel) { uint8_t i; uint16_t result = 0; // Den ADC aktivieren und Teilungsfaktor auf 64 stellen ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1
es möglich das die ADC Ports defekt sind? Oder muss ich bei den Fusebits etwas ändern? #include <avr/io.h> #include <inttypes.h> #include <util/delay.h> uint16_t readADC(uint8_t channel) { uint8_t i; uint16_t result = 0; // Den ADC aktivieren und Teilungsfaktor auf 64 stellen ADCSRA =
-
Thread
C: stdint und Formatkennzeichner
long unsigned int zwar verschiedene Datentypen sind, aber dieselbe interne Darstellung (64 Bit) haben. Mit "%lu" statt "llu" würde die Warnung verschwinden, dafür würde das Programm auf einem 32-Bit-Windows-PC nicht mehr funktionieren. Mit "%"PRIu64 bzw. "%"SCNu64 geht man all diesen
funktioniert ja. > > Neben der mangelnden Portabilität ist die Verwendung von "%llu" für > uint64_t auch unsauber. Das meint auch GCC (auf einem 64-Bit-Linux-PC): > Na toll. Ich präsentiere die Vorgehensweise anhand eines alten WinAVR (wie ich auch schrieb) und das geht nicht auf mit nem GCC
-
Thread
Effizientes Bitcount für 8, 16 u. 64 Bit?
- (((x)>>2)&0x3333) \ - (((x)>>3)&0x1111)) 64 Bit: (angenommen, es gibt einen 64-bit-Typen, ansonsten einfach 2x die beiden 32Bit-Hälften auswerten und zusammenzählen) #define BITCOUNT(x) (((BX_(x)+(BX_(x)>>4)) & 0x0F0F0F0F0F0F0F0F) % 255
soll wirklich die bits einer variable zählen? ich mach das so: bits = 0; i = 8; // 8, 16, 32, 64, ... while (i--) { if ( (x>>i)&(0x1) ) bits++; }
-
Thread
PDI + AVR Dragon
. Beim xmega32A4U ist bei den Tools auch der AVR-Dragon aufgeführt. Wenn ich beim AVR-Studio den AVR-Dragon und den xmega32A4U auswähle, sagt mir das Programmer-Fenster, das er über PDI verbunden werden will (logisch
von Atmel): >Yes, the Dragon can debug and program the ATxmega64A4U using >the PDI interface. >For the PDI pinout you can look in the appnote "AVR042 AVR hardware >considerations", it includes the pinout for the standard >PDI connector [1] in chapter 4.3. This
-
Thread
AVR32 interesse - wo kaufen?
Auf welchem Stand ist denn das AVR Studio 32 mittlerweile?
Vor ein paar Tagen sind gerade AVR32 Studio und Toolchain v2.0 herausgekommen! Kann man sich alles bei atmel.com ziehen. AVR32 Studio 2.0 unterstützt jetzt auch den neuen In-System Debugger AVR ONE!, der demnächst verfügbar sein sollte
-
Thread
Zeitmessung mit Timer2 asynchron
paar Wochen) ist immer schwer zu verstehen. Ich erkläre es gerne mal: Ich betreibe ein LCD das mit 32Hz umschaltet, deshalb nehme ich den Timer2 mit 64Hz. Der ist fest, kann ich nicht ändern. Ausserdem zählt er meine Uhr weiter. Die 64Hz sind aber nur die Überläufe, die Schrittweite ist 1/4096Hz also
Nächste Umdrehung: TCNT2 = 55, revolution = 10. Zwischen den Reed Schaltpunkten habe ich also 10*64 +55-20 Timerticks gehabt, das sind 675 Ticks zu 244µs. Auflösung ist 244µs, reicht mir vollkommen aus. 64 weil jede revolution schon 64 Ticks hatte, 55 weil ich in diesem Timerzyklus bis 55 gekommen
-
Thread
-
Thread
Windows7 / Parallel-Port Problem
Nehm doch z.B. http://matrixstorm.com/avr/tinyusbboard/ als avrBridge ( http://matrixstorm.com/avr/tinyusbboard/#firmwares bzw. http://ka010.wordpress.com/avrbridge/) beflasht. Dann kannst du was auch immer bequem ueber USB ansteuern
Bei mir läuft der Parallelport auch unter Win7 x64 ohne Probleme. inpoutx64 installiert und gut is...
-
Thread
welche FP-LIB für hochaufgelöstes Rechnen beim 16 BIT uc
so einige. [c] float f = 1.0; double d = 1.0; long double ld = 1.0; [/c] gcc (Linux) erzeugt 32/64/128bit Fließkomma. arm-none-eabi-gcc erzeugt 32/64/64bit Fließkomma. avr-gcc macht vergnüglich aus allen dreien einen simplen float(32bit).
fragte nach long double, da double nicht > genügend genau! Andi schrieb im Beitrag #7701494: > 64 Bit Float 64bit float ist aber "double". 32bit ist (single-precision) "float". "long double" wäre 128bit.
-
Thread
neuer Transistortester GM328 aus China
+ .noinit) EEPROM: 15 bytes (1.5% Full) (.eeprom) $ make -version GNU Make 3.81 $ avr-gcc --version avr-gcc.exe (AVR_8_bit_GNU_Toolchain_3.4.4_1229) 4.8.1 [/c] Avr-gcc is from the toolchain from Atmel. Make from mingw/msys. Martin
Hi I have solved the problem The avr-toolchain-installer-3.4.2.1573-win32.win32.x86.exe is working well and usable by command line This is a useful link too: http://tuxgraphics.org/electronics/201205/windows-avr-microcontroller-programming.shtml
-
Thread
STM32 Programmierschnittstelle / Grundbeschaltung
Auf dem Board für einen Controller im LQFP64 Format, die Stm32F4 gibts nur ab 100pins aufwärts oder?
S64DIL-Modul @ Markus Müller: Nun, wenn Anfragen sind, werde ich mich im Einzelfall darum kümmern. Auch eine fertig bestückte und geprüfte Ausführung wäre denkbar! Bisher verkauft sich von den STM32
-
Thread
Timer will nicht wie ich will
Datenblatt alt oder du hast dich vertan. >TCCR0 = (1<<WGM01) | (1<<CS01) | (1<<CS00); /*CTC, prescaler 64*/ ist ein Prescaler von 32. Aber das ist noch nicht die Ursache. Michael
Datenblatt alt oder du hast dich vertan. >>>TCCR0 = (1<<WGM01) | (1<<CS01) | (1<<CS00); /*CTC, prescaler 64*/ >ist ein Prescaler von 32. Aber das ist noch nicht die Ursache. Also auf dem Datenblatt des Atmega32 (S.82) gibt es keinen Faktor 32.
-
Thread
Datentypen wie "uint8_t"
Darstellung für Integers betrachten): . char >= 8 bits . int >= 16 bits . short >= 16 bits . long >= 32 bits . long long >= 64 bits Sieht auf den ersten Blick einleuchtend aus, hat aber auch ein paar Pferdefüße, die man nicht auf den ersten Blick sieht. Insbesondere ist es halt durch den Standard
schrieb im Beitrag #365924: > . char >= 8 bits > . int >= 16 bits > . short >= 16 bits > . long >= 32 bits > . long long >= 64 bits Dazu bleibt anzumerken, dass das mit hoher Wahrscheinlichkeit so ist und eine gute Annahme für die reale Welt ist, es aber nicht so verbindlich *standardisiert* ist.
-
Thread
Probleme mit 16Bit Timer1
/ 64 = 125kHz. Wie kann das sein?
etwa 25kHz... Woher nimmst du die 50kHz, die du da misst??? Wenn die stimmen, dann läuft dein AVR nicht mit 8MHz oder dein Vorteiler nicht mit 64... Falls dein AVR mit internem RC-Oszillator mit 8MHz läuft, dann erreichst du diese 8MHz nur, wenn du den AVR von Hand (also per deinem Programm)
-
Thread
STM32 Programm unerwartet groß
Mein erstes STM32 Programm läuft (Hurra!) allerdings ist es unerwartet groß. Und zwar habe ich in SW4STM32 ein neues Projekt mit der StdPeriph Library erstellt. Zielplattform ist das Nucleo-64 Board mit STM32F103RB
keine Libs nutzt werden die Programme sogar kleiner. Ich habe eine Drucker-Firmware auf den STM32F411 portiert. Die Größe ist um Faktor 2 (AVR->STM) kleiner bei mir.
-
Thread
AVR "Fernprogrammieren"
halte ich für zu gefährlich.. wenn da einer dein signal überpiepst ists aus mit dem relais... ein 32k ode 64k eeprom kostet mehr oder weniger nix.. dein "loader"-code wird schön klein und ganz nebenbei sollte damit das problem mit der datenübertragung auch weg sein... 73
Wahrscheinlichkeit reduzieren. Dazu einfach zb. 16 Bytes Zufall in den Code integrieren und als Prüfsumme mit CRC32 oder CRC64 arbeiten. Ich meine das die Stabilität diese Updateprozesses innerhalb einer CPU weit höher ist als mit 2 CPUs. Die Softwareanfälligkeit steigt meiner Erfahrung nach mit der Anzahl der
-
Thread
Suche nach gutem Mikrocontroller
Preis pro Stück ist Egal :) Wir produzieren nur in Kleinserie daher ist das verlöten schon teurer. 2. 32-Bit Arm 3. 40+ Mhz 4. 256+ KB Flash 5. In unterschiedlichen Größen verfügbar. 32, 64, 100 Pin 6. SMD per Hand lötbar. Also kein BGA 7. Eclipse basierte IDE (wenn möglich) ohne Einschränkungen
USB noch Spannungsregler brauchst, bleibt ja nur noch der nackte Mikrocontroller übrig (sowohl bei AVR als auch bei STM32). Damit erübrigt sich die Frage nach dem Modul oder dem Nachbauen.
-
Thread
Raspi Pi Pico schnell genug um 4Mhz Z80 zu sniffen?
, kannst also in einem Z80-Cycle 32 > Instruktionen ausführen statt nur 16. > > Da sollte genug Power sein, um ohne das WAIT-Geraffel auszukommen. Also > ich jedenfalls könnte es damit umsetzen. Habe jetzt mal nach AVR128DB64
in DIL. > Aber was meinst Du mit doppeltem Takt? Laut Datenblatt hat der > AVR128DB64 eine max clock von 24Mhz, wie alle AVR128DBs Offiziell ja. Tatsächlich laufen sie aber auch mit 32MHz, dann aber nicht über den kompletten spezifizierten Bereich der Umgebungstemperatur. Sprich
-
Thread
Atxmega Timer Compare
Dienen soll das ganze, um bei 2 Schrittmotoren die Drehzahl in 1-250 Upm vorzugeben. #include <avr/io.h> #include <util/delay.h> #include <avr/interrupt.h> #include "clksys_driver.h" static uint32_t Periode_M1; static uint32_t Periode_M2; volatile uint32_t Periode_Nachlade_M1; volatile uint32
Hi, so sieht es momentan aus: [c] #include <avr/io.h> #include <util/delay.h> #include <avr/interrupt.h> #include "clksys_driver.h" void Setze_Geschwindigkeit_M1(int16_t rpm) { uint16_t Timerwert=0; Timerwert=(uint16_t)((F_CPU/(2*64*
-
Thread
AVR128DA28 Temperatursensor
direkter Programmierung. Ist im Grunde nichts weiter wie die App Notes zusammengefügt. [c] /* AVR128DB64 'onChip ADC temperatur measuring with 32kHz onchip RTC Event Trigger" */ Stream &cout {Serial2}; void setup() { Serial2.swap(1); // PF4 TXD2 / PF5 RXD2 Serial2.begin
flag cout.println(ADC0.CTRLA, BIN); } void initRTC (void) { RTC.CLKSEL = RTC_CLKSEL_INT32K_gc; // period duration 30,518µs RTC.PER = 64; // 64 set period = 1000ms / 15,625ms RTC.CTRLA = RTC_PRESCALER_DIV512_gc; // prescaler 512 -->> 30,518µs * 512 = 15,625ms
-
Thread
Schaut x jemand ob ich multiplexe oder brenne
würde ja auch gern mit einer einfachen Schaltung anfangen aber ich brauche diese.Und ob ich nun den AVR mit 2 LED´s verbrate oder 64(zumal ich ja langsam steigern würde) ist doch gleich. Abgeändert habe ich jetzt alles bis auf die Adressleitung vom Multiplexer, brauch ich die unbedingt ich dachte da
Druck die dritten sollen Minuten zählen und die letzten zwei sollen den CO2 Gehalt darstellen.Die 64er Ledzeile sind 2x32 einmal Volt und einmal Ampere. Soll also ein Messgerät werden.Die Anzeige muss micht sehr hell sein da sie im dunkel betrieben wird.Wenn ich an die Ausgänge des AVR auch noch T
-
Thread
16 Bit SPI Übertragung
der Master diese Pause nicht macht. Der Master interessiert sich nicht für die Pause die sich der AVR gönnt, sondern taktet stur weiter. Die Frage lautet doch einfach ausgedrückt: Können die AVR's ein 16 Bit datenwort empfangen, oder können die AVR's nur 8 Bit. ==> Wieviele Bit hat das Schieberegister
Als Slave kannst Du maximal 5MHz SPI-Takt noch sicher abfragen (20MHz / 4). Ein Byte wir demnach in 32 AVR-Takten übertragen. Ein einmaliges Auslesen von 2 Byte, wenn der AVR sonst nichts tut, geht ohne Interrupt am schnellsten (man benötigt keine Zeit zum Ein- und Ausspringen aus der Interrupt-Routine
-
Thread
Shift-Operation im Makro mit UND
-- Das halte ich für ein Gerücht. Sowohl was die Rechenarchitektur als auch das Verhalten bei IA32 angeht. Auch der AVR kann 32, ja sogar 64 Bit Variablöen verarbeiten, und das macht er auch korrekt! Eher ist so, das ein (konstantes) Lichtsschieben um mehr Bits als die Variable umfasst immer 0
execution time of the instructions. ----- Der Compiler muss also gar nichts bei Left-Shifts >= 32 (im Fall von uint32_t). EDIT: Sowohl auf einer Linux-Büchse mit ELF 32-bit als auch als ELF 64-bit Executable ist das Verhalten identisch. [code] # file a.out a.out: ELF 64-bit LSB executable
-
Thread
24 serielle Schnittstellen am PC
Controller mit 20 MHz. Ein 1ms Timer und die passende State Machine, ausreichend RAM sollte aber sein, 32-64kB würde ich mal ansetzen. Möglicherweise ist es sinnvoll, das Ganze auf einem der neuen ARMs zu packen, dann hat man gleich Ethernet an board und genug Resourcen. >Eigenbau wäre über den Ansatz
auch nörgeln ;-) Ach ja: Ich benutze jetzt die Exsys EX-44023 in meinem relativ-standard Windows7/64 Arbeitplatzrechner. Programmiert wird in VC++/VS2010 als 32Bit-Applikation, damit man auch rückwärtskompatibel ist. Die COM-Ports werden mit CreateFile(..) und overlapped IO geöffnet. Dazu gibt es
-
Thread
Welches Betriessystem und welches "Setup" verwendet ihr?
1. Windows 7 Prof. 64 und Windows XP Prof. 32 2. AVR Studio 4.19, Inventor 2010, Visual Studio c# 2008 Express, KompoZer, OLS Client (für Open Logic Sniffer), LT Spice, Office 2010 Prof. Academic
1. Windows 7 64 bit, Ubuntu 14.04 2.Avrdude, Arduino IDE, EAGLE
-
Thread
Marlin Firmware mit dem ATMEL STUDIO 7 auf das Arduino Mega 2560 Board flashen
file "G:\AVR Studio\7.0\Build1188\7.0\Vs\Assembler.targets" from project "E:\Projekte AVR-Studio\ATmega\ATmega88\TWI_3\TWI_3\TWI_3.asmproj" (target "Build" depends on it): Task "RunAssemblerTask" G:\AVR
E:\Projekte AVR-Studio\ATmega\ATmega88\TWI_3\TWI_3\Debug\TWI_3.obj" "" -I "G:\AVR Studio\7.0\Build1188\7.0\toolchain\avr8\avrassembler\Include" AVRASM: AVR macro assembler 2.2.7 (build 69 Jul 26 2017 16:25:
-
Thread
Software zum Formel umstellen um Overflows zu vermeiden
Noch nie was von muldiv gehört, muldiv(a*b*c,d,3600*1000) in deinem Falle. Aber wenn es ein 32bit CPU ist, dann einfach den uint64_t nehmen, long long oder wie er in der Toolchain heisst. Ist es ein AVR, ... muldiv. Bei vielen 32bit CPU impliziert der Befehlt muldiv 64bit Integer, da der Compiler
keines der Zwischenergebnisse größer als das Gesamtergebnis. Wenn also das erwartete Ergebnis in 32 Bit passt, kann der Ausdruck (1) problemlos in 32-BitArithmetik berechnet werden, während beim Ausdruck (2) zur Vermeidung eines Überlaufs bei der Berechnung von a * b 64-Bit-Arithmetik erforderlich
-
Thread
Probleme mit DirectFB beim kompilieren
-I/home/june/proj/buildroot-avr32-v2.3.0/build_avr32/staging_dir/usr/include -I/home/june/proj/buildroot-avr32-v2.3.0/build_avr32/staging_dir/include -msoft-float -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -DHAVE_CONFIG_H
-Os -I/home/june/proj/buildroot-avr32-v2.3.0/build_avr32/staging_dir/usr/include -I/home/june/proj/buildroot-avr32-v2.3.0/build_avr32/staging_dir/include -msoft-float -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -MT
-
Thread
GCC für M16C!
die aktuellen Sourcen über CVS runtergeladen und bin gerade am Compilieren. In der 4.0.1 ist der m32c-Support noch nicht drin. Andreas: definiere vor Ort. ;) Ich wäre scharf auf das SKP32C84, wegen dem DRAM-Controller im M32C.
Ich seh schon, pgm_read_byte grüsst alle Freunde des M16C. Und mehr als 64KB Code ist wohl dem M32 vorbehalten. Mehr geht halt in einen 16bit Pointer nicht rein.
-
Thread
AVR Studio 4 mit AVRISP mkii zum laufen bekommen!
zum laufen zu bekommen... Ich habe ein Beispileprogramm, was in der Uni ohne Probleme läuft. Das M32 läuft auch, hab über UART die Spannungsversorgung und über ISP anschluss ist der Programmer dran. Den Pullup-Widerstand und der Bootlooder/Debug schalter habe ich ebenfalls schon eingebaut. AVR-Studio
:/ Gut, denn wäre das Problem auch gelöst. Also um auf deine Frage zu kommen, ich benutze Win7 x64. Nun habe ich den Richtigen Controler sprich den mega32 ausgesucht, und habe die ISP Frequenz erstmal auf 125kHz gestellt. Und funktioniert :) ***erleicht*** Ist die ISP Frequenz eigentlich wichtig
-
Thread
Mikrocontroller Einstieg
der Preis keine so große Rolle wie in der Serienproduktion. Wobei die Chinesen auch schon lange ARM32-Controller für irgendwelche Dimmer o.Ä. einsetzen, die ganzen Bestandteile eines Elektro-Scooters (Dashboard, Motor-Controller und BMS) sind voll mit ARM32-Varianten. Beim Kern des 8 Bit AVR, der
Ich empfehle für den Anfang ein Nucleo64 Board mit dem STM32L072 mit Arduino zu programmieren. Später eventuell ohne Arduino mit der kostenlosen Cube IDE von ST. Diesen 32 Bit ARM Cortex M0 Controller gibt es in unterschiedlichen Größen.
-
Thread
AVR-Mikrocontroller programmieren lernen
schrieb im Beitrag #3631866: >Das einzige was funktioniert ist > Python. Mein System ist Windows 7, 64 Bit, mit nur einem 9 polligem > D-Sub-Stecker. Und mindestens 4 USB-Anschlüsse. Auf deinem PC läuft auch AVR-Studio oder Atmel-Studio, wie das jetzt heisst. > Aus diesem hier AVR-Tutorial habe ich
Hi, mach das mal so wie Thomas Eckmann geschrieben hat und vergiss die 32bitter usw. Für AVR bekommst Du hier mit Abstand am meisten Hilfe und die reichen ganz sicher für das was Du vorhast, die Stimmensteuerung mal aussen vor. Einfach ein Arduinoboard und dann mit dem
-
Thread
CMSIS und GNU Support
sie das gewollt hätten, nämlich zwischen den einzelnen bestehenden Varianten wie STR7, STR9 und STM32, um nur die 32-Bit Versionen zu nennen. Indes sind die entsprechenden Libs von STR9 und STM32 abgesehen von der mir schwer zugänglichen Vorliebe für structs noch deutlich inkompatibler zueinander als
nicht vergessen: [c] /* Vector tables for Cortex-M3 must be aligned. The minimum alignment * is 32 words. The alignment of the vector table is calculated from * its size rounded up to the next power of two. */ #define _vec_tbl_align(a) (((16+(a) <= 32) ? 32 : ((16
-
Thread
Linux Distri für Entwicklung
Hab ich ein Vorteil von Linux-64bit? Oder reicht 32-bit aus? Ich tendiere zu 64bit, weil ich 4GB Ram habe
64bit ist inzwischen Default. Da werden alle Libraries für 32Bit Programme mitgeliefert. Gibt eigentlich keinen Grund 32Bit zu installieren.
-
Thread
Lohnt sich der Umstieg auf 32-Bit Controller
Dass 32-Bit Controller sich beim Umgang mit Daten >16-Bit leichter tun liegt auf der Hand. Aber der Umgang mit Adressräumen ist mindestens ebenso wichtig. 8/6-Bit Controller können entweder nur zusammen 64KB
der Stm32f103 mit 64kb Flash und 48 Pins. Bei der folgenden Aussage möchte ich bitte korrigiert Weden, falls sie falsch ist. Beim 32 bitter benötige ich meißt mehr Speicherplatz weil ich zum ersten mir nicht
-
Thread
Mittelwert aus ca.100 Werten.
doch gleich sein? Für die Zukunft: einfach den Compiler Explorer fragen was dabei compiliert wird (AVR-spezifisch: http://avr-gcc.senthilthecoder.com, allgemeiner: https://godbolt.org/) Gibt man dem AVR compiler explorer folgenden Quellcode [c]int shift(int in){ return (in >> 7); } int div
nicht das selbe (was ich nicht erwartet hätte...) -O2 ist auch nicht gleich. *Viel schlimmer*: avr-gcc 4.5.1/4.6.4 fügen mit "-Os" ein [c]call __divmodhi4[/c] ein, was 245(!) Takte braucht! Hier noch der Link zum AVR-GCC Compiler Explorer http://avr-gcc.senthilthecoder.com/#g:!((g:!((g:
-
Thread
Warum USB Chip?
install the driver as well under 64bit x86_64 version of Windows Vista/7/2008/2008R2." http://sourceforge.net/apps/trac/libusb-win32/wiki Allerdings http://sourceforge.net/mailarchive/forum.php?thread_name=AANLkTikGsfLJ8UpCdCqF9NV%3DahbRDiEV8X5whBp591iS%40mail.gmail.com&forum_name=libusb-win32-devel Alternativ kann man auch mit WinUSB arbeiten
-
Thread
Eclipse + AVR
2.3.3.20100701PRD.jar de.innot.avreclipse_2.3.3.20100701PRD.jar Ich arbeite übrigends mit Eclipse Helios in der 32 Bit Version. Die 64 Bit Version habe ich auf meinem Windows 7 nicht ans Rennen gebracht. Dann sollte es klappen. Gruß Frank
Problem habe - hat sich inzwischen etwas neues ergeben ? Ich benutze EClipse HELIOS unter Windows 7/64 Allein die Inbetriebnahme von Eclipse war eine mittlere Katastrophe - wohl wegen der 64Bit-Version von Windows Auch bei mir wird das AVR-Plugin als installiert geführt, zusammen mit der C/C++
-
Thread
Maskieren modern?
Arbeit übernimmt und viele andere davon profitieren. Wenn ich dann für das nächste Projekt keinen AVR, sondern einen ARM, einen ESP32 oder irgendeinen anderen Mikrocontroller einsetze möchte, geht das ganze Gefrickel wieder von vorne los. Die in der Praxis tatsächlich auftretenden Fehler und Probleme
praktischen Gründen macht man Datumsarithmetik auf Basis des julianischen Datums. Dann ist es auch für den AVR schnell geschrieben: [c] constexpr uint32_t julianDay(const uint16_t year, const uint8_t month, const uint8_t day) { const size_t a = (14 - month)/12; const size_t y = year+4800-a;
-
Thread
[V] Halbleiter, Netzteile, Opto, Diskret, Relais, Buchsen, Evalboards
10x 39VF010-70-4C, Microchip: 1MBit Parallel Flash -> 0,25€/Stk. 128x M29W320EB-70N6, ST: 32MBit Parallel Flash -> 0,50€/Stk. 152x S29AL008D70TFI02, Spansion: 8MBit Parallel Flash -> 0,25€/Stk. 43x M24C64-RMN6P, ST: I²C EEPROM 64kBit -> 0,15€/Stk. Halbleiter
PCA9515A, NXP: I²C Bus repeater -> 0,25€/Stk. 401x ATMEGA325-16AU, Atmel: AVR -> 0,75€/Stk. Halbleiter Speicher: 124x M29W320EB-70N6, ST: 32MBit Parallel Flash -> 0,50€/Stk. 5x M24C64-RMN6P, ST: I²C EEPROM 64kBit
-
Thread
stm32f103c8 lässt sic nich flashen
: C:\CooCox\CoIDE>"C:/CooCox/CoIDE/bin\coflash.exe" program STM32F103C8 "C:/CooCox/CoIDE/workspace/y/y/Debug/bin/y.elf" --adapter-name=ST-Link --port=SWD --adapter-clk=1000000 --erase=affected --reset=SYSRESETREQ --driver="C:/CooCox/CoIDE/flash/STM32F10x_MD_64.elf"
Bootlader _oder_ SWD? Das sind zwei verschiedene Dinge. Frage: Schaffst du es, aus deinem "STM32F10x_MD_64.elf" ein dazu passendes Hexfile oder Binärfile zu erzeugen? Also FromElf oder ObjCopy benutzen? Wenn ja, dann lade dir den Stm32Prog hier aus dem Forum herunter und versuche dein Glück damit
-
Thread
Download aller Atmel Datenblätter (µC)?
html), da diese anders benannt sind. Allerdings fehlen Datenblätter wie von ATtiny10 und die ATmega64-/32-/16-M1
ATmega2560 ATmega2561 ATmega32U6 ATmega64 ATmega640 ATmega64A ATmega8515 Demnach kann immerhin auch der Arduino Mega Displays einfach ohne Bitklappern ansteuern, die ein direkt adressierbares Pixel-Ram haben.