-
Thread
mit Bascom über rs232 Frequenz aus einen Frequenzzählermodul auslesen.
kann man schön im Buch von Claus Kühnel studieren. https://www.bod.de/buchshop/programmieren-der-avr-risc-microcontroller-mit-bascom-avr-claus-kuehnel-9783907857144/
Deinen Zweck aufgebaut werden kann: [code]$Regfile = "m8def.dat" $Crystal = 14745600 $hwstack = 64 $swstack = 32 $framesize = 32 Dim retrig_1 As Byte Dim retrig_2 As Byte Const retrig_1_preset = 5 Const retrig_2_preset = 10 Config Timer2 = Timer , Prescale = 1024 '
-
Thread
nochmal: Zisternen-Füllstand über Druck-Sensor
Und der hier? https://www.amazon.de/Sonic-Watchman-%C3%96l-levelmonitor/dp/B0032Q8Q64/ref=pd_sim_60_3?_encoding=UTF8&pd_rd_i=B0032Q8Q64&pd_rd_r=AN0R1PBC6425SDREZ2KA&pd_rd_w=vGqGc&pd_rd_wg=pkFZx&psc=1&refRID=AN0R1PBC6425SDREZ2KA
gescheiterten Versuche: - HRS04in 100er Rohr: zuviele Reflektionen - HRS04 Ultraschallsensor am ESP32 direkt in der Zisterne: keine zuverlässige WLAN Verbindung - HRS04 Ultraschallsensor in der Zisterne, ESP32 außerhalb: zu breits Ultraschallkeule, daher Reflektionen von der Seitenwand - JSN-SR04T
-
Thread
Ist die Karriere vorbei, wenn man zur Leihbude geht?
Werkstudententätigkeiten.Das war bei einer Kleinklitsche in NRW. Die > haben mit gesagt, dass meine AVR Kenntnisse(kein Arduino!) zu wenig > seien. Laut denen muss man heute mindestens 32-Bitter programmieren > können. Und hast Du dir ein 32bit Board besorgt und damit losgelegt?! Infineon schmeisst
unvollständig / inconsistent / - Fehlendes / schlechtes mutivations / anschreiben Die aussage AVR reicht nicht, es sollte schon ein 32Bitter sein, ... bezeichne ich mal als notlüge. Der PSOC 5 hat doch einen cortex oder teusch ich mich da? grüsse aus dem Süden der Republik
-
Thread
Wie Messwerte über Wlan auslesen?
Dieses z.B. https://www.electrodragon.com/product/esp32-wrover-v4-module-based-esp32/
. Mikrocontroller (ATmega) habe ich früher mit Assembler oder Bascom programmiert und jetzt mit LunAVR. Kleinere Windowsprogramme mit vb.net. Ja, ein Operationverstärtker mit Schutzschaltung wird vorgesehen und auch eine schaltbare Versorgungsspannung für den Sensor. Diese kleinen Wlan-Module sind
-
Thread
avrdude für Windows 10 installieren
Anleitung, wenn du noch keine andere Anleitung zu avrdude vorliegen hast: http://stefanfrings.de/avr_hello_world/index.html Absatz "Avrdude" Je nach dem, welchen Programmieradapter du verwendest, wirst du zusätzlich den libusb Treiber brauchen: http://stefanfrings.de/avr_tools/libusb-win32-bin-
die DLL "libusb0.dll" fehlt. Die bekommt man hier: https://sourceforge.net/projects/libusb-win32/files/libusb-win32-releases/1.2.6.0/ "libusb0_x86.dll" aus "bin\x86" in das Avrdude-Verzeichnis kopieren und in "libusb0.dll" umbenennen.
-
Thread
[V] Adapter QFN32 auf TQFP32 und eMMC auf SD-Card
definitiv OHNE Porto. In den meisten Fällen wird Versand als Brief (0.70€) vermutlich ausreichen. * QFN32 auf TQFP32 Adapter PCB (0.6mm dick, durchkontaktiert) 0.10€/Stück * eMMC auf SD-Card (4-lagig, 1.6mm, grün) 4€/Stück Der IC, das PCB Lineal, das tinyUSBboard und die lila Leiterplatte sind nur
Schönen guten Tag suche für den AVR64DD32 einen TQFP32 Adapter auf DIP, kann 2 Seitig sein mit den Pins links und rechts oder Quadratisch mit den Pins an allen 4 Seiten. Es würde beides gehen. Müsste aber 0,8mm Pin-Abstand sein. Glaube
-
Thread
Shakti: Indiens erster RISC-V basierender Prozessor bootet Linux
hier bekannten Microcontrollern, aber auch Broadcom mit seinen SOCs für Embedded. Atmel hat immerhin AVR32 erfunden umd irgendwelchen Grenzen oder Lizenzen zu entgehen.
gestritten werden... Es gibt vier sog. Basismodule (drei für die unterschiedlichen Adressbreiten 32, 64 und 128-Bit und ein abgespecktes für Microcontroller, RV32E genannt) und z.Z. 13 Erweiterungen... Es gibt zwei + n Befehlslängen: 32-Bit und 16-Bit komprimiert und variabler Länge (Vielfache von
-
Thread
Kaiser-Window Annäherung
A5HilbertPhasePage.html Kapitel 3.5. Das wird da als FIR-Filter umgesetzt. Läuft bei mir auf einem PIC32, aber ich sehe keinen Grund, warum das nicht auch ein AVR könnte.
schrieb im Beitrag #5503715: > Deinen Beitrag verstehe ich nicht.... > Läuft bei mir auf einem PIC32, aber ich sehe keinen Grund, warum das > nicht auch ein AVR könnte. Und was verstehst du da nicht? Ist ein Kaiser-Window eben. Tapnummer rein, Beta rein, Koeffizient raus. ferticht. Hab's eben grad
-
Thread
avrdude bzw. libusb funktioniert nur an bestimmtem USB-Anschluss
aTeVaL-Board von eHajo gibt es hier: https://www.ehajo.de/bausaetze/bedrahtet/89/ateval-microchip-avr-evaluationsboard http://dokuwiki.ehajo.de/artikel:ateval und zum Atmel AVRISP MkII hier: https://www.microchip.com/webdoc/avrispmkii/index.html Das aTeVaL hat einen ATmega32U2 mit USB
Hallo, zusätzlich zum aTeVaL von eHajo und AVRISP MkII von Atmel habe ich jetzt noch den AVR-ISP-Stick von eHajo getestet. Aufbau mit STK500 wie beim Test mit dem AVRISP MkII (s. o.), allerdings kommen die 5 V vom AVR-ISP-Stick. Der AVR-ISP-Stick von eHajo funktioniert soweit auch an beiden
-
Thread
14 Segment Display ansteuern
doch keinen PIC16 ans Bein. Wenn es ein µC mit eingebautem LCD-Controller sein soll, dann wäre ein STM32L.. oder STM8L.. eine vernünftige Wahl. Das obige Bild ist z.B. aus dem Datenblatt des STM32L152, der kann bis 8 Backplanes x 40 Segmente. Oder wenn man bei seinem alten µC bleiben will (z.B. AVR)
> Chinesen gerade mal €0,75. Einzeln wohlgemerkt. Im Zehnerpack günstiger. Bei Digikey im 64TQFP 2.19€, also gleich viel wie der PIC. > Allerdings ist der Preis IMHO nicht wirklich ein Kriterium, denn es geht > ja um Bastlerstückzahlen. Den STM32L würde ich dann dem STM8L schon > deswegen
-
Thread
Programmierung Hitachi
Typ HD64725-208PC10 512Byte RAM, 16K ROM, 10Bit ADC 4 channels 46 bidirectional I/O Gehäuse PLCC64 Controller Wer kann uns helfen das Programm aus einem Controller in einen neuen zu übertragen? Gruß Herbert Tel.0171.6205679
Die Aufgabe ist folglich, einen PLCC64 Sockel auf DIP32 Sockel zu stricken, die funktionierende CPU auszulesen und die Daten in eine neue CPU einzuprogrammieren.
-
Thread
Typ K Sensor mit ADS1118: SPI Problem
SPI_MSTR_CLK8 0x05 /* chip clock/8 */ #define SPI_MSTR_CLK16 0x01 /* chip clock/16 */ #define SPI_MSTR_CLK32 0x06 /* chip clock/32 */ #define SPI_MSTR_CLK64 0x02 /* chip clock/64 */ #define SPI_MSTR_CLK128 0x03 /* chip clock/128 */ void spiInit( uint8_t mode, // timing mode SPI_MODE[0-4]
dieser Stelle ist: aus main.c: [c] spiInit(SPI_MODE_1, SPI_MSB, SPI_NO_INTERRUPT, SPI_MSTR_CLK32); [/c]
-
Thread
David Jones über PIC vs AVR
sind gleich gut, schwer, oder schlecht. Wenn die alle so gleich wären, warum findet man dannbei AVR keine uC mit eingebautem LCD Treiber die NICHT 64 pins gross sind, Warum findet man unter den gefühlt 10000 Varianten keine AVR mit 100mA Treibern für LED-Multiplexanzeigen. Warum kann ein AVR
, oder was sonst auch speziell ist. > > Wenn die alle so gleich wären, warum findet man dannbei AVR keine uC mit > eingebautem LCD Treiber die NICHT 64 pins gross sind, > > Warum findet man unter den gefühlt 10000 Varianten keine AVR mit 100mA > Treibern für LED-Multiplexanzeigen. Weil das dann
-
Thread
ATtiny13A bzw. allgemein AVRs: was passiert beim Reset? Gesperrt
meiner Rente noch problemlos kaufen kann. Ich erwarte, dass einzelne Typen (zum Beispiel der ATMega32) abgeschafft werden, aber für die wird es Ersatz geben. Nichts desto Trotz ist für mich offensichtlich, dass alle Hersteller auf 32 und mehr Bits setzen. Die 8 bit AVR Kerne betrachte ich als ausgereift
Grundlagen dann spielt die Menge der Bits einer Architektur auch keine Rolle mehr. > Die 8 bit AVR Kerne betrachte ich als > ausgereift und daher langweilig. mmhhh ausgereift auf jedenfall langweilig ?? Sicher nicht! Vom Prinzip her ist es egal ob die Architektur 4/8/16/24/32/64/128...Bit verarbeiten
-
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
xmega Taktfrequenz
Folgender Code ergibt die Messung im Anhang (gemessen am Ausgangspin): [code] #include <avr/io.h> #define F_CPU 32000000UL #include <util/delay.h> int main( void ) { OSC.CTRL |= OSC_RC32MEN_bm; while(!(OSC.STATUS & OSC_RC32MRDY_bm)); CCP = CCP_IOREG_gc; CLK.CTRL = CLK_SCLKSEL_RC32M_gc
Nimm die PLL. 64MHz vertragen die xmegas noch..
-
Thread
Schiebetür Steuerung
soweit funktioniert er! würde mich auf verschiedene Lösungsvorschläge freuen LG [code] avr.device = atmega328p //Controller-Typ festlegen avr.clock = 8000000 //Dem Compiler mitteilen mit welcher Taktrate der Controller läuft avr.stack = 64 //Den Programmstack
Timer1 ***** Timer1.Clock = 256 '* Clock divider auf 1: 256 (8 Mhz = 125ns * 256 = 32uSec) Timer1.CmpA.Value = 3124 '* Outputcompare-Register auf 3125 ( 3125 * 32uSec =100mS) Timer1.CmpA.Isr = timer1_compare '* Compare-Interrupt aktivieren Timer1.CmpA.Clear.Enable
-
Thread
Linux Distribution für Mikrocontroller Programmierung?
Mint installieren, dann apt-get install acc-avr avrdude avr-libc kate konsole dann hast Du alles was Du (zumindest für AVR) brauchst. Als Editor dann Kate und dort unter plugins die terminal tools aktivieren.
Programmiert werden können: - nahezu alle AVR (Avrdude und AVR-GCC machen es möglich) - STM32: F030, F051, F103, F401, F411, F429 - STM8: STM8S103 / 003, STM8S105 - PIC16F: 16F887, 16F648, 16F630 - PIC18F: 18F52 - MCS51: AT89S51 / 52, AT89S8253
-
Thread
Serieller Plotter gesucht
Schnittstelle reinkommen ordentlich als Graph darstellen kann. Erzeugt werden die Daten durch einen AVR, d.h im Eingabeformat wäre ich recht frei. Zur Zeit verwende ich hierfür den Plotter der Arduino IDE. Damit bin ich aber weniger zufrieden, da sich im Nachhinein die Daten nicht mehr betrachten lassen
10. http://serialcominstruments.com/serial.php Kompatibel mit Window XP / Vista / 7 / 8 , 32 oder 64 bit Herbert schrieb im Beitrag #5487414: > Nur leider kommt > immer Buffer Overflow als Meldung sodass keine Verbindung möglich ist. Scheinbar wird Windows 10 (noch) nicht unterstützt
-
Thread
Wie und wie oft Bibliotheken benutzen?
auf den Markt kamen und das Datenblatt mehr den Namen Rätselheft verdient hätte. Ich hätte den ESP32 wohl kaum angefasst ohne Bibliotheken und Beispiele wenn ich da nur mit dem IDK alles hätte selber machen müssen. Gruß aus Berlin Michael
Base64 U. schrieb im Beitrag #5486895: > Einerseits erspart es dir die Arbeit und Zeit alle peripheriebausteien > in einem µC manuell über die Register an zu sprechen, Das spart weder Zeit noch Arbeit.
-
Thread
ATMEL SAM3X8 (Arduino Due) printf auf beliebiges Device umleiten?
da auch der gcc-arm-embedded mit newlib genutzt wird: https://www.mikrocontroller.net/articles/STM32_Eclipse_JLink_Linux/Windows#Optional:_Syscalls_implementieren
FVAR -0.0000 Die Kiste-Maggi Frage: wo liegt das Problem? Ach, wie war die Welt mit libc und dem AVR doch so schoen.... VG yogy
-
Thread
TIMER0 Normal Mode bei 2560
gCbi .if @0<32 cbi @0,@1 .else xIn WL,@0 cbr WL,(1<<@1) xOut @0,WL .endif .endmacro .macro gSbi .if @0<32 sbi @0,@1 .else xIn WL,@0 sbr WL,(1<<@1) xOut @0,WL .endif .endmacro[/c] Für spezielle Zugriffe sind diese auch sinnvoll: [c].macro gSbic .if @0<32 sbic @0,@1 .else xIn WL,@0 sbrc WL,@1 .endif .endmacro .macro gSbis .if @0<32 sbis @0,@1 .else xIn WL,@0 sbrs WL,@1 .endif .endmacro[/c] Wir nutzen darüber hinaus noch folgende
-
Thread
Maiskolben Lötstation Fehler beim Kompilieren
-DF_CPU=16000000L -DARDUINO=10805 -DARDUINO_AVR_UNO -DARDUINO_ARCH_AVR "-IC:\Users\Holger\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.6.21\cores\arduino" "-IC:\Users\Holger\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.6.21
0b11111000) | 6; //PWM Prescaler = 128 245Hz TCCR2B = (TCCR2B & 0b11111000) | 5; //PWM Prescaler = 64 490Hz //TCCR2B = (TCCR2B & 0b11111000) | 4 //PWM Prescaler = 32 980Hz //TCCR2B = (TCCR2B & 0b11111000) | 3; //PWM Prescaler = 8 3.9kHz //TCCR2B = (TCCR2B & 0b11111000) | 2 //PWM
-
Thread
Digitaler Bilderrahmen, ePaper, Batteriebetrieb, portabel
gar nicht. https://youtu.be/znfEyW1eg7Y Als Controller habe ich einen Pro-Micro-Clone (Atmega 32u4, 3,3 V, 8 MHz, 32 k Flash, 2.5 k RAM) eingesetzt, im Prinzip ginge es mit jedem Atmega ab 32 k Flash und 2 k RAM, wenn die Sektor-Puffergröße für das Lesen von der SD-Card reduziert wird. Der Programmcode
versorgt und kann damit komplett abgeschaltet werden. Die dekodierten Bilddaten werden in einem SPI-RAM (64 kByte, 23LC512) zwischengespeichert, es ist nicht möglich, sie gleich im Framebuffer des ePaper-Moduls abzulegen. Mittels Fotodiode BPW34 wird die Umgebungshelligkeit geprüft und das Display-Update
-
Thread
Programmdurchlauf auf Atmega - Frequenz
Funktionen sitzen 2,66MHz Ausgabe Frequenz drin. Auf einem 16MHz Uno. Ein Toggle braucht auf einem AVR Arduino also 3 Taktzyklen, incl Endlosschleife.
> ausgegeben werden soll. Der Puffer ist dann ratz-faz voll. Richtig! Arduino Serial hat eine 64 Byte FiFo. Die ist Ruckzuck voll, und danach blockieren die Print Methoden, bis wieder Platz ist.
-
Thread
Enum oder #define?
Prüfst du ob alle 100 Programme den nirgends nutzen? Sowas hab ich total gern: [c]#include <stm32f4xx.h> // Klasse zur Behandlung der RCC-Peripherie class RCC { // <- Hier kryptische Fehlermeldung };[/c]
leider hatten die Erfinder von C ganz andere Prioritäten Vor allem: ganz andere Möglichkeiten. 64 KiB für Code und 64 KiB für Daten (sofern sie glücklich genug waren, den Hack für "Split I&D" in ihrer PDP-11 nachgerüstet zu haben). > und auch > diejenigen die all die Jahre den C Standard
-
Thread
SPI Flash Programmer
PS: Gerade vergessen: Dein AVR ist ja ein Microchip AVR, der per UPDI programmiert wird. Daher bitte das "wie den AVR auch" streichen. Du bräuchstest ein 10-poliges TagConnect Kabel. GND VTarget AVR Reset SPI CS SPI SCK
Frank K. schrieb im Beitrag #5481249: > PS: Gerade vergessen: Dein AVR ist ja ein Microchip AVR, der per > UPDI > programmiert wird. Daher bitte das "wie den AVR auch" streichen. > > Du bräuchstest ein 10-poliges TagConnect Kabel. > > GND > VTarget > AVR Reset
-
Thread
IRLML2244 und IRLML6244 als "normale" Mosfet
Habe im Netz einen Schaltplan für einen Solar-LED-Strahler gefunden http://www.elektronik-labor.de/AVR/LEDstrahler.html Das Löten traue ich mir zu, jedoch die beiden SMD Mosfets IRLML2244 und IRLML6244 bereiten mir etwas Kopfzerbrechen. Gibt es denn "normale" Mosfets als Ersatz? Danke schon mal im
Schaltfrequenz (Timer1, 32 oder 64 Mhz) - Statt Spannungsregelung mit Vorwiderstand direkt den Strom durch die LED regeln. Der Tiny45 hat netterweise einen 20× Verstärker mit drinnen, damit der Shunt klein ausfallen kann.
-
Thread
Drehgeber Tutorial
// power on state enc_delta = 0; TCCR1B = (1<<CS11) | (1<<CS10); // prescaler 64 TCCR1B = (1<<WGM12) ; // CTC OCR1A = (uint8_t)(XTAL / 64.0 * 1e-3 - 0.5); // 1ms TIMSK1 |= (1<<OCIE1A); } ISR( TIMER1_COMPA_vect ) // 1ms for manual movement {
überschreibst die Timer-Konfiguration in TCCR1B: [c] TCCR1B = (1<<CS11) | (1<<CS10); // prescaler 64 TCCR1B = (1<<WGM12) ; // CTC [/c]
-
Thread
Warum Pascal/Delphi/Lazarus oft unbeliebt?
Der AVR wird auch unterstützt ;-) http://wiki.freepascal.org/AVR_Embedded_Tutorial/de
://electronics.stackexchange.com/questions/200055/most-efficient-way-of-creating-a-bool-array-in-c-avr
-
Thread
Problem mit INT0 auf Attiny24A
in den Powerdown und wacht auch beim auslösen des INT0 wie gewünscht wieder auf! [c] #include <avr/io.h> #include <avr/sleep.h> #include <avr/interrupt.h> #include <inttypes.h> const uint8_t Muster[] = {0x08, 0x44, 0x4C, 0x55, 0x5D, 0x77}; volatile uint8_t Zahl = 1; int main(void) {
PORTB = (1<<PB2); // Prescaler 8 => 128.000/8 = 16.000 Hz TCCR0B = (1<<CS01); // Prescaler 64 => 128.000/64 = 2.000 Hz TCCR1B = (1<<CS11) | (1<<CS10); // Overflow Interrupt für Timer0 erlauben TIMSK0 |= (1<<TOIE0); // Overflow Interrupt für Timer1 erlauben TIMSK1 |= (1<<TOIE1);
-
Thread
RasPi Daseins-Berechtigung?
fragte ich mich, was man damit (hardwarenah) machen kann und was der > killer Vorteil ggü den üblichen AVR Basteleien (hier) ist? Versuche mal, mit einem AVR irgendwelche Zeitrafferaufnahmen mit der zugehörigen Kamera zu machen.
ich mich, was man damit (hardwarenah) machen kann und was der > killer Vorteil ggü den üblichen AVR Basteleien (hier) ist? Leider kann man nur relativ wenig machen, was man nicht auch mit einem AVR8-System hinbekommen könnte. Umgekehrt kann man aber mit einem AVR8-System vieles machen, was mit
-
Thread
Modelleisenbahn Weichen Ansteuern
Michael_SS schrieb im Beitrag #5466706: > Ich würde gern mit einem ATMEGA64 die Weichen einer Modellbahnanlage > ansteuern. ATMEGA64 auf einen Waggon platzieren und den Zug von den Schienen leiten lassen. Dann braucht man gar nicht steuern. > Danke für eure Ideen.
Michael_SS schrieb im Beitrag #5467476: > nullsteuer schrieb im Beitrag #5467100: >> ATMEGA64 auf einen Waggon platzieren > Gute Idee, danke. Werde ich machen nimm lieber den 32 der ist kleiner, wenn du Platz hast, Spur 0 dann geht natürlich auch ein 1284p
-
Thread
Ähnlicher (gleicher) ersatz für 80c537
fuer ein copy von A nach B muss man immer wieder das Indexregister neu befuellen. Waehrend zB ein AVR 3 Indexregister hat. Der 8051 hat einen clock div 12 Teiler, waehrend die AVR keinen Teiler benoetigen. Bedeutet, beim 8051 hat man mit einem 12MHz Clock 1 MOps, waehrend es beim AVR 12 MOps sind
Vielleicht magst du mit STM32 einsteigen. http://stefanfrings.de/stm32/index.html
-
Thread
Probleme mit Multiplexen
Ausgabe = (Ausgabe + 16 ); } if (PIND3 == 0) { Ausgabe = (Ausgabe + 32 ); } if (PIND4 == 0) { Ausgabe = (Ausgabe + 64 ); } if (PIND5 == 0) { Ausgabe = (Ausgabe + 128 ); } if (Ausgabe >= 100) { Ausgabe
== 0) { Zahl = (Zahl + 16 ); } if (PIND3 == 0) { Zahl = (Zahl + 32 ); } if (PIND4 == 0) { Zahl = (Zahl + 64 ); } if (PIND5 == 0) { Zahl = (Zahl + 128 ); } if (Zahl >= 100) { Zahl = 99 ; }
-
Thread
Attiny85 Timer1 PWM: Keine Duty-Cycle-Formel (da nichtlinear?)
sieht eigentlich das Programm aus? Mein Testprogramm sieht im Moment so aus: [c] #include <avr/io.h> #include <avr/interrupt.h> #include <avr/cpufunc.h> // "nop" #include "tinyProj.h" #define IDX0 6400 ISR(TIMER1_OVF_vect){ static uint16_t idx = IDX0; static uint8_t val = 0;
haben sich beim umschreiben ein paar Fehler eingeschlichen.. Jetzt sollte es passen: [c] #include <avr/io.h> #include <avr/interrupt.h> #include <avr/cpufunc.h> // "nop" #define IDX0 6400 ISR(TIMER1_OVF_vect){ static uint16_t idx = IDX0; static uint8_t val = 0; if(!(--idx)){ OCR0B
-
Thread
myAVR Board light und myAVR Workpad arbeiten nicht zusammen
Empfehlung, wenn die Benutzung des Workpad nicht im Rahmen einer Schulung vorgeschrieben ist: - Atmel AVR-Studio 4.19 Build 730 (für Windows XP mit SP3, Vista, Win7, x32/64) installieren. Diese IDE ist das Original, kostenlos, von Haus aus für 8-Bit-AVR-Assembler, mit Quellcode-Editor, Simulator, Debugger. - WinAVR-20100110 für C/C++ mit GCC separat installieren und im AVR-Studio einbinden (oder die geeignete AVR-Toolchain verwenden). Das zu einem GCC-Projekt passende Makefile herauszufinden, falls die IDE das
-
Thread
Registerzugriff C Code frage
Zugriff erfolgt über den Befehl [c]__enable_peripheral(SPI1EN); // wobei SPI1EN = 44[/c] im stm32f100.h steht dann [c]#define __enable_peripheral(p) (&RCC_AHBENR)[p/32] |= 1 << (p % 32)[/c] [c](&RCC_AHBENR)[p/32] | [/c] Ich weiß es handelt sich um einen Pointer aber wozu [p/32]? und was macht
0x004 von einer > Registeradresse zur nächsten Registeradresse zustande, wenn die > Registerlänge 32 Bit ist? Ja, per Konvention sind alle Adressen Byte-Adressen. Das ist aber nicht überall so. Ein Gegenbeispiel sind Flash-Adressen auf dem AVR, die zeigen immer auf einen 16 Bit-Wert und werden
-
Thread
PWM Frequenz erhöhen
>> Hochauflösende PWM gibt es u.a. beim PICCOLO. >Oder beim ATtiny25/45/85 wenn der Timer 1 mit 64 MHz aus der PLL >versorgt wird. Naja, dann schau dir mal an, welche Zeitauflösung der PICCOLO kann. Dagegen sind 64 MHz PWM-Takt ein Witz.
Beitrag #5450177: > Naja, dann schau dir mal an, welche Zeitauflösung der PICCOLO kann. > Dagegen sind 64 MHz PWM-Takt ein Witz. Ok, dann rechnen wir mal nach: 1. ATtiny25/45/85: Taktfrequenz 8 MHz, nach PLL: 64 MHz bei einer 8-Bit PWM (256 steps) bleibt eine PWM-Frequenz von 250 kHz. Der Abstand
-
Thread
Unterschiedliche defines zwischen Atmel Studio und dem Datenblatt
Start - 1.0.116.0 Atmel Start Version: 1.0.116.0 Package GUID: F8853255-9C7B-4DC2-8E0F-64D9324AEB0E Company: Atmel Installed Packages: LiveWatch - 2.0.65 LiveWatch Version: 2.0.65 Package GUID: 7DF6DCFD-2BCA-41C7-9C0E-1B7F606B008E Company: Atmel Installed Packages: GdbConsole
in dem einen Register an einer anderen Stelle steht als im anderen Register. AFAIR war das bei de AVR-Timer gerne mal der Fall.
-
Thread
Lötstationen
du Kühlkörper, > Leistungsrelais ... Hier steht auch eine Rolle 1,5mm auf dem Tisch. > Mit SW32 machst du erst mal keinen Fehler. Ich habe neben F-SW32 63/37 auch noch F-SW26 Cu2 - das 26er geht deutlich besser, wenn die Oberflächen nicht mehr frisch sind. Aus der Fertigung wurde SW26 schon
zu senden so daß man graphisch die Step PID Antwort analysieren kann. Ich habe vor entweder einen AVR 1284P oder STM32F103 einzusetzen. Mit dem letzteren habe ich relativ viel Erfahrung. Mit Atollic Truestudio arbeitet es sich damit recht gut und der Debugger ist natürlich auch nicht zu verachten.
-
Thread
LCD 7-segment für Uhr hh:mm:ss gesucht (I2C oder SPI)
? Bei 100 Pins würde der dann aber > sicher auch einiges mehr verbrauchen? Z.B. MSP430F4x, STM32L4Rxxx Die brauchen auch nicht mehr, als 1 AVR und 11 Schieberegister.
Bei 100 Pins würde der dann aber >> sicher auch einiges mehr verbrauchen? > > Z.B. MSP430F4x, STM32L4Rxxx > Die brauchen auch nicht mehr, als 1 AVR und 11 Schieberegister. Mhh Abseits der Arduinos habe ich mich noch nicht so mit anderen µC beschäftigt. Wie leicht lassen die sich im Vergleich mit
-
Thread
Noch so ein Arduino-Diskussions-Thread.
Maik M. schrieb im Beitrag #5441944: > ist der Umstieg zu AVR-GCC doch ein > Quantensprung Arduino ist reines echtes AVR-GCC C++, nur mit ein paar Blümchen dran, auf die man auch verzichten kann
jemand etwas von seiner Entwicklung erzählt. Wie lange habt ihr z.B. für die Basics im Umgang mit AVR/-/GCC/-libc etc. gebraucht?
-
Thread
Code unleserlich schreiben um Zeilen zu sparen.
avr-gcc Pakete für Windows: https://sourceforge.net/projects/mobilechessboar/files/avr-gcc%20snapshots%20%28Win32%29/ http://blog.zakkemble.co.uk/avr-gcc-builds/
bestimmte Architektur die Größe ist, die auf dieser Maschine am besten verarbeitbar ist (auf einem AVR sind es daher 16 Bits, auf einem ARM 32, auf anderen können es auch 64 sein). Aber ich gebe dir Recht: genau /solche/ Abwägungen müsste man natürlich besser unter die Leute bringen.
-
Thread
Code(SRAM steuern) verbessern. Arduino mega 2560
Maxim B. schrieb im Beitrag #5441364: > Dafür gibt es interne SRAM. Zeige mir den AVR mit 32 oder 64 KB internem SRAM.
S. R. schrieb im Beitrag #5441366: > Zeige mir den AVR mit 32 oder 64 KB internem SRAM. Wenn man so viel SRAM für die Aufgaben braucht, die man mit AVR machen will - dann liegt das Problem nicht in SRAM sondern woanders. Z.B. man könnte Programmlogik