-
Thread
Inline Asm
Hi, ich habe folgenden Code, um in einer Interruptroutine Port D einzulesen: [code] unsigned char volatile G_cLastData = 0xAA; void __attribute__ ((naked)) SIG_INTERRUPT0 (void) { // Port D einlesen __asm__ __volatile( "push r2"
lvalue in asm statement ../Treiber_Parallel.c:192: error: output operand constraint lacks `=' C:\AVR\WinAVR\utils\bin\make.exe: *** [Treiber_Parallel.o] Error 1 [/quote]
-
Thread
Frequenzmessung mit Timer0 ohne ICP
mega16.h> ist das in deiner Toolchain wirklich richtig? Meine Toolchain besteht aus Linux-Kubuntu, avr-gcc, avr-libc und make zum Compilieren, und avrdude um auf den Controller zu brennen. Ich muss folgende includes machen damit es funktioniert: [c] #include <avr/io.h> #include <avr/interrupt.h>
dazu musste ich WinAVR20100110 installieren. > Wenn du schon AVRStudio hast warum willst du dann noch CodeVision benutzen? > avr-gcc, avr-libc gehören doch zu avrstudio oder ? Wenn du mit AVRstudio > arbeitest funktionieren
-
Thread
ESP8266 PWM Pin4
Peripheral Interface" Da steht nur, dass er vier PWMs erzeugen kann, aber nicht, dass sie auch einlesen kann. Der hat vermutlich schon mit dem WLAN-Gedöns genug um die Ohren. Man könnte einen AVR (oder ähnliches) nehmen, mit dem die PWN per Input-Capture-Unit messen und dann UART, I²C oder SPI an
steige ich noch auf einen teurere Hardware um... Oder auf billigere. Das ganze PWM erzeugen&einlesen macht ein kleiner AVR problemlos, und kann auch per UART/I²C/SPI mit dem ESP kommunizieren...
-
Thread
230V "abtasten" am µC - Eingang?
kondensator und das so dimensionieren das dort eben z.b. 4 V abfallen die du dann am eingang deines µC einlesen kannst
2F%2Fww1.microchip.com%2Fdownloads%2Fen%2FAppNotes%2FAtmel-2508-Zero-Cross-Detector_ApplicationNote_AVR182.pdf&usg=AOvVaw1pk-WBC4ICznBtDdsW1xhf MfG Spess
-
Thread
Wie kann ich Daten von einen Triple Axis Accelerometer an den PC per USB senden?
die Erklärung. Was ich brauch ist dann wohl das Gyroskop. Ich möchte auch gerne über den USB Port arbeiten, allerdings kann ich da auch gerne mit einer serielle Schnittstelle anfangen. Auch danke für diesen Tipp.
Projekte nachprogrammieren zu können, d.h. kostet was. > > Andere können dir sicherlich für ARM. AVR, ... Empfehlungen geben. Ok danke, dann würde ich wahrscheinlich eines der beiden nehmen. Wahrscheinlich 32-Bit PIC32 Was würde ich denn noch alles brauchen? Ach ja Löten kann ich, allerdings
-
Thread
Taster an Atmega8 -> Problem
den griff. die wollen einfach nicht gehen. hier zum anfang erstmal das c-programm: #include <avr/io.h> #include <stdio.h> #include <inttypes.h> int main(void) { DDRD = 0xff; //Port wird als ausgang definiert PORTD = 0xff; //Port wird auf High gelegt, leds leuchten nicht
;Richtungsregister DDRD als Eingang konfigurieren loop: in r16, PINC ;an Port D anliegende Werte (Taster) nach r16 einlesen out PORTD, r16 ;Inhalt von r16 an Port B ausgeben rjmp loop ;Sprung zu "loop:" -> Endlosschleife Meine Taster sind low
-
Thread
Input Capture bei XMega - welcher pin?
Also: Du hast pro Port (Gruppe von 8 IO Pins) max. 2 Interupts. Jeder dieser beiden Interupts kann durch jeden der 8 Pins aufgerufen werden. Für den Interupt0 gibt es das Register INT0MASK (das gibt es für JEDEN Port
Flanke eines Pins ausgelöst wird, wird im PINnCTRL eingestellt. (Dieses Register existiert 8 mal pro Port (für jeden Pin). Details siehe Datenblatt: IO-Ports - Register description.
-
Thread
Timer0 löst PCINT1 Interrupt aus?
ist, dass die Pins bitweise nummeriert sind, die PC-Interrupts aber byteweise bzw. Portweise (ein Port (und damit ein PCI-Handler) kann bis zu 8 Bits bzw. Pins haben). Alle Pins des ATTiny85 liegen auf PortB, also gibt es nur einen PCI-Handler für alle Portpins, und das ist PCINT0. > - wie > nutze
Flagregister gibt. Das würde ich auch begrüßen, und wenn nur zum Zeitpunkt des Interrupts der Port (wie bei ICP der Timerstand) in ein Zwischenregister eingelesen würde. Man kann aber leider nicht alles haben... ...
-
Thread
Verschiedene Tastenzuweisungen
verschiedene Ports. In AVR-ASM ist das ein Klacks, wie man es in C formuliert und dabei effizienten Code erhält, das weiß ich allerdings nicht. ...
das ja sowieso. Ich würde genz einfach die Signale (entsprechend) umgestellt so wie sie vom Input-Port kommen, auf den Output-Port durchschleifen. > Oder wie mach ich das jetzt Richtig mit dem von dir vorgeschlagenen > Array mit Bitmustern? Einfach umkodieren. Input einmal einlesen und für jedes
-
Thread
USB Joystick Controller mit Mega8
Ähm Tschuldigung, bin bei Copy und Paste in der Zeile verrutscht. Gemeint ist AVR309. http://atmel.com/dyn/resources/prod_documents/doc2556.pdf http://atmel.com/dyn/resources/prod_documents/AVR309.zip mfg, Stefan.
Naja, mit C ist in dem AVR309 nicht viel. Das ist alles Assembler. Leider nicht schlüsselfertig zum in den AVR brennen. Alternativ könnte der Key-Warrior für Dich interessant sein? Zu finden bei http://codemercs.de/. mfg
-
Thread
Mein erster Schaltplan. Kritiken (konstruktiv) sind ausdrücklich erwünscht.
3Leitungen realisieren - Ohne Schieberegister. Oder 8 Eingänge mit einem 8zu1 Multiplexer HC151 einlesen, braucht auch nur 4 Port-Pins aber ohne Takterei. Warum Pulldown am Button-Port? rgds
Denke ich auch. 6A66 schrieb im Beitrag #3645284: > Eingänge mit einem 8zu1 Multiplexer HC151 einlesen, braucht auch nur 4 > Port-Pins aber ohne Takterei. kenne noch nicht viele ICs 6A66 schrieb im Beitrag #3645284: > Warum Shift-Register? (!Schreibweise) ;) 6A66 schrieb im Beitrag #3645284
-
Thread
Wie lange Assemblerprogrammierung IC ADC ?
einlesen kann. ...
. Um das mal zu belegen. Eine einfache LED-Klasse könnte etwa so aussehen: [c] #include <avr/io.h> class led { volatile uint8_t * const port; volatile uint8_t * const pin; volatile uint8_t * const ddr; const uint8_t bit; public: led(volatile
-
Thread
HEX Editor AVR Controller
sicher viele Ergebnisse, auch den Link zum Hersteller aus China. Der Programmer ist auch für die AVR Controller gut geeignet wenn man die Ausführung mit dem ISP Port hat. Die Software kann auch ohne Programmer Hardware verwendet werden, um z.B. die HEX Files zu bearbeiten.
sicher viele Ergebnisse, > auch den Link zum Hersteller aus China. > Der Programmer ist auch für die AVR Controller gut geeignet wenn man die > Ausführung mit dem ISP Port hat. Bist du nicht in der Lage zu liefern? Ich soll für dich mich durchs Internet zu wühlen? Bist du nicht in der Lage zu zitieren
-
Thread
Beratung: Suche pendant zu C-Control II ?
decrement; long timerPuls, timerTor, tA, tAvgl, laenge, Lagen, laengencount, lagencount, port0cnt[3], port1cnt[3], port2cnt[3]; string s; ports.getcount(1); ports.getcount(2); ports.getcount(3); ports.deact(8); ports.deact(9); ports.deact(10); ports.deact(11);
------------------- Puls0[0] = Puls0[2] - a*port2cnt[0] + b*port2cnt[1] + c*port2cnt[2]; //Motor "0" wird ja von Eingang "2" beeinflusst Puls0[2] = Puls0[1]; Puls0[1] = Puls0[0]; port2cnt[2] = port2cnt[1]; port2cnt[1]
-
Thread
Kann ich das noch retten? Pins gegen GND als Schalter lesen
Pin-Vergleichen noch nicht > so, wann was bei welchem Vergleichszeichen 0 oder 1 wird oder warum ich > mal PORT und mal PIN nehmen muß. Bei letzterem, einfach mal hier nachlesen. http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Zugriff_auf_Ports Das hier ist zwar für Assembler geschrieben, die
andere davon ist auch für einen C-Programmierer wichtig: http://www.mikrocontroller.net/articles/AVR-Tutorial:_IO-Grundlagen#Zusammenfassung_der_Portregister http://www.mikrocontroller.net/articles/AVR-Tutorial:_IO-Grundlagen
-
Thread
Eclipse Programm (Mikroprozessor)
mir die inzelnen Schritte nochmal erklären könntet. Danke im Vorraus. CODE: #include <avr/io.h> #include <util/delay.h> void initPort_AinBout(); void putByteLED_B(unsigned char); unsigned char waitforKey_A(); unsigned char getKeyNum(unsigned char); void putPattern(unsigned char[]
Zu deiner Frage passt besonders dieser Abschnitt im AVR-GCC Tutorial: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Zugriff_auf_IO-Ports
-
Thread
ATTiny 2313 Änfängerfrage
Du arbeitest, aber > probier mal, ob dieses Programm übersetzt wird und läuft: > Ich arbeite mit AVR STudio und WinAVR müsste also klappen. Leider kann ich erst am Sonntag abend bescheid geben ob es funktionert hat da ich übers we weg bin. thx bis sonntag bzw montag
bei der 7 immer noch die 0 schwach durchleuchtet. Wie kann ich das umgehen. Ich hab auch schon im AVR Tutorial nachgelesen zwecks Geisterleuchten, komm aber gerade nicht weiter. Hier zusätzlich mein Code. vielen Dank [c] #include <avr/io.h> // Namen der IO Register #include <util/delay.h
-
Thread
Rotary Encoder
> beide normal als output gesetzt... Vielleicht doch als Eingang und beim PortB sind die Pullups aktiv? Der PortE hat keine Pullups.
einlesen: http://www.mikrocontroller.net/topic/112603#new Peter
-
Thread
Taster um Windows zu steuern?!
nun habe ich hier die Verschiedensten Gerätschaften rumliegen, die mit dem PC Kommunizieren können: AVR-NET-IO, Arduino und ein Raspberry.... Die Frage ist nun ob ich über eine der Eingangsgrößen auf irgendeine weise die Effekte abrufen kann?! Ich habe gestern krampfhaft versucht die über das Arduino
mir das ganze ja erstma auf meinem PC so vorgestellt: import processing.serial.*; Serial myPort; // The serial port void setup() { // List all the available serial ports println(Serial.list()); // Open the port you are using at the rate you want: myPort = new Serial(this, Serial.list
-
Thread
Lib für ESp8266 und DCF77
PD0 und PD1 sind in der regel mit dem seriellen Port verbunden und dadurch bereits intern belegt. Du solltest zuerst einfach mal den Pin einlesen und auf eine LED ausgeben (per Software!), um zu prüfen, ob die Hardware überhaupt funktioniert. [c
nicht" ist ein bisschen mager formuliert. PS: Warum weiß ich das eigentlich auswendig, obwohl ich AVR's noch nie mit Arduino programmiert habe?
-
Thread
UART-Fehler :(
#include <avr/interrupt.h> #include <avr/io.h> #include <avr/iom169p.h> #include <avr/portpins.h> #include <avr/sfr_defs.h> #include <stdint.h> #define BAUD 9600 #define FOSC 1843200 //Taktgeschwindigkeit
Timing was nicht. Also nochmal: Taktfrequenz kontrollieren #define F_CPU 8000000 #include <avr/io.h> #include <utils/delay.h> int main() { int i; DDRB = 0xFF; // Port B auf Ausgang oder wo du halt sonst // ein paar LED drann hast while( 1 ) { PORTB = 0xFF
-
Thread
Konzept für Funkuhr und Soft-PWM
Moin, Ich habe eine fertige Schaltung, in der die Helligkeit mit einem LDR ermittelt und von einem AVR ATMega16 über ein ADC-Pin ausgewertet wird. Abhängig von diesem Wert soll nun die Helligkeit von vier 7-Segment-Anzeigen eingestellt werden, die parallel an vier Ports hängen. Klar ist, das ganze muss
INT0 Ist unnötig und bisweilen fehleranfällig. >Vier 7-Segment-Anzeigen hängen an den vier Ports Ohne Multiplexen? Sollte man nicht machen. [[AVR-Tutorial: 7-Segment-Anzeige]] >erledigt wird. Welche Prozesse interruptgesteuert sind (DCF77 natürlich über externen Interrupt) Ganz unnatürlich
-
Thread
Assembler wieder auf dem Weg nach vorn Gesperrt
Sorry. Der steckt schon in einem gekauften XportPro. > Das schmälert den Nutzen des Traumgespanns ASM/AVR aber in keiner Weise > ;-) Hi Moby, die X-Ports sind schon ganz nett, aber relativ teuer. So ein Teil kostet um die 70 Euro. Wäre es da nicht sinnvoller einfach einen günstigen 32bitter mit integriertem
Ausnahme: > Z8, bei dem gab es keinen Unterschied zwischen RAM und Registern). Die Zugriffspfade (Ports) machen den Hauptunterschied im Aufwand aus. Auf RAM kann immer nur einer zugreifen, auf Register meist mehrere. Ein AVR kann pro Takt 2 Register lesen und eines schreiben. Aber pro Takt kann er nur
-
Thread
SPI über normale Pins
man die Pins geschickt, kann sogar wirklich gleichzeitig gearbeitet werden. Dann kann zB mit PortA=0x0F Alle Clk gleichzeitig gesetzt werden, wenn diese auf PortA(0...3) gemappt sind. Analog dazu MISO, MOSI und CS
Hallo, einen Port als MOSI, einen Port als MISO, 1x Clock parallel an alle Slaves, 1x CS parallel an alle Slaves. CS aktiv, damit warten alle Slaves auf Daten. Bitmuster des 2. Bits für die Slaves auf den MOSI-Port
-
Thread
Suche geeignete Simulationssoftware
Also. In deinem Fall könnte man a) ein fwertiges AVR Evaluationboard nehemen oder b) selber einen ATmega 16 oder so auf eine kleine Platine bringen und dort sämtliche IO dranhängen. Dem AVR kann man in Assembler (AVR Studio) oder C (WinAVR) programmieren
selber einen ATmega 16 oder so auf eine kleine Platine >bringen und dort sämtliche IO dranhängen. Dem AVR kann man in Assembler >(AVR Studio) oder C (WinAVR) programmieren. Das habe ich ja nun auch schon seit mehreren postings vor. Ich brauch nur eben irgend ne Kontrolle um zu sehen, dass das ganze
-
Thread
74xx165 mit 74xx595 per SPI gleichzeitig lesen/schreiben; clk-Inverter?
nicht. Verbinde den CLK-Pin (2) des 165 einfach mit der SCK Leitung. Ändere dann einfach nur die AVR-SPI-Routine etwa so in dieser Richtung ab: 1: SCK auf 0 2: Datenbit auf MOSI rausschieben 3: SCK auf 1 ; der 595 schiebt 1x rein, der 165 ein Bit raus 4: Datenbit auf MISO einlesen 5:
wollte kein Soft-SPI, sondern den USART im SPi-Modus nutzen. Hab schon alle leitungen umverlegt von PortC nach PortD. Wer lesen kann ist klar im Vorteil! Zum Thema: ich hab mich jetzt dazu entschlossen die Platine einfach mit dem transistor-inverter zu bauen und zu hofen dass es klappt. Aber das sollte
-
Thread
Programmierung myAVR-Board
BASCOM Vorlage für SiSy AVR-Board '---------------------------------------------------------- $regfile = "m8def.dat" $crystal = 3686400 ' hier Initalisierung durchführen Ddrb = &B00000001 ' PortB.0 auf Ausgang Do ' Beginn
Programmer ist "AVR ISP Programmer" Bei "AutoFlash" ist ein Haken dran, genau so bei "AutoVerify" Dann ist bei "Parallel" die LPT-Adress 378, Port Delay ist 0, bei "Universal" ist "WinAVR and SP12" eingestellt, habe
-
Thread
Sensordaten multiplexen
selbst die Daten einlesen)" Vielen Dank!!!
AVR hat sogar bis zu 8 ADC kanäle, sodass du entweder 3 AVRs benuzt oder halt Multiplexer (wobei das escht so sit das son Multiplexer bald teurer als nen weiter uC ist :D )
-
Thread
AVR Rom über USB auslesen
gedacht, das ich mit visual basic (vb wegen dem einfachen erstellen von forms) per button den wert einlese und einem label zuweise. mit dem usart habe ich ja nen virtuellen com port(port 3). aber wie greife ich nun an die speicherzelle des wertes auf dem µc zu?
Programmiersprache darf's denn sein? Für C empfehle ich mal beispielhaft folgendes: http://www.nongnu.org/avr-libc/user-manual/group__avr__eeprom.html Wie Du das ganze per UART loswirst, kannst Du z.B. hier im Wiki http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Der_UART nachlesen. Oder habe *ich
-
Thread
Flankenauswertung bei vielen Tasten
viel RAM damit belegen. Man kann es sich aber auch einfach machen und alle Tasten an den selben Port anschließen und den ganzen Port entprellen. Die ARM haben ja mindestens 16Bit breite Ports und beim AVR nimmt man 2 Ports, die man in ein uint16_t kombiniert. Oder man nimmt einen ADC-Eingang und ein
im Beitrag #5518816: > Man kann es sich aber auch einfach machen und alle Tasten an den selben > Port anschließen und den ganzen Port entprellen. Die ARM haben ja > mindestens 16Bit breite Ports und beim AVR nimmt man 2 Ports, die man in > ein uint16_t kombiniert. Und Bernd hat darauf hingewiesen
-
Thread
PWM möglich? - C - ATmega103L
http://www.mikrocontroller.net/wiki/AVR-GCC-Tutorial fang hier an
Ok danke für den Link. Ist sehr nützlich. Die Grundsätzlichen Dinge wie Port einlesen usw. waren mir schon bekannt. Habe jetzt das Meiste gelesen was ich wohl brauchen werde um dieses Projekt zu erstellen. Jedoch wäre ein Beispiel-Programm, dass ein veränderbares PWM Signal
-
Thread
LCD an T6963C und ATMega323
was allgemeines: controller ATMega323 auf STK500 mit AVR Studio 4.xx ja, du hast recht, der kommentar ist falsch - hab im nachherein die ports vertauscht. egal. PINB sind die portpins vom PORTB (datenbus). ich rufe an dieser stelle deren status ab (
I want to turn a AVR into a wet pussy. Can you help me?
-
Thread
Batterie Spannung messen: stromsparendste Methode für spezielle Anwendung
3,1V-4,1V lebt der Akku länger. Aber du nutzt ca. 15% der Kapazität nicht. Effektiv lässt du deinen AVR so lange laufen, bis entweder die Akkuspannung unter 3,1V gesunken ist oder er einfach ausgeht. Den LDO ignorierst du, der AVR hat ne BOD. > Aus Stromspargründen gibt es noch die Überlegung den LDO
Platinchen mit dem TXS108E günstig zu haben. Aus dem Datenblatt: "FEATURES 1.2 V to 3.6 V on A Port and 1.65 V to 5.5 V on B Port (V CCA ≤ V CCB )"
-
Thread
Ausgang nur kurz schalten
sich kompliziert an, ist es aber nicht hier mal der Code: [avrasm] Read_IO: IN Reg_A, Port_C ; Port einlesen COM Reg_A ; Bits drehen ANDI Reg_A, 0b00011100 ; nicht relevante Portpins ausblenden LDS Reg_B, in_Debounce ; kontrollierte Bits holen EOR
Kompiliere die Datei Test_C.cc. In file included from Test_C.cc:17: C:\Program Files (x86)\SiSy3 AVR\Compiler\winavr\avr\include/avr\delay.h:36:2: warning: #warning "This file has been moved to ." Linke die Datei Test_C.elf. Ende.
-
Thread
AVR ATMega32 ADC Konfiguration
------------ Die Ansteuerung der LEDs selber funktioniert einwandfrei. Wenn ich die Ausgänge an PortD "fest" auf 1 setze, verhält sich die Schaltung wie gewollt. Mein Problem bezieht sich lediglich auf das Einlesen der Spannungswerte der Potis P1 - P3 an PortA. Was ich schon mal mit Sicherheit sagen
~1MOhm). Da vermutest du falsch. AVCC ist ein Stromversorgungsanschluß. Damit wird der ADC und PortA versorgt. MfG Spess
-
Thread
AVR + 74HC165 + UART
Moin, ich habe mal ein bisschen was zusammengetipselt und habe nun das Problem, daß ich über UART nur was empfange, wenn ich den Schalter (mit Pull UP) am D7 des SR verändere. Alle anderen Schalter ergeben keine Reaktion. Ich habe zum testen mal nur ein SR angehängt, dessen Serial In mit Masse verbunden. Wenn ich jetzt Schalter 7 umstelle, dann wird der gesamte 16-Byte-Satz den ich empfange komplett 1 oder komplett 0. Ich schätze daß irgendwas am umschalten Shift/Load oder so nicht hinhaut. Vllt hat da jemand den Durchblick und schaut sich das kurz an? LG [c] unsigned char Data_to_send[17
-
Thread
Fragen zu Arduino und Interrupt und direktes Port lesen
goes to PIN 2 and generated interupt on falling // address nibble A7..A4 goes to PINs A3..A0 on (PortC) at UNO // data byte high nibble is on PINs D11..D8 on (PortB) at UNO // data byte low nibble is on PINs D7..D4 on (PortD) at UNO // way of working: // 1. at /IOW falling, trigger interrupt //
solltest Du auf sämtliche Manipulationen der Werte in der ISR verzichten, sondern nur die drei I/O-Ports einlesen und die Rohdaten aufheben, um sie in Deiner "loop" o.ä. zu verarbeiten. Die Adressauswertung und das Erzeugen Deines "state"-Flags muss ebenfalls dort erfolgen. Warum ist "data" auf zwei
-
Thread
STK500 Atmega8515 und einfaches C-Programm
AVR Prozessoren nicht zwei Port - Anweisungen direkt nacheinander ausführen kann. Also sprich ich kann nicht an Port D einlesen und direkt danach an Port B etwas ausgeben. Ich weis nicht ob ich das richtig
allerdings nicht. Vielleicht könnt ihr mir ja weiterhelfen! MFG BlueMorph [c] #include <avr/io.h> #define ausgang 0xff #define eingang 0x00 #define all_leds_out 0xFF int main (void){ uint8_t bPortD; DDRB = ausgang; DDRD = eingang; PORTB = all_leds_out; while
-
Thread
erzeugter code von avrgcc ineffizient
Beim Umstieg von avrgcc 3.02 zu avrgcc 3.3 (WinAVR) bin ich ueber genau dieses loop_until_bit_is_set macro gestolpert. Beim avrgcc 3.02 ist es in iomacro.h als asm-macro so definiert: #define loop_until_bit_is_set(port, bit) \ __asm__ __volatile
(port, bit) { while (!bit_is_set((port), (bit))); } Bei dieser Version verwendet der gcc den "skip on bit" Befehl (Compileraufruf natuerlich mit der Optimierungsoption -Os). Ansonsten scheint der avrgcc
-
Thread
AVR-Knowledgebase
Der Sinn ist, unter anderem auf immer wieder auftauchende "Anfänger"-Themen (zB. "Ich kann meinen Port nicht einlesen?" (PORTx statt PINx verwendet)" möglichst einfach eine Antwort geben zu können. Nämlich: Einfach einen Link zum richtigen Artikel in der AVRKB. Hier könnt ihr euch die bisherige Version
AVR Knowledge Bases : http://r.webring.com/t/AVR http://www.avrfreaks.net/ http://www.avr-forum.com/ plus noch Duzende kleinerer Seiten. Klar, etwas strukturierter haette ne Chance.
-
Thread
Viele viele Potis an Mega 16 ADC...
->Rest vom Poti an 5V und GND) und einen Ausgang damit gehst du auf den Analog eingangs deines AVR s . Mit den vier Auswahlleitungen A,B,C,D gehst du zu vier Dig. Ausgängen deine AVRs und bestimmst damit welches Poti du einlesen willst. Den INH legst du auf GND oder spendest im auch noch einen Dig. Ausgang von AVR. Gruß HansHans
-
Thread
portb= porta
Ne , ne so geht das nicht.... Wenn du zustände an porta einlesen und an portb ausgeben möchtest geht das folgendermaßen: If Pina.0 = 1 then set portb.0 else reset portb.0 end if Also liegt an port a Highpegel an, wird b.0 auch auf High gesetzt, andernfalls
Hi Mark! Momente mal. Du schreibst, Du ziehst die Eingänge an PortA nach Masse. Dazu brauchst Du ein Pull-Up (Widerstand an PortPins gegen +5V, etwa 10k bis 47k), entweder im AVR oder extern, sonst tut sich gar nix. Das interne Pull-Up machst Du über das PortA-Register
-
Thread
500V A/D Wandlung + Relais schalten --> ATMega8515
Zu 1: Einmal in C: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Analoge_Ein-_und_Ausgabe Und einmal in ASM: http://www.mikrocontroller.net/articles/AVR-Tutorial:_ADC Zu 2: Vergleichen geht in C meistens mit == Zu 3: du musst den Port so wie von dir beschrieben beschreiben. Der Port muss vorher als Ausgang definiert sein: Einmal in C: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Zugriff_auf_Ports Und einmal in ASM: http://www.mikrocontroller.net/articles/AVR-Tutorial
-
Thread
Wird meine AVR-Schaltung funktionieren?
Anhang) eine Schltung zu entwickeln mit der ich DS18x20-Sensoren (OneWire-Bus) in meine Computer einlesen kann. Da ich nicht viel von Hardware verstehe wäre es toll, wenn Ihr euch die Schaltung mal ansehen könntet. Nicht das es irgendwelche Überraschungen gibt, wenn ich die Schaltung zusammengebaut habe
Hi, R1-R4 (die PullUp's an PORTC) sind ueberfluessig. Du kannst die internen Pullups beim AVR aktivieren. Gruß Dirk
-
Thread
STM32: I2C-Master setzt ARLO-Flag (arbitration lost)
Wieso eigentlich 5V? Der STM kann nur max 3,6! Bist du sicher, dass deine für die i2c verwendeten Ports 5V-kompatibel sind?
output open drain verantwortlich ist. kannst du da die reihenfolge ändern? erst clock an, dann port init.
-
Thread
Lichtschranke anschließen Atmega16
ich was bestimmtes beachten? Hier ein ganze simples kastriertes Programm von mir [c]#include <avr/io.h> #include <avr/interrupt.h> #include <stdint.h> #include <stdlib.h> #include <util/delay.h> #include <avr/pgmspace.h> #define PORT_LED PORTC /* PORT C ZUM BETRIEB DER 'LEDs' */ #define PIN_LIGHT PINA /* EINLESEN DER PINS 'A'*/ #define LightBarrier1 PA7 /* Lichtschranken Signale */ int main(void) /* PROGRAMM START */ { DDRC = 0xff; //PORT C = Output DDRA=0x00;
-
Thread
Kupferdrahtdurchmesser bei Spulen
wird der Port auf 1 geschaltet. Die Flanke von 0 auf 1 bedeutet ein Low. Ist das Datenbit aber 1, bleibt der Port 1 (vom Startbit her ist er ja schon 1). In der Mitte des Datenbits schaltest du den Port auf 0, da
eine led oder mehrere an sind. Muss die äussere Spule nochmal ordentlicher wickeln ;) Aufbau: AVR-pin o-----[100R]------|<|---+----BC817----o +5V AVR-pin o-----[100R]------|<|---+ AVR-pin o-----[100R]------|<|---+ ... AVR-pin o-----[100R]------|<|---+ Also alle 16 leds an einem BC817, damit
-
Thread
WordClock mit DCF77, Photodiode und ATMega8
kannst Du ja noch die ein oder andere Leitung von PortC auf PortB oder PortD verlegen.
kannst Du ja noch die ein oder andere Leitung von PortC auf > PortB oder PortD verlegen. Ich denke ich werde die LEDs einfach mit weniger als 20mA betreiben. Ich werde ein paar Testläufe machen wie hell sie dann sind und den Vorwiderstand entsprechend
-
Thread
Abtastung Inkrementalgeber
Zeit. Es sollte etwas mehr Zeit zur Verfuegung stehen weil man alle sechs Leitungen an einem Port anordnen kann und dann beim einlesen auswerten einiges parallel laufen kann. Ich halte das schon fuer machbar. Die Frage ist nur warum 100kHz. Deshalb weil sich die Encoder so schnell drehen
aktuelle Datenbit ein, das wiederholt man solange bis man alle Datenbits eingelesen hat. Wenn Du einen Port für alle Datenleitungen benutzt und die Drehgeber synchron taktest, kannst Du die Datenbits von allen 3 Drehgeber gleichzeitig einlesen. Wenn es denn ABSOLUT Inkrementalgeber ;-) sein müssen, würde
-
Thread
ADC, Attiny84 interne Referenzspannung
Hallo, möchte am PA3 des Attiny84 einen analogen Wert einlesen. Die anderen Pins des Ports A werden als Ausgänge verwendet. Nun kann man im ADMUX die Bits REFS1 und REFS0 einstellen. Habe es schon im Öfteren versucht, und es hat leider nicht geklappt.
iGast schrieb im Beitrag #3917241: > möchte am PA3 des Attiny84 einen analogen Wert einlesen. Die anderen > Pins des Ports A werden als Ausgänge verwendet. Karl Heinz schrieb im Beitrag #3917312: > Was in diesem Fall aber keine Rolle spielt, da sein Messwertaufnehmer > von der selben