[ESP 12F] Vanaf het begin - ESP8266

Als je die Lua troep erin gestopt hebt, werken de AT commando's niet meer. Die werken alleen met de originele firmware.
Ik heb er ooit kort mee gewerkt, maar aangezien er geen enkele demo code te vinden was die zonder crashes, foutmeldingen of andere ongein werkte, heb ik 'm er snel afgeknikkerd...

Dus, als ik het goed begrijp : de geflashte ESP 12F werkt, maar kan niet overweg met AT-commando's ?

Ik ben echt een beginner met deze ESP8266 en snap er nog bitter weinig van. Zo begrijp ik niet dat een ESP 12F ueberhaupt geflashed moet worden. Maar dat komt wellicht omdat ik er met een "AVR-blik" tegen aan kijk: Je schrijft broncode om de chip te laten doen wat je voor ogen hebt. Vervolgens brandt je dat naar de AVR.

Met de ESP-12F krijg ik voorzichtig het idee dat het een soort computertje is, waar je een vorm van Operating System moet installeren (lees : flashen). En daar bovenop kunnen diverse bestandjes met broncode gedownload worden. En de broncode wordt opgemaakt in ESPlorer en ook daarmee geschreven naar de ESP 12F. Klopt dat ?

oxurane,

Klopt, LUA is vergelijkbaar met Basic, op de ESP-12F draait een interpreter voor LUA waar jij de bestanden met LUA commando's naar upload. Je kan LUA scripts ook complileren, dan nemen ze minder ruimte in.

Ik deel de ervaring van Arco mbt NodeMCU, heb hier ook een ESP-12F, ik gebruik LuaLoader. Er is genoeg LUA code te vinden, NodeMCU is populair voor IOT projecten, veel werkt idd niet of is instabiel. Debuggen betekend aanpassen, uploaden en testen , daar word je algauw zat van als je een uC gewend ben met een fatsoenlijke debugger die meeloopt tijdens de code uitvoer.

Hmm,. het wordt een beetje verwarrend voor me. NodeMCU is het "experimenteer-printje/board", waar ik een binary file voor heb gevonden en geflashed.

Zoals ik het nu begrijp, is de gekozen bin-file die ik geflashed heb, ongelukkig gekozen. Het is een "OS" waar weinig documentatie over te vinden is, maar bovenal veel fouten bevat wat betreft het interpreteren van LUA-broncode. Tenminste, dit haal ik uit het verhaal van Arco.

Uit het stukje van Roland begrijp ik dat de keuze voor ESPlorer ook niet handig is. LuaLoader zou een betere programmeeromgeving zijn.

Bedenk wel dat het allemaal nog steeds aardig verwarrend voor me is, zeker omdat ik hier als beginner bezig ben. Het is dus nog een beetje abracadabra voor me. Ik wil graag begrijpen hoe het nu in elkaar steekt. Laat ik het weergeven zoals ik denk dat het zit :

ESP8266 en OS
De ESP12 is een printje en heeft een ESP8266 aan boord. LUA is een programmeertaal. De ESP8266 heeft een "OS" nodig om te kunnen werken met LUA-code. Dit "OS" is een binary file, die je kunt downloaden. (Ik heb klaarblijkelijk voor de verkeerde gekozen)

OS
De binary file die ik heb gebruikt, kan met LUA-code werken op een ESP8266. Het probleem is dat dit "OS" onbetrouwbaar werkt, wat resulteert in problemen, zoals crashes, foutcodes e.d. Het achterhalen van deze problemen is schier onmogelijk, vanwege slechte / minieme documentatie hierover. Daarnaast kan het niet overweg met "AT"-commando's.
Er schijnt ergens "de originele versie" te zijn, die beter werkt en ook met "AT"-commando's overweg kan.

Programmeer-omgeving
ESPlorer is een programma, waarmee LUA-script / broncode geschreven kan worden. Dit programma kan een geschreven script downloaden naar het experimenteer-print. Zo is ook LuaLoader een programmeeromgeving voor LUA-script / broncode.

[Vragen]
Voor mijn begrip -en wellicht CO'ers die meelezen langs de lijn- stel ik dan maar de volgende vragen :

1) Klopt bovenstaande uitleg ?

2) Welk "OS" (lees : binary file) kan ik het beste flashen in het experimenteerboardje om te kunnen programmeren in LUA, incl. het gebruik van "AT"-commando's ? Zou je daar een link van kunnen geven, dan ben ik al een stukje geholpen. Met een link van een beschrijving wat dan (stap voor stap) moet gebeuren, wordt het nog mooier. In dat geval help je anderen ook, zodat zij ook snel aan de slag kunnen met een experimenteerprintje of ESPxx.

