A21 centrale digitale ethernet/Wifi...a 27 euro!

[sal727]

Testato finalmente facendo la prova sul campo, tutto funziona sia WiFi che ethernet, per quest'ultimo c'è solo un piccolo particolare ci mette un po' a connettersi con il pc, ma poi funziona tutto.

[sal727]

Per completare la centrale, mancava solamente il suo contenitoree compresa l'antenna WiFi

fatto su misura e ho lasciato volutamente a vista il connettore dei collegamenti e il tasto di reset.

[v200]

Molto utile il contenitore in 3D

[fabio]

Gran bel lavoro Salvatore Complimenti!

[ClaBos]

Ho realizzato, per gioco e per sperimentare, questa centrale digitale basata sull'open source DCC++, che praticamente emula perfettamente una Z21 Roco, e quindi è gestibile anche via smartphone/tablet tramite l'app Roco scaricabile dall'app store (o playstore per android), e supporta JMRI e Rocrail; preciso che progetto, codice e quant'altro NON è scritto/fatto da me, ho solo assemblato i due moduli Arduino necessari (Mega+Wifi+motor shield oppure Mega/motor shield e ethernet shield) e caricato il codice; esiste anche un Wifi throttle, sempre realizzabile a bassissimo costo su base arduino; il costo totale delle due versoni è di 27 euro la prima e circa 18 euro la seconda...Se qualcuno è interessato posso postare un tutorial, anche se in rete si trova tutto...
Arduino Mega+WiFi (19 euro spedito)
s-l1600.jpg
Motor shield (8 euro spedito)
motor.jpg
Wifi throttle
plexUnit1.jpg

Ciao. Potresti mettere un link per il motor shield? Ne trovo diversi in rete ma non so quale sia quello giusto.

Grazie

[max63]

Scusami ho visto solo ora la tua richiesta!
io ho usato questo:
https://www.ebay.it/itm/L298P-DC-Motor- ... SwkkNbFPua

[Abarth49]

Vorrei ringraziare tutti che hanno condiviso consigli e soluzioni,
per tutto questo ho deciso di costruire anch’io la centrale .
Grazie.

[ccomincini]

Innanzi tutto grazie per la condivisione. A tutti. Chiedo scusa fin d'ora per l'ignoranza, ma ho bisogno del vostro aiuto esperto. Sono arrivato a questo post cercando una soluzione ad un problema: Io ho una centrale nanoxs88, ma utilizzando Rocrail con una interfaccia auto-costruita GenLi-s88 seriale, spesso accade che i comandi inviati alle loco non vengano processati: Rocrail imposta la velocità di una Loco, ma quella non parte. se poi dal palmare virtuale vari la velocità, accendi le luci o attivi una funzione (insomma se invii n segnale)) la loco si prende in carico il treno di istruzioni che gli aveva spedito rocrail e riparte, ma... così è inutile.
Lo stesso problema poi si verifica con i deviatoi quando vengono impostate rotte multiple e questo genera disastrosi incidenti... tra l'altro quasi sempre in aree nascoste...
Così immaginando che il problema sia nell'interfaccia seriale che ha un baud rate molto basso ho cercato un'altrrnativa economica alla gen-li di Paco, e ho visto questo post e vorrei provare la A21, ma non capisco come potrò collegare i miei moduli di retroazione S88 realizzati tra l'altro con arduino e la medesima libreria usata per la centrale.

Mi sembra di capire che l' interfaccia di rete venga usate per la connessione dati tra PC e Centrale e che al massimo, oltre alle uscite per binario di programmazione e tracciato, si possa collegare un bus XPRESSNET usando le schedine e max485 e non vedo quindi una porta per il bus S88. HO immaginato che si partisse dai pin dell'arduino ma non ho capito come.

Inoltre nel file dello sketch versione 477 mi sembra che il codice per il bus s88 sia commentato...
//#define S88N

Qualcuno sarebbe così gentile da spiegarmi come si collega il bus s88 e se ci sono da fare delle modifiche allo sketch?
grazie mille in anticipo
Carlo

[MrMassy86]

Ciao Carlo benvenuto nel forum
Sicuramente gli esperti potranno darti una risposta al tuo quesito, io come membro dello staff ti invito a presentarti nell'apposita sezione
viewforum.php?f=44
E' un modo per conoscersi meglio ed istaurare un rapporto amichevole
Massimiliano

