sâmbătă, 31 decembrie 2016

Retea privata Dynamic DNS cu ESP8266 ( partea 2 )

Client si Server Dyn DNS - versiunea Arduino


            Cind am hotarit pentru prima oara sa scriu programe pentru NodeMCU, am avut de ales intre limbajele eLua si Arduino. Cistigator a fost eLua deoarece era mult mai apropiat de limbajele pe care le cunosc eu. Cu timpul am descoperit ca datorita simplitatii, limbajul eLua este foarte limitat. Atunci, de voie-de nevoie, am decis sa invat limbajul Arduino. Cu ajutorul unui tutorial simplu, aproape totul intr-o singura pagina, am inceput, incet-incet, sa il invat. La scurt timp au aparut si primele rezultate. Dar cea mai mare provocare a fost cind am luat hotarirea sa-mi traduc propriile programe din eLua, in Arduino. Desi rezultatele nu se aseamana cu sursele lor, am reusit sa implementez majoritatea functiilor si facilitatilor din programele sursa. Personal, cred ca am reusit. Azi fac public sursele programelor Server si Client Dyn DNS versiunea Arduino. Nu ma astept sa fie perfecte si probabil pe alocuri mai pot fi cosmetizate, dar garantez ca sint perfect functionale. Cel mai greu a fost implementarea agendei in care se memoreaza numele clientilor si IP-urile acestora. Sincer, in eLua era chiar mai simplu. Sper ca cineva, cu mult mai multa experienta, sa corecteze codul meu. 
Deoarece 2016 este la final si 2017 bate la usa, urez tuturor, 
La multi ani cu multa sanatate si prosperitate !

luni, 19 decembrie 2016

Retea privata Dynamic DNS cu ESP8266 ( partea 1 )

            Intotdeauna cind vei dori sa accesezi de la distanta prin internet un dispozitiv, o camera IP, un mic server sau un simplu senzor, te vei lovi mereu de aceeasi problema: unde si la ce adresa din internet se gaseste dispozitivul tau? Asa am patit si eu, la inceput, cind m-am hotarat sa accesez informatia de pe un mic server cu NodeMCU dispus la mine acasa. Dar problema expusa nu este noua, ea fiind rezolvata de multi altii inaintea mea. Solutia adoptata de catre acestia consta in apelarea la serviciile de redirectionare IP ale unor site-uri precum DynDNS, No-IP, FreeDNS, etc. La inceput am fost tentat si eu, sa folosesc un astfel de serviciu dar studiind bine oferta providerului meu de internet, RCS RDS, am constatat ca nu mai era necesar. Acesta ofera serviciul gratuit de redirectionare IP pentru clientii sai. Astfel, setand un domeniu pe site-ul lor si un port forward pe routerul meu am facut posibila aparitia mea pe internet la adresa ywar2.go.ro:9876. Dar lucrurile nu stau intotdeauna asa bine. Cind m-am hotarat sa fac aceeasi setare intr-o alta locatie a familiei mele, aceasta nu mai era posibila. Providerul local nu ofera servicii de redirectionare. Astfel, cautand solutii pe internet, mi-a venit ideea: de ce nu mi-as face propria mea retea privata de redirectionare IP? Oare ar fi posibil? De ce as avea nevoie?
            Fara sa intru in amanunte si descriind aspecte la care nu ma pricep, am constatat ca majoritatea retelelor sint constituite dintr-un server dispus la un IP fix, unul sau mai multi clienti care au IP-urile dinamice si un protocol de comunicatie intre acestia. Protocolul este simplu si consta dintr-un mesaj prin care clientul isi face cunoscuta identitatea si apartenenta la retea, iar serverul memoreaza identitatea si IP-ul la care se afla acesta. La aparitia unui vizitator care doreste sa ia legatura cu clientul, serverul trimite adresa IP unde se afla acesta, astfel stabilindu-se legatura intre vizitator si client. Daca asa stau lucrurile, atunci de ce as avea nevoie? In primul rand de un IP fix sau relativ fix, de un server, un client si un protocol de comunicatie intre acestia. IP fix sau relativ fix am de la providerul meu de internet. El este relativ fix deoarece in realitate este dinamic, dar adresa la care acesta este gasit, respectiv ywar2.go.ro, este fixa. Pentru server si client m-am hotarit sa folosesc modulele cu ESP8266, respectiv NodeMCU. Sint simplu de folosit, mici si ieftine, si se conecteaza usor la internet. In privinta protocolului de comunicatie m-am inspirat din mesajele pe care le trimit furnizorii de astfel de servicii pe care datorita simplitatii retelei le-am adaptat cerintelor minime de functionare. Iata cum arata in realitate reteaua mea privata !



