14. Networking and communication¶

#include <ESP8266WiFi.h>
#include <PubSubClient.h>

// SETUP WIFI CREDENTIALS
const char* ssid = "wifiname";
const char* password = "wifiPassword";
const char* mqtt_server = "broker";
const char* mqtt_user = "user";
const char* mqtt_pass = "password";

const int output5 = 5;
const int output4 = 4;

WiFiClient espClient;
PubSubClient client(espClient);

void setup() {
  Serial.begin(9600);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
  // Initialize the output variables as outputs
  pinMode(output5, OUTPUT);
  pinMode(output4, OUTPUT);
  // Set outputs to LOW
  digitalWrite(output5, LOW);
  digitalWrite(output4, LOW);
  // PUT THE CODE TO START YOUR SENSORS HERE

}

void loop() {

  if (!client.connected()) reconnect();
  client.loop();

  // Publish every 1000 milliseconds
  if (millis() % 5000 == 0) {

    // READ YOUR SENSOR DATA HERE
    float value = analogRead(A0);

    // Send value as characters
    char msg[50];
    snprintf (msg, 50, "%f", value);
    Serial.print("Publish message: ");
    Serial.println(msg);

    // SET THE TOPIC TO PUBLISH HERE
    client.publish("input/ARMAN", msg);
  }
}

void callback(char* topic, byte* payload, unsigned int length) {

  Serial.print("Message arrived [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();

  String strPayload = String((char*)payload);

  // Serial.println(strPayload.toFloat());
  // Serial.println(strPayload.toInt());

  // USE RECEIVED DATA HERE
  if (strPayload.toInt() > 20) digitalWrite(output4, LOW);
  else digitalWrite(output4, HIGH);

}

void reconnect() {

  // Loop until we're reconnected
  while (!client.connected()) {

    Serial.print("Attempting MQTT connection...");
    // Create a random client ID
    String clientId = "ESP8266Client-";
    clientId += String(random(0xffff), HEX);

    // Attempt to connect
    if (client.connect(clientId.c_str(), mqtt_user, mqtt_pass)) {
      Serial.println("connected");

      // SET THE TOPIC TO SUBSCRIBE HERE
      client.subscribe("output/ARMAN");

    } else {

      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);

    }
  }
}

