Page 1

REPORT FOR INDUSTRIAL TRAINING (EC781)

ON
IOT AND ARTIFICIAL INTELLIGENCE &
ITS APPLICATION

Submitted by:

Name: MD. Injamamul Haque Ansari

University Roll No: 13000321135
Year: 4th
Semester:7th
Section: B
Department: Electronics and Communication
Engineering
College: Techno Main Salt Lake, Kolkata
(Affiliated to Maulana Abul Kalam Azad University of Technology)
 1

CONTENTS

Pg. No.

Section 1: Artificial Intelligence and Machine Learning

1. Project Objective……………………………………………………….3
2. Libraries in python………………………………………………….….4
3. Description of libraries…………………………………………….…..4-5
4. Project Discussion……………………………………………………..6
5. Project Steps…………………………………………………….…….7
6. PROJECT PICTURE……………………………………………….....8-10
7. Result………………………………………………………………….11
8. Conclusion……………………………………………………….……11

Section 2: Internet of Things

1. Introduction of Arduino………………………………………………. 12
2. Bus Communication……………………………………………………14
3. Node MCU……………………………………………………………..18
4. Node MCU based IoT………………………………………………….20
5. Introduction to Raspberry Pi 2…………………………………………28
6. RPi based IoT………………………………………………………….30
 2

Implementation of Multiple and polynomial Regression using

Sales Dataset

A PROJECT REPORT

in partial fulfillment for the award of the degree

of
BACHELOR OF TECHNOLOGY
IN
Electronics & Communication Engineering

Under the Guidance of

TATHAGATA CHATTERJEE
Project Carried Out At

ARDENT COMPUTECH PVT LIMITED

Submitted By

Shakya Singha Biswas

 3

PROJECT OBJECTIVE

The primary objective of this project is to employ data analysis techniques to uncover patterns
within a dataset containing information about product ratings, quantities, and corresponding
discounts. Through the utilization of machine learning models, particularly polynomial regression
and multiple linear regression, the project aims to make accurate predictions of discounts based
on user-provided ratings and quantities. The insights gained from this analysis will empower
businesses to optimize discounting strategies, improve inventory management, and enhance the
overall customer experience by tailoring promotions to specific rating and quantity scenarios.
 4

LIBRARIES IN PYTHON
What is a Library?
· A library is a collection of pre-combined codes that can be used iteratively to reduce the time
required to code.
· They are particularly useful for accessing the pre-written frequently used codes instead of
writing them from scratch every single time.
· Similar to physical libraries, these are a collection of reusable resources, which means every
library has a root source.
· This is the foundation behind the numerous open-source libraries available in Python.

What is a Python Library?

Python library is a collection of modules that contain functions and classes that can be used by
other programs to perform various tasks.

What are the uses of Libraries in Python ?

As we write large-size programs in Python, we want to maintain the code’s modularity. For the
easy maintenance of the code, we split the code into different parts and we can use that code later
ever we need it.
· In Python, modules play that part. Instead of using the same code in different programs and
making the code complex, we define mostly used functions in modules and we can just simply
import them in a program wherever there is a requirement.
· We don’t need to write that code but still, we can use its functionality by importing its module.
Multiple interrelated modules are stored in a library. And whenever we need to use a module, we
import it from its library. In Python, it’s a very simple job to do due to its easy syntax. We just
need to use import.

DESCRIPTION OF LIBRARIES
pandas (Data Analysis and Manipulation):
● Purpose: Pandas is a powerful library for data manipulation and analysis. It
provides data structures like DataFrame, which is particularly useful for handling
tabular data.
● Usage in the Code:
● Reading a CSV file into a Pandas DataFrame: df = pd.read_csv('data3.csv')
● Handling missing values: df['rating'].fillna(100, inplace=True)
 5

numpy (Numerical Operations):

