Subversion Repositories Projects

/*-

 * Copyright (c) 2012,2013 Darran Hunt (darran [at] hunt dot net dot nz)

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,

 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY

 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL

 * THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/**

 * @file WiFly RN-XV Library

 */

//############################################################################

//# HISTORY  PKT_WiFlyHQ.c

//#

//# 03.06.2014 OG

//# - fix: find_WiFly() - Benutzer kann Suche nach WiFly jetzt abbrechen

//#        (z.b. weil er kein WiFly angesteckt hat)

//#        von dieser Aenderungen betroffen sind auch noch einige Codechanges

//#        an anderen Funktionen.

//#

//# 15.04.2014 OG

//# - chg: wifly_init() - Logik bei der Versionsverifikation von WIFLY_ADHOC

//#        geaendert da v2.38 ansonsten ggf. den Bach runter gegangen waere.

//#        AKTUELL UNGETESTET DA KEIN WIFLY ADHOC VORHANDEN!

//# - add: Wifly_update() ein paar Kommentare im Code

//# - add: KOMMENTAR zu define DEBUG_WIFLY ! (lesenswert!)

//#

//# 14.04.2014 Cebra

//# - add: Defines für getestete WiFly Softwareversionen

//# - add: wifly_init bei der Versionsabfrage erweitert

//#

//# 13.04.2014 OG

//# - ggf. Probleme beim Downgrade des WiFly auf v2.38 -> deaktiviert

//# - FAST KOMPLETT NEUER CODE

//#

//# 03.04.2014 OG

//# - add: define DELAY_BEFORE_SAVE

//# - add: define DELAY_BEFORE_REBOOT

//#

//# 02.04.2014 OG

//# WIP: etliche weitere Aenderungen....

//# - chg: getVersion(): Rueckgabe/Logik geaendert

//# - add: define DELAY_AFTER_MODUL_ON

//#

//# 01.04.2014 SH

//# - chg: Nicht benötigte Progmem Strings auskommentiert

//#

//# 11.03.2014 SH

//# - add: neue Funktionen wl_reset() und wl_update()

//# - chg: wl_init() wurde komplett auf den neuen AP Modus geändert, die Init Routine vom Ad Hoc Modus befindet sich ausgeklammert darunter

//# - chg: getVersion wurde angepasst + neuer Wert für resp_Version[] PROGMEM = "RN-171\r\n" anstatt WiFly

//# - chg: setSSID() und setPassphrase() wurden um weiteren Parameter ergänzt

//# - chg: createAdhocNetwork angepasst da Funktion setSSID() enthalten

//# - del: ausgeklammerte Funktionen getConnection, getDHCPMode, getSpaceReplace, getopt_Asc und join

//#

//# 12.02.2014 OG

//# - chg: readTimeout() Auskommentiert: "unused variable 'ind'"

//# - chg: wl_init() Auskommentiert: "unused variable 'dhcpMode'"

//#

//# 02.07.2013 cebra

//# - new: Routinen für WiFly WLAN-Modul

//#

//###########################################################################

#include <avr/pgmspace.h>

#include <stdbool.h>

#include <stdlib.h>

#include <stdarg.h>

#include <util/delay.h>

#include <inttypes.h>

#include <string.h>

#include "../main.h"

#include "PKT_WiFlyHQ.h"

#include "../eeprom/eeprom.h"

#include "../uart/uart1.h"

#include "../timer/timer.h"

#include "../lcd/lcd.h"

#include "../messages.h"

#include "../pkt/pkt.h"

#include "../utils/xutils.h"

#include "wifly_setup.h"

#ifdef USE_WLAN

//----------------------------------------------------

// DEBUG

//

// Wenn 'DEBUG_WIFLY' eingeschalte wird dann werden die Ausgaben

// des WiFly auf dem PKT-Screen angezeigt - fast wie bei einem

// Terminal Programm!

//

// Man kann dadurch genaueres erkennen wie die Kommunikation

// ablaeuft und mit welchen Strings beispielsweise das WiFly

// ein Ok quittiert.

//----------------------------------------------------

//#define DEBUG_WIFLY