Protocolul de comunicatie


           Pentru functionarea corecta a retelei periodic, la un anumit interval de timp, clientul trebuie sa comunice cu serverul. Acesta trebuie sa anunte de existenta si apartenenta sa la retea. Personal, datorita simplitatii retelei, dar si datorita faptului ca este privata, am renuntat la partea de mesaj cu apartenenta acestuia. Aceasta consta intr-o parola prin care isi confirma autenticitatea. Nu am si nu intentionez sa am asa multi clienti incat sa apara conflicte la nivelul serverului. Serverul confirma receptia mesajului, detecteaza IP-ul clientului si il memoreaza alaturi de identitatea acestuia. Cind un vizitator interogheaza serverul despre un client, serverul trimite vizitatorului o pagina HTML de redirectionare a acestuia catre adresa IP la care se gaseste clientul cautat. In continutul paginii HTML se gaseste un script care se executa automat si care directioneaza browserul clientului la adresa IP solicitata. Continutul paginii HTML este inspirat exact de aici. Iata mai exact schimbul de mesaje intre client, server si vizitator.


Serverul


            Gestionarea retelei, mai precis evidenta clientilor, detectarea IP-urilor si redirectionarea vizitatorilor catre destinatari este deservita de catre server. Desi, la prima vedere, pare ca acesta are destul de mult de lucru, in realitate nu este asa. Cea mai mare parte din timpul functionarii sale este ocupata cu traficul si evidenta clientilor, iar cea mai mica parte din timp, cu raspunsul la interogarea vizitatorilor. Ce face concret acesta ? Ori de cate ori un client trimite un mesaj de improspatare a datelor, continutul acestora este analizat, este extras numele clientului, detectat IP-ul acestuia si apoi memorate impreuna. Daca toate acestea sint realizate, serverul confirma clientului receptia corecta a mesajului. Desi nu am prevazut explicit acest caz, cind continutul mesajului este alterat, severul raspunde clientului cu pagina de redirectionare catre o pagina WEB care avertizeaza eroarea. La aparitia unui vizitator serverul poate raspunde in mai multe moduri. Daca vizitatorul interogheaza doar adresa serverului, fara numele unui client, acesta raspunde cu o pagina WEB prin care se identifica. Atunci cind interogarea contine si numele unui client, serverul verifica clientii din memoria sa si daca acesta exista, trimite pagina de redirectionare cu IP-ul clientului cautat. Daca clientul nu exista sau continutul este alterat, este redirectionat catre o pagina WEB care avertizeaza eroarea. Acestea sint pe scurt toate procesele pe care le desfasoara serverul. 

Clientul


            Rolul clientilor in aceasta retea este acela de a comunica serverului numele clientilor care beneficiaza de serviciul de redirectionare. Numele clientilor alaturi de IP-urile lor vor fi memorate de catre server pentru a fi furnizate ulterior vizitatorilor. Pentru a nu aglomera inutil serverul si pentru prevenirea aparitiei de coliziuni, este indicat ca rata de reimprospatare a datelor din server sa se faca o data la 10..15 minute. Astfel serverul poate gestiona un numar mare de clienti si utilizatori. Orice conectare corecta la server, dar si deconectarea, sint indicate de aprinderea sau stingerea LED-ului de pe placa. Desi nu este indicat, temporar, pana la resetarea IP-ului sau chiar a serverului, update-ul se poate face si manual, respectand regulile din imaginea de mai sus, dintr-o pagina WEB, fara a fi necesara existenta unui modul client. Acesta este un caz particular, posibil ca o  facilitate a acestui sistem.

