60

Lampiran 1

Hasil Alat Inkubator dan rangkaian sensor suhu beserta platform arduino
 61

Lampiran 2

Tabel Hasil Penelitian

Tabel 1. Hasil Perbandingan Pengambilan data sensor DHT11 dengan termometer

dan termohigrometer digital

DHT11 Termometer Termohigrometer 1 Termohigrometer 2

Suhu(°C) % RH Suhu(°C) Suhu(°C) % RH Suhu(°C) % RH
29 85.8 29.3 28.8 71 29.5 84
29.2 85.5 29.5 29 72 29.6 83
29.3 85.4 29.7 29.1 72 29.6 83
29.4 85.1 29.9 29.4 72 29.6 83
29.5 85.1 30.1 29.4 73 29.6 83
29.8 83.2 30.2 29.1 73 29.6 83
30 81.8 30.4 29.2 73 29.8 83
30.1 81 30.4 29.3 72 29.8 83
30.3 80.5 30.6 29.4 72 29.9 82
30.5 79.1 30.7 29.6 71 30.1 82
30.8 77.3 30.8 29.8 70 30.2 82
31 77 31.2 30.1 70 30.4 81
31.2 76.1 31.5 30.2 69 30.5 81
31.5 74.3 31.6 30.4 69 30.6 80
31.7 73.6 32.1 30.6 68 30.8 80
31.9 73 32.2 30.7 68 30.8 80
32 72.7 32.3 30.7 68 30.9 80
32.2 72.5 32.4 30.8 68 30.9 80
32.6 66 32.9 30.8 67 31 79
32.7 65.9 33.3 30.9 67 31.1 79
32.9 65.7 33.5 30.9 67 31.2 79
33 65.4 33.6 31 66 31.3 79
33.2 64.5 33.8 31 66 31.5 78
33.7 65.5 34 31.1 65 31.7 78
34 64.7 34.1 31.1 65 31.8 78
34.3 64.1 34.2 31.2 65 31.8 78
34.7 62.7 34.6 31.2 65 31.9 78
34.9 62.3 35 31.3 65 31.9 77
35 62.3 35.2 31.3 65 31.9 77
35.1 62 35.4 31.3 64 31.9 77
35.7 61.9 35.9 31.4 64 32 77
35.9 61 36 31.5 64 32.1 77
 62

36 60.8 36 31.6 64 32.2 77

36.3 59.8 36.5 31.8 63 32.3 77
36.8 59.7 37 32 63 32.4 77
37 59.5 37.2 32.7 62 32.6 77
37.2 58.8 37.4 32.8 61 32.8 77
37.6 56.9 37.9 33.2 60 33.1 76
37.9 55.3 38.3 33.5 60 33.4 76
38 55.1 38.5 33.6 59 33.5 76

Tabel 2. Nilai set point 36 derajat celcius

Menit Suhu DHT11 Menit Suhu DHT11

Ke- (°C) Ke- (°C)
1 26.7 31 36.1
2 27.5 32 36
3 28.5 33 35.9
4 29.4 34 35.9
5 30.2 35 36
6 31.1 36 35.9
7 31.8 37 36
8 32.3 38 36.1
9 33.2 39 35.9
10 33.8 40 35.8
11 34 41 35.7
12 34.3 42 35.7
13 34.6 43 35.8
14 35 44 35.9
15 35.3 45 36
16 35.6 46 36.1
17 36 47 35.9
18 36.1 48 35.8
19 36.5 49 35.7
20 37.2 50 35.9
21 37.8 51 36.1
22 37.3 52 36
23 36.7 53 36
24 36.2 54 36
 63

25 35.8 55 35.8
26 35.4 56 35.7
27 35.7 57 35.8
28 36.2 58 35.9
29 35.9 59 35.9
30 36 60 36
 64

Lampiran 3

Library PID logic Arduino

/*****************************************************************
*****************************
* Arduino PID Library - Version 1.0.1
* by Brett Beauregard <br3ttb@gmail.com> brettbeauregard.com
*
* This Library is licensed under a GPLv3 License

******************************************************************
****************************/

#if ARDUINO >= 100

#include "Arduino.h"
#else
#include "WProgram.h"
#endif

#include <PID_v1.h>

/*Constructor
(...)*********************************************************
* The parameters specified here are those for for which we can't set up
* reliable defaults, so we need to have the user set them.

******************************************************************
*********/
PID::PID(double* Input, double* Output, double* Setpoint,
double Kp, double Ki, double Kd, int ControllerDirection)
{

myOutput = Output;
myInput = Input;
mySetpoint = Setpoint;
inAuto = false;

PID::SetOutputLimits(0, 255); //default output limit corresponds to

//the arduino pwm limits

SampleTime = 100; //default Controller Sample Time is 0.1

seconds

PID::SetControllerDirection(ControllerDirection);
 65

PID::SetTunings(Kp, Ki, Kd);

lastTime = millis()-SampleTime;
}

/* Compute()
******************************************************************
****
* This, as they say, is where the magic happens. this function should be called
* every time "void loop()" executes. the function will decide for itself whether a
new
* pid Output needs to be computed. returns true when the output is computed,
* false when nothing has been done.

******************************************************************
****************/
bool PID::Compute()
{
if(!inAuto) return false;
unsigned long now = millis();
unsigned long timeChange = (now - lastTime);
if(timeChange>=SampleTime)
{
/*Compute all the working error variables*/
double input = *myInput;
double error = *mySetpoint - input;
ITerm+= (ki * error);
if(ITerm > outMax) ITerm= outMax;
else if(ITerm < outMin) ITerm= outMin;
double dInput = (input - lastInput);

/*Compute PID Output*/

double output = kp * error + ITerm- kd * dInput;

if(output > outMax) output = outMax;

else if(output < outMin) output = outMin;
*myOutput = output;

/*Remember some variables for next time*/

lastInput = input;
lastTime = now;
return true;
}
else return false;
}
 66

/*
SetTunings(...)******************************************************
*******
* This function allows the controller's dynamic performance to be adjusted.
* it's called automatically from the constructor, but tunings can also
* be adjusted on the fly during normal operation

******************************************************************
************/
void PID::SetTunings(double Kp, double Ki, double Kd)
{
if (Kp<0 || Ki<0 || Kd<0) return;

dispKp = Kp; dispKi = Ki; dispKd = Kd;

double SampleTimeInSec = ((double)SampleTime)/1000;

kp = Kp;
ki = Ki * SampleTimeInSec;
kd = Kd / SampleTimeInSec;

if(controllerDirection ==REVERSE)
{
kp = (0 - kp);
ki = (0 - ki);
kd = (0 - kd);
}
}

/* SetSampleTime(...)
*********************************************************
* sets the period, in Milliseconds, at which the calculation is performed

******************************************************************
************/
void PID::SetSampleTime(int NewSampleTime)
{
if (NewSampleTime > 0)
{
double ratio = (double)NewSampleTime
/ (double)SampleTime;
ki *= ratio;
kd /= ratio;
SampleTime = (unsigned long)NewSampleTime;
}
 67

/*
SetOutputLimits(...)*************************************************
***
* This function will be used far more often than SetInputLimits. while
* the input to the controller will generally be in the 0-1023 range (which is
* the default already,) the output will be a little different. maybe they'll
* be doing a time window and will need 0-8000 or something. or maybe they'll
* want to clamp it from 0-125. who knows. at any rate, that can all be done
* here.

******************************************************************
********/
void PID::SetOutputLimits(double Min, double Max)
{
if(Min >= Max) return;
outMin = Min;
outMax = Max;

if(inAuto)
{
if(*myOutput > outMax) *myOutput = outMax;
else if(*myOutput < outMin) *myOutput = outMin;

if(ITerm > outMax) ITerm= outMax;

else if(ITerm < outMin) ITerm= outMin;
}
}

/*
SetMode(...)********************************************************
********
* Allows the controller Mode to be set to manual (0) or Automatic (non-zero)
* when the transition from manual to auto occurs, the controller is
* automatically initialized

******************************************************************
************/
void PID::SetMode(int Mode)
{
bool newAuto = (Mode == AUTOMATIC);
if(newAuto == !inAuto)
{ /*we just went from manual to auto*/
PID::Initialize();
}
 68

inAuto = newAuto;
}

/*
Initialize()*********************************************************
*******
* does all the things that need to happen to ensure a bumpless transfer
* from manual to automatic mode.

******************************************************************
************/
void PID::Initialize()
{
ITerm = *myOutput;
lastInput = *myInput;
if(ITerm > outMax) ITerm = outMax;
else if(ITerm < outMin) ITerm = outMin;
}

/*
SetControllerDirection(...)********************************************
*****
* The PID will either be connected to a DIRECT acting process (+Output leads
* to +Input) or a REVERSE acting process(+Output leads to -Input.) we need to
* know which one, because otherwise we may increase the output when we
should
* be decreasing. This is called from the constructor.

******************************************************************
************/
void PID::SetControllerDirection(int Direction)
{
if(inAuto && Direction !=controllerDirection)
{
kp = (0 - kp);
ki = (0 - ki);
kd = (0 - kd);
}
controllerDirection = Direction;
}

/* Status
Funcions**********************************************************
***
* Just because you set the Kp=-1 doesn't mean it actually happened. these
* functions query the internal state of the PID. they're here for display
 69

* purposes. this are the functions the PID Front-end uses for example

******************************************************************
************/
double PID::GetKp(){ return dispKp; }
double PID::GetKi(){ return dispKi;}
double PID::GetKd(){ return dispKd;}
int PID::GetMode(){ return inAuto ? AUTOMATIC : MANUAL;}
int PID::GetDirection(){ return controllerDirection;}