-
Thread
Ergebnisse einer FFT zusammen fassen
5,0 , 6: 6,3 , 7: 8,0 , 8: 10,1 , 9: 12,7 , 10: 16,0 , 11: 20,2 , 12: 25,4 , 13: 32,0 , 14: 40,3 , 15: 50,8 , 16: 64,0 , 17: 80,6 , 18: 101,6 , Das sind dann 483 Punkte und man kann Frequenzen noch etwas verschieben, sodass man die äußersten 2 weglassen kann, (nicht bei
cos(2*pi*12/64)+j*sin(2*pi*12/64) b1 = 0 + j*1 [/code] [c] void df2_biquad_goertzel_1(float32_t* x, float32_t* y, uint32_t N) { float32_t stateA = 0; float32_t stateB = 0; float32_t stateC = 0; float32_t y_power = 0; float32_t y_magnitude = 0; // N = 64; // m = 12;
-
Thread
Uhr mit 32,768Khz Quarz
in der Schaltung verlöte die Frage. Sollte so was mit einem 32,768KHz gehen?
Hallo! Also wie es beim PIC genau ist, kann ich dir jetzt auch nicht sagen, da ich bisher nur AVR programmiert habe. Aber für gewöhnlich nimmst du den 32khz Quarz nicht als Taktgeber für den kompletten Chip, sondern nur als TAktquelle für einen Timer. Beim AVR gibts da für einen Timer den asynchronen
-
Thread
Rampenberechnung Schrittmotor
#3657845: > macht > die Anzahl der Tabelleneinträge ausreichend groß (z.B. 10.000). Auf einem AVR mit 8kB RAM? :-)
r19,r24 ; D.2042, D.2042 mov r20,r25 ; D.2042, D.2042 clr r21 ; D.2042 movw r24,r14 ; , D.2042 movw r22,r12 ; , D.2042 call __mulsi3 movw r18,r24 ; D.2042, D.2042 clr r20 ; D.2042 clr r21 ; D.2042 movw r24,r14 ; , D.2042 movw r22,r12 ; , D.2042
-
Thread
C++ Klassenbibliothek für AVR
Der Index ist jeweils die Arduino Pinnummer // UNO, Nano, Pro Mini usw. #if defined(__AVR_ATmega328P__) | defined(__AVR_ATmega328__) | defined(__AVR_ATmega168P__) | defined(__AVR_ATmega168__) constexpr uint8_t portBit[] = {0,1,2,3,4,5,6,7,0,1,2,3,4,5,0,1,2,3,4,5}; constexpr uint8
PINC,&PINC,&PINC,&PINC,&PINC,&PINC}; // #endif // Leonardo, Micro, usw. #elif defined(__AVR_ATmega32U4__) constexpr uint8_t portBit[] = {2,3,1,0,4,6,7,6,4,5,6,7,6,7,3,1,2,0,7,6,5,4,1,0}; constexpr uint8_t pinMaske[] = {0b100,0b1000,0b10,0b1,0b10000,0b1000000,0b10000000,0b1000000,0b10000,0b100000,0b1000000,0b10000000,0b1000000,0b10000000,0b1000,0b10,0b100,0b1,0b10000000,0b1000000,0b100000,0b10000,0b10,0b1
-
Thread
wiedereinstieg mit avr programierung
In was programmierst du denn? AVR Studio?
habe nun winAVR versucht. Geht auch nicht auf meinem PC
-
Thread
AVR-gcc und Bitfelder
Übersetzst du beim AVR mit -Os ?
Klafft schrieb im Beitrag #1777940: > Da ich unter SUSE Linux arbeite, möchte ich mir auch kein WinAVR > installieren. WinAVR ist doch AVR-GCC, das ändert doch nix... Verstehe ich das eigentlich richtig, Du möchtes *PMSMflags_t fastFlags* ständig in einem Register stehen haben?
-
Thread
CAN-Sender im Mini-Format
Eine weitere Möglichkeit wäre das Olimexino-STM32: https://www.olimex.com/Products/Duino/STM32/OLIMEXINO-STM32/open-source-hardware Nicht die kleinste Variante, dafür aber geringer Aufwand, weil alles schon fertig aufgebaut ist (Mikrocontroller mit
Dr. Sommer schrieb im Beitrag #5495474: > Eine weitere Möglichkeit wäre das Olimexino-STM32: > https://www.olimex.com/Products/Duino/STM32/OLIMEXINO-STM32/open-source-hardware > Nicht die kleinste Variante, dafür aber geringer Aufwand, weil alles > schon fertig aufgebaut ist (Mikrocontroller
-
Thread
AVR C implizite Typkonvertierung, fehlerträchtig oder falsch?
%0Avolatile+uint32_t+timer%3B%0Auint32_t+millis(void)+%7B+return+timer%3B+%7D%0A%0Avoid+delay_1(void)+%7B%0A++++uint32_t+timeout+%3D+millis()+%2B+1000%3B%0A++while+(+(int32_t)(timeout+-+millis())+%3E+0)%3B%0A%7D%0A%0Avoid+delay_2(void)+%7B%0A++uint32_t+start_time+%3D+millis()%3B%0A++while+(+(uint32_t)(millis()+-+start_time)+%3C+1000)+%3B%0A%7D%27),l:%275%27,n:%271%27,o:%27C+source+%231%27,t:%270%27)),k:50,l:%274%27,n:%270%27,o:%27%27,s:0,t:%270%27
-
Thread
Induktiver Positionssensor - Fragen dazu
diese, aus dem Video: https://www.youtube.com/watch?v=fPGsmCLoN_Y [c] // Simple I2C test for 128x32 oled. // Use smaller faster AvrI2c class in place of Wire. // Edit AVRI2C_FASTMODE in SSD1306Ascii.h to change the default I2C frequency. // #include "SSD1306Ascii.h" #include "SSD1306AsciiAvrI2c.h
, vollkommen problemlos. Frank O. schrieb im Beitrag #7640101: [c]> // Simple I2C test for 128x32 oled. > // Use smaller faster AvrI2c class in place of Wire. > // Edit AVRI2C_FASTMODE in SSD1306Ascii.h to change the default I2C > frequency. > // > #include "SSD1306Ascii.h" > #include "SSD1306AsciiAvrI2c.h
-
Thread
LCD, HD44780 und KS0076
library Author: Peter Fleury <pfleury@gmx.ch> http://jump.to/fleury File: $Id: lcd.c,v 1.14.2.2 2012/02/12 07:51:00 peter Exp $ Software: AVR-GCC 3.3 Target: any AVR device, memory mapped mode only for AT90S4414/8515/Mega DESCRIPTION Basic routines for interfacing a HD44780U-based
__) || defined(__AVR_ATmega162__) /* * memory mapped mode is only supported when the device has an external data memory interface */ #define LCD_IO_DATA 0xC000 /* A15=E=1, A14=RS=1 */ #define
-
Thread
Bildkompression mit 8-Bit AVR LZSS + Huffmann
2)Substitutionskompression LZSS sollte auch mit kleinem Wörterbuch laufen. Es gibt auch eine AVR implementierung: http://spin.atomicobject.com/2013/03/14/heatshrink-embedded-data-compression/ 3)Entropiekodierung Also Huffmann Dekompression gibt es ja schon: https://www.das-labor.org/wiki/
. Sollte zur Bildverarbeitung wesentlich besser geeignet sein als ein AVR... Mit dem STM32F407-Discovery-Board kriegst du den bereits einsatzbereit verlötet inkl. Debugger/Programmer für < 20€. Das STM32F429-Discovery-Board hat sogar ein Touch-LCD und 8 MByte SDRAM mit
-
Thread
welches LCD passt zum LCD Tutorial
vieleicht Erfahrungen mit diesem interessanten Tutorial??? http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#LCD-Ansteuerung Ich möchte für mein kleines Projekt ein LCD ansteuern. Es soll aber nicht mehr Arbeit machen als bis her. LCD (Zeilen x Zeichen 4x20). Controller (ATmega32) Kann
------------ - Anfänger Verdrahtung : ----------------------------------------- ATMEGA32 : ---------- 1 Vss GND 2 Vcc 5V 3 Vee GND 4 RS PD4 5 RW GND 6 E PD5 7 DB0 offen 8 DB1 offen 9 DB2 offen 10 DB3 offen 11 DB4 PD0 12 DB5 PD1 13 DB6 PD2 14 DB7
-
Thread
lpcxpreeso SystemFrequency LPC1768
vom Interrupt erhöht wird. Der Vergleich kostet Zeit. Dazu rechnest du mit 64bit Variabel auf einen 32bit Prozessor. Hier muss der Code auch immer einen Vergleich durchführen um die Inkrementierung zu überprüfen, ob es keinen Überlauf einer 32bit Variabel gibt. Dieser Code auf einem AVR ausgeführt, würde
Vielen dank für die Tipps. Durch Austausch von 64bit gegen 32 bit steigt die "Tatktzahl" auf rund 14Mhz. Das gibt ein Verhältnis von 1:6 zur systemFrequency. Es geht mir um das Verständnis des PLLO-Systems. ich möchte im Prinzip sehen, wie sich die Änderung der
-
Thread
Neue STM32G Serie
@Anton troll dich! Die STM32G0 sind lötbarer als die STM32F4, denn deren 32Pin LQFP Gehäuse hat denselben Pinabstand wie ein AVR LQFP32 und keine 0,5mm. Und scher programmierbar? Für Trolle wie dich villeicht! @Markus Danke
Mw E. schrieb im Beitrag #5946259: > Die STM32G0 sind lötbarer als die STM32F4, denn deren 32Pin LQFP Gehäuse > hat denselben Pinabstand wie ein AVR LQFP32 und keine 0,5mm. Mag sein das ich falsch liege aber ich meine, dass alle STM32 im LQFP32
-
Thread
128x64 Grafikdisplay von Pollin
ich habe mein display über den parallelen anschluss laufen an einem avr. 12 leitungen habe ich zur verfügung. es fehlt mir noch reset und die buchstabenumschaltung (6 oder 8bit) für den avr. wo kann ich diese beiden leitungen anzapfen an der fertigen parallelplatine.
ich habe einen avr16 mit intern 8mhz. mfg pebisoft
-
Thread
leere funktion in c code ändert verhalten (attiny13)
user@pc$ avr-objdump -h -S progrm01.elf progrm01.elf: file format elf32-avr Sections: Idx Name Size VMA LMA File off Algn 0 .text 0000001e 00000000 00000000 00000074
r24 ; 24 10: ef ed ldi r30, 0xDF ; 223 12: fe e2 ldi r31, 0x2E ; 46 14: 31 97 sbiw r30, 0x01 ; 1 16: f1 f7 brne .-4 ; 0x14 <main+0xe> 18: 00 c0 rjmp .+0 ; 0x1a <main+0x14> 1a: 00 00 nop 1c: f6 cf
-
Thread
kein debugwire wegen USB-Problem?
------------------------ OS Version: Microsoft Windows NT 5.1.2600 Service Pack 3 Platform: Win32NT Installed Packages: Shell VSIX manifest - 6.1 Shell VSIX manifest Version: 6.1 Package GUID: 5aa6ea3e-da7b-48c1-9b2a-cab2329d32ac Company: Atmel Corporation Installed Packages: Atmel
Das http://homepage.hispeed.ch/peterfleury/avr-hvsp-fuse-restore.html dürfte der einfachste für den Tiny13 sein. Da geht auch Steckbrett :-) Da habe ich den Link her https://www.mikrocontroller.net/articles/AVR_HV-Programmer und dort
-
Thread
Kameraschaltung Philips DC3840
In http://www.ulrichradig.de/home/index.php/avr/eth_m32_ex verwendet er doch genau diese Kombination. Schau Dir doch mal die Software an.
Debuggen erst mal versuchen die RS232 von Hand zu programmieren. Eventuell auch schon mal den AVR gewechselt, nicht dass der defekt ist. Gruß Tom
-
Thread
LED-Treiber MAX6956 C-Code
wieso 7 Bit? 16*7 Bit = 112Bit 112Bit / 8 = 14 Byte ich schiebe also immer nur 14 Byte raus solange du die "Wand" mit einfarbigen LEDs machst, könnte das reichen, sollten es jedoch RGB werden, wird das ganze sehr knapp vom Timing her... Ich
allen anderen datein verläuft alles normal! Creating load file for EEPROM: MAXSteuerung.eep avr-objcopy -j .eeprom --set-section-flags=.eeprom="alloc,load" \ --change-section-lma .eeprom=0 -O ihex MAXSteuerung.elf MAXSteuerung.eep c:\Programme\Atmel\bin\avr-objcopy.exe: there are no sections
-
Thread
STM32 ST-Library Pro oder Kontra
[/c] und ebenfalls mit symbolischen Namen: [c] #define LED_PORT GPIOB->ODR #define PIN14 14 #define LED3 PIN14 GPIOB->CRH |= (GPIO_OUT_PUSH_PULL | GPIO_SPEED_2MHZ) << GPIO_CONF_BIT(LED3)); LED_PORT |= (1<<LED3); [/c] ;-) Besonderheit bei STM ist, dass du immer 4 Bits
ich das. Wie beispielsweise ein Treiber für UART, mit sehr ähnlichem Interface bei LPC2000, STR9, STM32. Ebenso CAN für AVR/MCP2515, LPC2000, PIC16, STM32. Das lohnt sich aber nur, wenn sich ein einheitliches Interface nach oben anbietet und die Varianz der Funktionalität der Hardware sich verbergen
-
Thread
Countdown für Brutautomat über mehrere Tag mit Bascom
du mit "Das geht über Division (/) mit >module (%) deutlich einfacher." meinst Man nimmt eine 32 Bit Variabel und zählt normal runter time32--; Wenn man dann was anzeigen will, rechnet man von der Sekundendarstellung in time32 in hh::mm::ss um Tag = time32 / (24 * 86400); Rest = time32
würde bei mir in Bascom jetzt so aussehen: [code] dim sekunden_schlupf32 as Long dim sekunden_schlupf32_ram as eram Long dim sekunden_rest as long [/code] [code] tage_bis_schlupf = sekunden_schlupf32 / 86400 sekunden_rest = sekunden_schlupf32 mod 86400 stunden_schlupf
-
Thread
ATmega48 Hardware-PWM - Zu kurzer Servoweg
kann ich Dir nicht sagen. Dies hier (auch Mega48) funktioniert präzise: http://www.hanneslux.de/avr/mobau/7ksend/7ksend02.html ...
kombinieren kann. >Ich habe jedoch vor, eine Hardware-PWM zu erzeugen. Gut, dafür ist Der Modus 14 des Timer 1 genau richtig. MFg Falk
-
Thread
M16C62 32kHz Quarz zu ungenau ?!
= 0xc0; // Timer mode, fc32, no pulse output ta0 = (int)(( 1023*.1)); <---------------------------------! // 32kHz Quarz (32768/32 = 1024 +/- einige Prozent
Du falsch gemacht. Ich hab gestern auch mal testweise eine RTC programmiert (mit 1Hz Timer), nach 14h ist noch keine Abweichung feststellbar. Zum Vergleich hab ich den AVR Butterfly mitlaufen lassen, der geht inzwischen knapp 1s vor. Also ist der Quarz auf dem SKP wohl ganz gut. :) Was benutzt Du
-
Thread
Attiny26-16PU startet Programm nicht
der Compiler hier nicht meckert ist natürlich übel. Aus https://github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring_digital.c findest Du ein [c] void pinMode(uint8_t pin, uint8_t mode) [/c] Das ist ein unsigned byte. Warum sollte der Compiler meckern? Bei den 32-bit-Core ist es ein uint32_t.
-
Thread
avrdude schreibt nur bis 64 byte in den flash-speicher
mehr posten ;-) > > richtig ist natürlich -v -v -v -v > > Sorry... [code] john@pc0815:~/avr/Beispielprogramme$ avrdude -c avr911 -p m8 -P /dev/ttyUSB0 -U flash:w:timer.hex:i -vvvv avrdude: Version 6.0.1, compiled on Oct 21 2013 at 15:55:32 Copyright (c) 2000-2005 Brian Dean, http
0d] avrdude: Send: E [45] avrdude: Recv: . [0d] avrdude done. Thank you. john@pc0815:~/avr/Beispielprogramme$ avrdude -c avr911 -p m8 -P /dev/ttyUSB0 -U flash:w:timer2.hex:i -vvvv avrdude: Version 6.0.1, compiled on Oct 21 2013 at 15:55:32 Copyright (c) 2000-2005 Brian Dean,
-
Thread
16-Bit-Zahl ausgeben, nur wie?
Bereich von -1 bis 1 und haben 1 Vorkommastelle und 15 Nachkommastellen. Siehe dazu auch AppNote AVR201 von Atmel: http://faculty.capitol-college.edu/~andresho/tutor/Multimedia/AVR/HW_mult/avr201.htm Momentan hab ich folgende C-Routine, die Teil einer printf-ähnlichen Ausgabefunktion ist (put_char2
über 500 Byte Programmcode. (Und ja, ich hab Optimierung aktiviert. Die Zahl bezieht sich auf avr-gcc und ATmega8) [c] void put_sfrac32 (int32_t frac) { if (frac < 0) { put_char2 ('-'); frac = -frac; } put_char2 ('0'); put_char2 ('.'); uint64
-
Thread
Lokalität von Registerwerten?
-----; ; Melody Generator (C)ChaN, 2005 .include "tn45def.inc" ;This is included in "Atmel AVR Studio" .include "avr.inc" .include "mg.inc" .def _0 = r15 .def _Sreg = r14 .def _Zreg = r12 .def _Yreg = r10 .def _TmrH = r9 .def _TmrL = r8 .def _TmrS = r7 .equ N_NOTE
63, 72, 80, 86, 89, 90, 89, 87, 84, 81 .db 79, 77, 75, 73, 72, 69, 66, 61, 55, 48, 39, 31, 22, 14, 6, 0 .db -5, -10, -14, -17, -20, -22, -24, -26, -28, -29, -30, -31, -32, -33, -34, -35 .db -36, -37, -39, -41, -44, -48, -52, -57, -63, -70, -77, -85, -94, -102, -110, -116 .db -121, -124,
-
Thread
ATmega328p: timestamp beim Flashen ohne Zusatzhardware? Gesperrt
Vorschlag. Beispielsweise in den Sockel zum Flashen auch noch den UART an den PC durchverbinden. Der AVR wird beim Startup prüfen, ob bereits eine Zeit im EEPROM steht, wenn nein: - AVR sendet per UART kurzen Befehl an den PC, wo ein kleines Programm läuft - PC antwortet mit Uhrzeit - AVR schreibt
ATMEL328P(4): Signature : 0x1E 0x95 0xF Serial Number : 0x55 0x35 0x35 0x30 0x34 0x33 0xFF 0x14 0x25 0x27
-
Thread
PIC 32 schneller Basic Interpreter
Micromite schrieb im Beitrag #3624743: > Geoff hat den schnellen Basic Interpreter in einem PIC 32 nach der > Betaphase nun öffentlich gemacht. Super, herzlichen Dank für den link. und Lass dir von den Miesepetern und den AVR Heinzis nicht den Tag versauen. Wenn Betriebsblindheit blaue Flecken
Gerade getestet: 32 Sekunden auf einem PIC32MX150 bei 48MHZ.
-
Thread
XMEGA-A1 Xplained - AT32UC3B1256 - probleme mit verbindung
wieder anzuzeigen ? mit batchisp bekomme ich offensichtlich noch kontakt: [code] batchisp -device at32uc3b1256 -hardware usb -operation blankcheck Running batchisp 1.2.5 on Sat Nov 03 14:28:56 2012 AT32UC3B1256 - USB - USB/DFU Device selection....................... PASS Hardware selection
neu-avr schrieb im Beitrag #2901593: > " batchisp -device at32uc3b1256 -hardware usb > -operation blankcheck " Hmm, falls das wirklich die CDC Bridge Software im Board Controller gekillt hat, sehe ich
-
Thread
Hex Wert -> Dezimal an LCD ausgeben
neue AVR-Typen) und bei meinen kleinen Programmen auch übersichtlicher. Ich hantiere übrigens mehr mit dem Tiny12/15 als mit dem Mega8/16/32. Reicht meistens für meine Projekte. Dies soll aber keinesfalls
Im Ordner Appnotes vom AVR-Studio findest Du in den Dateien avr200.asm und avr201.asm (nur für Megas) Divisions- und Multiplikationsroutinen welche Du verwenden kannst. Aber es geht auch anders. 5 / 1024 = 0,0049 mal
-
Thread
MCU mit 24-Bit-SPI?
Mouser hat angeblich 270 Stück PIC32MK0512GPK im TQFP-64.
RSPIc der Renesas RX Familie können das >Transfer bit length is selectable as 8, 9, 10, 11, 12, 13, 14, 15, 16, 20, 24, or 32 bits. Z.B. R5F565N7ADFP https://mou.sr/3Hxw1el Grüße
-
Thread
Baustein mit 8-Bit Register gesucht
-- ; max 8 Takte out output, akku ; 1 sei nop rjmp loop[/avrasm] Braucht nen AVR mit 2 vollständigen 8 bit Ports und die Bereitschaft so ein wirres Programmkonstrukt einzusetzen... Takt liegt dabei auf INT1 und reset auf INT0, der Mega32 sollte 20MHz noch schaffen ;) Martin H
könnte man auch nutzen kostet anstelle des sei... Alternativ könnte man auch den reset an reset vom AVR anschließen und den AVR mit dem X-fachen Takt takten wenn man eh taktsyncron zu einem System arbeiten will macht eine Flankenerkennung ja nicht unbedingt sinn
-
Thread
DCF-Uhr from Scratch
Mischer/Demodulation, an den ADC. 77,5 kHz ist jetzt keine Hochfrequenz, aber etwas schneller als der AVR-Arduino-ADC sollte der schon sein. (STM32, RP2040, ...) Rest ist Software.
die CPU zu stören. Also echte parallel Verarbeitung. Ich habe dann mal nach diesen Daten die STM32 gefiltert und dabei dann STM32H723 oder den STM32H743 gefunden. Beide sind auf Nucleo Boards für 30 bis 50€ erhältlich. Echte 16-bit ADC mit DMA, SMID und DSP, 16-bit DAC um einen OCXO zu führen.
-
Thread
schaltplan ok? (+/- 5v netzteil, verstärker regelung, userinterface)
Zum Ausräumen sind die ohnehin überflüssig, denn das macht der aktive Pulldown vom AVR-Ausgang schon selber.
#1730024: > Zum Ausräumen sind die ohnehin überflüssig, denn das macht der aktive > Pulldown vom AVR-Ausgang schon selber. Das ist natürlich richtig!
-
Thread
Wechsel vom zwei- zum vierzeiler HD44780
Controller ATMEGA32 mit 16Mhz (geprüft, funktioniert!) Code: --------------- [c] #define F_CPU 16e6 //INCLUDEs #include <avr/io.h> #include <util/delay.h> void rs (uint8_t wert) { if (wert == 1) PORTD
bei AM.... steht I2C serieller Anschluß -> d.h. Ansteuerung über TWI des A 32 ... bud
-
Thread
byte buffer in long konvertieren
So [pre] buf2num = foldl (\n b -> 2*n+b) 0 [/pre] oder so [c] uint32_t buf2num(uint8_t buffer[]) { uint32_t num = 0; uint8_t i; for(i=0; i<24; i++) num = 2 * num + buffer[i]; return num; } [/c] je nach Geschmack.
einfach so: > (1UL<<(23-j)); er testet eh auf einen windows PC. Dort ist denke ich mal alles 32bit. Damit spielt es überhaupt keine Rolle.
-
Thread
115200baud mit 19.6608Mhz
baudrate eintippen > > Somit alles... > > > Die frage ist, was ist das höchst mögliche mit dem AVR Du drehst dich im Kreis :-) Die höchst mögliche auf dem AVR ergibt sich aus der maximalen Taktfrequenz, dir der AVR noch mitmacht und dem kleinstmöglichen Wert (also 1) den man noch in die UBRR
Und die 24MHz holt sich der AVR aus einem entsprechend konfigurierten Ausgang vom FT232. Ein Quarz weniger. Kann sein, dass der AVR das nicht packt, aber das wirst du sehen.
-
Thread
A2DP Bluetooth Modul China eBay
Man könnte natürlich auch ein WT32 kaufen, was dann auch SPDIF und I2S beherrscht und sauber dukumentiert ist...
Yes Christian, there's a T24C32A 32kbit EEPROM on the BLK* board and a Lize L24C08B 8kbit EEPROM on the I-WAVE board. My knowledge about microcontrollers and related parts is very low (not to say non existant ;)), but does that mean
-
Thread
Interesse an kleinem Linux Board?
nur irgendwelche > Sensordaten ins Netz übertragen will oder dergleichen. und dafür braucht man 32Bit und 400MHz?! Andere schaffen das mit einem AVR mit 8Bit und 20MHz. Letzterer braucht zudem noch viel weniger Strom. Selbst ein Ethernet-Controller-IC kann man sich sparen, wenn man nur senden möchte
irgendwelche >> Sensordaten ins Netz übertragen will oder dergleichen. > > und dafür braucht man 32Bit und 400MHz?! > Andere schaffen das mit einem AVR mit 8Bit und 20MHz. Letzterer braucht > zudem noch viel weniger Strom. Selbst ein Ethernet-Controller-IC kann > man sich sparen, wenn man nur
-
Thread
RTC DS3231 - Temperatur Daten?
weitere Werte... PC (NTP) DS3231M ppm 02:18:00 02:18:00 0 11:59:00 11:58:03 -1635 14:34:00 14:32:48 -1630 17:55:00 17:53:28 -1636 Ob die NTP Synchronisation vorher nun geeignet ist weiß ich einfach nicht 100%tig, habe aber nichts mit DCF77 im Haus. Joachim B. schrieb im
1024 Hz paßt sehr gut dafür. Auch nützlich, daß diese Frequenz deutlich genauer ist, als Quarz von AVR.
-
Thread
Unbekannter Assembler erzeugt große Änderungen bei kleinem Programm
üblicherweise das Programm abspeichern. Die IDE mit Assembler: http://www.padauk.com.tw/products.php?item=14 (IDE v0.81)
es einen AVR der die gleiche Anzahl an Instruktionen hat? Die PICs wurden recht häufig kopiert, von AVR weiß ich nichts. (selbst die OTP-PIC-Klone sind noch teurer)
-
Thread
Kleine Frage zum ENC28J60
> sein. Das spielt keine Rolle. Der ENC28J60 ist halt nicht besonders schnell. Mit einem PIC32MX795F512 oder einem äquvalenten ARM könntest Du 100 MBit/s fahren und würdest dabei auch Transferraten von 8MByte/s erreicht. Mit einem popeligen AVR geht das natürlich nicht. Der wird nicht einmal ein
Präambel, CRC, inter-packet-gap), so daß große Pakete mehr Durchsatz bringen. Und auf das eine Prozent (14 Bytes von 1500) kommt es auch nicht mehr an, wenn z.B. ein AVR dahintersteckt, der die 10Mbit sowieso nicht auslasten kann. "SPI-over-Ethernet" wird daraus übrigens sowieso nicht; dazu müßte man sich
-
Thread
Benötige Hilfe beim programmieren eines Microkontrollers!
aber parallel dazu auch selbst mit der "Materie" beschäftigen müssen. Ein guter Einstieg sind das AVR- und das AVR-GCC-Tutorial in diesem Forum: https://www.mikrocontroller.net/articles/AVR-Tutorial https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial Lese dich da mal ein und wenn unüberwindbare
beschäftigen zu müssen Das Datenblatt ist nicht riesig. Die entsprechende Dokumentation von STM32 Controllern ist 10x so umfangreich und trotzdem weniger ausführlich. Sei froh, dass du einen AVR verwenden darfst, und dann auch so ein 08/15 Modell. Für keinen anderen Mikrocontroller wirst du so viele
-
Thread
Raspberry-Webradio
erstellen mit nachfolgender Ausgabe root@raspberrypi:/home/pi/svn/trunk/interfaces/bridge# make hex avr-gcc -Wall -Os -DF_CPU=14000000L -I. -O2 -DDEBUG_LEVEL=0 -B /usr/avr/lib -I /usr/avr/include -mmcu=atmega32 -c main.c -o main.o In file included from main.c:13:0: glcd.h: In function
Hast du die beiden AVR-Source selbst kompiliert?
-
Thread
LED Sequenz Blinker KFZ - Schieberegister oder Microcontroller?
dem Eingangssignal am besten um, damit der MC mit 5V versorgt wird? Das Signal vom Blinker ist 12-14V gepulst (PWM), vermutlich 100Hz. Könnte mir da mal jmd eine Schaltung zukommen lassen? Welche Mosfets wären für mich geeignet? Viele Grüße, Ben
ihr das aufbauen? Spannungsspitzen bis 60V müssen bedacht werden. Die Eingangsspannung beträgt 11-14V, gepulst. Beim Thema Schutzbeschaltung fehlt mir leider jegliche Erfahrung. Darum wäre ein Schaltplan super :)
-
Thread
I2C Takt Pullup abhängig? (AVRxDB)
Hallo, ich spiele gerade mit einem AVR128DB64 rum und probiere Formeln aus wie man den optimalen BAUD Wert für den I2C Takt berechnet für unterschiedliche Gegebenheiten. Dabei fiel mir auf, dass der Takt stark vom Pullup abhängig ist. Nur
bis zu 9 SCL-Pulsen, bis SDA = 1 ist und dann ein STOP senden. https://www.robotroom.com/Atmel-AVR-TWI-I2C-Multi-Master-Problem.html
-
Thread
AVR Atiny2313
GCC-Testsuite gehört zur Qualitätssicherung des Compilers. Eben. Sag ich doch. > Was bringt es für einen avr-gcc, den Code für einen PC zu übersetzen > und dort laufen zu lassen? Für den avr-gcc? Nichts. Garnichts. Aber der TE ist keiner der Entwickler des AVR-GCC und will seinen Debugger auch sicher nicht
der auch noch der Quellcode zur Vollständigkeit: [c] /* * AVRGCC1.c * * Created: 10.02.2012 14:10:37 * Author: Paul E. */ #include <avr/io.h> #include <math.h> int volatile long a,b,sum; int main () { DDRB=255; PORTB=a; int n; n=50; fibonacci(n); return 0; }
-
Thread
Energieverbrauch ATtiny261 :-)
> Die ATtiny können zwar auch 32kHz, aber nur als CPU-Takt und verbrauchen > daher mindestens das 100-fache. ATTiny24A, 3 V, 32 KHz -> 10 µA
und Quarz! "www.youtube.com/watch?v=UXfV7GzvIps&feature=youtu.be" 1. [c] /* * attiny261_32khz.c * * Created: 07.06.2014 19:14:09 * Author: Chris */ #include <stdlib.h> #include <avr/io.h> #include <avr/interrupt.h> // Datei für Interrupts #define F_CPU 32768UL // Prozessortakt