void setup_wifi() {

  delay(10);
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

import paho.mqtt.client as mqtt
import time
import random

mqtt_broker = "netfabbcn.hopto.org"
mqtt_user = "students"
mqtt_pass = "fablabbcnisnice"
broker_port = 1883

def on_connect(client, userdata, flags, rc):
   print(f"Connected With Result Code: {rc}")

def on_message(client, userdata, message):
   print(f"Message Recieved: {message.payload.decode()}")
   # Do something here with the message

def on_log(client, obj, level, string):
    print (string)

def read_sensor():
    sensor_reading = random.randrange(0,1024)
    return sensor_reading

client = mqtt.Client(clean_session = True)
client.on_connect = on_connect
client.on_message = on_message
client.on_log = on_log
client.username_pw_set(username = mqtt_user, password = mqtt_pass)
client.connect(mqtt_broker, broker_port)


# Subscribe to your topic here
client.subscribe("output/pyarman", qos=1)
client.publish(topic="input/pyarman", payload="Hello from python", qos = 1, retain = False)


# Start looping (non-blocking)
client.loop_start()

while True:
    # Read data here
    sensor_reading = read_sensor()
    # Publish data here
    client.publish(topic="input/pyarman", payload=sensor_reading, qos = 1, retain = False)
    time.sleep(20)

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>

const char *ssid = "MyESP8266AP";
const char *password = "testpassword";

ESP8266WebServer server(80);

void handleRoot() {
  server.send(200, "text/html", " <h1>Hello from ESP8266 AP!</h1>");
}

void setup() {

  Serial.begin(115200);

  WiFi.softAP(ssid, password);

  Serial.println();
  Serial.print("Server IP address: ");
  Serial.println(WiFi.softAPIP());
  Serial.print("Server MAC address: ");
  Serial.println(WiFi.softAPmacAddress());

  server.on("/", handleRoot);
  server.begin();

  Serial.println("Server listening");
}

void loop() {
  server.handleClient();
}

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>

// AP Wi-Fi credentials
const char* ssid = "MyESP8266AP";
const char* password = "testpassword";
const char* host = "192.168.11.4";
// Local ESP web-server address
String data;
// DEEP_SLEEP Timeout interval
int sleepInterval = 5;
// DEEP_SLEEP Timeout interval when connecting to AP fails
int failConnectRetryInterval = 2;
int counter = 0;
float pt;
const int analogInPin = A0;


WiFiClient client;

void setup() {
  pinMode(analogInPin, INPUT);
  ESP.eraseConfig();
  WiFi.persistent(false);
  Serial.begin(115200);
  Serial.println();
  Serial.println("BEGIN");
  delay(500);
  WiFi.begin(ssid, password);
  Serial.println("");
  while (WiFi.status() != WL_CONNECTED) {
    if(counter > 20){
       Serial.println("- can't connect, going to sleep");    
       hibernate(failConnectRetryInterval);
    }
    delay(500);
    Serial.print(".");
    counter++;
  }

  Serial.println("- wifi connected");
  Serial.println("IP Address: ");
  Serial.println(WiFi.localIP());
  readSensor();
  Serial.println("- send GET request");
  sendHttp();
  Serial.println();
  Serial.println("- got back to sleep");
  Serial.println("");
  Serial.println("**************************");
  hibernate(sleepInterval);
}

void sendHttp() {
  if(client.connect(host,80)){
    String url = "/update?pt=";
    url+= String(pt);
    client.print(String("GET")+url+"HTTP/1.1\r\n"+"Host: "+host+"\r\n"+"Connection: keep-alive\r\n\r\n");
    delay(10);
    Serial.println("Response:");
    while(client.available()){
      String line = client.readStringUntil('\r');
      Serial.print(line);
    }
  }

}

void readSensor() {
  delay(200);
  pt = analogRead(analogInPin);
  if (isnan(pt)) {
    pt = 0.00;
  }
  Serial.println("- potentiometer read : "+String(pt));
}


void hibernate(int pInterval) {
  WiFi.disconnect();
  ESP.deepSleep(10 * 600000 * pInterval, WAKE_RFCAL);
  delay(100);
}

void loop() {}

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <Servo.h>
const char *ssid = "MyESP8266AP";
const char *password = "testpassword";
IPAddress ip(192, 168, 11, 4);
IPAddress gateway(192, 168, 11, 1);
IPAddress subnet(255, 255, 255, 0);

ESP8266WebServer server(80);
Servo myservo; // create servo object to control a servo
//static const uint8_t D2   = 4;
float pt;
void setup(void) {
  WiFi.mode(WIFI_AP);
  WiFi.softAPConfig(ip,gateway,subnet);
  WiFi.softAP(ssid,password);
  Serial.begin(115200);
  Serial.println();
  Serial.println("IP Address: ");
  Serial.println(WiFi.localIP());
  delay(10);
  server.on("/",handle_index);
  server.on("/update",handle_update);
  server.begin();

  myservo.attach(D2);
}
void handle_index() {
  server.send(200, "text/plain", String(pt));
}
void handle_update() {
  pt = server.arg("pt").toFloat();
  Serial.println(pt);
  server.send(200, "text/plain", "updated");
  servo(pt);
}

void loop(){
  server.handleClient();
}
void servo(float pt){
  if (pt>0 && pt<1024){
    float pos = map(pt,0,1023,0,180);
    myservo.write(pos);
  }
}

include<SPI.h>                             //Library for SPI
#define LED 2
int buttonvalue;
int x;
int incomingByte = 0;

void setup (void)
{
  Serial.begin(115200);                   //Starts Serial Communication at Baud Rate 115200

  pinMode(LED, OUTPUT);                   //Sets pin 7 as Output

  SPI.begin();                            //Begins the SPI commnuication
  SPI.setClockDivider(SPI_CLOCK_DIV8);    //Sets clock for SPI communication at 8 (16/8=2Mhz)
  digitalWrite(SS, HIGH);                 // Setting SlaveSelect as HIGH (So master doesnt connnect with slave)
}

void loop(void)
{
  byte Mastersend, Mastereceive;

  if (Serial.available() > 0) {
    incomingByte = Serial.read();
    Serial.println(incomingByte);
  }
  if (incomingByte == 48)
  {
    x = 1;
  }
  else
  {
    x = 0;
  }

  digitalWrite(SS, LOW);

  Mastersend = x;
  Mastereceive = SPI.transfer(Mastersend);

  if (Mastereceive == 49)
  {
    digitalWrite(LED, HIGH);
    Serial.println("Master LED ON");
  }
  else
  {
    digitalWrite(LED, LOW);
    Serial.println("Master LED OFF");
  }
  delay(1000);
}

//SPI SLAVE (ARDUINO)
//SPI COMMUNICATION BETWEEN TWO ARDUINO
//CIRCUIT DIGEST
//Pramoth.T

#include<SPI.h>
#define LEDpin 2

volatile boolean received;
volatile byte Slavereceived, Slavesend;
int buttonvalue;
int x;
void setup()

{
  Serial.begin(115200);

  pinMode(LEDpin, OUTPUT);                // Setting pin 7 as OUTPUT
  pinMode(MISO, OUTPUT);                  //Sets MISO as OUTPUT (Have to Send data to Master IN

  SPCR |= _BV(SPE);                       //Turn on SPI in Slave Mode
  received = false;

  SPI.attachInterrupt();                  //Interuupt ON is set for SPI commnucation

}

ISR (SPI_STC_vect)                        //Inerrrput routine function
{
  Slavereceived = SPDR;         // Value received from master if store in variable slavereceived
  received = true;                        //Sets received as True
}

void loop()
{ if (received)                           //Logic to SET LED ON OR OFF depending upon the value recerived from master
  {
    if (Slavereceived == 49)
    {
      digitalWrite(LEDpin, HIGH);        
      Serial.println("Slave LED ON");
      delay(500);
      x = 0;
    } else
    {
      digitalWrite(LEDpin, LOW);        
      Serial.println("Slave LED OFF");
      delay(500);
      x = 1;
    }

    Slavesend = x;
    SPDR = Slavesend;                           //Sends the x value to master via SPDR
    delay(1000);
  }
}