● Purpose: NumPy is a fundamental package for numerical operations in Python. It
provides support for large, multi-dimensional arrays and matrices.
● Usage in the Code:
● Creating a polynomial fit: np.polyfit(x_axis, y_axis, 10)
● Creating a polynomial regression model: np.poly1d(np.polyfit(x_axis,
y_axis, 10))
matplotlib.pyplot (Data Visualization):
● Purpose: Matplotlib is a comprehensive library for creating static, animated, and
interactive visualizations in Python. Pyplot is a sub-library that provides a
MATLAB-like interface for plotting.
● Usage in the Code:
● Creating scatter plots: plt.scatter(x_axis, y_axis)
● Plotting regression curves: plt.plot(curve, model(curve), 'g')
scipy.stats (Statistical Functions):
● Purpose: SciPy is a library for scientific and technical computing. The stats
module within SciPy includes statistical functions.
● Usage in the Code:
● Performing polynomial regression: stats.polyfit(x_axis, y_axis, 10)
sklearn.linear_model (Machine Learning - Linear Regression):
● Purpose: Scikit-learn is a machine learning library for various tasks, including
linear regression.
● Usage in the Code:
● Creating a linear regression model: linear_model.LinearRegression()
● Training the model: multiple_linear_regression.fit(x_axis, y_axis)
These libraries collectively provide the tools needed for data analysis, visualization, and
regression modeling in the context of your code. They are widely used in the Python data science
ecosystem and offer efficient and flexible functionalities.
 6

PROJECT DISCUSSION

In this project, our primary objective is to leverage data analysis techniques to predict discounts
based on product ratings and quantities. We will analyze a dataset comprising information about
product ratings, quantities, and corresponding discounts to extract meaningful patterns and
enhance decision-making processes.

Objectives:
Data Exploration:
● We began by loading and exploring the dataset, identifying key variables such as
ratings, quantities, and discounts.
● Addressed missing values responsibly, ensuring data integrity.
Polynomial Regression Analysis:
● Utilized polynomial regression to model the relationship between ratings and
discounts as well as quantities and discounts.
● Plotted regression curves to visually represent the trends in the data.
Multiple Linear Regression:
● Applied multiple linear regression to understand the combined influence of both
quantity and rating on discounts.
● Trained the model using the dataset and evaluated its performance.
User Interaction:
● Implemented a user-friendly interface allowing users to input quantity and rating
values.
● Leveraged the trained model to predict discounts based on the user inputs.
 7

PROJECT STEPS

1. Data Collection and Exploration:

● Collect the dataset containing information about ratings, quantities, and discounts (e.g.,
'data3.csv').
● Load the dataset into a Pandas DataFrame.
● Explore the dataset to understand its structure, check for missing values, and ensure data
integrity.

2. Polynomial Regression Analysis (Rating vs. Discount):

● Extract the 'rating' and 'discount' columns from the dataset.
● Handle missing values by filling them with a default value (e.g., 100).
● Perform polynomial regression of degree 10 on the 'rating' vs. 'discount' data.
● Plot a scatter plot of 'rating' vs. 'discount' and overlay the polynomial regression curve.

3. Polynomial Regression Analysis (Quantity vs. Discount):

● Extract the 'quantity' and 'discount' columns from the dataset.
● Handle missing values by filling them with a default value (e.g., 100).
● Perform polynomial regression of degree 10 on the 'quantity' vs. 'discount' data.
● Plot a scatter plot of 'quantity' vs. 'discount' and overlay the polynomial regression curve.

4. Multiple Linear Regression:

● Reload the dataset to ensure a clean start.
● Handle missing values in 'quantity', 'rating', and 'discount' by filling them with a default
value (e.g., 100).
● Create a feature matrix x_axis with columns 'quantity' and 'rating' and a target array y_axis
with the 'discount' column.
● Use scikit-learn's LinearRegression to fit a multiple linear regression model to predict
discounts based on quantity and rating.

5. User Interaction and Prediction:

● Prompt the user to input a quantity and a rating.
● Use the trained multiple linear regression model to predict the discount for the provided
quantity and rating.
● Display the predicted discount to the user.
 8

PROJECT PICTURE
1.Importing Libraries:

2. Reading the CSV file and Performing Polynomial Regression for Rating vs. Discount:
 9

3. Performing Polynomial Regression for Quantity vs. Discount:

 10

3.Performing Multiple Linear Regression for Quantity and Rating vs. Discount:

5. User Input and Prediction using Multiple Linear Regression:

 11

RESULT

