Arduino

Komunikasi Modbus PZEM 003 dengan arduino sebagai master (read input register tanpa library)

Asep Kurniawan

Modbus adalah sebuah protokol komunikasi antar perangkat. Modbus tergolong sebagai komunikasi serial dengan kelebihan mampu berkomunikasi dalam bus data (lalu lintas data),  jadi dalam sebuah jaringan modbus bisa menghubungkan lebih dari 2 alat (hingga 254 alat/perangkat). Contoh penggunaan protokol modbus adalah programmable logic controllers (PLCs) serta supervisory control and data acquisition (SCADA).

Dalam protokol modbus terdapat fungsi-fungsi diantaranya :

  • Coils (1 bit) baca/tulis
  • Discrete Inputs: (1 bit) hanya baca
  • Input Registers: (2 byte) hanya baca
  • Holding Registers: (2 byte) baca/tulis

Komunikasi antara perangkat dalam jaringan modbus digambarkan dalam diagram berikut :

RS485

rs485 adalah perangkat elektronika pengirim dan penerima data (serial) umumnya menggunakan dua kabel dengan karakteristik sinyal yang seimbang. rs485 juga mampu menghubungkan lebih dari 2 perangkat komunikasi (multipoint).

rs485 sering dimanfaatkan sebagai perangkat tambahan dalam komunikasi modbus.

Pembacaan modul PZEM modbus dengan arduino sebagai master

modul pzem dikenal sebagai modul pembaca tegangan, arus, daya, energi, frekuensi dari listrik. beberapa diantaranya mendukung protokol modbus. dalam contoh ini digunakan modul pzem 003 yaitu modul pengukuran dc.

skema komunikasi modbus berbasis arduino:

komponen yang digunakan :

  1. Arduino uno
  2. modul serial rs485

sketch/program arduino untuk pembacaan sensor pzem :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
#define pinModBusTX         4
 
#include <SoftwareSerial.h>
 
SoftwareSerial pzem(2, 3); // RX, TX
 
byte perintah[] = {0x01, 0x04, 0x00, 0x00, 0x00, 0x08};//readInputRegisters
byte bufferDataModbus[100];
byte *ptr;
 
void setup() {
  pinMode(pinModBusTX, OUTPUT);
 
  Serial.begin(9600);
  Serial.println(F("Komunikasi Modbus dengan arduino sebagai master (read input register tanpa library)"));
  Serial.println(F("https://www.project.semesin.com"));
  Serial.println();
 
  pzem.begin(9600);
  ptr = bufferDataModbus;
}
 
void loop()
{
  uint16_t crc = calcCRC(perintah, sizeof(perintah));
 
  digitalWrite(pinModBusTX, HIGH);
  delay(1);
  pzem.write(perintah, sizeof(perintah));
  pzem.write(lowByte(crc));
  pzem.write(highByte(crc));
  delay(10);
  digitalWrite(pinModBusTX, LOW);
 
  long millisResponModbus = millis() + 1000;
  while (!pzem.available())
  {
    if (millisResponModbus < millis())
    {
      break;//timeout
    }
  }
 
  while (pzem.available())
  {
    byte b = pzem.read();
    *ptr++ = b;
    delay(2);
  }
 
  if (memcmp(bufferDataModbus, perintah, 2) == 0)
  {
    ptr = bufferDataModbus;
 
    float tegangan      = ((ptr[0 + 3] << 8) + ptr[1 + 3]) * 0.01;
    float arus          = ((ptr[2 + 3] << 8) + ptr[3 + 3]) * 0.01;
    float daya          = (((uint32_t)ptr[6 + 3] << 24) + ((uint32_t)ptr[7 + 3] << 16) + (ptr[4 + 3] << 8) + ptr[5 + 3]) * 0.1;
    float energi        = (((uint32_t)ptr[10 + 3] << 24) + ((uint32_t)ptr[11 + 3] << 16) + (ptr[8 + 3] << 8) + ptr[9 + 3]);
    uint16_t alarmHigh  = ((ptr[12 + 3] << 8) + ptr[13 + 3]);
    uint16_t alarmLow   = ((ptr[14 + 3] << 8) + ptr[15 + 3]);
 
    memset(bufferDataModbus, 0x00, sizeof(bufferDataModbus));
 
    Serial.println("==========");
    Serial.print("tegangan      = ");
    Serial.println(tegangan);
    Serial.print("arus          = ");
    Serial.println(arus);
    Serial.print("daya          = ");
    Serial.println(daya);
    Serial.print("energi        = ");
    Serial.println(energi);
    Serial.print("alarmHigh     = ");
    Serial.println(alarmHigh);
    Serial.print("alarmLow      = ");
    Serial.println(alarmLow);
  }
 
  Serial.println();
  delay(1000);
}
 
uint16_t calcCRC(byte *data, byte panjang)
{
  int i;
  uint16_t crc = 0xFFFF;
  for (byte p = 0; p < panjang; p++)
  {
    crc ^= data[p];
    for (i = 0; i < 8; ++i)
    {
      if (crc & 1)
        crc = (crc >> 1) ^ 0xA001;
      else
        crc = (crc >> 1);
    }
  }
  return crc;
}

 

Tombol cerdas cermat +sesi diskualifikasi menggunakan arduino

Asep Kurniawan

Cerdas cermat adalah pertandingan yang mengandalkan kecerdasan serta kecepatan. Untuk memberikan keadilan bagi seluruh group peserta, maka perangkat pendukung harus memiliki kriteria berikut :

  1. waktu scanning
    metode yang sering digunakan adalah interupsi dan scanning tombol, dalam hal penggunaan arduino uno (yang memiliki 2 external interrupt dan 23 pin change interrupt) masing-masing memiliki kelemahan dan kelebihan :

    • metode interruptpenggunaan external interrupt adalah metode yang paling baik, namun arduino uno hanya memiliki 2 external interrupt (hanya untuk 2 group) sehingga kurang efektif. Jika menggunakan 23 jalur external interrupt lebih banyak akan tetapi jenis interupsi ini di arduino uno terpisah dalam 3 kelompok, sehingga, seandainya 2 group cerdas cermat dalam satu kelompok interupsi menekan tombol (dalam waktu  scanning-nya) naka harus diambil salah satu group cerdas cermat saja, dan masalahnya pengambilan keputusan ini akan menjadi masalah keadilan bagi peserta.
    • metode scanning tombol
      metode ini bisa diistilahkan ‘tombol yang tepat di waktu yang tepat’ karena jika tombol cerdas cermat ditekan bersamaan, maka yang akan terpilih adalah tombol yang sedang di scanning. Namun sebetulnya waktu scanning ini sangatlah cepat, dan letak keadilannya ditentukan oleh ‘waktu’
  2.  interlock tombol
    • Ketika group yang paling cepat di sahkan, maka tombol group lain tidak berfungsi.
    • seluruh tombol group cerdas cermat hanya bisa di tekan pada saat yang ditentukan (misalkan setelah pertanyaan selesai dibacakan) jika mendahului waktu tersebut, maka tombolnya tidak berfungsi (diskualifikasi sesi pertanyaan) dengan cara menahan [tombol reset] dan melepas-nya ketika pertanyaan selesai di bacakan

blok diagram cerdas cermat menggunakan arduino:

 

skema mesin cerdas cermat berbasis arduino:

 

koding bel cerdas cermat berbasis arduino:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#define pinGroup1               2
#define pinGroup2               3
#define pinGroup3               4
#define pinGroup4               5
 
#define pinGroup1Indikator      A0
#define pinGroup2Indikator      A1
#define pinGroup3Indikator      A2
#define pinGroup4Indikator      A3
 
#define pinReset                8
#define pinBel                  9
 
#define relayAktif              LOW
#define jumlahGroup             4
#define waktuBel                3000
 
byte pinGroup[jumlahGroup] = {pinGroup1, pinGroup2, pinGroup3, pinGroup4};
byte pinGroupIndikator[jumlahGroup] = {pinGroup1Indikator, pinGroup2Indikator, pinGroup3Indikator, pinGroup4Indikator};
 
byte groupAktif;
byte groupScan;
byte tombolAktif;
long millisBel;
bool statusTombol;
bool statusSesi;
bool sesi[jumlahGroup];
 
// the setup routine runs once when you press reset:
void setup() {
  Serial.begin(9600);
  Serial.println(F("Tombol cerdas cermat berbasis arduino"));
  Serial.println(F("https://www.project.semesin.com"));
  Serial.println();
 
  for (int i = 0; i < sizeof(pinGroup); i++)
  {
    pinMode(pinGroup[i], INPUT_PULLUP);
    pinMode(pinGroupIndikator[i], OUTPUT);
  }
 
  pinMode(pinReset, INPUT_PULLUP);
 
  digitalWrite(pinBel, !relayAktif);
  pinMode(pinBel, OUTPUT);
 
  memset(sesi, 1, 4);
}
 
// the loop routine runs over and over again forever:
void loop() {
 
  groupScan = (groupScan + 1) % jumlahGroup;
  if (!digitalRead(pinGroup[groupScan]))
  {
    if (tombolAktif)
    {
      if (sesi[groupScan])
      {
        groupAktif = groupScan + 1;
        statusTombol = true;
        statusSesi = true;
      }
    }
    else if (!statusSesi)
    {
      if (sesi[groupScan])
      {
        sesi[groupScan] = false;
        Serial.print("Diskualifikasi : ");
        Serial.println(groupScan + 1);
      }
    }
  }
 
  if (!digitalRead(pinReset))
  {
    delay(50);
 
    if (!digitalRead(pinReset))
    {
      tombolAktif = false;
      if (groupAktif)
      {
        digitalWrite(pinGroupIndikator[groupAktif - 1], LOW);
        digitalWrite(pinBel, !relayAktif);
        groupAktif = 0;
        Serial.println("Reset");
        statusSesi = false;
        memset(sesi, 1, 4);
      }
    }
  }
  else if (groupAktif)
  {
    if (statusTombol)
    {
      Serial.print("Group : ");
      Serial.println(groupAktif);
 
      millisBel = millis() + waktuBel;
      digitalWrite(pinBel, relayAktif);
 
      digitalWrite(pinGroupIndikator[groupScan], HIGH);
      statusTombol = false;
      tombolAktif = false;
    }
  }
  else if (!tombolAktif)
  {
    Serial.println("Sesi mulai");
 
    tombolAktif = true;
  }
 
  if (millisBel < millis())
  {
    digitalWrite(pinBel, !relayAktif);
  }
}

 

Pewaktu otomatis dengan arduino (aplikasi pemberi pakan ikan)

Asep Kurniawan

Pewaktu otomatis adalah perangkat bekerja menggunakan real time clock (RTC) sebagai basis waktu dan menghasilkan output aksi tepat pada waktu yang ditentukan.

setting waktu alarm

program ini akan setiap detik menmbandingkan/mencek apakah waktu alarm sama sama dengan waktu saat ini, untuk menentukan waktu alarm dalam contoh ini menggunakan 2 waktu alarm dengan cara mengatur variabel pada bagian ini :


#define waktuMakan1 DateTime(0, 1, 1, 8, 0, 0, 0)//jam 8 pagi
#define waktuMakan2 DateTime(0, 1, 1, 17, 0, 0, 0)//jam 5 sore

kelas date time diisi nilai tahun, bulan, tanggal, jam, menit, detik, hari.
namun untuk pengplikasian di sketch pemberi makanan ikan ini hanya diset bagian jam, menit dan detik dengan tujuan nilai waktu ini berulang setiap hari.

Waktu makan ikan

Pada contoh ini perangkat akan menggerakkan servo pemberi makan ikan pada jam 8 pagi dan jam 5 sore.

skema pemberi makan ikan menggunakan arduino :

 

koding/program feeder ikan berbasis arduino:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#define pinServoMakanan               A0
   
#define waktuBukaServo                1000//milidetik
#define servoBuka                     20//derajat
#define servoTutup                    60//derajat
   
#define waktuMakan1                   DateTime(0, 1, 1,  8, 0, 0, 0)//jam 8 pagi
#define waktuMakan2                   DateTime(0, 1, 1, 17, 0, 0, 0)//jam 5 sore
   
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include "Sodaq_DS3231.h"
#include <Servo.h>
   
LiquidCrystal_I2C lcd(0x3F, 16, 2);//coba juga 0x27
Servo servoMakanIkan;
   
byte detikSebelumnya;
char buf[17];
 
   
void setup() {
  Serial.begin(9600);
  Serial.println("Pemberi pakan ikan otomatis");
  Serial.println("https://www.project.semesin.com");
     
  servoMakanIkan.attach(pinServoMakanan);
  servoMakanIkan.write(servoTutup);
   
  Wire.begin();
  rtc.begin();
  //DateTime dt(2011, 11, 10, 15, 18, 0, 5); // set tanggal dan waktu (format): tahun, bulan tanggal, jam, menit, detik, hari (1=minggu, 7=sabtu)
  //rtc.setDateTime(dt);
   
  Wire.beginTransmission(0x3F);
  if (Wire.endTransmission())
  {
    lcd = LiquidCrystal_I2C(0x27, 16, 2);
  }
  lcd.begin();
   
  lcd.backlight();
   
  lcd.print("Pemberi ");
  lcd.setCursor(0, 1);
  lcd.print("pakan ikan");
  delay(3000);
  lcd.clear();
   
  Serial.println("Sistem mulai");
  sprintf(buf, "Set waktu 1 = %02d:%02d (%lu)", waktuMakan1.hour(), waktuMakan1.minute(), waktuMakan1.get());
  Serial.println(buf);
  sprintf(buf, "Set waktu 2 = %02d:%02d (%lu)", waktuMakan2.hour(), waktuMakan2.minute(), waktuMakan2.get());
  Serial.println(buf);
}
   
void loop() {
   
  DateTime now = rtc.now();
  if (detikSebelumnya != now.second())
  {
    sprintf(buf, "%02d:%02d:%02d", now.hour(), now.minute(), now.second());
    lcd.setCursor(4, 0);
    lcd.print(buf);
    Serial.print(buf);
   
    detikSebelumnya = now.second();
   
    uint32_t epoch = now.get() % 86400;//hanya jam menit detik
   
    if ((epoch == waktuMakan1.get()) ||
        (epoch == waktuMakan2.get()))
    {
      char buf[17];
      sprintf(buf, "Pakan = %02d:%02d", now.hour(), now.minute());
      lcd.setCursor(0, 1);
      lcd.print(buf);
      Serial.println(buf);
   
      servoMakanIkan.write(servoBuka);
      delay(waktuBukaServo);
      servoMakanIkan.write(servoTutup);
   
    }
  }
}

 

Library pemberi pakan ikan otomatis :

Input angka menggunakan keypad pada Arduino

Asep Kurniawan

Keypad untuk arduino terdiri atas numerik 0-9 serta ‘*’ dan ‘#’ berfungsi sebagai input bagi arduino. Arduino membaca keypad (type membrane) dengan metode scanning 7 kabel (untuk keypad 3×4), atau adc satu kabel. Dengan menggunakan library keypad, nilai input yang diterima arduino sudah berupa karakter ‘0’ – ‘9’, ‘*’ dan ‘#’, nilai ini bisa baca langsung sebagai perintah seperti contoh berikut ”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void loop(){
  char key = keypad.getKey();
   
  if (key){
    Serial.println(key);
    switch(key)
    {
      case '0':
        digitalWrite(2, HIGH);
        break;
      case '1':
        digitalWrite(3, HIGH);
        break;
      case '*'://reset
        digitalWrite(2, LOW);
        digitalWrite(3, LOW);
        break;
    }
  }
}

Input deret angka

Supaya keypad berfungsi sebagai input nilai angka (misal 0-1000) seperti untuk keperluan input variabel ‘setting batas sensor analog’, maka keypad dibaca beberapa kali dengan ketentuan:

  • karakter ‘0’ – ‘9’ sebagai input numerik
  • karakter ‘*’ berfungsi sebagai reset (kembali ke 0)
  • karakter ‘#’ berfungsi sebagai enter layaknya keybboard laptop dan menyimpan pembacaan keypad sebagai nilai variabel

berikut skema yang digunakan untuk pembacaan keypad dengan arduino:

koding input nilai variabel dari keypad :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Keypad.h>
 
const byte ROWS = 4;
const byte COLS = 3;
char keys[ROWS][COLS] = {
  {'1', '2', '3'},
  {'4', '5', '6'},
  {'7', '8', '9'},
  {'*', '0', '#'}
};
byte rowPins[ROWS] = {8, 7, 6, 5};
byte colPins[COLS] = {4, 3, 2};
 
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
LiquidCrystal_I2C lcd(0x3F, 16, 2);//coba juga 0x27
 
char stringAngka[17];
int indexKeypad = 0;
 
void setup() {
  Serial.begin(9600);
  Serial.println("Input angka menggunakan keypad");
  Serial.println("https://www.project.semesin.com/");
  Serial.println();
 
  Wire.begin();
  Wire.beginTransmission(0x3F);
  if (Wire.endTransmission())
  {
    lcd = LiquidCrystal_I2C(0x27, 16, 2);
  }
  lcd.begin();
  lcd.backlight();
  lcd.print("Input angka");
}
 
void loop() {
 
 
  char key = keypad.getKey();
 
  if (key) {
    Serial.println(key);
    switch (key)
    {
      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
        if (!indexKeypad)
        {
          lcd.clear();
        }
        stringAngka[indexKeypad++] = key;
        lcd.print(key);
        break;
      case '*'://reset
        lcd.clear();
        indexKeypad = 0;
        break;
      case '#':
        stringAngka[indexKeypad] = 0;
        lcd.setCursor(0, 1);
 
        int nilaiAngka = atoi(stringAngka);
        lcd.print(nilaiAngka);
 
        indexKeypad = 0;
        break;
    }
  }
}

contoh penggunaan keypad sebagai masukan variabel integer:

Jpeg

Putar musik .wav dari kartu memori SDCard dengan arduino

Asep Kurniawan

jenis file suara menurut sistem kompres data-nya terdiri atas file suara terkompresi dan file suara tidak dikompresi (compressed/uncompresses), yaitu metode penyimpanan data suara digital yang bertujuan memperkecil ukuran file suara dan dengan penurunan kualitas suara sekecil-kecilnya.

File suara tidak dikompres memiliki keunggulan kualitas yang asli selain itu tidak memerlukan proses dekompresi yang rumit untuk mengambil/memutar-nya menjadi suara.

WAV (waveform audio file format) adalah contoh file suara yang tidak dikompres. karena masih menyimpan data aslinya jenis file ini memiliki ukuran yang besar. tidak seperti file suara terkompresi seperti .mp3, .aac, .ogg, .wma yang mmembutuhkan algoritma/codec untuk membuka datanya, .wav bisa langsung digunakan. sehingga .wav sangat cocok untuk perangkat mikrokontroller seperti arduino yang memiliki kecepatan dan memory yang kecil.

play .wav dengan arduino

file wav disimpan dan di ambil data-nya dengan metode PCM (pulse code modulation). file wav memiliki struktur header 44 byte yang berisi informasi jum;ah channel (mono/stereo), sample rate, bit per sampel dan informasi lainnya.

Khusus penggunaan arduino untuk memutar  file .wav dengan kecepatan 16MHz hanya efektif di sample rate 32.000, 16.000, 8.000 dengan kanal mono dan 8 bit per sampel.

Skema memutar file suara .wav menggunakan arduino dari microSD

Rangkaian speaker bukan stereo (tapi unbalanced audio connection)

(seandainya menggunakan ampli) jangan hubungkan ground arduino dan ground ampli jika keluaran suara ke speaker menggunakan 2 kabel pin 9 dan 10 (gunakan salah satu saja jika ground terhubung)

koding memainkan suara dari kartu memori berbasis arduino:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
#define pinSpeakerA     9
#define pinSpeakerB     10
 
#define pinCS           8
#define faktorKali      2
 
#include <SD.h>
#include <SPI.h>
 
 
bool suaraDimainkan;
uint32_t sampleCounter;
byte ulangPerSampel;
byte ulang;
 
struct  HeaderWAV
{
  char                RIFF[4];
  unsigned long       ChunkSize;
  char                WAVE[4];
  char                fmt[4];
  unsigned long       Subchunk1Size;
  unsigned short      AudioFormat;
  unsigned short      NumOfChan;
  unsigned long       SamplesPerSec;
  unsigned long       bytesPerSec;
  unsigned short      blockAlign;
  unsigned short      bitsPerSample;
  char                Subchunk2ID[4];
  unsigned long       Subchunk2Size;
 
};
 
HeaderWAV headerWAV;
File fileSuara;
 
 
void setup(void)
{
  pinMode(pinSpeakerA, OUTPUT);
  pinMode(pinSpeakerB, OUTPUT);
 
  Serial.begin(9600);
  Serial.println("Memutar file suara .wav pada kartu memory SDCard dengan arduino");
  Serial.println("https://www.project.semesin.com/");
 
  if (!SD.begin(pinCS))
  {
    Serial.println("SD fail");
    return;
  }
}
 
void loop(void)
{
  if (!suaraDimainkan)
  {
    mainkanSuara("pulang.wav");
  }
  else
  {
    lanjutkanSuara();
  }
}
 
void mainkanSuara(char *namaFile)
{
  fileSuara = SD.open(namaFile);
  if ( !fileSuara )
  {
    Serial.println("File suara tidak ditemukan");
    return 0;
  }
 
  byte *alamat = (byte*)&headerWAV;
  for (byte i = 0; i < sizeof(headerWAV); i++)
  {
    byte data = fileSuara.read();
    *alamat++ = data;
  }
  Serial.print("namaFile=");
  Serial.println(namaFile);
  Serial.print("headerWAV.SamplesPerSec=");
  Serial.println(headerWAV.SamplesPerSec);
  Serial.print("headerWAV.NumOfChan=");
  Serial.println(headerWAV.NumOfChan);
  Serial.print("headerWAV.bitsPerSample=");
  Serial.println(headerWAV.bitsPerSample);
  Serial.print("headerWAV.Subchunk2Size=");
  Serial.println(headerWAV.Subchunk2Size);
 
  ulangPerSampel = 32000L / headerWAV.SamplesPerSec;
  ICR1 = 256;
  TCCR1A = _BV(COM1A1) | _BV(COM1B1) | _BV(WGM11);
  TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10);
 
  sampleCounter = 0;
  ulang = 0;
  suaraDimainkan = true;
}
 
void lanjutkanSuara()
{
  if (TIFR1 & _BV(TOV1))
  {
    TIFR1 |= _BV(TOV1);
    if (!(ulang++ % ulangPerSampel))
    {
      if (sampleCounter++ >= headerWAV.Subchunk2Size)
      {
        Serial.println("Selesai");
        stopPlayback();
      }
      else
      {
        byte data = fileSuara.read();
 
        uint16_t sample = data;
        OCR1B = 256 - sample;
        OCR1A = sample;
      }
    }
  }
}
 
 
void stopPlayback()
{
  TIMSK1 &= ~_BV(OCIE1A);
  TCCR1B &= ~_BV(CS10);
  OCR1A = 128;
  OCR1B = 128;
 
  fileSuara.close();
  digitalWrite(pinSpeakerA, LOW);
  digitalWrite(pinSpeakerB, LOW);
 
  suaraDimainkan = false;
}

contoh file .wav mono 16kHz 8 bit:
pulang.wav

Audio Player

Enkripsi sederhana berbasis arduino (Improve XOR)

Asep Kurniawan

Sistem keamanan komunikasi arduino

Arduino memiliki port komunikasi bawaan seperti Serial, SPI, I2C dan di beberapa jenis arduino juga memiliki JTAG, USB, CAN, selain itu arduino juga dapat ditambahkan modul komunikasi seperti Bluetooth, BLE, WiFi, Ethernet, GPRS dan lainnya.

Masing-masing memiliki protokol, namun sebagian besar transfer data-nya dengan mudah diretas, misalnya komunikasi Serial: dengan menyadap jalur rx/tx dengan baud rate yang sesuai maka data-datanya sudah bisa di baca.

Enkripsi adalah metode menyembunyikan informasi melalui proses enkripsi dan hanya dapat dibaca setelah melalui proses decode dengan kunci yang tepat.

terdapat bermacam-macam metode enkripsi mulai dari metode lama seperti substitusi, transposisi hingga metode enkripsi modern seperti MD2, MD4, MD5, SHA, RC4, Base64. Metode-metode ini memiliki kelebihan dan kekurangan masing-masing.

Penerapan metode enkripsi pada aplikasi arduino dibatasi oleh kecepatan dan kapasitas memori arduino itu sendiri terutama jika transmisi data dalam jumlah besar.

Metode XOR

XOR adalah operasi logika yang memberikan hasil yang sama jika diterapkan dua kali sehingga cocok digunakan sebagai operasi enkripsi.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
void setup() {
  Serial.begin(9600);
  Serial.println(F("Enkripsi sederhana berbasis arduino"));
  Serial.println(F("https://www.project.semesin.com"));
  Serial.println();
 
  char textBiasa[]      = "semesin.com";
  char kunci[]          = "kunci";
  byte chiperTeks[32];
  char teksDecode[32];
   
  //encode
  int i;
  for (i = 0; i < strlen(textBiasa); i++)
  {
    chiperTeks[i] = textBiasa[i] xor kunci[i % sizeof(kunci)];
  }
  chiperTeks[i] = 0;
 
  Serial.print("textBiasa = ");
  Serial.println(textBiasa);
  Serial.print("kunci = ");
  Serial.println(kunci);
  Serial.print("chiperTeks = ");
  Serial.println((char*)chiperTeks);
 
  Serial.print("chiperTeks (hex) = ");
 
  //decode
  for (i = 0; i < strlen(textBiasa); i++)
  {
    Serial.print(chiperTeks[i], HEX);
    Serial.print(' ');
  }
  Serial.println();
 
  for (i = 0; i < strlen(chiperTeks); i++)
  {
    teksDecode[i] = chiperTeks[i] xor kunci[i % sizeof(kunci)];
  }
  teksDecode[i] = 0;
 
  Serial.print("teksDecode = ");
  Serial.println(teksDecode);
  Serial.println();
 
  //hack
  char textHacker[] = {0, 0, 0, 0, 0, 0};
 
  for (i = 0; i < strlen(kunci); i++)
  {
    chiperTeks[i] = textHacker[i] xor kunci[i % sizeof(kunci)];
  }
  chiperTeks[i] = 0;
 
  Serial.print("Bobol kunci = ");
  Serial.println((char*)chiperTeks);
 
}
 
void loop() {
 
 
}

kelemahan metode sederhana ini adalah mudah dibobol dengan memasukkan plaintext/teks biasa dengan 0x00.

 

Metode XORS

metode ini tetap menggunakan logika xor sebagai operator utama dengan tambahan operator penambahan/pengurangan, pertimbangan utama metode ini adalah kecepatan dan penggunaan memory yang minimal.

Metode ini di gambarkan dalam skema berikut:

koding encode dan decode berbasis arduino:

1
2
3
4
5
6
7
8
9
10
char key[] = "www.Semesin.com/";
 
byte encode(byte dataEncode, byte index)
{
  return ((dataEncode xor key[index % 8]) + key[(index % 4) + 8]) xor key[(index % 4) + 12];
}
byte decode(byte dataDecode, byte index)
{
  return ((dataDecode xor key[(index % 4) + 12]) - key[(index % 4) + 8]) xor key[index % 8];
}

Bel sekolah dengan pengaturan melalui tombol

Asep Kurniawan

Bel sekolah merupakan pengingat waktu terjadwal yang menandai pergantian antar waktu pelajaran di sekolah. Ber sekolah juga memiliki penjawalan mingguan dan bulanan.

Perangkat bel sekolah otomatis bisa diaplikasikan menggunakan arduino sebagai unit prosesornya, tidak seperti bel sekolah digital berbasis komputer yang menyimpan jadwal dalam harddisk, bel sekolah digital arduino menyimpan data jadwal pelajaran didalam EEPROM. Data Jadwal disimpan dalam format/struktur berikut :

  • Aktif
  • Jam
  • Menit

Guna mengatur data jadwal tersebut, perangkat bel sekolah ini dilengkapi dengan tombol-tombol dengan fungsi [menu], [tambah], [kurang] dan [ok].

serta penggunaan LCD sebagai tampilan waktu sekarang dan tampilan jadwal apabila waktunya telah tepat.

skema bel sekolah dengan pengaturan melalui tombol/button:

komponen yang digunakan :

  1. Arduino uno
  2. RTC DS3231
  3. LCD i2C
  4. push button 4x

sketch/koding bel sekolah arduino :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
#define pinTombolMenu       5
#define pinTombolTambah     4
#define pinTombolKurang     3
#define pinTombolOk         2
 
#include <EEPROM.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <SoftwareSerial.h>
#include "RTC.h"
 
LiquidCrystal_I2C lcd(0x3F, 16, 2); // set the LCD address to 0x27 for a 16 chars and 2 line display
RTC_DS3231 rtc;
char namaHari[][7] = {"Minggu", "Senin", "Selasa", " Rabu", "Kamis", "Jum'at", "Sabtu"};
char textMenuUtama[][17] = {
  "Bel masuk +pel 1",
  "Ganti pel 2     ",
  "Bel istirahat   ",
  "Bel masuk +pel 3",
  "Ganti pel 4     ",
  "Bel pulang      ",
  "Set Jam         ",
};
char textAktif[][6] = {"Mati ", "Aktif"};
 
char bufWaktu[40];
 
struct Jadwal
{
  bool aktif;
  byte jam;
  byte menit;
};
 
Jadwal jadwal[6] = {{0, 7, 0}, {0, 7, 0}, {0, 7, 0}, {0, 7, 0}, {0, 7, 0}, {0, 7, 0},} ;
Jadwal jadwalSet;
 
void setup()
{
  pinMode(pinTombolMenu, INPUT_PULLUP);
  pinMode(pinTombolTambah, INPUT_PULLUP);
  pinMode(pinTombolKurang, INPUT_PULLUP);
  pinMode(pinTombolOk, INPUT_PULLUP);
 
  Serial.begin (9600);
 
  rtc.begin();
 
  if (rtc.lostPower())
  {
    Serial.println(F("Waktu RTC di set ulang"));
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
 
  Wire.beginTransmission(0x3F);
  if (Wire.endTransmission())
  {
    lcd = LiquidCrystal_I2C(0x27, 16, 2);
  }
  lcd.begin();
  // Print a message to the LCD.
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Nama");
  lcd.setCursor(0, 1);
  lcd.print("Judul");
 
  //  delay(3000);
 
  if (EEPROM.read(0) != 0x48)
  {
    simpanJadwal();
    EEPROM.write(0, 0x48);
  }
  else
  {
    ambilJadwal();
  }
  Serial.println("Bel sekolah dimulai");
}
 
byte detikSebelumnya = 60;
byte menitSebelumnya = 60;
byte menuLevel = 0;
byte menuIndex[2];
DateTime setWaktu;
 
void loop()
{
  DateTime now = rtc.now();
  if (detikSebelumnya != now.detik)
  {
    detikSebelumnya = now.detik;
    if (!menuLevel)
    {
      sprintf(bufWaktu, "Pukul : %02d:%02d:%02d", now.jam, now.menit, now.detik);
      lcd.setCursor(0, 0);
      lcd.print(bufWaktu);
      sprintf(bufWaktu, "%s, %02d/%02d/%02d", namaHari[now.hari - 1], now.tanggal, now.bulan, now.tahun - 2000);
      lcd.setCursor(0, 1);
      lcd.print(bufWaktu);
 
    }
    if (menitSebelumnya != now.menit)
    {
      menitSebelumnya = now.menit;
      for (byte i = 0; i < 6; i++)
      {
        if (jadwal[i].aktif)
        {
          if ((jadwal[i].jam == now.jam) && (jadwal[i].menit == now.menit))
          {
            lcd.setCursor(0, 0);
            lcd.print("  Bel Sekolah   ");
            lcd.setCursor(0, 1);
            lcd.print(textMenuUtama[i]);
            delay(10000);
          }
        }
      }
    }
  }
 
  if (!digitalRead(pinTombolMenu))
  {
    delay(100);
    if (!digitalRead(pinTombolMenu))
    {
      if (menuLevel == 0)
      {
        menuLevel = 1;
        menuIndex[0] = 0;
      }
      else
      {
        menuLevel = 0;
        lcd.noBlink();
      }
      tampilanMenu();
      while (!digitalRead(pinTombolMenu));
    }
  }
  if (!digitalRead(pinTombolTambah))
  {
    delay(100);
    if (!digitalRead(pinTombolTambah))
    {
      if (menuLevel == 1)
      {
        menuIndex[0]++;
        if (menuIndex[0] >= sizeof(textMenuUtama) / sizeof(textMenuUtama[0]))
        {
          menuIndex[0] = 0;
        }
        tampilanMenu();
      }
      if (menuLevel == 2)
      {
        if (menuIndex[0] == 6)
        {
          switch (menuIndex[1])
          {
            case 0:
              setWaktu.jam++;
              if (setWaktu.jam >= 24)
              {
                setWaktu.jam = 0;
              }
              break;
            case 1:
              setWaktu.menit++;
              if (setWaktu.menit >= 60)
              {
                setWaktu.menit = 0;
              }
              break;
            case 2:
              setWaktu.detik++;
              if (setWaktu.detik >= 60)
              {
                setWaktu.detik = 0;
              }
              break;
          }
        }
        else
        {
          switch (menuIndex[1])
          {
            case 0:
              jadwalSet.aktif = !jadwalSet.aktif;
              break;
            case 1:
              jadwalSet.jam++;
              if (jadwalSet.jam >= 24)
              {
                jadwalSet.jam = 0;
              }
              break;
            case 2:
              jadwalSet.menit++;
              if (jadwalSet.menit >= 60)
              {
                jadwalSet.menit = 0;
              }
              break;
          }
        }
        tampilanMenu();
      }
      delay(100);
    }
  }
  if (!digitalRead(pinTombolKurang))
  {
    delay(100);
    if (!digitalRead(pinTombolKurang))
    {
      if (menuLevel == 1)
      {
        if (menuIndex[0] == 0)
        {
          menuIndex[0] = sizeof(textMenuUtama) / sizeof(textMenuUtama[0]) - 1;
        }
        else
        {
          menuIndex[0]--;
        }
        tampilanMenu();
      }
      if (menuLevel == 2)
      {
        if (menuIndex[0] == 6)
        {
          switch (menuIndex[1])
          {
            case 0:
              if (setWaktu.jam == 0)
              {
                setWaktu.jam = 23;
              }
              else
              {
                setWaktu.jam--;
              }
              break;
            case 1:
              if (setWaktu.menit == 0)
              {
                setWaktu.menit = 59;
              }
              else
              {
                setWaktu.menit--;
              }
              break;
            case 2:
              if (setWaktu.detik == 0)
              {
                setWaktu.detik = 59;
              }
              else
              {
                setWaktu.detik--;
              }
              break;
          }
        }
        else
        {
          switch (menuIndex[1])
          {
            case 0:
              jadwalSet.aktif = !jadwalSet.aktif;
              break;
            case 1:
              if (jadwalSet.jam == 0)
              {
                jadwalSet.jam = 23;
              }
              else
              {
                jadwalSet.jam--;
              }
              break;
            case 2:
              if (jadwalSet.menit == 0)
              {
                jadwalSet.menit = 59;
              }
              else
              {
                jadwalSet.menit--;
              }
              break;
          }
        }
        tampilanMenu();
      }
      delay(100);
    }
  }
  if (!digitalRead(pinTombolOk))
  {
    delay(100);
    if (!digitalRead(pinTombolOk))
    {
      if (menuLevel == 1)
      {
        menuLevel = 2;
        menuIndex[1] = 0;
        if (menuIndex[0] == 6)
        {
          setWaktu = rtc.now();
          tampilanMenu();
          lcd.setCursor(4, 1);
          lcd.blink();
        }
        else
        {
          jadwalSet.aktif = jadwal[menuIndex[0]].aktif;
          jadwalSet.jam = jadwal[menuIndex[0]].jam;
          jadwalSet.menit = jadwal[menuIndex[0]].menit;
          tampilanMenu();
          lcd.setCursor(2, 1);
          lcd.blink();
        }
      }
      else if (menuLevel == 2)
      {
        menuIndex[1]++;
        if (menuIndex[0] == 6)
        {
          switch (menuIndex[1])
          {
            case 1:
              tampilanMenu();
              lcd.setCursor(7, 1);
              lcd.blink();
              break;
            case 2:
              tampilanMenu();
              lcd.setCursor(10, 1);
              lcd.blink();
              break;
            case 3:
              menuLevel = 1;
              rtc.adjust(setWaktu);
              tampilanMenu();
              lcd.noBlink();
              break;
          }
        }
        else
        {
          switch (menuIndex[1])
          {
            case 1:
              tampilanMenu();
              lcd.setCursor(8, 1);
              lcd.blink();
              break;
            case 2:
              tampilanMenu();
              lcd.setCursor(11, 1);
              lcd.blink();
              break;
            case 3:
              menuLevel = 1;
              jadwal[menuIndex[0]].aktif = jadwalSet.aktif;
              jadwal[menuIndex[0]].jam = jadwalSet.jam;
              jadwal[menuIndex[0]].menit = jadwalSet.menit;
              simpanJadwal();
              lcd.noBlink();
              tampilanMenu();
              break;
          }
        }
        while (!digitalRead(pinTombolOk));
        delay(500);
      }
    }
  }
}
void tampilanMenu()
{
  if (menuLevel == 1)
  {
    lcd.setCursor(0, 0);
    lcd.print("   Menu Utama   ");
    lcd.setCursor(0, 1);
    lcd.print(textMenuUtama[menuIndex[0]]);
  }
  else if (menuLevel == 2)
  {
    if (menuIndex[0] == 6)
    {
      lcd.setCursor(0, 0);
      lcd.print(textMenuUtama[menuIndex[0]]);
      sprintf(bufWaktu, "    %02d:%02d:%02d    ", setWaktu.jam, setWaktu.menit, setWaktu.detik);
      lcd.setCursor(0, 1);
      lcd.print(bufWaktu);
    }
    else
    {
      lcd.setCursor(0, 0);
      lcd.print(textMenuUtama[menuIndex[0]]);
      sprintf(bufWaktu, "  %s %02d:%02d   ", textAktif[jadwalSet.aktif], jadwalSet.jam, jadwalSet.menit);
      lcd.setCursor(0, 1);
      lcd.print(bufWaktu);
    }
  }
}
 
void ambilJadwal()
{
  byte *alamat = (byte*)jadwal;
  for (byte i = 1; i < sizeof(jadwal) + 1; i++)
  {
    *alamat++ = EEPROM.read(i);
  }
}
void simpanJadwal()
{
  byte *alamat = (byte*)jadwal;
  for (byte i = 1; i < sizeof(jadwal) + 1; i++)
  {
    EEPROM.update(i, *alamat++);
  }
}

library yang digunakan:

Papan skor arduino 3 panel P10 dengan kontrol android

Asep Kurniawan

Papan skor (score board) adalah papan tempat informasi dan hasil pertandingan yang dapat dilihat oleh semua orang yang berada di arena pertandingan dan penonton.

Papan skor dengan dot matrix (dmd) dengan kontrol android melalui bluetooth ini memiliki fitur :

  1. Tambah-kurang point, skor, waktu, dan ronde pertandingan serta reset point.
  2. Informasi running text yang bisa tampil di tengah pertandingan.
  3. Master reset untuk menginisialisasi semua informasi pertandingan.

Skema papan skor arduino

lepas ‘pin 0’ arduino – bluetooth saat upload sketch:

komponen papan skor bluetooth

  1. Arduino Uno
  2. 3 buah DMD Panel P10
  3. Bluetooth HC-05
  4. Android

Sketch/koding scoring board arduino dengan android melalui bluetooth

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
#include <SoftwareSerial.h>
#include <DMD_Semesin.h>
#include <fonts/Arial16.h>
#include <fonts/Arial_Black_16.h>
#include <fonts/SystemFont5x7.h>
#include <fonts/SystemFont5x7Gemuk.h>
#include <Wire.h>
 
//defenisi pin
#define pinOE         9
#define pinSCK        8
#define pinA          6
#define pinB          7
 
#define DISPLAYS_WIDE 3
#define DISPLAYS_HIGH 1
 
#define fontPembuka     Arial16
#define fontSkor        Arial_Black_16
#define fontInformasi   SystemFont5x7
#define fontWaktu       SystemFont5x7
#define fontRonde       SystemFont5x7Gemuk
 
SPIDMD dmd(DISPLAYS_WIDE, DISPLAYS_HIGH);
 
//SoftwareSerial bluetooth(2, 3);
#define bluetooth     Serial
 
byte pointA, pointB, skorA, skorB, ronde = 0;
uint16_t waktu = 0;
byte Arial14TengahY;
char strInformasi[200] = "Selamat Datang";
char bufferBluetooth[200];
bool pertandinganBerjalan;
long millisDetik;
long millisEfek;
byte detikSebelumnya = 60;
bool modeInformasi;
 
EfekMarque efekMarque;
 
enum perintah {
  initPerangkat,
  pointAplus,
  pointAminus,
  pointBplus,
  pointBminus,
  skorAplus,
  skorAminus,
  skorBplus,
  skorBminus,
  rondePlus,
  rondeMinus,
  menitPlus,
  menitMinus,
  text,
  resetPoint,
  resetSemua,
  mulai,
};
 
DMD_TextBox boxSkorA(dmd, 0, 0, 28, 16);
DMD_TextBox boxSkorB(dmd, 68, 0, 28, 16);
 
void setup() {
  Serial.begin(9600);
  bluetooth.begin(9600);
 
  Serial.println(F("Papan skor arduino 3 panel P10 dengan kontrol android"));
  Serial.println(F("https://www.project.semesin.com"));
 
 
  dmd.setBrightness(128);
  dmd.selectFont(fontPembuka);
  dmd.clearScreen();
  dmd.begin();
  dmd.drawString(0, 0, F("Papan Skor bluetooth"));
  delay(1000);
  dmd.clearScreen();
 
  efekMarque.mode = nonAktif;
  efekMarque.sumber = sumberRAM;
  efekMarque.font = fontInformasi;
  efekMarque.kiri = 28;
  efekMarque.atas = 0;
  efekMarque.tinggi = 8;
  efekMarque.lebar = 40;
  efekMarque.step = 1;
  efekMarque.skip = 0;
 
  tampilanUtama();
 
  Serial.println("Sistem dimulai");
 
  millisDetik = millis();
}
 
void loop() {
  if (millisDetik != millis() / 1000L)
  {
    millisDetik = millis() / 1000L;
    if (pertandinganBerjalan)
    {
      waktu++;
 
      if (!modeInformasi)
      {
        tampilanUtama();
      }
    }
  }
 
  if (millisEfek < millis() - 100)
  {
    millisEfek = millis();
    if (efekMarque.mode == XMinus)
    {
      dmd.marqueeXMinus(&efekMarque);
    }
    else
    {
      modeInformasi = false;
      tampilanUtama();
    }
  }
 
  if (bluetooth.available())
  {
    byte tokenMulai = bluetooth.read();
    Serial.println(tokenMulai, HEX);
    if (tokenMulai == 0xFE)
    {
      delay(2);
      byte perintah = bluetooth.read();
      delay(2);
      byte panjang = bluetooth.read();
 
      for (uint16_t i = 0; i < panjang; i++)
      {
        delay(2);
        char c = bluetooth.read();
        bufferBluetooth[i] = c;
      }
      delay(2);
      byte tokenSelesai = bluetooth.read();
      if (tokenSelesai == 0xFF)
      {
        uint16_t i;
        switch (perintah)
        {
          case initPerangkat:
            bluetooth.write(237);
            break;
          case pointAplus:
            pointA++;
            break;
          case pointAminus:
            pointA--;
            break;
          case pointBplus:
            pointB++;
            break;
          case pointBminus:
            pointB--;
            break;
          case skorAplus:
            skorA++;
            break;
          case skorAminus:
            skorA--;
            break;
          case skorBplus:
            skorB++;
            break;
          case skorBminus:
            skorB--;
            break;
          case rondePlus:
            ronde++;
            break;
          case rondeMinus:
            ronde--;
            break;
          case menitPlus:
            waktu += 60 ;
            break;
          case menitMinus:
            if (waktu > 60)
              waktu -= 60;
            else
              waktu = 0;
            break;
          case resetPoint:
            pointA = 0;
            pointB = 0;
            break;
          case resetSemua:
            pointA = 0;
            pointB = 0;
            skorA = 0;
            skorB = 0;
            ronde = 0;
            waktu = 0;
            break;
          case mulai:
            pertandinganBerjalan = !pertandinganBerjalan;
            break;
          case text:
            for (i = 0; i < panjang; i++)
            {
              strInformasi[i] = bufferBluetooth[i];
            }
            strInformasi[i] = 0;
            dmd.drawFilledBox(28, 0, 67, 7, GRAPHICS_OFF);
            efekMarque.init = true;
            efekMarque.alamat = strInformasi;
            efekMarque.mode = XMinus;
            efekMarque.clear = 40;
            modeInformasi = true;
 
            millisEfek = millis();
            break;
        }
        if (pointA == 255)
          pointA = 0;
        if (pointB == 255)
          pointB = 0;
        if (skorA == 255)
          skorA = 0;
        if (skorB == 255)
          skorB = 0;
        if (ronde == 255)
          ronde = 0;
        if (waktu == 3600)
          waktu = 0;
 
        if (!modeInformasi)
        {
          tampilanUtama();
        }
      }
    }
  }
}
byte bin2bcd(byte val)
{
  return val + 6 * (val / 10);
}
 
void tampilanUtama()
{
  byte lebarText;
  dmd.selectFont(fontSkor);
  Arial14TengahY = (dmd.height - dmd.fontHeader.height) / 2;
 
  boxSkorA.clear();
  boxSkorB.clear();
  lebarText = dmd.stringWidth(String(pointA));
  dmd.drawString((28 - lebarText) / 2 + 0, Arial14TengahY, String(pointA));
  lebarText = dmd.stringWidth(String(pointB));
  dmd.drawString((28 - lebarText) / 2 + 68, Arial14TengahY, String(pointB));
 
 
  dmd.selectFont(fontWaktu);
  char waktuStr[] = "00:00";
  byte menitBCD = bin2bcd(waktu / 60);
  byte detikBCD = bin2bcd(waktu % 60);
  waktuStr[0] = (menitBCD >> 4) + 0x30;
  waktuStr[1] = (menitBCD & 0x0F) + 0x30;
  waktuStr[3] = (detikBCD >> 4) + 0x30;
  waktuStr[4] = (detikBCD & 0x0F) + 0x30;
  lebarText = dmd.stringWidth(waktuStr);
  dmd.drawString((dmd.width - lebarText) / 2, 0, waktuStr);
 
  dmd.selectFont(fontRonde);
 
  dmd.drawString(28, 8, String(skorA));
  lebarText = dmd.stringWidth(String(skorB));
  dmd.drawString((68 - lebarText), 8, String(skorB));
 
  lebarText = dmd.stringWidth(String(ronde));
  dmd.drawString((dmd.width - lebarText) / 2, 8, String(ronde));
}

screenshot apk papan skor

File papan skor android

 

Bel sekolah arduino dengan kontrol android 2 (upgrade lcd)

Asep Kurniawan

Bel sekolah adalah pengingat waktu yang digunakan di sekolah sebagai penanda pergantian jadwal.

Bel sekolah digital bisa di aplikasikan dalam bentuk:

    1. Aplikasi komputer
      adalah aplikasi yang ditanam dalam komputer dan bisa dijalankan secara otomatis. sistem ini mudah dalam pengaturan, memiliki data jadwal sangat besar,  peringatan admin, backup, update suara mudah, perekan suara, kunci aplikasi dll. Kelemahannya adalah komputer dan aplifier suara harus tetap hidup dan bergantung kepada adanya daya listrik/ups termasuk biaya listrik, pesan sponsor pada aplikasi gratis,  biaya pengadaan dan perawatan komputer.
    2. Aplikasi android
      Aplikasi / apk android memiliki sama dengan aplikasi komputer dan aplikasi android dapat terhubung dengan  sistem tata suara melalui bluetooth dan kabel audio. kekurangannya adalah device android harus selalu berada dekat dengan sistem (selalu standby)
    3. Aplikasi perangkat mandiri
      Sistem bel sekolah otomatis dapat dibangun dengan perangkat mandiri menggunakan microkontroller dengan biaya murah dan bisa dikembangkan untuk keperluan lainnya seperti :

      • bisa menggunakan baterai sebagai daya cadangannya
      • Pendeteksi gempa dan peringatan
      • Notifikasi sms ke pengajar
      • Mekanuisme kunci pagar
      • Panggilan melalui microphone yang tertuju langsung ke kelas tertentu
      • dan lain-lain sesuai kebutuhan

      Kekurangan sistem ini adalah ruang penyimpanan data jadwal dan suara terbatas, pengaturan jadwal yang sulit melalui tombol/keypad.

Dalam proyek ini menggabungkan perangkat mandiri dengan platform arduino yang dikombinasikan dengan aplikasi/apk android sebagai kontrolnya.

Skema bel sekolah otomatis dengan kontrol android:

komponen bel sekolah arduino control android:

  • Arduino Uno
  • Bluetooth HC-05
  • RTC DS3231
  • LCD 1602 + I2C backpack
  • modul Relay 1 channel
  • DF Player mini mp3
  • Speaker

tampilan Aplikasi bel sekolah android :

sketch/aplikasi bel sekolah bluettoth android :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
#define namaSekolah   "Nama Sekolah"
 
#define SQWPin        A3
#define pinRelay      8
#define relayOn       LOW
 
#include <avr/sleep.h>
#include <SoftwareSerial.h>
#include <DFPlayer_Mini_Mp3.h>
#include "RTC.h"
#include <EEPROM.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
 
#define tokenEEPROM 0x83
SoftwareSerial bluetooth(2, 3); // RX, TX
SoftwareSerial mp3Serial(4, 5); // RX, TX
LiquidCrystal_I2C lcd(0x3F, 16, 2); // set the LCD address to 0x27 for a 16 chars and 2 line display
 
struct Waktu
{
  byte jam;
  byte menit;
};
 
struct TabelMataPelajaran
{
  byte aktif;
  Waktu waktu;
  byte hariAktif;
  byte mingguAktif;
  byte kegiatan;
};
 
const char kegiatanText[][17] PROGMEM = {
  "-               ",
  "Jam Pelajaran 1 ",
  "Jam Pelajaran 2 ",
  "Jam Pelajaran 3 ",
  "Jam Pelajaran 4 ",
  "Jam Pelajaran 5 ",
  "Jam Pelajaran 6 ",
  "Jam Pelajaran 7 ",
  "Jam Pelajaran 8 ",
  "Jam Pelajaran 9 ",
  "Jam Pelajaran 10",
  "Jam Pelajaran 11",
  "Jam Pelajaran 12",
  "Jam Pelajaran 13",
  "Jam Pelajaran 14",
  "Jam Pelajaran 15",
  "Masuk           ",
  "Upacara         ",
  "Istirahat       ",
  "Istirahat1      ",
  "Istirahat2      ",
  "Istirahat3      ",
  "Selesai istiraht",
  "Kepramukaan     ",
  "Khusus          ",
  "Pulang          ",
  "Pulang Jum'at   ",
  "Pulang Sabtu    ",
  "Musik 1         ",
  "Musik 2         ",
  "Musik 3         ",
  "Musik 4         ",
  "Musik 5         ",
  "Musik 6         ",
  "Hadits 1        ",
  "Hadits 2        ",
  "Hadits 3        ",
  "Hadits 4        ",
  "Hadits 5        ",
  "Hadits 6        ",
};
 
enum _kegiatan
{
  TidakAda,
  JamPelajaran1,
  JamPelajaran2,
  JamPelajaran3,
  JamPelajaran4,
  JamPelajaran5,
  JamPelajaran6,
  JamPelajaran7,
  JamPelajaran8,
  JamPelajaran9,
  JamPelajaran10,
  JamPelajaran11,
  JamPelajaran12,
  JamPelajaran13,
  JamPelajaran14,
  JamPelajaran15,
  Masuk,
  Upacara,
  Istirahat,
  Istirahat1,
  Istirahat2,
  Istirahat3,
  SelesaiIstirahat,
  Kepramukaan,
  Khusus,
  Pulang,
  PulangJumat,
  PulangSabtu,
  Musik1,
  Musik2,
  Musik3,
  Musik4,
  Musik5,
  Musik6,
  Hadits1,
  Hadits2,
  Hadits3,
  Hadits4,
  Hadits5,
  Hadits6,
};
enum PengaturanAndroid
{
  cekAses,
  pengaturanJadwal,
  pengaturanWaktu,
 
};
 
char karakterMusik[8] = {
  0b00000,
  0b00100,
  0b00110,
  0b00101,
  0b00101,
  0b00100,
  0b11100,
  0b11100
};
byte karakterDetik1[8] = {
  0b00000,
  0b00000,
  0b00000,
  0b00100,
  0b00000,
  0b00000,
  0b00000,
  0b00000
};
byte karakterDetik2[8] = {
  0b00000,
  0b00000,
  0b00100,
  0b01010,
  0b00100,
  0b00000,
  0b00000,
  0b00000
};
byte karakterDetik3[8] = {
  0b00000,
  0b00100,
  0b01010,
  0b10001,
  0b01010,
  0b00100,
  0b00000,
  0b00000
};
byte karakterSetting[8] = {
  0b00100,
  0b00100,
  0b00100,
  0b01110,
  0b00100,
  0b10001,
  0b01010,
  0b00100
};
 
volatile bool interupsiDetik;
byte indexMataPelajaran;
RTC_DS3231 rtc;
DateTime now;
bool rtcValid;
byte indexPengaturanJadwal = 0;
 
#define hariAktifSenin 1<<6
#define hariAktifSelasa 1<<5
#define hariAktifRabu 1<<4
#define hariAktifKamis 1<<3
#define hariAktifJumat 1<<2
#define hariAktifSabtu 1<<1
#define hariAktifMinggu 1<<7
 
char namaHari[][7] = {"Minggu", "Senin", "Selasa", "Rabu", "Kamis", "Jum'at", "Sabtu"};
#define _hariAktif(Sen,Sel,Rab,Kam,Jum,Sab,Mgu) (Mgu<<7)|(Sen<<6)|(Sel<<5)|(Rab<<4)|(Kam<<3)|(Jum<<2)|(Sab<<1)
#define _mingguAktif(Mgu1,Mgu2,Mgu3,Mgu4,Mgu5,Mgu6) (Mgu1<<7)|(Mgu2<<6)|(Mgu3<<5)|(Mgu4<<4)|(Mgu5<<3)|(Mgu6<<2)
#define _waktu(Jam, Menit) {Jam, Menit}
#define Aktif 1
#define TidakAktif 0
 
TabelMataPelajaran jadwalBelajar[40];
Waktu waktu;
 
char bufWaktu[40];
byte detikSebelumnya = 60;
byte tanggalSebelumnya = 0;
Waktu jadwalBerikutnya;
byte menitBel;
bool statusBel;
bool statusPengingat;
 
byte jadwalBerikutnyaKegiatan;
 
 
void setup() {
  digitalWrite(pinRelay, !relayOn);
  pinMode(pinRelay, OUTPUT);
   
  pinMode(SQWPin, INPUT_PULLUP);
 
  Serial.begin(9600);
  Serial.println(F("Bel Sekolah Dengan Kontrol Android"));
  Serial.println(F("https://www.project.semesin.com"));
  Serial.println();
 
  Wire.begin();
  Wire.beginTransmission(0x3F);
  if (Wire.endTransmission())
  {
    lcd = LiquidCrystal_I2C(0x27, 16, 2);
  }
  lcd.begin();
 
  lcd.command (0x40 | (0 << 3));
  for (byte i = 0; i < 8; i++)
    lcd.write (karakterDetik1[i]);
 
  lcd.command (0x40 | (1 << 3));
  for (byte i = 0; i < 8; i++)
    lcd.write (karakterDetik2[i]);
 
  lcd.command (0x40 | (2 << 3));
  for (byte i = 0; i < 8; i++)
    lcd.write (karakterDetik3[i]);
 
  lcd.command (0x40 | (3 << 3));
  for (byte i = 0; i < 8; i++)
    lcd.write (karakterDetik2[i]);
 
  lcd.command (0x40 | (4 << 3));
  for (byte i = 0; i < 8; i++)
    lcd.write (karakterMusik[i]);
 
  lcd.command (0x40 | (5 << 3));
  for (byte i = 0; i < 8; i++)
    lcd.write (karakterSetting[i]);
 
 
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Bel Sekolah");
  lcd.setCursor(0, 1);
  lcd.print(namaSekolah);
 
 
  mp3Serial.begin(9600);
  bluetooth.begin (9600);
  bluetooth.listen();
 
  mp3_set_serial (mp3Serial);
  mp3_set_volume (15);//full volume 0x30
 
  rtc.begin();
 
  if (rtc.lostPower())
  {
    Serial.println(F("RTC lost power, lets set the time!"));
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
   
  rtc.writeSqwPinMode(DS3231_SquareWave1Hz);
 
  if (EEPROM.read(sizeof(jadwalBelajar)) != tokenEEPROM)
  {
    nilaiAwal();
    EEPROM.write(sizeof(jadwalBelajar), tokenEEPROM);
    Serial.println("setting awal");
  }
   
  EEPROM.get(0, jadwalBelajar);
  cekJadwalHariIni();
 
  delay(1000);
 
  lcd.clear();
 
  Serial.println(F("Sistem bel sekolah dimulai"));
 
}
 
void loop() {
  if (digitalRead(SQWPin))
  {
    if (rtcValid)
    {
      rtcValid = false;
 
      now = rtc.now();
 
      uint16_t unixJadwalBerikutnya = (jadwalBerikutnya.jam * 60) + jadwalBerikutnya.menit;
      uint16_t unixWaktu = (now.jam * 60) + now.menit;
 
      if (!now.detik)
      {
        if (jadwalBerikutnyaKegiatan && (jadwalBerikutnya.jam == now.jam) && (jadwalBerikutnya.menit == now.menit))
        {
          lcd.setCursor(6, 1);
          lcd.print((char)4);
          lcd.setCursor(0, 0);
          lcd.print((__FlashStringHelper *)kegiatanText[jadwalBerikutnyaKegiatan]);
 
          mp3_play (jadwalBerikutnyaKegiatan);
          Serial.println((__FlashStringHelper *)kegiatanText[jadwalBerikutnyaKegiatan]);
          menitBel = jadwalBerikutnya.menit;
          statusBel = true;
          statusPengingat = false;
        }
        else if (jadwalBerikutnyaKegiatan && (unixWaktu == unixJadwalBerikutnya - 1))
        {
          statusPengingat = true;
          digitalWrite(pinRelay, relayOn);
          Serial.println("Pengingat bel masuk 1 menit lagi");
        }
      }
 
      if (menitBel != now.menit)
      {
        if (statusBel)
        {
          lcd.setCursor(6, 1);
          lcd.print(' ');
 
          digitalWrite(pinRelay, !relayOn);
 
          cariJadwal();
          statusBel = false;
          tanggalSebelumnya = 0;
        }
      }
 
      //tampilan
      if (statusPengingat)
      {
        lcd.setCursor(1, 1);
        if (now.detik % 2)
        {
          sprintf(bufWaktu, "%02d:%02d", jadwalBerikutnya.jam, jadwalBerikutnya.menit);
          lcd.print(bufWaktu);
        }
        else
        {
          lcd.print("     ");
        }
      }
 
      if (detikSebelumnya != now.detik)
      {
        sprintf(bufWaktu, "%02d:%02d:%02d", now.jam, now.menit, now.detik);
        lcd.setCursor(8, 1);
        lcd.print(bufWaktu);
        lcd.setCursor(0, 1);
        lcd.print((char)(now.detik % 4));
 
        sprintf(bufWaktu, "%02d:%02d:%02d %s, %02d/%02d/%02d", now.jam, now.menit, now.detik, namaHari[now.hari - 1], now.tanggal, now.bulan, now.tahun - 2000);
        Serial.println(bufWaktu);
      }
 
      if (tanggalSebelumnya != now.tanggal)
      {
        tanggalSebelumnya = now.tanggal;
        lcd.clear();
        lcd.print(namaHari[now.hari - 1]);
        lcd.print(',');
        sprintf(bufWaktu, "%02d/%02d/%02d", now.tanggal, now.bulan, now.tahun - 2000);
        lcd.setCursor(8, 0);
        lcd.print(bufWaktu);
 
        cariJadwal();
      }
    }
  }
  else
  {
    rtcValid = true;
  }
  cekBluetooth();
}
 
void cekBluetooth()
{
  uint8_t tokenMulai;
  uint8_t perintah;
  uint8_t parameter;
  uint8_t panjang1;
  uint8_t panjang2;
  char c;
  uint8_t i, j;
  uint8_t tokenSelesai;
  byte bufferSerial[100];
  byte *alamat;
 
  if (bluetooth.available())
  {
    tokenMulai = bluetoothRead();
    if (tokenMulai == 0xFD)
    {
      panjang1 = bluetoothRead();
      panjang2 = bluetoothRead();
 
      if (panjang2 == 254 - panjang1)
      {
        if (panjang1 >= sizeof(bufferSerial))
        {
          panjang1 = sizeof(bufferSerial);
        }
 
        uint16_t timeOut = 0xFFF;
        i = 0;
        do
        {
          if (bluetooth.available())
          {
            c = bluetoothRead();
            bufferSerial[i++] = c;
          }
        } while ((i < panjang1 + 3) && (timeOut--));
 
        perintah = bufferSerial[0];
        parameter = bufferSerial[1];
 
        tokenSelesai = bufferSerial[i - 1];
        if (tokenSelesai == 0x00)
        {
          delay(10);
          bluetooth.write(254);
          switch (perintah)
          {
            case cekAses:
              bluetooth.write(1);
              bluetooth.write(254);
              break;
            case pengaturanJadwal:
              lcd.setCursor(6, 1);
              lcd.print((char)5);
 
              memcpy((byte*)&jadwalBelajar[parameter], bufferSerial + 2, sizeof(TabelMataPelajaran));
              if (parameter == (sizeof(jadwalBelajar) / sizeof(TabelMataPelajaran)) - 1)
              {
                EEPROM.put(0, jadwalBelajar);
                Serial.println("Jadwal diterima");
 
                lcd.setCursor(6, 1);
                lcd.print(' ');
 
                tanggalSebelumnya = 0;
              }
              break;
            case pengaturanWaktu:
              memcpy((byte*)&now, bufferSerial + 2, sizeof(DateTime));
              rtc.adjust(now);
              tanggalSebelumnya = 0;
              Serial.println("Setting waktu diterima");
              break;
          }
        }
        else
        {
          bluetooth.write(252);//data tidak benar
        }
      }
    }
  }
}
byte bluetoothRead()
{
  uint16_t timeOut = 0xFFF;
  while (!bluetooth.available() && timeOut--);
  return bluetooth.read();
}
 
 
 
void nilaiAwal()
{
  byte i = 0;
  jadwalBelajar[i++] = {Aktif, _waktu(  6, 45 ), hariAktifSenin                 , _mingguAktif(1, 0, 0, 0, 0, 0), Upacara};
  jadwalBelajar[i++] = {Aktif, _waktu(  6, 45 ), hariAktifSenin                 , _mingguAktif(0, 1, 1, 1, 1, 1), JamPelajaran1};
  jadwalBelajar[i++] = {Aktif, _waktu(  6, 45 ), _hariAktif(0, 1, 1, 1, 1, 0, 0), _mingguAktif(1, 1, 1, 1, 1, 1), JamPelajaran1};
 
  jadwalBelajar[i++] = {Aktif, _waktu(  7, 30 ), _hariAktif(1, 1, 1, 1, 0, 0, 0), _mingguAktif(1, 1, 1, 1, 1, 1), JamPelajaran2};
  jadwalBelajar[i++] = {Aktif, _waktu(  8, 15 ), _hariAktif(1, 1, 1, 1, 0, 0, 0), _mingguAktif(1, 1, 1, 1, 1, 1), JamPelajaran3};
  jadwalBelajar[i++] = {Aktif, _waktu(  9, 0  ), _hariAktif(1, 1, 1, 1, 0, 0, 0), _mingguAktif(1, 1, 1, 1, 1, 1), JamPelajaran4};
  jadwalBelajar[i++] = {Aktif, _waktu(  9, 45 ), _hariAktif(1, 1, 1, 1, 0, 0, 0), _mingguAktif(1, 1, 1, 1, 1, 1), Istirahat};
  jadwalBelajar[i++] = {Aktif, _waktu( 10, 15 ), _hariAktif(1, 1, 1, 1, 0, 0, 0), _mingguAktif(1, 1, 1, 1, 1, 1), JamPelajaran5};
  jadwalBelajar[i++] = {Aktif, _waktu( 11, 0  ), _hariAktif(1, 1, 1, 1, 0, 0, 0), _mingguAktif(1, 1, 1, 1, 1, 1), JamPelajaran6};
  jadwalBelajar[i++] = {Aktif, _waktu( 11, 45 ), _hariAktif(1, 1, 1, 1, 0, 0, 0), _mingguAktif(1, 1, 1, 1, 1, 1), Istirahat};
  jadwalBelajar[i++] = {Aktif, _waktu( 12, 30 ), _hariAktif(1, 1, 1, 1, 0, 0, 0), _mingguAktif(1, 1, 1, 1, 1, 1), JamPelajaran7};
  jadwalBelajar[i++] = {Aktif, _waktu( 13, 15 ), _hariAktif(1, 1, 1, 1, 0, 0, 0), _mingguAktif(1, 1, 1, 1, 1, 1), JamPelajaran8};
 
  jadwalBelajar[i++] = {Aktif, _waktu( 14, 0  ), _hariAktif(1, 1, 1, 0, 0, 0, 0), _mingguAktif(1, 1, 1, 1, 1, 1), JamPelajaran9};
  jadwalBelajar[i++] = {Aktif, _waktu( 14, 45 ), _hariAktif(1, 1, 1, 0, 0, 0, 0), _mingguAktif(1, 1, 1, 1, 1, 1), JamPelajaran10};
 
  jadwalBelajar[i++] = {Aktif, _waktu( 14, 0  ), hariAktifKamis,            _mingguAktif(1, 1, 1, 1, 1, 1), Kepramukaan};
  jadwalBelajar[i++] = {Aktif, _waktu( 14, 45 ), hariAktifKamis,            _mingguAktif(1, 1, 1, 1, 1, 1), Khusus};
 
  jadwalBelajar[i++] = {Aktif, _waktu( 15, 30 ), _hariAktif(1, 1, 1, 1, 0, 0, 0), _mingguAktif(1, 1, 1, 1, 1, 1), Pulang};
 
  jadwalBelajar[i++] = {Aktif, _waktu(  7, 25 ), hariAktifJumat,            _mingguAktif(1, 1, 1, 1, 1, 1), JamPelajaran2};
  jadwalBelajar[i++] = {Aktif, _waktu(  8, 5  ), hariAktifJumat,            _mingguAktif(1, 1, 1, 1, 1, 1), JamPelajaran3};
  jadwalBelajar[i++] = {Aktif, _waktu(  8, 45 ), hariAktifJumat,            _mingguAktif(1, 1, 1, 1, 1, 1), JamPelajaran4};
  jadwalBelajar[i++] = {Aktif, _waktu(  9, 25 ), hariAktifJumat,            _mingguAktif(1, 1, 1, 1, 1, 1), Istirahat};
  jadwalBelajar[i++] = {Aktif, _waktu(  9, 55 ), hariAktifJumat,            _mingguAktif(1, 1, 1, 1, 1, 1), JamPelajaran5};
  jadwalBelajar[i++] = {Aktif, _waktu( 10, 35 ), hariAktifJumat,            _mingguAktif(1, 1, 1, 1, 1, 1), JamPelajaran6};
  jadwalBelajar[i++] = {Aktif, _waktu( 11, 15 ), hariAktifJumat,            _mingguAktif(1, 1, 1, 1, 1, 1), PulangJumat};
 
  EEPROM.put(0, jadwalBelajar);
}
 
void cekJadwalHariIni()
{
  Serial.println("Jadwal hari ini");
  for (byte i = 0; i < sizeof(jadwalBelajar) / sizeof(TabelMataPelajaran) ; i++)
  {
    Serial.print(jadwalBelajar[i].aktif);
    Serial.print('\t');
    Serial.print(jadwalBelajar[i].waktu.jam);
    Serial.print('\t');
    Serial.print(jadwalBelajar[i].waktu.menit);
    Serial.print('\t');
    Serial.print(jadwalBelajar[i].hariAktif, HEX);
    Serial.print('\t');
    Serial.print(jadwalBelajar[i].mingguAktif, HEX);
    Serial.print('\t');
    Serial.print(jadwalBelajar[i].kegiatan);
    Serial.print('\t');
    char buf[20];
    memcpy_P(buf, kegiatanText[jadwalBelajar[i].kegiatan], sizeof(kegiatanText[0]));
    Serial.print(buf);
    Serial.println();
  }
 
}
 
void cariJadwal()
{
  uint16_t unixWaktu = (now.jam * 60) + now.menit;
  byte hariKeDiTanggal1 = ((now.hari + 7  - (now.tanggal % 7)) % 7) + 1;
  byte SeninKe = ((now.tanggal + ((hariKeDiTanggal1 + 4) % 7)) / 7); //senin pertama
  byte mingguKe = ((now.tanggal + hariKeDiTanggal1 + 6 - 1) / 7);
 
  Serial.print("SeninKe = ");
  Serial.println(SeninKe);
  Serial.print("mingguKe = ");
  Serial.println(mingguKe);
 
 
  uint16_t unixTerkecil = UINT16_MAX;
  jadwalBerikutnyaKegiatan = 0;
  Waktu waktuTerkecil;
 
  for (byte i = 0; i < sizeof(jadwalBelajar) / sizeof(TabelMataPelajaran); i++)
  {
    if (
      (jadwalBelajar[i].aktif) &&
      (jadwalBelajar[i].hariAktif & (1 << (8 - now.hari))) &&
      (jadwalBelajar[i].mingguAktif & (1 << (8 - mingguKe)))
    )
    {
      uint16_t unixJadwal = (jadwalBelajar[i].waktu.jam * 60) + jadwalBelajar[i].waktu.menit;
      if (unixWaktu < unixJadwal)
      {
        if (unixTerkecil > unixJadwal)
        {
          unixTerkecil = unixJadwal;
          jadwalBerikutnya.jam = jadwalBelajar[i].waktu.jam;
          jadwalBerikutnya.menit = jadwalBelajar[i].waktu.menit;
          jadwalBerikutnyaKegiatan = jadwalBelajar[i].kegiatan;
        }
      }
    }
  }
  if (jadwalBerikutnyaKegiatan)
  {
    Serial.print("Bel berikutnya : ");
    Serial.print((__FlashStringHelper *)kegiatanText[jadwalBerikutnyaKegiatan]);
    Serial.print(" ");
    Serial.print(jadwalBerikutnya.jam);
    Serial.print(":");
    Serial.println(jadwalBerikutnya.menit);
 
    lcd.setCursor(1, 1);
    sprintf(bufWaktu, "%02d:%02d", jadwalBerikutnya.jam, jadwalBerikutnya.menit);
    lcd.print(bufWaktu);
  }
  else
  {
    lcd.setCursor(1, 1);
    lcd.print("--:--");
  }
 
 
}

library arduino bel sekolah dengan bluetooth dan aplikasi android yang digunakan :

Suara mp3 bel sekolah arduino dengan bluetooth:

mp3.zip

aplikasi apk android untuk bel sekolah arduino (evaluasi):

Bel_sekolah_v1_Evaluasi.apk

cara penggunaan :

  1. Buat rangkaian arduino seperti skema dan upload sketch yang diberikan.
  2. Masukkan file suara dalam kartu memori/SD card (file mp3 dan folder mp3).
  3. install aplikasi bel sekolah v1 evaluasi di android (evaluasi = 10 jadwal yang aktif).

Menu arduino dengan rotary encoder

Asep Kurniawan

Rotary encoder (shaft encoder) adalah komponen pengukuran arah putaran. Komponen ini memiliki dua pin keluaran yang menghasilkan sinyal pulsa yang diproses dahulu untuk mendapatkan arah putarannya.

Sinyal rotary encoder:

 

Rotary encoder tersedia dalam bermacam type, dan tipe yang digunakan dalam program ini ada type potensio rotary encoder.

Sinyal keluaran dari type ini terlihat dapat digambarkan sbb:

komponen aplikasi sketch menu rotary encoder berbasis arduino:

  1. Arduino Uno
  2. LCD 16×2 backpack I2C
  3. Momentary Rotary Encoder

Skema arduino menu menggunakan rotary encoder:

 

Sketch menu arduino ini menggunakan external interrupt. untuk arduino uno hanya bisa menggunakan pin 2 dan 3, sedangkan arduino mega bisa menggunakan pin 2, 3, 18, 19, 20 dan 21.

program/aplikasi arduino menu arduino dengan lcd I2c 16×2 menggunakan rotary encoder:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
#define pinRotaryEncoderCLK     2
#define pinRotaryEncoderDT      3
#define pinRotaryEncoderSwitch  4
 
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
 
LiquidCrystal_I2C lcd(0x3f, 16, 2); // coba juga alamat 0x27 (tergantung seri back pack)
 
uint8_t maskSensorA;
uint8_t maskSensorB;
uint8_t *pinSensorA;
uint8_t *pinSensorB;
volatile bool encoderAFlag = 0;
volatile bool encoderBFlag = 0;
 
int8_t nilaiEncoder = 0;
int nilaiSetting[4];
byte setMode;
 
void setup() {
  Serial.begin(9600);
  Serial.println("Menu rotary encoder");
  Serial.println("https://www.project.semesin.com/");
  Serial.println();
 
  pinMode(pinRotaryEncoderCLK, INPUT_PULLUP);
  pinMode(pinRotaryEncoderDT, INPUT_PULLUP);
  pinMode(pinRotaryEncoderSwitch, INPUT_PULLUP);
 
  Wire.begin();
  Wire.beginTransmission(0x3F);
  if (Wire.endTransmission())
  {
    lcd = LiquidCrystal_I2C(0x27, 16, 2);
  }
  lcd.begin();
  lcd.backlight();
 
  attachInterrupt(digitalPinToInterrupt(pinRotaryEncoderCLK), encoderARising, RISING);
  attachInterrupt(digitalPinToInterrupt(pinRotaryEncoderDT), encoderBRising, RISING);
 
  maskSensorA  = digitalPinToBitMask(pinRotaryEncoderCLK);
  pinSensorA = portInputRegister(digitalPinToPort(pinRotaryEncoderCLK));
  maskSensorB  = digitalPinToBitMask(pinRotaryEncoderDT);
  pinSensorB = portInputRegister(digitalPinToPort(pinRotaryEncoderDT));
 
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("A:0     C:0");
  lcd.setCursor(0, 1);
  lcd.print("B:0     D:0");
}
 
void loop() {
  if (nilaiEncoder != 0)
  {
    Serial.println(nilaiEncoder);
    nilaiSetting[setMode] += nilaiEncoder;
    nilaiEncoder = 0;
 
    lcd.setCursor(((setMode / 2) * 8) + 2, setMode % 2);
    lcd.print(nilaiSetting[setMode]);
    lcd.print(" ");
  }
  if (!digitalRead(pinRotaryEncoderSwitch))
  {
    delay(50);
    setMode = (setMode + 1) % 4;
    while (!digitalRead(pinRotaryEncoderSwitch));
    Serial.println(setMode);
  }
}
void encoderARising() {
  if ((*pinSensorB & maskSensorB) && encoderAFlag)
  {
    nilaiEncoder = -1;
    encoderAFlag = false;
    encoderBFlag = false;
  }
  else
  {
    encoderBFlag = true;
  }
 
}
 
void encoderBRising() {
  if ((*pinSensorA & maskSensorA) && encoderBFlag)
  {
    nilaiEncoder = 1;
    encoderAFlag = false;
    encoderBFlag = false;
  }
  else
  {
    encoderAFlag = true;
  }
}

library yang digunakan:

penggunaan aplikasi sketch menu rotary encoder:

  1. tekan knob untuk memilih menu setting
  2. putar knob ke untuk mengganti nilai setting

Dokumentasi menu rotary encoder lcd i2c:

Menu dan submenu LCD TFT dengan arduino

Asep Kurniawan

Sistem menu bertingkat (menu dan sub menu) adalah sistem pilihan/pengaturan yang terstruktur dalam kelompok-kelompok (sub menu).

Menu arduino juga bisa diterapkan pada lcd TFT (2.4″). Keunggulan sistem menu ini adalah pengaturan item menu bisa dengan mudah dimodifikasi, karena disusun dalam ‘struct’.

Video Player

 
komponen yang digunakan:

  1. Arduino Mega 2560
  2. LCD TFT 2.4″

Pengaturan menu

menu dalam program ini menggunakan struktur :

1
2
3
4
5
6
7
8
struct Menu
{
  byte tipe;
  void *variabel;
  uint16_t nilaiMin;
  uint16_t nilaiMax;
  void *subMenu;
};

struktur menu harus dibuat mengikuti struktur diatas yaitu:

  1. tipe dapat berupa UInt8, UInt16, Float, textDropDown, subMenu, dll
  2. variabel merupakan alamat dari nilai setting sesuai tipe yang diberikan
  3. nilaiMin dan nilaiMax merupakan batas setting.
  4. subMenu alamat struktur menu apabila tipenya adalah subMenu.

coding arduino menu tft lcd:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
#define LCD_CS                A3
#define LCD_CD                A2
#define LCD_WR                A1
#define LCD_RD                A0
 
#define LCD_RESET             A4
 
#define YP                    A1
#define XM                    A2
#define YM                    7
#define XP                    6
 
#define jumlahLevelMenu       2
#define panjangTextMenu       17
#define jumlahMenuDalamSatuLayar         4
 
#define lebarKolom1           210
#define tengahKolom1          (lebarKolom1/2)
#define tinggiBaris1          197
#define lebarKolom2           106
#define tengahKolom2          (214 + (lebarKolom2/2))
#define ringXPos              0
#define ringYPos              0
#define ringRadius            100
 
#define TS_MINX 130
#define TS_MINY 141
#define TS_MAXX 920
#define TS_MAXY 935
 
#define TS_MINPRESSURE 10
#define TS_MAXPRESSURE 1000
 
//========================================================
#include <Adafruit_GFX.h>
#include <SPFD5408_Adafruit_TFTLCD.h>
#include <SPFD5408_TouchScreen.h>
 
#define BLACK   0x0000
#define WHITE   0xFFFF
#define RED     0xF800
#define GREEN   0x07E0
#define BLUE    0x001F
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define GREY    0x2108
 
#define RED2RED 0
#define GREEN2GREEN 1
#define BLUE2BLUE 2
#define BLUE2RED 3
#define GREEN2RED 4
#define RED2GREEN 5
 
enum MenuMode
{
  UInt8,
  UInt16,
  Float,
  textDropDown,
  subMenu,
  commandSettingPabrik,
};
 
struct Menu
{
  byte tipe;
  void *variabel;
  uint16_t nilaiMin;
  uint16_t nilaiMax;
  void *subMenu;
};
 
struct MenuIndex
{
  byte index;
  char *menutext;
  Menu *menu;
  byte showIndex;
  byte menuLength;
  char *dropDown;
  byte dropDownLength;
};
 
struct Setting
{
  byte lampu;
  byte alarm;
  byte kipas;
  byte kontras;
  byte kecerahan;
  byte suhuSet;
  byte kelembabanSet;
  byte rollerMode;
  long rollerJeda;
  long rollerDurasi;
  long istirahatMode;
  long istirahatkipas;
  long istirahatJeda;
  long istirahatDurasi;
  byte lampuLatar;
  byte humidifier;
  long rollerSebelumnya;
  long istirahatSebelumnya;
  byte tombol;
};
 
struct TouchScreenKode
{
  uint16_t x1;
  uint16_t y1;
  uint16_t x2;
  uint16_t y2;
  byte kode;
};
 
//variabel
bool aktif;
float suhu;
float kelembaban;
 
uint16_t intensitasCahaya;
uint16_t aliranUdara;
uint16_t levelSuara;
uint16_t warnaLampu;
 
uint8_t jam;
uint8_t menit;
uint8_t detik;
uint8_t hari;
uint8_t tanggal;
uint8_t bulan;
uint8_t tahun;
 
Setting setting;
 
//Dropdown menu
const char aktifText[][panjangTextMenu] PROGMEM =
{
  "Tidak",
  "Ya",
};
const char pilihanBatalLanjut[][panjangTextMenu] PROGMEM  =
{
  "Batal",
  "Lanjut",
};
const char pilihanHidupMati[][panjangTextMenu] PROGMEM  =
{
  "Hidup",
  "Mati",
};
const char pilihanHidupMatiAuto[][panjangTextMenu] PROGMEM  =
{
  "Hidup",
  "Mati",
  "Auto",
};
 
const char pilihanKipas[][panjangTextMenu] PROGMEM =
{
  "Hidup",
  "Mati",
  "Humidity",
  "Lampu",
};
 
const char pilihanAlarm[][panjangTextMenu] PROGMEM =
{
  "Temp",
  "roll",
  "istrh",
  "Mati"
};
 
const char menuStrWaktu[][panjangTextMenu] PROGMEM =
{
  "1. Jam",
  "2. Menit",
  "3. Detik",
  "4. Tanggal",
  "5. Bulan",
  "6. Tahun",
};
 
//Sub menu
//tipe            variabel  nilaiMin nilaiMax submenu  jumlahBaris
const Menu menuWaktu[] =
{
  {UInt8         , &jam     , 1     , 24    , 0 },
  {UInt8         , &menit   , 0     , 59    , 0 },
  {UInt8         , &detik   , 0     , 59    , 0 },
  {UInt8         , &tanggal , 1     , 31    , 0 },
  {UInt8         , &bulan   , 1     , 12    , 0 },
  {UInt8         , &tahun   , 0     , 99    , 0 },
};
 
const char menuStrPeralatan[][panjangTextMenu] PROGMEM =
{
  "1. Kipas",
  "2. Alarm",
  "3. Kontras",
  "4. Kecerahan",
  "5. Lampu Latar",
  "6. Bunyi Tmbol",
};
 
const Menu menuPeralatan[] =
{
  {textDropDown  , &setting.kipas      , 0     , (sizeof(pilihanKipas) / sizeof(pilihanKipas[0]) - 1)                , &pilihanKipas         },
  {textDropDown  , &setting.alarm      , 0     , (sizeof(pilihanAlarm) / sizeof(pilihanAlarm[0]) - 1)                  , &pilihanAlarm         },
  {UInt8         , &setting.kontras    , 0     , 99                                                                  , 0                     },
  {UInt8         , &setting.kecerahan  , 0     , 99                                                                  , 0                     },
  {textDropDown  , &setting.lampuLatar , 0     , (sizeof(pilihanHidupMatiAuto) / sizeof(pilihanHidupMatiAuto[0]) - 1)  , &pilihanHidupMatiAuto },
  {textDropDown  , &setting.tombol     , 0     , (sizeof(pilihanHidupMati) / sizeof(pilihanHidupMati[0]) - 1)          , &pilihanHidupMati     },
};
 
const char menuStrRoller[][panjangTextMenu] PROGMEM =
{
  "1. Mode",
  "2. Jeda (jam)",
  "3. Lama(menit)",
};
 
const Menu menuRoller[] =
{
  {textDropDown  , &setting.rollerMode      , 0     , (sizeof(pilihanHidupMati) / sizeof(pilihanHidupMati[0])) - 1     , &pilihanHidupMati  },
  {UInt8         , &setting.rollerJeda      , 1     , 24                                                               , 0                  },
  {UInt8         , &setting.rollerDurasi    , 1     , 59                                                               , 0                  },
};
 
const char menuStrIstirahat[][panjangTextMenu] PROGMEM =
{
  "1. Istirahat",
  "2. Kipas",
  "3. Jeda (jam)",
  "4. Lama(menit)",
};
 
const Menu menuIstirahat[] =
{
  {textDropDown  , &setting.istirahatMode    , 0     , (sizeof(pilihanHidupMati) / sizeof(pilihanHidupMati[0])) - 1    , &pilihanHidupMati },
  {textDropDown  , &setting.istirahatkipas   , 0     , (sizeof(pilihanHidupMati) / sizeof(pilihanHidupMati[0])) - 1    , &pilihanHidupMati },
  {UInt8         , &setting.istirahatJeda    , 10    , 23                                                              , 0                 },
  {UInt8         , &setting.istirahatDurasi  , 1     , 59                                                              , 0                 },
};
 
//Menu utama
const char menuStrUtama[][panjangTextMenu] PROGMEM  =
{
  "1.Waktu",
  "2.Peralatan",
  "3.Temperatur",
  "4.Kelembaban",
  "5.Roller",
  "6.Istirahat",
  "7.Set. pabrik",
};
 
const Menu menuUtama[] =
{
  {subMenu                , &menuStrWaktu          , 0    , sizeof(menuWaktu) / sizeof(menuWaktu[0])                    , &menuWaktu          },
  {subMenu                , &menuStrPeralatan      , 0    , sizeof(menuPeralatan) / sizeof(menuPeralatan[0])            , &menuPeralatan      },
  {UInt8                  , &setting.suhuSet       , 0    , 99                                                          , 0                   },
  {UInt8                  , &setting.kelembabanSet , 0    , 99                                                          , 0                   },
  {subMenu                , &menuStrRoller         , 0    , sizeof(menuRoller) / sizeof(menuRoller[0])                  , &menuRoller         },
  {subMenu                , &menuStrIstirahat      , 0    , sizeof(menuIstirahat) / sizeof(menuIstirahat[0])            , &menuIstirahat      },
  {commandSettingPabrik   , 0                      , 0    , sizeof(pilihanBatalLanjut) / sizeof(pilihanBatalLanjut[0])  , &pilihanBatalLanjut },
};
//========================================================
 
 
 
TouchScreenKode tcKodeIdle[] = {
  {305, 730, 191, 943, 'M'},//menu utama
  {670, 716, 319, 928, 'T'},
  {867, 717, 724, 931, 'W'},
};
TouchScreenKode tcKodeMenu[] = {
  {745, 180, 692, 660, '1'},
  {634, 180, 554, 660, '2'},
  {511, 180, 442, 660, '3'},
  {390, 180, 316, 660, '4'},
  {263, 189, 176, 424, '<'},
  {263, 444, 190, 667, '>'},
  {305, 730, 191, 943, 'B'},
};
 
TouchScreenKode tcKodeEdit[] = {
  {416, 297, 327, 547, 'S'},
  {263, 189, 176, 424, '-'},
  {263, 444, 190, 667, '+'},
  {305, 730, 191, 943, 'B'},
};
 
 
MenuIndex menuIndex[jumlahLevelMenu];
 
long millismenuText;
int8_t levelMenu = -1;
bool menuEntriNilai;
char *judulMenu;
byte judulMenuTampil;
byte menu_Value8;
uint16_t menu_Value16;
float menu_ValueFloat;
 
float suhuSebelumnya;
float kelembabanSebelumnya;
 
Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
 
byte lebarText;
byte ukuranText;
 
bool statusLampu;
bool statusKipas;
bool statusHumidifier;
bool rollerStatus;
bool istirahatStatus;
 
long millisRoller;
long millisIstirahat;
 
bool alarmStatus;
bool alarmPinStatus;
 
void setup()
{
  Serial.begin(9600);
  Serial.println("Menu dan submenu menggunakan LCD TFT 2.4\" berbasis arduino");
  Serial.println("https://www.project.semesin.com/");
  Serial.println();
   
  tft.reset();
  tft.begin(0x9341);
  tft.setRotation(1);
 
  idle();
 
  suhu = 32;
  kelembaban = 65;
 
  ambilDefault();
}
 
void loop()
{
  char tcKode = 0;
  if (levelMenu == -1)
  {
    tcKode = ambilKodeTouchScreen((TouchScreenKode*)&tcKodeIdle, sizeof(tcKodeIdle) / sizeof(TouchScreenKode));
  }
  else if (menuEntriNilai)
  {
    tcKode = ambilKodeTouchScreen((TouchScreenKode*)&tcKodeEdit, sizeof(tcKodeEdit) / sizeof(TouchScreenKode));
  }
  else
  {
    tcKode = ambilKodeTouchScreen((TouchScreenKode*)&tcKodeMenu, sizeof(tcKodeMenu) / sizeof(TouchScreenKode));
  }
  if (tcKode)
  {
    switch (tcKode)
    {
      case 'M':
        levelMenu++;
        menu_Display();
        break;
      case '>':
        menuIndex[levelMenu].showIndex++;
        if (menuIndex[levelMenu].showIndex > (menuIndex[levelMenu].menuLength - (jumlahMenuDalamSatuLayar / 2)))
        {
          menuIndex[levelMenu].showIndex = 0;
        }
        menu_ShowItem();
        break;
      case '<':
        if (menuIndex[levelMenu].showIndex == 0)
        {
          menuIndex[levelMenu].showIndex = (menuIndex[levelMenu].menuLength - (jumlahMenuDalamSatuLayar / 2));
        }
        else
        {
          menuIndex[levelMenu].showIndex--;
        }
        menu_ShowItem();
        break;
      case '1':
      case '2':
      case '3':
      case '4':
        menuIndex[levelMenu].index = menuIndex[levelMenu].showIndex + (tcKode - '1');
        levelMenu++;
        menu_Display();
        break;
      case 'B':
        menuEntriNilai = false;
        levelMenu--;
        menu_Display();
        break;
      case 'S':
        menu_EditSelesai();
        break;
      case '-':
        menu_KurangNilai();
        break;
      case '+':
        menu_TambahNilai();
        break;
 
    }
  }
}
 
void menu_Display()
{
  if (levelMenu == -1)
  {
    idle();
    menuIndex[levelMenu].dropDownLength = 0;
  }
  else if (levelMenu == 0)
  {
    menuIndex[levelMenu].index = 0;
    menuIndex[levelMenu].menutext = (char*)menuStrUtama;
    menuIndex[levelMenu].menu = menuUtama;
    menuIndex[levelMenu].showIndex = 0;
    menuIndex[levelMenu].menuLength = sizeof(menuUtama) / sizeof(menuUtama[0]);
    menuIndex[levelMenu].dropDownLength = 0;
 
    tft.fillRect(0, tinggiBaris1 + 4, 208, 35, BLACK);
 
    ukuranText = 3;
    tft.setFont();
    tft.setTextColor (WHITE, BLACK);
 
    tft.fillRect(0, 0, lebarKolom1, tinggiBaris1, BLACK);
    tft.setTextSize (ukuranText);
    lebarText = 10 * ukuranText * 6;
    tft.setCursor(tengahKolom1 - (lebarText / 2), 0);
    tft.print("MENU UTAMA");
 
    menu_TcMenu();
    menu_ShowItem();
  }
  else
  {
    char buf[panjangTextMenu];
    Menu menuLama = menuIndex[levelMenu - 1].menu[menuIndex[levelMenu - 1].index];
 
    ukuranText = 3;
    tft.setFont();
    tft.setTextColor (WHITE, BLACK);
 
    tft.fillRect(0, 0, lebarKolom1, ukuranText * 8, BLACK);
    tft.setTextSize (ukuranText);
 
    copyFlashString(buf, menuIndex[levelMenu - 1].menutext + (menuIndex[levelMenu - 1].index * panjangTextMenu));
 
    lebarText = strlen(buf) * ukuranText * 6;
    tft.setCursor(tengahKolom1 - (lebarText / 2), 0);
    tft.print(buf);
 
    switch (menuLama.tipe)
    {
      case UInt8:
      case textDropDown:
        menu_Value8 = *(uint8_t*)menuLama.variabel;
        menuEntriNilai = true;
        break;
      case UInt16:
        menu_Value16 = *(uint16_t*)menuLama.variabel;
        menuEntriNilai = true;
        break;
      case Float:
        menu_Value16 = *(float*)menuLama.variabel;
        menuEntriNilai = true;
        break;
      case subMenu:
        menuIndex[levelMenu].index = 0;
        menuIndex[levelMenu].menutext = menuLama.variabel;
        menuIndex[levelMenu].menu = menuLama.subMenu;
        menuIndex[levelMenu].showIndex = 0;
        menuIndex[levelMenu].menuLength = menuLama.nilaiMax;
        menuIndex[levelMenu].dropDownLength = 0;
 
        menu_TcMenu();
        menu_ShowItem();
        break;
      case commandSettingPabrik:
        menu_Value8 = 0;
        menuEntriNilai = true;
        break;
    }
    if (menuEntriNilai)
    {
      menu_TcEdit();
      menu_ShowNilai();
    }
  }
}
void menu_tcIdle()
{
  tft.fillRect(210, 200, 110, 40, YELLOW);
  ukuranText = 3;
  tft.setFont();
  tft.setTextColor (BLACK, YELLOW);
  tft.setTextSize (ukuranText);
  lebarText = 4 * ukuranText * 6;
  tft.setCursor(tengahKolom2 - (lebarText / 2), 208);
  tft.print("MENU");
 
}
void menu_TcMenu()
{
  tft.fillRect(0, tinggiBaris1 + 4, (lebarKolom1 / 2) - 2, 36, YELLOW);
  tft.fillRect((lebarKolom1 / 2) - 2, tinggiBaris1 + 4, 4, 40, BLUE);
  tft.fillRect((lebarKolom1 / 2) + 2, tinggiBaris1 + 4, (lebarKolom1 / 2) - 2, 36, YELLOW);
  tft.fillRect(lebarKolom1 + 4, tinggiBaris1 + 4, 106, 36, YELLOW);
 
  ukuranText = 3;
  tft.setFont();
  tft.setTextColor (BLACK, YELLOW);
  tft.setTextSize (ukuranText);
  lebarText = 1 * ukuranText * 6;
  tft.setCursor(((lebarKolom1 / 2) - lebarText) / 2, 208);
  tft.print("<");
 
  tft.setCursor((((lebarKolom1 / 2) - lebarText) / 2) + (lebarKolom1 / 2), 208);
  tft.print(">");
 
 
  tft.setTextSize (ukuranText);
  lebarText = 5 * ukuranText * 6;
  tft.setCursor(tengahKolom2 - (lebarText / 2), 208);
  tft.print("BALIK");
}
 
void menu_TcEdit()
{
  tft.fillRect(0, tinggiBaris1 - 44, lebarKolom1, 44, BLACK);
  tft.fillRect((lebarKolom1 / 4) - 4, tinggiBaris1 - 44 - 4, (lebarKolom1 / 2) + 8, 36 + 8, BLUE);
  tft.fillRect((lebarKolom1 / 4), tinggiBaris1 - 44, (lebarKolom1 / 2), 36, YELLOW);
 
  tft.fillRect(0, tinggiBaris1 + 4, (lebarKolom1 / 2) - 2, 36, YELLOW);
  tft.fillRect((lebarKolom1 / 2) - 2, tinggiBaris1 + 4, 4, 40, BLUE);
  tft.fillRect((lebarKolom1 / 2) + 2, tinggiBaris1 + 4, (lebarKolom1 / 2) - 2, 36, YELLOW);
  tft.fillRect(lebarKolom1 + 4, tinggiBaris1 + 4, 106, 36, YELLOW);
 
  ukuranText = 3;
  lebarText = 3 * ukuranText * 6;
  tft.setFont();
  tft.setTextColor (BLACK, YELLOW);
  tft.setTextSize (ukuranText);
  tft.setCursor((lebarKolom1 - lebarText) / 2, tinggiBaris1 - 40);
  tft.print("Set");
 
  lebarText = 1 * ukuranText * 6;
  tft.setCursor(((lebarKolom1 / 2) - lebarText) / 2, 208);
  tft.print("-");
 
  tft.setCursor((((lebarKolom1 / 2) - lebarText) / 2) + (lebarKolom1 / 2), 208);
  tft.print("+");
 
 
  tft.setTextSize (ukuranText);
  lebarText = 5 * ukuranText * 6;
  tft.setCursor(tengahKolom2 - (lebarText / 2), 208);
  tft.print("BALIK");
}
void menu_ShowItem()
{
  char buf[panjangTextMenu];
  byte indexMenuMulai;
 
  ukuranText = 3;
  tft.fillRect(0, ukuranText * 8, lebarKolom1, tinggiBaris1 - ukuranText * 8, BLACK);
 
  ukuranText = 2;
  tft.setTextSize (ukuranText);
  tft.setFont();
  tft.setTextColor (WHITE, BLACK);
 
  byte menuItemSize = min(jumlahMenuDalamSatuLayar, menuIndex[levelMenu].menuLength - menuIndex[levelMenu].showIndex);
 
  for ( byte i = 0; i < menuItemSize; i++)
  {
    byte showIndex = menuIndex[levelMenu].showIndex + i;
    tft.setTextSize (ukuranText);
    tft.setCursor(0, (i * ukuranText * 20) + 50);
    copyFlashString(buf, menuIndex[levelMenu].menutext + (showIndex * panjangTextMenu));
    tft.print(buf);
 
    char *alamat;
 
    switch (menuIndex[levelMenu].menu[showIndex].tipe)
    {
      case UInt8:
        itoa(*(uint8_t*)menuIndex[levelMenu].menu[showIndex].variabel, buf, 10);
        lebarText = strlen(buf) * ukuranText * 6;
        tft.setCursor(lebarKolom1 - (lebarText + 10), (i * ukuranText * 20) + 50);
        tft.print(buf);
        break;
      case UInt16:
        itoa(*(uint16_t*)menuIndex[levelMenu].menu[showIndex].variabel, buf, 10);
        lebarText = strlen(buf) * ukuranText * 6;
        tft.setCursor(lebarKolom1 - (lebarText + 10), (i * ukuranText * 20) + 50);
        tft.print(buf);
        break;
      case Float:
        dtostrf(*(float*)menuIndex[levelMenu].menu[showIndex].variabel, 6, 2, buf);
        lebarText = strlen(buf) * ukuranText * 6;
        tft.setCursor(lebarKolom1 - (lebarText + 10), (i * ukuranText * 20) + 50);
        tft.print(buf);
        break;
      case textDropDown:
        copyFlashString(buf, menuIndex[levelMenu].menu[showIndex].subMenu + (*(uint8_t*)menuIndex[levelMenu].menu[showIndex].variabel * panjangTextMenu));
        lebarText = strlen(buf) * ukuranText * 6;
        tft.setCursor(lebarKolom1 - (lebarText + 10), (i * ukuranText * 20) + 50);
        tft.print(buf);
        break;
      case subMenu:
        lebarText = 1 * ukuranText * 6;
        tft.setCursor(lebarKolom1 - (lebarText + 10), (i * ukuranText * 20) + 50);
        tft.print('>');
        break;
      case commandSettingPabrik:
        break;
    }
  }
}
 
void menu_ShowNilai()
{
  char buf[panjangTextMenu];
 
  tft.fillRect(0, 50, lebarKolom1, 100, BLACK);
  Menu menuEdit = menuIndex[levelMenu - 1].menu[menuIndex[levelMenu - 1].index];
  switch (menuEdit.tipe)
  {
    case UInt8:
      itoa(menu_Value8, buf, 10);
      break;
    case UInt16:
      itoa(menu_Value16, buf, 10);
      break;
    case Float:
      dtostrf(menu_ValueFloat, 6, 2, buf);
      break;
    case textDropDown:
    case commandSettingPabrik:
      copyFlashString(buf, menuEdit.subMenu + (menu_Value8 * panjangTextMenu));
      break;
  }
  ukuranText = 5;
  tft.setFont();
  tft.setTextColor (WHITE, BLACK);
  tft.setTextSize (ukuranText);
  lebarText = strlen(buf) * ukuranText * 6;
 
  tft.setCursor((lebarKolom1 - lebarText) / 2, 70);
  tft.print(buf);
}
 
void menu_TambahNilai()
{
  Menu menuEdit = menuIndex[levelMenu - 1].menu[menuIndex[levelMenu - 1].index];
  switch (menuEdit.tipe)
  {
    case UInt8:
    case textDropDown:
    case commandSettingPabrik:
      if (menu_Value8 < menuEdit.nilaiMax)
      {
        menu_Value8++;
      }
      else
      {
        menu_Value8 = menuEdit.nilaiMin;
      }
      break;
    case UInt16:
      if (menu_Value16 < menuEdit.nilaiMax)
      {
        menu_Value16++;
      }
      else
      {
        menu_Value16 = menuEdit.nilaiMin;
      }
      break;
    case Float:
      if (menu_Value8 < menuEdit.nilaiMax)
      {
        menu_ValueFloat += 0.1;
      }
      else
      {
        menu_ValueFloat = menuEdit.nilaiMin;
      }
      break;
  }
  menu_ShowNilai();
 
}
void menu_KurangNilai()
{
  Menu menuEdit = menuIndex[levelMenu - 1].menu[menuIndex[levelMenu - 1].index];
  switch (menuEdit.tipe)
  {
    case UInt8:
    case textDropDown:
    case commandSettingPabrik:
      if (menu_Value8 != menuEdit.nilaiMin)
      {
        menu_Value8--;
      }
      else
      {
        menu_Value8 = menuEdit.nilaiMax;
      }
      break;
    case UInt16:
      if (menu_Value16 != menuEdit.nilaiMax)
      {
        menu_Value16--;
      }
      else
      {
        menu_Value16 = menuEdit.nilaiMax;
      }
      break;
    case Float:
      if (menu_Value8 != menuEdit.nilaiMax)
      {
        menu_ValueFloat -= 0.1;
      }
      else
      {
        menu_ValueFloat = menuEdit.nilaiMax;
      }
      break;
  }
  menu_ShowNilai();
}
void menu_EditSelesai()
{
  Menu menuEdit = menuIndex[levelMenu - 1].menu[menuIndex[levelMenu - 1].index];
 
  switch (menuEdit.tipe)
  {
    case UInt8:
    case textDropDown:
      *(uint8_t*)menuEdit.variabel = menu_Value8;
      break;
    case UInt16:
      *(uint8_t*)menuEdit.variabel = menu_Value16;
      break;
    case Float:
      *(uint8_t*)menuEdit.variabel = menu_ValueFloat;
      break;
    case commandSettingPabrik:
      ambilDefault();
      break;
  }
  menuEntriNilai = false;
 
  tft.fillRect(0, 50, lebarKolom1, 100, BLACK);
  ukuranText = 3;
  tft.setFont();
  tft.setTextColor (WHITE, BLACK);
  tft.setTextSize (ukuranText);
  lebarText = strlen("Tersimpan") * ukuranText * 6;
 
  tft.setCursor((lebarKolom1 - lebarText) / 2, 70);
  tft.print("Tersimpan");
 
  delay(1000);
 
  levelMenu--;
  menu_Display();
 
}
void idle()
{
  tft.fillScreen(BLACK);
  tft.setFont();
 
  menu_tcIdle();
}
 
char ambilKodeTouchScreen(TouchScreenKode *tcKode, byte jumlahArea)
{
  TSPoint p = ts.getPoint();
  char returnValue = 0;
  if ((p.z > TS_MINPRESSURE ) && (p.z < TS_MAXPRESSURE))
  {
    for (byte i = 0; i < jumlahArea; i++)
    {
      if ((tcKode[i].x1 > p.x) && (tcKode[i].x2 < p.x) && (tcKode[i].y1 < p.y) && (tcKode[i].y2 > p.y))
      {
        byte tsCounter;
        do
        {
          p = ts.getPoint();
          if ((p.z < TS_MINPRESSURE ) || (p.z > TS_MAXPRESSURE))
          {
            tsCounter++;
          }
          else
          {
            tsCounter = 0;
          }
        }
        while (tsCounter < 20);
        returnValue = tcKode[i].kode;
        break;
      }
    }
  }
 
  pinMode(XM, OUTPUT);
  pinMode(YP, OUTPUT);
 
  return returnValue;
}
void ambilDefault()
{
  setting.lampu = 2;
  setting.alarm = 0;
  setting.kipas = 2;
  setting.kontras = 55;
  setting.kecerahan = 100;
  setting.suhuSet = 30;
  setting.kelembabanSet = 80;
  setting.rollerMode = 0;
  setting.rollerJeda = 1;
  setting.rollerDurasi = 1;
  setting.istirahatMode = 0;
  setting.istirahatkipas = 0;
  setting.istirahatJeda = 1;
  setting.istirahatDurasi = 1;
  setting.lampuLatar = 0;
  setting.tombol = 0;
  setting.humidifier = 2;
}
byte copyFlashString(char* buf, const char* alamat)
{
  char c;
  byte l = 0;
  while (c = pgm_read_byte(alamat++))
  {
    *buf++ = c;
    l++;
  }
  *buf = 0;
  return l;
 
}

 
library yang digunakan :

  1. Adafruit_GFX_Library.zip
  2. SPFD5408.zip

Mengirim data detektor kebakaran dari arduino ke internet dengan antarmuka code igniter

Asep Kurniawan

Data sensor arduino

Sensor adalah instrumen atau komponen yang mampu mendeteksi perubahan kondisi objek dalam jangkauannya. Pengukuran besaran perubahan tersebut harus diubah dahulu menjadi bentuk digital sehingga dapat diproses oleh perangkat digital lainnya.

Data variabel ini bisa dimonitoring secara lokal melalui layar monitor maupun global melalui internet.

Hal yang mendukung keandalan sistem monitoring :

  1. realtime, yaitu data yang ditampilkan merupakan kondisi masa yang singkat, misalnya di perbarui setiap 1 detik.
  2. Data memiliki identitas seperti lokasi, waktu.
  3. Data yang diterima memiliki mekanisme penyaringan sehingga data yang ditampilkan terjamin.

Sensor detektor kebakaran

Terdapat beberapa Indikasi kebakaran yaitu :

  1. Api dideteksi dengan sensor flame
  2. Suhu dibaca dengan sensor suhu
  3. Asap dibaca dengan sensor asap (smoke detector)

Dalam hal pencegahan kebakaran, ketiga variabel ini terus menerus dimonitoring secara lokal.

Monitoring detektor kebakaran ini secara global juga diperlukan untuk memberikan informasi kepada pihak terkait.

Dalam contoh ini ketiga (modul) sensor ini digunakan bersama arduino dan akan dikirimkan ke mysql server.

Akses informasi sensor dengan codeIgniter

Informasi data saat ini dapat dengan mudah diakses dimanapun, namun dengan menggunakan codeIgniter diperoleh beberapa keuntungan yaitu :

  1. Pengembangan lebih mudah dengan baris program yang dapat disederhanakan.
  2. Aksesibilitas dapat dengan mudah dikontrol.
  3. Perlindungan terhadap server terutama server data lebih terjamin.

Skema Monitoring detektor kebakaran dengan codeIgniter

Komponen yang digunakan :

  1. Arduino Uno
  2. ESP8266
  3. Flame detector
  4. Sensor asap MQ7
  5. Sensor suhu dht11
  6. Relay
  7. Buzzer

Sketch / koding monitoring detektor kebakaran esp8266 – WebServer.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
#include "WiFiEsp.h"
#include <SoftwareSerial.h>
#include "DHT.h"
  
char ssid[] = "****";        // Isi dengan nama profil Wifi
char pass[] = "********";            // password wifi
char server[] = "x.x.x.x";
 
long waktuMintaData = 1000; //minta data setiap 1000ms
 
#define pinFlame    A0
#define pinMQ       A1
#define pinDHT      A2
#define pinBuzzer   8
#define pinRelay    9
 
float setSuhu = 31.0;
 
String Respon = "";
long waktuMulai;
bool responDariServer = false;
bool prosesKirimDataKeServer = false;
  
WiFiEspClient client;
int status = WL_IDLE_STATUS;
 
SoftwareSerial wifi(2,3);
DHT dht(pinDHT, DHT11);
  
void setup()
{
  pinMode(pinFlame, INPUT_PULLUP);
  pinMode(pinMQ, INPUT_PULLUP);
  pinMode(pinDHT, INPUT_PULLUP);
  pinMode(pinBuzzer, OUTPUT);
  digitalWrite(pinRelay, HIGH);
  pinMode(pinRelay, OUTPUT);
 
  Serial.begin(115200);
  
  wifi.begin(115200);
  WiFi.init(&wifi);
  
  // check for the presence of the shield
  if (WiFi.status() == WL_NO_SHIELD) {
    Serial.println("WiFi shield not present");
    // don't continue
    while (true);
  }
  
  // attempt to connect to WiFi network
  while ( status != WL_CONNECTED) {
    Serial.print("Attempting to connect to WPA SSID: ");
    Serial.println(ssid);
    // Connect to WPA/WPA2 network
    status = WiFi.begin(ssid, pass);
  }
  
  // you're connected now, so print out the data
  Serial.println("You're connected to the network");
    
  printWifiStatus();
  dht.begin();
  waktuMulai = millis();
}
  
void loop()
{
  float suhu = dht.readTemperature();
//print status
  Serial.println();
  Serial.print("Api = ");
  Serial.println(digitalRead(pinFlame));
  Serial.print("Asap = ");
  Serial.println(digitalRead(pinMQ));
  Serial.print("suhu = ");
  Serial.println(suhu);
   
  if(!digitalRead(pinFlame) && !digitalRead(pinMQ) && (suhu < setSuhu))
  {
    digitalWrite(pinRelay, HIGH);
    digitalWrite(pinBuzzer, LOW);
     
  }
  if(digitalRead(pinFlame))
  {
    digitalWrite(pinRelay, LOW);
    digitalWrite(pinBuzzer, HIGH);
  }
  if(digitalRead(pinMQ))
  {
    digitalWrite(pinRelay, LOW);
    digitalWrite(pinBuzzer, HIGH);
  }
  if(suhu >= setSuhu)
  {
    digitalWrite(pinBuzzer, HIGH);
  }
  //kirim data
  if(waktuMintaData < millis() - waktuMulai)
  {
    waktuMulai = millis();
    prosesKirimDataKeServer = kirimDataKeServer();
  }
 
  while (client.available())
  {
    char c = client.read();
    Respon += c;
  }
 
  Serial.print("prosesKirimDataKeServer = ");
  Serial.println(prosesKirimDataKeServer);
 
  if (!client.connected() && prosesKirimDataKeServer) {
    Serial.println("Disconnecting from server...");
    client.stop();
    responDariServer = true;
    prosesKirimDataKeServer = false;
  }
 
  // penanganan data yang diterima dari server
  if(responDariServer)
  {
    responDariServer = false;
    Serial.println(Respon);
    int posisiData = Respon.indexOf("\r\n\r\n");
    String Data = Respon.substring(posisiData+4);
    Data.trim();
  
    String variabel;
    String nilai;
  
    Serial.println("Data dari server");
    posisiData = Data.indexOf('=');
    if(posisiData > 0)
    {
      variabel = Data.substring(0,posisiData);
      nilai = Data.substring(posisiData+1);
    
      //===========Penanganan respon disini
      if(variabel == "setSuhu")
      {
        setSuhu = nilai.toFloat();
      }
//      Serial.print(variabel);
//      Serial.print(" = ");
//      Serial.println(nilai);
    }
    Respon = "";
  }
}
 
bool kirimDataKeServer()
{
  Serial.println();
  Serial.println("Starting connection to server...");
  // if you get a connection, report back via serial
  if (client.connect(server, 80)) {
    Serial.println("Connected to server");
    // Make a HTTP request
  
    client.print("GET /index.php/databaseArduino/dariArduino");
    client.print("?Api=");
    client.print(digitalRead(pinFlame));
      
    client.print("&Asap=");
    client.print(digitalRead(pinMQ));
 
    client.print("&Suhu=");
    client.print(dht.readTemperature());
      
    client.println(" HTTP/1.1");
    client.print("Host: ");
    client.println(server);
    client.println("Connection: close");
    client.println();
    return true;
  }
  return false;
}
  
void printWifiStatus()
{
  // print the SSID of the network you're attached to
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());
  
  // print your WiFi shield's IP address
  IPAddress ip = WiFi.localIP();
  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");
  
  IPAddress gateway = WiFi.gatewayIP();
  Serial.print("gateway:");
  Serial.print(gateway);
  Serial.println(" ");
}

program codeIgniter untuk monitoring data sensor arduino:

databaseArduino.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php
class databaseArduino extends CI_Controller {
  public function __construct() {
    parent::__construct();
  }
 
  public function dariBrowser() {
    $this->load->model('Model_databaseArduino');
    $this->Model_databaseArduino->salinDataDariBrowser();
    $data['dataSensor'] = $this->Model_databaseArduino->ambilDataDariArduino();
    $data['dataParameter'] = $this->Model_databaseArduino->ambilDataDariBrowser();
 
    $this->load->view("data_sensor", $data);
  }
 
    public function dariArduino() {
    $this->load->model('Model_databaseArduino');
    $this->Model_databaseArduino->salinDataDariArduino();
    $data['dataParameter'] = $this->Model_databaseArduino->ambilDataDariBrowser();
 
    $this->load->view("data_parameter", $data);
  }
}
?>

Model_databaseArduino.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
<?php
class Model_databaseArduino extends CI_Model {
 
  public $title;
  public $content;
  public $date;
 
  public function ambilDataDariArduino()
  {
    $this->load->database();
    $query = $this->db->query("SELECT * FROM (
    SELECT * FROM `data_sensor` ORDER BY `nomor` DESC LIMIT 10
    ) sub
    ORDER BY `nomor` ASC");
    $this->db->close(); 
    return $query->result();
  }
 
  public function salinDataDariArduino()
  {
    date_default_timezone_set('Asia/Jakarta'); # add your city to set local time zone
    $now = date('Y-m-d H:i:s');
 
    $this->load->database();
    $this->db->set('waktu', $now);
    $this->db->set('api', $this->input->get('Api'));
    $this->db->set('asap', $this->input->get('Asap'));
    $this->db->set('suhu', $this->input->get('Suhu'));
    $this->db->insert('data_sensor');
    $this->db->close();
  }
 
  public function ambilDataDariBrowser()
  {
    $this->load->database();
    $query = $this->db->query("SELECT * FROM `data_parameter` ORDER BY `nomor` DESC LIMIT 1");
    $this->db->close(); 
    return $query->row();
  }
 
  public function salinDataDariBrowser()
  {
    date_default_timezone_set('Asia/Jakarta'); # add your city to set local time zone
    $now = date('Y-m-d H:i:s');
 
    $this->load->database();
    $this->db->set('waktu', $now);
    $this->db->set('setSuhu', $this->input->post('setSuhu'));
    $this->db->insert('data_parameter');
    $this->db->close(); 
  }
}
?>

data_sensor.php

1
2
3
4
5
6
7
8
9
<?php
  defined('BASEPATH') OR exit('No direct script access allowed');
 
  if(isset($dataParameter))
  {
    echo "setSuhu=";
    echo $dataParameter->setSuhu;
  }
?>

data_parameter.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
<?php
defined('BASEPATH') OR exit('No direct script access allowed');
?>
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Welcome to CodeIgniter</title>
 
  <style type="text/css">
 
  ::selection { background-color: #E13300; color: white; }
  ::-moz-selection { background-color: #E13300; color: white; }
 
  body {
    background-color: #fff;
    margin: 40px;
    font: 13px/20px normal Helvetica, Arial, sans-serif;
    color: #4F5155;
  }
 
  a {
    color: #003399;
    background-color: transparent;
    font-weight: normal;
  }
 
  h1 {
    color: #444;
    background-color: transparent;
    border-bottom: 1px solid #D0D0D0;
    font-size: 19px;
    font-weight: normal;
    margin: 0 0 14px 0;
    padding: 14px 15px 10px 15px;
  }
 
  code {
    font-family: Consolas, Monaco, Courier New, Courier, monospace;
    font-size: 12px;
    background-color: #f9f9f9;
    border: 1px solid #D0D0D0;
    color: #002166;
    display: block;
    margin: 14px 0 14px 0;
    padding: 12px 10px 12px 10px;
  }
 
  #body {
    margin: 0 15px 0 15px;
  }
 
  p.footer {
    text-align: right;
    font-size: 11px;
    border-top: 1px solid #D0D0D0;
    line-height: 32px;
    padding: 0 10px 0 10px;
    margin: 20px 0 0 0;
  }
 
  #container {
    margin: 10px;
    border: 1px solid #D0D0D0;
    box-shadow: 0 0 8px #D0D0D0;
  }
  </style>
</head>
<body>
 
 
 
<!--
<form action="/form/data_submitted" method="get">
User Name: <input type="text" name="u_name" placeholder="Please Enter User Name" class="input_box">
<br>
User email: <input type="text" name="u_email" placeholder="Please Enter Email Address" class="input_box">
<input type="submit" value="Submit" class="submit">
</form>
-->
 
<?php
 
// echo $this->input->post('setSuhu');
 
echo form_open('databaseArduino/dariBrowser');
if(isset($dataParameter->setSuhu))
{
  echo form_input('setSuhu', $dataParameter->setSuhu);
}
else
{
  echo form_input('setSuhu', '30.0');
}
echo form_submit('suhuSubmit', 'Set Temperatur');
echo form_close();
 
echo "<br>";
echo "<strong>Data pembacaan sensor</strong>";
echo "<br>";
echo "<table>";
 
  echo "<tr>";
  echo "<td width='50'>Nomor</td>";
  echo "<td width='200'>Waktu</td>";
  echo "<td width='50'>Api</td>";
  echo "<td width='50'>Asap</td>";
  echo "<td width='50'>Suhu</td>";
  echo "</tr>";
 
  foreach ($dataSensor as $row)
{
  echo "<tr>";
  echo "<td>".$row->nomor."</td>";
  echo "<td>".$row->waktu."</td>";
  echo "<td>".$row->api."</td>";
  echo "<td>".$row->asap."</td>";
  echo "<td>".$row->suhu."</td>";
  echo "</tr>";
}
echo "</table>";
?>
</body>
</html>

file server : htdocs.zip

Input keyboard untuk LCD 16×2 menggunakan Arduino

Asep Kurniawan

Keyboard dan mouse merupakan perangkat PC (personal computer) yang berfungsi sebagai interface atau perantara antara pengguna dan pc. Perangkat ini umumnya terhubung menggunakan interface usb, akan tetapi umumnya keyboard dan mouse juga memiliki interface PS2 dan AT Bus.

PS2

PS2 atau Personal System/2 adalah salah satu protokol komunikasi antara komputer dan perangkat lain yang dikembangkan pada tahun 1987. Untuk keyboard dan mouse standar soket PS2-nya berbentuk seperti ini :

AT Bus

AT atau advanced technology bus dikembangkan pada tahun 1984. Standar interface AT Bus untuk keyboad berbentuk seperti ini:

USB Keyboard / mouse

Saat sekarang keyboad dan mouse dengan interface PS2 dan AT bus sudah tidak ditemukan yang digantikan dengan soket dengan interface USB. Namun kebanyakan keyboard dan mouse masih mendukung interface PS2 dengan kombinasi sebagai berikut :

Skema penggunaan keyboard dan mouse sebagai input

contoh sketch/program arduino menggunakan keyboard

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#include <PS2_Semesin.h>
#include <LiquidCrystal_I2C.h>
#include <PS2Code.h>
 
#define keyboardDATAPIN   4
#define keyboardClockPIN  3
 
#define MAX_COL 16
#define MAX_ROW  2
int8_t cols = 0;
int8_t rows = 0;
 
LiquidCrystal_I2C lcd(0x3F, MAX_COL, MAX_ROW);
PS2 keyboard;
 
void setup()
{
  Serial.begin(9600);
  Serial.println("Keyboard arduino dengan tampilan I2C LCD");
  Serial.println("https://www.project.semesin.com/");
  Serial.println();
 
  Wire.begin();
  Wire.beginTransmission(0x3F);
  if (Wire.endTransmission())
  {
    lcd = LiquidCrystal_I2C(0x27, 16, 2);
  }
  lcd.begin();
  lcd.backlight();
 
  keyboard.begin( keyboardDATAPIN, keyboardClockPIN );
  keyboard.setNoBreak(1);
  keyboard.setNoRepeat( 1 );
}
 
 
void loop()
{
  if ( keyboard.available() )
  {
    char keyboardData = keyboard.read();
    if(keyboardData >= ' ' && keyboardData <= '~')
    {
      lcd.print(keyboardData);
      cols++;
      if ( cols >= MAX_COL )
      {
        cols = 0;
        rows++;
        if ( rows >= MAX_ROW )
        {
          rows = 0;
        }
      }
      lcd.setCursor( cols, rows );
      Serial.print(keyboardData);
    }
    else
    {
      Serial.println();
      Serial.print("Special char = ");
      Serial.println(keyboardData,HEX);
      switch ( keyboardData )
      {
        case PS2_KEY_ENTER:
        case PS2_KEY_KP_ENTER:
          cols = 0;
          rows++;
          if ( rows >= MAX_ROW )
            rows = 0;
          break;
        case PS2_KEY_PGDN:
          rows = MAX_ROW - 1;
          break;
        case PS2_KEY_PGUP:
          rows = 0;
          break;
        case PS2_KEY_L_ARROW:
          cols--;
          if ( cols < 0 )
          {
            cols = MAX_COL - 1;
            rows--;
            if ( rows < 0 )
              rows = MAX_ROW - 1;
          }
          break;
        case PS2_KEY_R_ARROW:
          cols++;
          if ( cols >= MAX_COL )
          {
            cols = 0;
            rows++;
            if ( rows >= MAX_ROW )
              rows = 0;
          }
          break;
        case PS2_KEY_UP_ARROW:
          rows--;
          if ( rows < 0 )
            rows = 0;
          break;
        case PS2_KEY_DN_ARROW:
          rows++;
          if ( rows >= MAX_ROW )
            rows = MAX_ROW - 1;
          break;
        case PS2_KEY_BS:
          cols--;
          if ( cols < 0 )
          {
            cols = MAX_COL - 1;
            rows--;
            if ( rows < 0 )
              rows = MAX_ROW - 1;
          }
          lcd.setCursor( cols, rows );
          lcd.write( ' ' );
          break;
        case PS2_KEY_HOME:
          cols = 0;
          rows = 0;
          break;
        case PS2_KEY_END:
          cols = MAX_COL - 1;
          rows = MAX_ROW - 1;
          break;
      }
      lcd.setCursor( cols, rows );
    }
  }
}

library LiquidCrystal-I2C.zip, PS2_Semesin.zip

Pengontrolan tegangan menggunakan PWM pada arduino

Asep Kurniawan

Pengontrolan tegangan berfungsi untuk menjaga kestabilan tegangan keluaran ke beban sehingga beban bisa bekerja semestinya. Contohnya jika beban lampu yang intensitas cahayanya bergantung kepada tegangan, maka dengan tegangan yang stabil akan mengeluarkan cahaya yang stabil pula.

Hal yang menyebabkan ketidakstabilan tegangan diantaranya :

  1. Perubahan beban (penambahan dan pengurangan)
  2. Perubahan nilai masukan (input)
  3. Faktor luar seperti interferensi.

Faktor yang mempengaruhi keandalan pengontrolan tegangan :

  1. Kecepatan respon dari pengontrol tegangan terhadap perubahan yang terjadi, semakin cepat semakin baik.
  2. Sistem koreksi yang digunakan, seperti PID, fuzzy
  3. Karakteristik sensor dan beban yang digunakan

Pengontrolan tegangan dengan arduino

Pengendalian tegangan harus memiliki masukan sensor tegangan dan aktuator kontrol tegangan. Pada aplikasi arduino pembacaan tegangan menggunakan ADC dan aktuasi kontrol tegangan menggunakan PWM.

Dalam contoh ini, sistim koreksi tegangan menggunakan metode proporsional, yaitu semakin besar selisih tegangan dan input maka akan semakin besar pula penambahan nilai PWM.

skema sistem kontrol tegangan mengguakan arduino:

Sketch / koding Penngendalian Tegangan dengan PWM:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#define pinSensorTegangan     0
#define pinOutputPWM          9
#define setTegangan           2.5//volt
#define faktorProporsional    0.1
 
float keluaran;
 
void setup() {
  pinMode(pinOutputPWM, OUTPUT);
   
  Serial.begin(9600);
  Serial.println("Sumber tegangan stabil (automatic voltage regulator) menggunakan kontrol proporsional");
  Serial.println("https://www.project.semesin.com/");
  Serial.println();
 
  keluaran = setTegangan;
}
 
void loop() {
  uint16_t adc = analogRead(pinSensorTegangan);
  float tegangan = map(adc, 0, 1024, 0, 500)/100.0;
  float selisih = setTegangan - tegangan;
  float proporsional = faktorProporsional * selisih;
   
  keluaran += proporsional;
  keluaran = constrain(keluaran, 0, 5);
  byte keluaranPWM = map(keluaran*100, 0, 5*100, 0, 255);
  analogWrite(pinOutputPWM, keluaranPWM);
 
  //Plot serial, hapus untuk menambah kecepatan
  Serial.print(tegangan);
  Serial.print(", ");
  Serial.print(keluaranPWM);
  Serial.println();
  delay(10);
}

Hasil Plot sinyal PWM (merah) dan tegangan keluaran (biru) terhadap perubahan beban.

Tombol power otomatis arduino

Asep Kurniawan

tombol pengunci (self-latching)

Rangkaian kunci tombol otomatis bisa diterapkan dengan bermacam komponen utama, yang umum digunakan adalah dengan menggunakan relay, transistor, mosfet dan SCR.

Penggrendel tombol dengan relay

Dalam sistem listrik rangkaian ini dikenal sebagai DOL (direct on line). Jika tombol ‘nyala’ ditekan maka tegangan akan masuk ke relay melalui tombol ‘padam’, kemudian relay akan aktif dan NO dalam keadaan kontak dan mengunci tegangan tetap masuk ke coil relai dan mengunci posisi relay aktif.

Jika tombol ‘padam’ ditekan dalam keadaan rangkaian aktif, maka suplai  kunci akan terputus dan relay kembali nonaktif.

Pengancing tombol dengan SCR

Masih menggunakan interface yang sama tetapi menggunakan SCR/thyristor 2P4M sebagai penguncinya. Jika tombol ‘nyala ditekan, akan mengalirkan arus ‘gate trigger’ melalui resistor 330 ohmm dan menjadikan SCR dalam keadaan on-state yang selalu aktif walaupun tombol ‘nyala dilepaskan’.

Jika tombol ‘padam’ ditekan, maka suplay arus ke SCR melalui beban outpun akan hilang dan otomatis akan mematikan operasi SCR.

Tombol Vcc otomatis pada arduino menggunakan MOSFET

Tombol power dan arduino bisa dikombinasikan (saling melengkapi) antara pemberi sumber, dan pengunci sumber.

Cara kerjanya adalah pada saat tombol power ditekan, gate pada mosfet akan diberi tegangan 5V, dan menjadikan mosfet menghantarkan GND arduino ke ground sumber.

Sesaat setelah menerima power dari sumber/baterai melalui mosfet, arduino akan menjalankan perintah untuk mengunci kondisi mosfet tetap aktif.

Untuk menonaktifkan mosfetm, cukup dengan menjadikan pin Gate bernilai LOW.

contoh sketch Sumber baterai dengan tombol otomais:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#define pinPower A0
#define pinLED   13
 
void setup() {
  Serial.begin(9600);
  Serial.println("Power arduino otomatis menggunakan MOSFET");
  Serial.println("https://www.project.semesin.com/");
  Serial.println();
  Serial.println("Jangan beri power supply / catu daya USB");
  Serial.println("Akan dimatikan dalam 10 detik");
  Serial.println();
   
  pinMode(pinPower, OUTPUT);
  pinMode(pinLED, OUTPUT);
  digitalWrite(pinPower, HIGH);
  digitalWrite(pinLED, LOW);
 
  delay(7000);
  digitalWrite(pinLED, HIGH);//Tanda arduino akan dimatikan 3 detik lagi
  delay(3000);
 
  //Fungsi mematikan power Vcc
  digitalWrite(pinPower, LOW);
   
}
 
void loop() {
 
}

Tombol power otomatis pada arduino menggunakan SCR (hemat energi)

Prinsip kerja power otomatis pada arduino ini adalah ketika tombol ‘power’ ditekan, maka gate dari scr akan diberi trigger untuk mengaktifkan SCR, setelah tombol dilepaskan SCR akan tetap aktif tanpa sumber arus lain. Tidak seperti menggunakan transistor atau mosfet dimana arus dan tegangan harus disuplai dari arduino.

Untuk mematikan power ini, cukup dengan meng-ground-kan / logika LOW pada pin gate.

contoh sketch kunci tombol power otomatis:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#define pinPower A0
#define pinLED   13
 
void setup() {
  Serial.begin(9600);
  Serial.println("Power arduino otomatis ");
  Serial.println("https://www.project.semesin.com/");
  Serial.println();
  Serial.println("Jangan beri power supply / catu daya USB");
  Serial.println("Akan dimatikan dalam 10 detik");
  Serial.println();
   
  pinMode(pinLED, OUTPUT);
  digitalWrite(pinLED, LOW);
 
  delay(7000);
  digitalWrite(pinLED, HIGH);//Tanda arduino akan dimatikan 3 detik lagi
  delay(3000);
 
  //Fungsi mematikan power Vcc
  digitalWrite(pinPower, LOW);
  pinMode(pinPower, OUTPUT);
   
}
 
void loop() {
 
}

Hitung mundur Arduino (volatile countdown)

Asep Kurniawan

Hitung mundur volatile (tidak menguap) adalah metode hitung mundur digital yang terus berlangsung walaupun catu daya (power supply) dimatikan. Jadi hitung mundur berlanjut sesuai waktu normal ketika catu daya aktif kembali.

Countdown arduino ini berfungsi sebagai penghitung mundur hingga jangka tahunan karena menggunakan metode epoch time. Waktu acuan yang digunakan adalah waktu RTC (DS1307/DS3231).

Waktu epoch adalah jumlah detik hingga saat ini dari tangga 1 Januari 1970.

Hitung mundur menggunakan Arduino dan RTC memanfaatkan EEPROM untuk menyimpan data-data berikut :

  1. Aktif
  2. Waktu mulai hitung mundur (epoch waktu)
  3. Waktu hitung mundur (dalam detik)

Karena perangkat ini memiliki fitur volatile maka dibutuhkan mekanisme pengujian/pengecekan data waktu yang disimpan yaitu :

  1. Apakah ada hitung mundur yang aktif
  2. Jika aktif apakah epoch waktu sekarang lebih besar dari epoch waktu hitung mundur mulai
  3. jika aktif apakan epoch waktu sekarang kecil dari jumlah epoch waktu mulai ditambah jumlah detik hitung mundur.

jika syarat ini di penuhi maka hitung mundur dengan arduino dilanjutkan.

berikut skema Arduino countdown (berlaku untuk DS1307/DS3231):

koding / sketch arduino hitung mundur:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
#include <Wire.h>
#include <TimeLib.h>
#include <DS1307RTC.h>
#include <EEPROM.h>
 
#define alamatEEPROMCountDownAktif  0
#define alamatEEPROMCountDownMulai  1
#define alamatEEPROMCountDownDetik  5
 
byte countDownAktif;
uint32_t countDownMulai;
uint32_t countDownDetik;
uint32_t RTCEpoch;
byte detikSebelumnya = 60;
 
void setup() {
  Serial.begin(9600);
  Serial.println("Hitung mundur Arduino (volatile countdown)");
  Serial.println("https://www.project.semesin.com/");
  Serial.println("Entri waktu hitung mundur (dalam detik) :");
  Serial.println();
 
  countDownAktif = EEPROM.read(alamatEEPROMCountDownAktif);
  if(countDownAktif)
  {
    EEPROM.get(alamatEEPROMCountDownMulai, countDownMulai);
    EEPROM.get(alamatEEPROMCountDownDetik, countDownDetik);
    Serial.println("Hitung mundur aktif");
  }
   
}
 
void loop() {
  tmElements_t tm;
 
  if(Serial.available())
  {
    if (RTC.read(tm))
    {
      delay(200);
      countDownDetik = Serial.parseInt();
      countDownMulai = makeTime(tm);
      countDownAktif = true;
      EEPROM.write(alamatEEPROMCountDownAktif, countDownAktif);
      EEPROM.put(alamatEEPROMCountDownDetik, countDownDetik);
      EEPROM.put(alamatEEPROMCountDownMulai, countDownMulai);
      Serial.println("Waktu hitung mundur = " + String(countDownDetik) + " detik");
    }
    else
    {
      Serial.println("Gagal membaca RTC");
    }
  }
   
  if (RTC.read(tm))
  {
    if(detikSebelumnya != tm.Second)
    {
      if(countDownAktif)
      {
        RTCEpoch = makeTime(tm);
        uint32_t waktuCountDown = countDownDetik - (RTCEpoch - countDownMulai);
        Serial.println("Hitung mundur : " + String(waktuCountDown) + " detik");
   
        if(RTCEpoch < countDownMulai)
        {
          countDownAktif = false;
          EEPROM.write(alamatEEPROMCountDownAktif, countDownAktif);
          Serial.println("Hitung mundur di matikan karena Waktu RTC salah");
          Serial.println("Entri waktu hitung mundur (dalam detik) :");
        }
        else if(RTCEpoch > (countDownMulai + countDownDetik))
        {
          countDownAktif = false;
          EEPROM.write(alamatEEPROMCountDownAktif, countDownAktif);
          Serial.println("Hitung mundur kadaluarsa");
          Serial.println("Entri waktu hitung mundur (dalam detik) :");
        }
        else if(waktuCountDown == 0)
        {
          countDownAktif = false;
          EEPROM.write(alamatEEPROMCountDownAktif, countDownAktif);
          Serial.println("Hitung mundur berakhir");
          Serial.println("Entri waktu hitung mundur (dalam detik) :");
        }
      }
      detikSebelumnya = tm.Second;
    }
  }
  else
  {
    Serial.println("Gagal membaca RTC");
  }
  delay(100);
}

Keluaran serial monitor hitung mundur berbasis arduino:

Menu LCD Arduino dengan keypad

Asep Kurniawan

Aplikasi menu arduino memang menarik namun tidak mudah untuk dibuat. Arduino menggunakan menu merupakan aplikasi yang menampilkan sejumlah pilihan sehingga pengguna bisa memilih/merubah pilihannya.

Menu interaktif lebih cocok digunakan apabila sejumlah pilihan tidak bisa ditampilkan dalam satu halaman. Misalnya menampilkan menu pada LCD karakter 16×2 yang hanya bisa menampung 16 karakter setiap barisnya.

Salah satu menu yang sering digunakan adalah menu-menu makanan dan minuman pada penerapan restoran yang menggunakan sistem digital terkoneksi.

Kelebihan Menu I2C LCD Arduino ini adalah:

  1. Tampilan interaktif bergilir setiap 1 detik dan tampil 5 detik ketika hendak dipilih.
  2. Menggunakan keypad 4×4 sehingga lebih lega.

Video menu interaktif arduino:

Video Player

Dalam perancangan berbasis arduino ini digunakan komponen berikut :

  1. Arduino Uno
  2. LCD 1602 + I2C
  3. Keypad 4×4

skema menu arduino LCD dan keypad:

koding/sketch menu keypad arduino:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
#include <LiquidCrystal_I2C.h>
#include <Keypad.h>
 
const byte ROWS = 4; //four rows
const byte COLS = 4; //three columns
char keys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
byte rowPins[ROWS] = {4, 5, 6, 7};
byte colPins[COLS] = {8, 9, 10, 11};
 
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
 
LiquidCrystal_I2C lcd(0x3F, 16, 2);
 
struct daftarMenu {
  char strMenu[17];
  uint32_t harga;
  bool pilihan;
};
 
char menuUtama[][17] = {
  "0..9 - Pilih    ",
  "* - Pilih       ",
  "# - Batal       ",
  "A - Makanan     ",
  "B - Minuman     ",
  "C - Total/Pesan ",
  "D - Batal       ",
};
daftarMenu menuMakanan[] = {
  {"1 Nasi Goreng   ", 13000L, false},
  {"2 Mie Goreng    ", 8000L, false},
  {"3 Bihun Goreng  ", 8000L, false},
  {"4 Mie Rebus     ", 6000L, false},
  {"5 Gado-gado     ", 13000L, false},
  {"6 Soto Padang   ", 15000L, false},
  {"7 Sate Padang   ", 18000L, false},
};
daftarMenu menuMinuman[] = {
  {"1 Es Campur     ", 6000L, false},
  {"2 Es Tebak      ", 7500L, false},
  {"3 Es Kosong     ", 2000L, false},
  {"4 Jus Jeruk     ", 6000L, false},
  {"5 Jus Pokat     ", 6500L, false},
  {"6 Kopi          ", 4000L, false},
  {"7 Teh Panas     ", 4000L, false},
  {"8 Teh Telur     ", 8000L, false},
};
 
int8_t indexMenu = -1;
byte menuLevel = 0;
byte menuLevelSebelumnya = -1;
 
enum ModeMenu {
  modeMenuMakanan,
  modeMenuMinuman,
};
ModeMenu modeMenu;
#define standarWaktuTampil  1000L
#define LihatWaktuTampil    5000L
#define jumlahMakanan       sizeof(menuMakanan)/sizeof(menuMakanan[0])
#define jumlahMinuman       sizeof(menuMinuman)/sizeof(menuMinuman[0])
 
uint16_t waktuTampil;
unsigned long millisMulai;
 
void setup()
{
  Serial.begin(9600);
  Serial.println("Menu LCD Arduino dengan keypad");
  Serial.println("https://www.project.semesin.com/");
 
  Wire.begin();
  Wire.beginTransmission(0x3F);
  if (Wire.endTransmission())
  {
    lcd = LiquidCrystal_I2C(0x27, 16, 2);
  }
  lcd.begin ();
  lcd.backlight();
  //  tampilanDepan();
  millisMulai = millis();
  resetPilihan();
}
 
void loop()
{
  char key = keypad.getKey();
 
  if (key) {
    Serial.println(key);
    switch (key)
    {
      case 'A':
        menuLevel = 1;
        indexMenu = -1;
        modeMenu = modeMenuMakanan;
        break;
      case 'B':
        menuLevel = 1;
        indexMenu = -1;
        modeMenu = modeMenuMinuman;
        break;
      case 'C':
        menuLevel = 2;
        updateMenu();
        break;
      case 'D':
        resetPilihan();
        menuLevel = 0;
        indexMenu = -1;
        updateMenu();
        break;
      case '*':
        if (menuLevel == 2)
        {
          pesananMasuk();
        }
        else
        {
          if (waktuTampil == LihatWaktuTampil)
          {
            if (modeMenu == modeMenuMakanan)
            {
              menuMakanan[indexMenu].pilihan = true;
            }
            else if (modeMenu == modeMenuMinuman)
            {
              menuMinuman[indexMenu].pilihan = true;
            }
            updateMenu();
          }
          else
          {
            waktuTampil = LihatWaktuTampil;
            millisMulai = millis();
          }
        }
        break;
      case '#':
        if (menuLevel == 2)
        {
          menuLevel = 1;
        }
        else
        {
          if (waktuTampil == LihatWaktuTampil)
          {
            if (modeMenu == modeMenuMakanan)
            {
              menuMakanan[indexMenu].pilihan = false;
            }
            else if (modeMenu == modeMenuMinuman)
            {
              menuMinuman[indexMenu].pilihan = false;
            }
            updateMenu();
          }
          else
          {
            waktuTampil = LihatWaktuTampil;
            millisMulai = millis();
          }
        }
        break;
      default:
        indexMenu = key - '1';
        updateMenu();
        millisMulai = millis();
        waktuTampil = LihatWaktuTampil;
        break;
    }
  }
 
  if (millis() - millisMulai > waktuTampil)
  {
    millisMulai = millis();
    waktuTampil = standarWaktuTampil;
    indexMenu++;
    updateMenu();
    menuLevelSebelumnya = menuLevel;
  }
}
void pesananMasuk()
{
  //Aksi pesanan masuk
  lcd.setCursor(0, 0);
  lcd.println("  Terima Kasih  ");
  lcd.setCursor(0, 1);
  lcd.println("Silahkan tunggu ");
  delay(3000);
  Serial.println("Pesanan masuk!!!");
  menuLevel = 0;
  indexMenu = -1;
}
void updateMenu()
{
  if (menuLevel == 0)
  {
    if (indexMenu == sizeof(menuUtama) / sizeof(menuUtama[0]))
    {
      indexMenu = 0;
    }
    if (menuLevelSebelumnya != menuLevel)
    {
      lcd.clear();
      lcd.print("Selamat Datang");
    }
    tampilMenuUtama(indexMenu);
  }
  else if (menuLevel == 2)
  {
    lcd.setCursor(0, 0);
    lcd.print("Rp. ");
    formatStrHarga(totalPilihan());
    lcd.setCursor(0, 1);
    lcd.print("* Ya   # kembali");
  }
  else if (modeMenu == modeMenuMakanan)
  {
    if (indexMenu >= jumlahMakanan)
    {
      indexMenu = 0;
    }
    tampilMenuMakanan(indexMenu);
  }
  else if (modeMenu == modeMenuMinuman)
  {
    if (indexMenu >= jumlahMinuman)
    {
      indexMenu = 0;
    }
    tampilMenuMinuman(indexMenu);
  }
}
void resetPilihan()
{
  for (byte i = 0; i < jumlahMakanan; i++)
  {
    menuMakanan[i].pilihan = false;
  }
  for (byte i = 0; i < jumlahMinuman; i++)
  {
    menuMinuman[i].pilihan = false;
  }
}
uint32_t totalPilihan()
{
  uint32_t total = 0;
  for (byte i = 0; i < jumlahMakanan; i++)
  {
    if (menuMakanan[i].pilihan)
    {
      total += menuMakanan[i].harga;
    }
  }
  for (byte i = 0; i < jumlahMinuman; i++)
  {
    if (menuMinuman[i].pilihan)
    {
      total += menuMinuman[i].harga;
    }
  }
  return total;
}
void tampilMenuUtama(byte index)
{
  lcd.setCursor(0, 1);
  lcd.print(menuUtama[index]);
}
void tampilMenuMakanan(byte index)
{
  lcd.setCursor(0, 0);
  lcd.print(menuMakanan[index].strMenu);
  lcd.setCursor(0, 1);
  lcd.print("Rp. ");
  formatStrHarga(menuMakanan[index].harga);
  if (menuMakanan[index].pilihan)
  {
    lcd.setCursor(15, 1);
    lcd.print("*");
  }
}
void tampilMenuMinuman(byte index)
{
  lcd.setCursor(0, 0);
  lcd.print(menuMinuman[index].strMenu);
  lcd.setCursor(0, 1);
  lcd.print("Rp. ");
  formatStrHarga(menuMinuman[index].harga);
  if (menuMinuman[index].pilihan)
  {
    lcd.setCursor(15, 1);
    lcd.print("*");
  }
}
void formatStrHarga(uint32_t harga)
{
  String strHarga = String(harga);
  uint8_t panjangStr = strHarga.length();
  uint8_t offset = 3 - (panjangStr % 3);
  for (byte i = 0; i < strHarga.length(); i++)
  {
    lcd.print(strHarga[i]);
    if (!((strHarga.length() + i - offset + 1) % 3))
    {
      if (i != strHarga.length() - 1)
      {
        lcd.print('.');
      }
    }
  }
  for (byte i = 0; i < 16 - 5 - strHarga.length(); i++)
  {
    lcd.print(' ');
  }
}

Library:

Tampilan seven segment dengan metode scanning menggunakan arduino

Asep Kurniawan

Seven segment banyak digunakan sebagai tampilan dari sebuah perangkat, terutama tampilan angka. Seven segment telah tersedia dalam berbagai macam teknologi serta kelebihan masing-masing. Seven segment jenis LED memiliki kelebihan mampu menghasilkan cahaya sendiri sehingga terlihat lebih terang. Sedangkan seven segmen LCD hanya membutuhkan daya kecil untuk operasi-nya.

Setiap segment dari 7segment memiliki paling kurang 8 pin yaitu 7 pin untuk digit, dan 1 pin untuk CA/CC. Untuk membentuk deret angka seven segment digabungkan menjadi beberapa digit. Untuk mengontrol banyak digit seven segment biasanya digunakan metode scanning. Melalui metode scanning ini penggunaan pin menjadi lebih efisien.

Cara menghubungkan seven segment dengan arduino bisa menggunakan transistor array dan BCD to seven segment. Apabila menggunakan seven segment ukuran kecil misalnya ukuran 0.5″, bisa saja seven segment-nya dihubungkan langsung ke arduino seperti contoh berikut:

skema rangkaian seven segment menggunakan arduino:

tata letak seven segment:

sketch atau program scanning seven segment menggunakan arduino:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
#include <TimerOne.h>
 
#define CCorCA            1//0 = CC, 1 = CA
#define jumlah7Segment    4
 
#define pin1    A0
#define pin2    A1
#define pin3    A2
#define pin4    A3
 
#define pinA    4
#define pinB    5
#define pinC    6
#define pinD    7
#define pinE    8
#define pinF    9
#define pinG    10
#define pinDot  11
 
byte pin7Segment[] = {pinA, pinB, pinC, pinD, pinE, pinF, pinG};
byte pin7SegmentCommon[] = {pin1, pin2, pin3, pin4};
 
const char angka[] = {
  0b00111111,
  0b00000110,
  0b01011011,
  0b01001111,
  0b01100110,
  0b01101101,
  0b01111100,
  0b00000111,
  0b01111111,
  0b01100111,
  0b00000000,//blank
  0b01000000,//strip
  0b01101101,//S
  0b00000100,//i
  0b01011111,//a
  0b01110011,//p
 
};
#define Seg_blank 10
#define Seg_stip 11
#define Seg_S 12
#define Seg_i 13
#define Seg_a 14
#define Seg_p 15
 
#define dotBlank 6
#define dotAll   5
 
volatile byte nilai7Segment[4];
volatile byte lastScanIndex = 0;
volatile byte index7Segment = 0;
volatile byte posisiTitik;
 
void setup() {
  Serial.begin(9600);
  Serial.println("Tampilan 7 Segment metode scanning menggunakan arduino");
  Serial.println("https://www.project.semesin.com/");
  Serial.println();
 
  pinMode(pin1, OUTPUT);
  pinMode(pin2, OUTPUT);
  pinMode(pin3, OUTPUT);
  pinMode(pin4, OUTPUT);
 
  pinMode(pinA, OUTPUT);
  pinMode(pinB, OUTPUT);
  pinMode(pinC, OUTPUT);
  pinMode(pinD, OUTPUT);
  pinMode(pinE, OUTPUT);
  pinMode(pinF, OUTPUT);
  pinMode(pinG, OUTPUT);
  pinMode(pinDot, OUTPUT);
 
  Timer1.initialize(2000);
  Timer1.attachInterrupt( timerIsr );
 
  nilai7Segment [3] = Seg_S;
  nilai7Segment [2] = Seg_i;
  nilai7Segment [1] = Seg_a;
  nilai7Segment [0] = Seg_p;
  posisiTitik = dotBlank;
  delay(1000);
}
 
void loop() {
  for (uint16_t i = 0; i < 10000; i++)//0 .. 99.99
  {
    uint32_t BCD = Convert_IntToBCD32(i);
    nilai7Segment [0] = (BCD >> 0) & 0x0F;
    nilai7Segment [1] = (BCD >> 4) & 0x0F;
    nilai7Segment [2] = (BCD >> 8) & 0x0F;
    nilai7Segment [3] = (BCD >> 12) & 0x0F;
    posisiTitik = 2;
    delay(100);
  }
}
 
void timerIsr()
{
  digitalWrite(pin7SegmentCommon[lastScanIndex], CCorCA ? LOW : HIGH);
  drive7Segment(nilai7Segment[index7Segment]);
  if (posisiTitik == dotAll)
  {
    digitalWrite(pinDot, CCorCA ? LOW : HIGH);
  }
  else if (posisiTitik == dotBlank)
  {
    digitalWrite(pinDot, CCorCA ? HIGH : LOW);
  }
  else
  {
    digitalWrite(pinDot, (index7Segment == posisiTitik) ? CCorCA ? LOW : HIGH : CCorCA ? HIGH : LOW);
  }
  digitalWrite(pin7SegmentCommon[index7Segment], CCorCA ? HIGH : LOW);
  lastScanIndex = index7Segment++;
  if (index7Segment >= jumlah7Segment)index7Segment = 0;
}
void drive7Segment(byte nilai)
{
  byte nilai7Segment = CCorCA ? ~angka[nilai] : angka[nilai];
  for (byte i = 0; i < sizeof(pin7Segment); i++)
  {
    digitalWrite(pin7Segment[i], nilai7Segment & 0x01);
    nilai7Segment >>= 1;
  }
}
uint32_t Convert_IntToBCD32(uint32_t DecimalValue)
{
  uint32_t returnValue = 0;
  //uint32_t LSB_L = DecimalValue;
 
  while (DecimalValue >= 10000000L)
  {
    DecimalValue -= 10000000L;
    returnValue += 0x10000000;
  }
  while (DecimalValue >= 1000000L)
  {
    DecimalValue -= 1000000L;
    returnValue += 0x01000000;
  }
  while (DecimalValue >= 100000L)
  {
    DecimalValue -= 100000L;
    returnValue += 0x00100000;
  }
  while (DecimalValue >= 10000)
  {
    DecimalValue -= 10000;
    returnValue += 0x00010000;
  }
  while (DecimalValue >= 1000L)
  {
    DecimalValue -= 1000L;
    returnValue += 0x00001000;
  }
  while (DecimalValue >= 100)
  {
    DecimalValue -= 100;
    returnValue += 0x00000100;
  }
  while (DecimalValue >= 10)
  {
    DecimalValue -= 10;
    returnValue += 0x00000010;
  }
  return returnValue + DecimalValue;
}

Library : TimerOne.zip

Kalibrasi sensor loadcell interaktif dengan Serial USB TTL Arduino

Asep Kurniawan

Sebelum digunakan, timbangan wajib ditera atau di kalibrasi. Proses kalibrasi timbangan dilakukan dengan membandingkan hasil terukurnya dengan berat diketahui sebuah beban pengkalibrasinya.

Loadcell digunakan sebagai sensor berat digital. Proses kalibrasi loadcell dengan arduino menggunakan metode dua beban menggunakan formula :

cara mengkalibrasi loadcell dengan metode dua beban ini menghasilkan dua variabel yaitu skala dan ofset.

Timbangan digital dengan sensor loadcell memiliki karakteristik akurasi berikut :

  1. Skala
  2. Ofset
  3. Linearitas
  4. Diferensial linearitas
  5. Kuantisasi
  6. Transisi akurasi

Setiap loadcell memiliki karakteristik yang berbeda-beda. cara memperoleh nilai skala dan offset yang baik adalah dengan menetapkan nilai beban pengkalibrasi antara 25% – 75% dari kapasitas loadcell.

skema / rangkaian kalibrasi loadcell arduino:

Setting kalibrasi ini akan disimpan di EEPROM, dan akan diambil kembali saat perangkat mulai dihidupkan.

koding /program kalibrasi loadcell menggunakan arduino:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#include "HX711.h"
#include <EEPROM.h>
 
#define alamatKalibrasiM 0
#define alamatKalibrasiC 4
 
//pin
HX711 scale(A0, A1); // (DT, SCK)
 
byte modeKalibrasi = 0;
uint16_t beratKalibrasi1Tera;
uint16_t beratKalibrasi2Tera;
long beratKalibrasi1;
long beratKalibrasi2;
 
long lastMillis;
 
void setup() {
  Serial.begin(9600);
  Serial.println("Kalibrasi Loadcell");
  Serial.println("https://www.project.semesin.com/");
  Serial.println();
   
  float m,c;
  EEPROM.get(alamatKalibrasiM, m);
  EEPROM.get(alamatKalibrasiC, c);
  scale.power_up();
  scale.set_scale(m);
  scale.set_offset(c);
  scale.power_down();
 
  lastMillis = millis();
}
 
void loop() {
  if(Serial.available())
  {
    if(modeKalibrasi == 0)
    {
      if(toupper(Serial.read()) == 'K')
      {
        Serial.println("Masukkan beban kalibrasi pertama (gram) :");
        modeKalibrasi = 1;
      }
    }
    else if (modeKalibrasi == 1)
    {
      scale.power_up();
      delay(100);
      beratKalibrasi1Tera = Serial.parseInt();
      beratKalibrasi1 = scale.read_average(10);
      Serial.println("Beban = " + String(beratKalibrasi1Tera) + " gram, terukur = " + String(beratKalibrasi1) + " unit");
      Serial.println("Masukkan beban kalibrasi kedua yang lebih besar (gram) :");
      modeKalibrasi = 2;
      scale.power_down();
    }
    else if (modeKalibrasi == 2)
    {
      scale.power_up();
      delay(100);
      beratKalibrasi2Tera = Serial.parseInt();
      beratKalibrasi2 = scale.read_average(10);
      Serial.println("Beban = " + String(beratKalibrasi2Tera) + " gram, terukur = " + String(beratKalibrasi2) + " unit");
       
      float m = 1.0 * (beratKalibrasi2 - beratKalibrasi1) / ( beratKalibrasi2Tera - beratKalibrasi1Tera);
      float c = beratKalibrasi2 - (1.0 * m * beratKalibrasi2Tera);
 
      scale.set_scale(m);
      scale.set_offset(c);
      EEPROM.put(alamatKalibrasiM, m);
      EEPROM.put(alamatKalibrasiC, c);
 
      Serial.print("Skala = ");
      Serial.println(m);
      Serial.print("Ofset = ");
      Serial.println(c);
 
      scale.power_down();
      Serial.println("Kalibrasi berhasil.");
       
      modeKalibrasi = 0;
    }
  }
 
  if(!modeKalibrasi)
  {
    if(millis() - lastMillis > 100)
    {
      scale.power_up();
      delay(10);
      float berat = scale.get_units(10);
      scale.power_down();
      Serial.print("Berat : ");
      Serial.println(berat);
      lastMillis = millis();
    }
  }
}

Cara kalibrasi loadcell melalui serial monitor:

Prosedur kalibrasi loadcell dengan arduino melalui serial monitor:

  1. Input ‘K’ atau ‘k’ untuk masuk mode kalibrasi.
  2. Naikkan beban pengkalibrasi pertama
  3. Inputkan berat tera beban pengkalibrasi pertama – Enter
  4. Naikkan beban pengkalibrasi kedua
  5. Inputkan berat tera beban pengkalibrasi kedua – Enter
  6. Selesai

Library : HX711.zip

Seting waktu RTC otomatis dengan arduino

Asep Kurniawan

DS1307 dan DS3231 merupakan RTC (real time clock) yang umum digunakan dalam perancangan arduino. kedua RTC ini saling kompatibel untuk register waktunya, sedangkan register kontrol memiliki alamat berbeda. Selain itu DS3231 memiliki kelebihan dua alarm yang tidak dimiliki oleh DS1307.

Penggunaan RTC pertama kali, RTC harus disetting terlebih dahulu, cara setting DS3231 adalah dengan memberi nilai pada register waktunya, juga register kontrol atau register alarm (khusus DS3231).

Cara menyetting RTC DS3231 dan DS1307 umumnya membutuhkan dua sketch untuk menggunakan RTC ini yaitu setTime dan program utama. Program ‘set waktu’ harus dipisah untuk menghindari program me-‘set waktu’ setiap kali arduino reset.

Otomatisasi setting RTC bertujuan untuk membuat setting waktu berada dalam sketch utama sehingga lebih praktis terutama jika sketch akan bagikan ke publik atau pengguna lain.

Untuk mengetahui apakah RTC sudah disetting atau belum, digunakan 1 byte EEPROM untuk menyimpan status (dibaca tokenRTC), jika RTC sudah disetting maka sketch akan menulis dialamat alamatEEPROMCekToken pada EEPROM dengan nilai tokenRTC.

Ketika program dijalankan sketch akan menguji nilai tokenRTC, jika sama maka sketch tidak lagi melakukan setting waktu RTC.

Skema tulis waktu rtc otomatis (kompatibel DS1307):

sketch/program Atur waktu RTC otomatis (bisa digunakan langsung untuk DS1307 dan DS3231 tanpa library):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
#include <EEPROM.h>
#include <Wire.h>
#include <Sodaq_DS3231.h>
 
#define alamatRTC 0x68
#define alamatEEPROMCekToken 0
#define tokenRTC 0xAA //<== rubah token jika ingin nilai baru
 
void setup() {
  Serial.begin(9600);
  Serial.println("Set waktu RTC otomatis dengan arduino");
  Serial.println("https://www.project.semesin.com/");
  Serial.println();
 
  Wire.begin();
  if (EEPROM.read(alamatEEPROMCekToken) != tokenRTC)
  {
    //Waktu compiler
    char bulan[12];
    byte indexBulan;
    int jam, menit, detik, tanggal, tahun;
 
    char *namaBulan[12] = {
      "Jan", "Feb", "Mar", "Apr", "May", "Jun",
      "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
    };
    sscanf(__TIME__, "%d:%d:%d", &jam, &menit, &detik);
    sscanf(__DATE__, "%s %d %d", bulan, &tanggal, &tahun);
    for (indexBulan = 0; indexBulan < 12; indexBulan++) {
      if (strcmp(bulan, namaBulan[indexBulan]) == 0)
        break;
    }
    uint8_t wday = hariDariTanggal(tanggal, indexBulan + 1, tahun);
    DateTime dt(tahun, indexBulan + 1, tanggal, jam, menit, detik, wday);
    rtc.setDateTime(dt);
    EEPROM.write(alamatEEPROMCekToken, tokenRTC);
    Serial.println("RTC sudah otomatis di setting (Sekali saja)");
  }
}
 
uint32_t old_ts;
void loop() {
  String strNamaHari[] = {"Minggu", "Senin", "Selasa", "Rabu", "Kamis", "Jum'at", "Sabtu"};
  DateTime now = rtc.now(); //get the current date-time
  Serial.print(now.year(), DEC);
  Serial.print('/');
  Serial.print(now.month(), DEC);
  Serial.print('/');
  Serial.print(now.date(), DEC);
  Serial.print(' ');
  Serial.print(now.hour(), DEC);
  Serial.print(':');
  Serial.print(now.minute(), DEC);
  Serial.print(':');
  Serial.print(now.second(), DEC);
  Serial.print(' ');
  Serial.print(strNamaHari[now.dayOfWeek()-1]);
  Serial.println();
 
  while (1);
}
byte hariDariTanggal(byte tanggal, byte bulan, uint16_t tahun)
{
  uint16_t jumlahHariPerBulanMasehi[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
  if (tahun >= 2000)
    tahun -= 2000;
 
  uint32_t jumlahHari = tahun * 365;
  uint16_t tahunKabisat = tahun / 4;
  for (byte i = 0; i < tahun; i++)
  {
    if (!(i % 4))
    {
      jumlahHari++;
    }
  }
  jumlahHari += jumlahHariPerBulanMasehi[bulan - 1];
  if ( (bulan >= 2) && !(tahun % 4))
  {
    jumlahHari++;
  }
  jumlahHari += tanggal;
  return ((jumlahHari + 5) % 7) + 1;
}

Library: Sodaq_DS3231.zip
Versi tanpa library : set_otomatis_rtc.ino