Smart personliga termometer med Arduino (2 / 3 steg)

Steg 2: Lägga koden i

Koden du ser gör följande saker:

-Ansluter till WiFi-nätverk
-Får en IP-adress
-Ansluta över TCP till en server (som klient)
-Ställ in en TCP-server för vår egen.
-Läsa och Visa den temperaturavläsningen från din sensor.
-Läsa och Visa aktuell tid.
-Skjut den temperaturavläsningen till servern.
-Visa IP-adressen för servern.

Placera följande kod i din IDE, kompilera och ladda upp den till din arduino.

< p > / *** < br > ESP8266_Shield_Demo.h
SparkFun ESP8266 på bibliotek - Demo
Jim Lindblom @ SparkFun elektronik
Ursprungligt skapelsedatum: 16 juli 2015
< en href = "https://github.com/sparkfun/SparkFun_ESP8266_AT_Arduino_Library" rel = "nofollow" >

https://github.com/Sparkfun/SparkFun_ESP8266_AT_A...></p><p>this exemplet visar grunderna i SparkFun ESP8266
PÅ bibliotek. Det ska visa dig hur du ansluter till WiFi-nätverk,
få en IP-adress, över TCP att ansluta till en server (som klient),
och ställa in en TCP-server för vår egen. < /p >< p > utveckling miljö detaljerna:
IDE: Arduino 1.6.5
Hårdvaruplattform: Arduino Uno
ESP8266 WiFi sköld Version: 1.0 < /p >< p > här koden är släppt under MIT license. < /p >< p > distribueras som-är; ingen garanti ges.
************************************************************</p><p>/////////////////////
Biblioteket innehåller / /
//////////////////////
SoftwareSerial krävs (även du inte tänker på
med det).
#include
#include < /p >< p > / / /
WiFi-nätverk definitioner / /
//////////////////////////////
Ersätta dessa två strängar med namn och
lösenordet för ditt WiFi-nätverk.
CONST char mySSID [] = "***"; / Ange SSID
CONST char myPSK [] = "***"; < /p >< p > /Enter ditt lösenord

