#include <ESP8266WiFi.h>
#include <EEPROM.h>

#define SWITCH_PIN 0 // GPIO0 (programmind mode pin)
#define LED_PIN 16 // Internal LED
#define DCD_PIN 2 // DCD Carrier Status
#define RTS_PIN 4 // RTS Request to Send, connect to host's CTS pin
#define CTS_PIN 5 // CTS Clear to Send, connect to host's RTS pin

// Global variables
String cmd = ""; // Gather a new AT command to this string from serial
bool cmdMode = true; // Are we in AT command mode or connected mode
bool callConnected = false;// Are we currently in a call
bool telnet = false; // Is telnet control code handling enabled
bool verboseResults = false;

#define MAX_CMD_LENGTH 256 // Maximum length for AT command
char plusCount = 0; // Go to AT mode at "+++" sequence, that has to be counted
unsigned long plusTime = 0;// When did we last receive a "+++" sequence
#define LED_TIME 15 // How many ms to keep LED on at activity
unsigned long ledTime = 0;
#define TX_BUF_SIZE 256 // Buffer where to read from serial before writing to TCP
// (that direction is very blocking by the ESP TCP stack,
// so we can't do one byte a time.)

uint8_t txBuf[TX_BUF_SIZE];
String speedDials[10];
const int bauds[] = { 1200 };
byte serialspeed;
String busyMsg;
byte ringCount = 0;
String resultCodes[] = { "OK", "CONNECT", "RING", "NO CARRIER", "ERROR", "", "NO DIALTONE", "BUSY", "NO ANSWER" };
enum resultCodes_t { R_OK, R_CONNECT, R_RING, R_NOCARRIER, R_ERROR, R_NONE, R_NODIALTONE, R_BUSY, R_NOANSWER };
unsigned long connectTime = 0;
enum flowControl_t { F_NONE, F_HARDWARE, F_SOFTWARE };
byte flowControl = F_NONE; // Use flow control
bool txPaused = false; // Has flow control asked us to pause?
enum pinPolarity_t { P_INVERTED, P_NORMAL }; // Is LOW (0) or HIGH (1) active?
byte pinPolarity = P_INVERTED;


//BTICINO MOD
const char* host = "192.168.1.254"; // WEBSERVER MYHOME IP
const int port = 20000; // SERVER PORT
String ssid = "vostro_ssid";
String password = "vostra_password_wifi";

bool conn = false;
String rcv ="";
int ownstate = 0;
bool busy =false;
String cmdser="";
//


// Telnet codes
#define DO 0xfd
#define WONT 0xfc
#define WILL 0xfb
#define DONT 0xfe


WiFiClient tcpClient;
//MDNSResponder mdns;

String connectTimeString() {
unsigned long now = millis();
int secs = (now - connectTime) / 1000;
int mins = secs / 60;
int hours = mins / 60;
String out = "";
if (hours < 10) out.concat("0");
out.concat(String(hours));
out.concat(":");
if (mins % 60 < 10) out.concat("0");
out.concat(String(mins % 60));
out.concat(":");
if (secs % 60 < 10) out.concat("0");
out.concat(String(secs % 60));
return out;
}


void sendResult(int resultCode) {

}

// Hold for 5 seconds to switch to 300 baud
// Slow flash: keep holding
// Fast flash: let go
int checkButton() {
long time = millis();
while (digitalRead(SWITCH_PIN) == LOW && millis() - time < 5000) {
delay(250);
digitalWrite(LED_PIN, !digitalRead(LED_PIN));
yield();
}
if (millis() - time > 5000) {
Serial.flush();
Serial.end();
serialspeed = 0;
delay(100);
Serial.begin(bauds[serialspeed]);
sendResult(R_OK);
while (digitalRead(SWITCH_PIN) == LOW) {
delay(50);
digitalWrite(LED_PIN, !digitalRead(LED_PIN));
yield();
}
return 1;
} else {
return 0;
}
}

