-
Thread
K0855 durch Mikrocontroller ersetzen?
Programm. Jedes C-Programm beginnt mit den Anweisungen in der Funktion main. (3) Die Anschlüsse eines AVR ("Beinchen") werden zu Blöcken zusammengefasst, einen solchen Block bezeichnet man als Port. Beim ATmega16 hat jeder Port 8 Anschlüsse, bei kleineren AVRs können einem Port auch weniger als 8 Anschlüsse
Richtungsregister den entsprechenden Anschluss auf Ausgang schalten, werden mit DDRB=0xff alle Anschlüsse des Ports B zu Ausgängen. (4)stellt die Werte der Ausgänge ein. Die den ersten beiden Bits des Ports zugeordnete Anschluss (PB0 und PB1) werden 1, alle anderen Anschlüsse des Ports B (PB2-PB7) zu 0. Aktivierte
-
Thread
[AVR] Duty-Cycle von 0 mit Timern
derzeit auch noch ein weiteres Problem. Ich habe folgenden Code: [c]#include "audio.h" #include <avr/io.h> #include <avr/interrupt.h> static volatile uint8_t play; static volatile uint32_t rate; static volatile uint32_t rate_counter; static volatile uint8_t* audio_; static volatile uint16_t size_; ISR(TIMER0_COMPA_vect) { AUDIO_OUTPUT_PORT |= (1 << AUDIO_OUTPUT_POS); } ISR(TIMER0_COMPB_vect) { AUDIO_OUTPUT_PORT &= ~(1 << AUDIO_OUTPUT_POS); } void audio_init() { AUDIO_OUTPUT_DDR |= (1 << AUDIO_OUTPUT_POS); TCCR0B =
-
Thread
Rückgabewert von Funktion wird nicht übegeben
jeweilige LED aus wenn ich den entsprechenden Taster drücke. Das bezweifle ich. Wenn Du den Port B als Ausgang schaltest, kannst Du keine Taster einlesen. Peter
Sieht dein Programm inzwischen so aus? [C] #include <avr/io.h> unsigned char abc(void); int main(void) { DDRC = 0xff; // <== ! PORTD = 0xff; while (1) { // Port C Pin o---###--->|---o GND // R LED PORTC =
-
Thread
AVR per USB als HID-Gerät
Hi, in Zukunft werde ich immer wieder Projekte haben bei denen der AVR mit dem PC verbunden werden muss und das möglichst über USB. Diese Geschichte mit den Virtuellen COM-Ports klingt für mich aber nach ziemlichem Murks, da ich aus einem Programm heraus somit nicht erkennen
Also ich habe das so auf meinem AVR-Demoboard. Und es läuft ohne Probleme, nutze aber den COM-Port, aber das ist ja nur eine Treiber sache. Die Einstellungen werden über MPROG gemacht, hier das PDF dazu http://www.ftdichip.com/Resources
-
Thread
Was sind das für Bauteile?
Peter K. wrote: > Ja und beim Sensor geht noch eine Leitung rauf zu +V Das ist ein Pull-Up um den Port auf einen definierten Pegel (5V ueber Pull-Widerstand) zu heben. Einfach ueber den Widerstand an 5V (VCC) gehen. Der Temp-Sensor klingelt dann da, in dem er den Port auf Low zieht (Port PD1 am uC
Brauchst also ein Programm, mit dem Du das PWM-Tastverhaeltnis einstellen und das PWM-Signal an einen Port ausgeben kannst. Dort dann die LED mit Vorwiderstand gegen GND ran. Dann zwei Taster einlesen, einen als inkrement, einen als dekrement verwenden.
-
Thread
RFM12 Statusabfrage
= 0; unsigned char i; cbi(RF_PORT, CS); for (i=0; i<16; i++) { if (wert&32768) sbi(RF_PORT, SDI); else cbi(RF_PORT, SDI); werti<<=1; if (RF_PIN&(1<<SDO)) werti|=1; sbi(RF_PORT, SCK); wert<<=1; _delay_us(0.3); cbi(RF_PORT, SCK); } sbi(RF_PORT, CS); return werti; } void rf12_init(void) { RF_DDR =(1<<SDI)|(1<<SCK)|(1<<CS); RF_PORT =(1<<CS); _delay_ms(200); // wait until POR done rf12
-
Thread
Probleme mit High- und Low-Eingängen Arduino Nano
uint8_t timer = digitalPinToTimer(pin); uint8_t bit = digitalPinToBitMask(pin); uint8_t port = digitalPinToPort(pin); volatile uint8_t *out; if (port == NOT_A_PIN) return; // If the pin that support PWM output, we need to turn it off // before doing a digital write. if (timer
#7728103: > Fremdwort für Arduino-Fans. 1: Da irrst du! 2: Die Arduino Welt besteht nicht nur aus AVR und SAM Lothar M. schrieb im Beitrag #7728034: > versuche mal in der aktuellen Arduino IDE-Version 2.3.2 den > Proxy-Port 80 zu setzen. Dann bist du das: https://github.com/arduino/arduino-ide
-
Thread
Einführung in Octal 3-State Noninverting Transparent Latch gesucht
Kaffeesatzraten. Wenn er aber z.B. das setzen der Portdaten und den Wechsel der LE Leitung auf out PORT,DATEN sbi PORT,LE cli PORT,LE zusammenoptimiert, wird es dem Kram zu schnell sein. Gruß aus Berlin Michael
BasCom ja auch geben... Die Ausgabe ist ja immer identisch: 8Bit Muster zerlegen in 2 Bit für PortB und 6 Bit für PortD Daten von PortB einlesen, die beiden genutzen Bits auf 0, die neuen mit oder dazu und raus. Das gleiche für Port D. Hauptschleife liest die Daten aus einer Tabelle und schickt
-
Thread
TTL Signal Verarbeitung
Fehlerquellen. [C] #define F_CPU 4000000UL #define BAUD_RATE 9600 #include <stdlib.h> #include <avr/io.h> #include <avr/interrupt.h> #include "uart.h" volatile uint8_t getBit; ISR(INT0_vect) { getBit = 1; } int main(void) { DDRD = 0x00; // Port D als Eingang setzen PORTD
auf gleichheit prüfen usw. und wenn das bitpuffer == Flag ist dann die nächsten Bytes einfach einlesen.
-
Thread
AD-Wandler Problem
ist ja deins. Folgende Änderungen habe ich aber gemacht, da meiner mit 8 MHz taktet und die LCD auf PORT B liegt. Also Enable Pin geändert, RS Pin geändert, alle Delayschleifen doppelt drin, PORT D auf Port B gelegt MFG Dieter
ADC0 als Messeingang und dann ADC1 (z.B. PC1) als output zunutzen.... Oder ob es nur fuer den ganzen Port geht... Ich interpretiere den Satz so... Moechtest du den Port C als ADC nutzen lege ein tiefpassfilter... willste ihn als I/0 Port nutzen dann lege AVCC auf VCC da der Port seine Betriebsspg von den
-
Thread
AVR: Bit-Abfragen und -Zuweisungen an einzelnem Port
dem >>>[[AVR-GCC-Tutorial]]<<< als deine erste Anlaufstelle an. Dort finden sich solche Dinge, die dir für den Anfang den Weg erleichtern. [C] #include <avr/io.h> #define TASTER PB1 #define LED PB0
Vorsicht! Beim Einlesen PINB verwenden! PORTB steuert nur die Ausgänge! Man kann PORTB zurücklesen, bekommt aber nur den Wert der aktuell eingestellten Ausgänge wieder! PINB hingegen liefert den Eingangswert. Einzelne
-
Thread
Viele Drehimpulsgeber an einem PIC
Ports legen die Eingänge multiplexen und den Status einzeln abfragen. Das braucht dann 22 Ports und du muss die Encoder mit Dioden entkoppeln. Die Abfragezeit für alle machst du dann etwas größer als
Was spricht gegen Multiplexen? Immer 4 gleichzeitig einlesen (8 Pins), und das x5. Wenn die 13 Pins zuviel sind, nimmt man ein 74HC165 zum einlesen und ein 74HC299 zum Multiplexen: Das kostet 4 Pins (MOSI, MISO, 2xSCK). Der Aufwand zum einlesen ist verschwindend
-
Thread
Grundsatzfrage SD-Karte >> AVR
Hallo, ist es irgendwie technische möglich, eine SD-Karte die an einem AVR hängt über den ISP Port auszulesen?
>ist es irgendwie technische möglich, eine SD-Karte die an einem AVR >hängt über den ISP Port auszulesen? Ja klar. AVR in Resetzustand legen damit das lesen von der Karte nicht gestört wird. Eigenen ISP Prommer bauen und ein Programm dafür schreiben um die SD Karte
-
Thread
Hat jemand für den ATtiny44 eine funktionierende USI to SPI Routine?
SBIT(port,pin) ((*(volatile struct bits*)&port).b##pin) #define SPI_CLK SBIT( PORTB, 0 ) // clock #define SPI_CLK_DDR SBIT( DDRB, 0 ) #define SPI_MISO_PIN SBIT( PINB, 2 ) #define
ich aber am DO (Pin PA5) kein Signal messen. Was ist falsch? Hier der Code: [c] #include <avr/io.h> #include <stdlib.h> #include <avr/interrupt.h> #include <util/delay.h> void SPI_init(void) { DDRA |= (1<<PA4)|(1<<PA5); //Output: PA4=USCK, PA5=DO DDRB |= (1<<PB1); /
-
Thread
Zyklisches Auslesen eines Dual Port RAMs (ATmega32 und Schieberegister)
LED-Treiber ala TLC5940 & Co sind schon lange erfunden, siehe [[LED-Matrix]]. >Die Idee mit dem Dual-Port-RAM hatte unser Betreuer. Sie war zu dem >Zeitpunkt die eleganteste Lösung. Unter den Blinden ist der Einäugige der König. Wegen der popeligen Aufgabe "Tastatur einlesen" soll also extra ein Controller
auf und legst sie bitweise in den Bytes des RAM ab von wo > sie sich der andere holt und auf die Ports rausstreamed, ist doch schon > kompletter Unfug. Ohne jeden Zweifel. > Die einzigen Besonderheiten, die ein AVR haben sollte/könnte wären 219 > PWM Stufen und ein fix und fertiges Tastenmatrix
-
Thread
Peter Danneggers Bootloader (fastboot) für AVR-GCC-Toolchain
=PORTE -DSTX=PE1 -DSRX_PORT=PORTE -DSRX=PE0 added/bootload.S -o bootload.o avr-gcc -c -Wa,-adhlns=stub.lst -mmcu=atmega2560 -DF_CPU=16000000 -I . -I ./added -I ./converted -I/usr/local/avr/include -ffreestanding
-DSTX_PORT=PORTD -DSTX=PD1 -DSRX_PORT=PORT D -DSRX=PD0 added/bootload.S -o bootload.o avr-gcc -c -Wa,-adhlns=stub.lst -mmcu=atmega32 -DF_CPU=14745600 -I . -I ./added -I ./converted -I/usr/local/avr/include
-
Thread
Anfängerfragen zu asembler und AVR
avr oder was anderes? bei avr: 1. sbic, sbis 2. ldi r16,0b11110000 out DDRx, r16 die letzen 4 pins von port "x" sind dann outputs und die ersten inputs. siehe auch http://www.mikrocontroller.net
Na ja, Assembler-Code für den AVR wirst du auch nicht auf nem 8051 zum laufen bekommen, ohne den Codeschnipsel komplett umzuschreiben.
-
Thread
AD Wandler nutzen
Und wie wird der mit FastAVR angesprochen, bzw. benutzt? Ich möchte ein bischen üben und die gemessene Spannung über den Port D an Leds ausgeben.
PortD = PinC ist richtig.
-
Thread
Parallele Schnittstelle an AVR?
Wigglerkabel das an dem Parallelport einer Windows Maschine hängt. Dazu eine Software in C die über den Port und das Kabel per JTAG Lese und Schreibaktionen auf einem SMP8634 Prozessor ausführt. Nun möchte ich den Rechner durch einen AVR ersetzen. Die Software habe ich bereits auf einem Butterfly einigermaßen
Karl heinz Buchegger wrote: > Ob dann allerdings die Pinbelegungen um Port zu denen des > parallel Ports passen, musst du hardwaremässig sicherstellen. ... geht auch in Software, indem die Makros für die JTAG-Pins für den AVR anders definiert werden als für den Parallelport
-
Thread
FET ohne Treiber direkt am PIC?
er wieder auf 1. Im Register steht aber eine 0. Was lernen wir darauf ? -> Nächstes mal einen AVR nehmen. Vermutlich war das aber ein Softwarebug (ansonsten wäre das schon sehr bitter für die PICs). Ich tippe drauf, dass ihr irgendwo den Port zurücklest bzw. irgendwo ein Bit verodert, so dass der Port zurückgelesen wird. Dabei wird der Pin als Low erkannt (da beim Einlesen nicht der Ausgangswert gelesen wird, sondern der Eingangswert) und so das Bit gelöscht wird.
-
Thread
AVR und Wavefiles?
Ja. das kannste mitm pwm port machen. und nachher mit nem rc glied die spannung aufn mittelwert ziehen. muss man halt rumexperimentieren
ich würde einfach nen externen DAC verwenden, muss dann nur nacheinander ein Byte an einem Port ausgeben und am DAC kommts hinten richtig raus.
-
Thread
USBasp+AVRdude+libusb=MEGA-STRESS
seite verlinkt hat. Habe jetzt Avrburner drauf, Device auf m32 gestellt, Programmer ist usbasp und Port ist USB. --> Return-Code des Programms: 1 ---Errors--- error at C:\Mikrocontrollerprogrammierung\WinAVR-20080610\bin\avrdude.conf:385 unrecognized character: "u" Was ist mein nächster Schritt?
configuration file is "C:\Mikrocontrollerprogrammierung\WinAVR-20080610\bin\avrdude.conf" avrdude.exe: WARNING: -E option not supported by this programmer type Using Port : USB Using Programmer : usbasp
-
Thread
Suche Mikrochip für serielles Bit-Timing
wie gesagt, mit dem SPI Modul und AVR geht es auch.
der RPI hat meines Wissens auch ein DMA auf einen IO-Port dort sollte man auch ein genaues Timing hinbekommen.
-
Thread
Schiebepoti Auslesen klappt nicht.
keine Arduino Funktionen verwenden sondern "normales" C. Hier mein Quellcode: [c] #include <avr/interrupt.h> #include <avr/io.h> #include <stdio.h> #define F_CPU 16000000 #include <util/delay.h> #define BAUD_PRESCALLER (((F_CPU / (250000 * 16UL))) - 1) // Für Terminal volatile uint16
Poti ist 5V anliegen wenn der Taster gedrückt ist. oder 2. Den Taster an einen zweiten Pin vom AVR anschließen und den Wert einlesen. Wenn Taster gedrückt dann einfach den Wert des Potis "überschreiben*
-
Thread
atmega adc im assembler
kämpf mich durch die Tutorials durch aber ich finde einfach nicht raus, mit welchem Befehl ich den Port1 zum Beispiel auswählen kann statt dem Port0. Kann mir vielleicht da wer helfen. Wäre sehr dankbar.
djas020) >durch die Tutorials durch aber ich finde einfach nicht raus, mit welchem >Befehl ich den Port1 zum Beispiel auswählen kann statt dem Port0. Tja, wie wäre es mit einem Blick ins Datenblatt? http://www.atmel.com/dyn/resources/prod_documents/doc2486.pdf Seite 205 MFG Falk
-
Thread
Timing Problem
einem I/O-Zugriff abgeschaltet werden. Das geht natürlich nur, wenn alle PWMs in einer Reihe an einem Port hängen. Für andere Zwecke benutzte Pins dieses Ports sind zu maskieren (vorher einlesen). Die Drehzahlen kannst du auch in der ISR ermitteln: - Erstmal in der ISR einen Zähler hochzählen. - Dann einfach Port einlesen und mit dem zuletzt eingelesenen Wert (bitweise) vergleichen (das dürfte ganz gut mit einer abgespeckten Variante von Peter Danneggers Tastenentprellung gehen, Einlesen und Bitmanipulation
-
Thread
Dauerhafte Pinüberwachung in Assembler
überschaubare, wartbare und erweiterbare Programme abbilden. Denn dann ist jedesmal der selbe Ablauf: 1. Ports und Daten einlesen 2. Neue Zustände und Ergebnisse berechnen 3. Ausgänge schreiben 4. weiter bei 1. Und das Ganze so oft wie möglich pro Sekunde. Das ist das SPS-Schema, das unbestritten weltweit
Lothar Miller schrieb im Beitrag #3452374: > 1. Ports und Daten einlesen > 2. Neue Zustände und Ergebnisse berechnen > 3. Ausgänge schreiben > 4. weiter bei 1. > Und das Ganze so oft wie möglich pro Sekunde. nunja, es ist eben nicht alles eine
-
Thread
Tiny2313 Adresse einstellen
Ich habe folgendes Problem: Ich will mit Funk ein Netzwerk mit mehreren Avrs aufbaun. Jeder Avr soll natürlich eine andre Nummer(adresse haben) Natürlich wäre es möglich jedem eine Fixe adresse ein zuprogrammieren, die idee ist aber, bei jedem Avr die adresse extern ein zustellen...also irgendwie
problem das ich natürlich mit einem adressbyte die adressen einstellen könnte und dann einfach bei port B die pins einlesen.... ich brauch aber mehr als 255 adressen....also müssten es schon 2 byte sein da der tiny 2313 aber nicht viele ports hat und ich den rest der ports für andre sachen brauche
-
Thread
Grundlegende Architekturüberlegung - Bitte um Hilfe
Räumen "dumme" Datensammler (sorry, ich weiss nicht wie ich die Einheiten nennen soll) sitzen (z.B. AVR's) die Zentral über ein System, z.B. RasPi oder Linux-PC, mit Logik und "Intelligenz" komplettiert werden. Warum - um die Logik an einer stelle zu haben und dort Änderungen einmalig einspielen zu können
ist, Danke für den Hinweis. Werde mich gerade in Hinsicht auf den Energiebedarf nochmal genauer einlesen in die unterschiedlichen Bussysteme. Gibt es hierfür irgendwo eine "Übersicht" - quasi so in der Art: System / erforderliche Peripherie / Quellcode / Stabilität AVR + CAN-Bus / CAN CHip XY /
-
Thread
LCD 4bit mit 4 tasten 1port
hi ich brauche eine schaltung für ein lcd 4x20 4 tastern und das ganze auch aneinem port. ist das moglich wenn ja wie. martin.
Hi, Wenn Du 4 tasten als Matrix 2x2 an einen Port hängst, sie als Matrix abfragst, und die Datenleitungen des LCD mit an diese Ports hängst, dann geht das. Nach jedem Tastendruck muss dann lediglich eine Port Umschaltung Eingang -> Ausgang erfolgen
-
Thread
AVR_PORTA_IN/OUT
du mußt ddra ansprechen. ddra = 0x00; port a = eingang ddra = 0xff; port a = ausgang je nachdem wie schnell dein uC läuft kann es sinnvoll sein noch ein paar nops zwischen dem zuweisen von ddra und porta zu setzen. und nimm fürs einlesen
Ja, die Übesetzung ging fehlerfrei... aber trotzdem bekomme ich immer 0xFF am PORT-Ausgang.
-
Thread
Erste Schulstunde Microcontroller
char rot; unsigned char blau; void main(void) { while(1) //endlos { temp=P1; //Port P1 einlesen P1.1=temp; //an Port P1.1 ausgeben if(rot=1) { p1.2=0; p1.3=0; p1.4=0; p1.5=0; p1.6=0; p1.7=0; }else{
Knopf Leitung' auf low gezogen ist. Das Ausrufezeichen steht für NOT ( also invertiert ), P1 ist der Port 1 und das & (1<<roterButton) maskiert den Pin. Wenns ein AVR ist, musst du das PIN Register lesen und vorher den Port auf Input schalten. Auch solltest du den Pullup an diesem Pin aktiviert haben.
-
Thread
Delta- Mischer mittels AVR
gebastert, der nun einen Delta- Mischer bekommen soll. Und genau den wollte ich mir selber machen mit nem AVR. Das Prinzip vom Mischen der Kanläe verstehe ich ja auch das verrechnen (invertieren) geht wunderbar. Nur bei der Signalausgabe happert es ein wenig. Ich habe schon so einiges versucht, aber mein Oszi
Jeah, es geht, ich musste aus dem "Sbi PinC,1" ein "Sbi PortC, 1" machen :) jetzt funzt es! Danke Für eure Hilfe, ich hoffe ich werde es noch ganz hinbekommen! ;-)
-
Thread
Was ist bei AVR externem RAM die Spitze des Machbaren? (in mb/s)
pro Clock ein Byte schreiben können oder nicht? Ich brauch ja schoin mehrere ASM Befehle (=mehrere AVR Clocks) im AVR, um Bytes von Intern an den Port zu legen. > > Weiß nicht genau was du meinst, aber du könntest eine kleine Hardware > bauen, die so konstruiert ist, dass der parallele Lesevorgang
pro Clock ein Byte schreiben können oder nicht? Ich brauch ja schoin >mehrere ASM Befehle (=mehrere AVR Clocks) im AVR, um Bytes von Intern an >den Port zu legen. Würd ich nicht sagen. LD/ST mit Auto Inc/Dec tut WÄHREND der Ausführung des Befehls: Die Adresse inc/dec, an den Adressausgang geben
-
Thread
atmega, avr-gcc: Umschaltzeiten output<>input
Tasterabfrage als auch für Kontrollleuchten. Praktisch sieht das so aus, dass ich alle ~10ms den Port von Ausgang auf Eingang umkonfiguriere, einen ggf. vorliegenden Tastendruck auslese, entprelle usw. und danach den Port wieder auf Ausgang schalte, um die Statusleds wiederherzustellen. Soweit alles
https://www.mikrocontroller.net/articles/AVR-Tutorial:_IO-Grundlagen#m.C3.B6gliche_Zeitverz.C3.B6gerungen
-
Thread
8 Lichtschranken mit Tutorialaufbau abfragen
kommst du sowiso nicht weiter. Die internen PullUp-Widerstände schaltet man ein, indem man den Port als Eingang schaltet (ddrx auf 0 setzt) und den Ausgang auf 1 setzt (portx auf 1). Dann kann man an pinx den Eingangspegel einlesen, der durch die internen PullUps gegen Vcc gezogen wird, wenn er von
ist (incl. Platine) auch nicht viel teurer, hat aber mehr und vor allem übersichtlicher angeordnete Ports. Such doch mal nach AVR und Board, da findest du sicher etwas. Mit einem fertigen Board hast du eine Fehlerquelle weniger, denn die erste selbstgestrickte Platine funktioniert in den seltensten Fällen
-
Thread
VB.net single -> avr float -> VB.net single
uart_putc(z.c[1]); uart_putc(z.c[2]); uart_putc(z.c[3]); }/* uart_putf */ [/c] Das einlesen in VB über den besagten BitConverter und dem SerialPort Interface + SerialPort.Encoding = Encoding.GetEncoding(28591). Beide Baugruppen laufen bei mir schon seit nem Jahr "problemfrei"... heute
programmierer... demnächst wird das Tool noch auf C# portiert... obwohl das ja auch nicht viel mit C aufn AVR am Hut hat... Achso, hier die Lösung: Wenn ich dem Serial Port die Encodernummer 28591 zuweise, dann muss ich beim decodieren vom String in ein Byte arryer mit System.Text.Encoding.GetBytes auch
-
Thread
Programmierung des ATMEGA 16 über serielPort
Zu allererst solltest du dich mal in das Avr-Tutorial hier einlesen. Dann sollte schon einiges klar werden. http://www.mikrocontroller.net/articles/AVR Die Programmierung mittels serieller Schnittstelle sollte nur mit vorhandenem Bootloader
du kennst dich "etwas aus"? Soso. >programm ist da, aber wie krieg ich das nun auf den chip [[AVR ISP]] MFG Falk
-
Thread
ADC Code
Hallo alle zusammen, ich möchte am PIN 3 des Ports A einen analogen Wert zyklisch mit dem AD-Wandler einlesen. Dazu habe ich das Programm wie im Anhang geschrieben. Da meine Hardware noch nicht vorhanden ist, Teste ich im AVR Studio. Nun meine Frage
. Der Rückgabewert der Funktion steht dann in 'Messergebnis' Sofern Du den GNU-Compiler (hier WinAVR) benutzt sollte es auch im AVR-Studio funktionieren.
-
Thread
Servo Mischer für Zeppelin
steht. Deiner Aussage folgend reichen ja schon 2 Pins: nämlich das ursprüngliche Summensignal einlesen, mischen und wieder als Summensignal ausgeben. Macht also (5 Pins weniger als Fernsteuerer)
Mix-Berechnungen (mit viel Programmcode in > einer Hochsprache) ein Mega88/168. Oder man beherrscht PIC oder AVR Assembler, dann genügt ein kleiner µC und simple Routinen und das Problem ist gelöst. Die Antwort klingt ja wie eine Marsmission, aber nicht wie das einfache Einlesen von einigen Servopulsen, verrechnen
-
Thread
Boese Ueberraschungen beim ATMEGA2560-16AU
man, glaub ich, PORTG nicht bitmäßig ansprechen. Mein Programm wird so ausgelegt sein, dass die Ports byteweise geschrieben oder gelesen werden. Kann ich davon ausgehen, dass es hier keine bösen Überraschungen wegen der Ports geben wird? Ich programmiere mit Codevision-AVR. Ich danke euch
sinnfrei diese Aussage, denn sie gilt nur, wenn stets der Wert >ausgegeben werden soll. Für das Einlesen mag sie eingeschränkt richtig >sein. ???? Was dauert bei einem Port lesen länger? in r16,portx i = PORTX; >Falk, hast du dir eigentlich mal dein gesamtes Posting durchgelesen? Du Oh
-
Thread
Atmega8 langsam, viel versucht = ratlos
nicht erkennen das hierbei nur 1 bit gesetzt wird, damit bleibt ihm nichts anderes Übrig als port einlesen daten verodern port ausgeben Und diesen teil rufst du viel zu oft auf, ständig wird die LED ausgeschaltet auch wenn sie schon lange aus ist.
= 53Hz = genug. 240 Takte wie bisher sind es wirklich nicht, oder? Ich arbeite gerade an dem Port-Ding. *Simulation* -AVR-Studio läuft unter wine nicht -AVR-Studio unter xen habe ich nicht vollends einrichten können (USB= DomU vs. Dom0?) -Ich versuche mich mal an simulavr, auch wenn ich gerade
-
Thread
Timer Overflow Interrupt behindert Externen Interrupt?
bisheriger Code: [c]#undef F_CPU #ifndef F_CPU # define F_CPU 7372800L #endif #include <avr/io.h> #include <stdio.h> #include <avr/interrupt.h> #include <inttypes.h> #include <util/delay.h> #include <stdlib.h> // Zahlen - Typumwandlung "toi" usw. #include <math.h> #define
und an lediglich einen Interrupt Eingang legen. Jeder Sensor geht zusätzlich noch an seinen eigenen Port-Pin. In der ISR siehst du halt ganz einfach am Port nach, welcher Sensor den Interrupt ausgelöst hat. Aber eigentlich kann man die Sensoren auch durch Pollen abfragen. Und dabei langweilt sich der
-
Thread
AVR Atmega8-16PU Probleme mit ADC
Hallo zusammen, ich hoffe, dass mir hier jemand weiterhelfen kann. Ich möchte eine variable Spannung (von Poti) am Analogeingang1 (Pin24) einlesen und die höherwertigen 8 bits am PortD darstellen. Dieser steuert erst nur LEDS an, um zu sehen, ob sich etwas tut. Leider funktioniert hier gar nichts. Testweise Ansteuern der LEDs mittels Festwert funktioniert. Folgend der Assembler Code: .nolist .include "m8def.inc" .nolist main: ;PortD als Ausgang ldi r18,0xff out ddrd,r18 ;Einlesen Analogwert ldi r16,0x61 ;Avcc als Referenz, ADLAR ein, Mux1 (0110 0001) out ADMUX
-
Thread
Servo-Pulssignalläge messen mit Atmega328p
Studio gesucht und einen gefunden... [C] #define F_CPU 8000000UL //internal 8MHz #include <avr/io.h> #include <util/delay.h> unsigned long rc_value; int main(void) { DDRD = (0<<PD2); // port pd2 input rc signal DDRD = (1<<PD6); // port , output led //PORTD = (1<<PD6);
BAUD 19200 //Debug #define MYUBRR FOSC/16/BAUD-1 #define LED_PORT PC0 #define LED_ON PORTC |= (1 << LED_PORT) #define LED_OFF PORTC &= ~(1 << LED_PORT) #define RC_RECEIVER_PORT PD2 #define RISING_EDGE PIND & (1 << RC_RECEIVER_PORT) /*Variablen*/ volatile
-
Thread
PCINT triggert nicht immer
<stdio.h> #include <avr\io.h> #include <avr\interrupt.h> int main(){ DDRA &= ~(1<<PA4)|(1<<PA5); DDRB |= (1<<PB1); //ext. int PCICR |= (1<<PCIE0); PCMSK0 |= (1<<PCINT4)|(1<<PCINT5); sei(); do{}while(
#2770347: >>Wo sind die ISR dafür? > Die sind doch mit ISR der PCINT0 abgefrühstückt? IM DB sind PortA 0-7 in > dem Register eingetragen. Du hast recht. Mein Fehler. Da hab ich nicht aufgepasst.
-
Thread
Linux C-Programm - Zeitmessung per Interrupt
Schnittstelle ausgegeben werden buffer[0] = (char)'A'; //printf(buffer); //printf("\n"); write(port, buffer, sizeof(buffer)); //printf("Zeichen wurde gesendet\n"); // Zeichen von der seriellen Schnittstelle einlesen // es wird bis Zeilenende oder max. 80 Zeichen gelesen y=0; for (
.\n"); return(1); } // Erste Zeile nach dem Reset einlesen (dient nur zur Kontrolle für den Test) for (x=0; x<30; x++) { // Jetzt können Daten gelesen werden bytes = read(port, buffer, sizeof(buffer)); printf(buffer); if (buffer[
-
Thread
VGA-Signal digitalisieren
Hier mal ein paar Bilder für die "Ist doch mit einem AVR nicht möglich" Fraktion.
Guten Tag Gemeinde, AVR Mega 16 16MHz habe das Problem das ich mit Timer 0 ein Hsync signal erfassen will. Also habe ich Hsync mit Port B1 verbunden. Indem ich Port B1 dann mit [avrasm] clr temph loop1: sbic
-
Thread
Atmega 16 PWM über Komparator unterbrechen
weiter. Vielen Dank. Gruß Steffen [c] //Bibliotheken einbinden #define F_CPU 8000000 #include <avr/eeprom.h> #include <avr/interrupt.h> #include <avr/io.h> #include "lcd-routines.h" #include <stdlib.h> #include <util/delay.h> //Variablendeklaration uint16_t eeunten EEMEM; //fuer EEPROM
Motor sollte ja auch ausgehen. [c] //Bibliotheken einbinden #define F_CPU 8000000 #include <avr/eeprom.h> #include <avr/interrupt.h> #include <avr/io.h> #include "lcd-routines.h" #include <stdlib.h> #include <util/delay.h> //Variablendeklaration uint16_t eeunten EEMEM; //fuer EEPROM
-
Thread
Simples SPI an AVR32 funktioniert nicht
aktivert... #define CS 10 #define SCK 13 #define MISO 11 #define MOSI 12 #define A 0 AVR32_GPIO.port[A].gpers |= (1<<CS) | (1<<SCK) | (1<<MOSI) | (1<<MISO); // Pins aktivieren AVR32_GPIO.port[A].oders |= (1<<CS) | (1<<SCK) | (1<<MOSI); // Pins als Ausgang
************************ //************************************************************* AVR32_GPIO.port[0].oders = 1 << 11; // The output driver is enabled for the corresponding pin AVR32_GPIO.port[0].gpers = 1 << 11; // Set GPIO PA11 to output AVR32_GPIO.port[0].ovrc