Cara Membuat Modul Pompa Sirkulasi Tinta Wims DTF / DTG

#include “Countimer.h”
#include “Arduino.h”

Countimer::Countimer()
{
_previousMillis = 0;
_currentCountTime = 0;
_countTime = 0;
_isCounterCompleted = false;
_isStopped = true;
_countType = COUNT_NONE;
_startCountTime = 0;
}

Countimer::~Countimer()
{
}

void Countimer::setCounter(uint16_t hours, uint8_t minutes, uint8_t seconds, CountType countType, timer_callback onComplete)
{
_onComplete = onComplete;
_countType = countType;
setCounter(hours, minutes, seconds);
}

void Countimer::setCounter(uint16_t hours, uint8_t minutes, uint8_t seconds)
{
if (hours > COUNTIMER_MAX_HOURS) {
hours = COUNTIMER_MAX_HOURS;
}

if (minutes > COUNTIMER_MAX_MINUTES_SECONDS) {
minutes = COUNTIMER_MAX_MINUTES_SECONDS;
}

if (seconds > COUNTIMER_MAX_MINUTES_SECONDS) {
seconds = COUNTIMER_MAX_MINUTES_SECONDS;
}

_currentCountTime = ((hours * 3600L) + (minutes * 60L) + seconds) * 1000L;
_countTime = _currentCountTime;

if (_countType == COUNT_UP)
{
// if is count up mode, we have to start from 00:00:00;
_currentCountTime = 0;
}

_startCountTime = _currentCountTime;

}

void Countimer::setInterval(timer_callback callback, uint32_t interval)
{
_interval = interval;
_callback = callback;
}

uint16_t Countimer::getCurrentHours()
{
return _currentCountTime / 1000 / 3600;
}

uint8_t Countimer::getCurrentMinutes()
{
return _currentCountTime / 1000 % 3600 / 60;
}

uint8_t Countimer::getCurrentSeconds()
{
return _currentCountTime / 1000 % 3600 % 60 % 60;
}

char* Countimer::getCurrentTime()
{
sprintf(_formatted_time, “%02d:%02d:%02d”, getCurrentHours(), getCurrentMinutes(), getCurrentSeconds());
return _formatted_time;
}

bool Countimer::isCounterCompleted()
{
return _isCounterCompleted;
}

bool Countimer::isStopped()
{
return _isStopped;
}

void Countimer::start()
{
_isStopped = false;
if(_isCounterCompleted)
_isCounterCompleted = false;
}

void Countimer::pause()
{
_isStopped = true;
}

void Countimer::stop()
{
_isStopped = true;
_isCounterCompleted = true;
_currentCountTime = _countTime;

if(_countType == COUNT_UP)
{
_currentCountTime = 0;
}
}

void Countimer::restart()
{
_currentCountTime = _startCountTime;
_isCounterCompleted = false;
_isStopped = false;

start();
}

void Countimer::run()
{
// timer is running only if is not completed or not stopped.
if (_isCounterCompleted || _isStopped)
return;

if (millis() – _previousMillis >= _interval) {

if (_countType == COUNT_DOWN)
{
countDown();
}
else if (_countType == COUNT_UP)
{
countUp();
}
else
{
callback();
}
_previousMillis = millis();
}
}

void Countimer::countDown()
{
if (_currentCountTime > 0)
{
callback();
_currentCountTime -= _interval;
}
else
{
stop();
complete();
}
}

void Countimer::countUp()
{
if (_currentCountTime < _countTime)
{
callback();
_currentCountTime += _interval;
}
else
{
stop();
complete();
}
}

void Countimer::callback()
{
if(_callback != NULL)
_callback();
}

void Countimer::complete()
{
if(_onComplete != NULL)
_onComplete();
}

#pragma once

#ifndef COUNTIMER_H
#define COUNTIMER_H

#if defined(ARDUINO) && ARDUINO >= 100
#include
#else
#include
#endif

#define COUNTIMER_MAX_HOURS 999
#define COUNTIMER_MAX_MINUTES_SECONDS 59

typedef void(*timer_callback)(void);

class Countimer
{
public:
Countimer();
~Countimer();

enum CountType
{
COUNT_NONE = 0,
COUNT_UP = 1,
COUNT_DOWN = 2
};

// Set up counter time(hours, minutes, seconds), count mode and function to execute if count is completed.
void setCounter(uint16_t hours, uint8_t minutes, uint8_t seconds, CountType countType, timer_callback onComplete);

// Set up counter time(hours, minutes, seconds) for existing timer.
void setCounter(uint16_t hours, uint8_t minutes, uint8_t seconds);

// Returns timer’s current hours.
uint16_t getCurrentHours();

// Returns timer’s current minutes.
uint8_t getCurrentMinutes();

// Returns timer’s current seconds.
uint8_t getCurrentSeconds();

void setInterval(timer_callback callback, uint32_t interval);

// Returns current timer as formatted string HH:MM:SS
char* getCurrentTime();

// Returns true if counter is completed, otherwise returns false.
bool isCounterCompleted();

// Returns true if counter is still running, otherwise returns false.
bool isCounterRunning();

// Returns true if timer is stopped, otherwise returns false.
bool isStopped();

// Run timer. This is main method.
// If you want to start timer after run, you have to invoke start() method.
void run();

// Starting timer.
void start();

// Stopping timer.
void stop();

// Pausing timer.
void pause();

// Restart timer.
void restart();

private:
// Counting up timer.
void countDown();

void callback();
void complete();

// Counting down timer.
void countUp();

uint32_t _interval = 1;
uint32_t _previousMillis;

// Stores current counter value in milliseconds.
uint32_t _currentCountTime;
uint32_t _startCountTime;

// Stores cached user’s time.
uint32_t _countTime;

// Function to execute.
timer_callback _callback;

// Function to execute when timer is complete.
timer_callback _onComplete;
bool _isCounterCompleted;
bool _isStopped;
char _formatted_time[10];
CountType _countType;
};

