Penggunaan timbangan secara umum membutuhkan akurasi dan presisi. Dalam skala lebih luas sebaiknya unit timbangan juga informatif sehingga dapat diketahui hasilnya secara luas. Untuk keperluan ini, unit timbangan harus memiliki sarana display yang memadai seperti menggunakan display dot mattrix, seven segment dan sebagainya.
Fitur timbangan
Fitur/fasilitas timbangan bisa bermacam sesuai kebutuhan. Dalam perancangan timbangan 7-segment ini memasukkan fitur-fitur penting diantaranya :
-
- Kalibrasi
Kalibrasi adalah kegiatan untuk memastikan timbangan memiliki akurasi dan presisi yang baik. dalam perancangan ini prosedur kalibrasinya sebagai berikut:
-
- Posisi perangkat timbangan dalam keadaan mati
- Letakkan beban tera 1Kg
- Tekan dan tahan tombol [hold]
- Hidupkan perangkat timbangan (akan muncul tulisan ‘load 1’ di tampilan seven segment)
- lepas tombol [hold]
- Tunggu hingga muncul tulisan ‘load 2’ di 7-segment
- Letakkan beban tera 2.5 Kg
- Tekan dan lepas tombol [hold]
- Tunggu hingga muncul tulisan ‘siap’ didisplay 7-segment
- Kalibrasi selesai
- tombol tare
- tombol hold
- Tampilan seven segment
Seven Segmen
Seven segment memiliki kelebihan dari display lainnya, diantaranya :
- Intensitas cahaya lebih terang (akan berkurang jika menggunakan sistem scanning)
- Mudah terbaca dari jarak jauh (lebih jelas)
- Jika menggunakan mikrokontroler, lebih sedikit menggunakan resources (memory dan waktu proses)
- Menggunakan komponen lebih sedikit (non module)
- Perbandingan cahaya vs daya terpakai lebih sedikit sehingga lebih hemat.
Dalam proyek timbangan informatif dengan display 7-segment berbasis arduino ini menggunakan komponen sebagai berikut:
Komponen yang digunakan dalam perancangan timbangan sevent segment menggunakan arduino:
- Arduino uno
- modul hx711 dan loadcell 5Kg
- IC uln2003
- 5x 7-Segment CC
- 2x Tombol
Skema timbangan tampilan seven segmen:
source code/program arduino timbangan seven segment:
#include "HX711.h"
#include <TimerOne.h>
#include <EEPROM.h>
#define CCorCA 1//0 = CC, 1 = CA (rangkaian dengan resistor)
#define tareSaatMulai 1
#define beratKalibrasi1Tera 1.0f //Kg
#define beratKalibrasi2Tera 1.00f //Kg
#define beratMaksimal 2.50 //Kg
#define jumlahSampling 5 //kali
#define frekuensiUpdateData 20 //kali per detik
//pin
HX711 scale(3, 2); // (DT, SCK)
#define pin1 A0
#define pin2 A1
#define pin3 A2
#define pin4 A3
#define pin5 A4
#define pinA 4
#define pinB 5
#define pinC 6
#define pinD 7
#define pinE 8
#define pinF 9
#define pinG 10
#define pinDot 11
#define pinTare 12
#define pinHold 13
#define dotBlank 6
#define dotAll 5
byte pin7Segment[] = {pinA, pinB, pinC, pinD, pinE, pinF, pinG};
byte pin7SegmentCommon[] = {pin1, pin2, pin3, pin4, pin5};
byte posisiTitik = dotBlank;
const char angka[] = {
0b00111111,
0b00000110,
0b01011011,
0b01001111,
0b01100110,
0b01101101,
0b01111100,
0b00000111,
0b01111111,
0b01100111,
0b00000000,//blank
0b01000000,//strip
0b00111000,//L
0b01011100,//o
0b01011111,//a
0b01011110,//d
0b01101101,//S
0b00000100,//i
0b01110011,//p
};
#define Seg_blank 10
#define Seg_stip 11
#define Seg_L 12
#define Seg_o 13
#define Seg_a 14
#define Seg_d 15
#define Seg_S 16
#define Seg_i 17
#define Seg_p 18
//volatile uint32_t beratBCD = 0;
volatile uint8_t beratBCD[5];
volatile byte lastScanIndex = 0;
volatile byte index7Segment = 0;
long lastMillis;
long kirimDataMillis;
byte modeKalibrasi = 0;
long beratKalibrasi1;
long beratKalibrasi2;
float beratTerukur;
bool tahanNilai = false;
byte timbangBeratCounter = 0;
#define alamatKalibrasiM 0
#define alamatKalibrasiC 4
void setup() {
Serial.begin(9600);
Serial.println(F("Timbangan tampilan seven segment menggunakan arduino"));
Serial.println(F("https://www.project.semesin.com"));
pinMode(pin1, OUTPUT);
pinMode(pin2, OUTPUT);
pinMode(pin3, OUTPUT);
pinMode(pin4, OUTPUT);
pinMode(pin5, 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);
pinMode(pinTare, INPUT_PULLUP);
pinMode(pinHold, INPUT_PULLUP);
Timer1.initialize(2000);
Timer1.attachInterrupt( timerIsr );
float m,c;
scale.power_up();
//Mode kalibrasi
if(!digitalRead(pinHold))
{
delay(50);
if(!digitalRead(pinHold))
{
beratBCD[4] = Seg_L;
beratBCD[3] = Seg_o;
beratBCD[2] = Seg_a;
beratBCD[1] = Seg_d;
beratBCD[0] = 1;
while(!digitalRead(pinHold))//lepas
{
while(!digitalRead(pinHold))
{
delay(50);
}
}
delay(1000);
beratKalibrasi1 = scale.read_average(10);
beratBCD[0] = 2;
while(digitalRead(pinHold))//tekan
{
while(digitalRead(pinHold))
{
delay(50);
}
}
delay(1000);
beratKalibrasi2 = scale.read_average(10);
m = 1.0 * (beratKalibrasi2 - beratKalibrasi1) / ( beratKalibrasi2Tera - beratKalibrasi1Tera);
c = beratKalibrasi2 - (1.0 * m * beratKalibrasi2Tera);
EEPROM.put(alamatKalibrasiM, m);
EEPROM.put(alamatKalibrasiC, c);
beratBCD[4] = Seg_S;
beratBCD[3] = Seg_i;
beratBCD[2] = Seg_a;
beratBCD[1] = Seg_p;
beratBCD[0] = Seg_blank;
delay(500);
}
}
EEPROM.get(alamatKalibrasiM, m);
EEPROM.get(alamatKalibrasiC, c);
scale.set_scale(m);
scale.set_offset(c);
#if tareSaatMulai
scale.tare();
#endif
scale.power_down();
lastMillis = millis();
kirimDataMillis = millis();
}
void loop() {
if(!tahanNilai)
{
if(millis() - lastMillis > 10)
{
scale.power_up();
delay(10);
beratTerukur += scale.get_units(1);
if(timbangBeratCounter++ == jumlahSampling)
{
beratTerukur = beratTerukur * 100 / jumlahSampling;
if(beratTerukur < 0)
{
beratBCD[0] = 0;
beratBCD[1] = 0;
beratBCD[2] = 0;
beratBCD[3] = Seg_stip;
beratBCD[4] = Seg_blank;
posisiTitik = 2;
}
else if(beratTerukur <= (beratMaksimal*100))
{
uint32_t BCD = Convert_IntToBCD32(beratTerukur);
if((BCD & 0x0F) <= 5)
{
beratBCD[0] = 0;
}
else
{
beratBCD[0] = 5;
}
beratBCD[1] = (BCD >> 4) & 0x0F;
beratBCD[2] = (BCD >> 8) & 0x0F;
beratBCD[3] = (BCD >> 12) & 0x0F;
beratBCD[4] = (BCD >> 16) & 0x0F;
posisiTitik = 2;
}
beratTerukur = 0;
timbangBeratCounter = 0;
}
scale.power_down();
lastMillis = millis();
}
}
//Kirim data setiap 100ms
if(millis() - kirimDataMillis > (1000/frekuensiUpdateData))
{
if(beratTerukur <= 0)
{
Serial.println("0.00");
}
else
{
Serial.println(floor(beratTerukur)/100, 2);
}
kirimDataMillis = millis();
}
if(!digitalRead(pinTare))
{
delay(50);
if(!digitalRead(pinTare))
{
beratBCD[0] = Seg_blank;
beratBCD[1] = Seg_blank;
beratBCD[2] = Seg_blank;
beratBCD[3] = Seg_blank;
beratBCD[4] = Seg_blank;
posisiTitik = dotAll;
scale.power_up();
delay(10);
scale.tare();
scale.power_down();
while(!digitalRead(pinTare));
}
}
if(!digitalRead(pinHold))
{
delay(50);
if(!digitalRead(pinHold))
{
tahanNilai = !tahanNilai;
while(!digitalRead(pinHold));
}
}
}
void timerIsr()
{
digitalWrite(pin7SegmentCommon[lastScanIndex], CCorCA?LOW:HIGH);
drive7Segment(beratBCD[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 > 4)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 yang digunakan dalam perakitan timbangan arduino:
- HX711.zip
- TimerOne.zip
