USB String senden/empfangen

[Patrick (Gast)]

Hi,
ich arbeite momentan an einem kleinen Projekt und stehe momentan vor
folgendem Problem:

Zuerst:
Ich verwende den Controller AT32UC3C1512C. Software am PC wäre
hierfür AtmelStudio 6.1, sowie Visual Studio 2013.

Mein Ziel:
Ich will per USB daten zwischen uC und der PC-Software schicken.
Dem uC will ich einen String zuschicken(aus Visual Studio). In diesem 
String befindet sich ein "status" und die anschließend zu verarbeiteten 
"daten".

Hier kurz ein Einblick in die main-Funktion des uC:
wobei LPT_D/LTD_C/LPT_S per #define festgelegt wurden.

//status = recvDATA[0]
//data = recvDATA[1]
switch(recvDATA[0]){

case LPT_D: 

   if(recvDATA[1] & 0x80){
        gpio_set_pin_high(D7);  
   }
   else{
        gpio_set_pin_low(D7);
   }            
   if(recvDATA[1] & 0x40){
        gpio_set_pin_high(D6);
   }
   else{
        gpio_set_pin_low(D6);
   }            
      
    //usw.
   break;
case LPT_C:  
 
  if(recvDATA[1] & 0x08){
          gpio_set_pin_high(C3);
  }
  else{ gpio_set_pin_low(C3); }
  //usw
  break;

case LPT_S:
  sendDATA = gpio_get_pin_value(S3)*128;
  sendDATA += gpio_get_pin_value(S3)*64;
  //usw
  sendUSBdata(sendDATA);
  break;
}

wie man sieht, ist es für mich wichtig, das man die erhaltenen Daten im 
uC einzeln zuweisen kann (recvDATA[0], recvDATA[1]).

Problem:
Ich habe leider keine Ahnung, wie ich gesendete Strings auslesen kann 
und scheinbar auch keine, um welche zu senden. Der uC wird als COM4-Port 
erkannt und ansich werden daten gesendet, nur sind diese komplett 
daneben. Wenn ich zum Test eine "10" vom uC zum PC schicken will, kommt 
am PC random Zahlen raus, die weit von der eigentlichen Zahl abweichen.

Funktion zum senden: uC -> PC

void sendUSBdata(Byte *dat){
    //Wenn sendebereit
    if(udi_cdc_is_tx_ready()){
    //sende dat
    udi_cdc_putc(*dat);

Da sendDATA eigentlich nur eine int Zahl ist, habe ich das ganze auch 
mit int anstatt Byte versucht, was denoch nicht richtig war.
Habe auch zum Test mal folgendes probiert gehabt:

void sendUSBdata(Byte *dat){
    //Wenn sendebereit
    if(udi_cdc_is_tx_ready()){
    sprintf(str, "|%d|", dat);
    //sende dat
    udi_cdc_putc(str);

und in VisualStudio dann nach den Strichen gesucht und ausgegeben - 
funktionierte auch nicht wie gedacht.

Funktion zum empfangen: PC -> uC

int recvUSBdata(){
 char *token;
 char str[100];
 int i;

//checks if a character has been received on the CDC line. 
if(udi_cdc_is_rx_ready()){
   str = udi_cdc_getc();
   token = strtok (str, "|");  //unterteile string in einzelne tokens zwischen | |
  
   while (token != NULL, i++){
       recv_DATA[i] = token;    // i=0 ->status; i=1 ->data;
       token = strtok (NULL, "|");
   }
 return recv_DATA;
}

Das war so meien Grundidee, das ich den ankommenden String in Tokens 
aufteile und so die einzelnen Werte bekomme. In VisualStudio habe ich 
dementsprechend auch sprintf(str,"|%d|%d|", status,data) gesendet.
Problem dabei war es, dass udi_cdc_getc(); scheinbar nur int ausgibt.
Gibt es hierfür eine Funktion, die die gesendeten Daten als String 
ausgibt?

Ich hoffe ich könnt mein Problem einigermaßen verstehen und mir evtl. 
Tipps geben. Ich steck auch gerade gedanklich in diesem Schema fest und 
bekomme es gerade nicht hin umzudenken. Vielleicht geht es ja auch viel 
einfacher.

[Εrnst B. (ernst)]

Teile und Hersche.

Geht deine Serieller-Port-Emulation-über USB? Ja? Kann dein UC Text 
schicken ("Hello World!\n"), und der PC (Hyperterminal, Putty, etc am 
COM4) empfangen?

Ja? => Vergiss für deine Fehlersuche alles was mit USB zu tun hat. Du 
hast eine Serielle Leitung.

Nein? => Vergiss für deine Fehlersuche alles was mit deinen Daten, 
sprintfs, strtoks usw zu tun hat. Erst mal die Kommunikation generell 
hinkriegen.

[Patrick (Gast)]

Hallo Ernst, danke für deine Antwort.
Es hat sich herausgestellt, das es an der Übertragung selbst liegt. Ich 
kann zb ein ("Hello World!\n") überhaupt nicht senden, allerdings kann 
ich einzelne Charakter senden:

if (udi_cdc_is_tx_ready) udi_cdc_putc('H');

An der Empfangsseite bekomme ich dann 20mal ein H ausgegeben, da ich 
scheinbar jedesmal 20 Bytes empfange.

Ich kenn mich mit der uC-Programmierung leider nicht aus und so simpel 
wie ich dachte, scheint es nicht zu funktionieren.

Meine Main-Funktion zum test senden:

int main(void)
{
  irq_initialize_vectors();
  cpu_irq_enable();

  // Initialize the sleep manager
  sleepmgr_init();

  sysclk_init();
  board_init();
  ui_init();
  ui_powerdown();

  // Start USB stack to authorize VBus monitoring
  udc_start();
  
  
  // The main loop manages only the power mode
  // because the USB management is done by interrupt
  while (true) {
    
    sleepmgr_enter_sleep();
                
                //einzelnen charakter senden - funktionierte
                if (udi_cdc_is_tx_ready) udi_cdc_putc('A');
                
                //Versuch Hello World!\n zu senden
                //kommt nur ein komisches Zeichen an, auch wieder 20mal
                char sendTest[]= "Hello World!\n"
                udi_cdc_putc(sendTest);
        }
}

Ich glaube das die Funktion  udi_cdc_putc(), die falsche ist ^^. Sie 
gibt scheinbar nur einzelne values aus. Werde irgendwie mit dem Buffer 
arbeiten müssen um ganze strings zu senden.
Ich werde mich da mal genauer einlesen, wie das richtig funktioniert. 
Über Tipps bin ich jederzeit dankbar.

[Quack (Gast)]

Ich wuerde sagen, dir fehlen Sprachgrundlagen und Warning liest du auch 
nicht. Dass putc() fuer Strings nicht richtig ist, duerfte dir schon der 
Compiler sagen.