1

LAMPIRAN

Timeline
N

Jenis Kegiatan

Jadwal Kegiatan
Septemb

er
XX

Oktober

Novembe
r

Pengajuan

Penulisan BAB I

X X

3.

Penulisan BAB

X X X X X

4.

II

5.

Penulisan BAB

6.

III

7.

Penulisan BAB

8.

IV
Penulisan BAB
V
Pelaporan
Proma

Desembe

Januari

X X

X X X X X X X
X X X X X X X X
X X
X

2
Lampiran 2. Kode Program
// v.1.0
#include <Wire.h>
#include <Time.h>
#include <DS1307RTC.h>
#include <TimedAction.h>
#include <DHT.h>
#include <LiquidCrystal_I2C.h>
#define I2C_ADDR 0x27
#define BACKLIGHT_PIN 3
#define En_pin 2
#define Rw_pin 1
#define Rs_pin 0
#define D4_pin 4
#define D5_pin 5
#define D6_pin 6
#define D7_pin 7
LiquidCrystal_I2C
lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin,BACKLIGHT_PIN,POSITIVE);
//
TimedAction halfS = TimedAction(500,rutinHalf);
TimedAction oneS = TimedAction(1000,rutin1s);
TimedAction fiveS = TimedAction(5000,rutin5s);
TimedAction tenS = TimedAction(10000,rutin10s);

//### device ###

const byte devID = 201; // server ID 1xx ; client ID 2xx
volatile boolean registeredDev = false;
boolean servAv=false;
// #### communication ####
//String str = "";
//word masterID;
//String inString = "";
//boolean stringComplete = false;
//############## input var ###############
#define IR A3

3
volatile boolean irState = false;
boolean countIRst=false;
byte countIRval=0;
//** sensor GAS-api ***
#define api A1
volatile boolean apiState;
#define gas A2
volatile boolean gasState;
byte preAlert;
#define button 2
word btState;
word lastBtState = HIGH; //comm emiter
unsigned long lastDeb = 0;
volatile byte btVal;
volatile byte btCount;
//
//** sensor pir ***/
#define pir1 4
boolean pirSt[2] = {0,0};
byte countPir;
char countPirBuf[3] ="";
byte moveCount;
//#### DHT ########
#define DHTPIN 5
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
volatile byte hum = 0;
volatile byte temp = 0;
//
// **** sw Sens ****/
#define sw1 6
volatile boolean swState[2] = {0,0};
//
// ########### OUTPUT var ##############
#define unlock1 8
#define lock1 9

4
boolean lockState[3];
//***** ALARM ****
#define buzzer 10
unsigned long beepPrevMill = 0;
boolean beepState = false;
volatile byte beepVal = 0;
boolean beepWstate=false;
boolean beepWarning=false;
unsigned long prevB3Mill = 0;
unsigned long prevB3Mill2 = 0;
#define alarm 11
unsigned long alarmPrevMill = 0;
boolean alarmState = false;
boolean msgBeep;
float sinVal;
int toneVal;
// *** indicLED ***/
#define warnLed 12
boolean warningLed = false;
volatile unsigned long prevWarnLedMill = 0;
word warnLedState = LOW;
#define indicLed 13
volatile unsigned long prevIndicMill = 0;
//volatile unsigned long prevIndicMill2 = 0;
boolean indicState = false;
//
// ##### i2c dev ########
/**** lamp ****/
#define lampChip 0x21
volatile byte lampProfil;
volatile byte lastLampProfil;
// bacaan ldr u/ sens la

byte lampSt;
//
// #### deci State ###
//****** others ******

5
byte jam;
char jamBuf[3] ="";
char mnitBuf[3] ="";
volatile boolean jamKerja = false;
volatile boolean lembur = false;
volatile boolean onFire = false;
volatile boolean alert = false;
volatile boolean lockedAll = false;
volatile boolean anyMotion = false;
volatile boolean anyHuman = false;
volatile boolean highTemp = false;
//#####
//volatile float interv;
//volatile unsigned int highsInterv=0;
// kirim string serial
//- tiap 2 detik

// ## display state
boolean lcdAv = true;
boolean lcdAuto = true;
#define row 20
#define col 4
//String warnPrint[3];
String lastWarnPrint="";
String newWarnPrint="";
String lastPrint="";
String newPrint="";
String newPrint2="";
boolean lockPrint = false;
byte lockPrintS;
byte lockPrintS2;
boolean dtk=false;

//animasi lcd
byte a=0;
byte b=19;
//########################################################

