Arduino Programming | Sample Programs

HomeArduino Programming | Course HomeArduino Programming | Sample Programs

Arduino Programming – Sample Programs

Sample programs is the first step you take to transition from theory to practical. These sample programs typically demonstrated in a classroom will ensure you are able to immediately see it running in front of your eyes. Added to that our mentors will provide you some exercises where you will be modifying the code in the class itself. By doing this fill-in-the-blank approach, will take out your fear of coding.

Programs

Brief:

A simple program to control (Toggle) the Builtin LED connected at GPIO2.
 

Source Code:

 /*------------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 23 Jun 2021 10:00:00 IST
 *   Sketch         : Blinky.ino
 *   Title          : Blinky
 *   Description    : A simple program to control (Toggle) the Builtin LED connected at GPIO2
 *-----------------------------------------------------------------------------------------------*/

#define LED_BUILTIN         2

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
}

 

 Example output:

 

Brief:

A simple sketch to detect the change in signal level on port pin.
 
 
Source Code:
 /*-------------------------------------------------------------------------------------------------          		    
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 23 Jun 2021 10:00:00 IST
 *   Sketch         : LevelTrigger.ino
 *   Title          : Level Detection 
 *   Description    : A simple sketch to detect the change in signal level on port pin
 *-----------------------------------------------------------------------------------------------*/

#define GPIO0               0
#define GPIO2               2

#define SWITCH_BUILTIN      GPIO0
#define LED_BUILTIN         GPIO2

void setup() { 
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(SWITCH_BUILTIN, INPUT_PULLUP);
}

void loop() {
  static bool key;
  key = digitalRead(SWITCH_BUILTIN);
  digitalWrite(LED_BUILTIN, key); 
}

 

Arduino Programming Example output:

 

Brief:

A simple sketch to detect the signal stage change.
 
Source Code:
/*------------------------------------------------------------------------------------------------- 			    
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 23 Jun 2021 10:00:00 IST
 *   Sketch         : StateChange.ino
 *   Title          : State Change Detection
 *   Description    : A simple sketch to detect the signal stage change
 *-----------------------------------------------------------------------------------------------*/

#define GPIO0               0
#define GPIO2               2

#define SWITCH_BUILTIN      GPIO0
#define LED_BUILTIN         GPIO2

#define OFF                 1

void setup() {
  digitalWrite(LED_BUILTIN, OFF);
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(SWITCH_BUILTIN, INPUT);
}

bool read_key(void)
{
  static bool key;
  static bool once;
  key = digitalRead(SWITCH_BUILTIN);
  if (key && once)
  {
    once = 0;
    return 1;
  }
  else if (key == 0)
  {
    once = 1;
  }
  return 0;
}

void loop() {
  static bool state = OFF;
  if (read_key())
  {
    state = !state;
    digitalWrite(LED_BUILTIN, state);
  }
}

 

 Example output:

 

Brief:

A sketch to setup the timer to generate an event every second.
 
Source Code:
 /*------------------------------------------------------------------------------------------------- 			    
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 23 Jun 2021 10:00:00 IST
 *   Sketch         : EventTrigger.ino
 *   Title          : Event Trigger using Timer
 *   Description    : A sketch to setup the timer to generate an event every second
 *-----------------------------------------------------------------------------------------------*/

#define EDGE            true
#define UP_TICK         true
#define AUTO_RELOAD     true

volatile bool alr_triggered;
 
hw_timer_t *timer = NULL;
 
void IRAM_ATTR tmr_isr() {
  alr_triggered = 1;
}
 
void setup() {
 
  Serial.begin(115200);
 
  timer = timerBegin(0, 80, UP_TICK);
  timerAttachInterrupt(timer, &tmr_isr, EDGE);
  timerAlarmWrite(timer, 1000000, AUTO_RELOAD);
  timerAlarmEnable(timer);
}
 
void loop() {
  static int count;

  if (alr_triggered) {
    Serial.print("An interrupt as occurred. Total number: ");
    Serial.println(++count);

    alr_triggered = 0;
  }
}

 

