Go to most recent revision |
Blame |
Last modification |
View Log
| RSS feed
/*-
* 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