6
//************* SETUP *********************************
void setup() {
Serial.begin(9600);
lcd.begin(col,row);
lcd.home ();
Wire.begin();
setSyncProvider(RTC.get);
// **** INPUT *****/
//DDRD = B11111110; // sets Arduino pins 1 to 7 as outputs, pin 0 as input
//DDRD = DDRD | B11111100; // this is safer as it sets pins 2 to 7 as outputs
// without changing the value of pins 0 & 1, which are RX & TX
pinMode(pir1, INPUT);
//digitalWrite (pir, LOW);
pinMode(IR, INPUT);
pinMode(api, INPUT);
pinMode(gas, INPUT);
pinMode(button, INPUT);
// **** OUTPUT ****
pinMode (indicLed, OUTPUT);
digitalWrite(indicLed, LOW);
pinMode (warnLed, OUTPUT);
digitalWrite(warnLed, LOW);
pinMode(buzzer, OUTPUT);
digitalWrite(buzzer, LOW);
pinMode(alarm, OUTPUT);
digitalWrite(alarm, LOW);
pinMode(lock1, OUTPUT);
digitalWrite(lock1, LOW);
pinMode(unlock1, OUTPUT);
digitalWrite(unlock1, LOW);

// ####### pin mode ########

//
Serial.print(F("devID:"));
Serial.println(devID);
//
// ### pre set ###

7
swCek();
if (swState[1]){
doUnlock1();
if (swState[1]) {
Serial.println(F("pintu gagal terbuka"));
}
}
lampWrite(B00000000);

//nyalakan semua krn mod lamp active LOW

//
Serial.println(F("kalibrasi sensor "));
lcd.setCursor(0,0);
lcd.print("kalibrasi sensor....");
lcd.setCursor(0,1);
for(int i = 0; i < 20; i++){
lcd.setCursor(i,1);
Serial.print(".");
lcd.print(".");
indicState=!indicState;
digitalWrite(indicLed, indicState);
delay(1000);
}

Serial.println(F("."));
Serial.print(F("devID : "));
Serial.print(devID);
Serial.println(F(" started !!"));
lcd.clear();
lcd.setCursor(0,0);
lcd.print("devID :");
lcd.setCursor(8,0);
lcd.print(devID);
lcd.setCursor(0,1);
lcd.print("started!");
Serial.flush();
// buzzer dan warnled startup
digitalWrite(buzzer, HIGH);
//PORTB|=_BV(PB5);

8
digitalWrite(warnLed, HIGH);
delay(200);
digitalWrite(buzzer,LOW);
//PORTB &=~_BV(PB5);
digitalWrite(warnLed,LOW);
delay(700);
digitalWrite(alarm, HIGH);
digitalWrite(warnLed,HIGH);
delay(200);
digitalWrite(alarm,LOW);
digitalWrite(warnLed,LOW);
}
/*
########################################################
####################### SETUP END #######################
########################################################
*/
void loop() {
byte awal=millis();
// ***************** cekSensor *****************/
if (registeredDev==true) {
;
}
ser();
BTCek();
//cek timed rutin
halfS.check();
oneS.check();
//twoS.check();
fiveS.check();
tenS.check();
deci();
lcdUpdate();
//sAnimate();
if (indicState) {
unsigned long currIndicMill = millis();
if(currIndicMill - prevIndicMill > 200) {

9
prevIndicMill = currIndicMill;
digitalWrite(indicLed, LOW);
indicState=false;
}
}
}

