PIC -> WLAN Modul über UART. Verständnis des Programmcodes

[Gisti (Gast)]

Wie schon einmal erwähnt versuche ich über die UART-Schnittstelle (über 
ein PIC24E) ein WIFI Modul (RN 131) zu konfigurieren. Microship stellt 
ein Beispielprogramm bereit, das ich soweit auf meine gegebene Hardware 
umgeschrieben habe (Konfiguration der I/Os und Initialisierung der 
UART-Schnittstelle).

Der PIC sendet (oder soll) die folgenden Kommandos an das Modul 
schicken, um es mit einem AP zu verknüpfen.

- $$$: -> Put the module into command mode.
- set wlan ssid <string> : -> Set the network’s SSID where <string> is 
the SSID.
- set wlan pass <string> : -> Set the passphrase to use when joining 
where <string> is the passphrase


...

Dies ist in dem Beispielprogramm mit der Funktion

err_t module_send_cmd(const char *response, const char *fmt, ...)

realisiert. Der Parameter response entspricht der zu erwartenden Antwort 
des RN-Moduls, während fmt dem Befehl entspricht. Ein Aufruf der 
Funktion könnte dann zum BEispiel so aussehen:

module_send_cmd("CMD", "$$$")

oder

module_send_cmd(CMD_AOK, "set w s %s", NETWORK_SSID)

module_send_cmd(NULL, "save")

module_send_cmd(CMD_AOK, "set w p %s", NETWORK_PASS)

Der gesamte Funktion befindet sich am Ende meines Beitrags.
Mir ist natürlich klar dass mir Niemand die komplette Funktion erklären 
kann, aber das grundsätzliche Verständis wäre mir wichtig.

Der erste Teil der Funktion scheint mir noch verständlich:

for(p = fmt; *p != '\0'; p++)
  {
    if(*p != '%')
    {
      //putU1(*p);
                    ConsolePut(*p);                       
                    continue;
    }
}

Solange Buchstabe im Befehl vorhanden ist, wird er über die Fkt. 
ConsolePut an U2TXREG ausgegeben. In der

switch(*++p) case

Anweisung wird dann der darauffolgende Buchstabe analysiert. 
Beispielsweise im case 'c' wird der nächste Wert in der Argumentliste an 
die Variable i übergeben und wiederum über Console(i) ausgegeben. Mir 
ist also 1. unverständlich, warum in der Case Anweisung gerade diese 
Buchstaben abgefragt werden und warum 2.die FUnktion itoa (integer into 
string) in anderen Fällen angewandt wird?
Im 2. Teil der Funktion wird die Antwort des RN-Moduls (also response) 
ausgewertet. Wenn mir jemand 3. die If-Abfrage

if(response != (const char *)NULL)

 erläutern könnte, wäre mir schon sehr geholfen. Ich vermute die 
Schleife wird solange durchlaufen wie der Pointer der auf den Parameter 
response zeigt nicht der "NULL-Response" entspricht?

Ich hoffe der Beitrag ist nicht zu unübersichtlich geworden. Vielen Dank 
im Voraus.

typedef int err_t
err_t RN_ERR_OK = 0
/**************************************************************************************************/
err_t module_send_cmd(const char *response, const char *fmt, ...)
{
  err_t retval = RN_ERR_OK;
  const char *p;
  va_list argp;
  int i;
  char *s;
  static char fmtbuf[256];
  static char rxbuff[256];
  int rxbuff_size = 0;


  if(response != (const char *)NULL)
  {
            memset(rxbuff, '\0', sizeof(rxbuff));
            serial_util_set_rn_rx_buffer(rxbuff, sizeof(rxbuff), &rxbuff_size);
  }


  va_start(argp, fmt);
  for(p = fmt; *p != '\0'; p++)
  {
    if(*p != '%')
    {
      //putU1(*p);
                    ConsolePut(*p);                       
                    continue;
    }

    switch(*++p)
    {
    case 'c':
      i = va_arg(argp, int);
                        ConsolePut(i);
      break;

    case 'd':
      i = va_arg(argp, int);
      s = itoa(fmtbuf, i, 10);
                        ConsolePutString(s);
      break;

    case 's':
      s = va_arg(argp, char *);
                        ConsolePutString(s);
      break;

    case 'x':
    case 'X':
      i = va_arg(argp, int);
      s = itoa(fmtbuf, i, 16);
                        ConsolePutString(s);
      break;

    case '%':
                        ConsolePut('%');
      break;
    }
                __delay_ms(1);
  }

        if(appendCRLF)
        {
            ConsolePut('\r');
            ConsolePut('\n');
        }

        /* This is where module will fill rn_rx_buffer with response via the ISR */
        __delay_ms(50);
        __delay_ms(50);

       LED_1 = 1;

  if(response != (const char *)NULL)
  {
                int r;
    retval = RN_ERR_READ;
                
    for(r = 0; r < MODULE_RX_CMD_RESPONSE_TIMEOUT; ++r)
    {
      if(rxbuff_size != 0 && strstr(rxbuff, response))
      {
                                LED_2 = 1;
        retval = RN_ERR_OK;
        break;
      }

      __delay_ms(10);
    }

    serial_util_remove_rn_rx_buffer();
  }


  return retval;
}
void ConsolePut(char c)
{

        U2TXREG = c;
}
void ConsolePutString(char* str)
{
    char c;

    while( c = *str++ )
        ConsolePut(c);
}
void serial_util_set_rn_rx_buffer(volatile char *buffer, size_t len, volatile int *size)
{
  rn_rx_buffer_idx    = size;
  rn_rx_buffer_len    = len;
  rn_rx_buffer        = buffer;
}