Realizarea practica


            Pentru crearea serverului si clientului, m-am orientat catre modulele NodeMCU. Acestea beneficiaza de o gramada de facilitati care le fac perfecte realizarii proiectului. Pentru scrierea programelor care gestioneaza serviciile acestora am folosit limbajul eLua. Nu voi intra in amanunte legat de ceea ce am scris, dar voi da lamuriri daca mi se vor cere. Programele sint open source si pot fi modificate dupa bunul plac. Ambele variante, server si client sint versiuni Lite care asigura minimul de functii necesare functionarii corecte a retelei. Toate imbunatarile de care vor beneficia acestea, vor fi publicate pe viitor. Experimentele continua !

Online Dynamic DNS Server: ywar2.go.ro:9876.
Descarca codul sursa.

Pentru realizarea proiectului m-am inspirat din:


---  73's   YO7FWS  ---

vineri, 14 octombrie 2016

Interconectare GPS - ESP8266

      Intentionez sa ma apuc de un nou proiect. Vreau sa im construiesc o baliza radio WSPR. Din schemele publicate pe internet reiese necesitatea folosirii unui GPS, pentru sincronizarea corecta a balizei radio si detectarea pozitiei acesteia. Cu ajutorul site-urilor specializate in vinzari - cumparari, am gasit la un pret destul de modic un Mouse GPS model Fortuna U2 folosit la extinderea functiilor pocket-urilor. Prima operatie pe care am facut-o a fost demontarea acestuia, inlaturarea cablurilor de legatura si conectarea unor fire subtiri necesare testelor ce vor urma. Conectarea firelor am facut-o conform figurii de mai jos. Am cautat prin seratarele mele si am gasit un modul convertor USB2Serial care dupa instalarea driverelor in Windows am constatat ca nu functiona corect, fiind compatibil cu versiuni mai vechi. Ce este de facut?  Cum pot vizualiza semnalele NMEA receptionate de GPS daca nu am niciun adaptor de port serial? Astfel mi-a venit ideea: il conectez pe serialul lui NodeMCU. La treaba, urmeaza experimente !

Schema conectare GPS - NodeMCU V3

      Pentru a vizualiza semnalele NMEA care sint transmise prin intermediul portului serial cu ajutorul modulului NodeMCU imi era necesar realizarea unui bridge de date intre portul serial al acestuia si internet. Pentru aceasta am scris un mic program care transfera datele astfel incit ele pot fi vizualizate cu ajutorul unui client TCP din internet. Dupa citeva teste programul a fost gata si am trecut la experimente. Dupa conectarea iesirii de date de la GPS la modulul NodeMCU si alimentarea acestuia am inceput a vizualiza pe internet datele transmise de acesta. Nu mica mi-a fost mirarea sa constat ca erau caractere alfanumerice aleatoare, nimic din ce mai vazuzesem pe internet. M-am intors dinou la browser si dupa citeva cautari descopar in descrierea unui videoclip recomandarea: Baud rate: 4800, inverted signal levels. Desii am incercat software sa inversez semnalele inainte de a le transmite pe internet, rezultatele au fost un esec total.  Daca nu am reusit software atunci sa incercam hardware. Am luat un tranzistor BC171  si cu o rezistenta de 10K si cu ajutorul lor am construit o poarta inversoare pe care am conectat-o intre iesirea de date GPS si intrarea modulului NodeMCU. Am pornit montajul si satisfactie maxima: au aparut datele mult asteptate. Concluzie: GPS-ul functioneaza. Pozitionat in dreptul ferestrei a receptionat cu destula intirziere patru sateliti si mi-am putut vedea coordonatele pozitie mele.

Semnalele NMEA receptionate de GPS

      Pentru cine este interesat pun la dispozitie schema de interconectare GPS cu NodeMCU si softul pe care l-am folosit pentru a viziona datele din internet.
      Concluzie: inca un experiment reusit!

            GPS2Internet Bridge.lua

            Pentru realizarea experimentului m-am inspirat din:
            https://www.youtube.com/watch?v=NrUjZwZolA4
            http://www.blitzortung.org/Documents/TOA_Blitzortung.pdf


---  73's   YO7FWS  ---




vineri, 3 iunie 2016

Trimiterea mesajelor Email cu ajutorul lui ESP8266


