/*************************************************************
Download latest Blynk library here: https://github.com/blynkkk/blynk-library/releases/latest
Blynk is a platform with iOS and Android apps to control Arduino, Raspberry Pi and the likes over the Internet. You can easily build graphic interfaces for all your projects by simply dragging and dropping widgets. Downloads, docs, tutorials: http://www.blynk.cc
Sketch generator: http://examples.blynk.cc
Blynk community: http://community.blynk.cc
Follow us: http://www.fb.com/blynkapp
http://twitter.com/blynk_app
Blynk library is licensed under MIT license This example code is in public domain. *************************************************************
This example runs directly on NodeMCU.
Note: This requires ESP8266 support package: https://github.com/esp8266/Arduino
Please be sure to select the right NodeMCU module in the Tools -> Board menu! For advanced settings please follow ESP examples :
- ESP8266_Standalone_Manual_IP.ino
- ESP8266_Standalone_SmartConfig.ino
- ESP8266_Standalone_SSL.ino
Change WiFi ssid, pass, and Blynk auth token to run :) Feel free to apply it to any other example. It's simple!
*************************************************************/
/* Comment this out to disable prints and save space */
#define BLYNK_PRINT Serial
/* Fill-in your Template ID (only if using Blynk.Cloud) */
#define BLYNK_TEMPLATE_ID "TEMPLATE_ID"
#include
#include
#include
#include

// ####################### What you need to modify #####################
// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "BLYNK_TOKEN";
// Your WiFi credentials.
// Set password to "" for open networks.
char ssid[] = "WIFI_SSID";
char pass[] = "WIFI_PASSWORD";

// #####################################################################
Servo myservo;

#define LCD_LINE_1 V0
#define LCD_LINE_2 V1
#define TIMER_1 V2
#define TIMER_2 V3
#define TIMER_3 V4
#define EN_TIMER_1 V5
#define EN_TIMER_2 V6
#define EN_TIMER_3 V7
#define REPEAT_1 V8
#define REPEAT_2 V9
#define REPEAT_3 V10
#define MANUAL_FEED V11
#define FEED_COUNT V12
#define CLEAR_FEED V13

#define SERVO_PIN D0
#define IR_SENSOR_PIN D1
#define MANUAL_SW D3

#define EMPTY_FOOD (digitalRead(IR_SENSOR_PIN))

#define TIMER_NUMBER 3

struct str_command
{
unsigned char start_time_hour[TIMER_NUMBER];
unsigned char start_time_min[TIMER_NUMBER];
unsigned char day_timer[TIMER_NUMBER];
unsigned char feed_repetition[TIMER_NUMBER];
bool flag_timer_en[TIMER_NUMBER];
};

struct str_command timer;

unsigned char rtc_hour;
unsigned char rtc_min;
unsigned char rtc_weekday;

unsigned char server_hour;
unsigned char server_min;
unsigned char server_weekday;

unsigned char feed_rep_count;

unsigned int fish_feed_count;

bool flag_food_check;
bool flag_servo_on_food_check;
unsigned char food_check_count;
unsigned char food_detected_timeout;

bool rtc_synchronized;
bool flag_servo_on;
bool flag_servo_on_buf;

bool blynk_manual_feed_update;

// ######################################################################
void blynk_timer_en_set(unsigned char idx, unsigned char value)
{
timer.flag_timer_en[idx] = value;
Serial.println("Timer " + String(idx+1) + " Set: " + String(value));
}

// ######################################################################
void blynk_feed_repetition_set(unsigned char idx, unsigned char value)
{
timer.feed_repetition[idx] = value;
Serial.println("Feed Repetition " + String(idx+1) + " Set: " + String(value));
}

// ######################################################################
void blynk_timer_set(unsigned char idx, unsigned char start_hr, unsigned char start_min, unsigned char dow)
{
timer.start_time_hour[idx] = start_hr;
timer.start_time_min[idx] = start_min;
timer.day_timer[idx] = dow;

Serial.println();
Serial.println("Timer " + String(idx + 1) + ":");
Serial.println("Start Time: " + String(start_hr) + ":" + String(start_min));
Serial.print("Day set: ");
Serial.println(dow, HEX);v Serial.println();

}

// #####################################################################
BLYNK_CONNECTED()
{
Serial.println("BLYNK SERVER CONNECTED !!!");

Blynk.syncVirtual(TIMER_1);
Blynk.syncVirtual(TIMER_2);
Blynk.syncVirtual(TIMER_3);
Blynk.syncVirtual(EN_TIMER_1);
Blynk.syncVirtual(EN_TIMER_2);
Blynk.syncVirtual(EN_TIMER_3);
Blynk.syncVirtual(REPEAT_1);
Blynk.syncVirtual(REPEAT_2);
Blynk.syncVirtual(REPEAT_3);
Blynk.syncVirtual(FEED_COUNT);

Blynk.sendInternal("rtc", "sync");
}

