-
Thread
Quellcode ändern von Pic auf MEGA8
Hi AVR415: RC5 IR Remote Control Transmitter on tinyAVR and megaAVR devices http://www.atmel.com/dyn/resources/prod_documents/doc2534.pdf http://www.atmel.com/dyn/resources/prod_documents/AVR415.zip
Output 'Ein Pin >wird als Ausgang konfiguriert PC0 (also Pin0 von Port C) Du konfigurierst zwar den richtigen Port B Pin 0 damit, aber in deinem Kommentar nebendran ist es Port C den du meinst???? Wo hast du die LED angeschlossen??? Sicher auch Port B??? Code scheint
-
Thread
Assembler und Mega48
@Kurt: Du arbeitest doch sicher mit AVR-Studio. Das hat oben eine Menüleiste. Ganz rechts gibt es den Menüpunkt "Help". Wenn man den anklickt, bekommt man unter Tools, AVR-Assembler (oder so ähnlich) komplette Auflistungen der Direktiven
folgendes: ldi r16,0 ;oder andere Werte für den OSCCAL. out OSCCAL,r16 sbi DDRB,0 ;PortB.0 als Ausgang. in r16,PortB ;Port-Status einlesen. ldi r17,0b1 ;Bit 0 zum switchen. loop: eor r16,r17 ;PortB.0 umschalten. out PortB,r16 ;Und Ausgeben. rjmp loop Macht eine
-
Thread
Mikrocontroller Einstieg
Zugriff, weil die ARMs anders als AVR keine direkten atomischen IO-Zugriffe können. Immerhin muss das nur 1x pro Port-Register erfolgen, auch wenn man mehrere (bis 16) Pins auf einmal atomisch setzt - nur ein zusätzlicher Takt für jeden
Moin, Die rote AVR Bord von Gregor gefällt mir eigentlich. Gerhard
-
Thread
ATmega8 Timer Problem
wollte ein Programm schreiben, dass 2 verschiedene Blink-Programme ausführt. Im ersten Programm sollen PortD und PortB blinken und im zweiten Programm sollen sie ganz simpel leuchten. Das Blinken geschieht in Timer0 und funktionierte in vorherigen Tests auch schon. Der Programmwechsel sollte im OverflowHandler
Hi Kleiner Vorschlag: wenn du für dein Blinkprogramm die Ports gleich im Timer1_Overflow inialisierst, kannst du den Teil: >blinken: > sbic PORTB, 0 ;Nächsten Befehl überspringen, falls Bit0 abm PortB ist > > rjmp led_ein ;Ansonsten LED einschalten
-
Thread
BLDC Sinus AVR449 Allradantrieb Fahrrad
der Kollegen hat ein Platinenlayout entworfen, auf dem ein Attiny 861A verbaut ist. Dort kommt das AVR Programm AVR449 "Sinusoidal driving of 3-phase permanent magnet motor using ATtiny261/461/861" zum Einsatz. Details dazu gerne auf Anfrage, da ich nicht weiß, welche Informationen ihr braucht. Ich
benutzt wird: Der muss erstmal sauber laufen, sonst hat es keinen Sinn, auf Sinus umzuschalten. Für AVR447 habe ich eine Terminalumgebung mit eingebaut, um mir Variable, Ports und andere Werte auf den PC zu senden, und Parameter von da aus zu ändern. Da ich es hier mit 5 oder 6 verschiedenen Maschinen
-
Thread
PORTD vom ATMega8 geht nicht
irgendwelche Besonderheiten des PORTD beim ATMega8 gegenüber PORTB und C ? Ich möchte PD6 und PD7 einlesen, geht aber leider nicht. Genauso kann ich die Pins von PORTD auch nicht auf high setzen. Beides klappt mit den anderen beiden Ports problemlos. Es kann also kein Syntax-Fehler sein. Oder muss ich
Joh, wenn ich das Datenblatt richtig verstehe, ist auf PortD der AnalogComperator default-mässig eingeschaltet, das bedeutet, PD6 7 kann nicht als regulärer IO-Port genutzt werden. Afaik muss man erst ACME auf "1" setzen, damit das funzt. ACD und ADEN müssen
-
Thread
Servo am Mikrocontroller
/ //////////////////////////////////////// #include <stdlib.h> #include <inttypes.h> #include <avr/io.h> #include <avr/interrupt.h> #include <avr/signal.h> #include <avr/sleep.h> #include <avr/pgmspace.h> #include <math.h> #include "lcd.h" #define XTAL 1000000 // [Hz] void schlaf(float
OK. Gut Ich glaube ich weiss, warum es bei Dir am Port C nicht funktioniert hat. Da ist uns wohl das JTAG Interface dazwischen gekommen. Schalt das gleich mal ab (Im PonyProg die Fuses einlesen und das Haeckchen bei JTAGEN wegnehmen), sonst kommt es
-
Thread
Gibt es einen schnelleren aber baugleichen AVR zum Atiny2313
ext. Oszillator einspeisen, das Programm neu strukturieren, oder über einen Adapter einen anderen AVR µC anflanschen.
der hier ; abgearbeitet wird. Dabei können die Bits mit 4Mhz toggeln, weil der ; abgefragte PIO-Port so oft abgefragt wird Ausgabe: cli in SREG1,SREG ; SREG Register sichern in mtemp2,PINB ; Spaltenwert vom Z1013 einlesen andi mtemp2,0x0F ; nur Bits 0..3 zulassen ; Interrupt
-
Thread
LCD von Peter Fleury
An welchem Port hängt das LCD?? Welchen AVR verwendest du??
das programm mfile liest diese ja nicht selber ein. die einstellungen sind sehr einfach. nur die ports ändern, den display-type und die xtal-frequenz.jetzt kann ich daten vom adc-port einlesen und sichtbar machen. mfg pebisoft
-
Thread
ATmega32 mit Timer1 (PD5) + restliche Ports als I/O nutzen
ganz passen, habe seit dem Fehler viel probiert. Vielen Dank schonmal!! Gruß [c]#include <avr/io.h> #include <stdlib.h> #include <avr/interrupt.h> #include <avr/iom32.h> #include <stdio.h> #include <util/delay.h> #define F_CPU 16000000 #define UART_BAUD 19200 #define MaxPuffer 2 //
sollte jedoch passen oder? Ich muss an einer bestehenden PCB anknüpfen, dort sind alle Pins belegt (Port C = Datenbus von SRAM, Port A & B = Adressbus SRAM, Port D = Timer, 2 Bits für einen Multiplexer [für die umschaltung von den insg. 4 SRAMs]) etc. Eine Frage hätte ich jedoch noch: Warum "muss"
-
Thread
Frequenz über Mikrofon einlesen ATmega16 oder 32
Hallo, ich habe folgendes Projekt: Ich möchte von einen mit dem Mikrofon aufgenommenen Ton die Frequenz ermitteln und dann weiterverarbeiten mit dem ATmega8/16/32. Der Ton entseht beim klopfen auf die Saite eines Tennisschlägers. Im Amhang hab ich mal den Frequenzgang einer "Klopfaunahme" mit dem PC dargestellt. Je nach Schläger(und dessen Bespannug) können Töne entstehen die von Minimum 400Hz bis Maximum 800Hz liegen(in der angehängten Datei liegt der angestrebte Wert bei 576MHz). Wie man aber auf dem Spektrum erkennen kann sind auch andere Frequenzen aufgenommen worden. Wie schaffe ich
-
Thread
Grafik LCD Ansteuerung funz nicht??
nicht, wieso der AVR bei so einem Portzugriff hängen beleiben kann. Als ich testweise die SBIs und CBIs durch nops ersetzten liess, hing der AVR angeblich nicht mehr. Dann wurde mir gesagt, dass man die Befehlsfolge doch
paar schöneren Umschreibungen nur meinen Denkfehler in Bezug auf Sprünge (SBIS anstatt SBIC), das einlesen (PINB), und natürlich meine aufgrund von erwiesener Dusseligkeit überschriebene Clearschleife Aber das passiert, wenn ein PIC-User seinen ersten AVR-Code schreibt und dämlicherweise auch noch das
-
Thread
Microcontroller mit Python
einen Link von einem Tiny posten? Habe keine Ahnung was > das ist dann kann ich mich ein wenig einlesen https://www.mikrocontroller.net/articles/AVR_Typen
einen Link von einem Tiny posten? Habe keine Ahnung was > das ist dann kann ich mich ein wenig einlesen Na genau der, der in meinem Buch behandelt wird: https://ww1.microchip.com/downloads/en/devicedoc/doc2535.pdf oder etwas neuer: https://ww1.microchip.com/downloads/en/DeviceDoc/Atmel-2586-AVR
-
Thread
POCSAG Protokoll
nach 1 usw. ändert. Präambel Erkennung: Dies macht man am besten so: ACHTUNG PIC ASSEMBLER, kein AVR. #define DISKRI PORTB,x <= Eingang Pin MOVLW d'8' ; 8 Bit = 1 Byte MOVWF BITZAHLER ; Zähler BIT_EINLESEN: CLRF STATUS,C ; zur Sicherheit Carry Flag Löschen BTFSC
schieben DECFSZ BITZAHLER ; Bitzähler -1, wenn 0 dann Überspringe nächste Zeile GOTO BIT_EINLESEN ; Noch kein Byte voll, erneut Einlesen. Wenn dies Schleife Durchlaufen ist hast du das erste Byte von 4. Nun mußt du es mit der Erwartung Präambel vergleichen. MOVLW b'01010101' ; Vergleichswert
-
Thread
SPI Master-Slave kommunikation
--------------------------------------------- */ Conf: ldi accu1, 0b00000010 sts PORTE_DIR, accu1 // SPI Port E MISO =out ldi accu1, 0b00001100 sts PORTB_DIR, accu1 // PortB (Pin2+3) DAC richtung OUT ldi accu2, 0b00000001 // 32 MHz intern
--------------------------------------------------- */ /*------------------------- rückgabe einlesen --------------------------------*/ /*--------------------------------------------------------------------------------- */ SPI_EMPFANGEN: in temp, SPDR ; einlesen out PORTB, temp
-
Thread
Atmega16 Taster an Port C einlesen und Display-Ausgabe.
Hallo, Ich möchte 4 Taster an Port 4[2..5] einlesen und per Display deren Zustände anzeigen... die Taster verwenden die internen Pull-Up's. Jedoch gibt's 2 Probleme: 1. entgegen allen anderen Pins ist Port C4 nicht auf 1 sonder auf
werden. Also erst einlesen, dann maskieren, da die anderen Pin's ja nicht interessieren. Danach um 2 Bit Links-Schieben damit PortC.2 = Bit 0 wird. Abschließend zur Ausgabe 30 addieren damit 0 zur ASCII-0 wird. Auf dem
-
Thread
LM235 Beschaltung
gibt pro °K 10mV Änderung aus(0°C = 273,15 K): Hier der Code: 0°C = 273,15 K 'Analogeingang einlesen + Ausgabe LCD Pause 500 DEFINE OSC 4 ' Oscillator set to 4Mhz DEFINE LCD_DREG PORTD ' LCD Data port at Port D DEFINE LCD_DBIT 0 ' LCD starting data bit = 4 DEFINE
Danke! Ich kann aber ehrlich gesagt keinen Fehler findest. Was muss man beim AVR machen dass er es nicht linksbündig ausgibt. Oder findest du einen Fehler? 'Analogeingang einlesen + Ausgabe LCD Pause 500 DEFINE OSC 4 ' Oscillator set to 4Mhz DEFINE LCD_DREG PORTD
-
Thread
Interrupts vs. Endlosschleife
Lichtschranken ohne Weiteres zusammen mit eventuellen Bedienungstasten und Endschaltern auf einen Port legen und mittels Entprellung nach Peter Dannegger im 10ms-Takt (100Hz) einlesen. Die Auswertung (Zählung der Wegstrecke...) kann dann anhand der Tastenflags (tfl bzw. key_press) als Job der Mainloop
du hier: http://www.hanneslux.de/avr/zuenduhr/index.html speziell im Quelltext der Zünduhr. ...
-
Thread
ATMega328-basierter Sprach-Synthesizer für den CPC 464 - Schnelles Byte-weises Lesen mit dem 328?
alten Prozessoren muß/te man immer die sehr schwachen Bustreiber berücksichtigen. Um einen fetten AVR-Port umzuladen, brauchen die vielleicht etwas mehr Zeit als man denkt.
noch einmal abschliessend melden... > so wie es aussieht, ist all die Diskusion um Timing- und > Port-Lese-Probleme etc. Makulatur. Kannst du mal testweise einen String schnellstmöglich an deinen Synthesizer schicken (also mehrfaches LDI), und schauen, ob dein AVR hinterherkommt? Deine Schaltung
-
Thread
ADC auslesen
Sorry hatte ich vergessen zu erwähnen benutzte einen AVR ATMEGA128 also ich möchte halt das der ADC im intervall von 250ms (delay) ausgelesen wird und die eingelesenen wert(8Bits) ausgibt
unsigned short adcres; adcres=ADC; //Auslesen } [/c] so jetzt möchte in werte einlesen und auf die leds ausgeben und da hängts
-
Thread
Parallelport Interfacing
ich möchte auf allereinfachste Art ein paar Debuggingausgaben aus meinem atmega8 mit dem PC einlesen. Ich dachte da an die parallele Schnittstelle, eine Art "Protokoll" würde ich schon programmieren können. Meine Frage: Kann ich den AVR einfach an die Schnittstelle hängen ohne Buspuffer
Pinbelegung etc. ist nicht das Problem Es geht mir um die Beinflussung der zwei Stromkreise, z.B. der AVR zieht auf Low, lässt dann der PC-Port das mit sich machen;) ?
-
Thread
Frage: 328p und Timer2/GPIO in assembler
Nächste überlegung war PortD einlesen, bit7 togglen, PortD wieder ausgeben. Am Pin D7 hängt ledidglich nur der SALEAE Clone. Gruß
Andreas schrieb im Beitrag #7859889: > Nächste überlegung war PortD einlesen, bit7 togglen, PortD wieder Warum nicht einfach eine (toggle)Maske in PINB rein schreiben?
-
Thread
Hilfe! LCD-Ansteuerung
Platine mit Mega8 und Quarz 8MHz. Ist noch nicht fertig, läuft aber. Das LCD wird jetzt aus einem AVR-Port (PD1) mit Strom versorgt und kann per Software ein- und ausgeschaltet werden. Das bringt allerdings nicht das, was ich erhoffte. Der AVR zieht ohne LCD knapp 6mA, mit LCD knapp 8mA, während der
Spezialfunktionspins des AVR reservieren, dann ein Nibble für die LCD-Daten, dann die Steuerleitungen an die AVR-Pins, die noch frei sind. Habe ich alle LCD-Anschlüsse an einem Port, dann wird es (besonders beim Mega8) schwierig
-
Thread
einlesen von seriellen daten am atmega32
also meine frage ist konkret: wie kann man, wenn inkey() den wert "a" erhält die folgenden 2bytes einlesen, und hintereinander auf porta legen und dann "b" einlesen und in der folge byte3 und byte4 einlesen und an porta geben und so weiter und so fort bis ein ganzer tv-frame(16 bytes) durch gelaufen und
beim Feuerwerk-Zündgerät so gemacht (der Einfachheit halber ohne Interrupt): http://www.hanneslux.de/avr/zuenduhr/index.html Für deine Zwecke müsste der Empfangsbuffer vergrößert werden. ...
-
Thread
Statusvariable als struct?
Hallo, ich stehe vor folgendem Problem: Ich lese 2 Ports eines AVR ein. Um das geschickt und platzsparend zu machen lege ich die Werte in einer einzigen Variable ab. Jedes Bit der Variable bildet dann ein Port-Pin ab (1 = Pinliegt auf High, 0 = Pin liegt
.) Der AVR sollte dann einfach nur an zwei anderen Ports die 1:1 zugeordneten Bits toggeln, also 1. Tastendruck auf "L" 2. Tastendruck wieder auf"H". Klingt ganz einfach und ich weiss eigentlich genau was ich
-
Thread
"Einfache" Kommunikation zwischen 2 Atmegas
(z.Bsp. ATTiny44) gebe, dort die 10 Eingänge auf ein 5-bit Muster reduzieren und dieses auf einen Port ausgebe...kann der "Hauptmikrocontroller" dann einfach die 5-bit über 5 Pins einlesen? Oder gibt es da Probleme beim Einlesen? Ich möchte keine besondere serielle Schnittstelle benutzen oder Daten
Wenn man knapp an Ports ist, den naechst groesseren nehmen. Die software benoetigt wenig anpassungen
-
Thread
2 AVRs an einem SRam
"Ich bin immer davon ausgegangen, dass ich in einem Takt den Pegel eines AVR-Ausganges per "out" ändern kann." Stimmt. Aber woher soll das LCD wissen, daß da neue Daten am Port anliegen ? Du mußt also noch ein /WE-Signal takten. Und ob Du dafür 3 * OUT oder 1 * ST
sram auf write treiber enablen zählern disablen 6 enablen doppel-takt sram -> daten einlesen wenn avr 2 auf ready Also 6 takte, ohne schleife. Quasi in einem "unrolled-loop". sollte doch hinhauen, oder ? Falls du da einen Fehler drin siehst, dann lass es mich bitte wissen... :
-
Thread
Atmega16 kleine Hilfe für ADC benötigt.
Du musst das ADC Register einlesen, und nicht das MUX Register.
Dich bei der Programmierung in C aber zunächst nur am Rande interessieren muss). Die Pins von Port A können über einen Multiplexer /alternierend/ mit dem ADC verbunden werden. Der Multiplexer wird über die /MUX/ -Bits im Register /ADMUX/ gesteuert. Du musst, wenn Du einen Wert von PA0 einlesen willst
-
Thread
Fusebits - ein controller nach dem anderen raucht mir ab :'(
Wen Du Probleme mit dem Fusen hast, solltest Du erstmal einen fabrikneuen AVR einlesen und die Fuses mit den Defaulteinstellungen vergleichen. Wenn es dann schon Ungereimtheiten gibt, dann kann ja beim Umfusen nur Mist rauskommen. Auch solltest Du daran denken, daß neuere
> Wen Du Probleme mit dem Fusen hast, solltest Du erstmal einen > fabrikneuen AVR einlesen und die Fuses mit den Defaulteinstellungen > vergleichen. das habe ich bereits getan, aber da war alles in ordnung! > Auch solltest Du daran denken, daß neuere AVRs einen Prescaler haben
-
Thread
LCD 1x16 HD44870 kompatibel will einfach nicht mit der library von Peter Fleury funktionieren
#define LCD_DATA2_PORT LCD_PORT /**< port for 4bit data bit 2 */ #define LCD_DATA3_PORT LCD_PORT /**< port for 4bit data bit 3 */ #define LCD_RS_PORT LCD_PORT /**< port for RS line */ #define
musste ich mehr anpassen. Hier nun also der komplette Code: [c] #include <inttypes.h> #include <avr/io.h> #include <avr/pgmspace.h> #include "lcd.h" // constants/macros #define DDR(x) (*(&x - 1)) /* address of data direction register of port x */ #define PIN(x) (*(&x - 2)) /* address
-
Thread
FT245 únd AVR
2. Wenn TXE# low ist kannst du in den FTDI schreiben. Wenn du schreiben willst stellst du den Port des AVR auf Ausgang, legst die Daten an und ziehst WR kurz auf 1. 3. Wenn Daten im FIFO des FTDI vorhanden sind ist dessen RXF# auf 0. Dann stellst du deinen Port auf Eingang, legst RD# auf 0 und
habe ich zur Zeit nur auf Papier. Der Ft245 wird an den 8515 wie folgt angeschlossen: Dataport:PortD RD=PC0 WR=PC1 TXE=PC2 RXF=PC3 SI/WU=PC4 Das Ft245 board habe ich von Ebay. Der Assembler - SourceCode für den AVR ist im Anhang (wobei ich mir die includes für LCD und speicherkopieren gesparthabe
-
Thread
c# AVR sendet Daten an C# Consolenprogramm
In deiner serialPort1_DataReceived gehst du davon aus, dass du hier serialPort1.ReadExisting() einen kompletten String vom Arduino kriegst. So lange du dein Programm mit dem Debugger zwischendruch immer wieder mal
eine Taste gedrückt wurde? nein, man kann auch einen eigenen thread starten der ständig von dem com-port daten einliest.
-
Thread
Input nicht lesbar, wenn keine 1 im Datenregister liegt
Eigentlich solltest du alle als Ausgang definieren, denn dann floaten sie nicht - egal was du auf PortB schreibst. Sie bewegen sich dann aber alle. - PORTD = 0x0C; Da der Port im Defaultzustand auf Input steht, aktivierst du den Pullup an den beiden Pins. Die anderen Pins des PORTD sind wieder offene
eines der ersten, die du dir sicher aneignen solltest. Dazu gibt es auch ein schönes Kapitel im [[AVR-GCC-Tutorial#Zugriff_auf_IO-Ports]], was ich dir wärmstens empfehle!
-
Thread
Probleme beim ADC-Wert auf LCD ausgeben
RS zu setzen push temp2 push temp3 in temp3, LCD_Strg_PORT ; schreibt den Zustand von LCD_Strg_PORT nach temp3 ;cbr temp3, Pin_RS ; Setzt RS auf 0 (0=Befehl) andi temp3, 0b11111011 out LCD_Strg_PORT, temp3 ; Gibt temp3 an LCD_Strg_PORT aus (jetzt mit RS=0) out LCD_PORT, temp1 ; Gibt den Befehl an LCD_PORT aus rcall lcd_enable rcall delay50us pop temp3 pop temp2
-
Thread
Propeller Clock
Hm, ein Byte kann ich ja nicht ausgeben, den Port kann ich ja nur auf High oder Low setzten... Ich habe ja 8 Ports anzusteuern, in jedem Byte steckt die Info, was die 8 Ports bei einem Schritt tun müssen.. Ich muss also noch die einzelnen 8 Bits aus dem Byte auslesen und dann auf die einzelnen Ports führen... Oh, oder meinst du mit Portb den Gesamten Port... Hmm, das könnte ja geil gehen.. Hey, der PortB besteht aus 8 Pins... Frage an die Bascom-Kenner: Funktioniert das, wenn ich sage
-
Thread
Suche Mentor für Entwicklung eines Audio-Messwert-Erfassers
unbedingt empfohlen. Man könnte auch ein ARM9-CPU-Board kaufen, oder auch eines von den preiswerten AVR32-Boards... Diese führen die meisten Ports auf eine handelsübliche Stiftleiste und lassen sich dann sogar auf Lochrasterplatinen verarbeiten.
Blocker sind 1206er, die anderen Widerständler werden 0805er. Angeschlossen wird jeweils ein halber Port per 10Pin Wanne. Die ersten 8Bit sind fix, danach kann jeweils ein halber Port dazu genommen werden (per Jumper). Die Artefakte rechts stammen vom verkorksten Löthonig. Habe vergällten Spiritus
-
Thread
Alle Eingänge in eine uint16_t variable schreiben
Hallo, wie fasse ich in AVR-GCC alle Eingänge die auf verscheiden Ports (PORTA, PORTB, PORTC) liegen in eine variable die uint16_t lang ist. Ich habe insgesamt 11 Eingänge die wegen dem Layout auf den drei Ports verteilt sind.
Gast) >Ich will einfach beim Programm an einem bestimmten Punkt, alle Eingänge >auf einmal einlesen und in uint16_t variable so verteilen, das der >jeweilige Eingang einem Bit in uint16_t variable zugerodnet ist. EXAKT auf einmal geht nicht, aber nahe zu. [c] uint16_t get_ports(void) {
-
Thread
Input mit Attiny12 abfragen
Niklas Beuster schrieb im Beitrag #2200201: > IN temp, PORTB ;PortB als Eingang lesen PINB
Bits auch beim Einlesen vom Pin Register wieder. D.h. In dem Moment, in dem du am Port B LDI R17, (1<<PINB0)|(1<<PINB2) die Bits 0 und 2 setzt, wirst du vom Pin Register keine exakte 2 mehr einlesen können, selbst wenn
-
Thread
6502 Emulation auf AVR ?
Michael sowas gibt es schon (für parallel port und auch mit controller, vlt nicht avr)
Daten auf Port, Adresse R/W auf Port, jetzt E-Zustand abwarten (CTC-Pin lesen oder ähnlich) und passend vor E L/H CS setzen und nach E H/L wieder zurück. Zurücksetzen kann man die AVR-Takte zählen, das Verhältnis
-
Thread
Bit nachschieben oder Bitfolge füllen
Am einfachsten: (alles natürlich beispielhaft) [avrasm] in r17, PORTA ;Port einlesen andi r17, 0b0001000 ; gewünschtes Bit Maskieren subi r17, 0xFF ; Testen ob 0 und ggf Carry setzen (0xFF-0 = kein Carry -1= Carry) ror r16 ; rechts --> Carry wird vorne reingeschoben [/avrasm
, außer, daß die Formulierung: >also bin nun soweit dass das interrupt eben hochkommt und den port abfragt auf 0 oder 1 nun soll ein register beschrieben werden. etwas unklar ist (ein Port hat beim AVR 8 Bit...) falls Du ein bestimmtes Bit meinst (immer das gleiche): sec ; carry setzen
-
Thread
Mega16 Pony JTAG
Hallo, nach 3 Wochen Arbeit habe ich heute meinen AVR Mega 16 zum laufen gebracht. Nur jetzt ist die frage was stellt man bei Ponyprog den Controller ein ? . Bzw. wie kann man die Security JTAG Bits wider Programmieren. Im Moment kann ich mein Programm
erst mal ohne Kondensatoren einsetzen. Meistens ist es bei kaputten CKSEL-Fuses aber so, das der AVR nur mit einem externen Takt und definitiven 5 und 0V wieder zum leben kommt. Mir ist es auch schon passiert, das SPIE (SPI Enable) zerschossen wurde und der AVR nichts mehr über ISP angenommen hatte
-
Thread
Emitterschaltung mit AVR und BC639
Transistor nicht genug Strom liefern kann. Meine Frage ist nun, wie ich mit dem AVR einen BC639 schalten kann? +12V o------------------------+ | .-. ( X )
Wert herunter gezogen. Der Strom wird dann nur durch die Innenschaltung des µC (Treiberleistung des Ports) begrenzt und ist nicht genau kalkulierbar. Du wirst den µC daher wahrscheinlich überlasten! Gruß Dietrich
-
Thread
GPS - MOUSE - MINI- NAVIGATOR (Assembler) ATmega8
wäre die ideale Hardware dafür nicht ein AVR Butterfly?
dient nur zum Konfigurieren des Controllers... Hängt das Modul dann an einem anderen Pin und das Einlesen der Daten wird per Software (Software-UART) gemacht?
-
Thread
Programmcode aus RAM ausführen
Rolle. Wenn ehe schon Atmel-Tools vorhanden sind, wäre hier ein AVR32 keine schlechte Wahl.
ich vote auch für AVR32
-
Thread
PC Tastatur Bibliothek
Hallo, hier mal eine Lib um eine PC-Tastatur an einen AVR anzuschließen. Kurzdoku ist in der Header-Datei. Stefan
aber in Bascom gibt es den Befehl "GETATKBD" Damit kann man ohne große Mühe einen Tastaturcode einlesen. MfG Paul
-
Thread
Verschiedene Bits effizient auslesen
einer neuen WINAVR Version > ist, dann sehe ich für mich überhaupt nicht die geringste Chance. WinAVR ist wesentlich mehr als ein schlichter Build der avr-Tools: Es gibt zahlreiche Patches, einen Installer, avrdude, simulavr, Doku, Beispielprogramme, etc. die man alle für eine Arbeit an avr-gcc nicht
DDR_FARBE |= 0b11 << PIN_GRUEN; DDR_FARBE |= 0b11 << PIN_BLAU; // Ausgabe von Werten in Port A: PORT_FARBE &= ~(0b11 << PIN_ROT); // alten Wert zu 0 PORT_FARBE |= 0 << PIN_ROT; // neue Bits setzen PORT_FARBE &= ~(0b11 << PIN_GRUEN); // alten Wert zu 0 PORT_FARBE |= 2 << PIN_GRUEN
-
Thread
Global Variablen in Interrupt-Routine
entsprach. Hier der code, wie ich ihn in SiSy nutze: [C] #define F_CPU 3686400 #include <avr\io.h> #include <avr\interrupt.h> volatile uint8_t sec, min, hour; ISR(TIMER1_COMPA_vect) { sec++; PORTB ^= (1<<PB0); if (sec > 5) { min++; sec = 0; PORTB ^= (1<<PB1
0; } ISR(ADC_vect) { // Beginn der Ereignisbehandlung uint16_t wert=ADC; // Einlesen des Analogwertes Low+High-Teil } void init() { DDRB=0b00000011; // Ports initialisieren TCCR1B=0x03; // Teiler 1/64 TCCR1B|=0x08; // Zählen bis Vergleichswert OCR1A=57600;
-
Thread
Programmablaufplan Drehgeber
wäre mir am liebsten. Mir hilft es aber auch weiter, wenn es einen PAP gibt, der allgemein das Einlesen des Graycodes mit Interrupt aufzeigt. Hier noch einmal der Code von Peter, damit ihr nicht solange suchen müüss Danke Udo [c] #include <avr\io.h> #include <avr\interrupt.h> #define
, zum Testen habe ich gerade einen manuellen alps Drehgeber angeschlossen, um das Prizip des Einlesens zu verstehen. Danach werde ich die Encoder Scheibe mit der 2-Kanal Lichtschranke anschließen. Also die Hardware optischer Encoder auf der Motorwelle wird zum Einsatz kommen. Gruß Udo
-
Thread
Pin Change Interrupts - ATmega168 - Pin fesstellen?
hast (z.B. Interrupt-Request-Leitungen von externen Bausteinen), dann kannst du durch einfaches Einlesen des Ports (PINx) und bitweisem Prüfens die Interrupt-Quelle herausfinden. Zumindest habe ich das Datenblatt bzw. die PCI-Funktion bis jetzt so verstanden.
>Dan werde ich doch wieder dazu übergehen die Tasten in einer Schleife abzufragen. so etwa: Port in X einlesen einen Moment *WARTEN* Port in y einlesen mach irgendwas, wenn x=y? das *WARTEN* kann man durch einen regelmässigen Timer-Interrupt viel besser machen, indem man man in der Interrupt-Routine
-
Thread
Assembler-Kode Optimierung
PORTC löschen anfang: cli ; Globalen Interrupt ausschalten in temp, PINb ; Port B einlesen andi temp, 1 ; mit 1 ver-unden cpi temp, 1 ; Taste1 gedrückt? brne hochzaehlen ; wenn ja, dann dann zu hochzaehlen in temp, PINb ; Port B einlesen andi
+++++++++++++++++++++ sbrc temp1,4 rjmp anfang ; ++++++++++++++++ ; in temp, PINb ; Port B einlesen ; andi temp, 16 ; mit 16 ver-unden ; cpi temp, 16 ; Taste2 gedrckt? ; breq anfang ; wenn nein, dann zurck zu anfang ; +++++++++++++++++++ runterzaehlen: rcall