HC-SR04 an MK2 anbinden mit Atmel Studio und Labview auswertung

[morob]

http://www.voelkner.de/products/29877/Myavr-Board-Mk2-USB.html?ref=43&products_model=Q07636&gclid=CLr2qs m-jswCFfUV0wodwL8Arw[/URL]
Dieses board müssen wir verwenden.

kannte ich noch nicht

[Jeans]

Dann melde ich mich wohl hier nochmal

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);
}
}