Dann melde ich mich wohl hier nochmal :D
Nachdem ich mich dran versucht habe und zu keinem Vernüftigen Ergebnis kam hier mal mein Code den ich bis jetzt erstellt habe. Mit ein bisschen hilfe muss ich dazu sagen.
Der Anschluss am Board ist mir auch recht schlüssig und sollte ich richtig gemacht haben.
Vielleicht kann ja jemand mal drüber schauen und mir Konkret sagen was ich noch ändern muss oder kurz einfach überarbeiten.
Danke schonmal
Gruß Jens
// ------------------------------------------------------------------------------------
// Einbinden von Bibliotheken; Festlegen von Einstellungen
// ------------------------------------------------------------------------------------
#define F_CPU 3686400 // Festlegen µC-Takt
#include <avr\io.h> // Bibliothek der Namen der Register
#include <util\delay.h> // Bibliothek mit Warteroutinen
#include <avr/interrupt.h> // Bibliothek mit Interrupts
#include <stdint.h> // Bibliothek mit Datentypen
// ------------------------------------------------------------------------------------
// Deklarationen von globalen Variablen
// ------------------------------------------------------------------------------------
volatile uint8_t uart_str_complete = 0; // Deklaration uart_str_complete
volatile char uart_string[30] = ""; // Deklaration uart_string
volatile uint8_t uart_str_count = 0; // Deklaration uart_str_count
uint16_t Analogwert = 0;
// ------------------------------------------------------------------------------------
// Senden an PC über serielle Schnittstelle (USB)
// ------------------------------------------------------------------------------------
void uartPutChar(char data) // 'uartPutChar' zur Datenübertragung
{
while (!(UCSRA & (1<<UDRE))); // Endlosschleife solange UDR nicht leer ist
UDR = data; // 'data' in 'UART I/O Data Register' schreiben
}
void print(const char buffer1[]) // selbsterstellte Strings an PC senden
{
for(int i=0; buffer1[i]!=0; i++) // Schleife durchlaufen bis alle Daten verarbeitet
{
uartPutChar(buffer1[i]); // Aufruf 'uartPutChar'
}
uartPutChar('\n'); // Endzeichen '\n' zur Markierung des Übertragungsendes
}
// ------------------------------------------------------------------------------------
// AD-Wandlung von Kanal X
// ------------------------------------------------------------------------------------
int AD_Wandlung(int x) // Analog-Digital-Wandlung
{
cli(); // globale Interrupts deaktivieren
ADMUX = x; // Kanal einstellen
ADMUX |= (1<<REFS0); // AVCC als Referenzspannung, Wandlungsergebnis linksbündig
// um die 2 niederwertigsten Bits rauszufiltern (wegen Flatterwerten)
ADCSRA = 0b11000101; // Frequenzvorteiler auf 32 setzen
// und ADC0 als Analogeingangsbit aktivieren
while(bit_is_set(ADCSRA,ADSC)); // Warten bis Wandlung abgeschlossen
Analogwert = ADCW; // ADCW-Wert in Analogwert übergeben
sei(); // globale Interrupts aktivieren
return Analogwert; // Analogwert an Hautprogramm zurückgegeben
}
// ------------------------------------------------------------------------------------
// Interrupt empfangen
// ------------------------------------------------------------------------------------
ISR(USART_RXC_vect) // Interrupt-Sub-Routine USART_RXC_vect
{
unsigned char nextChar; // Deklaration 'nextChar'
nextChar = UDR; // Daten 'UART I/O Data Register' in 'nextChar'
if(uart_str_complete == 0) // Wenn uart_str_complete=0, dann
{
if(nextChar != '#') // Wenn 'nextChar' nicht '#', dann
{
uart_string[uart_str_count] = nextChar; // Daten 'nextChar' in String ablegen
uart_str_count++; // uart_str_count inkrementieren
}
else // sonst
{
uart_string[uart_str_count] = '\0'; // uart_string[] Ende des Strings '\0' zuweisen
uart_str_count = 0; // 0 in uart_str_count Null schreiben
uart_str_complete = 1; // 1 in uart_str_complete schreiben
}
}
}
//-----------------------------------------------------------------------------------
// main
//-----------------------------------------------------------------------------------
int main ()
{
// 6 Eingänge = PIND,2 bis PIND,7
// 6 Ausgänge = PINB,0 bis PINB,5
DDRD |= 0b00000000; // Datenrichtung Port D 0=Eingang 1=Ausgang
DDRB |= 0b11111111; // Datenrichtung Port B 0=Eingang 1=Ausgang
DDRC |= 0b00000000; // Datenrichtung Port C 0=Eingang 1=Ausgang
PORTD |= 0b11111100; // Ausgänge von Port D
PORTB |= 0b00000000; // Ausgänge von Port B
PORTC |= 0b11111111; // Ausgänge von Port C
UBRRL = 23; // 9600 Baud siehe Baudratentabelle
UCSRB = 0b10011000; // Interrupt RX ein, Senden & Empfangen ein
UCSRC = 0b10000110;
sei(); // globale Interrupts aktivieren
// Programmvariablen
uint16_t AD_Wert=0;
char Eingaenge[15];
char AD_WertBuffer[15];
while (1) // Mainloop-Begin
{
_delay_ms(100); // 100 ms warten
// empfangene Ausgangsdaten von PC auswerten und ausgeben
if(uart_str_complete == 1) // Wenn String komplett Empfangen, dann Auswertung:
{
if(uart_string[0] == 'S') // Wenn erste Stelle = 'S', dann
{
if(uart_string[1] == '1') // Wenn zweites Bit = '1', dann
{
PORTB |= (1<<PB0); // Ausgang Port B,0 = 1
}
else // Wenn zweites Bit = '0', dann
{
PORTB &= ~(1<<PB0); // Ausgang Port B,0 = 0
}
if(uart_string[2] == '1') // Wenn drittes Bit = '1', dann
{
PORTB |= (1<<PB1); // Ausgang Port B,1 = 1
}
else // Wenn drittes Bit = '0', dann
{
PORTB &= ~(1<<PB1); // Ausgang Port B,1 = 0
}
if(uart_string[3] == '1') // Wenn viertes Bit = '1', dann
{
PORTB |= (1<<PB2); // Ausgang PortB,2 = 1
}
else // Wenn viertes Bit = '0', dann
{
PORTB &= ~(1<<PB2); // Ausgang PortB,2 = 0
}
if(uart_string[4] == '1') // Wenn fünftes Bit = '1', dann
{
PORTB |= (1<<PB3); // Ausgang PortB,3 = 1
}
else // Wenn fünftes Bit = '0', dann
{
PORTB &= ~(1<<PB3); // Ausgang PortB,3 = 0
}
if(uart_string[5] == '1') // Wenn sechstes Bit = '1', dann
{
PORTB |= (1<<PB4); // Ausgang PortB,4 = 1
}
else // Wenn sechstes Bit = '0', dann
{
PORTB &= ~(1<<PB4); // Ausgang PortB,4 = 0
}
if(uart_string[6] == '1') // Wenn siebtes Bit = '1', dann
{
PORTB |= (1<<PB5); // Ausgang PortB,5 = 1
}
else // Wenn siebtes Bit = '0', dann
{
PORTB &= ~(1<<PB5); // Ausgang PortB,5 = 0
}
}
uart_str_complete = 0; // Freigabe für Empfang weiterer Strings über RS232
}
// Eingänge zusammenstellen
// Eingänge mit '0' initialisieren
Eingaenge[0] = '0';
Eingaenge[1] = '0';
Eingaenge[2] = '0';
Eingaenge[3] = '0';
Eingaenge[4] = '0';
Eingaenge[5] = '0';
// Eingangs-PINs liegen an PULL-UP-Widerstand und werden bei Beschaltung auf Masse gezogen
if(bit_is_clear(PIND,2)) // Wenn Eingang PIND,2 = 0, dann
{
_delay_ms(23); // Entprellzeit
if(bit_is_clear(PIND,2)) // Wenn Eingang PIND,2 nach Entprellung = 0, dann
{
Eingaenge[0]='1'; // binärer Wert an LabVIEW
}
}
if(bit_is_clear(PIND,3)) // Wenn Eingang PIND,3 = 0, dann
{
_delay_ms(23); // Entprellzeit
if(bit_is_clear(PIND,3)) // Wenn Eingang PIND,3 nach Entprellung = 0, dann
{
Eingaenge[1]='1'; // binärer Wert an LabVIEW
}
}
if(bit_is_clear(PIND,4)) // Wenn Eingang PIND,4 = 0, dann
{
_delay_ms(23); // Entprellzeit
if(bit_is_clear(PIND,4)) // Wenn Eingang PIND,4 nach Entprellung = 0, dann
{
Eingaenge[2]='1'; // binärer Wert an LabVIEW
}
}
if(bit_is_clear(PIND,5)) // Wenn Eingang PIND,5 = 0, dann
{
_delay_ms(23); // Entprellzeit
if(bit_is_clear(PIND,5)) // Wenn Eingang PIND,5 nach Entprellung = 0, dann
{
Eingaenge[3]='1'; // binärer Wert an LabVIEW
}
}
if(bit_is_clear(PIND,6)) // Wenn Eingang PIND,6 = 0, dann
{
_delay_ms(23); // Entprellzeit
if(bit_is_clear(PIND,6)) // Wenn Eingang PIND,6 nach Entprellung = 0, dann
{
Eingaenge[4]='1'; // binärer Wert an LabVIEW
}
}
if(bit_is_clear(PIND,7)) // Wenn Eingang PIND,7 = 0, dann
{
_delay_ms(23); // Entprellzeit
if(bit_is_clear(PIND,7)) // Wenn Eingang PIND,7 nach Entprellung = 0, dann
{
Eingaenge[5]='1'; // binärer Wert an LabVIEW
}
}
// AD_Wert ermitteln
AD_Wert = AD_Wandlung(0); // Analog-Digital-Wandlung aufrufen
itoa(AD_Wert, AD_WertBuffer, 10); // Integer to ASCII; 10 = dezimal
// AD_Wert in Eingangs-String einarbeiten
if(AD_Wert <10) // Wenn Eingangswert<10 -> Tausender, Hunderter, Zehner = '0'
{
Eingaenge[6] = '0'; // Tausenderstelle
Eingaenge[7] = '0'; // Hunderterstelle
Eingaenge[8] = '0'; // Zehnerstelle
Eingaenge[9] = AD_WertBuffer[0]; // Einerstelle
}
else if(AD_Wert <100) // Wenn Eingangswert<100 -> Tausender, Hunderter = '0'
{
Eingaenge[6] = '0'; // Tausenderstelle
Eingaenge[7] = '0'; // Hunderterstelle
Eingaenge[8] = AD_WertBuffer[0]; // Zehnerstelle
Eingaenge[9] = AD_WertBuffer[1]; // Einerstelle
}
else if(AD_Wert <1000) // Wenn Eingangswert<1000 -> Tausender = '0'
{
Eingaenge[6] = '0'; // Tausenderstelle
Eingaenge[7] = AD_WertBuffer[0]; // Hunderterstelle
Eingaenge[8] = AD_WertBuffer[1]; // Zehnerstelle
Eingaenge[9] = AD_WertBuffer[2]; // Einerstelle
}
else // sonst Eingangswert vierstellig (>=1000)
{
Eingaenge[6] = AD_WertBuffer[0]; // Tausenderstelle
Eingaenge[7] = AD_WertBuffer[1]; // Hunderterstelle
Eingaenge[8] = AD_WertBuffer[2]; // Zehnerstelle
Eingaenge[9] = AD_WertBuffer[3]; // Einerstelle
}
Eingaenge[10] = '\0'; // Ausgabestring beenden mit \0
// gesamten Eingangs-String an PC senden
print (Eingaenge);
}
}