// #####################################################################
BLYNK_WRITE ( MANUAL_FEED )
{
int val = param.asInt(); // assigning incomming value from pin to a var

if ( val )
flag_servo_on = 1;
}

// #####################################################################
BLYNK_WRITE ( FEED_COUNT )
{
fish_feed_count = param.asInt();
}

// #####################################################################
BLYNK_WRITE ( CLEAR_FEED )
{
int val = param.asInt(); // assigning incomming value from pin to a var

if ( val )
{
fish_feed_count = 0;
Blynk.virtualWrite(LCD_LINE_2, fish_feed_count);
Blynk.virtualWrite(FEED_COUNT, fish_feed_count);
}
}

// #####################################################################
BLYNK_WRITE (REPEAT_1)
{
int val = param.asInt(); // assigning incomming value from pin to a var
blynk_feed_repetition_set(0, val);v }

// #####################################################################
BLYNK_WRITE (REPEAT_2)
{
int val = param.asInt(); // assigning incomming value from pin to a var
blynk_feed_repetition_set(1, val);
}

// #####################################################################
BLYNK_WRITE (REPEAT_3)
{
int val = param.asInt(); // assigning incomming value from pin to a var
blynk_feed_repetition_set(2, val);
}

// #####################################################################
BLYNK_WRITE (EN_TIMER_1)
{
int val = param.asInt(); // assigning incomming value from pin to a var
blynk_timer_en_set(0, val);
}

// #####################################################################
BLYNK_WRITE (EN_TIMER_2)
{
int val = param.asInt(); // assigning incomming value from pin to a var
blynk_timer_en_set(1, val);
}

// #####################################################################
BLYNK_WRITE (EN_TIMER_3)
{
int val = param.asInt(); // assigning incomming value from pin to a var
blynk_timer_en_set(2, val);
}

// #####################################################################
BLYNK_WRITE( TIMER_1 )
{
unsigned char week_day;
unsigned char start_hr, start_min;

TimeInputParam t(param);

if (t.hasStartTime() )
{
start_hr = t.getStartHour();
start_min = t.getStartMinute();

week_day = 0;

for (int i = 1; i <= 7; i++)v {
if (t.isWeekdaySelected(i)) // will be "TRUE" if nothing selected as well
week_day |= (0x01 << (i-1));
}
blynk_timer_set(0, start_hr, start_min, week_day);
}
else
{
Serial.println("Disabled Timer 1");
}
}
// #####################################################################
BLYNK_WRITE( TIMER_2 )
{
unsigned char week_day;
unsigned char start_hr, start_min;
TimeInputParam t(param);
if (t.hasStartTime() )
{
start_hr = t.getStartHour();
start_min = t.getStartMinute();

week_day = 0;

for (int i = 1; i <= 7; i++)
{
if (t.isWeekdaySelected(i)) // will be "TRUE" if nothing selected as well
week_day |= (0x01 << (i-1));
}

blynk_timer_set(1, start_hr, start_min, week_day);
}
else
{
Serial.println("Disabled Timer 2");
}
}