Arduino Programming Example output:

 

Brief:

A simple sketch to configure a GPIO pin in Interrupt mode to detect falling edge.
 
Source Code:
 /*------------------------------------------------------------------------------------------------- 			    
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 23 Jun 2021 10:00:00 IST
 *   Sketch         : ExternalInterrupt.ino
 *   Title          : External Interrupt
 *   Description    : A simple sketch to configure a GPIO pin in Interrupt mode to detect falling 
 *                    edge
 *-----------------------------------------------------------------------------------------------*/

#define GPIO0         0

const byte int_pin = GPIO0;

volatile bool int_triggered;
volatile int count;
 
void IRAM_ATTR int_isr() {
  int_triggered = 1;
  count++;
}

void setup() {
  Serial.begin(115200);
 
  Serial.println("Press Boot Pin to Trigger Interrupt");
  pinMode(int_pin, INPUT_PULLUP);

  attachInterrupt(digitalPinToInterrupt(int_pin), int_isr, FALLING);
}

void loop() {
  if (int_triggered) {
    Serial.print("Total event triggered: ");
    Serial.println(count);

    int_triggered = 0;
  }
}

 

Example output:

 

Brief:

A simple sketch to read the analog input and trigger an event once the set threshold is reached.
 
 
Source Code:
 /*-------------------------------------------------------------------------------------------------  
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 23 Jun 2021 10:00:00 IST
 *   Sketch         : AnalogInput.ino
 *   Title          : Analog Signal Detection
 *   Description    : A simple sketch to read the analog input and trigger an event once the set 
 *                    threshold is reached
 *-----------------------------------------------------------------------------------------------*/

#define CHANNEL0        A0

#define LED_BUILTIN     2

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void glow_led(unsigned short adc_reg_val)
{
  if (adc_reg_val > 2048)
  {
    digitalWrite(LED_BUILTIN, 1);
  }
  else
  {
    digitalWrite(LED_BUILTIN, 0);
  }
}

void loop() {
  static int adc_val;
  
  adc_val = analogRead(CHANNEL0);

  glow_led(adc_val);
}

 

Schematic

 
Arduino Programming Example output:

 

Arduino Programming Example output:

 

Brief:

A simple sketch to generate a PWM signal to control the LED brightness using LED PWM control module supported by ESP32 module.
 
 
Source Code:
 /*------------------------------------------------------------------------------------------------- 			    
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 23 Jun 2021 10:00:00 IST
 *   Sketch         : LEDC.ino
 *   Title          : Pulse Width Modulation (LED PWM)
 *   Description    : A simple sketch to generate a PWM signal to control the LED brightness using
 *                    LED PWM control module supported by ESP32 module
 *-----------------------------------------------------------------------------------------------*/

#define LED_CHANNEL         0
#define FREQ                25000
#define RESOLUTION          12

#define LED_BUILTIN         2

#define CHANNEL0            A0
#define NO_OF_SAMPLE        100

void setup_led_pwm(void)
{
  /* The below function set even the pin direction */
  ledcSetup(LED_CHANNEL, FREQ, RESOLUTION);
  ledcAttachPin(LED_BUILTIN, LED_CHANNEL);
}

void setup()
{
  setup_led_pwm();
}

int read_knob(void)
{
  float adc_val = 0;
  int samples;

  samples = 0;
  while (samples < NO_OF_SAMPLE)
  {
    adc_val = adc_val + analogRead(CHANNEL0);
    samples++;
  }

  adc_val = adc_val / samples;

  return (int) adc_val;
}

void loop()
{
  int duty_cycle;

  duty_cycle = read_knob();

  ledcWrite(LED_CHANNEL, duty_cycle);
}

 

Schematic

 
Embedded Systems Course | Emertxe | Bengaluru

 

Example output:

Brief:

A simple sketch to drive a CLCD module in 4 bit mode.
 
 

Source Code:

clcd.cpp