//----------------------------------------------------

// unterstützte WiFly Softwareversionen

//----------------------------------------------------

#define  Adhoc_Version1   232           // getestet Version 2.32

#define  Adhoc_Version2   238           // getestet Version 2.38

#define  Apmode_Version1  441           // getestet Version 4.41

//----------------------------------------------------

// Einstellungen

//----------------------------------------------------

static const char WIFLY_IP_ADDRESS[]        PROGMEM = "169.254.1.1";

static const char WIFLY_IP_PORT[]           PROGMEM = "2000";

static const char WIFLY_IP_GATEWAY[]        PROGMEM = "169.254.1.1";

static const char WIFLY_IP_NETMASK[]        PROGMEM = "255.255.0.0";

static const char WIFLY_VERSION_ADHOC[]     PROGMEM = "2.38.3";

//static const char WIFLY_VERSION_ADHOC[]     PROGMEM = "v2.32";

static const char WIFLY_VERSION_APMODE[]    PROGMEM = "4.41";

//----------------------------------------------------

// Einsstellungen fuer Delay's

//----------------------------------------------------

//#define WIFLY_DEFAULT_TIMEOUT       500 /* 500 milliseconds */

#define WIFLY_DEFAULT_TIMEOUT       100 // n milliseconds

//----------------------------------------------------

//----------------------------------------------------

uint8_t     progress_max = 0;

uint8_t     progress_act = 0;

char        progress_buffer[22];

char        buffer[20];

char        wifly_version_string[12];

uint16_t    wifly_version;

//----------------------------------------------------

// Texte

//----------------------------------------------------

static const char STR_WIFLY_NOT_FOUND[]     PROGMEM = "WiFly not found";

static const char RECEIVE_AOK[]             PROGMEM = "AOK";

#define REPLACE_SPACE_CHAR  '$'     // ersetzt Spaces in einem String-Parameter des WiFly - '$' ist WiFly default (0x24) fuer SSID und Pwd

//static const char []      PROGMEM = "";

//----------------------------------------------------

//#############################################################################

//#

//#############################################################################

//----------------------------------------------------

//----------------------------------------------------

void debug_begin( void )

{

    lcd_cls();

    lcd_setpos(0,0);

}

//----------------------------------------------------

//----------------------------------------------------

void debug_wait( void )

{

    set_beep( 25, 0xffff, BeepNormal );

    clear_key_all();

    while( !get_key_press(1 << KEY_ESC) && !get_key_press(1 << KEY_ENTER) );

    lcd_print_LF();

}

//----------------------------------------------------

//----------------------------------------------------

void debug_message( uint8_t *text )

{

    lcd_print_LF();

    lcd_print( text, MINVERS );

    debug_wait();

    lcd_print_LF();

}

//#############################################################################

//#

//#############################################################################

/** Read the next character from the WiFly serial interface.

 * Waits up to timeout milliseconds to receive the character.

 * @param chp pointer to store the read character in

 * @param timeout the number of milliseconds to wait for a character

 * @retval true - character read

 * @retval false - timeout reached, character not read

 */

bool readTimeout( char *chp, uint16_t timeout)

{

    char ch;

    timer2 = timeout;

    while( timer2>0 )

    {

        if( uart1_available() > 0 )

        {

            ch = uart1_getc();

            *chp = ch;

            #ifdef DEBUG_WIFLY

            lcd_print_char( ch, MNORMAL);

            #endif

            return (true);

        }

    }

    return (false);

}

//--------------------------------------------------------------

//--------------------------------------------------------------

void flushRx( int timeout )

{

    char ch;

    while( readTimeout( &ch, timeout) );

}

/**

 * Read characters from the WiFly and match them against the

 * progmem string. Ignore any leading characters that don't match. Keep

 * reading, discarding the input, until the string is matched

 * or until no characters are received for the timeout duration.

 * @param str The string to match, in progmem.

 * @param timeout fail if no data received for this period (in milliseconds).

 * @retval true - a match was found

 * @retval false - no match found, timeout reached

 */

bool match_P( const char *str, uint16_t timeout)

