Datentypen Int oder String in Bits/Bytes umwandeln

[xVentura]

Hallo,

1. frage: wie sende ich daten über die Rs 232 an einem Mikrocontroller?
- ich denke in einer reihe von bytes oder liege ich falsch?

und somit komme ich zu meiner eigentlichen frage wie speicher ich Daten/befehle in Java in Bytes ab damit ich sie direkt an die Rs 232 schicken kann

ich dachte ich speicher sie zuerst in Int ab und wandle sie dann in Bytes um. ich habe jedes mal ein paket von 2 bytes.

Hat einer eine Idee wie es geht? Bin eigentlich noch ein Anfänger also aufjedenfall nicht erfahren genug. also macht es mir bitte nicht zu kompliziert...

danke

MfG ventura

 

[Ralph-Uwe]

Hi,

am einfachsten ist der Datenverkehr mit einem Mikrocontroller über Strings.

Du musst Dir Befehle ausdenken, die entsprechend von den Gegenseite verstanden werden.

Welchen Mikrocontroller verwendet Du?

 

[xVentura]

danke für die schnelle antwort.

ich benutze http://ces.karlsruhe.de:51080/~BUB/Controller/USB_Boards/mini-usb-board.pdf

ich hab z.B. den befehl: 00000000 00000000
und definiert ist es als Licht bade zimmer an oder sowas

 

[Ralph-Uwe]

danke für die schnelle antwort.

ich benutze http://ces.karlsruhe.de:51080/~BUB/Controller/USB_Boards/mini-usb-board.pdf

ich hab z.B. den befehl: 00000000 00000000
und definiert ist es als Licht bade zimmer an oder sowas

In welcher Sprache programmierst Du den AVR, bzw wie überträgst Du das Programm?
Bei dem Board in dem Link ist kein Max232 verbaut, so dass damit keine serielle Datenübertragung
möglich ist.

Edit: Upps, habe die Seite nicht weit genug runter geblättert, es gibt doch eine bestückte Variante

 

[pro2]

Das heißt, du hast z. B. den Befehl "00000001 00000100" als Ganzes und möchtest diesen jetzt in die einzelnen Bytes aufteilen, oder wie versteh ich das?

 

[Ralph-Uwe]

Vielleicht hilft das weiter:

RXTX einrichten der Seriellenschnittstelle unter Java:

private static void schnittstelleIni(){
    /**
     *  Comport initialisieren 
     */
     try {
     	   comPort = CommPortIdentifier.getPortIdentifier(port);
            serialPort = (SerialPort) comPort.open("Controller", 5000);
            serialPort.setSerialPortParams(38400, SerialPort.DATABITS_8,SerialPort.STOPBITS_1,SerialPort.PARITY_NONE);
            serialPort.notifyOnDataAvailable(true);
            serialPort.addEventListener( new CommListener());
            in = new DataInputStream(serialPort.getInputStream());
            out = new DataOutputStream(serialPort.getOutputStream());
        } catch (UnsupportedCommOperationException e) {
     	   e.printStackTrace();
        } catch (TooManyListenersException e) {
     	   e.printStackTrace();
        } catch (NoSuchPortException e) {
            e.printStackTrace();
        } catch (IOException e) {
     	   e.printStackTrace();
        } catch (PortInUseException e) {
     	   e.printStackTrace();
        }
	}