/*------------------------------------------------------------------------------------------------- 			   
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 23 Jun 2021 10:00:00 IST
 *   code           : clcd.cpp
 *   Title          : CLCD driver
 *   Description    : CLCD driver code with works in 4 bit mode
 *-----------------------------------------------------------------------------------------------*/

#include 
#include "clcd.h"
#include "Arduino.h"

CLCD::CLCD(uint8_t d4, uint8_t d5, uint8_t d6, uint8_t d7, uint8_t rs, uint8_t en)
{
  clcd_rs_pin = rs;
  clcd_en_pin = en;

  clcd_data_pin[0] = d4;
  clcd_data_pin[1] = d5;
  clcd_data_pin[2] = d6;
  clcd_data_pin[3] = d7;
}

void CLCD::write(uint8_t data, bool rs_bit_val, uint16_t exec_time_us)
{
  digitalWrite(clcd_rs_pin, rs_bit_val);

  digitalWrite(clcd_data_pin[0], (data >> 4) & 0x01);
  digitalWrite(clcd_data_pin[1], (data >> 5) & 0x01);
  digitalWrite(clcd_data_pin[2], (data >> 6) & 0x01);
  digitalWrite(clcd_data_pin[3], (data >> 7) & 0x01);

  digitalWrite(clcd_en_pin, HI);
  delayMicroseconds(1); // Requires the delay of 200 nsecs
  digitalWrite(clcd_en_pin, LO);

  digitalWrite(clcd_data_pin[0], (data >> 0) & 0x01);
  digitalWrite(clcd_data_pin[1], (data >> 1) & 0x01);
  digitalWrite(clcd_data_pin[2], (data >> 2) & 0x01);
  digitalWrite(clcd_data_pin[3], (data >> 3) & 0x01);

  digitalWrite(clcd_en_pin, HI);
  delayMicroseconds(1); // Requires the delay of 200 nsecs
  digitalWrite(clcd_en_pin, LO);

  delayMicroseconds(exec_time_us);
}

void CLCD::command(uint8_t data, uint16_t exec_time_us)
{
  write(data, 0, exec_time_us);
}

void CLCD::begin(void)
{
  digitalWrite(clcd_en_pin, LO);

  pinMode(clcd_rs_pin, OUTPUT);
  pinMode(clcd_en_pin, OUTPUT);
  pinMode(clcd_data_pin[0], OUTPUT);
  pinMode(clcd_data_pin[1], OUTPUT);
  pinMode(clcd_data_pin[2], OUTPUT);
  pinMode(clcd_data_pin[3], OUTPUT);

  /*
     Refer page 45/46 of HD44780U ADE-207-272(Z)
     "If the power supply conditions for correctly operating the internal reset 
     circuit are not met, initialization by instructions becomes necessary"
     As per the flow chart, we need at least 40ms after power rises above 2.7V
     So waiting forapprox 50 msecs
  */
  delayMicroseconds(50000);

  write(0x03, 0, 4500); // We start in 8 bit mode, try to set 4 bit mode
  write(0x03, 0, 4500);
  write(0x03, 0, 150);

  write(TWO_LINE_5x7_MATRIX_4_BIT, 0, 37);
  write(CURSOR_HOME, 0, 1640);
  write(DISP_ON_AND_CURSOR_OFF, 0, 37);
  write(CLEAR_DISP_SCREEN, 0, 1640);
}
  
void CLCD::print(const char *s, uint8_t addr)
{
  write(addr, 0, 37);

  while (*s != '\0')
  {
    write(*s++, 1, 37);
  }
}

void CLCD::putch(int8_t data , uint8_t addr)
{
  write(addr, 0, 37);
  write(data, 1, 37);
}


clcd.ino

   /*------------------------------------------------------------------------------------------------- 			    
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 23 Jun 2021 10:00:00 IST
 *   Sketch         : CLCD.ino
 *   Title          : CLCD Demo
 *   Description    : A simple sketch to drive a CLCD module in 4 bit mode
 *-----------------------------------------------------------------------------------------------*/

