-
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
-
Thread
2 Fragen zum AVR Befehlssatz
1. Kann das Zeroflag nach erfolgtem Branch weiterverwendet werden. Ich möchte damit Sprünge kaskadieren, die außerhalb der Reichweite für rel. jumps liegen. Bsp: tst a breq p21 ... tst a p21: breq p22 ... p22: 2. Das Manual ist für mich nicht eindeutig. Kann ich ein Output-Bit über ein in rx, pinb einlesen? Bsp: ldi r16,0x55 out portb, r16 nop in r17, pinb Ist r17 dann 0x55? Danke.
-
Thread
Toggelgeschwindigkeit für Ports
Optimierung ist es nicht sonderlich schnell, da du ja den Compiler anweist, dass er jeweils den Wert des Ports erst wieder einlesen muss -- obwohl das für deine Funktion (Emulieren des SPI- Taktes) gar nicht notwendig wäre. Eine entrollte Schleife wäre nach der Hardware-SPI (weiß der Geier, warum du die
. Das hatte ich in meinem ersten Eifer dann einfach mal so "runterprogrammiert", nach dem Motto: Ports setzen, Takt simulieren mittels toggeln, Ports neu setzen, nochmal toggeln usw. Das funktionierte dann nicht und ich fing an mir Gedanken zu machen, ob das eventuelle am Takt liegen könnte und ich
-
Thread
Einstieg in FPGA/CPLD
nach durchaus ok, denn bei einer Normalen Lösung (8bit PWM lässt sich ja leicht in Software auf nem AVR realisieren) bräuchte ich auch mindestens 2 avr's, alleine schon wegen der Pins und preislich geben sich 2x AVR vs FPGA + avr nicht viel, sodass ich lieber die Lösung mit FPGA nehm und dafür dann im
EMV-Labor einfallen... Dominik Thalhammer schrieb im Beitrag #3092919: > und preislich geben sich 2x AVR vs FPGA+ avr nicht viel Dass du dir da mal nicht irgendwas schönrechnest. Aber fürs Hobby muss man nicht immer aufs Geld schauen...
-
Thread
Mega8 läuft mit 2MHz wie er soll, mit 8MHz nicht mehr.
>Wenn ich den AVR aber trotzdem in einer solchen Umgebung (PC-Netzteil) >betreiben möchte, wie stabilisiere ich das am geschicktesten? >Reichen da Abblockkondensatoren, oder doch eher Mit Z-Diode mit/ohne >Transistor
dummy wrote: >>Wenn ich den AVR aber trotzdem in einer solchen Umgebung (PC-Netzteil) >>betreiben möchte, wie stabilisiere ich das am geschicktesten? > >>Reichen da Abblockkondensatoren, oder doch eher Mit Z-Diode mit/ohne >>
-
Thread
8051 Befehl in avr umsetzen
Achtung, Falle. Wenn mich meine Erinnerung nicht trügt, wird auf dem 8051 dieselbe Port-Adresse für Input und Output genutzt. Beim AVR sind das zwei verschiedene (PIN vs. PORT). Darauf musst du bei der Umsetzung auch achten. Gruß, DetlevT
Macht eigentlich keinen großen Unterschied. Mußt halt nur eine 1 schreiben wenn Du einlesen willst. Im Gegenteil. Bei 8051 ist es eben nicht notwendig die Direction des Ports zu deklarieren. Port zur Laufzeit mit FF beschreiben und schon ist er als Eingang definiert. Mach das mal mit
-
Thread
touchpad ili9341 will nicht wie es soll
schrieb im Beitrag #7787059: > Hier mal ein Design-Vorschlag Ich versuche ja, einheitlich mit dem avr zu programmieren. Bei mir sieht das zur Zeit so aus: [c] #define GLUE(a, b) a##b #define GPIO(x) GLUE(GPIO,x) #define reg_dir_out(port,pin) \ {GPIO(port)->MODER&=~(0b11<<(pin*2)); \ GPIO(port)->MODER|= (0b01<<(pin*2)); \ GPIO(port)->PUPDR&=~(0b11<<(pin*2)); \ GPIO(port)->OTYPER&=~(1<<pin); \ GPIO(port)->OSPEEDR&=~(0b11<<pin);} #define reg_dir_in(port,pin,pullup) \ {/* 0b00no 0b01pu 0b10pd */ \ GPIO(port)->MODER&=
-
Thread
7 segment über aus 150m steuern
Optokoppler setzen. PC817 zum Beispiel. Als Pullup reichen 10k > oder der interne Widerstand des AVR. Genau.
Parallelport 8 mal schneller ist. Wenn du ein höherpaariges Kabel verwendest, dann könntest du zum Einlesen der Taster aber z.B. 8-bit-Schieberegister ggfs. auch kaskadiert verwenden, die parallel einlesen, und seriell ausgeben. Da ist auch kein µC erforderlich. Aber keine separate Leitung für jeden Taster
-
Thread
Pcf8574 datenblatt ohne infos über register?
>Aber trotzdem würde mich dann interessieren wie ich dem ic unterscheide >ob gerade daten am port anliegen oder obwas gesendet wird. Wenn du mit diesem "Satz" meinst, wie man dem PCF8574 sagt, ob er Daten ausgeben oder einlesen, dann solltest du dir das R/W-Bit im Adressbyte angucken. Das steuert
möglichkeiten: 1. Zyklisch Lesen --> Senden Adressbyte + R/W bit = 1 Danach einfach 8bits einlesen ACK abfragen nicht vergessen 2. Interrupt gesteuert. d.h. sobald sich was am Port ändert wird ein interrupt ausgelöst. Dann kannste wie unter 1 verfahren. Es ist dir hoffentlich klar das
-
Thread
Schaltzustände potentialfreier Kontakte per LAN übertragen
per LAN ins Heimnetz > überträgt, so dass ich diese per Software auslesen kann. Klassiker: X-Port Wenn man nicht jedem Tor einen X-Port spendieren will, mit einem Controller kombinieren. Was auch geht: Print-Server mit seriellem Port, und den als "Terminalserver" laufen lassen. Terminalserver
krieg ich wenn es sein muss auch noch SMD aber Programmieren > würde dauern, wenn ich mich da einlesen muss In diesem Fall könnte das etwas für dich sein: https://stefanfrings.de/avr_io/index.html Eventuell überlässt dir der Chef von der Firma chip45 das Layout von einer Platine, oder er hat
-
Thread
Hilfe Grundlagen Atmel in C
. Als ich mich in AVR einlesen wollte, habe ich einfach die umfangreichen Datenblätter gedruckt und nach und nach gelesen. Möchtest du einfach in AVR uC einsteigen (und lernen) oder hast du schon ein bestimmtes Projekt
define CURSOR_HOME 0x02 // Pinbelegung für das LCD, an verwendete Pins anpassen #define LCD_PORT PORTA//an meine Werte angepasst #define LCD_DDR DDRA #define LCD_RS PD4 #define LCD_EN PD5 // DB4 bis DB7 des LCD sind mit PD0 bis PD3 des AVR verbunden Leider funtioniert
-
Thread
Suche: Generator für mehrere digitale Signale
Und wenn du es mit einem AVR machen willst, schickst du die begrenzte Anzahl von Zuständen von 8 Ports in sein SRAM, gibst grob die Taktfrequenz vor und los gehts.
Moritz G. schrieb im Beitrag #4956166: > Ich werde einfach einen Port nehmen damit es Gleichzeitigkeit gibt und > eine Serie von 24 bit "Befehlen" im 2KB SRAM speichern. Immer wenn der > Zählerstand im "Befehl" erreicht ist wird das Byte an den Port > geschrieben.
-
Thread
Timer0 + UART = Interruptprobleme
durcheinander?! Vielleicht pollt dieser auch die eingehenden Daten und wird durch die Kommunikation vom AVR gestört?! Aber wenn der AVR Daten gesendet hat, werden nur die Daten vom Partner bearbeitet, ohne dass der AVR dazwischen erneut etwas sendet. Das ist sehr seltsam. Wie bereits geschrieben, mit Delays hatte es ganz zu Anfang ohne Probleme funktioniert. So war vorher das AVR-Programm aufgebaut: * AVR sendet * _delay_ms(100) * (während Delay hat der Partner Daten an den AVR gesendet) * AVR wertet Daten aus dem Ringpuffer aus * wenn Daten gültig, wieder etwas senden
-
Thread
Motoransteuerung mit PWM
habe ich kein Oszi da um den PWM Ausgang zu testen. Mein Code sieht wie folgt aus: #include <avr/io.h> #include <avr/interrupt.h> #include "lcd_ks0066_4bit_io.h" #include "Define_Inputs.h" #include "Define_Outputs.h" #include <stdlib.h> #include <inttypes.h> void initial(void) {
// PING2 } // Motor links rechts lauf if (STATE_DI4_INPUT_X6) { PORTE &= ~(1<<OUT_H_Bridge_Right_A_PINE6); PORTE |= 0x80; //PINE7 } else { PORTE &= ~(1<<OUT_H_Bridge_Left_B_PINE7); PORTE |= 0x40; //PINE6 }
-
Thread
Verständniss Problem und allgemeine Fragen
i vermute das die anderen Pins von port D 'floaten' dh. du must den Pin filtern vor dem vergleich irgend wie in der art dummy = pind AND 0b00000100 so ist sichergestellt das nur bit2 noch relevant ist vlG Charly
Einstellung für die pullups und bei der if-abfrage schreibst du in "PORTD" den Ausgangsstatus des Ports. Ich hatte das mal, dass ich vergessen hatte, den ADC auszuschalten, der am Port hängt. Allerdings bei einem anderen Controller. Vielleicht hast du ja auch am PORTD eine höherwertige Funktion als
-
Thread
Parallele Reedkontakte mit Toggle
IOs des ESP sind demnach nicht das Problem :) Soweit ich das gerade Überblicke, macht ein Port-Expander an Pin INT genau das, was ich für den Reset des ESP brauche. Die Status der einzelnen Eingänge könnte ich dann über I2C einlesen, richtig? Danke für den Hinweis @c-hater https://www.mikrocontroller.net
schalten. Florian W. schrieb im Beitrag #6751369: > Soweit ich das gerade Überblicke, macht ein Port-Expander an Pin INT > genau das, was ich für den Reset des ESP brauche. Die Status der > einzelnen Eingänge könnte ich dann über I2C einlesen, richtig? > https://www.mikrocontroller.net/articles/
-
Thread
ATMega4809 EVSYS, total überfordert
musste alle Bits im Register einzeln verordern und zuweisen. [c] EVSYS.CHANNEL4 = EVSYS_GENERATOR_PORT1_PIN1_gc; // verbinde Generator 'Pin PF1' mit Kanal 4 [/c] PORT1 ist aus Tabelle festgelegt. PIN1 ist das Bit1 von deinem Port PF1. Welche Pins als Event User verfügbar sind findet man in
Port Signale umrouten muss man nicht.
-
Thread
Frage zu 8-Line To 3-Line Encoder im Midi-Projekt
am µC einen freien A/D-Wandler Pin hast, kannst du die gedrückten Tasten einer Zeile über diesen einlesen und brauchst dann anstatt der zehn zum Einlesen benutzten IO-Pins nur mehr diesen einen A/D-Pin (und zehn Widerstände, um die einzelnen Spalten per A/D-Wandler unterscheiden zu können). Anregungen
gibt's hier: http://www.mikrocontroller.net/topic/52500 Solltest du dann immer noch zuwenige Ports haben, kannst du die Anzahl deiner Ports mit (hintereinander geschalteten) Schieberegistern beliebig erweitern. Unabhängig davon, wie viele Schieberegister du verwendest, brauchst zu deren Anschluss
-
Thread
6 Tachosignale von PC-Lüftern messen
und 32er da hab. Die Signale hängen an einem normalen Eingang. http://www.stefan-moench.de/pc/avr_lueftersteuerung/avr_lueftersteuerung.htm Da oben habe ich eine Lösung mit 4 Lüftern gefunden, allerdings kann ich kein/kaum Assembler und ich verstehe den Assembler Code überhaupt nicht. Ich möchte
messen. Von den AD-Wandlern hat der Mega16/32 ja 8 Stück... Du könntest aber auch mit einem Timer den Port an dem die Lüfter hängen in regelmässigen Abständen (z.B.10µs) einlesen und so die Drehzahl feststellen. Du könntest auch die Tachosignale mit einem Multiplexer an den ICP-Eingang schalten und dann
-
Thread
Grundsätzliche Frage zum Rechnen in avrasm
120) - dann das Ergebnis (85) am Port wieder einlesen. Ist das zu naiv gedacht? Oder gibt es so ein modul?
die Brust ins Auge. Du schreibst die Zahl als String hin und läßt dann zur Laufzeit den String einlesen. Assembler und Rechnen passen also nicht sonderlich gut zusammen. Peter
-
Thread
40x SPI-Chipselect?
jeweils ein PT100 hängt an einem dieser ICs? Und Du willst alle 40 ICs dannn durch einen Master-IC (AVR?) steuern und jeweils die CS Leitungen vom Master-IC durchsteuern und die Messwerte dann per SPI auslesen? Mit einem Port-Extender (MCP23017 et al.) oder einem TQFP64 AVR (z.B. ATMega644 oder ATMega128
Vcc+ gezogen ist das der Baustein 1 A0 und A1 auf Vcc+ Baustein 2 usw Wenn du einen GPIO einlesen willst, und du weisst, welchen du einlesen willst, z.B den des Baustein 3 Port A Bit3 dann schreibst einfach Value = SPI_READ(Device, GPIO); Wenn du dir schöne Defines anlegst, .. #define
-
Thread
Logikanalysator für den Parallel Port
MHz und einem 32k seriellen SRAM. Bei einem bestimmten Bitmuster startet der Logikanalyser das Einlesen. Je nach Anwendung hab ich vorher den 8515 programmiert, das er so alle paar us die Eingänge an einem Port ins SRAM eingelesen hat. Ist also 8 Kanal und geht nur mit 5V (da die Ports direkt angeschlossen
erfolgreich benutzt zum Debuggen von I2C und RC5 Software: A logic analyzer using the PC's parallel port. http://www.xs4all.nl/~jwasys/old/diy2.html
-
Thread
Tabellen in Assembler für Atmega 16
programmiert und die liest. hab folgendes vor. ich will ein wert durch tastendrücken, wie bei einer uhr einlesen und über 7 segment anzeige anzeigen lassen. hat jemand ideen, wie man sowas macht. danke im voraus
lpm wl,z ;Bitmuster aus Flash holen out segport,wl ;und an Segment-Port ausgeben ret ;zurück...
-
Thread
attiny USI Slave Implementierung
ein kleiner Fehler sein... in der usiTwiSlave.c musst du folgendes Ändern [c] #elif defined( __AVR_ATtiny25__ ) | \ defined( __AVR_ATtiny45__ ) | \ defined( __AVR_ATtiny85__ ) #define DDR_USI DDRB #define PORT_USI PORTB #define PIN_USI PINB #define
spricht technisch was dagegen? genügt es folgende Ergänzung zu machen? [c] #elif defined( __AVR_ATmega8__ ) #define DDR_USI DDRC #define PORT_USI PORTC #define PIN_USI PINC #define PORT_USI_SDA PC4 #define PORT_USI_SCL PC5
-
Thread
Mehrere Timer aktiv?! Atmega8l
Hex-Dateien wäre kein Problem aber die Steuerung der 3 ISP-Signale und sowieso der Zugriff auf die COM-Ports. MfG Andi
mehr stimmt. Böse Falle, aber ich animiere niemanden dazu, das Teil zu verwenden. Der ISP(SPI)-Port war nicht das Problem, das Timing wird ja in den AVR-Datenblättern gut beschrieben, die Serielle unterstützt mein Programmer nicht. Und es ist schließlich nicht das erste QB-Programm, das den Druckerport
-
Thread
Erstes Programm vom AVR-Tutorial mit dem ATmega8515
Folgendes Programm habe ich im AVR - Tutorial gefunden: [avrasm] .include "m8def.inc" ldi r16, 0xFF out DDRB, r16 ; Alle Pins am Port B durch Ausgabe von 0xFF ins ; Richtungsregister
DDRB als Ausgang konfigurieren ldi r16, 0x00 out DDRD, r16 ; Alle Pins am Port D durch Ausgabe von 0x00 ins ; Richtungsregister DDRD als Eingang konfigurieren loop: in r16, PIND ; an Port D anliegende Werte (Taster) nach r16 einlesen
-
Thread
Anfängerfrage: Temperatursensor steuert Gerät über LPT port
erklärt: http://www.rn-wissen.de/index.php/I2C Damit sollte das meiste beantwortet sein. avr
beschrieben (Suchfunktion). Es gibt auch einfache Varianten an der RS232 (kein USB-Wandler!). avr
-
Thread
Warte-Befehl in Assembler?
AVR, so erhält man alles, nur keine RC5 Befehle. Wenn man sich dann den generierten Code von Compilern (Bascom etc.) oder was zu RC5 an Codebeispielen zum AVR anschaut, so stellt man schnell fest, dass
denke aber mal, wenn ein und derselbe RC5 Empfänger an der C-Control feste Zeiten pro Bit hat und beim AVR nicht, wenn die Zeiten bei der DCF77 Uhr dermaßen schwanken, dann liegt für mich die Ursache eindeutig beim AVR. Wenn man dies berücksichtigt, dann kann man denke ich mit dem AVR alles machen. Die C-Control
-
Thread
geht es noch schneller in ASM?
BIT cbi port_data sbrc R17,7 sbi port_data sbi port_clock cbi port_clock rol R17 'drittes Bit cbi port_data sbrc R17,7 sbi port_data sbi port_clock
ich glaube, besser geht's nicht! Doch: jetzt könnte man noch daten und clock auf verschiedene Ports legen und den Trick mit dem Einlesen des Ports auch da anwenden, dann kann man für SBI und CBI noch 2x OUT (mit vorbelegten registern) schreiben und spart nochmal 2 Takte je bit. Ich danke Euch
-
Thread
Funktioniert diese Schaltung so?
nicht wie beim AVR umschalten, sondern man setzt den Port auf "1", wenn man ihn als Eingang benutzen will. Und bei "0" ist das Geraffel dahinter sowieso ohne Funktion. Mini Float schrieb im Beitrag #2401073: >
Elektronik und > Open-Collector-Ausgang? Muss er auch sein. Der muss in der Lage sein, den Pullup des Ports auf "0" zu ziehen. Sonst wird das nichts mit 'nem 8051. Jedenfalls wenn man den Zustand damit einlesen will. Aber wozu soll der Port sonst gut sein? mfg.
-
Thread
Primitiver Computer im Eigenbau
so etwas habe ich auch vor, irgendwie mal einen computer im miniformat zu bauen auf der untersten avr-stufe. interessant hier im forum ist auch das avr-basic auf einen avr644p. da kannst du mal schauen wie ein interpreter funktioniert. das programm ist sehr übersichtlich geschrieben. es passt
andere Zeichen, ausser 0..9 darstellen möchte, sollte man auf den einsatz von decodern verzichten. Um Ports/Pins zu sparen, benutzt man multiplexing, was in http://www.mikrocontroller.net/articles/AVR-Tutorial:_7-Segment-Anzeige beschrieben ist. MfG Turbotoni
-
Thread
GPS-Parser für XMEGA
zweidimensional sein? sollte so sein, vermutlich für 4 Satelliten. Aber.. der Aufruf GPGSV_Einlesen(GPGSV0, &GPS_Daten0) führt im AVR-Studio4 zu folgenden Fehler, da die Variable ein mehrdimensionales Array ist. warning: passing argument 1 of 'GPGSV_Einlesen' from incompatible pointer type void GPS_Einlesen(uint8_t Empfaenger){ if(Empfaenger == 0) { GPRMC_Einlesen(GPRMC0, &GPS_Daten0); // ok GPGGA_Einlesen(GPGGA0, &GPS_Daten0); // ok GPGSA_Einlesen(GPGSA0, &GPS_Daten0); // ok GPGSV_Einlesen(
-
Thread
USB-Host / industrielle SPS / Frequency Counter
Protokollumsetzungsgeschichte zu basteln ? Bleibt noch die Frage, wie wir dann die Frequenz vom Counter in die SPS einlesen wollen. Bester Gruß Draco
geschrieben, aber falls es noch herüberkommen ist - hier nochmal: ich habe an der SPS nur einen 232/485 Port, einen einzigen. Den kann ich programmmäßig als serielle schnittstelle oder Modbus Port festlegen. Jetzt ist es so, daß ein industrielles AD-Wandler (IO) Modul von Advantech zugekauft werden muss, und
-
Thread
DIP Schalter abfrage funktioniert nicht
wenn ich den Code von 80% da reinlege, funktioniert es nicht. Woran liegt es also? [c] #include <avr/io.h> #include <util/delay.h> #include <avr/interrupt.h> #include <avr/sleep.h> volatile int sekunde = 0; //wird vom Timer immer um 1 erhöht. //1 = 0,01sekunden
#define LED_PORT PORTD #define ERROR_LED PD5 #define TURN_ON(b) LED_PORT |= ( 1 << b ) #define TURN_OFF(b) LED_PORT &= ~( 1 << b ) ... TURN_ON( ERROR_LED ); TURN_OFF( BUSY_LED ); [/c] und
-
Thread
verständnisfrage timer mega48
, an dem du die Spannung leicht sichtbar machen kannst [C] #define F_CPU 16000000 #include <avr/io.h> #include <util/delay.h> #define LED_PORT PORTB #define LED_PIN PB1 int main() { while( 1 ) { LED_PORT |= ( 1 << LED_PIN ); _delay_ms( 1000 ); LED_PORT &= ~( 1 <<
COMPA_vect) { if(timer1==0)timer1=1; } SIGNAL(INT0_vect) { freq++; } void set_ports(void) { port_spi_7SEG_cs(); //CS 7SEG port_spi_sck(); //SCK port_spi_mosi();//MOSI port_spi_miso();//MISO SEG_cs_high(); } void main(void) { set_ports(); init_7seg1(
-
Thread
C-Code optimieren
= AVR32_GPIO.port[IPMS_DB_PORT].pvr; /* Byte wieder zurecht biegen */ if(temp_bitmask & (1 << (GPIO_IPMS_DB0 & 0x1F))) data |= 1; if(temp_bitmask & (1 << (GPIO_IPMS_DB1 & 0x1F))) data |= 2;
[c] uint32_t i = AVR32_GPIO.port[IPMS_DB_PORT].pvr; Data = ((i >> 11) & 1) | ((i >> 12) & 6) | ((i >> 18) & 8) | ((i >> 23) & 0xF0); [/c]
-
Thread
Probleme mit In und Out
Hallo Leute, ich habe ein Problem. Ich möchte an Port C etwas ausgeben (Daten für ein EEPROM). Später möchte ich sie zur Kontrolle wieder einlesen. Habe ich als letztes 66h (also f) ausgegeben liegt dies am EEPROM auch an. Habe ich mit einem Multimeter
siehe Datenblatt I/O-Ports). Tschüß, Andre. -- CAN@home - http://www.CANathome.de - Hausautomation mit AVR + CAN
-
Thread
AVR-Pin als Ein- und Ausgang nutzen
Seiten stöbern würdest findest du auch etwas dazu. z.B. : http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Zugriff_auf_Ports http://www.mikrocontroller.net/articles/AVR_Checkliste#Hardware
: Externen Pullup dran, im PORT-Register das betreffende Bit auf Null, und dann die Ausgabe per DDR. Voila!
-
Thread
Probleme bei Programm (Assembler)
gesetzt,die dann festlegen,wie der Timer funktioniert. http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Die_Timer.2FCounter_des_AVR
PORTC, 0 ist aber kein AVR-Assembler denke das ist eher 8051 oder was anderes. Woher kommen die 5V an den Pin durch externen oder internen Pullup? Einen einzelnen Pin z.b. PortD Pin7 frägt man am leichtesten so ab sbic
-
Thread
com schnittstelle mit c ansprechen
empfängt Daten. Ich habe ihn der Übersicht halber auf das reduziert, was ich brauche, nämlich das Einlesen von Daten, die der ATmega16 per USART sendet (soll ein Datenlogger werden). Der AVR sendet testweise in seinem Programm nur einmal ein Telegramm von 10 bytes. Er hängt am STK500, benutzt also dessen 5V-Versorgung und den Spare-RS232-Port. Damit sendet er immer dann ein Telegramm, wenn ich den Resetknopf auf dem STK500 drücke. Jetzt zum Problem: Nachdem die 10 bytes empfangen worden sind, wird am COM-Port des PCs anscheinend das Event
-
Thread
Binär Uhr Selbst Bauen
Beschaltung) ein (liegt an PB0 an) Einen Takt kann man mit einem externen Interrupt oder einem Timer einlesen. Man könnte auch einfach die 4,194304MHz oder einen anderen Quarz direkt als CPU-Takt anschließen. Der AVR hat die Hucke voll mit Timern, die das runter teilen können. Lars S. schrieb im Beitrag
Ich habe mal eine andere Frage: Ich nutze PORTB,1 als Eingang, in der Simulation beim AVR-Studio 4 funktioniert das auch. Aber in der Schaltung klappt es nicht. Ich habe auch schon nachgeschaut es liegt auch ein High-Signal an dem Port an (4,93V). Kann es sein, dass ich den irgendwie von
-
Thread
Reinitialisieren von Registern beim ATtiny841
Windows/Software-Updates ein Neustart gemacht wird. 2 RasPi's könnte ich auch noch dazuzählen, einige AVR und ESPs durchaus auch. Gruß aus Berlin Michael
festzustellen. Dann muß man das I2C disablen, um es zurück zu setzen. https://www.robotroom.com/Atmel-AVR-TWI-I2C-Multi-Master-Problem.html
-
Thread
Kippschalter an zwei AVRs gleichzeitig anschließen
Dioden am Schalter verbinden. Komme ich mit den Dioden ausreichend auf Low? Das Datenblatt des AVR sagt Input Low Voltage max. 0,2V.
Udo S. schrieb im Beitrag #7750513: > Wenn du den Port jetzt auf Ausgang schaltest und auf High legst, fließt > genauso der Kurzschlussstrom über die Diode zum Schalter. Dann also doch mit Serienwiderstand zum Port-Pin ...
-
Thread
Port D, Pin PD7 vom At90S8515 bleibt auf Low Pegel.
neue At90S8515 von Reichelt bezogen (alle aus einer Charge 0327) und alle 3 machen dasselbe. Beim Einlesen der Port D Pins erhalte ich immer ein low von PD7 egal welcher Pegel anliegt.
Thorsten, hier noch ein paar Details. Der AVR steckt auf einem Steckbrett und das Port D mit allen Pins ist voellig isoliert. Nach dem Programmieren gehen alle Port D Pins mit dem Reset auf High und dann PD0-PD6 in Tristate und PD7 auf Low. Wenn
-
Thread
Erfahrung wäre nicht schnell
! #include <avr/io.h> #include <avr/interrupt.h> //unsigned char typedef enum {FALSE,TRUE} logic; logic HolzIstNeu; int sollwert=4; int istwert=0; void Init(void); void output_H(void); void output_L(void
> Das zweite Problem ist in der main, im while loop. Ich möchte einen > sollwert aus dem PORTC einlesen. Und diesen Wert für das Zählen des > Interrupt ereignisses nutzen. Das lesen geht so nicht. Was muss ich > machen? Einlesen vom Port nicht über PORTx sondern über PINx, sonst liest du immer
-
Thread
Lightweight WS2811/WS2812 Library
provided with support cpu clocks from 8Mhz to 16Mhz (standard AVR) or 4MHz to 8Mhz (reduced core). Usage ===== - Add "light_ws2812.c" and "light_ws2812.h" to your project - Change ws2812_port and ws2812_pin in the include file according to the I/O pin you
_GPIO_PORT->CLR0) // Address of the data port register to clear the pin [/c] Die Adresse des von mir verwendeten Port ist 0x40044084, was ich anstelle von &LIGHT_WS2812_GPIO_PORT eingefügt habe. Jedoch ohne
-
Thread
AVRs mit USB?
Was genau ist an ATMega*U veraltet? Sind doch noch in Produktion... Ansonsten gäbe es noch die AVR*DU, z.B. den AVR16DU14, der ist so brandneu, denn gibts noch nicht mal zu kaufen. Aus dieser Reihe sind bis dato nur der AVR64DU28 und AVR64DU32 verfügbar
trotzdem noch auf eine simplere Umsetzung. Das Anstecken meines Controllers soll einen virtuellen COM-Port zum Datenaustausch bereitstellen- mehr brauchts nicht. Es hilft auch wenig, wenn die begrenzten Ressourcen eines AVR bereits zum guten Teil durch das USB-Handling belegt würden.
-
Thread
7 Segmentanzeige falsch eingekauft, reagiert nur auf low.
also a,b,c,d,e,f und ggf. auch dp) parallel und schließt sie über Vorwiderstände 330 Ohm an einem Port mit 7 oder 8 Portpins an. Das wäre bei Deinem Mega8 der PortD, da PortB und PortC keine volle 8 Bit Breite haben (PB6 und PB7 wird ja vom Quarz blockiert). Dann brauchst Du für jede Anzeigestelle
streichst. Stattdessen solltest Du die Segmente aller 4 Anzeigen (über Widerstände 330 Ohm) direkt an den AVR anschließen. Um sie alle an einen Port zu bekommen (damit die Programmierung einfacher wird), solltest Du sie an PortD des Mega8 anschließen, denn von PortB blockiert der Quarz ja zwei Bit und PortC