void ser(){
if(Serial.available()>0){
byte inByte = Serial.read();
switch (inByte) {
case '0':
if (alert) {
terminator();
Serial.println("warning terminated by remote");
if (lcdAv){
lcd.clear();
lcd.setCursor(0,0);
//lcd.print("

");

lcd.print("warning terminated !");

lcd.setCursor(0,1);
//lcd.print("

");

lcd.print("by remote");
lockPrint=true;
}
} else {
newPrint="tidak ada terminasi";
}
break;
case '1':
Serial.println("ok1");
newPrint = ">>>> ok1 <<<<

";

break;
case '2':
lcdAv=!lcdAv;
if (lcdAv) {
Serial.println("LCD activated");

10
lcd.on();
lcd.clear();
//lastPrint="";
newPrint="wellcome boss !

";

} else {
newPrint="LCD disable

";

delay(3000);
lcd.clear();
lcd.off();
Serial.println(F("LCD disable"));
}
break;
case '3':
lcdAuto=!lcdAuto;
if (lcdAuto) {
newPrint="LCD set Auto

";

delay (3000);
} else {
newPrint="LCD set manual

";

}
break;
case '4':
if (lockState[1]){
Serial.println(F("pintu 1 dibuka via remote"));
newPrint = "buka via remote";
doUnlock1();
} else {
Serial.println(F("pintu 1 sudah terbuka sebelumnya"));
newPrint = "perintah salah

";

}
break;
case '5':
if (!lockState[1]){
Serial.println(F("pintu 1 ditutup via remote"));
newPrint = "tutup via remote
doLock1();
} else {

";

11
Serial.println(F("pintu 1 sudah tertutup sebelumnya"));
newPrint = "perintah salah

";

}
break;
case '6':
lembur=!lembur;
break;
case '9':
servAv=!servAv;
break;
default:
newPrint="input salah

";

}
}
}
void terminator(){
lastWarnPrint=newWarnPrint;
btVal = 0;
beepVal =0;
alarmState = false;
warningLed = false;
digitalWrite(warnLed, LOW);
beepState = false;
onFire = false;
alert = false;
noTone(buzzer);
noTone(alarm);
}
// ########## cek sens ######## //
void deci(){
//************ warning cek (1PRIOR) ***************/
//memuat kondisi berbahaya

if (!onFire) {
if (apiState || gasState){
if (highTemp) {

12
onFire = true;
newWarnPrint = "kebakaran";
if (!jamKerja) {
doUnlock1();
}
}
if (apiState){
newPrint = "terdeteksi api

";

} else if (gasState){
newPrint = "terdeteksi gas

";

}
}
} else {
alert=true;
}
// ######### triger warning output #####
if (alert){
beepState=1;
if(alarmState) {
alarmTriggered();
}
if(beepState) {
beepON();
warnLedBlink();
}
}
/*######## warning end #############*/
if (lockState[1] && swState[1]) {
lockedAll = true;
} else {
lockedAll = false;
}
// ##### end deci #########
//pengenolan
// var btVal button bermasalah di pengenolan button jika kurang dari 50000
if (btVal >= 1 && btCount>30) {
btVal = 0;

13
btCount=0;
}
}
//

// ### schedule #### //

void cekTime() {
jam = hour();
if ( jam >= 9 && jam <16 ) {
jamKerja = true;
lampProfil = 1;
} else {
jamKerja = false;
}
if (jam >= 16 && jam < 22) {
lampProfil = 2;
//malam hari
}
if (jam >=22 || jam <=6) {
lampProfil = 3;
//tengah malam
}
if (jam > 6 && jam < 9) {
lampProfil = 4;
//pagi hari non aktif
}
}
// ******** scheduled end ********

/**************** timed rutin *****************/