Navigind pe internet in cautarea diferitelor aplicatii pentru modulul ESP8266 am fost placut surprins sa gasesc un mic program cu ajutorul caruia acest modul poate trimite mesaje de tip email. Programul a fost publicat de utilizatorul Miguel pe site-ul Github .
             Dupa ce am citit codul sursa, la sfatul autorului mi-am creat un cont de email pe site-ul
AOL.com. Am modificat codul sursa cu datele contului meu si l-am incarcat in modul. Dupa restart, in cca 10…20 secunde, timp in care modulul s-a preocupat cu logarea si trimiterea unui email, am fost anuntat de un notificator ca am primit un email pe adresa mea de Yahoo. Surpriza mare: functioneaza !
             Am fost foarte bucuros de aceasta, deoarece trimiterea independenta a unui mesaj email, fara interventia utilizatorului, poate crea noi oportunitati pentru viitoare proiecte si experimentari. Cel mai bun exemplu este monitorizarea unui proces oarecare si notificarea prin email in cazul unei modificari al acestuia. Daca tot experimentez mini Dx Cluster-ul folosind acest modul, ce ar fi daca as incerca sa imi implinesc un vis mai vechi: sa am propriul Dx Robot precum cel de la adresa de aici. Adica un program care sa monitorizeze toate spoturile de pe cluster, sa le filtreze, i-ar la aparitia unor indicative cautate, a unor legaturi intr-o anumita banda, s-au a unei propagari deoasebite, sa fiu notificat in timp real prin email. Mi se pare o idée buna, mai cu seama ca poate fi facuta cu un modul de dimensiunile unei jumatati de pachet de tigari care poate fi alimentat cu doua baterii de telecomanda. In curind voi incepe noi experimentari, iar rezultatele acestora le voi face publice aici.
             Deoarece am rezolvat problema uploadului pentru codul sursa, solutia fiind Google Drive, nu voi publica codul sursa, dar il voi pune si eu la dispozitie, desii acesta poate fi descarcat si de pe Github.
             Inca odata mentionez codul sursa nu-mi apartine, eu nu am facut decit sa il testez.

send_email_smtp.lua
base64.lua


---  73's   YO7FWS  ---



sâmbătă, 21 mai 2016

mini DX Cluster cu ESP8266 ( partea 2 )

Si experimentele continua…
      In prima parte solutia pe care am gasit-o la realizarea proiectului consta in crearea unui client TCP care se conecta la DX Cluster ( DXC ) si apoi crearea unui server TCP care gestiona conectarile clientilor la acesta. Transferul datelor, a spoturilor in sine, se facea odata la 100 msec cu ajutorul unui timer. Solutia aceasta nu mi-a placut deloc in sine, deoarece mi se parea corect ca trimiterea spoturilor catre clientul serverului, trebuia sa se faca ‘on event’, adica in momentul receptionarii unui spot. Plecind de la aceasta dorinta am gasit solutia optima, si probabil cea mai corecta. Mai intii creez serverul TCP, serverul care va gestiona conectarea clientilor catre DXC si il pun in asteptarea unui viitor client. Cind un client se conecteaza la server, creez o conexiune TCP si ma conectez la DXC, iar in momentul receptionarii spoturilor le trimit catre clientul serverului. Cind clientul se deconecteaza, conexiunea TCP cu DXC se inchide, serverul revenind dinou in starea de asteptare.  Aceasta solutie functioneaza foarte bine si astfel nu voi pierde niciun spot receptionat, iar serverul va va fi ocupat decit pe durata conectarii clientului sau.
      Pe timpul experimentelor am constatat si alte evenimente paralele cu aplicatia, evenimente nedorite. Citeva dintre acestea au fost: intreruperea conexiunii de internet dintre routerul meu si provider sau intreruperea conexiunii wireless. Deoarece in programul scris de mine nu au fost prevazute asemenea momente, modulul raminea fara conexiune si chiar daca totul revenea la normal, acesta nu se mai reconecta deloc.  Pentru rezolvarea acestor probleme, am setat un timer care odata la 10 secunde se verifica starea conexiunii wireless si daca se constata nereguli, modulul se restarteaza automat. Deasemenea, pentru a prevenii eventuale disfunctionalitati in conexiunea cu internetul, am prevazut ca odata pe ora, numai daca nu am un client conectat, modulul sa se restarteze automat, indiferent de starea conexiunilor wireless si internet in sine. Am simulat diferite momente, respectiv pierderea conexiunii wireless sau internet si apoi revenirea acestora. Modulul s-a comportat corect restabilind cu succes conexiunea.
      Am adaugat si unele briz-briz-uri, caci altfel nu se poate, conectarea unui client la server este semnalizata de un LED ce se gaseste pe modulul ESP8266.
      Deoarece pina voi rezolva problema uploadarii codului sursa arhivat pe blog, il voi publica aici, in continuare.
      Daca nu fac experimente si modulul este liber, puteti sa incercati functionarea conexiunii,  conectindu-va cu un program client TCP la adresa: http://ywar2.go.ro:9876
      Acum ma grabesc sa inchid, deoarece mi-a mai venit inca o idée…