3) Welk programma voor het maken / wegschrijven van LUA-script kan het beste gebruikt / geinstalleerd worden ?

LuaLoader is mi niet beter of slechter dan ESPlorer. NodeMCU is bekend binnen IOT, de ESP8266 + regulator+ serieele interface worden dan ook onder deze naam aangeboden.

http://www.nodemcu.com/index_en.html

LUA is geen OS, het is een stukje software wat LUA commando's interpreteerd.

Via de Arduino IDE kun je ook de ESP8266 programeren, dit bespaard je de hele overhead van de LUA interpreter. Ben ik mee bezig geweest, ligt op het moment stil, andere prioriteiten.

http://hackaday.com/2015/03/28/arduino-ide-support-for-the-esp8266/

Misschien is Blynk een oplossing?

Screenshot

De opstelling met een ESP01 module die hier al enkele weken draait als temperatuur- en barometer met een BMP180 (links).
De FTDI module rechts is enkel nodig om de software in de ESP te flashen.
Vooraan zit een 3.3V module.

De (verplichte) onderkant

Hallo oxurane,

Ik ben zelf een maand of drie ook begonnen met de esp8266. En heb toen bijna letterlijk dezelfde weg bewandeld als jij.

Heb ook gekozen voor het gebruik van een ESP12, heb daar ook voor de zekerheid een NodeMcu (clone) bordje bij besteld om eerst eens wat te testen. Voor software heb ik net als jij gekozen voor ESPlorer.

Enige verschil is dat ik gebruik heb gemaakt van deze flasher. Daarbij heb ik dus niet zelf ergens een binary file gedownload. Simpelweg de flasher uitgevoerd.

Vervolgens:
1. Open ESPlorer
2. Open de com-poort
3. Klik op de reset knop op het nodemcu bordje. Als het goed is wordt dan de versie en build nummer geprint.
4. Tik de volgende code in het linker venster en sla deze op als "init.lua"

function check_connection()
  if wifi.sta.getip()==nil then                 --Checken of we al een ip adres hebben gekregen
  else
    tmr.stop(1)                                 --Stop de timer die deze functie om de 250mS aanroept
    connected()                                 --Voer de functie "connected" uit, deze start het daadwerkelijke programma
  end
end

function connected()
  uart.write(0,"Connected to WiFi with ip: ")   --uart.write want die stuurt geen linfeed en cariage return mee
  print(wifi.sta.getip())                       --Print het ip adres
  --dofile("telnet.lua")                        --Mijn init start momenteel een telnet test
end

wifi.setmode(wifi.STATION)
wifi.sta.config("SSID","PASSWORD")              --Vul hier het SSID en wachtwoord in
wifi.sta.connect()                              --Maak verbinding

tmr.alarm(1, 250, 1, check_connection)          --Start om de 250mS de functie "check_connection" om te checken of er reeds verbinding is

5. Het "init.lua" bestand wordt nu automatisch geschreven op je hdd en op de esp. Is het laatste niet het geval (als het wel gebeurt merk je dat aan actieviteit in het rechter venster) klik dan linksonder op "Save to ESP".

De "dofile()" regel is op dit moment "gecomment", als je bovenstaande code werkend hebt kun je daar een eigen programma invullen. Let op dat je dat programma eerst naar de ESP stuurt en daarna pas de init update. Anders crasht de ESP omdat hij het opgegeven bestand niet kan vinden.

Er kunnen dus tegelijkertijd meerdere .lua bestanden op de ESP staan.

Groeten,
Emiel

EDIT: Het valt me trouwens op dat je t over de ESP-12F heb in je posts. Mocht je op dit moment testen met het NodeMcu bordje, daar zit een ESP-12E op. Volgens mij maakt dat verder niet uit, maar het viel me op.

Ik vroeg me een tijdje terug af of al iemand de nieuwe ESP-WROOM module gebruikt en of die qua firmware compatible is?
De nieuwe module wordt gemaakt door ExpressIf ( de maker van de ESP chip), dus dat lijkt me wel een voordeel...
www.circuitsonline.net/forum/view/130318

Pertinax
Ik vind het er erg strak uitzien. Eenmaal op de pagina beland van Blynk, lees ik het nodige over het gebruik met Arduino. Daarnaast dat er een soort App gemaakt moet worden, voor zowel een Android en Apple toestel. Dat is nu net wat ik wil voorkomen.

Wat ik voor ogen heb, is dat een draadloze WiFi-verbinding gemaakt kan worden met de ESP12, waarbij een webpage zichtbaar wordt.
Op deze webpage is de status zichtbaar van de AVR-module. Ik heb inmiddels hiervoor een HTML-page geschreven. In deze HTML-code zitten diverse knoppen verwerkt, die middels POST of GET aangeven welke knop is gedrukt. Het is de bedoeling dat de POST/GET wordt verstuurd naar de AVR, via de UART met de ESP12.
Vervolgens verwerkt de AVR de POST of GET-datastring en stuurt een update van de huidige status retour.
En de update, wordt verwerkt in de HTML-code, richting de gebruiker.
Ik heb specifiek gekozen voor HTML, omdat ik niet vast wil zitten aan een Android / iPhone of PC.

De ESP12 hoeft helemaal niet doorverbonden te worden met internet. Het is puur een verbinding tussen de ESP12 en een mobiele telefoon / PC.

Het komt dus neer op het volgende :

Gebruiker ---[WiFi]--- ESP12 --- [UART] --- AVR-module

Waarbij :
- Gebruiker : PC of mobiele telefoon
- WiFi : directe link tussen gebruiker en ESP12
- ESP12 : genereert een (dynamische) webpage
- UART : data-overdracht tussen ESP12 en AVR-module

Leime
Bedankt voor je info, en het duidelijk weergeven van de eerste stapjes !
Ik heb precies uitgevoerd zoals je het hebt beschreven. Ook nu merk ik dat de "AT"-commando's niet werken. Deze keer vind ik dat minder erg. Je weet niet half hoe blij ik ben dat er iemand is, die wat praktische informatie kan / wil geven , zodat de eerste stapjes gemaakt kunnen worden.

Wat betreft de ESP12F : omdat ik op een gegeven moment echt begon te twijfelen over de hardware van de ESP12F, heb ik het kapje eens verwijderd. Er zit inderdaad een ESP8266 onboard, samen met een BergMicro 25Q32 flash-geheugen (4 MByte).

Arco
De ESPxx-codering is volgens mij niets anders dan een codering voor hoe het printje eruit ziet, waarop een ESP8266 zit. Ja, en hoe de pin-aansluitingen zitten.

Hieronder de foto's (aanklikbaar voor groter formaat) van mijn ESP12F-module.

De onderkant, met de vermelding van 12-F:

De bovenkant, zonder metalen beschermkapje :

Goed, ik moet nu dus op zoek naar code, waarbij ik de NodeMCU DEVKIT (want zo heet het officieel):
- puur als zelfstandige module werkt (geen externe internetverbinding)
- om kan gaan met HTML-code
- GET / POST message kan versturen naar de AVR
- de data van de AVR kan verwerken in de HTML-code.

Ik hoop dat er hier nog veel meer info wordt geplaatst door jullie. Tot nu toe heb ik het idee dat er wel interesse is, maar nog te weinig kennis (wordt gedeeld).

-=[ UPDATE ]=-
Zo, na erg veel stoeien en rommelen met de "init.lua", heb ik het voor elkaar dat de module zichtbaar is op het netwerk :

-- Globale opstart parameters.
local IP_specs = 
      {
       ip      = "192.168.4.1",    -- IP-adres Station / AccesPoint
       netmask = "255.255.255.0",
       gateway = "192.168.4.1"
      }
local Station_Specs =
      {
       ssid ="ESP12", -- Naam waarmee de ESP12 zichtbaar is op draadloos netwerk
       pwd="1234"     -- Het paswoord om toegang te krijgen tot de ESP12
      }           

-- hoofdprogramma
wifi.setmode(wifi.STATIONAP)                 -- Instellen als Station / Access Point
wifi.ap.config(Station_Specs)                -- Instellen : SSID voor WiFi
wifi.ap.setip(IP_specs)                      -- Instellen : ip, netmask en gateway
print(Station_Specs.ssid .. ": Aktief");     -- Melding via COM-poort

gratis book over esp:
http://neilkolban.com/tech/esp8266/

Dank je voor de link. Ik kende het boek. Inmiddels heb ik het hier al aardig aan de praat gekregen. Dat is vooral te danken aan jullie reacties hier. Echter, ik wil Emiel in het bijzonder bedanken. Met zijn reactie werd ik het meest geholpen.

Wat betreft het stoeien met de NodeMCU devkit, heb ik ook al een paar blunders gemaakt : de module die in een eeuwige loop blijft. Ik liep tegen de barriere aan van de maximale bestandsgrootte voor een HTML-pagina (1460 bytes).
Na wat zoekwerk kwam ik op YouTube terecht bij een oplossing van Lefteris Stamataros. Het probleem is dat je alles van het filmpje moet overtypen. Tsja, ik had dus een paar type-foutjes gemaakt in het LUA-script voor het bestandje "init.lua", waardoor de ESP12 bleef re-booten. Daarvoor werd hier de oplossing geboden, waarbij ik een oudere flash-versie heb gebruikt.

Uiteindelijk heb ik besloten om LuaforWindows te installeren. Samen met het reeds aangeschafte boek "Beginning Lua Programming", ben ik nu eerst LUA aan het leren. Zodra de broncode werkt, zet ik het via ESPlorer over naar de NodeMCU met onboard ESP12. Deze werkwijze is omslachtiger, maar het is veiliger en erg leerzaam.

Zo, ik hoop dat met bovenstaand bericht, en vooral de opgegeven linkjes, ook anderen kan helpen, die de eerste stapjes gaan maken met een ESP8266.

-=[ UPDATE ]=-
Tot slot : ik verbaas me enorm over hoe flexibel je kunt programmeren in LUA. Daarnaast denk ik dat er een essentieel verschil is tussen de broncode bij een AVR en een LUA-script voor een ESP8266.
Wanneer ik programmeer in Bascom, maak ik een hoofdprogramma dat in een eeuwig durende do-loop blijft hangen. Daarmee blijft de AVR werken. In die loop roep ik diverse functies aan.
Ik krijg het idee dat met de ESP8266, samen met een LUA-script dit niet nodig is. Dat loopt kennelijk automatisch al in een loop. Dat is even wennen.

Smaken verschillen. Ik vond Lua een traag (interpreter) en dramatisch slecht misbaksel...
De documentatie klopt ook geen hout van; zelfs de voorbeelden bij de diverse commando's staan vol fouten en mag je zelf uitzoeken.
Ik knoop er liever een los picje aan, dan weet je in ieder geval wat je doet, en kan de module met de originele firmware blijven werken...

Tsja, ook ik zet er een microcontroller achter. Jij een PIC, ik een AVR. Ik was van plan om het allemaal met "AT"-commando's op te lossen, naar de microcontroller.

Ik liep met het idee rond om een webpage in de AVR-broncode te programmeren. De ESP12 zou puur voor de communicatie tussen PC/mobiele telefoon en AVR ingezet worden. Toen ik merkte dat de ESP12 :
- 4MByte aan geheugen heeft,
- met LUA-scripts overweg kan,
- een webpage, incl. afbeeldingen e.d. kan opslaan,
werd de keuze voor mij beduidend anders.

De AVR laat ik het werk doen om de spullen aan te sturen. De ESP8266 (lees : de ESP12) wordt het "smoelwerk" naar de buitenwereld. Op de achtergrond, verschuif ik ook het web-page gebeuren naar de ESP12, met behulp van LUA-script.

Het houdt in dat ik LUA zal moeten leren. Ik heb het er voor over. Je hebt volkomen gelijk wat betreft de fouten en het nodige zoekwerk, wat er bij komt kijken. Dat probeer ik deels op te vangen middels LuaforWindows.
Volgens mij is het gebeuren rondom de ESP8266 in combinatie met LUA nog steeds aan het door-ontwikkelen. Dat valt ook te lezen op de openingspagina van CO. Ik verwacht dat daar ook weer iets "LUA-achtigs" bij komt kijken. Dan heb ik met de huidige keuze / werkwijze alvast de stap gemaakt om daar snel in thuis te geraken.

Laat ik overigens voorop stellen dat bovenstaande, voor mij persoonlijk geldt. Ik kan me heel goed voorstellen dat je een andere motivatie hebt en dus andere keuzes maakt.

Het allerbelangrijkste van dit topic, is dat eenieder nu een beetje op weg geholpen kan worden. Ook jouw reacties / ervaringen zijn daarin belangrijk als informatie, netzoals die van de anderen die gereageerd hebben. Ik vond het een frustrerend pad wat ik heb moeten afleggen om het een en ander te leren begrijpen rondom de ESP8266. Ik hoop dat we met dit topic een enorme hobbel wegnemen voor anderen. Vandaar dat ik mijn vorige bericht uitvoerig voorzien heb van linkjes, zodat makkelijker de eerste stapjes gezet kunnen worden.

Vraagje aan TS:
waarom overweeg je niet de ESP te programmeren alsof het een Arduino is? Kan sinds ergens 2e helft vorig jaar gewoon vanuit de Arduino IDE als je via de boardmanager de ESP8266-addon hebt geïnstalleerd.

Op 8 maart 2016 14:54:20 schreef HaZee:
Vraagje aan TS:
waarom overweeg je niet de ESP te programmeren alsof het een Arduino is? Kan sinds ergens 2e helft vorig jaar gewoon vanuit de Arduino IDE als je via de boardmanager de ESP8266-addon hebt geïnstalleerd.

Inmiddels heb ik het al aardig voor elkaar, maar komen een paar andere dingen tussendoor. Binnenkort ga ik weer verder hiermee. Toch moet ik opmerken dat het op zich wel interessant is, wat je voorstelt.