{

    const char *match = str;

    char ch, ch_P;

    ch_P = pgm_read_byte(match);

    if( ch_P == '\0' ) return true; /* Null string always matches */

    while( readTimeout( &ch, timeout) )

    {

        // DEBUG

        //lcd_print_char( ch, MNORMAL );

        if( ch == ch_P ) match++;

        else

        {

            match = str; // Restart match

            if( ch == pgm_read_byte(match) ) match++;

        }

        ch_P = pgm_read_byte( match );

        if( ch_P == '\0' ) return (true);

    }

    return (false);

}

//#############################################################################

//# progress

//#############################################################################

//--------------------------------------------------------------

// msg: PROGMEM

//--------------------------------------------------------------

void progress_begin( uint8_t maxsteps )

{

    progress_max = maxsteps;

    progress_act = 0;

}

//--------------------------------------------------------------

// wait4key: true / false

//--------------------------------------------------------------

void progress_end( uint8_t wait4key )

{

    progress_max = 0;

    progress_act = 0;

    if( wait4key )

    {

        lcd_printp_at( 12, 7, strGet(ENDE), MNORMAL);                   // Keyline

        set_beep( 25, 0xffff, BeepNormal );                             // kurzer Bestaetigungs-Beep

        clear_key_all();

        while( !get_key_press(1 << KEY_ESC) );                          // warte auf Taste...

    }

}

//--------------------------------------------------------------

// msg: PROGMEM

//--------------------------------------------------------------

void progress_show( const char *msg )

{

    int8_t  yoffs = 3;

    #ifdef DEBUG_WIFLY

    return;

    #endif

    if( progress_max )

    {

        progress_act++;

        lcdx_printf_center_P( 4, MNORMAL, 0,yoffs, PSTR("%d/%d"), progress_act, progress_max );

        if( msg )

        {

            strncpyat_P( progress_buffer, msg, 20, ' ', 2);

            lcd_frect( 2, (5*8)+yoffs, 124, 7, 0);                                          // Zeile 5 loeschen

            lcdx_print_center( 5, (uint8_t *)progress_buffer, MNORMAL, 0,yoffs);            // Text zentriert; String im RAM

        }

        lcd_rect_round( 0, 28+yoffs, 127, 22, 1, R2);                                       // Rahmen

        _delay_ms(700);                                                                     // fuer Anzeige (Entschleunigung)

    }

}

//--------------------------------------------------------------

// gibt zentriert einen Text und loescht vorher die Zeile

//--------------------------------------------------------------

void MsgCenter_P( uint8_t y, const char *text, uint8_t mode, int8_t yoffs )

{

    lcdx_cls_row( y, MNORMAL, yoffs );

    lcdx_printp_center( y, text, MNORMAL, 0, yoffs );

}

//#############################################################################

//# sendcmd

//#############################################################################

//--------------------------------------------------------------

//--------------------------------------------------------------

void cmd_showerror( const char *cmdstr)

{

    //void PKT_Message_P( const char *text, uint8_t error, uint16_t timeout, uint8_t beep, uint8_t clearscreen )

    PKT_Message_P( cmdstr, true, 3000, true, true );        // max. 30 Sekunden anzeigen

}

//--------------------------------------------------------------

//--------------------------------------------------------------

uint8_t find_Prompt()

{

    char c;

    uint8_t state = 0;

    while( readTimeout( &c, WIFLY_DEFAULT_TIMEOUT) )

    {

        if( state == 0 && (c == '>') )  { state = 1; continue; }

        if( state == 1 && (c == ' ') )  return true;

        if( state == 1 ) break;     // Fehler: nicht vorgesehen

    }

    return false;

}

//--------------------------------------------------------------

// nicht verwendet...

//--------------------------------------------------------------

uint8_t find_Prompt2()

{

    char c;

    timer2 = 800;  // 8 Sekunden max. suchen

    while( readTimeout( &c, WIFLY_DEFAULT_TIMEOUT) && timer2 )

    {

        if( c == '>' )  return true;

    }

    return false;

}

//--------------------------------------------------------------

// Das ist erstmal so uebernommen - ob das alles sein muss??

//

// Put the WiFly into command mode

//

// RUECKGABE:

//  >0: ok

//  =0: Fehler

//  -1: Abbruch Benutzer

//--------------------------------------------------------------

int8_t cmd_EnterCommandMode( void )

{

    uint8_t retry  = 2;

    int8_t  result = 0;     // false

    while( retry && !result )

    {

        //_delay_ms(250);

        uart1_puts_p( PSTR("$$$") );

        //_delay_ms(250);

        _delay_ms(100);

        uart1_putc('\r');

        if( get_key_short(1 << KEY_ESC) )       // Abbruch durch Benutzer?

        {

            return -1;                          //   -1 = Abbruch Benutzer

        }

        result = find_Prompt();                 // ggf. result = true

        if( !result )

        {

            retry--;

            _delay_ms(250);

        }

    }

    return result;

}

//--------------------------------------------------------------

// PARAMETER:

//   cmdstr       : PROGMEM

//   strvalue     : RAM

//   match_receive: PROGMEM

//   findprompt   : true/false

//--------------------------------------------------------------

uint8_t cmdsend( const char *cmdstr, const char *strvalue, const char *match_receive, uint8_t findprompt )

{

    uint8_t result = true;

    const char *p;

    char c;

    progress_show( cmdstr );

    //--------------------

    // Senden...

    //--------------------

    uart1_puts_p( cmdstr );

    if( strvalue != NULL )

    {

        uart1_putc(' ');

        p = strvalue;

        while( *p )

        {

            c = *p;

            if( c == ' ' ) c = REPLACE_SPACE_CHAR;

            uart1_putc( c );

            p++;

        }

    }

    uart1_putc('\r');

    //--------------------

    // Antwort...

    //--------------------

    if( match_receive )

    {

        //if( !match_P( p, WIFLY_DEFAULT_TIMEOUT) )

        if( !match_P( match_receive, 2000) )

        {

            cmd_showerror( cmdstr );                // Fehler auf PKT Screen anzeigen und durch Benutzer bestaetigen lassen

            result = false;

        }

        // DEBUG

        //lcdx_printf_at_P( 2, 7, MINVERS,  0,0, PSTR("%d"), result );

    }

    #ifdef DEBUG_WIFLY

    debug_wait();

    #endif

    // TODO: Kommandos die keinen Prompt zurueckliefern? (evtl. 'reset'?)

    //uart1_putc('\r'); // fuer cmd_Join ein extra Return... (bei den anderen Kommandos stoert es nicht)

    if( result && findprompt)

    {

        result = find_Prompt();

    }

    return( result );

}

//--------------------------------------------------------------

// cmdsend_P()

//

// PARAMETER:

//--------------------------------------------------------------

uint8_t cmdsend_P( const char *cmdstr, const char *strvalue, const char *match_receive, uint8_t findprompt )

{

    strncpy_P( buffer, strvalue, 20);

    return cmdsend( cmdstr, buffer, match_receive, findprompt );

}

//--------------------------------------------------------------

// Version wird anhand des Prompt's ermittelt

// Implementiert als State-Machine

//--------------------------------------------------------------

uint8_t cmd_GetVersion( void )

{

    char    c;

    uint8_t state = 0;

    char    *dst = wifly_version_string;

    uint8_t n = 0;

    wifly_version = 0;

    uart1_putc('\r');                                       // erzwinge Prompt

    while( readTimeout( &c, WIFLY_DEFAULT_TIMEOUT) )

    {

        if( (state == 0) && (c == '<') )

        {

            state = 1;

            continue;

        }

        if( (state == 1) && (c != '>') )

        {

            // TODO: Ende vom Prompt im Fehlerfall catchen...

            if( n+1 >= sizeof(wifly_version_string) )

                break;

            *dst = c;

            dst++;

            n++;

            continue;

        }

        if( (state == 1) && (c == '>') )                    //  Versionsstring-Ende erreicht

        {

            *dst = 0;

            state = 2;

            break;

        }

    }

    if( state == 2 )

    {

        //uint16_t  wifly_version;

        wifly_version  = (wifly_version_string[0]-'0') * 100;

        wifly_version += (wifly_version_string[2]-'0') * 10;

        wifly_version += (wifly_version_string[3]-'0') * 1;

    }

    else

    {

        cmd_showerror( PSTR("get version") );               // Fehler auf PKT Screen anzeigen und durch Benutzer bestaetigen lassen

    }

    return (state == 2);

}

//--------------------------------------------------------------

// cmd_Set()

//

// PARAMETER:

//   cmdstr: PROGMEM

//--------------------------------------------------------------

uint8_t cmd_Set( const char *cmdstr )

{

    return cmdsend( cmdstr, 0, RECEIVE_AOK, true );

}

//--------------------------------------------------------------

// cmd_SetStr()

//

// PARAMETER:

//   cmdstr: PROGMEM

//   str   : RAM

//--------------------------------------------------------------

uint8_t cmd_SetStr( const char *cmdstr, const char *str )

{

    return cmdsend( cmdstr, str, RECEIVE_AOK, true );

}

//--------------------------------------------------------------

// cmd_SetStr()

//

// PARAMETER:

//   cmdstr: PROGMEM

//   str   : PROGMEM

//--------------------------------------------------------------

uint8_t cmd_SetStr_P( const char *cmdstr, const char *str )

{

    return cmdsend_P( cmdstr, str, RECEIVE_AOK, true );

}

//--------------------------------------------------------------

// cmd_SetNum()

//

// PARAMETER:

//   cmdstr: PROGMEM

//   value : Dezimal

//--------------------------------------------------------------

uint8_t cmd_SetNum( const char *cmdstr, const uint16_t value )

{

    utoa( value, buffer, 10 );

    return cmd_SetStr( cmdstr, buffer);

}

//--------------------------------------------------------------

// cmd_Reset()

//--------------------------------------------------------------

uint8_t cmd_Reset( void )

{

    uint8_t result = true;

    //_delay_ms( 500 );

    result = cmdsend( PSTR("factory RESET"), 0, PSTR("Defaults"), false );

    _delay_ms( 1000 );

    return result;

//  return cmdsend( PSTR("factory RESET"), 0, PSTR("Defaults"), true );

}

//--------------------------------------------------------------

// cmd_Save()

//--------------------------------------------------------------

uint8_t cmd_Save( void )

{

    //_delay_ms( DELAY_BEFORE_SAVE );

    _delay_ms( 200 );

    return cmdsend( PSTR("save"), 0, PSTR("Storing"), true );

}

//--------------------------------------------------------------

// cmd_Join()

//--------------------------------------------------------------

uint8_t cmd_Join( const char *ssid )

{

    uint8_t result = true;

    result = cmdsend( PSTR("join"), ssid, PSTR("Associated"), false );

    if( result )    uart1_putc('\r');;

    if( result )    result = find_Prompt();

    return result;

}

//--------------------------------------------------------------

// cmd_Reboot()

//--------------------------------------------------------------

uint8_t cmd_Reboot( void )

{

    //_delay_ms( DELAY_BEFORE_REBOOT );

    _delay_ms( 300 );

    cmdsend( PSTR("reboot"), 0, 0, false );

    _delay_ms( 2000 );

    return true;

}

//#############################################################################

//# WiFly suchen

//#############################################################################

//--------------------------------------------------------------

//--------------------------------------------------------------

void find_WiFly_searchmsg( const char *text, uint8_t baud )

{

    lcd_frect( 0, 2*8, 126, 7, 0);                                                              // Zeile 2 loeschen

    lcdx_printf_center_P( 2, MNORMAL, 0,0, PSTR("%S %lu Baud"), text, Baud_to_uint32(baud) );   // Text zentriert

}

//--------------------------------------------------------------

// RUECKGABE:

//  >0: ok

//  =0: Fehler

//  -1: Abbruch Benutzer

//--------------------------------------------------------------

int8_t find_WiFly_baud( uint8_t baud )

{

    int8_t result = 1;

    find_WiFly_searchmsg( strGet(STR_SEARCH), baud );

    // Anmerkung 06.04.2014 OG:

    // SetBaudUart1() (in uart/uart1.c) setzt nur die Baudrate des Uart.

    // Config.PKT_Baudrate wird durch SetBaudUart1() NICHT geaendert!

    SetBaudUart1( baud );

    result = cmd_EnterCommandMode();

    if( result > 0 )

    {

        return baud;                        // Baud gefunden, ok!

    }

    return result;                          // nicht gefunden oder Abbruch durch Benutzer

}

//--------------------------------------------------------------

// ok = find_WiFly()

//

// Sucht das WiFly mit verschiedenen Baudraten.

//

// Wenn das WiFly mit von Config.PKT_Baudrate (= 57600) abweichender

// Baudrate gefunden wird (z.B. 9600 Baud) dann wird das WiFly

// automatisch auf 57600 Baud umkonfiguriert damit nachfolgende

// Funktionen das nicht mehr beachten muessen.

//

// RUECKGABE:

//  ok = true : WiFly gefunden und ist auf 57600 Baud

//  ok = false: kein WiFly gefunden

//

//  >0: ok

//  =0: Fehler

//  -1: Abbruch Benutzer

//

// Anmerkung:

//  #define Baud_9600       1

//  #define Baud_19200      2

//  #define Baud_38400      3

//  #define Baud_57600      4

//  #define Baud_115200     5

//  #define Baud_4800       6

//  #define Baud_2400       7

//--------------------------------------------------------------

int8_t find_WiFly( void )  // search Wifly with all Baudrates

{

    int8_t result = 1;                                                          // 1 == true

    int8_t baud   = 0;

    //inCommandMode = false;

    //exitCommand   = 0;

    set_Modul_On( Wlan );                                                       // WiFly einschalten

    timer2 = 60;                                                                // Delay damit das WiFly booten kann

    while( timer2 );

    lcd_printp_at(12, 7, strGet(ENDE), MNORMAL);                                // Keyline: "Ende"

    //------------------------

    // suche WiFly mit versch. Baudraten

    //------------------------

    if( baud==0 ) baud = find_WiFly_baud( Baud_57600  );

    if( baud==0 ) baud = find_WiFly_baud( Baud_9600   );

    if( baud==0 ) baud = find_WiFly_baud( Baud_115200 );

    if( baud==0 ) baud = find_WiFly_baud( Baud_38400  );

    if( baud==0 ) baud = find_WiFly_baud( Baud_19200  );

    if( baud==0 ) baud = find_WiFly_baud( Baud_4800   );

    if( baud==0 ) baud = find_WiFly_baud( Baud_2400   );

    lcdx_cls_row( 7, MNORMAL, 0);                                               // Keyline loeschen

    //------------------------

    // Abbruch durch Benutzer?

    //------------------------

    if( baud < 0 )

    {

        SetBaudUart1( Config.PKT_Baudrate );                                    // orginal Baudrate von Uart1 wieder herstellen

        set_Modul_On( USB );                                                    // wieder auf USB zurueckschalten

        return -1;                                                              // -1 = Abbruch Benutzer

    }

    //------------------------

    // kein WiFly gefunden...

    //------------------------

    if( baud==0 )                                                               // WiFly nicht gefunden :-(

    {

        SetBaudUart1( Config.PKT_Baudrate );                                    // orginal Baudrate von Uart1 wieder herstellen

        set_Modul_On( USB );                                                    // wieder auf USB zurueckschalten

        //PKT_Message_P( *text, error, timeout, beep, clearscreen )

        PKT_Message_P( STR_WIFLY_NOT_FOUND, true, 3000, true, true );           // max. 30 Sekunden anzeigen

        return false;                                                           // 0 = nicht gefunden

    }

    //------------------------

    // WiFly gefunden!

    //------------------------

    find_WiFly_searchmsg( strGet(STR_FOUND), baud );                            // Anzeige: "gefunden..."

    //------------------------

    // WiFly Baud ok?

    // -> ggf. WiFly Baud umkonfigurieren

    //------------------------

    if( Config.PKT_Baudrate != baud )

    {

        find_WiFly_searchmsg( strGet(STR_SET), Config.PKT_Baudrate );           // Anzeige: "setze..."