void connectWiFi() {
//WIFI SSID,PASSWORD
WiFi.begin(ssid, password);
//Serial.print("\nCONNECTING TO SSID "); Serial.print(ssid);

// fixed ip for myhome
IPAddress ip(192,168,1,10);
IPAddress gateway(192,168,1,1);
IPAddress subnet(255,255,255,0);
WiFi.config(ip, gateway, subnet);

uint8_t i = 0;
while (WiFi.status() != WL_CONNECTED && i++ < 20) {
digitalWrite(LED_PIN, LOW);
delay(250);
digitalWrite(LED_PIN, HIGH);
delay(250);
//Serial.print(".");
}
Serial.println();
if (i == 21) {
Serial.print("COULD NOT CONNET TO "); Serial.println(ssid);
WiFi.disconnect();
updateLed();
} else {
//Serial.print("CONNECTED TO "); Serial.println(WiFi.SSID());
//Serial.print("IP ADDRESS: "); Serial.println(WiFi.localIP());
updateLed();
}
}

void updateLed() {
if (WiFi.status() == WL_CONNECTED) {
digitalWrite(LED_PIN, LOW); // on
} else {
digitalWrite(LED_PIN, HIGH); //off
}
}

void disconnectWiFi() {
WiFi.disconnect();
updateLed();
}

void setCarrier(byte carrier) {
if (pinPolarity == P_NORMAL) carrier = !carrier;
digitalWrite(DCD_PIN, carrier);
}


/**
Arduino main init function
*/
void setup() {
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, HIGH); // off
pinMode(SWITCH_PIN, INPUT);
digitalWrite(SWITCH_PIN, HIGH);
pinMode(DCD_PIN, OUTPUT);
pinMode(RTS_PIN, OUTPUT);
digitalWrite(RTS_PIN, HIGH); // ready to receive data
pinMode(CTS_PIN, INPUT);
setCarrier(false);

delay(10);

Serial.begin(1200);
WiFi.mode(WIFI_STA);
connectWiFi();
//digitalWrite(LED_PIN, LOW); // on
}

