-
Thread
Arduino oder Mikrocontroller - Was ist besser?
nur im Grenzbereich. Ein "digital write" Befehl dauert deutlich länger als ein direktes setzen der Port-Register in c und ist nicht wesentlich einfacher. Jedoch gibts für AVR-GCC (das "normale" c für die Atmels) ebenso viele Bibliotheken. Diese sind nur viel weiter verstreut und man sucht länger.
hat. Programmieren und vor allem SIMULIEREN dann mit dem guten AVR-Studio4 (gibt Menschen, die auch das 6er mögen - AVR-Studio6 kommt mit einem c++-Compiler daher, der Compiler der 4er ist glaub rein c). Einen Programmer braucht es dann noch (zB. http://www.ebay.de
-
Thread
Assembler, Counter, 7Segment
bisheriges Programm würde in C so aussehen (ohne dein Tastenproblem damit gelöst zu haben) [C] #include <avr/io.h> uint8_t team1Points; uint8_t team2Points; // die Tastenpins am Port B #define T1_UP 0 #define T1_DOWN 1 #define T2_UP 2 #define T2_DOWN 3 #define T_RESET 4 uint8_t
zum thema AVR-Assembler Programmierung sagen ?
-
Thread
Stoppuhr mit Bascom AVR
Moin Leute, Hab jetzt schon des Öfteren mit Bascom AVR rumgespielt und nun wollte ich mal eine Stoppuhr programmieren und auf einen ATmega16 ziehen. Mir persönlich würde jetzt nur einfallen dass ich im Programm jeweils "wait" eingebe und er dann weiter
Ubersetzt zum Testen habe ich das Prg. mit Basom Version 2.0.81. Text, Zeitanzeigeformat und Taster-Ports sind deinem Prog. entnommen. Gruß Alex
-
Thread
WinAVR "unerklärliche Fehler beim compilieren"
bool Taste_x; bool Taste_4; unsigned int Lux_Ausgabe(void) // Makros #define SET_BIT(PORT, BIT) ((PORT) |= (1<<BIT)) // Einzelbit auf Port SET #define CLR_BIT(PORT, BIT) ((PORT) &= ~(1<<BIT)) // Einzelbit auf Port RESET // Funktionsprototypen void initDisplay(void); //
====== // TASTENABFRAGE void SwitchQuery() ***{ // Umschaltung Port C, Bit 0..3 auf Eingang CLR_BIT(PORTD, ENABLE); // Enable-Signal auf 0 DDRC = DDRC & 0xF0; // Port C auf Eingabe schalten PORTC = 0x0F; // Pullup-Rs eingeschaltet
-
Thread
AVR Zeit zwischen 2 Eingangssignalen messen
Beispielcode dort hat mir kaum weiter geholfen. Hier mein Code: [c] #define F_CPU 16000000 #include <avr/io.h> #include <stdlib.h> #include <avr/interrupt.h> #include "lcd.h" int taster; int overflow = 0; int mess1; int mess2; int ergebnis; char Buffer[20]; ISR (TIMER0_OVF_vect)
Zum Beispiel daran [c] DDRA=0xff; ... taster = PINA & 0xf0; [/c] wenn man vom Port A über das Pin Register den Zustand von Tasten einlesen will, dann ist es eher wenig zielführend, den kompletten Port auf Ausgang zu schalten. volatile wurde schon angesprochen. Das Rücksetzen
-
Thread
STM32: Wie funktioniert diese Entprellung?
Wie kann ich diese Funktion für alle Pins verallgemeinern? Ich würde an die Funktion den Pin und Port übergeben (z.B. PD2) und dort eine switch-case Abfrage mit allen möglichen Pins. In dieser Abfrage dann den jeweiligen Pin einlesen. Peter D. schrieb im Beitrag #4608892: > Z.B. reicht ein 2Bit-Zähler
Wie kann ich diese Funktion für alle Pins verallgemeinern? > Ich würde an die Funktion den Pin und Port übergeben (z.B. PD2) und dort > eine switch-case Abfrage mit allen möglichen Pins. In dieser Abfrage > dann den jeweiligen Pin einlesen. Mir fällt gerade auf, dass dies keinen Sinn macht, weil
-
Thread
DRAM am AVR: Wie sieht Euer Wunsch-Interface aus?
interessiert, für welche Anwendungen kann man überhaupt DRAM sinnvoll benutzen ??? Nur deshalb DRAM an den AVR dranpappen, damit man ihn mal drangepappt hat, finde ich persönlich völlig witzlos. Der AVR ist auch ne äußerst ungünstige Wahl, da er nur max 64kB RAM adressieren kann. Ich würde mindestens
nicht? zu 4) wo ich ja eigentlich drauf hinaus will ... zu 5) Wenn man schon viele Pins am AVR benutzen will/muss, kann man das Timing auch gleich im AVR machen. So viel kostet das Refresh ja wirklich nicht. Das einzig schoene waere das XMEM Interface, da es sehr transparant zu programmieren
-
Thread
DOGM128 und Atmega16 via STK500
eigentlich später, aber evtl frage ich jetzt. Das Testprogram ist eigentlich schon da, mit LunaAVR kommt eines genau für den LCD, allerdings gefällt mir eine Stelle da nicht so. Da werden die Pins des µC so verwendet bzw. ich verstehe das Kommentar so, dass die Pins des Port C auf die angegebene Pins des LCD gehen (Angabe ist jeweils Text hinter dem Hochkomma): [code] #define dogmMosiPin as PortC.0 ' in dogm datasheet named 'SI' #define dogmSckPin as PortC.1 ' in dogm datasheet named 'SCL' #define dogmA0Pin as PortC.2 ' in dogm datasheet named 'A0' #define dogmSsPin as PortC.3 ' in
-
Thread
PWM mit AD-Wandler steuern
mit mir gemeckert wird wegen formatierung. Ich wollte jetzt mit demn Wert den ich über den ADC einlese an die PWM ausgeben. Das gelingt auch, nur kann ich das Tastverhältniss nur bis etwa 50% einstellen. Wo ist hier der Knacks ? [c] #define F_CPU 1000000UL #include <avr\io.h> #include <util
pin liegt über 100nF an Masse. VACC liegt an 5 Volt. [c] #define F_CPU 1000000UL #include <avr\io.h> #include <util/delay.h> int main (void) { DDRB = 255; // PORT auf Ausgang // AD INIT ADMUX |= (0<<REFS1) |(1<<REFS0); // externe Referenz ADMUX |= (0<<MUX3) |(0<<MUX2) | (0<
-
Thread
Ablauf eines Programms?
Hallsensor im Poll-Betrieb (Timer-Interrupt bzw. Takte während einer Torzeit zählen) abfragen. Mit einem AVR sollte man das auf jeden Fall hinbekommen.
Ja das hat er. Interrupt auf port RB.
-
Thread
Problem bei ADC Messung
auf 0 gesetzt wird also die Wandlung nicht beendet wird. Hier mal mein Code: [c] #include <avr/io.h> #include <avr/interrupt.h> #include <stdio.h> // Hier die verwendete Taktfrequenz in Hz eintragen, wichtig! #define MCU at90can128 #define F_CPU 14000000//7372800UL #define ADC_PORT 0
delay_ms (500); // Messwerte jede 1/2 Sekunde erfassen Wert = adc_read_avg( ADC_PORT, 7 ); errechne aus Wert die Temperatur gib die Temperatur auf dem LCD aus } } [/c] wird ja genau die Sequenz ADC_einlesen -> Temperatur_errechnen -> Temperatur_ausgeben immer
-
Thread
Basom:wo fehler bei portabfrage
Die Sache mit Pin statt Port ist AVR Standard, gibts schon seit dem 90S1200 und steht in jd. Datenblatt unter 'IO Ports'.
Die unterscheidung zwischen PIN und PORT hat ganz einfach damit zu tun, dass man beim AVR jedes Register wieder einlesen kann. Auserdem wird das PORT-Register auch verwendet zum die Pullups einschalten. Gruß, Florian
-
Thread
fehlerfreie UART-Übertragung?
um nicht noch mehr Verwirrung durch die verscheidenen Signalpolaritäten auf dem Weg bis zu deinem AVR zu stiften Mess einfach nach: Vor dem Start des Terminal Programms sollte RTS "nicht Empfangsbereit" anzeigen, nach dem Start/Öffnen des COM Ports sollte dann die Leitung umschalten. Daran erkennst
***mist, hab gerade nochmal nachgeprüft: selbst bei deaktivierten RTS/CTS Handshake wird beim COM Port öffnen RTS aktiviert, dann aber in der Pufferüberlaufsituation nicht mehr zurückgenommen. Ob der COM port von deinem Terminalprogramm richtig konfiguriert ist kriegt man also so nicht direkt heraus.
-
Thread
2 Externe Interrup auf gleichen Vektor
Nö, ich würde erstmal den Port (PINx) einlesen, damit Änderungen während der Auswertung unwirksam bleiben. Dann würde ich die interessierenden Bits der Portkopie prüfen und danach die Entscheidungen treffen. In der ISR an PCMSKx
Hannes Lux schrieb: > Nö, ich würde erstmal den Port (PINx) einlesen, damit Änderungen während > > der Auswertung unwirksam bleiben. Dann würde ich die interessierenden > > Bits der Portkopie prüfen und danach die Entscheidungen treffen. > >
-
Thread
Dumme Frage
Schau Dir die Hilfe zu "config port" an. Markus
(Zitat aus der Hilfe): 'Again, note that the AVR port pins have a data direction register 'when you want to use a pin as an input it must be set low first 'you can do this by writing zeros to the DDRx: 'DDRB =&B11110000 'this will set portb1.0,
-
Thread
externes Interrupt wird beliebig ausgelöst (Motorrad)
Das Entprellen funktioniert ja und macht auch keine Probleme. [c] #include <stdint.h> #include <avr/io.h> #include <avr/interrupt.h> #include <inttypes.h> #ifndef F_CPU #define F_CPU 8000000UL // processor clock frequency 8Mhz #endif #define LED PA6 //
Versorgungsspannung so dicht wie möglich am µC. Ich wollte erstmal die Signalerkennung ordentlich einlesen, erst dann mit der Auswertung und dem Display weitermachen. Jedoch ohne diese Grundlage, ist der Rest hinfällig, daher ist der Schaltplan im Moment nur minimal.
-
Thread
AVR Mikrocontroller Lohnenswert?
Controllern den Vorteil, dass Du Dich nicht noch zusätzlich mit Dingen wie unterschiedlichen Clock domains, Port-Matrix, IRQ-Prioritäten oder komplexerer Hardware herumschlagen musst. (Obwohl es das auch da gibt - aber nicht beim einfachen AVR.) Wenn Du noch eine Stufe weiter herauszoomen möchtest, wäre der
;P1.0 (LED1) Toggle > BR $ ; Waitt of Watchdog Reset Beim AVR geht das nicht, da setzt das Watchdog-Reset alle Port-Register zurück, da toggled also nichts. Welcher seltsame MC ist das denn, wo der Watchdog kein richtiges Reset ausführt? Man könnte den AVR
-
Thread
Tastertest AVR Evaluationsboard Pollin
Hallo, ich habe das Pollin Atmel Evaluationboard 2.01 und pobiere gerade einige Dinge aus. Ich möchte einfach, das die LEDs die Tasterstati anzeigen. Auf dem Board sind die verwendeten Taster 2/3 mit PD3/4 und die LEDs 1/2 mit PD5/5 verbunden. Es ist ein Tiny2313 gesteckt. Dazu habe ich folgendes Assembler-Programm geschrieben. ;------------------------------------------------------------------------ .include "2313def.inc" ;Definitionsdatei laden .cseg ;Beginn eines Code-Segmentes .org 0 ;Startadresse = 0 ; start: ldi r16, low(ramend)
-
Thread
LM75 mit Mega88PA auslesen
; DDRB = 0xFF; // use all pins on port B for output DDRC = 0xFF; // use all pins on port B for output PORTB = 0x00; PORTC = 0x00; i2c_init(); // init
Karl Heinz Buchegger schrieb im Beitrag #2481322: > Beim Ablesen der LED die Ports falsch zugeordnet (kann auch ein > optischer Irrtum sein!)? Ja, Ports vertauscht! -> jetzt funzt alles! Das ganze werde ich im nächsten Schritt auf eine 7-Segment-Anzeige bringen. Positive
-
Thread
externer Interrupt 0 --> Entprellung funktioniert nicht !
---------------------------------------------------------------- #define F_CPU 3686400 #include <avr\io.h> #include <inttypes.h> #include <avr\interrupt.h> #include <util/delay.h> //---------------------------------------------------------------------- volatile unsigned char buffer; // globale
der Prozessor aus der ISR wieder herauskommt. Warum verwendest du nicht einfach diese Tasten-Einlese-und-Entprell- ISR zusammen mit einerm Systemtimer? http://www.mikrocontroller.net/articles/Entprellung#Komfortroutine_.28C_f.C3.BCr_AVR.29 Die ist 100% zuverlässig.
-
Thread
ATtiny26 Balkenanzeige ( Hysterese ) mit acht Schaltschwellen (ASM)
Oldtimer wie den ATTiny26. Der hat noch nicht einmal den vollständigen Befehlssatz eines aktuellen AVR. MfG Spess
Bargraf [/avrasm] ... [avrasm] end_loop: com r18 ; negieren (wegen STK500) out PortA,r18 rjmp mainloop [/avrasm] Bernd_Stein
-
Thread
µC + LCD + Tastatur - newbie
?? Programmspeicher? Du musst dir definitv erstmal ein paar Grundlagen erarbeiten..z.b. mit dem AVR-Tutorial hier..erst langsam anfangen, was heisst eine LED zum leuchten bringen mit dem controller, taster einlesen, dann evtl textdisplay ansteuern, UART, SPI...und das dauert, va. wenn du alles selber
klar, AVR <> ARM
-
Thread
Hackbarer(?) 21 EUR Quadcopter
... und ein Blinky-Projekt war auch dabei. Es muss nur noch der Port angepasst werden. (Auf welchem Port ist die LED angeschlossen?)
LDROM) memory; 256 bytes direct and indirect RAM, 256 bytes XRAM; 25 I/O with bit-addressable I/O ports; two 16-bit timers/counters; 8-channel multiplexed 10-bit A/D converter; 4-channel 10-bit PWM; three serial ports including a SPI, I2C and an enhanced full duplex serial port; 2-level BOD voltage detection
-
Thread
[C] While Schleife mit drücken eines Buttons abbrechen
Mario I. schrieb im Beitrag #5336671: > PinD ist die Pingruppe D Pingruppe? == PortD ?-\ Mario I. schrieb im Beitrag #5336671: > Und was meinst du damit ? KA, ich hab einfach NULL Plan von AVR. Dachte das bringt dich auf einen neuen Ansatz zur Fehlersuche...... Ich sollts lieber
stoppen. Oder statt eines Pin-Interrupt regelmäßig (zB.300ms wie du gerade wartest) /pollen/, einlesen -> Nennt sich Polling. :) https://de.wikipedia.org/wiki/Polling_(Informatik)
-
Thread
High-speed AVR
Taktgeschwindigkeit wieder ausgeglichen... @Michael Schade, dann hätte man ja wirklich einen "normalen" AVR mit höherer Geschwindigkeit... Falls jemand mir helfen kann: Beim Bootvorgang werden die Programmdaten in den Programm-SRAM gelesen. Doch warum braucht man 3 verschiedene Modi zum einlesen? Und wozu der USB-Mode? Wird dann das Programm durch den USB-Port gelesen? Wozu?
-
Thread
Programm bleibt stehen
"Überprüfungsled" getoggelt, also das Programm läuft weiter. [c] #include <stdlib.h> #include <avr/io.h> #include <avr/interrupt.h> #include <avr/pgmspace.h> #include <util/crc16.h> #include <avr/eeprom.h> #include "uart.h" #include "lib_crc.h" #include <util/delay.h> /* define CPU frequency
10; uint8_t t_overflow = 0; uint16_t ptherme EEMEM = 0000; void entprellung( volatile uint8_t *port, uint8_t maske ) { uint8_t port_puffer; uint8_t entprellungs_puffer; for( entprellungs_puffer=0 ; entprellungs_puffer!=0xff ; ) { entprellungs_puffer<<=1; port_puffer = *port
-
Thread
goto verpönt - was dann nehmen?
>static u16_t tcp_new_port(void) { > static u16_t port = TCP_LOCAL_PORT_RANGE_START; > do { > if (port++ >= TCP_LOCAL_PORT_RANGE_END) > port = TCP_LOCAL_PORT_RANGE_START; > } while(port_is_in_use(port));
port = TCP_LOCAL_PORT_RANGE_START; } if (!port_is_in_use(port)) break; } if (i==0) { return 0; // error, no more free ports } else { return port; } } [/c]
-
Thread
PIC12F675 & Poti.Wer kann mir helfen???
mittlerer entfernung,rot bei mittlerer bis naher entfernung. im moment bin ich mich bei sprut.de am einlesen.schau später mal bei fernando heitor vorbei. poste dann nomma wenns was neues gibt! mfg
fertig ADC-Wert einlesen; if (ADC_wert < 512 && a) { a=0; Timer so einstellen das es langsam piepst; LED_grün=1; LED_rot=0; b=255; }
-
Thread
Raspberry Pi Taster stören sich gegenseitig
keine!) Ahnung von elektrischen > Schaltungen. mal ehrlich, +3,3V ohne Strombegrenzung auf einen Port zu schalten ist keine besonders gute Idee, 1. wenn der Port mal auf out und low gestellt wird (reicht ja ein falsches Programm ein falsches Kernelupdate oder ein Absturz) dann hat der Port an +3,3V
Raspberry PI Erfolg garantiert, das Datenblatt vom SoC BCM2835sagt was von ca. 50mA zusätzlich an allen Ports als Quelle oder Senke, das ist nicht üppig, Strombegrenzung wie beim AVR findet auch nicht statt, man kann locker pro Port mehrere mA verballern bis der SoC aufgibt.
-
Thread
geschachtelte if Abfrage auf AVR Pins
Hi, vielleicht zum debuggen die Ports separieren und einzeln die PINx werte zur Fehlersuche binaer/hex ausgeben. Dann bieten sich zur beseren Lesbarkeit auch noch Masken an. //hufnala
Ansonsten gebe ich dir zu 100% Recht, es ist übersichtlicher und man läuft nicht in die Gefahr, dass der Port zwischen den einzenlen Vergleichen den Zustand wechselt. Je nach Anwendung ist das aber auch egal.
-
Thread
Wecker mit Solar und Ladeüberwachung bauen
und dass mit der ladungsanzeige is dass für einen anfänger ratsam? ich habe ein avr buch hier nur finde ich die beschreibungen da drinn ziemlich kacke.
liegt? ich schalte bei meiner schaltung das die spannungsversorgung des dcf77 moduls durch den avr ein und dann kommt das signal auf einen pin am avr.
-
Thread
Optrex DMF5008
SEL1 auf GND D0-D7 auf PA0-PA7 /RD auf PB1 /WR auf PB2 A0 auf PB3 Hier die DEFINES: // Data port #define LCDDATAPIN PINA #define LCDDATADDR DDRA #define LCDDATAPORT PORTA // Control port #define LCDCTLPIN PINB #define LCDCTLDDR DDRB #define LCDCTLPORT PORTB
fast zwei Jahre alt ist, so habe ich doch trotzdem heute eine Frage dazu: Ihr gebt hier Codes für AVR und PIC an, aber wie ist das Display denn überhaupt angeschlossen? Kann mal jemand einen kleinen Verdrahtungsplan aufzeigen? Ich will mich eigentlich in die AVR-Arbeit einlesen und habe noch so ein
-
Thread
Inkrementalgeber
euch dankbar wenn ihr mir weiterhelfen könnt, da ich noch Anfänger bin! benutzt wird Atmega8 PortD - PIN5 --> Phase_A PortD - PIN6 --> Phase B gruß
kürzlich Teile des GCC-Tutorial in separate Artikel ausgelagert. http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Die_Timer_und_Z%C3%A4hler_des_AVR
-
Thread
Bitte einmal den Schaltplan kontrollieren
basteln möchtest oder den UART nutzt. Ich habe hier immer 2 Sorten (ein großer und ein kleinerer AVR) Standard-Platinen die ich für alles möglich nutzen kann, auf denen ist der jeweilige AVR, Pads für einen Quarz, Widerstände für die Ausgänge, die Filterung für den ADC, eine Spannungsregelung und eine
Platine mit paar Taster verbinden oder man nimmt einen USB-nach-UART/TTL Konverter und redet mit dem AVR über den Seriellen Port. (diese MAX232 nutze ich nicht, das ist heutzutage eh sinnlos da nirgends mehr ein Com-port verbaut wird)
-
Thread
Atmega8-16 ADC von Poti
veränderbare Kontakt des Potis geht dann an PC0 am Atmega8-16. Hier mein Programm: [c] #include <avr/io.h> #include <util/delay.h> #define an(port,b) (port) |= (1<<(b)) #define aus(port,b) (port) &= ~(1<<(b)) //Beispielaufruf: an(PORTC,PB1); int main () { // Helligkeit in % int pb1_soll
ist die LED eigentlich noch zu dunkel. Und dann springt sie plötzlich auf ganz hell [c] #include <avr/io.h> #include <util/delay.h> #define an(port,b) (port) |= (1<<(b)) #define aus(port,b) (port) &= ~(1<<(b)) //Beispielaufruf: an(PORTC,PB1); int main () { // Helligkeit in % int pb1_soll
-
Thread
MP3-Player umdrehen?
MByte/sec übertragen werden. Das geschieht mit 16-Bit-Zugriffen von je 125 nsec Dauer. Um mit 'nem AVR in diese Regionen zu geraten, ist ein Memory-Mapped-Interface erforderlich (also nicht über irgendwelche Ports, sondern über das externe Speicherinterface). Mit einem PLD muss dann noch dafür gesorgt
USB-IDE-Bridge. Die gibt es als fertiges Bauteil zu kaufen und erreichen Datendurchsatzraten am USB-Port, die ein AVR noch nicht mal beim Beschreiben von SRAM hinbekäme. Über eine Signalleitung kann die USB-IDE-Bridge dem AVR mitteilen, daß er jetzt "die Pfoten" von der Platte zu lassen hat, um das Dateisystem
-
Thread
Taster enprellen aus Codesammlung
Schon mal mit echten AVR's gearbeitet, oder nur Papiertiger?
Seiteneffekte, wie sie leider viele andere Lösungen haben. Der einzige Hardwarezugriff ist das Einlesen des Ports, da kommt man nicht drumrum. Und einen Timerinterrupt hat eh jede Anwendung, wo man sie mit einfügen kann. Peter
-
Thread
Bascom & Analog
Hallo an Alle Ich mache schon seit längerem mit Bascom und AVR rum, aber habe immer noch nicht raus, wie ich die Analog Ports abfrage. Kann mir da jemand helfen? Danke
Heist das etwa, der kann keine Analogen Werte einlesen? Der Port A ist in meinen Documentationen als ADC0 bis ADC7 bzw AD0 bis AD7 bezeichnet. Ich muss unbedingt analoge werte mit Bascom einlesen und auswerten können.
-
Thread
Fehler beim Lesen von RS232
So auf den ersten Blick arbeitest du im AVR mit Parity. Parity verwendet aber das MSB, da dieses Konzept aus dem 7-Bit ASCII Code stammt bei dem eben jenes Bit unbenutzt ist. Wenn es der USART richtig macht muss er das höchstwertige Bit mit dem
dem das Partitätsbit zusätzlich zu den 8 Datenbits untergebracht werden kann. Den zugehörigen AVR-Code hat er ja nicht gepostet. Prinzipiell können die USARTs der neueren AVRs auch das 9-bit-Format, aber das 9. Bit ist ein wenig umständlich zu be-/verarbeiten.
-
Thread
wie in AVR-Programmierung einsteigen?
Anfänger bezüglich microcontroller, möchte mich aber in die Programmierung und Anwendung der Atmel AVR's einarbeiten. Wie fängt man am besten an? Welche Vorraussetzungen (Testboard, Programmer, ...) braucht man? mfg Kay
Ok, dann werd ich mich erstmal bissl einlesen und dann parallel dazu praktisch anfangen, dann wird sich ja zeigen ob ich dahin komme wirkliche Projekte zu realisieren. Wenn nicht, hab ich wenigstens nicht hunderte Euro's in den Sand gesetzt.
-
Thread
CH32V003 und Arduino
aus lauter Jux und Dollerei habe ich jetzt mein my_printf und v003colpos auf avr losgelassen und prompt funktioniert es nicht, weil ich type int verwende (und die auch als 32-bit behandle), die aber auf avr nur 16 bit lang sind. eine explizite angabe von int32_t für alle bisher int angaben macht my_printf und v003colpos auch mit avr kompatibel.
-
Thread
Wiedereinstieg in die Programmierung
da ich mich da schon etwas auskenne. Hiermal ein programmbeispiel. #include <stdio.h> #include <avr/io.h> uint8_t set; //Variable deklarieren int main(void) { DDRB = 0xFF; //PortB als Ausgang definieren DDRD = 0x00; //PortD als Eingang definieren set = PIND; //Porteingangsregister
im Beitrag #2571594: > Was stellst du dir denn unter PIND vor? Unter PIND stelle ich mir da zu Port D gehörige Regiter zum einlesen der Zustände an den Pins vor, sofern der Port als Eingang definiert is, oder verstehe ich da was falsch?
-
Thread
Drehencoder entprellen, aber wie?
drehgeber_step(void); static inline char drehgeber_job(void); #if defined (__GNUC__) && defined (__AVR__) # include <avr/pgmspace.h> #else # define PROGMEM # define pgm_read_byte(x) (*(x)) #endif // avr-gcc // Aufrufen, wenn eine Flanke an einem der Ports festgestellt wurde, // zB aus
0 }; static uint8_t a_alt; uint8_t a = a_alt; if (IS_SET (PORT_DREH_A)) a |= (1 << 2); if (IS_SET (PORT_DREH_B)) a |= (1 << 3); a_alt = a >> 2; return (char) pgm_read_byte (& drehgeber_transitions[a]); } // Mein Drehgeber
-
Thread
Bytes über Serielle Schnittstelle senden/empfangen
schicken ich einen String mir 3 mal einem Byte. Die C# Routine beim Empfangen lautet: serialPort1.Open(); serialPort1.Read(b, 0, 3); serialPort1.Close(); b ist ein ByteArray der Größe 3. byte[] Eigentlich sollte nun das erste Byte in b[0], das zweite in b[1] und das dritte an b[2]
, funktioniert es. Hier der Code in C# : byte[] b = new byte[3]; serialPort1.Open(); serialPort1.Write(b,0,3); serialPort1.Close(); Es werden hierbei die drei Bytes im Byte-Array b[3] in den Puffer geladen. Der MC holt sich die Daten dann seriell
-
Thread
20Euro Embedded System mit ARM, 128MB ram und 256MB Flash
Port außen wird die Platte automatisch erkannt. Frage, hat schon jemand ne Platte oder anderes USB Gerät an dem Port auf der Platine am laufen?
mal den anderen Port probiert habe... gut es war auch schon 4 Uhr morgens xD Es ist halt insofern witzig, da später in Debian beide Ports einwandfrei funktionieren, nur uBoot erkennt die Platten am linken Port einfach
-
Thread
leichter Einstieg in ASM für AVR
Nimm das AVR-Studio. (Gibts auf der Seite von Atmel) Ist sogar ein Softwaredebugger mit drin. Vorteil ist, das man sogar seine Bascom-Hex Files damit einlesen kann und debuggen kann... ;) (Und man sieht, was
So, habe jetzt im AVR Studio den Simulator eingeschaltet und einen Mega8 ausgewählt. Dann folgendes Programm eingegeben, es soll ein Brummen (Rechteck) an Port B, Bit 0 ausgeben: .equ c1 = 0 ; Bestimmt die Tonhöhe
-
Thread
avr-gcc vergisst volatile variable in isr neu zu lesen
Hmm.. so wie ich das verstanden habe dient volatile (!beim AVR!) dazu, Variablen, die außerhalb der Funktion 'main' behandelt werden, neu einzulesen und während des Einlesens den globalen INT zu sperren, um teilweises Lesen zu vermeiden, falls währenddessen ein
Alle Ports und Steuerregister sind "volatile". Wenn GCC da jedesmal einen cli/sei-Wrapper drumwickeln würde...
-
Thread
Welche Programmiersprache soll ich lernen?
Einfaches Beispiel für blinkende LED [code]avr.device = atmega168 avr.clock = 8000000 avr.stack = 32 #define LED1 as portB.0 'LED1 wird als Bezeichner für portB.0 definiert LED1.mode = output,low 'Port als Ausgang definieren und auf
Mr. K. schrieb im Beitrag #5532457: > #define LED1 as portB.0 'LED1 wird als Bezeichner für portB.0 > definiert Und http://gcbasic.sourceforge.net/help/__define.html Anscheinend haben sowohl LunaAVR als auch GCBasic die C-Makros als simple Textersetzung
-
Thread
Assemblertrick "Delaybreaker" gesucht
Lösungsansatz mit min. Zusatzhardware: Das Signal kommt sagen wir an Port A.0 an, geht zusätzlich auf Din eines D Flipflop, dessen Q an Port A.1, Port B.0 liefert dem Flipflop CLK und Reset. Dann wäre der Zyklus folgender: Signal wurde an A.0 detektiert FF zurücksetzen ;Takt '0' verzögerung ;Takt '1-8' (loop, nops) Port B.0 High ;Enable des FF Eingangs, Takt '9' In Port A.1 ;Testen des FF Ausgang
-
Thread
Zeigt her Eure Kunstwerke! Gesperrt Bilder
Das hier ist ein kleiner AVR-ISP Programmer für den COM-Port. Durch ein paar Wiederstände mehr ist er auch für 3.3V Schaltungen geeignet, aber eben nur für AVR. Als Gehäuse dient eine Filmdose.
multiplexen, kann aber auch auf eine Reihe LEDs umgeschaltet werden, oder per Jumper vier Taster einlesen. Gebaut für einen PIC16F627 oder (aber nicht gleichzeitig), PIC16F873 bzw. alle Pinkompatiblen. Ganz links alle Ports (und Osc.) auf Klemmen rausgeführt. Das 2x16 LCD wird über die Klemmen unten