-
Thread
Servosteuerung 30 A - H-Brücke verstärken?
darf also annehmen, daß die Kommunikation zwischen Programmer und MCU funktioniert. [code] ~/test/AVR/hello/timer$ man avarice .... avarice currently has support for the following devices: at90can128 at90can32 (o) at90can64 (o) .... * - Only supported
Wolfgang R. schrieb im Beitrag #4937603: > ~/test/AVR/hello/timer$ man avarice > .... > avarice currently has support for the following devices: > at90can128 > at90can32 (o) > at90can64 (o) > .... >
-
Thread
Einstieg in C - komische Fragen
Dynamikbereich von Gleitkommazahlen in erster Näherung beliebig groß. :) Zwar gibt's für den AVR keine 64-bit-double (nichtmal 48-bit wie bei Turbo Pascal), aber die 32-bit-Operationen sind /verdammt/ kompakt implementiert. Ich möchte meine nicht vorhandene Perücke verwetten, dass sie in der
Jörg W. schrieb im Beitrag #4391272: > Zwar gibt's für > den AVR keine 64-bit-double Gibt es doch, man muß sie nur nehmen: IAR-Kickstart für AVR bietet double. Daß AVR-GCC es nicht kann, bedeutet doch nicht, daß es nicht ginge oder geht.
-
Thread
Vorzeichenbehandlung und Typcast
auf int-Größe und werden daher nur nach unsigned promotet. Auf Linux-System: (int32_t)(ADC - offset) = -3 Auf AVR: (int32_t)(ADC - offset) = 65533
long int uint32_t; typedef signed long long int int64_t; typedef unsigned long long int uint64_t; [/c] Ist stdint.h eigentlich erst eine Neuerscheinung von C99? Unter Linux wo int 32bit lang ist (vermutlich
-
Thread
DRAM am AVR: Wie sieht Euer Wunsch-Interface aus?
interessiert, für welche Anwendungen kann man überhaupt DRAM sinnvoll benutzen ??? Nur deshalb DRAM an den AVR dranpappen, damit man ihn mal drangepappt hat, finde ich persönlich völlig witzlos. Der AVR ist auch ne äußerst ungünstige Wahl, da er nur max 64kB RAM adressieren kann. Ich würde mindestens
Signal. IC6 dient als Latch fürs Banking. Insgesamt unterstützt die Schaltung 2MByte, aufgeteilt auf 64 Bänke. Ich verwende immer die oberen 32kB des Adressraums für den Speicher und den unteren für I/O (LCD, IDE, Speicher Mapping Register usw.) Wenn ich mir das AVR Timing anschaue, dann steht das
-
Thread
PIC Prifi gesucht : Suche gleichwertige PIC uC zu ATMEL atmega32u4 und at90usb1287
WilliWillsWissen schrieb im Beitrag #1953975: > -Für den kleinen ATmega32u4 vielleicht der PIC18F4450 oder doch ein > 16Bit > PIC24FJ32GB004 ? > -Für den AT90USB1287 vielleicht den PIC24FJ64GB110 ? > > Vielleicht gibt es einen Profi der sich hiermit schon mal > auseinandergesetzt
@Michael H. > Kein PIC24F geht bis 64MHz. stimmt! mein fehler, habe einfach die MIPS-zahl mit 4 multipliziert anstatt mit 2 also: PIC24F 32MHz (16MIPS) und PIC24H 80MHz (40MIPS)
-
Thread
IAR math funktion mit 64bit double
Hallo ich hoffe hier kann mir jemand helfen.Ich benutze den IAR AVR Compiler und würde gern mit 64bit double werten rechnen.Leider bringt mein kleines Testprogramm bei 64bit keine vernünftigen Werte. Mit 32bit double klappt die Berechnung problemlos. Die CLIB ist
: (DLIB 64bit) AVR Simulator: Invalid opcode 0xffff at address 0x005858 (mal was neues) (DLIB 32Bit) bei Gleitkommazahlen (einzelnen chars dezimal) "3.14" --> 102d 0d 52d 0d 255d ... falsch bei integer
-
Thread
WinAvr Atmel Ice als Programmer hinzufuegen
Ich habe Libusb ausgefuehrt und den ICE eigetragen. Neustart -> WinAvr gestartet und das Makefile neu gemacht. Jetzt bekomme ich folgende Ausgabe: avrdude -p atmega32 -P usb -c atmelice_isp -U flash:w:main.hex avrdude: usbdev_open(): USB device has no configuration
Wenn ich dann mal diesen Befehl eingebe: sudo avrdude -p m32 -P usb -c atmelice_isp -U flash:w:main.hex -B10 -F -D avrdude: stk500v2_command(): command failed avrdude: initialization failed, rc=-1 avrdude: AVR device initialized and ready to accept instructions
-
Thread
Vista: MP3-Wiedergabe stockt bei hoher CPU-Last
x32-Emulation. Bei IA64-CPUs würde ich dir zustimmen. Aber x86_64-CPUs können IA32-Code nativ ausführen. Also nix mit Emulation.
Itanium = IA-64-Architektur => Ausführung von IA-32 Code nur im extrem langsamen Firmware-Emulationsmodus Intel 64 = AMD64 = x86_64 = EMT64 = IA32e => Erweiterung der IA-32-Architektur; kann IA-32-Code im Compability-Mode
-
Thread
Microcontroller - Warum kein Flash-Parity?
AVR32SD20/28/32 Preliminary Data Sheet: – 32 KB in-system-programmable Flash memory with ECC – 4 KB SRAM with ECC – 256B EEPROM with EC
tri-stated. https://ww1.microchip.com/downloads/aemDocuments/documents/MCU08/ProductDocuments/UserGuides/AVR32SD32-CuriosityNano-UserGuide-DS50003842.pdf
-
Thread
Daten in Struct zuordnen und ins EEPROM speichern
übertragen wird, richtig? Basti schrieb im Beitrag #4892987: > Vorschlag: > > int eeprom_store(uint32_t addr, void *data, size_t len); > int eeprom_load(uint32_t addr, void *data, size_t len); ich möchte dafür die funktionen eeprom_update_block und eeprom_read_block nutzen aus <avr/eeprom.h>.
gefährlich wenn man die Architektur nicht ausreichend kennt. Ich verstehe auch nicht warum deine 64bit Daten Type nicht als Array belässt. Das hin und herschieben bringt kaum was. Denn ein AVR wird sie weiterhin byte weise speichern müssen. Es gäbe noch eine Möglichkeit in dem man den Datentyp
-
Thread
GLCD Routinen ( KS0108, HD61202 )
dieses Display: http://www.sure-electronics.net/mcu,display/DE-LM106.pdf Controller ist ein ATMEGA32 (mit 8 MHz intern). Beides habe ich im Projekt (AVR-Studio) eingestellt und die Pins habe ich auch angepasst. Die Ausgabe ist prinzipiell zu erkennen, aber es ist nicht i.O. (siehe angehängtes Bild
Schon gut... habs hinbekommen! ich Depp musste erstmal die Funktionen unter AVR aktivieren! :-S
-
Thread
Fehler bei SRAM Berechnung?
of 2 */ #ifndef UART_TX_BUFFER_SIZE #define UART_TX_BUFFER_SIZE 32 #endif [/c] Jetzt bin ich erst recht überrascht: Der Atmega128 hat 4kByte SRAM; wieso sollen denn jetzt plötzlich 64 Byte da nicht mehr reinpassen!? Also habe ich mir die Werte der defines mal
zeigt. Umgebung: Atmel Studio 6 (Version 6.0.1996 - Service Pack 2), keinerlei weiteren Pakete wie WinAVR etc. Nur dieses Studio auf einem frisch aufgesetztem Rechner Win7 64bit. Oliver S. schrieb im Beitrag #2961641: > Was mal wieder ein Beispiel dafür ist, daß Diskussionen über nicht > komplett
-
Thread
Neue schnellere ARMe von Philips - bastelfreundlich!
Diese "Seuche" mit 1,8 und 3,3 Volt können die wohl nicht lassen, da ist in der Summe nen AT91SAM7S32 preiswerter bei gleicher Stückzahl und vor allem lieferbar, wobei der S64 mit mehr FLASH, SRAM und USB nicht sehr viel mehr kostet.
beiden zu zaehlen? Der 48-pinner von Philips ist viel flexibler and kann bis zu 32 I/O pins bereitstellen, da brauchts schon den 64-pinner von Atmel. Nimmst Du aber den 64-pinner von Philips (LPC213x oder LPC214x) dann hast Du wieder 5-10 I/O pins mehr, mehr Geschwindigkeit, auch
-
Thread
Dialog übernimmt Atmel [Update: Nein, Microchip übernimmt Atmel]
Hobbyistenszene noch einen großen Bedarf an 8Bit µC gibt. Denn 32Bit ist nicht bei allem besser... Die werden jetzt auch Überlegen: Es gibt Sounsoviele industrielle AVR Anwender. Ein paar werden in der nächsten Zeit sowieso von AVR weggehen weil die mehr Leistung brauchen
sec/filings/FY16/425%20Filing%202-5-2016%20(re%20conf%20call).pdf "the addition of Atmel’s 8-bit AVR microcontroller family, and 32-bit ARM microcontroller family, we expect will enhance Microchip’s industry-leading 8-bit, 16-bit, and 32-bit microcontroller offerings." [...] "The comment from investors
-
Thread
Arduino IDE 1.8.9 buggy?
unter windows XP (32) wenn ich neu was kompilieren will Fehler unter win7 - 64 gehts das hatte ich bis 1.8.5 nie [c] In function 'global constructors keyed to 65535_0_A804b_nan_Nok_RTC_EEP_DHT22_ok_slow_DS.ino.cpp.o
1.8.9 wer zwischen den Prozzis wechselt sollte sich eine Erinnerungshilfe einbauen #if defined(__AVR_ATmega328P__) // o.ä. z.B. #if defined(__AVR_ATmega328P__) || defined(__AVR_ATmega1284P__) #pragma message "#if(defined(__AVR_ATmega1284P__) || defined(__AVR_ATmega328P__))" #elif defined(ESP32
-
Thread
uint64_t Division großer Zahlen benötigt zu viel Programmcode
-64-bit-support?name=PNphpBB2&file=viewtopic&t=113673 Bei neueren AVR-GCC wurde die dann übernommen.
, obwohl das interessant und fortschritlich wäre. Bei Atmel kann man die neue Toolchain "avr8-gnu-toolchain-installer-3.5.0.85-win32.any.x86.exe" erhalten, die den AVR-GCC enthält. Diesen entpackt man in ein beliebiges Verzeichnis. Damit AVR-Studio diesen auch benutzt, muß man im AVR-Studio
-
Thread
ARM ist die Zukunft?
es heute ist. Für den µC-Bereich ist Thumb wirklich wichtig, und da hat ja Atmel lange mit seinem AVR32 gestänkert, dass die mehr Mips/MHz schaffen. Seit Thumb-2 ist das vorbei. Gibt ja auch keine wirkliche Weiterentwicklung bei AVR32 mehr. Und x86 ist einfach zu komplex, nichtmal der Atom wäre eeignet
Peripherie ist von Hersteller zu Hersteller völlig > unterschiedlich - teilweise ist es einfacher, von AVR32 auf AT91SAM3U zu > portieren als von STM32 auf LPC18xx.
-
Thread
ATmega162V Software auf ATxmega 64A3 spielen (umwandeln,Makefile?)
ATmega325P 8-bit picoPower AVR Microcontroller, 32KB Flash, 64-pin ATmega325PA 8-bit picoPower AVR Microcontroller, 32KB Flash, 64-pin ATmega645P 8-bit picoPower AVR Microcontroller, 64KB Flash, 64-pin ATmega169P 8-bit picoPower
picoPower AVR Microcontroller, 32KB Flash, 64-pin, LCD Controller ATmega329PA 8-bit picoPower AVR Microcontroller, 32KB Flash, 64-pin, LCD Controller ATmega649P 8-bit picoPower AVR Microcontroller, 64KB Flash
-
Thread
Sprachausgabe mit AVR
lt. Ulrich Radigs Programm würde ich auf folgende Beschaltung kommen AVR_ATmega32 SPI_DI (MISO) PB6 an Data Output der SD-Karte (PIN 7) SPI_DO (MOSI) PB5 an Data Input der SD-Karte (PIN 2) SPI_Clock (SCK) PB7 an Clock der SD-Karte
So, hier mal eine vorläufige Version zum schnuppern als AVR-Studio Projekt. Soundausgabe erfolgt an OC2/PD7 per PWM. Standard SPI Anschluss der SD-Karte an MISO,MOSI, SCK. CS der SD am SS Pin. ATMega32 getaktet mit 16MHz. Bei Problemen schlagen sie ihren
-
Thread
Ich versuch es ja, aber ich werde mit C++ einfach nicht warm :(
Klammern fehlen. [c] /* Signed. */ # define INT8_C(c) c # define INT16_C(c) c # define INT32_C(c) c # if __WORDSIZE == 64 # define INT64_C(c) c ## L # else # define INT64_C(c) c ## LL # endif /* Unsigned. */ # define UINT8_C(c) c # define UINT16_C(c) c # define UINT32_C(c)
sinnvoll einsetzen und nicht so willkürlich, wie in besagtem Buch. Meine Bibliothek habe ich für AVR und stm32 geschrieben. Da wird es dann schnell haarig, weil man jede Funktion, die man beim stm32 aus der STL verwenden könnte, beim AVR nach implementieren muss. Selbst der C-Standard ist nicht einheitlich
-
Thread
MSP430 vs. AVR: Welches Konzept ist besser?
internen RC-Oszillator starten, die 4xx brauchen dazu einen 32kHz-Uhrenquarz. Zudem lassen sich die Taktquellen zur Laufzeit umstellen (keine Fuses etc. wie beim AVR).
anzubieten, wird sicher in Kürze dort, oder auf meiner Homepage auftauchen. AT90CAN32, die kleine Version (was den Speicher angeht) gibt es inzwischen als "Engineering Samples" im TQFP-64-Gehäuse. AT90USB1287 im TQFP-64 Gehäuse sind lieferbar. Erwin
-
Thread
Handlicher Ethernet-Controller mit SPI von Microchip
avr==cmos mcu => 2,5V @ 5V Vdd sollte also eigentlich hinhaun... wobei ich mir nicht sicher wäre wie sauber das ganze schaltet => leckströme im avr... 73
: ARP + ICMP sind fertig: [c] > ping 192.168.0.5 PING 192.168.0.5 (192.168.0.5): 56 data bytes 64 bytes from 192.168.0.5: icmp_seq=0 ttl=64 time=1.3 ms 64 bytes from 192.168.0.5: icmp_seq=1 ttl=64 time=1.3 ms 64 bytes from 192.168.0.5: icmp_seq=2 ttl=64 time=1.3 ms 64 bytes from 192.168.0.5: icmp_seq
-
Thread
PI mit 8-Bit Controller auf viele DEZIMALSTELLEN genau berechnen
weniger interessiert als DHRYSTONE, WHETSTONE und LINPACK Benchmarks. Die Arduino-IDE unterstützt neben AVR-Atmega Controllern inzwischen eine ganze Bandbreite von Mikrocontrollern, einschließlich ESP8266 und STM32. Das wäre vielleicht eher ein Thema fürdas Forum auf Arduino.cc, denn aufPlattformen, die nicht
sich durch Umstellung auf 32-Bit Integer-Datenytpen im Code so weit aufbohren, dass weitaus mehr als 4000 Hex-Digits von PI auf AVR-GCC korrekt berechnet werden können. 3. Und last but not least: Zum Zwischenspeichern von Hex-Digits
-
Thread
Programme aus RAM auf AVR32
*hust* AVR32 *hust*
(AVR32_PIN_PB22); }; gpio_tgl_gpio_pin(AVR32_PIN_PB21); } gpio_set_gpio_pin(AVR32_PIN_PB23); } [\c] Erstellt mit mit 'Position independent code', 'use assembler for pseudo instructions
-
Thread
sprintf mit dynamischen Format
Beispiel beim ersten mal hinsehen falsch interpretiert. Leider komme ich erst wieder am Montag zu dem AVR32 Board damit ich den Code Testen kann. Ich wollte es jetzt unter Ubuntu (64Bit) mit Eclipse testen. Leider bekommen ich folgenden Fehler: Typkonvertierung gibt Feldtyp an Naja ich werde es
Hier noch der link zur Atmel Toolchain (newlib): http://distribute.atmel.no/tools/opensource/Atmel-AVR-Toolchain-3.4.2/avr32/ http://distribute.atmel.no/tools/opensource/Atmel-AVR-Toolchain-3.4.2/avr32/avr32-newlib-1.16.0.tar.gz
-
Thread
Taktfrequenz vom ATxmega
. Das gibt dann: - 32MHz CPU Takt - 64MHz Peripherietakt (Speicher etc.) Die Architektur des XMegas und der Mega AVRs sind sehr verschieden. Beim XMega wurde halt auch ordentlich aufgeräumt, was die ganzen Altlasten
2 stellen. Das gibt dann: > - 32MHz CPU Takt > - 64MHz Peripherietakt (Speicher etc.) Der RAM läuft auf 64MHz gescheit? Habe dazu (noch) keine Info im Datenblatt finden können. Wie kann man sonst einen Timer mit 64MHz betreiben
-
Thread
EOL ATmega328p
The new AVR® DD family of microcontrollers feature the well-known AVR® CPU, now running at up to 24 MHz across the full supply voltage range of 1.8V to 5.5V. https://www.microchip.com/en-us/product/AVR64DD32
ATtiny461 ATtiny461A ATtiny48 ATTINY84 ATtiny84A ATtiny85 ATtiny861 ATtiny861A ATTINY88 AVR128DA28 AVR128DB28 AVR16DD28 AVR32DA28 AVR32DB28 AVR32DD28 AVR64DA28 AVR64DB28 AVR64DD28 Die gesamte Liste kann man als *.xlsx-Datei herunterladen, und wenn man da die Spalte "Package" nach
-
Thread
Encoder mit ATMEGA8
OCR2 TCCR0 TCCR2 = 1<<WGM21^1<<CS22; // CTC2, Prescaler 64 D.h. die Änderungen sind auf vier Zeilen begrenzt [C] ISR(TIMER2_COMP_vect) { ... } ... TCCR2 = 1<<WGM21^1<<CS22; // CTC2, Prescaler 64 OCR2 = (uint8_t)(XTAL / 64.0 * 1e-3 - 0.5);
> Ich bekomme maximal ein -1 aufs LCD. itoa bei einem int32_t val ist nix. Nimm ltoa http://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html#ga1d4c7b84110553544081a69a0fc49c52 > char buffer[7]; Ist für eine long (int32_t) Zahl potentiell
-
Thread
Sinusberechnung auf Controller STM32F030
fürs > Programm. Im AVR wäre das so nicht ein Problem, weil ein 8 Bit breit, bei einem ARM dieses jedoch 32 Bit breit. Es wäre mal einen Vergleich wert, wie groß der Code auf einem AVR und wie groß der Code auf einem ARM
eichfähiges System eine interne Berechnung in int64_t statt in double durchgeführt. Plötzlich reichen auch 16k statt 32k Flash. Und int64_t war schon der Ansatz für Faule. ;)
-
Thread
Suche ein 28 Pin Mikrocontroller mit mehr als 32 kBit Flash Speicher
Der ATmega328 hat 32 Ki *Byte*.
mehrfach vorkommende Wort nur einmal gespeichert werden. Oder eine ganz einfache Komprimierung die der AVR noch schafft: https://en.wikipedia.org/wiki/Run-length_encoding Ansonsten ist ein 8-Bit uC die falsche Wahl für alles was über 64k ROM oder 4k RAM rausgeht, sollte ja eigentlich vorher absehbar
-
Thread
Anfängerproblem mit C
"generell" anzunehmen. Auf 8- oder 16-Bit-Systemen ist ein /int/ üblicherweise 16 Bit groß, auf 32-Bit-Systemen ist er üblicherweise 32 Bit groß, auf 64-Bit-Systemen ist er meistens auch 32 Bit groß, kann aber auch 64 Bit groß sein. Georg W. schrieb im Beitrag #8070001: > Wir programmieren SPSen
immer 16 Bit lang ist. Auf die Frage woher denn die > Definition kommt Tja, bei ARM ist ein Word 32bit, ein Halfword 16bit, und ein Doubleword 64bit.
-
Thread
Warum besitzt der AVR keine Division-Funktion?
Ähm, sorry, Leute, aber irgendwie klingen die letzten Posts alle, als ob Ihr noch nie was vom AVR32 gehört habt. Gruß Johannes
Hier ist nur die Rede von AVR-Mikrocontrollern. Der AVR32 ist ne komplett neue Produktreihe und ein DSP bzw. MCU. Oder wolltest du auf was anderes hinaus? Dann entschuldige ich mich hiermit schonmal ;) MfG
-
Thread
Nokia 6100 Ansteuerung in C
er auf die Dauer immer korrekt arbeitet. Aber ich meine das es wahrscheinlicher ist das die meisten AVR's auch ausserhalb ihrer Grenzen SCHEINBAR stabil laufen statt überhaupt nicht. Zb. habe ich einen ST24C64 als W und normale Version. Die normale Version dieses EEPROM I2C Chips soll laut Doku mit
könnte, aber so wie es jetzt ist ist es wesentlich performanter und störsicherer. Nehmen wir einen AVR mit 16MHz Takt an. Das schnellste SPI ist also mit 8MHz möglich. Zu rausschieben eines Bytes benötigt man also 32 Takte der MCU. Der Code zum Befüllen des SPI's benötigt ca. 6 Takte. Ohne den IRQ
-
Thread
Unterschied zw. uint8_t und unsigned int
> ein "unsigned integer" hat auf x86 > vier Bytes, also 32 Bits. Sofern x86 = 386 und aufwärts im 32-Bit-Modus. Bei üblichen 8-Bit-Systemen wie AVR, MSP430 etc. ist ein unsigned integer 16 Bit groß, bei x86 im 16-Bit-Modus ("real mode") auch.
Auf vielen Platformen entspricht die Größe des ints tatsächlich der Wortbreite. Spätestens bei den 64Bit Architekturen ist da aber Schluß. Dort hat der int üblicherweise nur 32 Bits, der long Typ ist aber 64 Bits groß. Den int bei 64-Bit Architekturen bei 32 Bits zu belassen ist aber sicherlich
-
Thread
16Bit Variable - überlauf abfangen?
brauche ich ja auch wieder zwei Variablen bzw. eine Hilfsvariable: [c] Mittelwert1 = Mittelwert(64); Hilfsvariable = Mittelwert(64); Mittelwert1 = (Mittelwert1 + Hilfsvariable) / 2; [/c] Daher passt dann wirklich die uint32_t obwohl ich dann 15 Bit "verschenke" oder gehts auch so: (Mittelwert1 = 16Bit) [c] Mittelwert1 = (Mittelwert(64) + Mittelwert(64))/2; [/c] tuppes schrieb im Beitrag #1725321: > Warum nicht? Hast du keinen Speicher mehr für 32 Bit? Oder hast du Angst > vor dem Performance-Verlust? Das Programm ist noch nicht
-
Thread
Ambilight mit STM32F4discovery und TVP5150AM1
http://de.farnell.com/stmicroelectronics/stm32f4discovery/evaluationsbord-stm32f4-discovery/dp/2009276 Habe es selbst gefunden, sry :=~ Hier mal im Vergleich ein ATMEGA128 ( bei Farnell ) http://de.farnell.com/atmel/atmega128-16au/8bit-128k-flash-mcu-tqfp64
Verarbeitung des Bildes in 2 Hälften (links und rechts). Zunächst wird das Bild in ein grobpixeliges 64*40 Bild gerastert. Das passiert in 2 Durchgängen (32*40 links, dann 32*40 rechts). Dabei wird die Befüllung der 32 Pixel von links nach rechts durchgeführt. Bei unglücklichen Teierverhältnissen kann
-
Thread
LEDs dimmen ohne PWM
@Hagen Das klingt sehr interessant, aber 32MHz Pixeltakt ? Woher kommen die Daten dafür, aus einem AVR wohl nicht...
Umdrehungsgeschwindigkeit des Rotors und erzeugt für die 512 Pixelspalten einen Basistakt. 5.) Takterzeugung aus einem 32Mhz externen Oszillator für die 16Mhz des AVR's und den internen Takt von 64Mhz für den FPGA. Soweit in Einzelmodulen fertig sind die Takterzeugung, die PLL zur Synchronisation, der Multiplexer, der
-
Thread
8051 - Programm und Daten in einem 128kB Chip ohne Overlap
versuche gerade, ein Entwicklungsboard für einen Atmel 8051er Prozessor zu entwerfen. Ich möchte 64kB Datenspeicher und 64kB Programmspeicher, der auch RAM sein soll, anschließen. Weil es bei Reichelt nach 32kB nur 128kB RAMs gibt, ist mir die Idee gekommen, Daten- und Programmspeicher in einen Chip
gesamt gelöscht wird. Aber auch dafür gibt es eine Lösung. Das Bild zeigt ein Speicherbeispiel für 64k-Programm- mit 8k-Datenspeicher, welche mit der 2k-Testversion problemlos programmiert werden können. Ich mache das eigentlich mit den STM32xx so, um auf legalen Weg die 32k-Beschränkung zu umgehen
-
Thread
Frage zu Timern in C
Indem du einen uint64_t wählst. Dann hast du Ruhe.
verhindern, dass er wöhrend dessen durch die ISR verändert wird. Zum Beispiel so: [c] volatile uint32_t sechzehn_ms=0; int main(void) { // Hier den Timer starten cli(); uint32_t warte_seit=sechzehn_ms; sei(); while(1) { cli(); uint32_t jetzt=sechzehn_ms
-
Thread
Embedded Projects übernimmt Mikrocontroller.net-Shop
ein LCD/TFT mit dem Board betreiben. Sind die Treiber integriert? siehe auch hier: http://www.avr32linux.org/twiki/bin/view/Main/AtmelLcdcDriver Fragen über Fragen...
>which does not exist! Assume -R? [n] Das ist die erste Meldung. Und ne Toolchain bauen wie bei avr32linux beschrieben klappt auch nicht, da ist wohl nen bekanntes problem bei.
-
Thread
USBasp über Parallels
Wird da eigentlich der korrekte Treiber (winusb.sys für ARM) installiert, oder ein Treiber für 32/64bit Intel?
Fall zwingend ein ARM64 Binary sein. Die Intel-Emulation geht nur für den Usermode, nicht aber für Kerneltreiber. Du kannst ja nicht einmal 32 Bit x86 Treiber mit einem x64 64 Bit Windows benutzen. Da Du offensichtlich kein
-
Thread
Newbie: Welches FPGA verwenden?
Und was spricht gegen die Version mit einem stm32 mit >64 IOs und alles per USB übertragen? Mit 100kHz 8 Byte vergleichen ist ein Witz für einen STM32. Nochmal, das sind 8 Byte. Wenn du das noch ein wenig clever an den Mikrocontroller anklemmst, ist
Selbst wenn es rein theoretisch 64x 8 Bit Werte @100khz von ADCs wären, könnte ein sehr schneller Mikrocontroller das noch wuppen (sofern man genug ADC Kanäle dranbekommt). Das wären 51.2 Mbit/s. (USB 2.0 HS 480 Mbit/s ist im STM32 auch
-
Thread
Wir kriegen euch alle!
>der nen anderen Tip? Ich brauch was mit mindestens 8kb Ram, mindestens >32kb Flash, gut von Hand loetbar, 2x RS232, Geschwindigkeit ziemlich >egal, 5V Betrieb. Nimmm doch einen ATMega8515 - bis zu 64kByte RAM extern - sollte für Dich perfekt sein
Olaf wrote: > Oder nen anderen Tip? Ich brauch was mit mindestens 8kb Ram, mindestens > 32kb Flash, gut von Hand loetbar, 2x RS232, Geschwindigkeit ziemlich > egal, 5V Betrieb. Mit mindestens 8 KiB RAM brauchst du bei Atmel zwar kein TQFP-100, aber ein TQFP-64. Die sind aber mit 0,65
-
Thread
Schreibunterlage für Programmierer
Vom Maurer für die Stupidenten: 8 Bit: 7 6 5 4 3 2 1 0 128 64 32 16 8 4 2 1
| | int16_t | 16 | | uint16_t | 16 | | int32_t | 32 | | uint32_t | 32 | | int64_t | 64 | | uint64_t | 64 | ———————————————————————————————
-
Thread
16 UARTs für MIDI
Arduino zu verwenden, ist trivial. Aber > was ist mit 16? So viele UART-Interfaces hat selbst ein STM32 nicht zur > Verfügung. Ich würde drei AVR128DB64 verwenden. Die meisten von deren vielen schönen Pins liegen in der konkreten Anwendung dann zwar brach, aber was soll's. Die drei Dinger kosten zusammen
dürften die Kosten so ungefähr auf demselben Level landen wie die von mir vorgeschlagene Lösung mit 3x AVR128DB64.
-
Thread
Timer1 ( ATMega 32U4 ) zu schnell - Fehler in der Konfiguration?
Timer nicht so wie ich. Habe auch lange nichts mehr gemacht und mache das erstemal mit dem ATMega 32U4 Bekanntschaft: Fakten: ATMega 32U4 Takt 8 MHZ 3,3 Volt Ziel: Takt von 0,01 Sekunden Meine Initalisierung: TCCR1B = (1<<WGM12)|(1<<CS11)|(1<<CS10);// CTC Mode, OCRA, Prescaler 64
<<WGM12)|(1<<CS10)|(1<<CS10);// CTC Mode, TCCR1A bleibt auf default fuer CTC Mode, OCRA, Prescaler 64 OCR1A = 1249; TIMSK1 = (1<<OCIE1A);// Output Compare Match A Intterupt Enable //Initalisierung Timer3, Zustaendig für 0,001s //TCCR3B = (1<<WGM32)|(1<<CS31)|(1<<CS30);// CTC Mode, TCCR3A
-
Thread
Commodore C128
Ingo L. schrieb im Beitrag #7939552: > Meine ersten Gehversuche in Maschinensprache waren auf dem C64 (6502). > Das hat mir alles mehr Spaß gemacht als mit einen PC oder mit den AVR´s. > Am dem Rechner konnte mann noch rumbasteln. Da war noch irgendie alles > "offen" Was ist an einem AVR nicht
ich benutze auch die AVR´s aber der C64 und der 128 macht einfach mehr Spaß.
-
Thread
'var' may be uninitialized
konkret an dem Beispiel: https://www.mikrocontroller.net/topic/366173 kurz zusammengefasst: int32: 930 Bytes Code, 2960 Takte int64: 1366 Bytes Code, 6900 Takte float: 578 Bytes Code, 3300 Takte wobei die int32-Variante recht ungenau ist, und für gewisse Fälle (genaue Höhenmessung) damit unbrauchbar
Michael Reinelt schrieb im Beitrag #4125778: > kurz zusammengefasst: > int32: 930 Bytes Code, 2960 Takte > int64: 1366 Bytes Code, 6900 Takte > float: 578 Bytes Code, 3300 Takte Da fehlt aber noch der Verbrauch für die Libs. Daß int32 größer ist, liegt daran, daß oft
-
Thread
NeuesOS für AVR Mikrocontroller
Guten Abend, ich habe angefangen den Code für den atMega32 an zu passen. "system/header/nano_os.h" [code] #elif defined (__AVR_ATmega32__) #define RAMSTART 0x60 #define HEAPSTART 0x085f #define STACK_SIZE 54 // immer Timer0 ! #define TIMER_REGISTER
dec hex filename 0 692 0 692 2b4 nano_os.hex atmega32 $ avr-size nano_os.hex text data bss dec hex filename 0 712 0 712 2c8 nano_os.hex
-
Thread
Programmer Empfelung
Treiber gibt'S z.B. hier: http://www.ulrichradig.de/home/uploads/File/USBasp/091122_USBASP_Driver_Win32-Win64_v0_1_12_1.zip Oder direkt bei fischl: http://www.fischl.de/usbasp/ Der läuft bei mir unter Win7 32/64 ohne Probleme mit WinAVR. Wenn Du avrdude per "Hand" bedienen willst gibt es dafür auch
programm enable: target doesn't answer. 1 avrdude.exe: initialization failed, rc=-1 avrdude.exe: AVR device initialized and ready to accept instructions avrdude.exe: Device signature = 0x000000 avrdude.exe: Yikes! Invalid device signature. avrdude.exe: Expected signature for ATMEGA32 is 1E 95 02