---------------------------------------------------------------
--                         v1.5.7                            --
---------------------------------------------------------------
-- se verifica existenta conexiunii WiFi la fiecare 10 secunde
-- din ora in ora restartez automat modulul daca nu am niciun
-- client conectat
-- se afiseaza ip-ul userului conectat
-- conectarea utilizatorilor este semnalizata prin LED-ul WiFi
---------------------------------------------------------------

    -- setez id wireless si parola
    ssid = "YO7FWS"
    pass = "********"

    -- configurez wifi in client mode
    wifi.setmode(wifi.STATION)

    -- wifi config start
    wifi.sta.config(ssid,pass)
    
    -- wifi connect
    wifi.sta.connect()
    
    -- variabila folosita la contorizarea unei ore
    t = 0

    -- variabila care indica daca am un utilizator conectat
    -- true -> conectat, false -> deconectat
    conectat = false
    
    -- pinul la care este conectat ledul de pe modulul WiFi
    -- led ON -> client conectat, led OFF -> client deconectat
    pin = 4
    
    --  setez pinul ca iesire
    gpio.mode(pin, gpio.OUTPUT)
    
    -- verific daca mai sint conectat la reteaua WiFi
    -- daca sint deconectat atunci restart modul
    tmr.alarm(0, 10000, 1, function()
        if wifi.sta.status() == 1 then node.restart() end
        if wifi.sta.status() == 2 then node.restart() end
        if wifi.sta.status() == 3 then node.restart() end
        if wifi.sta.status() == 4 then node.restart() end

        -- cronometrez o ora
        t = t + 1

        -- cind a trecut o ora, daca nu am niciun client
        -- conectat, atunci restart modul
        -- 1[h]*60[min]*60[sec]*1000[msec]/10000[msec] = 360
        if (t >= 360) and (conectat == false) then node.restart() end
    end)

    -- creez un server viitor dx cluster
    server = net.createServer(net.TCP,28800)
    
    -- variabile care memoreaza spoturile ptr a fi retransmise
    spot = ''
    
    -- serverul sta in stand by pina ce se conecteaza un client 
    -- cind un client s-a conectat atunci...
    server:listen(9876, function(server)

        -- creez o conexiunea client la un dx cluster
        client = net.createConnection(net.TCP, false)
    
        -- ma conectez la dx clusterul lui N2YO
        client:connect(7300,"dxc.n2yo.net")
        
        -- debugg
        print('Client conectat')
        
        -- aprind ledul
        gpio.write(pin, gpio.LOW)

        -- indic client conectat
        conectat = true
        
        -- interoghez serverul despre IP
        ip,port = server:getpeer()
        
        -- trimit un mesaj de intimpinare
        server:send('Bine ati venit pe Dx Clusterul meu\nVizionare placuta !\nIP-ul dvs este '..ip..'\n')
        
        -- cind se receptioneaza un mesaj sau spot
        client:on("receive", function(sck, spot) 
        
            -- daca mesajul este de logare atunci transmit clusterului indicativul
            if spot == 'login: ' then 
                client:send("yo7fws\n") 
            else 
                -- altfel transmit clientului meu spotul  
                server:send(spot)
            end
            
            -- debugg
            --print(spot)
        end)
        
        -- cind clinetul se deconecteaza 
        server:on('disconnection', function(server)
        
            -- inchid conexiunea cu dx cluterul
            client:close()
            
            -- debugg
            print('Client deconectat') 


            -- indic client deconectat
            conectat = false

            -- resetez contorul de restart la 1 ora
            t = 0
            
            -- sting ledul
            gpio.write(pin, gpio.HIGH)
        end)
    end)
    
    
