-
Thread
Sniffer für HD44780 Display
RS und E an Arduino I/O Eingänge. Wie willst Du dann auf den 450ns kurzen E-Puls triggern? Der AVR ist damit hoffnungslos überfordert.
Enable Leitung mit einem Interrupt Pin verbinden, und bei jedem Interrupt die anderen Leitungen einlesen und auswerten.
-
Thread
AVR Bootloader
wurde, weil der neue Fehler hatte. Die ganzen malloc-sachen usw. konnte ich nicht testen, da kein AVR dran. nimm einfach statt alloc mal malloc rein. Es hätte mich auch gewundert, wenn es auf Anhieb geklappt hätte. Mir war z.B. folgendes in Peter´s Programm nicht klar: if( !ComPort ) return
@AndreasH das mit dem: if( !ComPort ) return COMMAND_DONE; ist nur zum Debuggen drin. Damit habe ich getestet, ohne wirklich immer mit dem AVR verbunden sein zu müssen. Sobald eine COM ausgewählt ist, enthält ComPort die Adresse
-
Thread
PORTA und DDRA Zusammenhang
Ausgangspin high/low Deswegen kannst du mit dem PORT-Register auch keine Eingangssignale lesen, du würdest nur den Status der Pull-Ups einlesen. Verwende also zum Einlesen das PIN-Register. Du solltest zu dem Thema mal allgemein nach Atmega, AVR-GCC
, AVR-GCC, Ports & > Pins usw. googlen, da kommt noch einiges mehr...
-
Thread
AVR-Tutorial: Equipment wird nicht erkannt
Hast du denn in dem Reiter "Hardware" in MyAVR Prog Tool ganz unten bei Controller auch den richtigen Controllertyp, in deinem Fall den Atmega 8 ausgewählt ? Das du den richtigen Programmer und Port eingestellt hast setze ich mal voraus.
Hast du es mit beiden Controllern versucht ? Der Usb-Port den du benutzt ist vom Typ 2.0 ? Laut MyAvr wird nur Usb 2.0 unterstützt. USb 3.0 (die blaun Anschlüße) ist zwar abwärtskompatibel, aber wer weiß wie es mit den Treibern aussieht. In jedem Screenshot
-
Thread
AVR: mehere schnelle synchrone Signale gleichzeitig einlesen
Hm, vielleicht versteh ich das ja jetzt falsch, aber kannst du nicht einfach einen kompletten IO-Port einlesen? Dann kannst du ja quasi immer 8 Bit gleichzeitig einlesen. Aber das ist zu einfach, ich hab bestimmt was falsch verstanden... Gruß
, vielleicht versteh ich das ja jetzt falsch, aber kannst du nicht > einfach einen kompletten IO-Port einlesen? Dann kannst du ja quasi immer > 8 Bit gleichzeitig einlesen. Aber das ist zu einfach, ich hab bestimmt > was falsch verstanden... ja, das wär einfach - wenn die Meßschieber brav alle
-
Thread
AVR: Port wiederholt schnellstmöglich auslesen?
Moin! Folgendes Problem: Mit einem AVR moechte ich ein Port-Register PinX ueber einen Zeitraum von wenigen Millisekunden so oft wie moeglich auslesen und die Bytes sequentiell im RAM ablegen, um diese dann anschliessend in Ruhe auszuwerten
anschliessend in Ruhe auszuwerten. Danach kann man die Daten aus den RAMs in aller Ruhe über einen Port in den Controller einlesen, verarbeiten, zum PC schicken oder sonstwas damit veranstalten. mfg.
-
Thread
PIN vs PORT beim OUTPUT
Auch bei einem AVR kann man, wenn der Pin sich im Output befindet, den IST-Zustand über PINx abfragen. Gerade wenn mit Pull-Up / -Down gearbeitet wird ist dies sehr hilfreich. Ob dies nun bei allen AVR so ist, kann ich
anmutet. So ist es. Man kann sogar einen kompletten Port kurzschließen. Der AVR wird heiß, funktioniert aber hinterher trotzdem noch. xXx schrieb im Beitrag #5101469: > Könnte es nicht so sein, dass der Pin PC7, auf Eingang geschaltet werden > sollte
-
Thread
ATmega 128 langsam?
einen Eingangsport komplett auf einen >Ausgangsport durchzuschalten. In seinem Beispiel wird nur Port A nach Port C , und Port B nach Port D geschaufelt. Also geht es ganz einfach Byteweise.
Eingangsport komplett auf einen >>Ausgangsport durchzuschalten. > > In seinem Beispiel wird nur Port A nach Port C , und Port B nach Port D > geschaufelt. > > Also geht es ganz einfach Byteweise. Du musst auch das Fernziel im Auge haben. Und das Fernziel ist nun mal ein Kreuzschienenverteiler
-
Thread
RC-Signale einlesen - so einigermassen bulletproof?
Je nachdem, wieviele Ports der AVR hat, hast du auch mehrere Gruppen von PCInts. Ausserdem gibts es noch INT0 und manchmal auch INT1.
wenigsten hilfreiche Beitrag... Matthias S. schrieb im Beitrag #7865450: > Je nachdem, wieviele Ports der AVR hat, hast du auch mehrere Gruppen von > PCInts. Ausserdem gibts es noch INT0 und manchmal auch INT1. Wie geschrieben, dieser ATtiny 861 hat zwar zwei Gruppen PCINT, die man freigeben muss
-
Thread
Datenrekorder auf SD-Karte mit mega88
Hallo, also das Kompilieren mit der neuesten WinAVR-Version hilft... Bin auch schon kräftig am Erweitern. Folgendes tut schon: 5 Servosignale einlesen "Zeitangabe" vor jedem Datensatz "Automatic-Mode"-Option, Logger aktiviert sich selbständig
`MMC_get_sec_stop_w': D:\AVR\Logger\MrData/../../Logger/MrData/mmc.c:407: undefined reference to `spi_io' D:\AVR\Logger\MrData/../../Logger/MrData/mmc.c:408: undefined reference to `spi_io' D:\AVR\Logger\MrData/../../Logger/MrData
-
Thread
Problem beim Einlesen eines Drehgebers
; Alt auf "alten" Zustand setzen in temp, DrehPort ; DrehPort einlesen com temp ; Invertieren -> Bessere Anschaulichkeit andi temp, maske ; Ausmaskieren der Drehgeber Bits mov merker, temp ; Sichern mov merker2, temp
, zahl main: in temp, DrehPort ; DrehPort einlesen com temp ; Invertieren -> Bessere Anschaulichkeit andi temp, maske ; Ausmaskieren der Drehgeber Bits mov merker, temp ; Sichern cp alt, merker
-
Thread
myAVR, einzelnes Bit einlesen
Hallo Leute, habe mir das Entwicklungsboard von myAVR zugelegt und wollte gern wissen mit welchem Befehl ich ein EINZELNES Bit (welches beispielsweise an PortB anliegt) einlesen kann, um dies danach weiter zu verarbeiten. Wie würde also der Befehl
...bei meinnem "alten" KISS-Board machte man das, indem man erst den Port und dann die Portstelle mit Punkt getrennt eingab. Bsp.: mov A,Port0.3 aber wie geht das mit dem myAVR
-
Thread
Analog einlesen und als PWM ausgeben
Hallo an die Profis, Ich habe folgendes problem, Ich habe AVR Mikrocontroller ATMEGA8L mit 8Mhz und lese einen Analogwert an Port C Pin 0 ein. Soweit habe ich die sache auch schon. Nun wie kann ich diesen eingelesenen Analogwert als eingangswert für meine PWM
Timer implementiert. Ich kam auf eine 6 bit auflösunf da ich den eingelesenen Analogwert auf den PortD gelegt habe und mit den LED überprüft aber an den Ausgängen 6und 7 kam nichts an, somit folgerte eine Auflösung von bit0 bis bit5. kam mir selber auch komisch von da ich ja mit 8 bit einlese! Habe
-
Thread
Probleme mit den Ports beim 2561
am üben und fange nun auch ganz klein an. allerdings kann ich mir nicht erklären, warum ich auf port G0 einen eingang einlesen kann und auf den D und C ports nicht. hardware funktioniert. wenn ich die sicherungsdatei vom anlieferungszustand einspiele, kann ich über den software-porttester alle eingänge
selber gefunden :-) jetzt funktioniert es. vielen dank für deine hilfe..dann werd ich mal zum AVR-GCC-Tutorium gehen und mich einlesen. gruss martin
-
Thread
ADC-Wert nicht linear beim Einlesen
ADC-Auslese-Funktion ist aus dem Tutorial (vorherige Version). Und hier die main.c [c] #include <avr/io.h> // avr Header File für IO Ports #include <avr/pgmspace.h> // Markos für PGM Space // INCLUDES für Display #include <stdio.h> #include <stdlib.h> #include <string.h> #include
lcd_init(); lcd_clear(); while (1){ ADCWert = readADCWert (0); // ADC-Wert einlesen // ADC-Wert ausgeben lcd_setcursor(0,0); lcd_string_P(PSTR("ADC-Wert:")); utoa( ADCWert, buffer, 10); lcd_string( buffer ); } } void init_ports(void) { //
-
Thread
Wie Ports am Besten zusammenfassen?
Port A "blind" schreiben kann, muss ich Port B erst einlesen, einzelne Bits manipulieren, und wieder den ganzen Port ausgeben. Wie handhabt man das am Besten? Bzw. wie macht ihr das? Mit freundlichen
>Ähnlich verhält es sich bei der Ausgabe von Werten: Während ich bei Port >A "blind" schreiben kann, muss ich Port B erst einlesen, einzelne Bits >manipulieren, und wieder den ganzen Port ausgeben. Nö, einzelne Bits kannst du zumindest bei PORTB über cbi, sbi setzen.
-
Thread
Pins einlesen unter C
Hallo Leute, ich möchte gerne einen Pin einlesen und den Wert in einer Variablen speichern. Kann mir jemand sagen, wie dies Programmiert werden soll. Danke
Hallo, wenn Du WinAVR verwendest, ist das ganz einfach. Wenn Du zum Beispiel Port D, Pin 4 lesen möchtest, geht das mit #include <avr\io.h> bool ReadPin (void) { bool variable; variable = PORTD & 0x10; return variable
-
Thread
ADC Messung mit dem Attiny 841
(1<<TWCMD1); } } } } int main(void) { DDRA=0b00000011; // Port A auf Ausgang schalten PORTA=0b00000011; // Port A auf aus DDRB=0b00000011; // Port A auf Ausgang schalten PORTB=0b00000011; // Port A auf aus I2C_init(); while(1)
immer - einmal einlesen ist Murks
-
Thread
MCP23017 - Abfrage Taster
Hallo Zur Abfrage eines Tasters am MCP23017 habe ich folgenden Code: [c] // einlesen der Port / Taster i2c_start(MCP23017_ADDR); // Adresse i2c_write(MCP23017_GPIOB); Data = i2c_read(0xff); // liest Ausgänge ein i2c_stop(); if (Data
: [c]while(1) { // einlesen der Port / Taster i2c_start(MCP23017_ADDR); // Adresse i2c_write(MCP23017_GPIOB); Data = i2c_read(0xff); // liest Ausgänge ein i2c_stop(); i2c_start
-
Thread
xmega_Unklarheiten
nach den Virtuellen Ports durchgesucht. Dabei habe ich keine Register für das Portmapping wie bei den anderen Xmegas (VPCTRLA und VPCTRLB) gefunden. Im AVR-Studio 6.2 habe ich dazu ebenfalls nichts gefunden. Nun würde mich
TCC5 verwenden und der korrekte Befehl lautet: TCC4.CTRLA = TC45_CLKSEL_DIV256_gc; Das virtuelle Port D (=VPORT2), Pin 0 müsstest Du wie folgt einlesen können: if(VPORT2_IN && PIN0_bm){ ... Code }
-
Thread
I2C-Bus: SDA und SCL an ATMEGA328p
SDA-Pin als auch der SCL-Pin jeweils als Ausgang und als Eingang verwendet. Kann ich dazu z.B. die Port-Pins PD.2 und PD.3 verwenden? Wenn diese als Ausgänge konfiguriert werden, sollte dann trotzdem das Einlesen der Eingangspegel an den Pins mit den folgenden Makros funktionieren? [c] #define I2C_SDA_PIN
Beitrag #7442415: > ich habe eine Frage zur Verwendung des I2C-Bus mit einem ATMEGA328p Der konkrete AVR hat eine TWI Einheit in Hardware. Wieso willst du das in Software erledigen? Wo ist deine Notlage, die dich dazu zwingt? Zudem: Rainer G. schrieb im Beitrag #7442415: > void Port_Init (void
-
Thread
Falsche Anzeige nach Spannungsverlust
void LCD_Init() { RS_LOW; delay_ms(110); PORTC = 0b00110000; // Setze D4, D5 Port zu 1 _E(); // High->Low zu E Port (Puls) delay_ms(80); PORTC = 0b00110000; // Setze D4, D5 Port zu 1 _E(); // High->Low zu E Port (Puls) delay_ms(80); PORTC = 0b00110000; // Setze D4, D5 Port zu 1 _E(); // High->Low zu E Port (Puls) delay_ms(80); PORTC = 0b00100000; // Setze D4 zu 0, D5 Port zu 1. Wechsel in den 4 Bit Modus. _E(); // High
-
Thread
mega 8 lässt sich nur sporadisch beschreiben
; Richtungsregister DDRD als Eingang konfigurieren loop: in r16, PIND ; an Port D anliegende Werte (Taster) nach r16 ; einlesen out PORTB, r16 ; Inhalt von r16 an Port B ausgeben rjmp loop ; Sprung zu "loop:" -> Endlosschleife
; Richtungsregister DDRD als Eingang konfigurieren loop: in r16, PIND ; an Port D anliegende Werte (Taster) nach r16 ; einlesen out PORTB, r16 ; Inhalt von r16 an Port B ausgeben rjmp loop ; Sprung zu "loop:" -> Endlosschleife [/avrasm
-
Thread
mehrere Pins vom Mega32 einlesen und Frage zu Ponyprog
ich möchte die Daten von mehreren Port-Pins mit der gleichen Subroutine verarbeiten. Geht das überhaupt? Die Schwierigkeit liegt darin, daß beim Einlesen eine Nummer erwartet wird und somit keine Variable möglich erscheint. Ich hatte
Du willst Port *und* Pin "hochzählen"? Bei den Pins ist das ja kein Problem. Beim Port musste eben ne separate Abfrage machen.
-
Thread
Schieberegister: Abfrage von mehreren Tastern
OK. Erstes Testprogramm [c] #include <avr/io.h> // Schieberegister MC14021 #define SR_DDR DDRB #define SR_PORT PORTB #define SR_PIN PINB #define SR_PS PB0 #define SR_C PB1 #define SR_DATA PB2 #define SET_BIT(p,b) p
// 1 MHz #define BAUD 31250 // MIDI-Baudrate (31,25kBit) #include <avr/io.h> #include <util/setbaud.h> // Schieberegister MC14021 #define SR_DDR DDRB #define SR_PORT PORTB #define SR_PIN PINB #define SR_PS PB0 #define SR_C PB1 #define SR_DATA PB2
-
Thread
STM32 counter up/down mit Step/Dir Signalen
Mi N. schrieb im Beitrag #7426100: > Oder anstatt diskreter Logik ein 8-pol. AVR zur Umsetzung Step/Dir -> > PhaseA/PhaseB verwenden und dann auf die STM-Timer geben. Genau so hab ich es vor wenn es keine interne Möglichkeit im STM32 gibt. Die AVR's in Assembler für die Wandlung
, geht im AVR zuverlässig. over/underrun der 3 16bit counter muss ich noch weiter testen.
-
Thread
Uhrzeit stellen
= *port; _delay_us(150); if( (*port & maske) == (port_puffer & maske) ) entprellungs_puffer |= 0x01; } } int main(void) { lcd_init(); lcd_setcursor(1,1); lcd_string( "
= *port; _delay_us(150); if( (*port & maske) == (port_puffer & maske) ) entprellungs_puffer |= 0x01; } } int main(void) { char str[2+1]; // <=== War vorher zu klein für zwei Dezimalstellen
-
Thread
Taster einlesen und abfragen - Probleme?!
bin ich leider immer noch nicht auf die Lösung gekommen, wie ich denn nun meinen Taster richtig einlese! Da ich ebenso noch Neuling auf diesem Gebiet bin, verstehe ich meist die Codes, welche von echten "Profis" erstellt wurde, nicht. VOn AVR GCC wurde ich ebenso wenig schlau! Eventuell gibt
Port D ist dein Eingang, du liest aber von PINC. Port B ist dein Ausgang, du schreibst aber auf PORTD. Zeige deinen Schaltplan. Was ist wie wo angeschlossen?
-
Thread
C++ auf einem MC, wie geht das?
definiere dann meine Ports als Konstante . #ifdef __AVR_ATmega16__ constexpr AvrPortRegsTyp1 PORTA = {0x19,0x1A,0x1B}; constexpr AvrPortRegsTyp1 PORTB = {0x16,0x17,0x18}; constexpr AvrPortRegsTyp1 PORTC = {0x13,0x14,0x15}; constexpr AvrPortRegsTyp1 PORTD = {0x10,0x11,0x12}; #endif // __AVR_ATmega16__ #ifdef __AVR_ATtiny1634__ constexpr AvrPortRegsTyp2 PORTA = {0x0F,0x10,0x11,0x12}; constexpr AvrPortRegsTyp2 PORTB = {0x0B,0x0C
-
Thread
Probelme bei einem Programm
;Richtungsregister DDRD als Eingang konfigurieren loop: in r17, PINA ;an Port D anliegende Werte (Taster) nach r16 einlesen out PORTC, r17 ;Inhalt von r16 an Port B ausgeben rjmp loop ;Sprung zu "loop:" -> Endlosschleifede" -> Endlosschleife
Stattdessen erzählst Du was von C un SPS... In Deinem Beispiel schreibst Du > in r17, PINA ;an Port D anliegende Werte (Taster) nach r16 einlesen > out PORTC, r17 ;Inhalt von r16 an Port B ausgeben Überlege bitte mal, ob Du wirklich weißt, was Du willst. Und wenn ja, dann sorge dafür, dass Programm
-
Thread
Fragen zur erstnutztung meines stk500
SHIFT+P den programming dialog aufrufen. Wenn hier das Tool STK500 und der am PC angeschlossene COM-port angewählt sind, kannst du über den Knopf "read" bei target voltage, die aktuell am board eingestellte target-spannung einlesen. Bekommst du hier eine Fehlermeldung, dann besteht keine Verbindung zwischen
+P den programming dialog aufrufen. > Wenn hier das Tool STK500 und der am PC angeschlossene COM-port > angewählt sind, kannst du über den Knopf "read" bei target voltage, die > aktuell am board eingestellte target-spannung einlesen. > Bekommst du hier eine Fehlermeldung, dann besteht keine Verbindung
-
Thread
AVR Ports und Pins Verständnisfrage
Hallo ich habe eine Anfängerfrage bzgl. PORTS und PINS bei AVR Controllern. Soweit ich das verstehe haben ja PORTB, PORTC und PORTD jeweils mehrere Pins. Wenn ich jetzt also auf einem bestimmten I/O Ausgang eine digitale 1 ausgeben will muss ich
setzt einen Ausgangs-Port/Pin oder wenn es ein Eingang ist aktiviert er den Pullup. Das Pin-Register ist zum einlesen eines Eingangs gedacht. Wenn es Pin7 Hardwäremäßig nicht gibt passiert außen eben nichts.
-
Thread
Potentiometer mit ADU Atmega328PB [HILFE]
zwei Bibliotheks-Dateien eingebunden werden (bitte Punkte passend ersetzen) #include <avr/interrupt.h> #include <avr/io.h> // Felddeklarationen (Arrays) passend für die LED-Segmentbits zu den jeweiligen Ziffern 0..9 (1=an, 0=aus, 0=Restbits) // ACHTUNG: Geändert gegenüber den bisher
auch soll, aber die Aufgabe verbietet die direkte Wertezuweisung und erwartet dass modifizieren von PortC und PortD über Maskieroperationen. [c] #define F_CPU 16000000 //Nachfolgend müssen zwei Bibliotheks-Dateien eingebunden werden (bitte Punkte passend ersetzen) #include <avr/interrupt.h>
-
Thread
AD Wandlung von 128 Bits in 1ms
@Matthias: Da könntest du wirklich recht haben, dass das ein AVR auch noch schaffen kann. Sehr viel muss man ja nicht machen. Eigentlich muss man nur die Daten an nem Port einlesen und ins intere RAM abspeichern. Alle weiteren Schritte kann man ja machen, wenn
"Eigentlich muss man nur die Daten an nem Port einlesen und ins intere RAM abspeichern" Schön und gut, aber wie will ich eine Spannung an einem Port einlesen und ins RAM abspeichern? Das Signal is ja analog und nicht digital. Da muss ich
-
Thread
Led und taster
Das PORTx-Register ist zum setzen eines Ausganges, oder für die Pullups. Du brauchst zum Einlesen eines Wertes von einem Port aber das PINx-Register. Also musst Du anstatt "k=PORTA" "k=PINA" schreiben. PORT-Register: Zustand eines Ausganges setzen PIN-Register: Zustand eines Einganges einlesen
Ports und wird zum Einlesen vom Zustandes eines Einganges benutzt. Kurz gesagt: PORTx zum Setzen eines Ausganges, PINx zum auslesen eines Einganges. Gruß Jonathan
-
Thread
AVR assembler frage, IO ports
in temp,porta ;Port (nicht PIN) einlesen cbr temp,0b00001111 ;die gewünschten Bits auf 0 setzen andi temp1,0b00001111 ;die unerwünschten Bits auf 0 setzen or temp,temp1 ;die gewollten Bits übernehmen
Das hat ja auch jeder AVR... - Oder???
-
Thread
-
Thread
XMEGA128A1 Pin einlesen
sich doch etwas tun? #include <avr/io.h> #include <avr/interrupt.h> void io_init(void); void clock_init(void); int main(void){ clock_init(); io_init(); while(1){ PORTE.IN = PORTE.OUT; } return
[c] PORTE.DIR = 0xff; PORTE.DIR = 0x00; ^------------- ? [/c]
-
Thread
PIN s einlesen in C
Hallo, könnt Ihr mir als Anfänger mal folgende Fragen beantworten? Ich lerne am besten an Beispielen. Wozu sind die folgenden Definitionen: \avr\portpins.h *********************************************************** /* Port Data Register (generic) */ #define PORT7 7 ... /* Port Data Direction Register (generic) */ #define DD7 7 ... /* Define PORTxn values for all possible port pins. */ /* PORT A */ #if defined(PA0) # define PORTA0 PA0 ... ***************************************************** \avr\ z.B. m8.h **********************************
-
Thread
Pic 12F675 Frequenz einlesen und geändert ausgeben
----------------------------------------------------------------------- 2) Ich möchte an einem port eine Analoge Spannung 0-5V einlesen und Digital verarbeiten. z.B. eingelesener Wert 155 am AD Eingang Im Programm abfragen, ob der Wert: #anfang abfrage des AD-Ports AD-port = 155 if
das >Programmiert. Beispiel direkt für den PIC gibt es hier nicht, im wesentlichen nur für den AVR. Das Prinzip bleibt das Gleiche. Stichworte Input Capture und Output Compare Funktion, [[Timer]]. Ausserdem: >Ich möchte mit dem Pic 12F675 an einem Port eine Frequenz von 0-3MHz >einlesen ändern
-
Thread
SPI mit Attiny 841 und MCP23S17
MCP23S17 erfolgt keine Anzeige. [c] #define F_CPU 16000000UL #include "util/delay.h" #include "avr/io.h" // Attiny 841 ATtiny841 old Atmega48 #define SPI_DDR DDRA // DDRA DDRB #define SPI_PORT PORTA // PORTA PortB #define SCK
alten Problem und muss erst mal meine "alte" Software zum laufen bekommen. Danach soll aber das einlesen von Ports kommen um den MCP23S17 besser zu verstehen.
-
Thread
-
Thread
Tasten entprellen - Bulletproof
Ich tue in der zwischenzeit komplett alle Ports immer über Interrupts einlesen. Dann habe ich globale Variablen mit dem namen PORTX_STATE PORTX_PRESS PORTX_UNPRESS für jeden PORT. Und habe dann alle Eingänge schön entprellt.
Den Code einfach ein zweites Mal mit geänderten Variablen- und Port-Namen anhängen, das Ganze evtl. noch etwas nachoptimieren. Oder: Alle 8-Bit-Variablen in 16 Bit ändern und beim Einlesen der Ports die beiden 8-Bit-Werte zu einem 16-Bit-Wert zusammenfassen. Dies
-
Thread
Tutorial und Simulator, Frage zu DDRB
aktivieren. Dies geht deshalb durch eine Ausgabe ; nach PORTD, da ja der Port auf Eingang gestellt ist. loop: in r16, PIND ; an Port D anliegende Werte (Taster) nach r16 einlesen out PORTB, r16 ; Inhalt von r16 an Port B ausgeben rjmp loop
Simulator das Einlesen eines Pinzustandes simuliert werden soll, muss dazu PIND angeklickt werden! Port D konfiguriert als *Output* (DDRD = 0xFF) --> Änderung an PORTD-Register schaltet die Ausgangs-Treibertransistoren
-
Thread
spannung einlesen auf led-reihe ausgeben
hier im AVR-GCC Tutorial ist ein Beispiel für das Einlesen vom ADC.
Port F (PF7..PF0) Port F serves as the analog inputs to the A/D Converter. steht im datenblatt...
-
Thread
anfänger bei assembler
Für den einfachen Anfang reicht der sbic/sbis Befehl zum Einlesen des Port-Pins und der sbi/cbi Befehl zur Ausgabe eines Bits auf dem Port-Pin. sbic - überspringe nächsten Befehl, wenn PinX im PortPinX '0' ist sbis - überspringe nächsten Befehl, wenn PinX im
meine nächste Anfängerfrage ^^ ich möchte versuchen das ein zähler entsteht der mir den stand am port mit leds binär ausgibt durch anzahl der tastenklicks soll der zähler weiterzählen ich verwende dazu den code AVR-Tutorial: Tasten \\ 4.1 Einfache Tastenentprellung und Abfrage \\ mit timer ,
-
Thread
Idee:Speicheroszilloskop(keine eierlegende Wollmilchsau!!!)
angesteuert? Dieser müsste ja mindestens eine Clock erhalten, die irgendwie synchron zum Einlesezyklus im AVR ist. 2. Für das einlesen eines Ports und das speichern im RAM sind zwei Anweisungen nötig: in R16, PINA st z+, R16 Diese brauchen insgesamt 3 Taktzyklen. Folglich käme beim aneinanderreihen
Lochraster mit einem Mega32 und einem ADS800U (den hatte ich noch da :-)) gemacht und kurze Routinen zum Einlesen geschrieben. Der AD-Wandler ist mit einem Port verbunden, der Takt kommt direkt aus dem AVR Oszillator. Nun kann ich mit 16/3Mhz einen Single-Shot durchlauf machen (1024 Werte derzeit. Ist schon
-
Thread
wie Daten an MSP430F1611 seriell einlesen?
Offensichtlich ist mein Problem so trivial, dass ich nichts darüber finde. Der Temperaturfühler TSic 506 sendet in Abständen von ca. 3ms seine 2 Bytes langen Daten seriell auf einer Datenleitung. (mit 8kHz). Die Datenleitung soll bei mir an P2.5 des MSP430 angeschlossen sein. Und jetzt mein Problem: Wie kriege ich die ankommenden Nullen und Einsen seriell in einen Puffer, um dann diese weiterverarbeiten zu können. Als Ansatz hatte ich mir gedacht, ich definiere eine Variable, und schiebe den Inhalt der Variablen nach jedem Takt um eine Stelle nach links. Aber wie kann ich P2.5 abfragen,
-
Thread
IR NEC Protokoll einlesen
*********** SIGNAL (SIG_OVERFLOW2) //Interruptroutine Zählerüberlauf { static unsigned char In_Port,stat; In_Port = IR_PP1; //Lese Wert von Port ein if(In_Port == 1) //Wenn Input High { //Setze Bit auf 1 TIMSK &= ~0x40; //Lösche Timer Overflow Interrupt
Hallo zusammen Bin mir sicher es ist ein Timingproblem oder ein Problem beim enlesen des Port's. Denn ich lese immer High ein Ist es überhaupt möglich den externen Interrupt sowohl als Flankentrigger wie auch als Eingangsport zu nuzen? Mache ich beim Einlesen einen Fehler? In_Port =
-
Thread
2x5 Tastenmatrix an AT90USB1287
nahe 0 Ohm gemessen werden, würde ich die Tastatur über Serienwiderstände anschliessen, um aus den AVR Ports nicht zu viel Strom zu saugen.
"Pulsblinkens" blinkt die LED im 1s-Takt weiter... Tastendruck egal, selbst bei einem anderen Port (PortF). Ich finde es schon etwas sonderlich, denn heute Nachmittag konnte ich deutlich beobachten, wie der AVR nach den 10 Phasen des "Pulsblinken" auf das 2s Blinken gewechselt ist. Nach dem