void rutinHalf(){
apiState=!apiCek();
//
beepWarn();
//
pirCek();

14
if (lcdAuto){
irCek();
}
}
//********************************************
void rutin1s(){
//// tes
/*
Serial.println("warnPrint");
Serial.println(newWarnPrint);
Serial.println(warnPrint[1]);
Serial.println(warnPrint[2]);
Serial.println(warnPrint[3]);
*/
// end tes
//swCek();
gasCek();
dtk=!dtk;
//
if (gasState || apiState) {
preAlert++;
Serial.println(preAlert);
if (preAlert>=6 && preAlert <10 ) {
beepWarning=true;
newPrint="pemicu kebakaran ";
} else if (preAlert>=10){
alert=true;
newWarnPrint="pemicu kbkr";
}
} else {
preAlert=0;
}
//
/*
if (newWarnPrint!=warnPrint[1]) {
warnPrint[2]=warnPrint[1];
newWarnPrint=warnPrint[1];

15
}
*/
//Serial.println(F("1 : "));
if(newPrint=lastPrint) {
lockPrintS2++;
if (lockPrintS2=10){
lastPrint="";
}
}
if (lockPrint) {
lockPrintS++;
/*newPrint2=newPrint;
if ( newPrint2 != newPrint) {
lockPrintS=0;
} else */ if (lockPrintS>=10){
lockPrint=false;
lockPrintS=0;
lastPrint=newPrint;
}
}
// Serial.print("api : ");
// Serial.println (apiState);
if (beepState){
beepVal++;
if (beepVal >= 5) {
beepVal =0;
beepState = false;
noTone(buzzer);
alarmState = true;
}
} else if(msgBeep) {
byte bpCount;
if (bpCount<=10) {
bpCount++;
//beep3();
} else {
bpCount=0;

16
}
}
if (btVal >= 1 && !beepState) {
btCount++;
}
//////////////////////////
if (countIRst){
countIRval ++;
}
if (irState) {
countIRval=0;
}
//
if (pirSt[1]||anyHuman) {
countPir++;
}
if(lcdAv){
sprintf(countPirBuf, "%02d", countPir);
}
/*
Serial.print("countIRval : ");
Serial.println (countIRval);
Serial.print("gerak1 : ");
Serial.println (pir1St);
Serial.print(F("onFire : "));
Serial.println (onFire);
Serial.print(F("highTemp : "));
Serial.println (highTemp);
Serial.print(F("btVal : "));
Serial.println (btVal);
Serial.print("sensSt : ");
*/
if (servAv) {
Serial.print(devID);
Serial.print(";");
// Serial.print("allSt : ");
Serial.print("S;");

17
boolean allSt[17]={
irState,

//1

apiState,

//2

gasState,

//3

pirSt[1],

//4

swState[1], //5
lockState[1], //6
btState,

//7

beepState, //8
alarmState, //9
alert,

//10

onFire, //11
anyHuman,
highTemp,
jamKerja,
lcdAv,

//12
//13
//14

//15

lcdAuto,

//16

lembur

//17

};
for (byte i=0; i<17; i++){
Serial.print(allSt[i]);
Serial.print(";");
}
Serial.println("#");
//######## kirim semua sensor value ############
Serial.print("V;");
byte aSensVal[3]={
temp,
hum,
};
for (byte v=0; v<8; v++){
Serial.print(aSensVal[v]);
Serial.print(";");
}
Serial.println("#");
//########### kirim semua lamp state
//Serial.print ("lampSt: ");

18
Serial.print("L;");
Serial.print(lampSt);
Serial.println("#");
}
AnimDisplay();
}

//***************************************************
void rutin5s(){
// Serial.println("5 :");
/* Serial.print("jamKerja : ");
Serial.println (jamKerja);
Serial.print("lock1 : ");
Serial.println (lockState[1]);
Serial.print("lockedAll : ");
Serial.println (lockedAll);
Serial.print("anyHuman : ");
Serial.println (anyHuman);
Serial.print("switch : ");
Serial.println (swState[1]);
*/
if (anyHuman && !jamKerja && !lembur) {
moveCount++;
if (moveCount<10) {
beepWstate=true;
} else if (moveCount>=10) {
moveCount=0;
beepWstate=false;
alert=true;
newWarnPrint="maling";
}
}
DHTCek();
cekTime();
digitalWrite(indicLed, HIGH);
indicState=true;
//

19
}
void rutin10s(){
//Serial.println(F("10 :"));
doLamp();
doLock();
//tes kirim all state
/*
if (servAv) {
servAv=false;
}
*/
}
void pirCek(){
pirSt[1] = digitalRead(pir1);
if(pirSt[1]) {
anyHuman=true;
countPir=0;
}
if (countPir>=5){
pirSt[1]=false;
if (countPir>=20) {
countPir=0;
//countPirBuf=0;
anyHuman=false;
}
}
}
//
void gasCek() {
word gasVal = analogRead(gas);
if (gasVal>300) {
gasState = true;
} else {
gasState = false;
}
}
//

20
boolean apiCek(){
digitalRead(api);
}
//
void DHTCek(){
hum = dht.readHumidity();
temp = dht.readTemperature();
if (temp > 37){
highTemp, beepWarning = true;
newPrint="HIGH TEMPERATURE ! ";
} else {
highTemp,beepWarning = false;
}
}

//
void irCek(){
irState=!digitalRead(IR);
if (irState && !lcdAv) {
lcdAv=true;
lcd.on();
countIRst=false;
}
if (lcdAuto && lcdAv && !irState) {
countIRst=true;
if (countIRval>=10){
lcdAv=false;
lcd.off();
countIRst=false;
countIRval=0;
}
}
}
//
void swCek(){
swState[1] = !digitalRead (sw1);
}

21
//
void BTCek() {
int reading = digitalRead(button);
if (reading != lastBtState) {
lastDeb = millis();
}
if ((millis() - lastDeb) > 25) {
if (reading != btState) {
btState = reading;
if (btState == LOW) {
btVal++;
}
}
}
lastBtState = reading;
switch (btVal) {
case 1:
if (!lcdAv) {
lcdAv=true;
lcd.on();
if (lcdAuto) {
lcdAuto=false;
}
newPrint="wellcome boss !
/*lcd.setCursor(0,0);
lcd.print("LCD Status:");
lcd.setCursor(0,12);
if (lcdAuto) {
lcd.print("auto");
} else {
lcd.print("manual");
} */
}
break;
case 3:
if (alert) {
terminator();

";

22
Serial.println(F("warning terminated by tombol"));
newPrint="terminated by button";
}
break;
case 5:
if (lcdAv && !lcdAuto) {
lcd.off();
lcdAv=false;
}
break;
case 6:
if (!lcdAuto) {
lcdAuto=true;
lcdAv=!lcdAv;
}
//
break;
case 7:
btVal=0;
//
break;
}
}
//
/************ cek sensor func END ***************/

/* ############ OUTPUT Func ############### */

void warnLedBlink() {
// knState = LOW;
unsigned long currWarnLedMill = millis();
if(currWarnLedMill - prevWarnLedMill > 500) {
prevWarnLedMill = currWarnLedMill;
warnLedState = HIGH;
}
digitalWrite(warnLed, warnLedState);
unsigned long currWarnLedMill2 = millis();

23
if(currWarnLedMill2 - prevWarnLedMill > 100) {
warnLedState = LOW;
}
digitalWrite(warnLed, warnLedState);
}

void beepON(){
unsigned long beepCurrMill = millis();
if(beepCurrMill - beepPrevMill >= 150) {
beepPrevMill = beepCurrMill;
for (int x=0; x<180; x++) {
sinVal = (sin(x*(3.1412/180)));

// convert degrees to radians then obtain sin value

toneVal = 2000+(int(sinVal*1000)); // generate a frequency from the sin value

tone(buzzer, toneVal);
}
}
}

void beepWarn(){
if (beepWarning && !alert){
digitalWrite(alarm, beepWstate);
beepWstate=!beepWstate;
} else if (!alert) {
digitalWrite(alarm, LOW);
}
}

/*
void beep3() {
unsigned long currB3Mill = millis();
if(currB3Mill - prevB3Mill > 1000) {
prevB3Mill = currB3Mill;
if (B3state == LOW)
B3state = HIGH;
digitalWrite(buzzer, B3state);
}

24
unsigned long currB3Mill2 = millis();
if(currB3Mill2 - prevB3Mill2 > 500) {
prevB3Mill2 = currB3Mill2;
B3state = LOW;
digitalWrite(buzzer, B3state);
}
}
*/
void alarmTriggered() {
//Serial.println("alarm!!!!!!!");
unsigned long alarmCurrMill = millis();
if(alarmCurrMill - alarmPrevMill >= 150) {
alarmPrevMill = alarmCurrMill;
for (int x=0; x<180; x++) {
sinVal = (sin(x*(3.1412/180)));

// convert degrees to radians then obtain sin value

toneVal = 2000+(int(sinVal*1000)); // generate a frequency from the sin value

tone(alarm, toneVal);
}
}
}

void doLock () {
lockPrint = false;
swCek();
if (!alert){
if (!jamKerja) {
if (!anyHuman) {
if (!swState[1]) {
doLock1();
if (!lockedAll) {
//beep3();
//beepState = true;
//warningLed = true;
} else {
newPrint="semua pintu terkunci";
}
}

25
} else if (!swState[1]) {
newPrint="segera keluar ruang";
}
} else if (swState[1]) {
doUnlock1();
Serial.println("jam kerja, open");
}
} else if (swState[1]) {
doUnlock1();
Serial.println("pintu dibuka karena alert");
}
}

void doLock1(){
digitalWrite(lock1, HIGH);
delay (1200);
digitalWrite(lock1, LOW);
swCek();
if (swState[1]) {
lockState[1] = true;
newPrint="pintu 1 terkunci

";

} else {
newPrint="pintu gagal tertutup";
}
}
void doUnlock1(){
digitalWrite(unlock1, HIGH);
delay (700);
digitalWrite(unlock1, LOW);
swCek();
if (!swState[1]) {
lockState[1] = false;
newPrint="pintu 1 terbuka

";

} else {
newPrint="pintu gagal terbuka ";
}
}

26

void doLamp() {
// if (lampProfil != lastLampProfil);
switch (lampProfil) {
case 1:
lampWrite(B00001101); //
lampSt=B01001111;
break;
case 2:
lampWrite(B00001001); //
lampSt=B01101111;
break;
case 3:
lampWrite(B00001100); //
lampSt=B11001111;
break;
case 4:
lampWrite(B00001011);
lampSt=B00101111;
break;
case 5:
lampWrite(B00001100);
lampSt=B11001111;
break;
default:
lampWrite(B00000000); //mati semua
lampSt=B11111111;
}
//lastLampProfil=lampProfil;
}