---------------------------------------------------------------
--                     YO7FWS - MAI 2016                     --
---------------------------------------------------------------

Pentru gasirea unor solutii pe timpul scrierii programului m-am mai inspirat si de aici:

vineri, 15 aprilie 2016

mini DX Cluster cu ESP8266 ( partea 1 )

                De curind am descoperit pe internet un modul WiFi gestionat de un microcontroler Tensilica capabil de conexiuni TCP/IP, construit de o firma chineza Espressif. Acest modul se cheama ESP8266 si pina la momentul actual a fost construit in mai multe versiuni. Nu voi intra foarte mult in detalii legate de capabilitatile acestui modul deoarece ele sint descrise detaliat pe pagina producatorului cit si pe o multime de pagini din internet. Acest modul poate fi programat de utilizatori folosind diferite limbaje de programare, dintre cele mai utilizate fiind Lua, C++ si Arduino, dar si comenzile 'AT', atunci cind folositi un microcontroler extern. Din nefericire pentru mine niciunul dintre aceste limbaje nu imi este bine cunoscut, dar uitindu-ma peste sursele diferitelor aplicatii publicate pe internet, Lua se apropie cel mai bine de cunostintele mele in programare. Asa ca de voie, de nevoie, m-am apucat sa invat din mers... LUA. Pentru a scrie in Lua este nevoie ca in  modul sa fie incarcat un interpretor, respectiv firmware-ul NodeMCU. Va sfatuiesc sa intrati pe pagina oficiala NodeMCU si sa va uitati pe diferitele programe date ca exemplu, mai mult ca sigur o sa ramineti pe ginduri.
                Deoarece marea majoritate a modulelor sint construite minimal, pentru aplicatii simple unde este nevoie decit de alimentare si citeva conexiuni cu exteriorul, eu am optat pentru o placa de dezvoltare. Principalele motive sint: 
- usor de programat deoarece contine interfata USB - Serial
- alimentarea se face atit prin intermediul portului micro USB cit si prin pini dedicati. Deobicei o alimentez din USB-ul calculatorului, iar cind sint plecat folosesc incarcatorul telefonului mobil
- port serial prin pini dedicati pentru conexiuni cu exteriorul
- si nu in ultimul rind, o gramada de porturi GPIO
               Placa de dezvoltare pe care am cumparat-o este 'teoretic' construita de firma LoLin, am gasit-o pe un site de vinzari - cumparari din tara noastra.


Softul folosit de mine pentru incarcarea programului scris in Lua este ESP8266 LuaLoader.


                Programul in sine redirectioneaza toate spoturile transmise de un DX Cluster ( DXCL ) catre un client TCP, conectat de aceasta data la serverul ESP8266. Nu am incercat conectarea si retransmiterea in acelasi timp a spoturilor din doua sau mai multe clustere, dar o voi incerca pe viitor. Ceea ce este inedit la aceasta aplicatie, este faptul ca inafara de alimentare si citeva setari in routerul de internet, avem cel mai mic si mai simplu server si client TCP. Ca facilitati, doar folosind clientul TCP al DXCL, se pot implementa in acesta filtrarea spoturilor. De exemplu spoturile care anunta propagarea Es sporadic sau Aurora, pot fi filtrate si retransmise catre un client. Alta posibila aplicatie ar putea fi anuntarea clientului prin trimiterea unui SMS sau email, a unui spot anume. Si posibiltatile mai pot fi multe altele. 
               Simplitatea presupune si dezavantaje. Un dezavantaj observat de mine este faptul ca serverul nu poate gestiona mai mult de un client. In momentul conectarii celui de al doilea client, toate spoturile sint redirectionate catre acesta, primul client nemai receptionind nimic. Probabil functioneaza si aceasta, sau poate nu, ramine de studiat pe viitor.
                O problema pentru mine a fost extragerea spotului receptionat de catre clientul DXCL si retransmiterea lui catre server. Desii am incercat mai multe variante de a reimprospata datele din server cu cele din clientul DXCL, nu am avut niciun rezultat multumitor. Singura solutie, care marturisesc ca nu mi-a placut, a fost sa fac refresh cu ajutorul unui timer setat arbitrar de mine la 100 msec. Un dezavantaj ar fi ca daca in decursul a 100 msec vin doua spoturi, unul dintre ele se va pierde sigur. O alta solutie incercata de mine, cu sanse foarte mari de reusita era sa transmit datele pe iesirea portului serial si printr-o bucla, sa le reintroduc pe intrarea aceluiasi port. Functioneaza, chiar foarte bine, dar din cauza logo-ului din restartul modulului, NodeMCU 0.9.6 build 20150704  powered by Lua 5.1.4, acesta nu poate restarta corect programul, facind restart continuu. Problema se putea rezolva cu ajutorul unei porti exterioare comandata intirziat de un registru GPIO, dar atunci proiectul isi pierde din farmecul simplicitatii lui. Pe partea de client, spoturile transmise de serverul ESP8266, pot fi vizualizate cu ajutorul unui client TCP. Pe smartphone am folosit aplicatia TCP Client pe care o descarcati din Google Store, iar in Windows am folosit aplicatia Hercules Setup Utility.