#include "clcd.h"

CLCD clcd(D4, D5, D6, D7, RS, EN);

void setup()
{
  clcd.begin();

  clcd.print("Hello  World", LINE1(2));
  clcd.print("CLCD  with ESP32", LINE2(0));
}

void loop() {
    /* Nothing here yet */
}

 

Schematic

 
Arduino Programming Example output:

 

Arduino Programming Example output:

 

Brief:

A simple sketch to demonstrate the serial functions.
 
 

Source Code:

/*------------------------------------------------------------------------------------------------- 			    
 *   Author         : Emertxe (https://emertxe.com)
 *   Date           : Wed 23 Jun 2021 10:00:00 IST
 *   Sketch         : UART.ino
 *   Title          : UART Demo
 *   Description    : A simple sketch to demonstrate the serial functions
 *-----------------------------------------------------------------------------------------------*/

int get_c(void)
{
  bool user_acked = 0;

  while (!user_acked)
  {
    if (Serial.available())
    {
      user_acked = 1;

      return Serial.read();
    }
  }

  return 0;
}

void setup() {
  Serial.begin(115200);
}

void loop() {
  char ch;

  ch = get_c();

  Serial.print(ch);
}

 

 Example output:

 

Brief:

A simple sketch to demostrate SPI protocol by communication with external EEPROM.
 

Source Code:

25lc040.cpp

 /*------------------------------------------------------------------------------------------------- 			   
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 23 Jun 2021 10:00:00 IST
 *   code           : 25lc040.cpp
 *   Title          : 25lc040 driver
 *   Description    : SPI driver code to communicate with EEPROM 25lc040
 *-----------------------------------------------------------------------------------------------*/

#include 
#include 
#include "25lc040.h"

#define SPI_CLK_FREQ 1000000 // 1 MHz

SPIClass *vspi = NULL;

void init_spi(void)
{
  /*
   Created 30/04/2018 by Alistair Symonds
   Adapted for SPI EEPROM 25LC040 by Adil S K
  */
  // Initialise two instances of the SPIClass attached to VSPI and HSPI respectively
  vspi = new SPIClass(VSPI);

  // SCLK = 18, MISO = 19, MOSI = 23, SS = 5
  vspi->begin();

  // Use it as you would the regular arduino SPI API
  vspi->beginTransaction(SPISettings(SPI_CLK_FREQ, MSBFIRST, SPI_MODE0));

  // Set up slave select pins as outputs as the Arduino API
  // Doesn't handle automatically pulling SS low
  pinMode(CS_PIN, OUTPUT); //VSPI Chip Select
  
  chip_select(HIGH); //pull SS high to start with
}

void spi_eeprom_write_byte(unsigned char address, unsigned char data) 
{
  /* Refer Datasheet for the write sequence */
  chip_select(LOW);
  spi_transfer(WREN);
  chip_select(HIGH);
  
  delay(1);
  
  chip_select(LOW);
  spi_transfer(WRITE);
  spi_transfer(address);
  spi_transfer(data);
  chip_select(HIGH);

  delay(5); // Refer datasheet

  chip_select(LOW);
  spi_transfer(WRDI);
  chip_select(HIGH);
  
  delay(1);
}

unsigned char spi_eeprom_read_byte(unsigned char address) 
{
  unsigned char data;

  /* Refer Datasheet for the read sequence */
  chip_select(LOW);
  spi_transfer(READ);
  spi_transfer(address);
  data = spi_transfer(DUMMY);
  chip_select(HIGH);
  
  return data;
}


25lc040.h

#ifndef _25LC040_H_													  
#define _25LC040_H_

#define WREN            6
#define WRDI            4
#define RDSR            5
#define WRSR            1
#define READ            3
#define WRITE           2

#define CS_PIN          5

#define DUMMY           0xFF

#define spi_transfer(x) vspi->transfer(x)
#define chip_select(x)  digitalWrite(CS_PIN, x);