void lampWrite(byte _data ) {

Wire.beginTransmission(lampChip);
Wire.write(_data);
Wire.endTransmission();
}
void lcdUpdate(){

27
if (lcdAv){
if(newPrint!=lastPrint){
lockPrint = false;
//Serial.println(newPrint);
lcd.setCursor(0,2);
lcd.print("new msg :

");

lcd.setCursor(0,3);
lcd.print(newPrint);
lockPrint = true;
}
if (alert) {
if (dtk){
lcd.setCursor(0,0);
lcd.print("Warning :

");

lcd.setCursor(0,1);
lcd.print("indikasi");
lcd.setCursor(8,1);
lcd.print(" ");
lcd.setCursor(9,1);
lcd.print(newWarnPrint);
} else {
lcd.setCursor(0,0);
lcd.print("

");

lcd.setCursor(0,1);
lcd.print("

");

// kondisi normal
} else if (!lockPrint){
sprintf(jamBuf, "%02d", hour());
sprintf(mnitBuf, "%02d", minute());
lcd.setCursor(0,0);
lcd.print("devID:");
lcd.setCursor(6,0);
lcd.print(devID);
lcd.setCursor(15,0);

28
lcd.print(jamBuf);
lcd.setCursor(17,0);
if (dtk) {
lcd.print(":");
lcd.setCursor(10,0);
if (servAv){
lcd.print("> <");
} else {
lcd.setCursor(9,0);
lcd.print(" ");
lcd.setCursor(10,0);
lcd.print("=//=");
}
} else {
lcd.print(" ");
if (servAv){
lcd.setCursor(10,0);
lcd.print(" ");
lcd.setCursor(13,0);
lcd.print(" ");
lcd.setCursor(11,0);
lcd.print("><");
}
}
lcd.setCursor(18,0);
lcd.print(mnitBuf);

// ******** baris 3 ********//

lcd.setCursor(0,2);
lcd.print("T:");
lcd.setCursor(2,2);
lcd.print(temp);
lcd.setCursor(4,2);
lcd.print(" ");
lcd.setCursor(5,2);
lcd.print("H:");

29
lcd.setCursor(7,2);
lcd.print(hum);
lcd.setCursor(9,2);
lcd.print("%");
lcd.setCursor(11,2);
lcd.print("JK:");
lcd.setCursor(14,2);
lcd.print(jamKerja);
lcd.setCursor(16,2);
lcd.print("LP:");
lcd.setCursor(19,2);
lcd.print(lampProfil);
// ******** baris 4 ********//
lcd.setCursor(0,3);
lcd.print("M:");
lcd.setCursor(2,3);
lcd.print(pirSt[1]);
lcd.setCursor(3,3);
lcd.print(" ");
lcd.setCursor(4,3);
lcd.print("AH:");
lcd.setCursor(7,3);
lcd.print(anyHuman);
lcd.setCursor(8,3);
lcd.print(" ");
lcd.setCursor(9,3);
lcd.print(countPirBuf);
lcd.setCursor(11,3);
lcd.print(" ");
lcd.setCursor(12,3);
if (lockState[1]) {
lcd.print("locked ");
} else {
lcd.print("unlocked");
}
}

30

}
}

void AnimDisplay(){
if (!alert && lcdAv) {
if (a<=19) {
lcd.setCursor(a,1);
lcd.print("=");
a ++;
}
if (a>19) {
lcd.setCursor(b,1);
lcd.print("-");
b --;
}
if (b<=0) {
a=0;
b=19;
}
}
}

31

Lampiran 10. Biodata Penulis

BIODATA PENULIS

Nama

: Choirul Hifni Danudi

Tempat/Tgl. Lahir : Probolinggo, 24 januari 1986

Alamat

: Jl. Neptunus 15, Malang

No. Telepon

: 081230030010

e-mail

: danudion@gmail.com

Riwayat Pendidikan : 1. SDN I Probolinggo, lulus tahun 1999

2. SLTPN I Probolinggo, lulus tahun 2002
3. SMAN I Probolinggo, lulus tahun 2004
4. Universitas

Narotama

Surabaya,

angkatan

2011,

mengikuti ujian Tugas Akhir pada periode Agustus

2013