// #####################################################################
BLYNK_WRITE( TIMER_3 )
{
unsigned char week_day;
unsigned char start_hr, start_min;

TimeInputParam t(param);

if (t.hasStartTime() )
{
start_hr = t.getStartHour();
start_min = t.getStartMinute();

week_day = 0;

for (int i = 1; i <= 7; i++)
{
if (t.isWeekdaySelected(i)) // will be "TRUE" if nothing selected as well
week_day |= (0x01 << (i-1));
}
blynk_timer_set(2, start_hr, start_min, week_day);
}
else
{
Serial.println("Disabled Timer 3");
}
}
// #####################################################################
BLYNK_WRITE( InternalPinRTC )
{
const unsigned long DEFAULT_TIME = 1357041600; // Jan 1 2013
unsigned long blynkTime = param.asLong();

if ( blynkTime >= DEFAULT_TIME )
{
setTime(blynkTime);
server_hour = hour();
server_min = minute();
server_weekday = weekday();

if ( server_weekday == 1 )
server_weekday = 7;
elsev server_weekday -= 1;

if ( rtc_synchronized == 0 )
{
rtc_hour = server_hour;
rtc_min = server_min;
rtc_weekday = server_weekday;
}

rtc_synchronized = 1;
}
}
// #####################################################################
unsigned long ms_min_buf;
unsigned long ms_sec_buf;
unsigned char time_10_sec;
void checkTime()
{ unsigned long time_ms = millis();
unsigned long ms_min_diff = time_ms - ms_min_buf;
unsigned long ms_sec_diff = time_ms - ms_sec_buf;
unsigned long server_time_sec;
unsigned long real_time_sec;
// Second management
if ( ms_sec_diff >= 1000 ) // 1 seconds
{
ms_sec_buf = time_ms;

time_10_sec++;
if(time_10_sec >= 10)
{
time_10_sec = 0;
Blynk.sendInternal("rtc", "sync");
}

// update to blynk
if ( flag_servo_on_buf != flag_servo_on )
{
if ( !((flag_servo_on==0)&&(feed_rep_count)) )
{
Blynk.virtualWrite(MANUAL_FEED, flag_servo_on);
}

flag_servo_on_buf = flag_servo_on;
}

if ( food_detected_timeout )
food_detected_timeout--;

// servo management
if ( flag_servo_on )
{
flag_servo_on = 0;

if ( feed_rep_count )
feed_rep_count--;

myservo.write(180);

if ( fish_feed_count < 65535 )
{
fish_feed_count++;
Blynk.virtualWrite(LCD_LINE_2, fish_feed_count);
Blynk.virtualWrite(FEED_COUNT, fish_feed_count);
}

if ( feed_rep_count == 0 )
{
Blynk.logEvent("feeding");
}

food_detected_timeout = 3;
flag_food_check = 0;
}
else
{
if ( flag_food_check )
{
if ( !EMPTY_FOOD ) // found food during checking
{
flag_food_check = 0;
food_detected_timeout = 0;
Blynk.virtualWrite(LCD_LINE_1, "NORMAL");
}
else
{
if ( flag_servo_on_food_check )
{
flag_servo_on_food_check = 0;
myservo.write(45);
if ( food_check_count )
food_check_count--;
}
elsev
{
myservo.write(0);

if ( food_check_count )
{
flag_servo_on_food_check = 1;
}
else // not found food
{
flag_food_check = 0;
Blynk.logEvent("empty_food");
Blynk.virtualWrite(LCD_LINE_1, "EMPTY!!!");
}
}
}
}
else
{
myservo.write(0);
if ( feed_rep_count )
{
flag_servo_on = 1;
}
else
{
if ( food_detected_timeout )
{
if ( EMPTY_FOOD )
{
flag_food_check = 1;
food_check_count = 3;
}
else
{
Blynk.virtualWrite(LCD_LINE_1, "NORMAL");
}
}
}
}
}
}

// Minute management
if ( ms_min_diff >= 60000 ) // 1 min
{
ms_min_buf = time_ms;

// แปลงเวลาให้อยู่ในรูปแบบของวินาที
server_time_sec = (server_hour * 60 * 60) + (server_min * 60);
real_time_sec = (rtc_hour * 60 * 60) + (rtc_min * 60);

// ซิงค์เวลากับ Server เมื่อเวลาปัจจุบันของบอร์ด มีค่าต่างจาก Server มากกว่า 5 นาที
if ( rtc_synchronized &&
(!(server_hour == 23 && server_min == 59 && rtc_hour == 0)) &&
(((server_time_sec > real_time_sec) && ((server_time_sec - real_time_sec) > 300)) ||
((server_time_sec < real_time_sec) && ((real_time_sec - server_time_sec) > 300))) )
{
rtc_hour = server_hour;
rtc_min = server_min;

rtc_weekday = server_weekday;
}

// เวลาปัจจุบันของบอร์ด
rtc_min++;
if (rtc_min >= 60)
{
rtc_min = 0;
rtc_hour++;
if (rtc_hour >= 24)
{
rtc_hour = 0;
rtc_weekday++;
if ( rtc_weekday > 7 )
rtc_weekday = 1;
} }

// Check for start
for (int j=0; j {
if ( timer.flag_timer_en[j] &&
(timer.day_timer[j] == 0x00 || (timer.day_timer[j] & (0x01 << (rtc_weekday - 1) ))) &&
(( rtc_hour == timer.start_time_hour[j] ) && ( rtc_min == timer.start_time_min[j] )) )
{
feed_rep_count = timer.feed_repetition[j];
flag_servo_on = 1;
}
}

// ส่งค่าเวลาต่างๆ ออกทาง Serial monitor เพื่อตรวจสอบ
Serial.println("Server time: " + String(server_hour) + ":" + String(server_min));
Serial.println(String("Server Weekday: ") + String(server_weekday));
Serial.println("Real Time: " + String(rtc_hour) + ":" + String(rtc_min));
Serial.println(String("RTC Weekday: ") + String(rtc_weekday));
Serial.print("Blynk connection status: ");
Serial.println (Blynk.connected());
Serial.println();

}

// To re-synchronize time again when server is connected
if ( !Blynk.connected() )
rtc_synchronized = 0;
}

// #####################################################################
void check_switch()
{
if ( digitalRead(MANUAL_SW) == 0 )
flag_servo_on = 1;
}

// #####################################################################
void setup()
{
// Debug console
Serial.begin(9600);

pinMode(MANUAL_SW, INPUT_PULLUP);

pinMode(IR_SENSOR_PIN, INPUT_PULLUP);

myservo.attach(SERVO_PIN, 544, 2400);
myservo.write(0);

Blynk.begin(auth, ssid, pass);
// You can also specify server:
//Blynk.begin(auth, ssid, pass, "blynk-cloud.com", 80);
//Blynk.begin(auth, ssid, pass, IPAddress(192,168,1,100), 8080);

}

// #####################################################################
void loop()
{
Blynk.run();
checkTime();
check_switch();
}