RFM12USB senden oder empfang Problem

[Benjamin W. (baumwolli)]

Hallo Freunde des Mikrocontrollers,

ich habe mir letztens eine Ladung RFM12 Module bei Pollin bestellt und 
mir das RFM12USB Module von Das Labor nachgebaut 
(http://www.das-labor.org/wiki/Rfm12usb).
Zusätzlich hab ich noch eine Schaltung gebaut die zum testen erstmal die 
Daten vom Rechner empfangen soll und sie dann wieder zurück schickt.
Es klappt auch alles.

Nur die Daten die mir das Modul zurück schickt sind nicht ok. Ich 
bekomme immer nur 3 Bytes übermittelt.

Treiber des USB2RFM (Inspiriert bei 
http://www.das-labor.org/trac/browser/microcontroller/src-atmel/rfm12/rfm12usb/trunk/host/console)

int main(int argc, char* argv[])
{
  uint_fast16_t i, j;
  ssize_t l;
  uint8_t buf[512];
  int vid, pid, tmp;
  char *rfmData;
  char uri[512];
  FILE *checkSendFile;
  
  const unsigned char rawVid[2] =  {
    USB_CFG_VENDOR_ID
  },
  rawPid[2] =  {
    USB_CFG_DEVICE_ID
  };

  char vendor[] =
  { 
    USB_CFG_VENDOR_NAME, 0
  },
  product[] =
  {
    USB_CFG_DEVICE_NAME, 0
  };
  
  usb_init();
  g_type_init();
  
  /* usb setup */
  vid = rawVid[1] * 256 + rawVid[0];
  pid = rawPid[1] * 256 + rawPid[0];

  if (usbOpenDevice (&udhandle, vid, vendor, pid, product) != 0) {
    printf ("Can't find USB Device w/ uid %04X, pid %04X\r\n", vid, pid);
    console_exit(__LINE__ * -1);
    return __LINE__ * -1;
  }

  signal (SIGINT, console_exit);
  signal (SIGKILL, console_exit);
  signal (SIGHUP, console_exit);

  tmp=0;
  i=0;

  printf ("Connection established.\r\n");
  
  if (argc > 1) {
    // Senden
    uint8_t temp[32];
    uint8_t address[4];
    uint8_t address_byte = 0;
    
    // Es wird bereits gesendet
    while (checkSendFile = fopen("send", "r")) {
      if (fgetc(checkSendFile) == '0') {
        fclose(checkSendFile);
        break;
      }
      
      fclose(checkSendFile);
    }
    
    checkSendFile = fopen("send", "w");
    fprintf(checkSendFile, "%d", 1);
    fclose(checkSendFile);
    
    rfmData = "";
    
    temp[0] = USB_SENDSTR;
    temp[1] = 0x12; // Adresse
    temp[2] = 0xEE;
    temp[3] = 0xDD;
    temp[4] = 0xCC;
    
    // 10 mal versuchen zu senden
    for (j = 0; j < 10; j++) {
        usb_control_msg(udhandle,
          USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT,
          RFMUSB_RQ_RFM12_PUT, USB_TXPACKET, 0, temp, sizeof temp,
          5000
        );
        
        // Auf Empfangsbestätigung warten
        for (i = 0; i < 255; i++) {
          tmp = usb_control_msg (udhandle,
            USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
            RFMUSB_RQ_RFM12_GET, 0, 0, buf, sizeof (buf),
            5000
          );
          
          // Empfangen
          if (tmp > 0) { /* data received from usb bus */  
            if (buf[2] == 0) {
                        checkSendFile = fopen("send", "w");
                        fprintf(checkSendFile, "%d", 0);
                        fclose(checkSendFile);

              g_printf("Empfangsbestaetigung\r\n");
              return 1;
            }
          }
    
          usleep (1000);
        }
    }
    
    checkSendFile = fopen("send", "w");
    fprintf(checkSendFile, "%d", 0);
    fclose(checkSendFile);
        
    g_printf("Abbruch\r\n");
    return 0;
  } else {
    // Empfang
    char temp[4];
    uint8_t receiveReturn[4];
    receiveReturn[0] = USB_SENDCHAR;
  
    while (1) {
      // Es wird gesendet
      while (checkSendFile = fopen("send", "r")) {
        if (fgetc(checkSendFile) == '0') {
          fclose(checkSendFile);
          break;
        }
        
        fclose(checkSendFile);
      }
      
      tmp = usb_control_msg (udhandle,
        USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
        RFMUSB_RQ_RFM12_GET, 0, 0, buf, sizeof (buf),
        5000
      );

      if (tmp > 0) { /* data received from usb bus */       
        g_printf("#%d: ", buf[1]);
        
        if (buf[2] != 0) {
          // Empfangsbestätigung senden
          receiveReturn[1] = buf[1];
          receiveReturn[2] = 0xAC;
          
          usb_control_msg (udhandle,
            USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT,
            RFMUSB_RQ_RFM12_PUT, USB_TXPACKET, 0, receiveReturn, sizeof receiveReturn,
            5000
          );
          rfmData = "/data/";

          for (i=3; i<tmp; i++) {
            g_printf("%.2x ", buf[i]);
            g_snprintf(temp, sizeof temp, "%.2x", buf[i]);
            rfmData = g_strconcat(rfmData, temp, NULL);
          }
          
          g_printf("\r\n");
          
          // URI erstellen und aufrufen
          g_snprintf(uri, sizeof uri, "%s%d%s", "http://os.gibson.guinness.lan/homecontrol/rfm/input/from/", buf[1], rfmData);      
          request(uri);
        } else {
          g_printf("Empfangsbestaetigung\r\n");
        }
      }

      usleep (10000);
    }
  }
  
  return 1;
}

Auf der anderen Schaltung läuft folgendes

#define WITHOUT_RECEIVE_RETURN 0
#define WITH_RECEIVE_RETURN 1

#define RECEIVED 1

#define TYPE_RECEIVE_RETURN 0x00
#define TYPE_HANDSHAKE 0x01
#define TYPE_DATA 0xFF

uint8_t hc_receive(char with_receive_return)
{
    rfm12_tick();

    // Es wird was empfangen
    if (rfm12_rx_status() > STATUS_FREE) {
        // LED schalten
        PORT_WRK_LED |= (1 << PIN_WRK_LED);
    }

    while (rfm12_rx_status() == STATUS_OCCUPIED) {
        rfm12_tick();
    }

    // Empfang komplett
    if (rfm12_rx_status() == STATUS_COMPLETE) {
        PORT_WRK_LED &= ~(1 << PIN_WRK_LED);

        // Adresse pruefen
        if (rfm12_rx_type() == hc_address) {
            hc_receive_data = rfm12_rx_buffer();
            hc_receive_len = rfm12_rx_len();
            rfm12_rx_clear();

            // Empfang bestaetigen
            if (with_receive_return == WITH_RECEIVE_RETURN) {

                uint8_t receive_return[] = {TYPE_RECEIVE_RETURN};
                hc_send(sizeof receive_return, receive_return, WITHOUT_RECEIVE_RETURN);

                uint8_t receive_return2[hc_receive_len+1];
                receive_return2[0] = TYPE_DATA;

                for (hc_wait = 0; hc_wait < hc_receive_len; hc_wait++) {
                    receive_return2[hc_wait+1] = hc_receive_data[hc_wait];
                }

                //rfm12_tick();
                hc_send(sizeof receive_return2, receive_return2, WITH_RECEIVE_RETURN);
            }

            return RECEIVED;
        }

        rfm12_rx_clear();
    }

    return 0;
}

In dem Szenario kriege ich am Ende aufm Rechner zurück

#12: ee dd

Hoffe einer von euch schlägt sich jetzt vorn Kopf und sieht den Fehler 
sofort. :)

Liebe Grüße Benjamin

[Benjamin W. (baumwolli)]

Hier noch alles in Dateiform. :)

Die Firmware auf dem USB Gerät ist die Standard USB12USB Firmware.
Wenn man Treiber.rar in das Host Verzeichnis von RFM12USB entpackt 
sollte es auch gleich lauffähig sein.

Bell.rar ist die Firmware für das 2te Modul.

[Benjamin W. (baumwolli)]

Fehler gefunden!
Das USB_SENDSTR war falsch. Stattdessen muss natürlich die länge der zu 
übermittelnden Daten übergeben werden.
Und weil der Wert von USB_SENDSTR 2 ist wurden immer nur 2 Byte an Daten 
übertragen.

[Klaus (Gast)]

Schön wenn wir dir helfen konnten :)