Empfang und sende Methode:

	 /**
	  * 
	  *EventListener der Com-Schnittstelle, der die empfangenden Daten auf empfang weiter leitet
	  */
	public static class CommListener implements SerialPortEventListener{
		    public void serialEvent(SerialPortEvent event) {
		    switch (event.getEventType()) {
			    case SerialPortEvent.DATA_AVAILABLE: empfang(); 
			    default:
		    	}
		    }
	}
	
	/**
	 *  empfangende Daten auswerten bzw. ausgeben
	 */
	private static void empfang(){
		try {
			byte b = (byte) in.read();
			if (b == ETX){
				if (daten.substring(0,1).equals("0")){
					bvlWert.setText(daten.substring(2, daten.length()));
				}
				if (daten.substring(0,1).equals("1")){
					brlWert.setText(daten.substring(2, daten.length()));
				}
				if (daten.substring(0,1).equals("2")){
					hvlWert.setText(daten.substring(2, daten.length()));
				}
				if (daten.substring(0,1).equals("3")){
					hrlWert.setText(daten.substring(2, daten.length()));
				}
				daten = "";
			}
			else{
				daten += (char)b;
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}	 

	private static void sende(String text){
		try {
			text = text.toUpperCase();
			out.writeBytes(text + "\r");
			Thread.sleep(10);
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

Auf der AVR Seite steht (in C):

ISR(USART_RXC_vect){
	unsigned char nextChar;
	// Daten aus dem Puffer lesen
	nextChar = UDR;
	if( uart_str_complete == 0 ) {	// wenn uart_string gerade in Verwendung, neues Zeichen verwerfen
	// Daten werden erst in uart_string geschrieben, wenn nicht String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
	if( nextChar != '\n' &&
	nextChar != '\r' &&
	uart_str_count < UART_MAXSTRLEN ) {
		uart_string[uart_str_count] = nextChar;
		uart_str_count++;
	}
	else {
		uart_string[uart_str_count] = '\0';
		uart_str_count = 0;
		uart_str_complete = 1;
	}
}

}

und als auswertung der empfangenden Daten:

		if (uart_str_complete){
			char uart_string_copy[UART_MAXSTRLEN + 1] = "";
			strcpy(uart_string_copy,uart_string);
			if (strcmp(uart_string_copy,"3") == 0){
				strcpy(test,uart_string_copy);
				strcat(test," ");
				int_to_str(fuehler_nr[3].temp_wert,text,10,1);
				strcat(test,text);
				uart_send_string(strcat(test,"~"));
			}
			else if (strcmp(uart_string_copy,"2") == 0){
				strcpy(test,uart_string_copy);
				strcat(test," ");
				int_to_str(fuehler_nr[2].temp_wert,text,10,1);
				strcat(test,text);
				uart_send_string(strcat(test,"~"));
			}
			else if (strcmp(uart_string_copy,"1") == 0){
				strcpy(test,uart_string_copy);
				strcat(test," ");
				int_to_str(fuehler_nr[1].temp_wert,text,10,1);
				strcat(test,text);
				uart_send_string(strcat(test,"~"));
			}
			else if (strcmp(uart_string_copy,"0") == 0){
				strcpy(test,uart_string_copy);
				strcat(test," ");
				int_to_str(fuehler_nr[0].temp_wert,text,10,1);
				strcat(test,text);
				uart_send_string(strcat(test,"~"));
			}
			else{
				strcpy(stringWert,"NV ~");
				uart_send_string(stringWert);
			}
			uart_str_complete = 0;
			_delay_ms(10);
		}

Die funktionsweise ist folgendermaßen:
Das Javaprogramm sendet an den AVR eine Zahl zwischen 0 und 3 (dies entspricht Temperatursensoren) und ein entsprechenden "ende"-Zeichen (\r).
Der AVR liest solange empfangende Daten ein, bis das Steuerzeichen (\r) folgt oder die max. länge
des Empfangspuffers erreicht wurde.
uart_str_complete zeigt an, dass ein vollständiger Befehl empfangen wurde.

Der AVR antwortet mit der Sensornummer und der entsprechenden Temperatur.

 

[xVentura]

ich hab aber immer noch nicht verstanden wie ich zb. den code 00010001 00010001 in einem Short umwandle

 

[Ralph-Uwe]

Hallo,

so wäre es möglich, allerdings muß der Binätwert als String vorliegen.

public class VString {
   public static void main (String [] args)   {
 
	  short wert = (short) Integer.parseInt("0001000100010001", 2);
	  System.out.println("Wert :" + wert);
   }
}

 

[pro2]

Den merkwürdigen Cast kann man sich auch sparen^^

public class VString {
   public static void main (String [] args)   {
 
      short wert = Short.parseShort("0001000100010001", 2);
      System.out.println("Wert :" + wert);
   }
}

 

[xVentura]

Danke!!!!

public class VString {
   public static void main (String [] args)   {
 
      short wert = (short) Integer.parseInt("0001000100010001", 2);
      System.out.println("Wert :" + wert);
   }
}

Was bedeutet "short wert = (short) Integer.parseInt("0001000100010001",2);" ?? Also was macht diese ,2?

 

[pro2]

Die gibt an, dass die Zahl, die du der Funktion mitgibst, sich im Binärsystem befindet. So was kann man aber auch in der API nachsehen! Short (Java Platform SE 7 ), int)

Du kannst auch eine Zahl jedes anderen Zahlensystems mitgeben:

Short.parseShort("10A", 16);