[ccomincini]

Ciao Carlo benvenuto nel forum
Sicuramente gli esperti potranno darti una risposta al tuo quesito, io come membro dello staff ti invito a presentarti nell'apposita sezione
viewforum.php?f=44
E' un modo per conoscersi meglio ed istaurare un rapporto amichevole
Massimiliano

FATTO!
Grazie

[ccomincini]

[...]
Qualcuno sarebbe così gentile da spiegarmi come si collega il bus s88 e se ci sono da fare delle modifiche allo sketch?
grazie mille in anticipo
Carlo

Ok, rispondersi da soli non è proprio politically correct, ma ... ho trovato il sito pgahtow.de già citato più volte nei post precedenti un'immagine che mi ha confuso ulteriormente: http://pgahtow.de/wiki/images/Arduino_MEGA_Zentrale.png
Secondo questo schema per la connessione del S88 servirebbe un'interfaccia di mezzo basata su un integrato SN74HC244N.
Io capisco poco di elettronica, ma leggendo mi è sembrato di comprendere che si tratti di una sorta di booster usato per amplificare e stabilizzare il segnale del bus s88.
Mi ha confuso perché qui parlate di una centrale basata su 4 schedine (Arduino, motore, rete, max485 per xpressnet) ma su quel sito sembra che si debba realizzare qualcosa di un po' più complesso da unire all'Arduino e ai suoi shield.

Sempre sul sito di Philipp Gahtow, nelle pagine che spiegano la realizzazione della centrale Z21 http://pgahtow.de/wiki/index.php?title=Zentrale#S88N , c'è scritto:

Rückmeldungen können mit dem S88N-Interface an die Steuersoftware weitergeleitet werden. Es werden bis zu 62 Rückmeldemodule mit 8 Eingängen unterstützt. Einstellungen zur Anzahl der abzufragenden Module lassen sich über die Webkonfiguration mittels LAN oder WLAN vornehmen. Aktiviert wird das S88-Interface mittels:
#define S88N
Hinweis: Ab ca. 5 Modulen sollte ein Ausgangstreiber 74HC244 für den S88 Bus verwendet werden.

Quindi sembra che si possa usare il bus s88 direttamente collegato all'Arduino, ma che in caso di utilizzo di più di 5 moduli (40 sensori), sia opportuno usare un driver basato sul suddetto integrato... e nelle pagine che spiegano come realizzare il driver si mostra una sorta di sostituto dell'interfaccia HSI88 di LTD per il controllo del bus s88 su tre porte...

mumble...mumble...
ma qualcuno di voi ha collegato un modulo di retroazione alla centrale A21? e come?

[Charlie63]

E' quello che sembra anche a me...
Si parla SOLO di controllare le loco, non di tutte le interfacce che ha la Z21.
Quelle sono in una 2 schede a parte (1 per le interfacce e 1 per l s88) che come si puo' vedere sono realizzata su delle millefori collegate ad Arduino.
E questa e' la parte che piu' interessa anche a me.

[ClaBos]

Buongiorno a tutti.

Oggi mi sono messo al pc per programmare Arduino Mega+WiFi con il Motor shield.

Io vorrei usare la versione wifi.

Ho iniziato a seguire la guida ma ad un certo punto non mi carica uno Sketch dandomi errore....

Ho caricato (dopo averli decompressi) tutti gli archivi con gli sketch per Arduino ed ESP..ho messo in ON i dip switch 3 ° e 4 ° (tutti gli altri in OFF, il secondo interruttore RX0 /
RX3 su “0”) ..collegata la scheda tramite usb al pc...selezionato tipo di scheda e porta e caricato lo sketch....e fin qui tutto bene.


Ho messo il 3 ° e il 4 ° DIP switch su OFF ed il 5, 6 e 7 su ON; l’interruttore a levetta sempre su RX/TX=0
Apri lo sketch Z21_ESPArduinoUDP_v27.ino
Nel menu Strumenti-> Scheda ...-> Modulo Wemos D1 R2 e mini
Con i parametri Flash Size= 4M (3M SPIFFS)
Ed il clock a 80mhz

Ho caricato lo sketch ma mi ha dato questo errore...

Codice: Seleziona tutto

Arduino:1.8.8 (Windows 10), Scheda:"WeMos D1 R1, 80 MHz, Flash, Disabled, 4M (no SPIFFS), v2 Lower Memory, Disabled, None, Only Sketch, 921600"

C:\Users\39349\Desktop\Z21\Z21_ESPArduinoUDP_v27\Z21_ESPArduinoUDP_v27.ino: In function 'void loop()':

Z21_ESPArduinoUDP_v27:511:42: error: invalid conversion from 'char*' to 'const uint8_t* {aka const unsigned char*}' [-fpermissive]

     Serial.write(packetBuffer, packetSize); //send to Zentrale (trenne erst dort kombinierte Pakete!)

                                          ^

In file included from C:\Users\39349\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.5.0\cores\esp8266/Arduino.h:263:0,

                 from sketch\Z21_ESPArduinoUDP_v27.ino.cpp:1:

C:\Users\39349\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.5.0\cores\esp8266/HardwareSerial.h:171:12: error:   initializing argument 1 of 'virtual size_t HardwareSerial::write(const uint8_t*, size_t)' [-fpermissive]

     size_t write(const uint8_t *buffer, size_t size) override

            ^

exit status 1
invalid conversion from 'char*' to 'const uint8_t* {aka const unsigned char*}' [-fpermissive]

Questo report potrebbe essere più ricco di informazioni abilitando l'opzione
"Mostra un output dettagliato durante la compilazione"
in "File -> Impostazioni"

Provo ad allegare tutto lo sketch...

Codice: Seleziona tutto

/* Arduino IDE for ESP8266 
      Z21 ESP UDP
      
      This Sketch communicate with the Z21 App via UDP on Port 21105
      It send all data over Serial out. It add to each serial packet a client identify code,
      so you are able to answer a request to the IP that ask.
      The UDP answer is generated by serial receive, the data always start with the identify code.
      The length of each packet is coded in the second byte, that is the first byte of the Z21 LAN protocoll!
      
      Example:
        Answer with HTerm to
        LAN X GET Version in HEX with: 0x00, 0x09, 0x00, 0x40, 0x00, 0x63, 0x21, 0x30, 0x12, 0x60  
                                     client | Z21 LAN protocoll        
      
      The Sketch provide a AJAX Webserver to configure the AP (after ESP reset) and client WiFi connection. 
        - Read more about AJAX: https://startingelectronics.org/tutorials/arduino/ethernet-shield-web-server-tutorial/web-server-read-switch-using-AJAX/
      
      Important:
      You can reset the stored data of the AP, when you pull-down the GPIO 2 while starting the ESP!
*/      
#define VERSION 2.7
/*
      Copyright (c) 2016 Philipp Gahtow  All right reserved.
      digitalmoba@arcor.de

Changelog:
      02.06.2016 Add Auto Baudrate detection
      17.07.2016 Fix Network UDP answer port - send paket back to source port
      23.07.2017 accept also SSID length with only one char
*/ 

//For Debugging active flag and read out via serial:
//#define DEBUG

#include <ESP8266WiFi.h>
#include <WiFiClient.h> 
#include <WiFiUDP.h>

#include <EEPROM.h>

WiFiServer server(80);

WiFiUDP Udp;

//client ssid and pw stored in EEPROM!
String ssid = "";  
String pass = "";

#define SssidAP "Z21_ESP"   // Default Z21 AP (SSID)
#define SpassAP "12345678"  // Default Z21 network password
#define SkanalAP 6          // Default Kanal des AP

unsigned long serialbaud = 19200;   //Default Serial Baudrate
byte counterr = 0;
#define MaxError 5     //bei Übertragungsfehler - starte Neuerkennung Baudrate

 //latest config out of EEPROM:
String ssidAP = "";
String passAP = "";
byte kanalAP = 6;  

#define maxIP 20                //Client IP that are stored
#define Z21_UDP_TX_MAX_SIZE 20  //max UDP packet size
#define localPort 21105

//Z21 WLAN Default config:
static IPAddress Ip(192, 168, 0, 1); //default IP
static IPAddress Gw(192, 168, 0, 1); //default Gateway
static IPAddress Sb(255, 255, 255, 0); //default Subnet

//EEPROM Konfiguration
#define EESize 256    //Größe des EEPROM
//Client:
#define EEssidLength 0       //Länge der SSID
#define EEssidBegin 1        //Start Wert
#define EEpassLength 32        //Länge des Passwort
#define EEpassBegin 33        //Start Wert
//AP:
#define EEssidAPLength 64       //Länge der SSID AP
#define EEssidAPBegin 65        //Start Wert
#define EEpassAPLength 98        //Länge des Passwort AP
#define EEpassAPBegin 99        //Start Wert
#define EEkanalAP 150          //Kanal AP

byte outData[Z21_UDP_TX_MAX_SIZE];    //store received Serial to send via UDP
byte outDcount = 0;  //position writing out data
byte sendTOO = 0xFF;  //memIP to whom to send the data

typedef struct		//Rückmeldung des Status der Programmierung
{
  IPAddress IP;
  byte time;  //aktive Zeit
  unsigned int port;    //source Port
} listofIP;
listofIP mem[maxIP];

byte countIP = 0;    //zähler für Eintragungen

#define ActTimeIP 20    //Aktivhaltung einer IP für (sec./2)
#define interval 2000   //interval in milliseconds for checking IP aktiv state

unsigned long IPpreviousMillis = 0;       // will store last time of IP decount updated

byte S88Module = 0xFE;  //Anzahl der abzufragenden S88 Module

#define ResetPin 2      //to Reset the Module at Startup!

byte count = 0;     //Zähler bis Data Flush

/**********************************************************************************/
void EEPROMwrite (String s, byte laenge, byte start) {
  byte len = s.length();
  EEPROM.write(laenge,len);
  for (int i = start; i < (start+len); i++) {
     EEPROM.write(i,s[i-start]);
  }
}

/**********************************************************************************/
String EEPROMread (byte laenge, byte start) {
  String s = "";
  byte len = EEPROM.read(laenge);
  for (int i = start; i < (start+len); i++) {
    s += char(EEPROM.read(i));
  }
  return s;
}

/**********************************************************************************/
boolean tryWifiClient() {
  // WiFi.scanNetworks will return the number of networks found
  byte n = 1; //WiFi.scanNetworks();
  if ((n > 0) && (ssid.length() > 0)) {
    //Try to connect to WiFi
     WiFi.begin(ssid.c_str(), pass.c_str());
     n = 0;
     while(WiFi.waitForConnectResult() != WL_CONNECTED){
//        WiFi.begin(ssid.c_str(), pass.c_str());
        delay(100);
        n++;
        if (n > 30) {
            WiFi.disconnect();
            return false;
        }
      }
      return true;
  }
  return false;
}

/**********************************************************************************/
void sendUDP () {
  for (byte s = 0; s < countIP; s++) {
    if (mem[s].time > 0) {
      if (sendTOO == 0x00) {  //Broadcast
        Udp.beginPacket(mem[s].IP, mem[s].port);
      }
      else Udp.beginPacket(mem[sendTOO-1].IP, mem[sendTOO-1].port);  //singel Answer
      Udp.write(outData, outDcount);
      Udp.endPacket();
      if (sendTOO != 0x00)  //wenn kein Broadcast -> ENDE!
        return;
    }
  }
}

/**********************************************************************************/
// function to return valid received baud rate
long detRate(byte recpin) {
  long baud, rate, x;
  pinMode(recpin, INPUT_PULLUP);      // make sure serial in is a input pin
  do {
     rate = 10000;
     for (int i = 0; i < 10; i++) {
         do {
          baud = pulseIn(recpin,LOW);   // measure the next zero bit width
         } while (baud == 0);
         rate = baud < rate ? baud : rate;
     }
     if (rate < 6)
     baud = 0;
     else if (rate < 12)
     baud = 115200;
     else if (rate < 20)
     baud = 57600;
     else if (rate < 29)
     baud = 38400;
     else if (rate < 40)
     baud = 28800;
     else if (rate < 60)
     baud = 19200;
     else if (rate < 80)
     baud = 14400;
     else if (rate < 150)
     baud = 9600;
     else if (rate < 300)
     baud = 4800;
     else if (rate < 600)
     baud = 2400;
     else if (rate < 1200)
     baud = 1200;
     else
     baud = 0; 
  } while (baud == 0);
  return baud;
}

/**********************************************************************************/
void receiveEvent(int howMany) {
      outData[outDcount] = Serial.read();
      count = 0;
      if (sendTOO == 0xFF)
        sendTOO = outData[outDcount];  //Ziel IP/client read out
      else {
        outDcount++;
        if (outData[0] <= outDcount) {  //1. Byte gibt länge der Daten an!
          if (sendTOO <= countIP) {     //Ziel in Range?
            sendUDP();  //send Data out!
            Serial.print("OK");  //Accept
            counterr = 0;
          }
          else Serial.print("EE");  //Fail - client to high
          counterr++; //Fehler zählen
          outDcount = 0;
          sendTOO = 0xFF;
          //Serial.flush();
        }
        //ERROR:
        if (outDcount >= Z21_UDP_TX_MAX_SIZE) {  //keine valied Data!
          Serial.print("EE");  //Fail
          counterr++; //Fehler zählen
          outDcount = 0;   //reset read buffer
          sendTOO = 0xFF;
          Serial.flush();
        }
        //set S88 Module:
        if (outData[0] == 'S' && outData[1] == '8' && outData[2] == '8') {
          if (sendTOO > 0)
            S88Module = sendTOO;
          outDcount = 0;   //reset read buffer
          sendTOO = 0xFF;
          Serial.print("OK");  //get data
          counterr = 0;
        }
      }
      if (counterr > MaxError) {
        Serial.end();
        serialbaud = detRate(3);  // detect Baud rate again!
        Serial.begin(serialbaud);
        Serial.flush();
        counterr = 0;
      }
}  

/**********************************************************************************/
byte addIP (IPAddress ip, unsigned int port) {
  //suche ob IP schon vorhanden?
  for (byte i = 0; i < countIP; i++) {
    if (mem[i].IP == ip && mem[i].port == port) {
      mem[i].time = ActTimeIP; //setzte Zeit
      return i+1;      //Rückgabe der Speicherzelle
    }
  }
  //nicht vorhanden!
  if (countIP >= maxIP) {
    for (byte i = 0; i < countIP; i++) {
      if (mem[i].time == 0) { //Abgelaufende IP, dort eintragen!
        mem[i].IP = ip;
        mem[i].port = port;
        mem[i].time = ActTimeIP; //setzte Zeit
        return i+1;
      }
    }
    Serial.print("EE");  //Fail
    return 0;           //Fehler, keine freien Speicherzellen!
  }
  mem[countIP].IP = ip;  //eintragen
  mem[countIP].port = port;
  mem[countIP].time = ActTimeIP; //setzte Zeit
  countIP++;            //Zähler erhöhen
  return countIP;       //Rückgabe
}

/**********************************************************************************/
void webconfig() {
  WiFiClient client = server.available();
  if (!client)
    return;
    
  String HTTP_req;            // stores the HTTP request 

  if (client) {  // got client?
        boolean currentLineIsBlank = true;
        while (client.connected()) {
            if (client.available()) {   // client data available to read
                char c = client.read(); // read 1 byte (character) from client
                HTTP_req += c;  // save the HTTP request 1 char at a time
                // last line of client request is blank and ends with \n
                // respond to client only after last line received
                if (c == '\n' && currentLineIsBlank) {
                    // send a standard http response header
                    client.println("HTTP/1.1 200 OK");
                    client.println("Content-Type: text/html");
                    client.println("Connection: keep-alive");
                    client.println();      //don't forget this!!!
                    // AJAX request for switch state
                    if (HTTP_req.indexOf("/ajax_switch") > -1) {
                        // read switch state and send appropriate paragraph text
                        ssid = HTTP_req.substring(HTTP_req.indexOf("&s=")+3,HTTP_req.indexOf("&p="));
                        pass = HTTP_req.substring(HTTP_req.indexOf("&p=")+3,HTTP_req.indexOf("&As="));
                        ssidAP = HTTP_req.substring(HTTP_req.indexOf("&As=")+4,HTTP_req.indexOf("&Ap="));
                        passAP = HTTP_req.substring(HTTP_req.indexOf("&Ap=")+4,HTTP_req.indexOf("&Ak="));
                        kanalAP = HTTP_req.substring(HTTP_req.indexOf("&Ak=")+4,HTTP_req.indexOf("&S8=")).toInt();
                        if (S88Module != 0xFE) {
                          S88Module = HTTP_req.substring(HTTP_req.indexOf("&S8=")+4,HTTP_req.indexOf("&nocache")).toInt();
                          Serial.write(S88Module);    //sende S88 Einstellungen an Zentrale!
                          Serial.print("S88");
                        }
                        
                        if ((kanalAP < 1) || (kanalAP > 13)) {
                          kanalAP = SkanalAP;
                          client.print("Ka. error! ");
                        }
                        if (passAP.length() < 8) {
                          passAP = SpassAP;
                          client.print("Code length error (min. 8)! ");
                        }
                        
                        // write eeprom
                        EEPROMwrite (ssid, EEssidLength, EEssidBegin);
                        EEPROMwrite (pass, EEpassLength, EEpassBegin);
                        
                        EEPROMwrite (ssidAP, EEssidAPLength, EEssidAPBegin);
                        EEPROMwrite (passAP, EEpassAPLength, EEpassAPBegin);
                        EEPROM.write(EEkanalAP, kanalAP);
                        EEPROM.commit(); 

                        WiFi.disconnect();
                        tryWifiClient();
                        
                        Udp.begin(localPort);

                        client.println("saved");   //OK!
                    }
                    else {  // HTTP request for web page
                        // send web page - contains JavaScript with AJAX calls
                        client.println("<!DOCTYPE html>");
                        client.println("<html><head><title>Z21</title>");
                        client.println("<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"/>");
                        client.println("<script>");
                        client.println("function SetState() {");
                        client.println("document.getElementById(\"state\").innerHTML = \"wait\";");
                        client.println("nocache = \"&s=\" + document.getElementById(\"ssid\").value;");
                        client.println("nocache += \"&p=\" + document.getElementById(\"pass\").value;");
                        client.println("nocache += \"&As=\" + document.getElementById(\"ssidAP\").value;");
                        client.println("nocache += \"&Ap=\" + document.getElementById(\"passAP\").value;");
                        client.println("nocache += \"&Ak=\" + document.getElementById(\"kanalAP\").value;");
                        client.println("nocache += \"&S8=\" + document.getElementById(\"S88\").value;");
                        client.println("nocache += \"&nocache=\" + Math.random() * 1000000;");
                        client.println("var request = new XMLHttpRequest();");
                        client.println("request.onreadystatechange = function() {");
                        client.println("if (this.readyState == 4){");
//                        client.println("if (this.status == 200){");
//                        client.println("if (this.responseText != null) {");
                        client.println("document.getElementById(\"state\").innerHTML = this.responseText;");
                        client.println("top.window.location.reload(true);");
                        client.println("}}");
                        client.println("request.open(\"GET\", \"ajax_switch\" + nocache, true);");
                        client.println("request.send(null);");
                        //client.println("setTimeout('SetState()', 1000);");
                        client.println("}");
                        client.println("</script>");
                        client.println("</head>");
                        client.println("<body><h1>Z21 Net-config</h1><hr>");
                        
                        client.print("<h2>WiFi Direct AP</h2>");
                        client.print("<dl><dd>IP: ");
                        client.print(WiFi.softAPIP());
                        client.print("</dd><dd>SSID: <input type=\"text\" id=\"ssidAP\" value=\"");
                        client.print(ssidAP);
                        client.print("\"></dd><dd>code: <input type=\"text\" id=\"passAP\" value=\"");
                        client.print(passAP);
                        client.print("\"></dd><dd>Ka.: <input type=\"number\" min=\"1\" max=\"13\" id=\"kanalAP\" value=\"");
                        client.print(kanalAP);
                        client.println("\"></dd></dl>");
                        
                        client.print("<h2>WiFi client</h2>");
                        client.print("<dl><dd>IP: ");
                        if (WiFi.status() == WL_CONNECTED)
                          client.print(WiFi.localIP());
                        else client.print("none");
                        client.print("</dd><dd>SSID: <input type=text id=\"ssid\" value=\"");  
                        client.print(ssid);
                        client.print("\"></dd><dd>code: <input type=text id=\"pass\" value=\"");
                        client.print(pass);
                        client.println("\"></dd></dl>");

                        client.println("<h2>S88 Module</h2>");
                        client.print("<dl><dd>8x Anzahl: <input type=number min=\"0\" max=\"62\" id=\"S88\" value=\"");
                        if (S88Module != 0xFE) {                          
                          client.print(S88Module);
                          client.print("\"");
                        }
                        else client.print("0\" disabled");
                        client.println("></dd></dl><br>");
                        
                        client.println("<input type=submit onclick=\"SetState()\">"); 
                        client.println("<p id=\"state\"></p>");
                        client.print("<hr><p>Z21_ESPArduinoUDP_v");
                        client.print(VERSION);
                        client.print("<br>Run at Baudrate: ");
                        client.print(serialbaud);
                        client.println("<br>Copyright (c) 2016 Philipp Gahtow<br>digitalmoba@arcor.de</p>");
                        client.println("</body>");
                        client.print("</html>");
                    }
                    // display received HTTP request on serial port
                    //Serial.print(HTTP_req);
                    HTTP_req = "";            // finished with request, empty string
                    break;
                }
                // every line of text received from the client ends with \r\n
                if (c == '\n') {
                    // last character on line of received text
                    // starting new line with next character read
                    currentLineIsBlank = true;
                } 
                else if (c != '\r') {
                    // a text character was received from client
                    currentLineIsBlank = false;
                }
            } // end if (client.available())
        } // end while (client.connected())
        delay(1);      // give the web browser time to receive the data
        client.stop(); // close the connection
    } // end if (client)
}

/**********************************************************************************/
void setup()
{
  EEPROM.begin(EESize);  //init EEPROM
  
  pinMode(ResetPin, INPUT);  //init Reset Pin
  
  // read eeprom for ssid and pass
  //--------------WIFI CLIENT---------------
  ssid = EEPROMread(EEssidLength, EEssidBegin);
  pass = EEPROMread(EEpassLength, EEpassBegin);
   //--------------ACCESS POINT------------- 
  ssidAP = EEPROMread(EEssidAPLength, EEssidAPBegin);
  passAP = EEPROMread(EEpassAPLength, EEpassAPBegin);
  if ((ssidAP.length() > 32) || (ssidAP.length() == 0) || (passAP.length() > 32) || (passAP.length() == 0) || (digitalRead(ResetPin) == LOW)) { //request is OK?
    ssidAP = SssidAP;
    passAP = SpassAP;
    kanalAP = SkanalAP;
          EEPROMwrite (ssidAP, EEssidAPLength, EEssidAPBegin);
          EEPROMwrite (passAP, EEpassAPLength, EEpassAPBegin);
          EEPROM.write(EEkanalAP, kanalAP);
          EEPROM.commit();
  }
  else {    
      kanalAP = EEPROM.read(EEkanalAP);
      if ((kanalAP < 1) || (kanalAP > 13))
        kanalAP = SkanalAP;
  }

  WiFi.mode(WIFI_AP_STA);  //AP & client
  
  WiFi.softAP(ssidAP.c_str(), passAP.c_str(), kanalAP);    //Start AcessPoint
  WiFi.softAPConfig(Ip, Gw, Sb);  //set the IP for Z21

  //---wait for serial to get ready!---
  //the pin receiving the serial input data is GPIO3 = RX0
  serialbaud = detRate(3);  // Function finds a standard baudrate of either
                              // 1200,2400,4800,9600,14400,19200,28800,38400,57600,115200 
  Serial.begin(serialbaud);  //UDP to Serial Kommunikation
  Serial.flush();   //make serial empty and start!
  
  tryWifiClient();  //Try to connect to WiFi
 
  //Start the HTTP server
  server.begin();
  
  Udp.begin(localPort);   //open Z21 port

  #if defined(DEBUG)
  Serial.print("AP: ");
  Serial.println(ssidAP);
  Serial.print("PW: ");
  Serial.println(passAP);
  Serial.print("Cannel: ");
  Serial.println(kanalAP);
  #endif
}

/**********************************************************************************/
void loop() {
  //If there's UDP data from WLAN available, read a packet:
  byte packetSize = Udp.parsePacket();
  if (packetSize) {
    IPAddress remoteIp = Udp.remoteIP();
    Serial.write(addIP(remoteIp, Udp.remotePort()));  //send and save client Identity
    
    // read the packet into packetBufffer
    char packetBuffer[packetSize]; //buffer to hold incoming packet
    byte len = Udp.read(packetBuffer, packetSize);
    if (len > 0) {
      packetBuffer[len] = 0;
    }
    Serial.write(packetBuffer, packetSize); //send to Zentrale (trenne erst dort kombinierte Pakete!)
  }

  count++;
  if (count == 0 && sendTOO != 0xFF) {  //if no Serial receive clear read data buffer!
    sendTOO = 0xFF;
    outDcount = 0;
  }
    
  //receive data
  if (Serial.available() > 0) {  //Senden UDP over WLAN
    receiveEvent(Serial.available());
  }
      
  //Nutzungszeit IP's bestimmen
  unsigned long currentMillis = millis();
  if(currentMillis - IPpreviousMillis > interval) {
    IPpreviousMillis = currentMillis;   
    for (byte i = 0; i < countIP; i++) {
        if (mem[i].time > 0) 
          mem[i].time--;    //Zeit herrunterrechnen
    }
  }  
  
  webconfig();  //create Website

  delay(1);   //to let the wifi work
} 

Da qui in poi non sono riuscito più ad andare avanti...dov'è il problema?

[sal727]

Lo sketch non c'entra nulla sull'errore, il problema è che non riesce a comunicare con la scheda, forse hai una scheda non compatibile con il settaggio che hai fatto, guarda esattamente il modello della scheda se è lo stesso che abbiamo usato in questo tread, magari posta una foto della scheda.

[ClaBos]

La scheda è una wemos. Nella selezione della scheda ho selezionato la wemos ma non nonostante questo non vuole caricare lo sketch.

[ClaBos]

https://m.banggood.com/Wemos-Mega-WiFi- ... s=myorders

Questa è la mia scheda

[sal727]

La scheda è quella
domanda:
quando carichi lo sketch lo tieni premuto il pulsante?

[ClaBos]

Purtroppo si.
Ho notato che nelle fasi successive, quando ho caricato gli sketch, i led a bordo scheda lampeggiavano mentre in questo caso, premuto o meno il pulsante, nessun led lampeggiava.

Però ti chiedo... La mia wifi di casa, per caricare lo sketch, centra qualcosa oppure no?

[sal727]

Oltre al pulsante hai spostato lo swich?
come vedi nell'immagine che ti ho postato
la wifi?
per caricare lo sketch vai con la usb

[ClaBos]

Ho provato sia con swich in 0 che in 1 sempre tenendo premuto il pulsante ma mi dava sempre lo stesso errore.

Per caricare lo sketch uso il cavo usb.

[ClaBos]

La wifi di casa non c'entra niente con lo sketch?

Cioè non devo inserire da nessuna parte user e password per accedere alla rete wifi?

[sal727]

La procedura è questa:
switch su txD0 e rxD0 senza premere nulla carichi lo sketch per arduino Mega
switch su txD3e rxD3 tenendo premuto il pulsante per tutto il tempo di carica dello sketch per programmare il modulo wifi della scheda
naturalmente con i switch numerati nella posiozione corretta come da istruzioni e puoi anche vedere nell'immagine che ho postato prima
se non funziona allora ha qualche problema la scheda

[ClaBos]

Ok Salvatore. Domani mattina mi rimetto sotto e rifaccio le prove.

Chiedo ancora una cosa:i driver per usb su CH340 sono necessari? Io non li ho caricati... E comunque trovo solo la versione CH341...

[sal727]

Si ci vogliono perchè la scheda non è originale, ma se non avevi i driver non ti avrebbe riconosciuto la scheda, avrai verificato su quale porta com è la scheda prima di iniziare e se non ti dava nessun errore vuol dire che i driver li aveva

[ClaBos]

Si mi indicava COM 1 O COM 4..nel mio caso era COM 4..infatti nel caricare lo sketch per Arduino mega è andato tutto liscio al primo colpo.. Quindi i driver sicuramente erano apposto.