● This step-by-step execution ensures that each part of the analysis is performed
independently and allows for a clear understanding of the relationships within the dataset.
Users can interact with the system to obtain predictions tailored to their inputted quantity
and rating values, providing practical insights for decision-making in discount strategies.
● The polynomial regression curves provided insights into the non-linear relationships between
ratings, quantities, and discounts.
● Multiple linear regression demonstrated the significance of both quantity and rating in predicting
discounts, offering a holistic view of their impact.

CONCLUSION

The "Data Analysis and Prediction of Discounts based on Ratings and Quantities" project offers a
robust framework for businesses to enhance their discounting strategies through data-driven
insights. By understanding the intricate relationships within the dataset, users can make informed
decisions that positively impact sales, customer satisfaction, and overall business performance.
 12

MODULE:1
Introduction of Arduino Uno

Fig no. 1

Basically, the processor of the Arduino board uses the Harvard architecture where the program code
and program data have separate memory.
The Atmega328 microcontroller has 32kb of flash memory, 2kb of SRAM 1kb of EPROM and
operates with a 16MHz clock speed.
The Arduino Uno is a microcontroller board based on the ATmega328. It has 14 digital input/output
pins (of which 6 can be used as PWM outputs), 6 analog inputs, a 16 MHz ceramic resonator, a
USB connection, a power jack, an ICSP header, and a reset button. It contains everything needed
to support the microcontroller; simply connect it to a computer with a USB cable or power it with
a AC-to-DC adapter or battery to get started.
 13

Fig no. 2

✔ 8BIT AVR RISC MICROCONTROLLER

✔ Microcontroller ATmega 328

✔ Operating voltage: 5 V

✔ Input voltage recommended : 7-12 V

✔ Digital I/O Pins: 14 ( of which 6 PWM output)

✔ Analog input Pins:6

✔ DC current per I/O Pin: 40 mA

✔ DC current for 3.3 V Pin: 50 mA

✔ Flash memory : 32 kB (Atmega 328) of which 0.5 kB used by bootloader

✔ SRAM: 2 kB

✔ EEPROM: 1 kB

✔ Clock speed : 16 MHz

✔ 6 CHANNEL ,10 BIT ADC

MODULE:2
 14

Bus Communication

Control an LED via Serial Communication:

Code for Master Arduino :

#include <SoftwareSerial.h>
SoftwareSerial softSerial(10, 11);
void setup()
{
softSerial.begin(9600);
Serial.begin(9600);
 15

}
void loop()
{
softSerial.print(1);
Serial.print(1);
delay(5000);
softSerial.print(0);
Serial.print(0);
delay(5000);
}
Code for Slave Arduino:
#include <SoftwareSerial.h>
SoftwareSerial softSerial(10, 11);
char number = ' ';
int LED = 2;
void setup()
{
softSerial.begin(9600);
Serial.begin(9600);
pinMode(LED, OUTPUT);
}
void loop()
{
if (softSerial.available())
{
char number = softSerial.read();
if (number == '0')
{
digitalWrite(LED, LOW);
}
 16

if (number == '1')
{
digitalWrite(LED, HIGH);
}
Serial.println(number);
}
}
----------------------------------------------------------------------------------------------------------------

Two-way communication between two Arduino using I2C:

Sketch for Master:

#include <Wire.h>
void setup() {
Serial.begin(9600); /* begin serial comm. */
Wire.begin(); /* join i2c bus as master */
Serial.println("I am I2C Master");
}
void loop() {
Wire.beginTransmission(8); /* begin with device address 8 */
Wire.write("Hello Slave"); /* sends hello string */
Wire.endTransmission(); /* stop transmitting */

Wire.requestFrom(8, 9); /* request & read data of size 9 from slave */

while(Wire.available()){
char c = Wire.read();/* read data received from slave */
Serial.print(c);
}
Serial.println();
delay(1000);
 17

}
______________________________________________________________________________
________________________________________________________________________

Sketch for Slave:

#include <Wire.h>
void setup() {
Wire.begin(8); /* join i2c bus with address 8 */
Wire.onReceive(receiveEvent); /* register receive event */
Wire.onRequest(requestEvent); /* register request event */
Serial.begin(9600); /* start serial comm. */
Serial.println("I am I2C Slave");
}
void loop() {
delay(100);
}
// function that executes whenever data is received from master
void receiveEvent(int howMany) {
while (0 <Wire.available()) {
char c = Wire.read(); /* receive byte as a character */
Serial.print(c); /* print the character */
}
Serial.println(); /* to newline */
}
// function that executes whenever data is requested from master
void requestEvent() {
Wire.write("Hi Master"); /*send string on request */
}
 18

MODULE:3
Node MCU

Fig No. 3
❑ The development board equips the ESP-12E module containing ESP8266 chip having
Tensilica Xtensa® 32-bit LX106 RISC microprocessor which operates at 80 to 160 MHz
adjustable clock frequency and supports RTOS.

❑ There’s also 128 KB RAM and 4MB of Flash memory (for program and data storage) just
enough to cope with the large strings that make up web pages, JSON/XML data, and
everything we throw at IoT devices nowadays.

❑ The ESP8266 Integrates 802.11b/g/n HT40 Wi-Fi transceiver, so it can not only connect
to a Wi-Fi network and interact with the Internet, but it can also set up a network of its
own, allowing other devices to connect directly to it.

❑ Power to the ESP8266 NodeMCU is supplied via the on- board MicroB USB connector.
 19

❑ You can also regulated 5V voltage source, the VIN pin can be used to directly supply
current the ESP8266 and its peripherals.

❑ As the operating voltage range of ESP8266 is 3V to 3.6V, the board comes with a
LDO(Low Dropout) voltage regulator to keep the voltage steady at 3.3V.

❑ It can reliably supply up to 600mA, which should be more than enough when ESP8266
pulls as much as 80mA during RF transmissions.
The ESP8266 NodeMCU has total 17 GPIO pins :

❑ ADC channel – A 10-bit ADC channel.

❑ UART interface – UART interface is used to load code serially.

❑ PWM outputs – PWM pins for dimming LEDs or controlling motors.

❑ SPI, I2C & I2S interface – SPI and I2C interface to hook up all sorts of sensors and
peripherals.

❑ I2S interface – I2S interface if you want to add sound to your project.

Fig no. 4

MODULE:4

NODE MCU Based IoT

4.1 IoT based Temperature and Humidity and Light Intensity Monitoring and
control devices using Thing Speak cloud server.
 20

Fig no. 5

#include <ESP8266WiFi.h>;
#include <WiFiClient.h>;
#include <ThingSpeak.h>;
#include <DHT.h>;
WiFiClient client;
const char* ssid = "Redmi"; //Your Network SSID
const char* password = "12345678"; //Your Network Password

unsigned long myChannelNumber = 2045473;

const char * myWriteAPIKey = "CDVUNQL9CCOTSUGB";
const char * myReadAPIKey = "C86E152W4AMV3TGP";
#define DHTPIN D2 //pin where the dht11 is connected
DHT dht(DHTPIN, DHT11);
int temp;
int hum;
int light;
int led1 = D6;
 21

int led2 = D7;

int led3 = D8;
int ldr = A0;
int val =0;
void setup(){
Serial.begin(115200);
WiFi.begin(ssid, password);
dht.begin();
ThingSpeak.begin(client);
pinMode(led1,OUTPUT);
pinMode(led2,OUTPUT);
pinMode(led3,OUTPUT);
}
void loop(){

float h = dht.readHumidity();
float t = dht.readTemperature();
Serial.println(h);
Serial.println(t);
val = analogRead(ldr);
Serial.println(val);
ThingSpeak.setField(1, h);
ThingSpeak.setField(2, t);
ThingSpeak.setField(3, val);
ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey);
hum = ThingSpeak.readIntField(myChannelNumber, 1, myReadAPIKey);
temp = ThingSpeak.readIntField(myChannelNumber, 2, myReadAPIKey);
 22

light = ThingSpeak.readIntField(myChannelNumber, 3, myReadAPIKey);

Serial.println(hum);
if(hum<100)
{
digitalWrite(led1,HIGH);
}
else
{
digitalWrite(led1,LOW);
}
Serial.println(temp);
if(temp<40)
{
digitalWrite(led2,HIGH);
}
else
{
digitalWrite(led2,LOW);
}
Serial.println(light);
if(light<200)
{
digitalWrite(led3,HIGH);
}
else
{
digitalWrite(led3,LOW);
 23

}
delay(15000);
}

4.2 IoT based Light Intensity Monitoring and control devices using UBIDOTS
cloud server (MQTT Protocol Based).

#include "UbidotsESPMQTT.h"
#include <ESP8266WiFi.h>
int ldrPin = A0;
/**************
* Define Constants
**************/
#define TOKEN "BBFF-x5e4HGEd4oiVIl6M34KiuJqD6qU3Cx" // Your Ubidots
TOKEN
#define WIFINAME "Redmi" //Your SSID
#define WIFIPASS "12345678" // Your Wifi Pass

Ubidots client(TOKEN);
int LED = D5;
char* variable1 = "led";
char* variable2 = "ldr";

/**************
* Auxiliar Functions
**************/
 24

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]);
}
if ((char)payload[0]=='1'){
digitalWrite(D5, HIGH);
}
else{
digitalWrite(D5, LOW);
}
Serial.println();
}
void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
client.setDebug(true); // Pass a true or false bool value to activate debug messages
client.wifiConnection(WIFINAME, WIFIPASS);
client.begin(callback);
pinMode(D5, OUTPUT);
client.ubidotsSubscribe("MQTT",variable1);
}
void loop() {
// put your main code here, to run repeatedly:
if(!client.connected()){
 25

client.reconnect();
}
int ldrValue = analogRead(ldrPin);
Serial.println(ldrValue);
client.add(variable2, ldrValue);
client.ubidotsPublish("MQTT");
client.loop();
delay(6000);
}

4.3 IoT based Temperature and Humidity Monitoring and control devices
using FireBase cloud server.

#include "FirebaseESP8266.h" // Install Firebase ESP8266 library

#include <ESP8266WiFi.h>
#include <DHT.h> // Install DHT11 Library and Adafruit Unified Sensor Library
#define FIREBASE_HOST "https://subhajit-7af42-default-rtdb.asia-
southeast1.firebasedatabase.app//" //Without http:// or https:// schemes
#define FIREBASE_AUTH
"AIzaSyA6gMCNCc82nnRy5mfD51nr9ViPYc6LVWs"
#define WIFI_SSID "Redmi"
#define WIFI_PASSWORD "12345678"
#define DHTPIN D4 // Connect Data pin of DHT to D2
int led = D5; // Connect LED to D5
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

//Define FirebaseESP8266 data object

 26

FirebaseData firebaseData;
FirebaseData ledData;

//FirebaseJson json;
void setup()
{
Serial.begin(9600);
dht.begin();
pinMode(led,OUTPUT);
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
Firebase.begin(FIREBASE_HOST, FIREBASE_AUTH);
Firebase.reconnectWiFi(true);
}
void sensorUpdate(){
float h = dht.readHumidity();
float t = dht.readTemperature();
if (isnan(h) || isnan(t) ) {
Serial.println(F("Failed to read from DHT sensor!"));
return;
}
Serial.println(h);
Serial.println(t);
if (Firebase.pushFloat(firebaseData, "/FirebaseIOT/temperature", t))
{
Serial.println("PASSED");
}
else
 27

{
Serial.println("FAILED");
}
if (Firebase.pushFloat(firebaseData, "/FirebaseIOT/humidity", h))
{
Serial.println("PASSED");
}
else
{
Serial.println("FAILED");
}
}
void loop() {
sensorUpdate();
if (Firebase.getString(ledData, "/FirebaseIOT/led")){
Serial.println(ledData.stringData());
if (ledData.stringData() == "1") {
digitalWrite(led, HIGH);
}
else if (ledData.stringData() == "0"){
digitalWrite(led, LOW);
}
}
delay(100);
}

MODULE: 5
 28

Introduction to Raspberry Pi

Fig no. 6

The Raspberry Pi is a small computer (which includes the processor, graphics card, and memory in
a single package.), about the size of a credit card which was developed in UK by the Raspberry Pi
Foundation. Name of Raspberry Pi is combination of Raspberry and Pi, where raspberry is fruit
name and pi stand for Python.
 29

Fig no. 7

Control Led using RPi

import time
#import RPi.GPIO as GPIO
from RPi import GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(21,GPIO.OUT)
try:
while True:
GPIO.output(21,GPIO.HIGH)
time.sleep(1)
print("On")
 30

GPIO.output(21,GPIO.LOW)
time.sleep(1)
print("Off")

except KeyboardInterrupt:
pass
finally:
GPIO.cleanup()

MODULE: 6
RPi Based IoT
6.1 IoT based Temperature and Humidity Monitoring using Thing Speak
cloud server.
import sys
import urllib.request
from time import sleep
import Adafruit_DHT as dht

# Enter Your API key here

myAPI = 'T0RGBR7N1ARD9XWB'
# URL where we will send the data, Don't change it
baseURL = 'https://api.thingspeak.com/update?api_key=%s' % myAPI
def DHT11_data():
# Reading from DHT11 and storing the temperature and humidity
humi, temp = dht.read_retry(dht.DHT11, 21)
return humi, temp
while True:
 31

try:
humi, temp = DHT11_data()

# If Reading is valid
if isinstance(humi, float) and isinstance(temp, float):
# Formatting to two decimal places
humi = '%.2f' % humi
temp = '%.2f' % temp
print(humi)
print(temp)

# Sending the data to thingspeak

conn = urllib.request.urlopen(baseURL + '&field1=%s&field2=%s' %
(temp, humi))
conn.read()
# Closing the connection
conn.close()
else:
print ('Error')

# DHT11 requires 2 seconds to give a reading, so make sure to add delay of above 2
seconds.
sleep(20)
except:
break
6.2 Human Motion Detection and post to UBIDOTS cloud server.
from gpiozero import MotionSensor
import json,requests
 32

import time
PIR = MotionSensor(21)

url = "http://things.ubidots.com"
TOKEN = "BBFF-x5e4HGEd4oiVIl6M34KiuJqD6qU3Cx" # Put your TOKEN
here
DEVICE_LABEL = "pir"
url = "{}/api/v1.6/devices/{}".format(url, DEVICE_LABEL)
headers = {"X-Auth-Token": TOKEN, "Content-Type": "application/json"}
#VARIABLE_LABEL_1 = "dust-sensor" # Put your first variable label here
#VARIABLE_LABEL_2 = "alcohol" # Put your second variable label here
VARIABLE_LABEL_3 = "PIR"

def value (PIR):

payload = {
VARIABLE_LABEL_3 : PIR}
status = 400
attempts = 0
while status >= 400 and attempts <= 5:
req = requests.post(url=url, headers=headers, json=payload)
status = req.status_code
attempts += 1
time.sleep(1)
if status >= 400:
print("[ERROR] Could not send data after 5 attempts, please check \
your token credentials and internet connection")
return
while True:
 33

PIR.wait_for_motion()
print("You moved")
value(1)
PIR.wait_for_no_motion()
print("Don't Moved")
value(0)

6.3 Data gets from UBIDOTS cloud server. (IoT based Automation)
import time
import requests
import RPi.GPIO as GPIO
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(21,GPIO.OUT)
DEVICE ="LED"
VARIABLE1 ="BLINK"
TOKEN = "BBFF-x5e4HGEd4oiVIl6M34KiuJqD6qU3Cx"
try:
while True:
light1 =
requests.get("http://things.ubidots.com/api/v1.6/devices/"+DEVICE+"/"+VARIABL
E1+"/lv?token="+TOKEN)
print(light1.content) # Returns the content of the response, in bytes
print(light1.json()) # Returns a JSON object of the result
data = light1.json()
print(type(data))
if data==1.0:
 34

GPIO.output(21,GPIO.HIGH)
#GPIO.output(26,GPIO.LOW)
print("On")
#time.sleep(3)
if data==0.0:
GPIO.output(21,GPIO.LOW)
#GPIO.output(26,GPIO.HIGH)
print("Off")
#time.sleep(3)
except KeyboardInterrupt:
pass
finally:
GPIO.cleanup()
light1 = ''