//////////////////////////////
ESP8266Server definition / /
//////////////////////////////
serverobjektet används i slutet av demo.
(Detta är endast globala eftersom det kallas i båda setup()
och loop()).
ESP8266Server server = ESP8266Server(80); < /p >< p > / / /
HTTP strängar / /
//////////////////
CONST char destServer [] = "tmce.io.tudelft.nl";
const String htmlHeader = "HTTP/1.1 200 OK\r\n"
"Content-Type: text/html\r\n"
"Anslutning: close\r\n\r\n"
"\r\n"
"
\r\n"; < /p >< p > const String httpRequest =" få < en href = "http://tmce.io.tudelft.nl/test/time.php" rel = "nofollow" >< en href = "http://tmce.io.tudelft.nl/test/time.php" rel = "nofollow" > http://tmce.io.tudelft.nl/test/time.php < /a >< /a > HTTP/1.1\n "
"Host: tmce.io.tudelft.nl\n"
"Anslutning: close\n\n"; < /p >< p > / / alla funktioner anropade från setup() har definierats under den
loop() funktion. De modularized att göra det lättare att
klistra in skisser av dina egna.
void setup()
{
Serial Monitor används för att styra demo och Visa
debug information.
{
Serial.BEGIN(9600);
} < /p >< p > serialTrigger F ("Tryck någon nyckel till börjar."). < /p >< p > / / initializeESP8266() verifierar kommunikation med WiFi
sköld, och ställer den.
initializeESP8266(); < /p >< p > / / connectESP8266() ansluter till definierade WiFi-nätverk.
connectESP8266(); < /p >< p > / / displayConnectInfo prints Shields lokala IP
och nätverket är ansluten till.
displayConnectInfo(); < /p >< p > serialTrigger F ("Tryck på valfri tangent för att ansluta klienten.").
clientDemo();

serialTrigger F ("Tryck på valfri tangent för att testa servern.").
serverSetup();
} < /p >< p > dubbel Thermister (int RawADC)
{//Function att utföra fancy matten av Steinhart-Hart ekvationen
dubbel härda;
Temp = log(((10240000/RawADC) - 10000));
Temp = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Temp * Temp)) * Temp);
Temp = Temp - 273.15; Konvertera Kelvin till Celsius
returnera härda;
} < /p >< p > void loop()
{
serverDemo();
int timmar; måste du lägga till dessa variabler
int minuter; för lagring av tidpunkten < /p >< p > {
FÅR TID
clientDemoTime (och timmar och minuter);
Visa det på serial monitorn.
Serial.Print ("servertid är:");
Serial.Print(hours);
Serial.Print(":");
Serial.println(Minutes); < /p >< p > delay(5000); fördröja - inte oveload min server...
}
int val; Skapa en heltalsvariabel
Val=analogRead(0); Läsa den analoga porten 0 och lagra värdet i val
dubbel härda;
Temp=Thermister(val);
Serial.println ("och det är:");
Serial.println(temp); Skriva ut värdet till den seriella porten
Serial.println ("grader");
Delay(1000); Vänta en sekund innan vi gör det igen
} < /p >< p > void initializeESP8266()
{
esp8266.BEGIN() verifierar att ESP8266 är i drift
och ställer upp för resten av skissen.
Den returnerar sant eller falskt--som visar om
kommunikation var successul eller inte.
True
int test = esp8266.begin();
om (testa! = true)
{
Serial.println F ("fel prata med ESP8266.").
errorLoop(test);
}
Serial.println (F ("ESP8266 sköld för närvarande"));
} < /p >< p > void connectESP8266()
{
ESP8266 kan anges till ett av tre lägen:
1 - ESP8266_MODE_STA - Station endast
2 - ESP8266_MODE_AP - åtkomstpunkt endast
3 - ESP8266_MODE_STAAP - Station/AP combo
Använd esp8266.getMode() för att kontrollera vilket läge det är:
int retVal = esp8266.getMode();
om (retVal! = ESP8266_MODE_STA)
{/ / Om det inte är i station läge.
Använda esp8266.setMode([mode]) till sätta den till en angiven
läget.
retVal = esp8266.setMode(ESP8266_MODE_STA);
om (retVal < 0)
{
Serial.println F ("fel inställning mode.").
errorLoop(retVal);
}
}
Serial.println F ("läge inställd station"). < /p >< p > / / esp8266.status() indikerar den ESP8266 WiFi ansluter
status.
Returnerade värdet 1 anger enheten är redan
ansluten. 0 anger frånkopplad. (Negativa värden
jämställer kommunikation fel.)
retVal = esp8266.status();
om (retVal < = 0)
{
Serial.Print F ("ansluter till").
Serial.println(mySSID);
esp8266.connect ([ssid], [psk]) ansluter ESP8266
till ett nätverk.
På framgång connect-funktionen returnerar ett värde > 0
På misslyckas returnerar funktionen antingen:
-1: TIMEOUT - biblioteket har en uppsättning 30s timeout
-3: misslyckas - kunde inte ansluta till nätverket.
retVal = esp8266.connect (mySSID, myPSK);
om (retVal < 0)
{
Serial.println F ("fel anslutning").
errorLoop(retVal);
}
}
} < /p >< p > void displayConnectInfo()
{
char connectedSSID [24].
MEMSET (connectedSSID, 0, 24);
esp8266.getAP() kan användas för att kontrollera vilka AP den
ESP8266 är ansluten till. Den returnerar en felkod.
Anslutna AP returneras av referens som en parameter.
int retVal = esp8266.getAP(connectedSSID);
om (retVal > 0)
{
Serial.Print (F ("ansluten till:"));
Serial.println(connectedSSID);
} < /p >< p > / / esp8266.localIP returnerar en IPadress variabel med den
ESP8266's nuvarande lokal IP-adress.
IP-adress myIP = esp8266.localIP();
Serial.Print (F ("min IP:")); Serial.println(myIP);
} < /p >< p > void clientDemo()
{
Till använda ESP8266 som en TCP-klient, använda den
ESP8266Client klass. Skapa först ett objekt:
ESP8266Client klient; < /p >< p > / / ESP8266Client ansluta ([server], [port]) som används till
ansluta till en server (const char * eller IP-adress) på
en angiven port.
Returer: 1 på framgång, 2 på redan ansluten,
negativ på misslyckas (-1 = TIMEOUT, -3 = Underkänd).
int retVal = client.connect (destServer, 80);
om (retVal < = 0)
{
Serial.println F ("kunde inte ansluta till servern.").
hemkomst.
} < /p >< p > / / Skriv ut och skriv kan användas för att skicka data till en ansluten
klientanslutning.
client.Print(HTTPRequest); < /p >< p > / / available() kommer tillbaka antalet tecken
för närvarande i mottagningsbufferten.
samtidigt (client.available())
Serial.write(client.Read()); Read() blir FIFO röding

Connected() är en boolean returvärdet - 1 om den
anslutningen är aktiv, 0 om den är stängd.
om (client.connected())
client.stop(); Stop() stänger en TCP-anslutning.
} < /p >< p > void serverSetup()
{
börja initialiserar ett ESP8266Server objekt. Det kommer att
starta en server på port anges i objektets
konstruktören (i globala område)
Server.BEGIN();
Serial.Print (F ("Server igång! Gå till "));
Serial.println(esp8266.localIP());
Serial.println();
} < /p >< p > void serverDemo()
{
available() är en ESP8266Server funktion som kommer att
returnera ett ESP8266Client objekt för att skriva ut och läsa.
available() har en parameter--ett timeout-värde. Detta
är antalet millisekunder funktionen waits,
kontroll för en anslutning.
ESP8266Client klient = server.available(500);

om (klient)
{
Serial.println F ("klient ansluten!").
en http-förfrågan avslutas med en tom rad
booleska currentLineIsBlank = sant;
samtidigt (client.connected())
{
om (client.available())
{
char c = client.read();
Om du har fått till slutet av raden (fick en newline
karaktär) och raden är tom, http-begäran har avslutats,
så du kan skicka ett svar
om (c == '\n' & & currentLineIsBlank)
{
Serial.println F ("skicka HTML-sidan").
Skicka en standard http-svarshuvudet:
client.Print(htmlHeader);
Sträng htmlBody;
utgående värdet för varje analog ingångsstift
för (int en = 0; en < 1; a ++)
{
htmlBody += "A";
htmlBody += String(a);
htmlBody += ":";
htmlBody += String(Thermister(analogRead(a))); < /p >< p > //htmlBody += Serial.println(temp);
htmlBody += "< br > \n";
}
htmlBody += "< /p >< p > \n";
client.Print(htmlBody);
bryta;
}
om (c == "\n")
{
du börjar en ny rad
currentLineIsBlank = sant;
}
annars om (c! = '\r')
{
du har fått ett tecken på den aktuella raden
currentLineIsBlank = false;
}
}
}
de web webbläsare möjlighet att ta emot data
Delay(1);

stänga anslutningen:
client.stop();
Serial.println F ("klienten kopplas bort").
}

} < /p >< p > / / errorLoop skriver ut en felkod, då loopar för evigt.
void errorLoop(int error)
{
Serial.Print (F ("fel:")); Serial.println(Error);
Serial.println F ("Looping för evigt.").
för (;)
;
} < /p >< p > / / serialTrigger skriver ut ett meddelande, sedan väntar något
komma in från den seriella porten.
void serialTrigger(String message)
{
Serial.println();
Serial.println(Message);
Serial.println();
tag (!. Serial.available())
;
samtidigt (Serial.available())
Serial.Read();
} < /p >