void init_spi(void);
void spi_eeprom_write_byte(unsigned char address, unsigned char data);
unsigned char spi_eeprom_read_byte(unsigned char address);

#endif


SPI_EEPROM.ino

 /*------------------------------------------------------------------------------------------------- 			    
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 23 Jun 2021 10:00:00 IST
 *   Sketch         : SPI-EEPROM.ino
 *   Title          : SPI Demo
 *   Description    : A simple sketch to demostrate SPI protocol by communication with external
 *                    EEPROM
 *-----------------------------------------------------------------------------------------------*/

#include 
#include "25lc040.h"

#define GPIO0               0
#define SWITCH_BUILTIN      GPIO0

bool read_key(void)
{
  static bool key;
  static bool once;

  key = digitalRead(SWITCH_BUILTIN);

  if (key && once)
  {
    once = 0;
    
    return 1;
  }
  else if (key == 0)
  {
    once = 1;
  }
  
  return 0;
}

void spi_eeprom_test() 
{
  char data;
  static char prev_data;
  static char loc = 0;
  int key;

  key = read_key();
  
  if (key)
  {
    if (loc < 3)
    {
      loc++;
    }
    else
    {
      loc = 0;
    }
  }

  data = spi_eeprom_read_byte(loc);

  if (data != prev_data)
  {
    Serial.println(data);
    prev_data = data;
  }
}

void setup() 
{
  Serial.begin(115200);
  Serial.println("SPI EEPROM Test");
  
  init_spi();

  spi_eeprom_write_byte(0, 'A');
  spi_eeprom_write_byte(1, 'B');
  spi_eeprom_write_byte(2, 'C');
  spi_eeprom_write_byte(3, 'D');
}

void loop() 
{
  spi_eeprom_test();
}

 

Schematic

Embedded Systems Course | Emertxe | Bengaluru

Arduino Programming Example output:

 

Brief:

An application to intract with DS1307 RTC using I2C protocol.
 

Source Code:

ds1370.cpp

 /*------------------------------------------------------------------------------------------------- 			   
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 24 Mar 2021 16:0main.c0:04 IST
 *   File           : ds1307.cpp
 *   Title          : DS1307 RTC Driver
 *   Description    : Drive to read and write DS1307
 *-----------------------------------------------------------------------------------------------*/

#include "Arduino.h"
#include "Wire.h"
#include "ds1307.h"

void write_ds1307(unsigned char addr, unsigned char data)
{
  Wire.beginTransmission(SLAVE_ID);
  Wire.write(addr);
  Wire.write(data);
  Wire.endTransmission();
}

unsigned char read_ds1307(unsigned char addr)
{
  unsigned char data;

  Wire.beginTransmission(SLAVE_ID);
  Wire.write(addr);
  Wire.endTransmission();
  Wire.requestFrom(SLAVE_ID, 1);

  data = Wire.read();

  return data;
}

void init_ds1307(void)
{
  unsigned char dummy;

  Wire.begin(21, 22, 100000);

  /* Setting the CH bit of the RTC to Stop the Clock */

  dummy = read_ds1307(SEC_ADDR);
  write_ds1307(SEC_ADDR, dummy | 0x80);

  /*
     Control Register of ds1338
     Bit 7 - OUT
     Bit 6 - 0
     Bit 5 - OSF
     Bit 4 - SQWE
     Bit 3 - 0
     Bit 2 - 0
     Bit 1 - RS1
     Bit 0 - RS0

     Seting RS0 and RS1 as 11 to achive SQW out at 32.768 KHz
  */
  write_ds1307(CNTL_ADDR, 0x93);

  /* Clearing the CH bit of the RTC to Start the Clock */
  dummy = read_ds1307(SEC_ADDR);
  write_ds1307(SEC_ADDR, dummy & 0x7F);
}


ds1307.h

#ifndef DS1338_H												          
#define DS1338_H

#define SLAVE_ID        0x68

#define SEC_ADDR        0x00
#define MIN_ADDR        0x01
#define HOUR_ADDR       0x02
#define DAY_ADDR        0x03
#define DATE_ADDR       0x04
#define MONTH_ADDR      0x05
#define YEAR_ADDR       0x06
#define CNTL_ADDR       0x07

#define SEC_FIELD       buffer[0]
#define MIN_FIELD       buffer[1]
#define HRS_FIELD       buffer[2]
#define DAY_OF_WEEK     buffer[3] - 1
#define DAY_FIELD       buffer[4]
#define MONTH_FIELD     buffer[5]
#define YEAR_FIELD      buffer[6]

#define _12_HRS_        0x40
#define _12_            0x1F
#define _24_            0x3F
#define AM_PM           0x20

void set_rtc(char *buffer);
void get_rtc(char *buffer);
void write_ds1307(unsigned char addr, unsigned char data);
unsigned char read_ds1307(unsigned char addr);
void init_ds1307(void);

#endif


DS1307.ino

 /*------------------------------------------------------------------------------------------------- 			    
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 24 Mar 2021 16:0main.c0:04 IST
 *   Sketch         : DS1307.ino
 *   Title          : DS1307 RTC
 *   Description    : An application to intract with DS1307 RTC using I2C protocol
 *-----------------------------------------------------------------------------------------------*/

#include 
#include "ds1307.h"

unsigned char clock_reg[3];
unsigned char time[9];

void display_time(void)
{
  Serial.println((char *)time);

  if (clock_reg[0] & 0x40)
  {
    if (clock_reg[0] & 0x20)
    {
      Serial.print("PM");
    }
    else
    {
      Serial.print("AM");
    }
  }
}

static void get_time(void)
{
  clock_reg[0] = read_ds1307(HOUR_ADDR);
  clock_reg[1] = read_ds1307(MIN_ADDR);
  clock_reg[2] = read_ds1307(SEC_ADDR);

  if (clock_reg[0] & 0x40)
  {
    time[0] = '0' + ((clock_reg[0] >> 4) & 0x01);
    time[1] = '0' + (clock_reg[0] & 0x0F);
  }
  else
  {
    time[0] = '0' + ((clock_reg[0] >> 4) & 0x03);
    time[1] = '0' + (clock_reg[0] & 0x0F);
  }
  time[2] = ':';
  time[3] = '0' + ((clock_reg[1] >> 4) & 0x0F);
  time[4] = '0' + (clock_reg[1] & 0x0F);
  time[5] = ':';
  time[6] = '0' + ((clock_reg[2] >> 4) & 0x0F);
  time[7] = '0' + (clock_reg[2] & 0x0F);
  time[8] = '\0';
}

void setup()
{
  Serial.begin(115200);

  init_ds1307();
}

void loop()
{
  get_time();
  display_time();

  delay(1000);
}

 

Schematic

Arduino Programming Example output:

 

Arduino Programming Example output:

Brief:

A simple application acting as a web browser to control the and get status of the device.

 

 
Source Code:
/*------------------------------------------------------------------------------------------------- 
 *   Author         : Emertxe (https://emertxe.com) 
 *   Date           : Wed 24 Mar 2021 16:0main.c0:04 IST
 *   Sketch         : SimpleWebBrowser.ino
 *   Title          : Web Browser
 *   Description    : A simple appilcation acting as a web browser to control the and get status
 *                    of the device
 *-----------------------------------------------------------------------------------------------*/

#include 

char ssid[] =     // Your network SSID (name)
char pass[] = // Your network password

WiFiServer server(80);

static bool state;

#define GPIO0 0
#define GPIO2 2

#define SWITCH_BUILTIN GPIO0
#define LED_BUILTIN GPIO2

#define OFF 1

void wifi_info(void)
{
    // print the SSID of the network you're attached to:
    Serial.print("SSID: ");
    Serial.println(WiFi.SSID());

    // print your WiFi shield's IP address:
    String ip = WiFi.localIP().toString();
    Serial.print("IP Address: ");
    Serial.println(ip);

    // print the received signal strength:
    long rssi = WiFi.RSSI();
    Serial.print("Signal strength (RSSI):");
    Serial.print(rssi);
    Serial.println(" dBm");

    Serial.println("\nType " + ip + " on your Web Browser to know more");
}

void setup()
{
    int wifi_state = WL_IDLE_STATUS;

    //Initialize serial and wait for port to open
    Serial.begin(115200);

    digitalWrite(LED_BUILTIN, OFF);

    pinMode(LED_BUILTIN, OUTPUT);
    pinMode(SWITCH_BUILTIN, INPUT);

    // Attempt to connect to Wifi network
    while (wifi_state != WL_CONNECTED)
    {
        Serial.print("Attempting to connect to SSID: ");
        Serial.println(ssid);
        // Connect to WPA/WPA2 network
        wifi_state = WiFi.begin(ssid, pass);

        // wait 2 seconds to retry
        delay(2000);
    }
    Serial.println("Wifi Connected");
    Serial.println("Initializing the server. Please wait for a while");
    server.begin();

    delay(10000);
    Serial.println("Done");

    // Connection establised, Let print the wifi info
    wifi_info();
}

void usage(WiFiClient client)
{
    String ip = WiFi.localIP().toString();

    client.println("
");
    client.print("Usage:");
    client.println("
");
    client.print(ip + "\t - Will show this page");
    client.println("
");
    client.print(ip + "/state - Get the LED status");
    client.println("
");
    client.print(ip + "/led/1 - Switch ON the LED");
    client.println("
");
    client.print(ip + "/led/0 - Switch OFF the LED");
}

void send(int update_state, WiFiClient client)
{
    client.println("HTTP/1.1 200 OK");
    client.println("Content-Type: text/html");
    client.println("Connection: close");
    client.println();
    client.println("");
    client.println("");

    if (update_state == 1)
    {
        client.print("# Welcome to Simple Web Service :-");
        usage(client);
    }
    else if (update_state == 2)
    {
        client.print("LED is ");
        client.print(state ? "ON" : "OFF");
    }
    else
    {
        client.print("Invalid Request");
        client.println("");
        usage(client);
    }

    client.println("");
    client.println("");
}

void service(void)
{
    // listen for incoming clients
    WiFiClient client = server.available();

    if (client)
    {
        Serial.println("New client request");

        int update_state = 0;

        if (client.connected())
        {
            if (client.available())
            {
                String command = "";
                char ch = '0';

                ch = client.read();

                while ((ch != '\n') && (ch != '\r'))
                {
                    command.concat(ch);
                    ch = client.read();
                }
                command.concat('\0');

                Serial.print("Received request: ");
                Serial.println(command);

                command = strtok((char *)&command[0], " ");
                command = strtok(NULL, " ");

                if (!strcmp((char *)&command[0], "/"))
                {
                    update_state = 1;
                }
                else if (!strcmp((char *)&command[0], "/state"))
                {
                    state = digitalRead(LED_BUILTIN);
                    update_state = 2;
                }
                else if (!strcmp((char *)&command[0], "/led/1"))
                {
                    state = 1;
                    digitalWrite(LED_BUILTIN, state);
                    update_state = 2;
                }
                else if (!strcmp((char *)&command[0], "/led/0"))
                {
                    state = 0;
                    digitalWrite(LED_BUILTIN, state);
                    update_state = 2;
                }
                else
                {
                    update_state = 0;
                }

                send(update_state, client);
            }
        }

        // close the connection:
        client.flush();
        client.stop();
        Serial.println("client disonnected");
    }
}

void led_control(void)
{
    static bool key;
    static bool once;

    key = digitalRead(SWITCH_BUILTIN);

    if (key && once)
    {
        once = 0;

        state = !state;
        digitalWrite(LED_BUILTIN, state);
    }
    else if (key == 0)
    {
        once = 1;
    }
}

void loop()
{
    service();
    led_control();
}

 

Arduino Programming Example output: