-
Thread
UART Bootloader ATtiny13 - ATmega644
o.k. Elapsed time: 0.00 seconds C:\AVR_PR~1>FBOOT.EXE /PC:\AVR_programm\LED_mega32.hex COM 1 at 115200 Baud: Connected Bootloader V1.4 Target: 1E9502 ATmega32 Buffer: 1792 Byte Size available: 32256 Byte File C:\AVR_programm\LED_mega32
time: 0.00 seconds C:\AVR>FBOOT.EXE /PC:\AVR\LED_mega32.hex COM 1 at 115200 Baud: Connected Bootloader V1.4 Target: 1E9502 ATmega32 Buffer: 1792 Byte Size available: 32256 Byte File C:\AVR\LED_mega32.hex open failed !
-
Thread
Lokalität von Registerwerten?
cpi AL, 12 brcs PC+2 ldi AL, 0 std Y+ns_loop, AL brcs dd_nxt ldd ZL, Y+ns_lp inc ZL breq dd_nxt std Y+ns_lp, ZL clr ZH addiw Z, envelope*2 lpm AL, Z std Y+ns_lvl, AL dd_nxt: adiw YL, 9 cpi YL, low(Notes+nsize*N_NOTE) brne dd_lp popw Z ret ;--------------------------------------------------------------------; ; 32 kHz wave form synthesising interrupt isr_tc0_coma: in _Sreg, SREG ;Save regs...
-
Thread
Zeitgesteuertes Schalten eines Verbrauchers ohne Mikrocontroller
Vielleicht sollte er uns mal sagen welchen µC er benutzt. Ich habe vor kurzem etwas ähnliches mit dem STM32L1xx gemacht einfach vor dem Stopmodus die RTC anschmeißen, die nach einer vorgegeben Zeit einen externen Interrupt auslöst.
vermutlich 100x so viel Energie wie mit I2C und sie blockiert im Router auch noch den USB Port. Ein Atmega32U4 braucht via PLL sogar 40MHz oder 48MHz... Dafür hat man das USB in Hardware. USART hatten wir doch schon ausgeschlossen, weil die interne Clock vom AVR zu ungenau ist um eine stabile Datenrate zu
-
Thread
(STM32) Register Lib mit define oder nicht define..
Ich komme aus der AVR Ecke und bin es jahrelang gewohnt meine Register selbst zu beschreiben. Nun gibt es ja für die STM32 die HAL Lib und die StdPeriph Lib. Die nehmen einen ja schon ne Menge Arbeit ab, aber ich mach
ausreichend header für die ARMs. Und die sind ordentlich angelegt, nicht wie dieser Shift-Scheiss aus der AVR Ecke. Sorry, musste sein. Hier ein Beispiel von den ARM Machern: http://www.keil.com/dd/docs/arm/st/stm32f10x/stm32f10x.h Schön alle Flags als Masken, wie es sich gehört.
-
Thread
bit invertieren
alles mit /mirror/ auskommentiert wurde, und danach der Speicherplatzzuwachs festgestellt wurde (Atmega32, -Os, avr-gcc 4.3.2): [c] #include <avr/io.h> volatile uint8_t cnt; unsigned char mirror( unsigned char a ) // 90 Bytes { a = ((a >> 4) & 0x0F) | ((a << 4) & 0xF0); a = ((a >> 2) & 0x33
mit /mirror/ auskommentiert wurde, und danach der > Speicherplatzzuwachs festgestellt wurde (Atmega32, -Os, avr-gcc 4.3.2): Erstaunlich, was bei Dir an relativen(!) Unterschieden rauskommt. Bei mir ist es ATmega168, -Os, avr-gcc 4.3.3.
-
Thread
PIC Mikrocontroller noch aktuell ?
spezifisch für 8-bit Mikrocontroller interessiert, dann kommt natürlich auch PIC in Frage. Aber Padauk, AVR und STM8 sind vielleicht sogar interessanter. Ansonsten gibt es viele 32 bit alternativen: RP2040, STM32, CH32V, PY32F etc...
beispielsweise: https://ww1.microchip.com/downloads/aemDocuments/documents/MCU08/ProductDocuments/DataSheets/AVR64DD32-28-Complete-DataSheet-DS40002315.pdf
-
Thread
Logamatic 2107 Schnittstelle
Gruß, Mike Buderus HS2401 / Ecomatic 4000 (mit Schieberegler) / Baujahr 1994 ATMEL ATMEGA32, Pollin AVR Net I/O, EvalBoard 2.0.1 / AddOn Board
Ich wollte mal meine Projekte zur Verfüging stellen. ETH_M32 (URadig) ist für das Pollin-AVR-Net-IO Board. Läuft bei mir aber mit einem Atmega644 statt Atmega32. Wenn man sich per Telnet drauf verbindet werden die empfangenen Telegramme über die Telnet-Verbindung
-
Thread
ATMEGA32 Minimum System Board
Link: http://dx.com/p/jy-mcu-minimum-avr-system-board-atmega32-104310 korrigierter Link für Youtube-Video "atmega32 minimum Bascom blinky 9 Euro" http://youtu.be/gQD3SdgPueQ
Auf Wunsch compilier ich dir was vor. Der AVR muesste ein ATmega32L auf 12 MHz sein? MfG
-
Thread
Nach fast 3 Jahren fehlerkorrigiertes Datenblatt für die AVR-DB Serie erschienen
Client. https://ww1.microchip.com/downloads/aemDocuments/documents/MCU08/ProductDocuments/DataSheets/AVR128DB28-32-48-64-DataSheet-DS40002247A.pdf
Nun gibt es schon die AVR_DU-Datenblätter: AVR64DU-28-32-Prelim-DataSheet-DS40002548.pdf AVR32-16DU-14-20-28-32-Prelim-DataSheet-DS40002576.pdf
-
Thread
AVR VS1011 MP3-Daten richtig senden
schwingt also? Erster Versuch (Library von Daniel R. siehe: http://www.mikrocontroller.net/articles/AVR_FAT32: [c] void Play() { unsigned char file_name[20]="test mp3"; if(MMC_FILE_EXISTS == ffopen(file_name)) { //geht super uputs((unsigned char*)"Datei exisitert!\n"); // setzen
test.mp3" nicht. Verwendetder Code: [c] struct fat16_file_struct* fd = open_file_in_dir(fs, dd, "test.mp3"); uint8_t buffer[32]; if(!fd) { //hier landet er immer, fs und dd wurden korrekt zugewiesen uputs("Datei nicht gefunden!"); return; } [/c]
-
Thread
AVR "ret" springt zu 0x00
000004DB POP R29 Pop register from stack 000004DC POP R28 Pop register from stack 000004DD RET Subroutine return[/avrasm] Nach 0x4DD wenn ich mit F10 ein Step Over mache springt der AVR auf 0x00: [avrasm]--- No source file ----------------------------------------------------------
// Filter 0 0,0,0,0, //MCP2515_FILTER(0x000), // Filter 1 // Group 1 32,0,0,0, //MCP2515_FILTER(CAN_WHO_IS_ONLINE), // Filter 2 32,0,0,0, //MCP2515_FILTER(CAN_WHO_IS_ONLINE), // Filter 3 32,0,0,0, //MCP2515_FILTER(CAN_WHO_IS_ONLINE), // Filter 4 32,0,0,0
-
Thread
Digitaluhr mit geringem Stromverbrauch
Beim Ali gibt es > diese LCDs auch mit 6 Stellen (du wolltest gerne 6 Stellen?). Und statt > des AVR128DA48 nimmst du einen AVR128DA64 damit du mehr IOs für das > Display hast. Die Platine musst du natürlich neu machen. Sehe ich das richtig, dass der avr128da64 zwar mit 3V läuft, aber dann auf
nicht unterstützt. Du kannst ihn aber mit anderen Programmen verwenden, z.B. avrude und als GU dazu AVR8 Burn-O-Mat oder Avrdudess. Dazu brauchst du den libusb Treiber. Anleitung: http://stefanfrings.de/avr_tools/index.html#avrdude
-
Thread
8 Kanal 50Ms/s AVR Logic-Analyzer
Hallo, wer ein Ram im SDIP sucht, kann auch den CY7C199C-15 (32kx8) nehmen, den U. Radig http://www.ulrichradig.de/ in seinem AVR-DSO eingesetzt hat. (Kostet in seinem Shop ~5€)
auch) Version. Man kann natürlich auch bei der Mega16 Version einen 74ACT161 mehr reinlöten und 32k Ram nutzen, die Anpassungen in der AVR-Software sind minimal, der PC-Software ist es egal. Die will nur den maximalen Takt und die Speichergröße vom AVR mitgeteilt bekommen. Es ist keine vollständige
-
Thread
SD - Karte compile Probleme
Files für mehrere µC Typen geschrieben. ->if difines (Präprozessoranweisungen) #if defined (__AVR_ATmega32__) #define USR UCSRA #define UCR UCSRB #define UBRR UBRRL #define EICR EICRB #define USART_RX USART_RXC_vect #endif Es existiert nur eins fürn MEGA32 und keins
Ok, SRAM ist jetzt zu wenig MEGA32 muss her^^ Reichelt: http://www.reichelt.de/?;ACTION=3;LA=4;GROUP=A363;GROUPID=2959;ARTICLE=45026;START=0;SORT=artnr;OFFSET=16;SID=31SoNsr6wQAR8AAE5kr3Uf99c79dd8bb35dcc037a8602701397c6 war da
-
Thread
MCURSES - Mini Curses Bibliothek für Mikrocontroller
. schrieb im Beitrag #3875528: > Schau mal nach Uwe Bergers Basic Interpreter, den er bereits auf AVR, > XMC2GO und STM32F4xxx portiert hat: > > Beitrag "Basic-Interpreter auf einem AVR" > Beitrag "uPlay Basic Interpreter per XMC2Go" > Beitrag "Basic Editor und Interpreter auf dem STM32F429
#3879142: > Die Library sieht interessant aus, etwas störend sind IMHO die fest im > Code hängenden AVR-Eigenheiten [...] Wieso stören sie Dich? Unter Linux oder SDCC für Z80 (oder demnächst für STM32F4) werden die AVR-Spezifika doch komplett weggeblendet. > und die Lizenz. Die GPL ist denkbar
-
Thread
Wie Zahl subtrahieren, die in 4 Registern steht?
In 4 registern ? Eine 32 bit Zahl ? Also, es gibt SUB, SBC, SUBI, etwa. Damit kann man alles machen. Was soll denn genau gemacht werden ? Unsigned32 - konstante32 unsigned32 - konstante16 Unsigned32 - unsigned32 unsigned32 - signed32 unsigned32 - unsigned16 unsigned32 - signed16 unsigned32 - unsigned8 unsigned32 - signed8
-
Thread
stm32f103c8 lässt sic nich flashen
Habe dieses board - http://www.ebay.de/itm/1-2-5-10Stks-STM32F103C8T6-ARM-STM32-Minimum-System-Development-Board-Module-/272425764978?var=&hash=item3f6dd74872:m:mrAOyKktZjIFkrwmEnoO1Mg - vergeblich versucht mittels St-Link V2 zu flashen. Fehlermeldung coide
verwende inzwischen hauptsächlich AVRs und STMs, früher LPCs. Sind alle gut. zur Zeit Mega328 und STM32F103C8, weil man da ohne Rücksicht auf das 3€-board alles ausprobieren kann. Ich verwende noch winAVR und Coide. studio ist mir zu nervig. Cube weiß ich nicht. LPCXpresso war sicher besser als coide -
-
Thread
Welcher µC für Hobbyzwecke?
Beitrag da gelesen habe. UNd mit den Interrupts gibts da wohl auch Probleme. Oder hat sich das mit dem AVR32 32-bit MCU/DSP geändert? An dem wäre ich dann nämlich sehr interessiert. Philipp Karbach wrote: > bist du fan von asm oder c? bei C würd ich dir nen ARM7/9 empfehlen da > kommst du sicherlich
Hersteller kommen ohne aus und verkaufen dennoch ihre Chips. Im 8 BIT Bereich kannst du auf die AVR's sowie hunderter 8x51 Derivate wählen. http://www.keil.com/dd/search_parm.asp Sehr schöne 8x51 Derivate findest du hier: http://www.silabs.com/tgwWebApp/public/index.htm 16 BIT, dann schau
-
Thread
Erste Schritte mit ARM SAMD20
Firmware ist der Bresenham-Algorithmus, also 32-Bit-Integer-Additionen und -Subtraktionen. Der braucht nach wie vor rund 300 CPU-Takte. Lediglich der 32-Bit-Timer hat etwas gespart, der wird auf AVR mit einem 16-Bit-Timer emuliert, was einige Takte
drunter mit GCC 4.8.4 mit CMSIS 4.2.0. Aktuell wäre 4.8.5, 4.9.3 oder 5.2 und CMSIS 4.3.0. Für den AVR ist es GCC 4.8.1 und für AVR32 gar 4.4.7. Also der Zoo an Tools wird doch eigentlich immer bunter, obwohl vieles davon GCC ist.
-
Thread
Schrittmotorsteuerung mit Atmega8?
>Das ist mit diesem Controller im gegensatz zu einem AVR noch loesbar. Was man hier alles ertragen muß! Heute ist der 1. Dezember und nicht der 1. April! Ein Atmega8 reicht für einen Motor; besser ist es, einen AVR zu nehmen, bei dem mehrere 16bit Timer
, y0); while(x < y) { if(f >= 0) { y--; ddF_y += 2; f += ddF_y; } x++; ddF_x += 2; f += ddF_x + 1; setPixel(x0 + x, y0 + y); setPixel(x0 - x, y0 + y); setPixel(x0 + x, y0 - y);
-
Thread
AT32 UC3 Beispielschaltung
eine klasse Alternative und auf jeden Fall leistungsstark. Ich würde trotzdem gerne mal mit einem 32 bit Modell arbeiten. der AT32 UC3B0256 sieht vielversprechend aus. http://www.reichelt.de/Atmel-AVR32-Controller/AT32-UC3B0256/index.html?;ACTION=3;LA=444;GROUP=A367;GROUPID=5378;ARTICLE=115704;START
schrieb im Beitrag #2609141: > Nach dem studieren des Datenblattes bin ich nun etwas verwirrt da der 32 > bitter schon ein bischen anders ist. Ich brauche nur einen kleine > Anstoss wie ich ihn verbauen kann. Atmel AVR32768: 32-Bit AVR UC3 C Series Schematic Checklist http://www.atmel.com/Images/
-
Thread
AVR Bootloader
Hier noch die Meldungen: AVRASM: AVR macro assembler version 1.77.3 (Dec 20 2006 14:29:41) Copyright (C) 1995-2005 ATMEL Corporation Creating 'M32BOOT.hex' Assembling 'M32BOOT.ASM' Including 'm32def.inc' Including 'bootload.h
output vom assembler. lg, thomas <------------------- snip ------------------> AVRASM: AVR macro assembler version 1.77.3 (Sep 21 2005 08:43:03) Copyright (C) 1995-2005 ATMEL Corporation Creating 'm32boot.eep' Creating 'm32boot.hex' Creating 'm32boot.lst' Assembling 'm32boot.asm
-
Thread
Pollin - Receiver-Mainboard mit Twin DVB-[T,C] Tuner, NXP PNX8950EH
JTAG ohne LPT Arduino JTAG "cable" http://www.dd-wrt.com/phpBB2/viewtopic.php?t=69441&highlight=arduino http://hsb.wikidot.com/arduino-jtag-finder-workshop http://deadhacker.com/2010/02/03/jtag-enumeration/ avr_jtag http://hg.assembla.com
Statt einer primären Partition hat sie gleich am Anfang eine erweiterte Partition in der sich 2 FAT32 Partitionen befinden. Ähnlich war die CF-Karte in der Thomson IP1001 für WinCE 5.0 formatiert. Ein clonen der CF-Karte war nur mit dd (Linux) möglich. Wer also eine originale Platte hat, sollte diese
-
Thread
Lastkapazität Quarz
Hallo Peter, >Ich habe mir die AppNote "AVR042: AVR Hardware Design Considerations" >durchgelesen. Wenn ich das richtig verstehe hat die Kapazität keine >Auswirkung auf die genauigkeit also lieber 15 nehmen weil nur zuwenig >Kapazität in dem
pF benutzen können sollte, zumal 18 pF ja gut im "recommended range" für die Lastkondensatoren im AVR-Datenblatt liegen. Bei den 32-kHz-Quarzen hieß es früher immer, man bräuchte keine externen Kondensatoren, aber darauf würde ich mich nicht verlassen. Gerade bei ATmega128 gab es wiederholt Berichte
-
Thread
(dauerhaft) aktuelle Toolchain
/files/avr-gcc%20snapshots%20%28Win32%29/ Ist eine Toolchain mit avr-gcc 6.1.1, ist aber ohne make & Co. Dafür läuft diese mit WinAvr 4.18 - jedenfalls bis Win7.
Frank M. schrieb im Beitrag #4754696: > https://sourceforge.net/projects/mobilechessboar/files/avr-gcc%20snapshots%20%28Win32%29/ > > Ist eine Toolchain mit avr-gcc 6.1.1, ist aber ohne make & Co. Dafür > läuft diese mit WinAvr 4.18 - jedenfalls bis Win7. Wenn man für Kunden was macht finde
-
Thread
Endian Formate
Der AVR verwendet die 'little endian' Byteorder. http://de.wikipedia.org/wiki/Little_Endian Bei einem 32Bit Speicherzugriff würde dein 0xA1 im ersten Byte stehen. Die anderen sind 0. Ein Beispiel für eine 32Bit Variable: Byte 1. 2. 3. 4. 0xAABBCCDD -> 0xDD 0xCC 0xBB 0xAA
-
Thread
EEprom AVR-DA (avr128da32)
Wilhelm M. schrieb im Beitrag #6563471: > Zumindest funktioniert Code für den mega4808 auf dem avr128da32 nicht > mehr korrekt. Warum sollte er auch? Ist ja ein anderer uC.
Eine template-spezialisierung weiter hat die DA/DB/(DD) nun wieder dieselbe Schnittstelle ;-) Schade nur, dass die avr-libc auch an dieser Stelle veraltet.
-
Thread
Merkwürdigkeit Pollin Entwicklungsboard ATMEL ATmega168PA
mich jetzt bitte nicht wo, ich meine es aber irgendwo gelesen > zu haben. In irgendeinem STM32-Datenblatt?
möchte mich aber mit dem Konzept hinter "Arduino" nicht beschäftigen, einfach den MC auf Standard AVR rücksetzen. Den Ext. Crys. Osc. 8MHz. aber benutzen. Würde ich den MC abschießen, wenn ich die Fuses von Pollin lxhxe von FF:DD:F8 auf 7F:DF:F9 setzen würde? Gruß Markus
-
Thread
uClock - Matrix-Uhr mit WS2812 LEDs
und einen kleinen AVR zur Ansteuerung der LEDs nimmst? Ich meine es ist viel einfacher, als die Parameteraustauscherei und dieses Protokoll zwischen ESP8266 und dem STM32. Den AVR könnte man mit SPI ansteuern oder I2C wobei
=new#6097851 https://www.mikrocontroller.net/topic/488417 Ich arbeite daher gerade an einer STM32F303CCT6-Portierung für die WodClock24. Zum Test habe ich mir folgendes Black-Pill bestellt: https://robotdyn.com/stm32f303cct6-256-kb-flash-stm32-arm-cortexr-m4-mini-system-dev-board-3326a9dd-3c19
-
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
Ralph S. schrieb im Beitrag #4669687: > Im AVR wäre das so nicht ein Problem, weil ein 8 Bit breit, bei einem > ARM dieses jedoch 32 Bit breit. Genau das ist deinen Chance, hatte nur keine Zeit mehr, zu editieren. Der ARM ist nativ 32 bit breit
-
Thread
MMC/SD Karte: mmc_lib Version 2.0
die Karte kopiert und mir auch den Karteninhalt als Rohdaten von der Karte kopiert (mit dem Befehl dd unter Linux ;)). Wenn ich nun per AVR lesen möchte, kriege ich aber nur andere Daten (Schrott) raus. Initialisierung der MMC geht einwandfrei, die CID und CSD kann ich auch problemlos auslesen. Der
, aber bei WinAvr scheint man für die 32bit ja einen unsinged long long zu brauchen...komische Sache. Ich dachte mir immer: char - 8 bit short - 16 bit long - 32 bit long long - 64 bit Naja, scheint nach
-
Thread
bidirektionale RS232 Funkbrücke mit RFM12
: Impulsgeber -> Atmega32 -> RFM12 ........ RFM12 -> Atmega32 -> Servo In wie weit kann ich die rf12.c / .h nutzen bzw. was müsste ich in der rf12.c / .h anpassen um diese getrennt nutzen zu können? Danke schonmal, Ralf
Pollin Funk-Avr-Evulationboard V1.20 * RFM12 mit 17cm-Draht-Antenne * Atmega32 mit 16 MHz-Quarz Änderungen in den Dateien rfm12_rs232_rxtx_check5.zip: main.c ====== CPU-Frequenz - #define F_CPU 10000000UL
-
Thread
STM32F4Discovery und TLC5940
zusammen, ich versuche aktuell einen TLC5940 (16 Kanal LED-Treiber mit 12 Bit PWM) an einem STM32F407VG (STM32F4Discovery-Board) zur laufen zu bekommen. Der TLC5940 ist grundsätzlich folgend zu betreiben: 1. Er braucht einen externen Takt für die PWM (GSCLK). Alle 4096 Ticks muss die PWM zurückgesetzt
MHz-Speed }; . . . palSetPadMode(SPI2_SCLK_PORT, SPI2_SCLK_PIN, PAL_MODE_ALTERNATE(5) | PAL_STM32_OSPEED_MID2); palSetPadMode(SPI2_MOSI_PORT, SPI2_MOSI_PIN, PAL_MODE_ALTERNATE(5) | PAL_STM32_OSPEED_MID2); palSetPadMode(SPI2_CS_PORT, SPI2_CS_PIN, PAL_MODE_OUTPUT_PUSHPULL | PAL_STM32_OSPEED_MID2)
-
Thread
RIP AtmelStudio
? Eagle und AVR sind einfach nur sowas von Stand 2000. Nimm doch einfach KiCad und STM32 :)
einsetzen, wenn man doch den avr-gcc hat? > Das ist dann wohl das Ende vom AVR :-( Ich habe AVR-Studio noch nie benutzt sondern avr-gcc und make. Das wird immer funktionieren.
-
Thread
AVR-GCC Bibliothek für SD-Card, welche ist geeignet?
lseek.html reinschauen. Die Library benutze ich mit guten Erfahrungen selbst, allerdings nicht mit AVR.
ein Disk-Optimizer, um die SD wieder für AVR vorzubereiten.
-
Thread
I2C Kein ACK :-(
baud #define BAUDRATE ((F_CPU)/(BAUD*16UL)-1) #define SCL_CLOCK 100000 //100 kHz #include <avr/io.h> #include <util/delay.h> #include <util/twi.h> #include<stdbool.h> #include "USART.h" #include <avr/io.h> void I2C_sende(int daten) { TWDR = daten; TWCR = (1<<TWINT) | (1<<TWEN);
} I2C_sende(adresse); } void I2C_init(void) { DDRC &= !((1<<DD0)|(1<<DD1)); PORTC = (1<<DD0)|(1<<DD1); TWSR = 0; /* no prescaler */ TWBR = ((F_CPU/SCL_CLOCK)-16)/2; /* must be > 10 for stable operation */ } int main
-
Thread
Stack Überschreiber beim Rechnen mit uint64_t
64-Bit PeDa: *4,600ms* 2) Als Kettenbruch-Entwicklung benötigt die Berechnung des FTW mit 32-Bit Zahlen: 32-Bit Kettenbruch: *4,447ms* Hier der Code [c] const uint32_t freq32 = F_MHZ(10); uint32_t ftw32 = 0; start_t1_counter(); ftw32 = freq32 * 24ul; ftw32 -= freq32 / 7ul; ftw32 += freq32 / 264ul; ftw32 -= freq32 / 761203ul; stop_t1_counter(); [/c] 3) Matthias Hopf hat auch eine 64-Bit Lib geschrieben - http://www.mshopf.de/proj/avr/uint64_ops.html Damit ist
-
Thread
EMS > Adapter > NetIO > Raspi
des Projektes belaufen sich, Stand 12.2013, auf ca.: Adapterplatine 6,00 € selbst gefertigt AVR-NetIO 20,00 € Pollin Bausatz ATmega644P 5,00 € Ersatz für ATmega32 RaspberryPi 39,00 € Modell B SD-Card 16 GB 10,00 € für Raspi Netzteil 5,00 € 5V,
Olaf. Es ist das Experimentierboard von Ulrich Radig http://www.ulrichradig.de/home/index.php/avr/eth_m32_ex Ist der zweite usart hier entscheidend?
-
Thread
Problem mit Interrupt
Zur Hardware: Verwende einen Atmega 16 Zum Problem: Anscheinend macht der mir auch aus einem int32_t immer eine 16bit Variable. Damit überläuft selbige und fängt bei - wieder an. Wie kann ich mit AVR-GCC und dem ATmega 16 eine 32Bit Variable nutzen oder ist dies vielleicht sogar gar nicht möglich
Natürlich kannst du 32-bit-Variablen nutzen. Aber: int ist beim avr-gcc nunmal nur 16 bit, und itoa ist so definiert: http://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html#ga4f6b3dd51c1f8519d5b8fce1dbf7a665
-
Thread
WordClock mit WS2812
richtig sparsam. Außerdem kann man die Übertragungsgeschwindigkeit selber wählen. Dabei kanns mit dem STM32 auch erheblich flotter sein als beim WS2812-Protokoll. Ein langsamerer Prozessor wie ein AVR kann die Dinger aber trotzdem noch in gemächlichem Tempo ansteuern, um nicht ins Schwitzen zu kommen. Fazit
online 08:32:32.039: --> time "192.53.103.103"<0d><0a> update display 08:32:32.054: (OK time) 08:32:41.412: update display 08:33:23.175: (- new client) (HTTP GET /) http path: '/' http parameters
-
Thread
AVR und großer Speicher
sollen mit 40kHz rausgehen, deshalb fällt eine SD >Karte via SPI wohl flach. Wer sagt das? Ein AVR @ 16 MHz kann mit 8 Mbit/s die Daten aus der SD-Karte ziehen, macht 1MB/s. OK, der Overhead für FAT32 kommt hinzu, und der ist relevant. Aber 40kB/s schafft auch ein AVR. >Meine Idee wäre jetzt mit
original Code. Ich weis - boese gehackt. Achja, basiert auf: http://www.mikrocontroller.net/articles/AVR_FAT32 (Lediglich der Dateikram ist entfernt, und Sequenzlesen ist korrigiert/ergaenzt) MfG
-
Thread
Günstige Microcontroller für Privat Projekte
Nimm nen AVR, der tuts am einfachsten.
-3326a9dd-3c19-11e9-910a-901b0ebb3621.html, 5,00€) Groß 32bit: STM32F103VET6 Minimum System Development Board (9,00€) Und für den Anfang zum Ausprobieren empfehle ich ebenfalls die Nucleo-64 Boards von ST.
-
Thread
Grafikfähiger LCD Controller für 320x240 LCD mit 4 Graustufen
3*32KByte für 640*480? Das stimmt aber nur für Graustufen. Und da wär ich mir nicht sicher, ob das noch vernünftig aus nem AVR zu holen ist. Lass mich aber auch gerne vom gegenteil überzeugen. Wieso nicht
Sebastian schrieb: > 3*32KByte für 640*480? Das stimmt aber nur für Graustufen. Und da wär > ich mir nicht sicher, ob das noch vernünftig aus nem AVR zu holen ist. > Lass mich aber auch gerne vom gegenteil überzeugen. Müsste
-
Thread
8h Timer mit attiny85 - Genauigkeit ohne Quarz
lange auf PIC gekuckt. Aber diese zwei Sachen, gebankte SRAM und teure Compiler - das hält mich bei AVR. Wenn schon zu wechseln, dann lieber gleich auf STM32. Auch kostenlose Compiler und frei zugängliche (und auch viel größere) RAM. Wenn AVR nicht mehr reicht. Übrigens, hier hat man noch eins bei
CTC mode Table 11.5 TCCR0B |= (1 << CS00);// Prescaler table 11.6 OCR0A=121; //CTC Compare value 32,786885 khz, 0.0576% error , 243 on 16mhz ! } void loop(){ } [/code] sowie ein Code zur Kalibration z.B. diesen hier: [code] #include <avr/io.h> #include <util/delay.h> #include <avr
-
Thread
LCD Problem mit blafusel´s Routinen
Wahl. Die meisten kommen wohl damit halbwegs zurecht: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/LCD-Ansteuerung
D7 * R/W ist n.c. * * 03/2005 Florian Schäffer, http://www.blafusel.de * */ #include <avr/io.h> #include <avr/delay.h> #define delay(us) _delay_loop_2 (((F_CPU/4000)*us)/1000) // wartet µs void lcd_write_init(uint8_t data) { PORTC = (data>>4); // output
-
Thread
STM32 Umfang
d.h. statt [c] // 64 MHz using the 8 MHz/2 HSI oscillator with 16x PLL, lowspeed I/O runs at 32 MHz WRITE_REG(RCC->CFGR, RCC_CFGR_PLLMULL16 + RCC_CFGR_PPRE1_DIV2); // Enable PLL SET_BIT(RCC->CR, RCC_CR_PLLON); [/c] kann man auch ganz einfach (ähnlich beim AVR) schreiben: [c] // 64
können dann genau so wie die stm32f103xx.h aussehen ohne die Tastatur komplett abzunutzen. Die sind m.W. in den Device Packs enthalten: https://www.keil.com/dd2/pack/ https://www.keil.com/cmsis/svd Wenn man es schon selbst macht
-
Thread
DCF77 Selbstbauempfänger
Empfangsstufe: Am besten für eine Empfangsstufe hat sich die aktive Antenne mit seriellen Quarz von DD7YB gemacht. Hier der Link zu der Internetseite von DD7YB wo es auch Bilder von seinem Frequenznormal gibt, wo die aktive Antenne Funktion fand und es auch den Download der Schaltung gibt. http://www.dd7yb.de
das in der Software statt eines AM Demodulators ein FSK Demodulator drin ist. Der Vorteil des STM32 gegenueber einem AVR ist das er: 1. Schneller ist 2. ADCs mit 12 Bit Aufloesung besitzt, also einen grossere Dynamikumfang im Empfangssignal verarbeiten kann. 3. 2 Stueck ADC drinne hat die gleichzeitig
-
Thread
Hackbarer(?) 21 EUR Quadcopter
No y. schrieb im Beitrag #3365954: > Keil gibt es bis 32Kb kostenlos. reicht also für den Quadrocopter. Weiß > nur nicht ob Keil auch die Nuvoto drin hat. Oh, da hatten wir den gleichen Gedanken. Keil kennt den Controller: http://www.keil.com/dd
sind die Anschlussbezeichnungen. http://www.ebay.de/itm/2-4G-Wireless-Module-FSK-BK2423-Atmega-AVR-Arduino-UNO-R3-SPI-MCU-ARM-C51-STM32-/271139012729 Edit: Sorry, ich war zu schnell. Das Ebay-Modul hat nur 8 Anschlusse.
-
Thread
Verständnisfrage PWM mit AVR
braucht man 26MHz Takt. Das können nur die Xmega oder ggf. die > noch neueren AVRs, welche bis zu 32 MHz schaffen. Verstehe ich nicht ? Warum diese hohe Taktrate für 6,5 kHz ? Falk B. schrieb im Beitrag #7772758: > Dort liegt also das Problem. Naja, dann wird es schwierig. Welchen AVR > willst
PLL) https://ww1.microchip.com/downloads/aemDocuments/documents/MCU08/ProductDocuments/DataSheets/AVR64DD32-28-Complete-DataSheet-DS40002315.pdf
-
Thread
KS0108 GLCD Routinen
Hallo, hat schonmal jemand diese lib auf einem mega32 1MHz(auslieferungszustand)am laufen gehabt? Bei mir funktioniert das Testprogramm leider nicht und ich habe die Hardware schon mehrfach überprüft. Im Anhang mein AVR-Studio Projekt ( Habe da eigentlich
von Ape aus seinem ersten Post(also die Urlib(für mich als Anfänger reichts)) auch auf meinen Atmega32 laufen, nur leider sieht das das Display so aus wie im angehängten Bild. Hier mal mei n Quellcode vom main.c [c] #include <avr/io.h> #include <avr/pgmspace.h> #include <avr/delay.h> #include