Iata in continuare programul meu:

---------------------------------------------------------------
--                         v1.4                              --
---------------------------------------------------------------
 -- setez id wireless si parola
 ssid = "YO7FWS"
 pass = "********"

 -- configurez wifi in client mode
 wifi.setmode(wifi.STATION)

 -- numai pentru debug, afisez modul
 --print('set mode=STATION (mode='..wifi.getmode()..')\n')

 -- setez SSID si parola wifi
 wifi.sta.config(ssid,pass)

 -- ma conectez wifi
 wifi.sta.connect()

 -- creez o conexiunea client la un dx cluster
 client = net.createConnection(net.TCP, false)

 -- creez un server viitor dx cluster
 server = net.createServer(net.TCP)

 -- variabila care memoreaza portul din routerul meu
 -- unde poate fi accesat clusterul
 port = 9876

 -- variabile care preia spotul de la clientul dx cluster
 -- si il transmite viitorului server dx cluster
 spot = ''

 -- variabila care memoreaza ultimul spot retransmis
 mem = spot

 -- atunci cind clientul a receptionat un mesaj sau spot
 client:on("receive", function(sck, c) 
    -- daca cere sa ma loghez atunci transmit indicativul
    if c == 'login: ' then client:send("yo7fws\n") end  
    -- extrag spotul sau mesajul pentru a fi retransmis 
    spot = c
 end )

 -- atunci cind la server s-a conectat un client 
 server:listen(port, function(server)
    -- la fiecre conectare a unui client afisez un logo
    server:send("Bine ati venit pe clusterul lui YO7FWS\n\n")
    -- nu-mi place asta, dar n-am gasit nicio solutie
    -- execut odata la 100 msec
    tmr.alarm(0, 100, 1, function()
        -- daca spotul este diferit de ceea ce a fost 
        -- retransmis anterior, atunci
        if mem ~= spot then
            -- numai pentru debug, afisez spotul
            --print(spot) 
            -- transmit clientului spotul
            server:send(spot)
            -- memorez acest spot pentru 
            -- a nu-l retransmite dinou
            mem = spot
        end
    end )
 end)

 -- ma conectez ca client la dx clusterul lui N2YO
 client:connect(7300,"dxc.n2yo.net")
---------------------------------------------------------------
--                     YO7FWS - APR 2016                     --
---------------------------------------------------------------

                Proiectul descris aici nu este mare lucru. Este o solutie din alte multe altele. Un simplu smartphone face mult mai mult decit aici. Dar placerea este cu mult mai mare cind am gasit eu rezultatul la provocarea: ia sa vedem, eu pot ? Si am putut...
Pe curind !

Cind nu fac experimente, puteti accesa clusterul pe adresa: http://ywar2.go.ro:9876

Ca surse de inspiratie am folosit:

Si totul a plecat de aici: