Networking and Communications

So, in order to transfer the data, the device needs some kind of reference which separates one data from another or know when the data starts and where it ends. Depending upon the use of clock or not there are two types:

Synchronous:
If the communication uses reference of clock to transfer a data or a signal it is called synchronous communication. Here data is send bu one wire and the synchronized clock is send from another wire and the reading is done according to the clock. There are different types of synchronous communication protocol like Inter-Integrated Circuit(I2C) protocol or two wire interface and Serial Peripheral Interface (SPI). The details are explained below.
Asynchronous
If the communication does not use reference of dedicated clock signal to transfer a data or a signal it is called asynchronous communication. So the question is how does it know when the data starts and ends. To solve this, there should be common configuration between the transmitter and receiver. The main configuration are
a. transmission speed in bauds/s, normally 9600 bauds/s is used
b. data length in bits, if 9600 bauds/s is used one bit is 104micro second
c. when to start and stop, there is low signal for start and high signal at the stop.
So the way it work is first when low signal is there it assumes the data is started. Once the signal is low, it goes 104uS and takes as the start of the data but to have a clean reading it goes in middle i.e half of the bit time i.e 52us to read the data the it continues reading until 8 bit and there is high signal again as a stop bit. Then the buffered data is pased to the other area of board. An example of Asynchronous communication is UART.

The one I will be doing is I2C type this week as this is simple connection thata can be used in my final project as well. This is a type of synchronous communication protocol. It differs with SPI which is also a synchronous protocol. Lets me first talk about SPI and then come to I2C

SPI (Serial Peripheral Interface) protocol:

[When SPI was invented, the naming was done according to Master and slave which you find in other document, but in this document, the term "slave" has been replaced with "secondary"]
This is a synchronous type serial communication protocol which consists of two data lines (MOSI and MISO), one clock line (SCK) and a Secondary select line (SS). Before moving ahead here are some terms that you should be aware of:

Master – Device which provides clock for communication
Secondary – Device other than master which utilizes master’s clock to communicate
MOSI – Master Out Secondary In (line though which master sends data to its Secondary)
MISO – Master In Secondary Out (line though which Secondary responds back to the master)
SCK – Serial Clock (clock provided by master device)
SS – Secondary Select (line used to select Secondary board to which master wants to communicate)

#include <TinyWire.h>
#include <SoftwareSerial.h>
int sensorPin = 4;// hall effect sensor (you should change the pin number from 4 to the pin you have connected your sensor to)
int digitalValue = 0;// variable to store the value coming from sensor
int analogValue = 0;
int x = 0;
SoftwareSerial Serial(1, 2); //(Tx, Rx pins for serial response)
void setup()
{
pinMode(sensorPin, INPUT_PULLUP);
pinMode(3, OUTPUT);
Serial.begin(9600); // initialize serial communications at 9600 bps
// TinyWireM.begin();
}
void loop()
{
analogValue = analogRead(A2);
if (analogValue <= 468 || analogValue >= 568 ) {
digitalWrite(3, HIGH);
x = 1;
}
else
{
digitalWrite(3, LOW);
x = 0;
}
Serial.print(x);
TinyWireM.beginTransmission (8);
TinyWireM.write(x);
TinyWireM.endTransmission ();
delay(100);
}

#include <TinyWireS.h>
#include <SoftwareSerial.h>
SoftwareSerial Serial(0, 1); //(Tx, Rx pins for serial response)
#define LED1 7
#define LED2 2

void setup() {
TinyWireS.begin(8);
pinMode(LED1, OUTPUT);
pinMode(LED2, OUTPUT);
Serial.begin(9600);
}

void loop() {
int x=0;
digitalWrite(LED1, HIGH);
if (TinyWireS.available()) {
x = TinyWireS.receive();

if (x == 1) {
digitalWrite(LED2, HIGH);
}
else {
digitalWrite(LED2, LOW);
}
}
delay(100);
}

#include <Wire.h>
#include <Servo.h>
#define hall 1
Servo myservo;

void setup() {
Wire.begin();
myservo.attach(0);

}

void loop() {
if (analogRead(hall) > 460) {
Wire.beginTransmission(8); // transmit to device #8
Wire.write(1);
Wire.endTransmission(); // stop transmitting
}
else {
for (int angle = 0; angle <= 180; angle += 1) {
myservo.write(angle);
delay(10);
}
delay(100);
for (int angle = 180; angle >= 0; angle -= 1) {
myservo.write(angle);
delay(10);
}
}
}

#include <Wire.h>
#include <Servo.h>
Servo myservo;

void setup() {
Wire.begin(8);
Wire.onReceive(receiveEvent);
myservo.attach(0);

}

void loop() {
delay(100);
}

void receiveEvent(int howMany) {
int val = Wire.read();
if (val==1){

for (int angle = 110; angle <= 130; angle += 10) {
myservo.write(angle);
delay(10);
}
delay(100);
for (int angle = 130; angle >= 110; angle -= 10) {
myservo.write(angle);
delay(10);
}
}
}

#include <Wire.h>
#include <Servo.h>
Servo myservo;

volatile bool flag = 0;
volatile int val = 0;

void setup() {
Wire.begin(8);
Wire.onReceive(receiveEvent);
myservo.attach(0);

}

void loop() {
if (flag) {
if (val == 1) {
for (int angle = 126; angle <= 180; angle += 1) {
myservo.write(angle);
delay(10);
}
for (int angle = 180; angle >= 126; angle -= 1) {
myservo.write(angle);
delay(10);
}
}
flag = 0;
}
}

void receiveEvent(int howMany) {
val = Wire.read();
flag = 1;
}

#include <WiFi.h>
#include <SPI.h>
#include <NTPClient.h>
#include <WiFiUdp.h>
#include <Servo_ESP32.h>
#include <BlynkSimpleEsp32.h>
#include <Wire.h>
#include "time.h"

#define servoPin 14 //printed G14 on the board
#define buzzer 27
#define hall 35
Servo_ESP32 servo1;

int angle = 100;
int angleMin = 100;
int angleMax = 170;
int angleStep = 1;

int med_qty = 0;
int buttonState = 0;
int setsec1 = 0;
int setsec2 = 0;
int setsec3 = 0;

int med_qty_sl1 = 0;
int buttonState_sl1 = 0;
int model1 = 0;
int setsec4 = 0;
int setsec5 = 0;
int setsec6 = 0;

int med_qty_sl2 = 0;
int buttonState_sl2 = 0;
int model2 = 0;
int setsec7 = 0;
int setsec8 = 0;
int setsec9 = 0;

char auth[] = "CXPXe4FBMq3APKm3-9C0hI5wrK1lKW5x";

const char* ssid = "iPhone"; //WiFi Name
const char* password = "NMF123!!!"; // WiFi Password

WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "1.asia.pool.ntp.org", 19800);

void setup()
{
Serial.begin(115200);
Blynk.begin(auth, ssid, password);
servo1.attach(servoPin);
pinMode(buzzer, OUTPUT);
pinMode(hall, INPUT);
//connect to WiFi
Serial.printf("Connecting to %s ", ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println(" CONNECTED");
Wire.begin();

}

void loop()
{
timeClient.update();
int h = timeClient.getHours();
int m = timeClient.getMinutes();
int s = timeClient.getSeconds();
int actsec = h * 3600 + m * 60 + s;
Serial.print(h);
Serial.print(":");
Serial.println(m);
Blynk.run();
Serial.println(setsec1);
if (actsec == setsec4 || actsec == setsec5 || actsec == setsec6 || buttonState_sl1 == 1) {
Wire.beginTransmission(model1);
Wire.write(med_qty_sl1);
Wire.endTransmission();
}

if (actsec == setsec7 || actsec == setsec8 || actsec == setsec9 || buttonState_sl2 == 1) {
Wire.beginTransmission(model2);
Wire.write(med_qty_sl2);
Wire.endTransmission();
}

if (actsec == setsec1 || actsec == setsec2 || actsec == setsec3 || buttonState == 1) {
dispense(med_qty);
while (analogRead(hall) <= 3500) {
buzz();
}
}
delay(500);

}

void dispense(int med_qty) {
for (int i = 1 ; i <= med_qty; i++) {
for (int angle = angleMin; angle <= angleMax; angle += angleStep) {
servo1.write(angle);
Serial.println(angle);
delay(20);
}
delay(100);

for (int angle = angleMax; angle >= angleMin; angle -= angleStep) {
servo1.write(angle);
Serial.println(angle);
delay(20);
}
delay(100);
}
}

void buzz() {
digitalWrite(buzzer, 1);
delay(100);
digitalWrite(buzzer, 0);
delay(100);
}

BLYNK_WRITE(V0)
{
med_qty = param.asInt(); // assigning incoming value from pin V1 to a variable
}

BLYNK_WRITE(V1) {
TimeInputParam t(param);

if (t.hasStartTime())
{
Serial.println(String("Start: ") +
t.getStartHour() + ":" +
t.getStartMinute() + ":" +
t.getStartSecond());
setsec1 = (t.getStartHour() * 3600) + (t.getStartMinute() * 60) + t.getStartSecond();
}
}

BLYNK_WRITE(V2) {
TimeInputParam t(param);

if (t.hasStartTime())
{
Serial.println(String("Start: ") +
t.getStartHour() + ":" +
t.getStartMinute() + ":" +
t.getStartSecond());
setsec2 = (t.getStartHour() * 3600) + (t.getStartMinute() * 60) + t.getStartSecond();
}
}

BLYNK_WRITE(V3) {
TimeInputParam t(param);

if (t.hasStartTime())
{
Serial.println(String("Start: ") +
t.getStartHour() + ":" +
t.getStartMinute() + ":" +
t.getStartSecond());
setsec3 = (t.getStartHour() * 3600) + (t.getStartMinute() * 60) + t.getStartSecond();
}
}

BLYNK_WRITE(V4)
{
buttonState = param.asInt(); // assigning incoming value from pin V1 to a variable
}

BLYNK_WRITE(V5)
{
model1 = param.asInt(); // assigning incoming value from pin V1 to a variable
}

BLYNK_WRITE(V6)
{
med_qty_sl1 = param.asInt(); // assigning incoming value from pin V1 to a variable
}

BLYNK_WRITE(V7) {
TimeInputParam t(param);

if (t.hasStartTime())
{
Serial.println(String("Start: ") +
t.getStartHour() + ":" +
t.getStartMinute() + ":" +
t.getStartSecond());
setsec4 = (t.getStartHour() * 3600) + (t.getStartMinute() * 60) + t.getStartSecond();
}
}

BLYNK_WRITE(V8) {
TimeInputParam t(param);

if (t.hasStartTime())
{
Serial.println(String("Start: ") +
t.getStartHour() + ":" +
t.getStartMinute() + ":" +
t.getStartSecond());
setsec5 = (t.getStartHour() * 3600) + (t.getStartMinute() * 60) + t.getStartSecond();
}
}

BLYNK_WRITE(V9) {
TimeInputParam t(param);

if (t.hasStartTime())
{
Serial.println(String("Start: ") +
t.getStartHour() + ":" +
t.getStartMinute() + ":" +
t.getStartSecond());
setsec6 = (t.getStartHour() * 3600) + (t.getStartMinute() * 60) + t.getStartSecond();
}
}

BLYNK_WRITE(V10)
{
buttonState_sl1 = param.asInt(); // assigning incoming value from pin V1 to a variable
}

BLYNK_WRITE(V11)
{
model2 = param.asInt(); // assigning incoming value from pin V1 to a variable
}

BLYNK_WRITE(V12)
{
med_qty_sl2 = param.asInt(); // assigning incoming value from pin V1 to a variable
}

BLYNK_WRITE(V13) {
TimeInputParam t(param);

if (t.hasStartTime())
{
Serial.println(String("Start: ") +
t.getStartHour() + ":" +
t.getStartMinute() + ":" +
t.getStartSecond());
setsec7 = (t.getStartHour() * 3600) + (t.getStartMinute() * 60) + t.getStartSecond();
}
}

BLYNK_WRITE(V14) {
TimeInputParam t(param);

if (t.hasStartTime())
{
Serial.println(String("Start: ") +
t.getStartHour() + ":" +
t.getStartMinute() + ":" +
t.getStartSecond());
setsec8 = (t.getStartHour() * 3600) + (t.getStartMinute() * 60) + t.getStartSecond();
}
}

BLYNK_WRITE(V15) {
TimeInputParam t(param);

if (t.hasStartTime())
{
Serial.println(String("Start: ") +
t.getStartHour() + ":" +
t.getStartMinute() + ":" +
t.getStartSecond());
setsec9 = (t.getStartHour() * 3600) + (t.getStartMinute() * 60) + t.getStartSecond();
}
}

BLYNK_WRITE(V16)
{
buttonState_sl2 = param.asInt(); // assigning incoming value from pin V1 to a variable
}

Assignment

Introduction

Series: Data is sent by same wire but in series one after another. It is relatively slower but are cheap and easy to use. The examples of serial communication are as follows

So, in order to transfer the data, the device needs some kind of reference which separates one data from another or know when the data starts and where it ends. Depending upon the use of clock or not there are two types:

First the ESP-32 main board is connected to wifi and takes time form the internet

On the GUI (blynk app), user sets the time when he/she can dispense.

Similarly for the secondary module, model number is entered in the blynk app, which will be the address for the i2c communication. And time is set on that as well.

Then the time is saved in seconds and it will be easier to compare. Hence the ESP 32 main board is comparing the time with the entered time

If the time matches. the board will check the address for i2c connection where the time is matching and send the medicine quantity to the secondary or move the servo motor according to medicine quantity

Now after the quantity is send by the main module to secondary module, in secondary module, if address is matching, it saves the received number and the actuates servo for the loop of received number.

In both master module and secondary module, here hall sensor is kept under the tray which has got magnet in it and the buzzer is on when servo runs its cycle until the magnet is away meaning if the user has unloaded the magnetic tray to have the medicine.