#endif

#include
#include “Countimer.h”
Countimer timer;
LCD_I2C lcd(0x27);
#include

#define bt_set A0
#define bt_up A1
#define bt_down A2
#define bt_start A3

int time_s = 0;
int time_m = 0;
int time_h = 0;

int set=0, mode=0;
int flag1=0, flag2=0, flag3=0;

int relay = 8;

void setup() {
Serial.begin (9600);

pinMode(bt_set, INPUT_PULLUP);
pinMode(bt_up, INPUT_PULLUP);
pinMode(bt_down, INPUT_PULLUP);
pinMode(bt_start, INPUT_PULLUP);

pinMode(relay, OUTPUT); digitalWrite(relay, HIGH);

lcd.begin();
lcd.backlight();
lcd.clear();
lcd.setCursor(0,0);
lcd.print(“RIKI ADVERTISING”);
lcd.setCursor(0,1);
lcd.print(“ON/OF WIMS”);
timer.setInterval(print_time, 999);
delay(5000);
lcd.clear();
read_on_time();
}

void print_time(){
time_s = time_s-1;
if(time_s<0 0="" bt_set="" digitalread="" flag1="=0" flag2="=0){flag1=1;" if="" loop="" mode="" time_h="time_h-1;}" time_m="59;" time_s="59;" timer.run="" void="">2){mode=0; set=0;}
if(mode==1){read_on_time(); flag3=0;}
if(mode==2){read_of_time(); flag3=1;}

delay(100);
}
}

if(digitalRead (bt_up) == 0){
if(set==0 && mode==0){timer.start(); flag2=1;}
if(set==1){time_s++;}
if(set==2){time_m++;}
if(set==3){time_h++;}
if(time_s>59){time_s=0;}
if(time_m>59){time_m=0;}
if(time_h>99){time_h=0;}
if(set>0 && mode==1){write_on_time();}
if(set>0 && mode==2){write_of_time();}
delay(200);
}

if(digitalRead (bt_down) == 0){
if(set==0 && mode==0){timer.stop(); flag2=0;}
if(set==1){time_s–;}
if(set==2){time_m–;}
if(set==3){time_h–;}
if(time_s<0 if="" set="" time_h="99;}" time_m="59;}" time_s="59;}">0 && mode==1){write_on_time();}
if(set>0 && mode==2){write_of_time();}
delay(200);
}

if(digitalRead (bt_start) == 0){
if(mode==0){ flag2=1; flag3=0;
read_on_time();
timer.restart();
timer.start();
}
if(mode>0 && flag1==0){ flag1=1;
set = set+1;
if(set>3){set=0;}
delay(100);
}
}

if(digitalRead (bt_set) == 1 && digitalRead (bt_start) == 1){flag1=0;}

lcd.setCursor(0,0);
if(flag3==0){lcd.print(“OFF “);}
if(flag3==1){lcd.print(“ON “);}
lcd.print(“WIMS”);
if(set==0 && mode>0){lcd.print(” SETING “);}
if(set==0 && mode==0 && flag2==0){lcd.print(” STOP “);}
if(set==0 && mode==0 && flag2==1){lcd.print(” START “);}
if(set==1){lcd.print(” SET D “);}
if(set==2){lcd.print(” SET M “);}
if(set==3){lcd.print(” SET J “);}

lcd.setCursor(4,1);
if(time_h<=9){lcd.print(“0”);}
lcd.print(time_h);
lcd.print(“:”);
if(time_m<=9){lcd.print(“0”);}
lcd.print(time_m);
lcd.print(“:”);
if(time_s<=9){lcd.print(“0″);}
lcd.print(time_s);
lcd.print(” “);

if(time_s==0 && time_m==0 && time_h==0 && flag2==1){
flag3 = flag3+1;
if(flag3>1){flag3=0;}

if(flag3==0){read_on_time();}
if(flag3==1){read_of_time();}

timer.restart();
timer.start();

digitalWrite(relay, flag3);

delay(90000);

}

if(flag2==1){digitalWrite(relay, flag3);}
else{digitalWrite(relay, HIGH);}

delay(1);
}

void write_on_time(){
EEPROM.write(1, time_s);
EEPROM.write(2, time_m);
EEPROM.write(3, time_h);
}

void write_of_time(){
EEPROM.write(11, time_s);
EEPROM.write(12, time_m);
EEPROM.write(13, time_h);
}

void read_on_time(){
time_s = EEPROM.read(1);
time_m = EEPROM.read(2);
time_h = EEPROM.read(3);
}

void read_of_time(){
time_s = EEPROM.read(11);
time_m = EEPROM.read(12);
time_h = EEPROM.read(13);
}