0,0 → 1,1406 |
/*- |
* 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..." |
|
if( result ) result = cmd_Set( PSTR("set u b 57600") ); // -> etwas unsauber hier einfach 57600 zu setzen und nicht Config.PKT_Baudrate |
if( result ) result = cmd_Save(); |
if( result ) result = cmd_Reboot(); // true = uart-baud setzen |
|
SetBaudUart1( Config.PKT_Baudrate ); // orginal Baudrate von Uart1 wieder herstellen |
if( result ) result = cmd_EnterCommandMode(); |
} |
|
|
return result; |
} |
|
|
|
//############################################################################# |
//# |
//############################################################################# |
|
|
//-------------------------------------------------------------- |
// zeigt die WiFly-Version an |
//-------------------------------------------------------------- |
uint8_t wifly_version_show( void ) |
{ |
int8_t result = 1; // 1 = true |
|
ShowTitle_P( PSTR("WiFly Version"), true ); |
|
result = find_WiFly(); |
|
if( result < 0 ) // Abbruch durch Benutzer? |
{ |
clear_key_all(); |
return result; |
} |
|
if( result ) result = cmd_GetVersion(); // Ergebnis in 'wifly_version_string' |
|
set_Modul_On( USB ); |
|
if( result ) |
{ |
// TODO: |
// Anzeige ob WiFly-Version kompatibel zum gewaehlten |
// Mode (AP-Mode, AdHoc) ist |
//lcd_frect( 0, 2*8, 126, 7, 0); // Zeile 2 loeschen |
|
lcd_rect_round( 0, 8*4+3, 127, 8*2, 1, R2); // Anzeige-Rahmen |
lcdx_printf_center_P( 5, MNORMAL, 0,0, PSTR("Version: v%s"), wifly_version_string ); |
|
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... |
} |
else |
{ |
PKT_Message_P( PSTR("Version FAIL!"), true, 3000, true, true ); // max. 30 Sekunden anzeigen |
} |
|
clear_key_all(); |
return result; |
} |
|
|
|
|
//-------------------------------------------------------------- |
//-------------------------------------------------------------- |
uint8_t _ask( uint8_t keyline ) |
{ |
uint8_t ask = 0; |
|
lcd_rect_round( 0, 34, 127, 16, 1, R2); // Rahmen |
|
lcd_printp_at( 12, 7, strGet(keyline), MNORMAL); // Keyline |
|
if( keyline == ENDE ) |
set_beep( 1000, 0xffff, BeepNormal ); // langer Error-Beep |
else |
set_beep( 25, 0xffff, BeepNormal ); // kurzer Bestaetigungs-Beep |
|
clear_key_all(); |
while( !ask ) // warte auf Ja/Nein |
{ |
if( get_key_press(1 << KEY_ENTER) ) ask = 1; // "Ja" |
if( get_key_press(1 << KEY_ESC) ) ask = 2; // "Nein" |
}; |
|
return( ask==1 ); |
} |
|
|
|
|
//-------------------------------------------------------------- |
//-------------------------------------------------------------- |
uint8_t wifly_init_perform( uint8_t wiflymode ) //AP Mode |
{ |
uint8_t result = true; |
|
#ifndef DEBUG_WIFLY |
MsgCenter_P( 2, PSTR("INIT"), MNORMAL, 0 ); |
#endif |
|
|
//--------------- |
// WIFLY_ADHOC |
//--------------- |
if( wiflymode == WIFLY_ADHOC ) |
{ |
progress_begin( 9 ); |
|
//if( result ) result = cmd_Set( PSTR("set u m 1") ); // ist das notwendig? - (turn off echo) |
//if( result ) result = cmd_Set( PSTR("set sys printlvl 0") ); // ist das notwendig? |
//if( result ) result = cmd_Set( PSTR("set comm remote 0") ); // ist das notwendig? |
|
if( result ) result = cmd_Set( PSTR("set wlan join 4") ); // 4 = AdHoc |
if( result ) result = cmd_Set( PSTR("set ip dhcp 0") ); |
|
if( result ) result = cmd_SetStr_P( PSTR("set ip address"), WIFLY_IP_ADDRESS ); |
if( result ) result = cmd_SetStr_P( PSTR("set ip gateway"), WIFLY_IP_GATEWAY ); |
if( result ) result = cmd_SetStr_P( PSTR("set ip netmask"), WIFLY_IP_NETMASK ); |
|
if( result ) result = cmd_SetStr( PSTR("set wlan ssid"), Config.Wlan_SSID ); |
if( result ) result = cmd_SetNum( PSTR("set wlan chan"), Config.Wlan_Channel ); |
} |
|
|
//--------------- |
// WIFLY_APMODE |
//--------------- |
if( wiflymode == WIFLY_APMODE ) |
{ |
progress_begin( 13 ); |
|
if( result ) result = cmd_Set( PSTR("set wlan join 7") ); |
if( result ) result = cmd_Set( PSTR("set ip dhcp 4") ); |
|
if( result ) result = cmd_SetStr_P( PSTR("set ip address"), WIFLY_IP_ADDRESS ); |
if( result ) result = cmd_SetStr_P( PSTR("set ip gateway"), WIFLY_IP_GATEWAY ); |
if( result ) result = cmd_SetStr_P( PSTR("set ip netmask"), WIFLY_IP_NETMASK ); |
|
if( result ) result = cmd_Set( PSTR("set wlan rate 3") ); |
if( result ) result = cmd_SetStr( PSTR("set apmode ssid") , Config.Wlan_SSID ); |
if( result ) result = cmd_SetStr( PSTR("set apmode pass") , Config.Wlan_Password ); |
if( result ) result = cmd_SetNum( PSTR("set wlan channel"), Config.Wlan_Channel ); |
if( result ) result = cmd_Set( PSTR("set ip protocol 0x3") ); |
if( result ) result = cmd_Set( PSTR("set apmode link_monitor 0") ); |
} |
|
if( result ) result = cmd_Save(); |
if( result ) result = cmd_Reboot(); |
|
progress_end( false ); // Progress abschalten |
|
return( result ); |
} |
|
|
|
|
//-------------------------------------------------------------- |
// ok = wifly_init( wiflymode ) |
// |
// initialisiert das WiFly fuer AP-Mode oder AdHoc |
// |
// PARAMETER: |
// wiflymode: WIFLY_APMODE = Firmware wifly7-441.img |
// WIFLY_ADHOC = Firmware wifly7-2383.img |
//-------------------------------------------------------------- |
uint8_t wifly_init( uint8_t wiflymode ) //AP Mode |
{ |
int8_t result = 1; // 1 = true |
uint8_t ask = false; |
uint8_t versionerror = false; |
char *title = (char *)PSTR("Init WiFly"); |
char *strMode; |
|
if( wiflymode == WIFLY_ADHOC ) strMode = (char *)PSTR("AdHoc"); |
else strMode = (char *)PSTR("AP-Mode"); |
|
ShowTitle_P( title, true ); |
|
result = find_WiFly(); |
|
if( result < 0 ) // Abbruch durch Benutzer? |
{ |
clear_key_all(); |
return result; |
} |
|
|
if( result ) result = cmd_GetVersion(); |
|
//----------------------------- |
// Version pruefen |
//----------------------------- |
if( result ) |
{ |
//-------- |
// ADHOC |
//-------- |
if( wiflymode == WIFLY_ADHOC ) |
{ |
if( (wifly_version != Adhoc_Version1) // 2.32 |
&& (wifly_version != Adhoc_Version2) // 2.38 |
) |
{ |
versionerror = true; |
} |
} |
|
//-------- |
// APMODE |
//-------- |
if( wiflymode == WIFLY_APMODE && wifly_version != Apmode_Version1 ) versionerror = true; |
|
if( versionerror ) |
{ |
set_Modul_On( USB ); |
ShowTitle_P( title, true ); |
lcdx_printf_center_P( 2, MNORMAL, 0, -4, PSTR("WiFly v%s"), wifly_version_string ); |
lcdx_printf_center_P( 3, MNORMAL, 0, -1, PSTR("ERROR") ); |
lcdx_printf_center_P( 5, MNORMAL, 0, -1, PSTR("Version no %S!"), strMode ); // "Version no AP-Mode" / "AdHoc" |
ask = _ask( ENDE ); |
|
return false; |
} |
} |
|
|
//----------------------------- |
// Benutzer fragen |
//----------------------------- |
if( result ) |
{ |
ShowTitle_P( title, true ); |
//lcdx_printf_at_P( 0, 1, MINVERS, 0,0, PSTR("%d"), wifly_version ); |
|
lcdx_printf_center_P( 2, MNORMAL, 0, -4, PSTR("WiFly v%s"), wifly_version_string ); // WiFly Versionsanzeige |
lcdx_printf_center_P( 3, MNORMAL, 0, -2, PSTR("%S: OK") , strMode ); // "AP-Mode" oder "AdHoc" |
lcdx_printf_center_P( 5, MNORMAL, 0, -1, PSTR("%S?") , title ); // "Init WiFly?" |
|
ask = _ask( NOYES ); |
|
if( !ask ) // "Nein" |
{ |
set_Modul_On( USB ); |
return false; |
} |
} |
|
|
//----------------------------- |
// Init durchfuehren |
//----------------------------- |
if( result ) |
{ |
ShowTitle_P( title, true ); |
result = wifly_init_perform( wiflymode ); |
} |
|
set_Modul_On( USB ); |
|
if( !result ) |
PKT_Message_P( PSTR("Init FAIL!"), true, 3000, true, true ); // max. 30 Sekunden anzeigen |
else |
PKT_Message_P( PSTR("Init OK!"), false, 3000, true, true ); // max. 30 Sekunden anzeigen |
|
clear_key_all(); |
return( result ); |
} |
|
|
|
//-------------------------------------------------------------- |
// PARAMETER: |
// wiflymode: WIFLY_APMODE = Firmware wifly7-441.img |
// WIFLY_ADHOC = Firmware wifly7-2383.img |
//-------------------------------------------------------------- |
uint8_t wifly_update( uint8_t wiflymode ) |
{ |
int8_t result = 1; // 1 = true |
uint8_t ask = false; |
char *title = (char *)PSTR("Update WiFly"); |
const char *pStr; |
|
|
ShowTitle_P( title, true ); |
|
result = find_WiFly(); |
|
if( result < 0 ) // Abbruch durch Benutzer? |
{ |
clear_key_all(); |
return result; |
} |
|
|
if( result ) result = cmd_GetVersion(); |
|
//----------------------------- |
// Benutzer fragen |
//----------------------------- |
if( result ) |
{ |
if( wiflymode == WIFLY_ADHOC ) pStr = WIFLY_VERSION_ADHOC; |
else pStr = WIFLY_VERSION_APMODE; |
|
ShowTitle_P( title, true ); |
//lcdx_printf_at_P( 0, 1, MINVERS, 0,0, PSTR("%d"), wifly_version ); |
lcdx_printf_center_P( 2, MNORMAL, 0, -4, PSTR("%S: v%s"), strGet(STR_VON), wifly_version_string ); |
lcdx_printf_center_P( 3, MNORMAL, 0, -2, PSTR("%S: v%S"), strGet(STR_NACH), pStr ); |
lcdx_printf_center_P( 5, MNORMAL, 0, -1, PSTR("%S?"), title ); |
|
ask = _ask( NOYES ); |
|
if( !ask ) // "Nein" |
{ |
set_Modul_On( USB ); |
return false; |
} |
} |
|
|
//----------------------------- |
// Update durchfuehren |
//----------------------------- |
if( result ) |
{ |
ShowTitle_P( title, true ); |
progress_begin( 16 ); |
} |
|
//---------------------------- |
// 1. Reset |
//---------------------------- |
#ifndef DEBUG_WIFLY |
if( result ) MsgCenter_P( 2, PSTR("Reset"), MNORMAL, 0 ); |
#endif |
if( result ) result = cmd_Reset(); |
if( result ) result = cmd_Reboot(); |
if( result ) result = find_WiFly(); |
|
//---------------------------- |
// 2. mit Heimnetz verbinden |
//---------------------------- |
#ifndef DEBUG_WIFLY |
if( result ) MsgCenter_P( 2, PSTR("verbinde Heimnetz"), MNORMAL, 0 ); |
#endif |
if( result ) result = cmd_Set( PSTR("set ip dhcp 1") ); |
if( result ) result = cmd_SetStr( PSTR("set wlan phrase"), Config.Wlan_HomePassword ); |
if( result ) result = cmd_Set( PSTR("set wlan channel 0") ); |
|
if( result ) result = cmd_Join( Config.Wlan_HomeSSID ); |
|
//---------------------------- |
// 3. FTP Download & Update |
//---------------------------- |
#ifndef DEBUG_WIFLY |
if( result ) MsgCenter_P( 2, PSTR("FTP Update"), MNORMAL, 0 ); |
#endif |
if( result ) result = cmd_Set( PSTR("set ftp address 198.175.253.161") ); |
if( result ) result = cmd_Set( PSTR("set ftp dir public") ); |
if( result ) result = cmd_Set( PSTR("set ftp user roving") ); |
if( result ) result = cmd_Set( PSTR("set ftp pass Pass123") ); |
if( result ) result = cmd_Set( PSTR("set ftp timeout 800") ); |
|
//if( result ) result = cmd_Set( PSTR("del config") ); |
|
if( result ) |
{ |
//----- |
// das kann einiges gekuerzt werden wenn das denn zuverlaessig laufen wuerde... |
// |
// hier wird auf v4.40 geprueft da laut Refrenz-Manual erst seit dieser Version |
// "cupdate" unterstuetzt wird. Bei einem Downgraden von v4.4 auf eine aeltere |
// Version ist ein clean des Dateisystems ('c') erforderlich da sonst das WiFly |
// nur via Hardware-Taster an GPIO9 wiedre zum Leben erweckt werden kann. |
// |
// Anmerkung: evtl. wuer auch ein "del config" reichen - das ist aber nicht |
// hinreichend getestet |
//----- |
if( wifly_version >= 440 ) |
{ |
if( wiflymode == WIFLY_ADHOC ) |
result = cmdsend( PSTR("ftp cupdate wifly7-2383.img"), 0, PSTR("UPDATE OK"), false ); |
else |
result = cmdsend( PSTR("ftp cupdate wifly7-441.img") , 0, PSTR("UPDATE OK"), false ); |
} |
else |
{ |
if( wiflymode == WIFLY_ADHOC ) |
result = cmdsend( PSTR("ftp update wifly7-2383.img"), 0, PSTR("UPDATE OK"), false ); |
else |
result = cmdsend( PSTR("ftp update wifly7-441.img") , 0, PSTR("UPDATE OK"), false ); |
} |
} |
|
if( result ) result = cmd_Reset(); |
if( result ) { timer2 = 50; while(timer2); }; |
|
|
/* |
//----- |
// Baustelle / Experimente bzgl. FTP-Update |
//----- |
//debug_message("FTP END"); |
//debug_message("RESET"); |
//if( result ) result = cmd_Reboot(); |
if( result ) { timer2 = 100; while(timer2); }; |
if( result ) { timer2 = 200; while(timer2); }; |
debug_message("FINDPR"); |
uart1_putc('\r'); |
if( result ) result = find_Prompt(); |
if( result ) debug_message("FINDPR END: 1"); |
else debug_message("FINDPR END: 0"); |
*/ |
|
|
//progress_end( true ); // Progress abschalten & warten |
progress_end( false ); // Progress abschalten |
|
|
//---------------------------- |
// 4. Init |
//---------------------------- |
/* |
if( result ) { timer2 = 10; while(timer2); }; |
if( result ) set_Modul_On( USB ); |
if( result ) { timer2 = 10; while(timer2); }; |
if( result ) ShowTitle_P( title, true ); |
if( result ) result = result = find_WiFly(); |
if( result ) result = wifly_init_perform( wiflymode ); |
*/ |
|
set_Modul_On( USB ); |
|
|
if( !result ) |
PKT_Message_P( PSTR("Update FAIL!"), true, 3000, true, true ); // max. 30 Sekunden anzeigen |
else |
PKT_Message_P( PSTR("Update OK!"), false, 3000, true, true ); // max. 30 Sekunden anzeigen |
|
|
clear_key_all(); |
return result; |
} |
|
|
|
//-------------------------------------------------------------- |
//-------------------------------------------------------------- |
uint8_t wifly_reset( void ) |
{ |
int8_t result = 1; // 1 = true |
uint8_t ask = false; |
char *title = (char *)PSTR("Reset WiFly"); |
|
ShowTitle_P( title, true ); |
|
result = find_WiFly(); |
|
if( result < 0 ) // Abbruch durch Benutzer? |
{ |
clear_key_all(); |
return result; |
} |
|
|
//----------------------------- |
// Benutzer fragen |
//----------------------------- |
if( result ) |
{ |
ShowTitle_P( title, true ); |
lcdx_printf_center_P( 5, MNORMAL, 0, -1, PSTR("%S?"), title ); |
|
ask = _ask( NOYES ); |
|
if( !ask ) // "Nein" |
{ |
set_Modul_On( USB ); |
return false; |
} |
} |
|
ShowTitle_P( title, true ); |
|
if( result ) progress_begin( 2 ); |
|
if( result ) result = cmd_Reset(); |
if( result ) result = cmd_Reboot(); |
|
progress_end( false ); // Progress abschalten |
|
set_Modul_On( USB ); |
|
if( result ) |
{ |
//PKT_Message_P( *text, error, timeout, beep, clearscreen ) |
PKT_Message_P( PSTR("Reset OK!"), false, 3000, true, true ); // max. 30 Sekunden anzeigen |
} |
else |
{ |
PKT_Message_P( PSTR("Reset FAIL!"), true, 3000, true, true ); // max. 30 Sekunden anzeigen |
} |
|
clear_key_all(); |
return result; |
} |
|
|
|
//############################################################################# |
//# TEST / DEBUG |
//############################################################################# |
|
|
//-------------------------------------------------------------- |
// nur zum testen! |
//-------------------------------------------------------------- |
uint8_t wifly_test( void ) |
{ |
uint8_t result = true; |
|
return result; |
} |
|
#endif |
|
Property changes: |
Added: svn:mime-type |
+text/plain |
\ No newline at end of property |