String ipToString(IPAddress ip) {
char s[16];
sprintf(s, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
return s;
}

void hangUp() {
tcpClient.stop();
callConnected = false;
setCarrier(callConnected);
sendResult(R_NOCARRIER);
connectTime = 0;
}


void handleRoot() {
String page = "WIFI STATUS: ";
if (WiFi.status() == WL_CONNECTED) {
page.concat("CONNECTED");
}
if (WiFi.status() == WL_IDLE_STATUS) {
page.concat("OFFLINE");
}
if (WiFi.status() == WL_CONNECT_FAILED) {
page.concat("CONNECT FAILED");
}
if (WiFi.status() == WL_NO_SSID_AVAIL) {
page.concat("SSID UNAVAILABLE");
}
if (WiFi.status() == WL_CONNECTION_LOST) {
page.concat("CONNECTION LOST");
}
if (WiFi.status() == WL_DISCONNECTED) {
page.concat("DISCONNECTED");
}
if (WiFi.status() == WL_SCAN_COMPLETED) {
page.concat("SCAN COMPLETED");
}
yield();
page.concat("\nSSID.......: " + WiFi.SSID());

byte mac[6];
WiFi.macAddress(mac);
page.concat("\nMAC ADDRESS: ");
page.concat(String(mac[0], HEX));
page.concat(":");
page.concat(String(mac[1], HEX));
page.concat(":");
page.concat(String(mac[2], HEX));
page.concat(":");
page.concat(String(mac[3], HEX));
page.concat(":");
page.concat(String(mac[4], HEX));
page.concat(":");
page.concat(String(mac[5], HEX));
yield();

page.concat("\nIP ADDRESS.: "); page.concat(ipToString(WiFi.localIP()));
page.concat("\nGATEWAY....: "); page.concat(ipToString(WiFi.gatewayIP()));
yield();

page.concat("\nSUBNET MASK: "); page.concat(ipToString(WiFi.subnetMask()));
yield();

page.concat("\nCALL STATUS: ");
if (callConnected) {
page.concat("CONNECTED TO ");
page.concat(ipToString(tcpClient.remoteIP()));
page.concat("\nCALL LENGTH: "); page.concat(connectTimeString()); yield();
} else {
page.concat("NOT CONNECTED");
}
page.concat("\n");
//webServer.send(200, "text/plain", page);
delay(100);
}

/**
Turn on the LED and store the time, so the LED will be shortly after turned off
*/
void led_on()
{
digitalWrite(LED_PIN, !digitalRead(LED_PIN));
ledTime = millis();
}



/**
Perform a command given in command mode
*/
void command()
{
cmd.trim();
if (cmd == "") return;
//Serial.println();
String upCmd = cmd;
upCmd.toUpperCase();

//comando own
if (upCmd.substring(1,2)="*") {
//Serial.println(upCmd);
tcpClient.print(upCmd);
tcpClient.flush();
cmd="";
return;
}

if (upCmd == "AT") sendResult(R_OK);/**** Just AT ****/

/**** Disconnect WiFi ****/
else if (upCmd == "ATC0") {
disconnectWiFi();
sendResult(R_OK);
}

/**** Connect WiFi ****/
else if (upCmd == "ATC1") {
connectWiFi();
sendResult(R_OK);
}

/**** See my IP address ****/
else if (upCmd == "ATIP?")
{
Serial.println(WiFi.localIP());
sendResult(R_OK);
}

/**** Unknown command ****/
else sendResult(R_ERROR);

cmd = "";
}


void OwnRecive(String message) {
//Serial.print(rcv);
busy=false;
if (rcv=="*#*1##") {//ACK
switch (ownstate){
case 0: //richiesta autenticazione
if (tcpClient.connected()) {
//Serial.println("richiesta sessione");
tcpClient.print("*99*0##");
tcpClient.flush();
busy=true;
}
ownstate=1;
break;
case 1: //esito auth
ownstate=2; //ok
break;
case 2://esiti comandi da seriale
Serial.print(rcv);
break;

}
} else if (rcv=="*#*0##") {//NACK
Serial.print(rcv);
if (ownstate==1) {ownstate=0;}//rifiuto connessione

} else {//dati

if (rcv.length()>=12 && ownstate==1) { //password open
String pass1 = rcv.substring(2,11);
Serial.println("pass required");
}
}
rcv="";
}

/*************************************************************************************************************************************************************************************************************
Arduino main loop function
**************************************************************************************************************************************************************************************************************/
void loop()
{

//WiFiClient client;
if (conn==false) {
if (!tcpClient.connect(host, port)) {
conn=false;
Serial.println("connection failed");
delay(3000);
return;
} else {
conn=true;
}
}

if (tcpClient.connected()) {
//Serial.println("connesso");

// wait for data to be available
unsigned long timeout = millis();
while (tcpClient.available() == 0 && busy==true) {
if (millis() - timeout > 5000) {
Serial.println("Client Timeout !");
tcpClient.stop();
delay(5000);
return;
}
}

if (tcpClient.available()){
while (tcpClient.available()>0) {
char c = tcpClient.read();
rcv+=c;
}
OwnRecive(rcv);
}

} else { //client connesso
//Serial.println("disconnected");
ownstate=0;
conn=false;
}

/**** AT command mode ****/
// In command mode - don't exchange with TCP but gather characters to a string
if (Serial.available())
{
char chr = Serial.read();
// Convert uppercase PETSCII to lowercase ASCII (C64) in command mode only
if ((chr >= 193) && (chr <= 218)) chr-= 96;

// Return, enter, new line, carriage return.. anything goes to end the command
if ((chr == '\n') || (chr == '\r'))
{
command();
}
// Backspace or delete deletes previous character
else if ((chr == 8) || (chr == 127) || (chr == 20))
{
cmd.remove(cmd.length() - 1);
}
else
{
if (cmd.length() < MAX_CMD_LENGTH) cmd.concat(chr);
}
}

delay(10);
}

const char* host = "192.168.1.254"; // INDIRIZZO IP WS (ES.F453)
const int port = 20000; // PORTA PER INVIO COMANDI (DI SOLITO 20000)
String ssid = "vostro_ssid"; // IL NOME DELLA VOSTRA RETE WIFI
String password = "vostra_password_wifi"; // E LA RELATIVA PASSWORD

IPAddress ip(192,168,1,10); //INDIRIZZO IP FISSO DELL NODEMCU
IPAddress gateway(192,168,1,1); // GATEWAY DEL VOSTRO MODEM/ROUTER
IPAddress subnet(255,255,255,0); // SUBNET DELLA VOSTRA RETE

IMPORTANTE!

l'indirizzo ip del NodeMcu deve essere tra quelli consentiti alla connessione senza password sul gateway Bticino.

Requisiti del sistema :
NodeMcu EPS8266 (ho usato il Cp2102), Commodore 64 o 128, Gateway BTicino.

Ti piacciono questi software?
Puoi contribuire con una ..