Obbart/ETcontroller_PRO
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

File reorg, step1

Browse Source
This commit is contained in:
Emanuele Trabattoni
2025-06-20 17:13:16 +02:00
parent 8087774c89
commit 7ea491905f
20 changed files with 3 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
lib/ETH/WS_ETH.cpp Normal file
View File

@@ -0,0 +1,120 @@
#include "WS_ETH.h"
#include <NTPClient.h>
#include <WiFiUdp.h>
static bool eth_connected = false;
static bool eth_connected_Old = false;
IPAddress ETH_ip;
// NTP setup
WiFiUDP udp;
NTPClient timeClient(udp, "pool.ntp.org", timezone*3600, 60000); // NTP server, time offset in seconds, update interval
void onEvent(arduino_event_id_t event, arduino_event_info_t info) {
switch (event) {
case ARDUINO_EVENT_ETH_START:
printf("ETH Started\r\n");
//set eth hostname here
ETH.setHostname("esp32-eth0");
break;
case ARDUINO_EVENT_ETH_CONNECTED: printf("ETH Connected\r\n"); break;
case ARDUINO_EVENT_ETH_GOT_IP: printf("ETH Got IP: '%s'\n", esp_netif_get_desc(info.got_ip.esp_netif)); //printf("%s\r\n",ETH);
ETH_ip = ETH.localIP();
printf("ETH Got IP: %d.%d.%d.%d\n", ETH_ip[0], ETH_ip[1], ETH_ip[2], ETH_ip[3]);
#if USE_TWO_ETH_PORTS
// printf("%d\r\n",ETH1);
#endif
eth_connected = true;
break;
case ARDUINO_EVENT_ETH_LOST_IP:
printf("ETH Lost IP\r\n");
eth_connected = false;
break;
case ARDUINO_EVENT_ETH_DISCONNECTED:
printf("ETH Disconnected\r\n");
eth_connected = false;
break;
case ARDUINO_EVENT_ETH_STOP:
printf("ETH Stopped\r\n");
eth_connected = false;
break;
default: break;
}
}
void testClient(const char *host, uint16_t port) {
printf("\nconnecting to \r\n");;
printf("%s\r\n",host);
NetworkClient client;
if (!client.connect(host, port)) {
printf("connection failed\r\n");
return;
}
client.printf("GET / HTTP/1.1\r\nHost: %s\r\n\r\n", host);
while (client.connected() && !client.available());
while (client.available()) {
printf("%c",(char)client.read());
}
printf("closing connection\n");
client.stop();
}
void ETH_Init(void) {
printf("Ethernet Start\r\n");
Network.onEvent(onEvent);
SPI.begin(ETH_SPI_SCK, ETH_SPI_MISO, ETH_SPI_MOSI);
ETH.begin(ETH_PHY_TYPE, ETH_PHY_ADDR, ETH_PHY_CS, ETH_PHY_IRQ, ETH_PHY_RST, SPI);
#if USE_TWO_ETH_PORTS
ETH1.begin(ETH1_PHY_TYPE, ETH1_PHY_ADDR, ETH1_PHY_CS, ETH1_PHY_IRQ, ETH1_PHY_RST, SPI);
#endif
xTaskCreatePinnedToCore(
EthernetTask,
"EthernetTask",
4096,
NULL,
2,
NULL,
0
);
}
void EthernetTask(void *parameter) {
while(1){
if (eth_connected && !eth_connected_Old) {
eth_connected_Old = eth_connected;
RGB_Open_Time(0, 60, 0,1000, 0);
printf("Network port connected!\r\n");
Acquisition_time();
}
else if(!eth_connected && eth_connected_Old){
eth_connected_Old = eth_connected;
printf("Network port disconnected!\r\n");
}
vTaskDelay(pdMS_TO_TICKS(100));
}
vTaskDelete(NULL);
}
void Acquisition_time(void) { // Get the network time and set to DS3231 to be called after the WIFI connection is successful
timeClient.begin();
timeClient.update();
time_t currentTime = timeClient.getEpochTime();
while(currentTime < 1609459200) // Using the current timestamp to compare with a known larger value,1609459200 is a known larger timestamp value that corresponds to January 1, 2021
{
timeClient.update();
currentTime = timeClient.getEpochTime();
printf("ETH - Online clock error!!!\r\n");
}
struct tm *localTime = localtime(&currentTime);
static datetime_t PCF85063_Time = {0};
PCF85063_Time.year = localTime->tm_year + 1900;
PCF85063_Time.month = localTime->tm_mon + 1;
PCF85063_Time.day = localTime->tm_mday;
PCF85063_Time.dotw = localTime->tm_wday;
PCF85063_Time.hour = localTime->tm_hour;
PCF85063_Time.minute = localTime->tm_min;
PCF85063_Time.second = localTime->tm_sec;
PCF85063_Set_All(PCF85063_Time);
}

44
lib/ETH/WS_ETH.h Normal file
View File

@@ -0,0 +1,44 @@
#pragma once
#include <Arduino.h>
#include <ETH.h>
#include <SPI.h>
#include "WS_PCF85063.h"
#include "WS_GPIO.h"
#include "WS_RTC.h"
// Set this to 1 to enable dual Ethernet support
#define USE_TWO_ETH_PORTS 0
#ifndef ETH_PHY_TYPE
#define ETH_PHY_TYPE ETH_PHY_W5500
#define ETH_PHY_ADDR 1
#define ETH_PHY_CS 16
#define ETH_PHY_IRQ 12
#define ETH_PHY_RST 39
#endif
// SPI pins
#define ETH_SPI_SCK 15
#define ETH_SPI_MISO 14
#define ETH_SPI_MOSI 13
#if USE_TWO_ETH_PORTS
// Second port on shared SPI bus
#ifndef ETH1_PHY_TYPE
#define ETH1_PHY_TYPE ETH_PHY_W5500
#define ETH1_PHY_ADDR 1
#define ETH1_PHY_CS 32
#define ETH1_PHY_IRQ 33
#define ETH1_PHY_RST 18
#endif
ETHClass ETH1(1);
#endif
#define timezone 8 // china
void ETH_Init(void);
void ETH_Loop(void);
void EthernetTask(void *parameter);
void Acquisition_time(void);

189
lib/ETH/WS_PCF85063.cpp Normal file
View File

@@ -0,0 +1,189 @@
#include "WS_PCF85063.h"
datetime_t datetime= {0};
datetime_t Update_datetime= {0};
static uint8_t decToBcd(int val);
static int bcdToDec(uint8_t val);
void Time_printf(void *parameter) {
while(1){
char datetime_str[50];
datetime_to_str(datetime_str,datetime);
printf("Time:%s\r\n",datetime_str);
vTaskDelay(pdMS_TO_TICKS(500));
}
vTaskDelete(NULL);
}
void PCF85063_Init(void) // PCF85063 initialized
{
uint8_t Value = RTC_CTRL_1_DEFAULT|RTC_CTRL_1_CAP_SEL;
I2C_Write(PCF85063_ADDRESS, RTC_CTRL_1_ADDR, &Value, 1);
I2C_Read(PCF85063_ADDRESS, RTC_CTRL_1_ADDR, &Value, 1);
if(Value & RTC_CTRL_1_STOP)
printf("PCF85063 failed to be initialized.state :%d\r\n",Value);
else
printf("PCF85063 is running,state :%d\r\n",Value);
//
// Update_datetime.year = 2024;
// Update_datetime.month = 9;
// Update_datetime.day = 20;
// Update_datetime.dotw = 5;
// Update_datetime.hour = 9;
// Update_datetime.minute = 50;
// Update_datetime.second = 0;
// PCF85063_Set_All(Update_datetime);
xTaskCreatePinnedToCore(
PCF85063Task,
"PCF85063Task",
4096,
NULL,
3,
NULL,
0
);
// xTaskCreatePinnedToCore(
// Time_printf,
// "Time_printf",
// 4096,
// NULL,
// 3,
// NULL,
// 0
// );
}
void PCF85063Task(void *parameter) {
while(1){
PCF85063_Read_Time(&datetime);
vTaskDelay(pdMS_TO_TICKS(100));
}
vTaskDelete(NULL);
}
void PCF85063_Reset() // Reset PCF85063
{
uint8_t Value = RTC_CTRL_1_DEFAULT|RTC_CTRL_1_CAP_SEL|RTC_CTRL_1_SR;
esp_err_t ret = I2C_Write(PCF85063_ADDRESS, RTC_CTRL_1_ADDR, &Value, 1);
if(ret != ESP_OK)
printf("PCF85063 : Reset failure\r\n");
}
void PCF85063_Set_Time(datetime_t time) // Set Time
{
uint8_t buf[3] = {decToBcd(time.second),
decToBcd(time.minute),
decToBcd(time.hour)};
esp_err_t ret = I2C_Write(PCF85063_ADDRESS, RTC_SECOND_ADDR, buf, sizeof(buf));
if(ret != ESP_OK)
printf("PCF85063 : Time setting failure\r\n");
}
void PCF85063_Set_Date(datetime_t date) // Set Date
{
uint8_t buf[4] = {decToBcd(date.day),
decToBcd(date.dotw),
decToBcd(date.month),
decToBcd(date.year - YEAR_OFFSET)};
esp_err_t ret = I2C_Write(PCF85063_ADDRESS, RTC_DAY_ADDR, buf, sizeof(buf));
if(ret != ESP_OK)
printf("PCF85063 : Date setting failed\r\n");
}
void PCF85063_Set_All(datetime_t time) // Set Time And Date
{
uint8_t buf[7] = {decToBcd(time.second),
decToBcd(time.minute),
decToBcd(time.hour),
decToBcd(time.day),
decToBcd(time.dotw),
decToBcd(time.month),
decToBcd(time.year - YEAR_OFFSET)};
esp_err_t ret = I2C_Write(PCF85063_ADDRESS, RTC_SECOND_ADDR, buf, sizeof(buf));
if(ret != ESP_OK)
printf("PCF85063 : Failed to set the date and time\r\n");
}
void PCF85063_Read_Time(datetime_t *time) // Read Time And Date
{
uint8_t buf[7] = {0};
esp_err_t ret = I2C_Read(PCF85063_ADDRESS, RTC_SECOND_ADDR, buf, sizeof(buf));
if(ret != ESP_OK)
printf("PCF85063 : Time read failure\r\n");
else{
time->second = bcdToDec(buf[0] & 0x7F);
time->minute = bcdToDec(buf[1] & 0x7F);
time->hour = bcdToDec(buf[2] & 0x3F);
time->day = bcdToDec(buf[3] & 0x3F);
time->dotw = bcdToDec(buf[4] & 0x07);
time->month = bcdToDec(buf[5] & 0x1F);
time->year = bcdToDec(buf[6]) + YEAR_OFFSET;
}
}
void PCF85063_Enable_Alarm() // Enable Alarm and Clear Alarm flag
{
uint8_t Value = RTC_CTRL_2_DEFAULT | RTC_CTRL_2_AIE;
Value &= ~RTC_CTRL_2_AF;
esp_err_t ret = I2C_Write(PCF85063_ADDRESS, RTC_CTRL_2_ADDR, &Value, 1);
if(ret != ESP_OK)
printf("PCF85063 : Failed to enable Alarm Flag and Clear Alarm Flag \r\n");
}
uint8_t PCF85063_Get_Alarm_Flag() // Get Alarm flag
{
uint8_t Value = 0;
esp_err_t ret = I2C_Read(PCF85063_ADDRESS, RTC_CTRL_2_ADDR, &Value, 1);
if(ret != ESP_OK)
printf("PCF85063 : Failed to obtain a warning flag.\r\n");
else
Value &= RTC_CTRL_2_AF | RTC_CTRL_2_AIE;
//printf("Value = 0x%x",Value);
return Value;
}
void PCF85063_Set_Alarm(datetime_t time) // Set Alarm
{
uint8_t buf[5] ={
decToBcd(time.second)&(~RTC_ALARM),
decToBcd(time.minute)&(~RTC_ALARM),
decToBcd(time.hour)&(~RTC_ALARM),
//decToBcd(time.day)&(~RTC_ALARM),
//decToBcd(time.dotw)&(~RTC_ALARM)
RTC_ALARM, //disalbe day
RTC_ALARM //disalbe weekday
};
esp_err_t ret = I2C_Write(PCF85063_ADDRESS, RTC_SECOND_ALARM, buf, sizeof(buf));
if(ret != ESP_OK)
printf("PCF85063 : Failed to set alarm flag\r\n");
}
void PCF85063_Read_Alarm(datetime_t *time) // Read Alarm
{
uint8_t buf[5] = {0};
esp_err_t ret = I2C_Read(PCF85063_ADDRESS, RTC_SECOND_ALARM, buf, sizeof(buf));
if(ret != ESP_OK)
printf("PCF85063 : Failed to read the alarm sign\r\n");
else{
time->second = bcdToDec(buf[0] & 0x7F);
time->minute = bcdToDec(buf[1] & 0x7F);
time->hour = bcdToDec(buf[2] & 0x3F);
time->day = bcdToDec(buf[3] & 0x3F);
time->dotw = bcdToDec(buf[4] & 0x07);
}
}
static uint8_t decToBcd(int val) // Convert normal decimal numbers to binary coded decimal
{
return (uint8_t)((val / 10 * 16) + (val % 10));
}
static int bcdToDec(uint8_t val) // Convert binary coded decimal to normal decimal numbers
{
return (int)((val / 16 * 10) + (val % 16));
}
void datetime_to_str(char *datetime_str,datetime_t time)
{
sprintf(datetime_str, " %d.%d.%d %d:%d:%d %s", time.year, time.month,
time.day, time.hour, time.minute, time.second, Week[time.dotw]);
}

103
lib/ETH/WS_PCF85063.h Normal file
View File

@@ -0,0 +1,103 @@
#pragma once
#include "I2C_Driver.h"
//PCF85063_ADDRESS
#define PCF85063_ADDRESS (0x51)
//
#define YEAR_OFFSET (1970)
// registar overview - crtl & status reg
#define RTC_CTRL_1_ADDR (0x00)
#define RTC_CTRL_2_ADDR (0x01)
#define RTC_OFFSET_ADDR (0x02)
#define RTC_RAM_by_ADDR (0x03)
// registar overview - time & data reg
#define RTC_SECOND_ADDR (0x04)
#define RTC_MINUTE_ADDR (0x05)
#define RTC_HOUR_ADDR (0x06)
#define RTC_DAY_ADDR (0x07)
#define RTC_WDAY_ADDR (0x08)
#define RTC_MONTH_ADDR (0x09)
#define RTC_YEAR_ADDR (0x0A) // years 0-99; calculate real year = 1970 + RCC reg year
// registar overview - alarm reg
#define RTC_SECOND_ALARM (0x0B)
#define RTC_MINUTE_ALARM (0x0C)
#define RTC_HOUR_ALARM (0x0D)
#define RTC_DAY_ALARM (0x0E)
#define RTC_WDAY_ALARM (0x0F)
// registar overview - timer reg
#define RTC_TIMER_VAL (0x10)
#define RTC_TIMER_MODE (0x11)
//RTC_CTRL_1 registar
#define RTC_CTRL_1_EXT_TEST (0x80)
#define RTC_CTRL_1_STOP (0x20) //0-RTC clock runs 1- RTC clock is stopped
#define RTC_CTRL_1_SR (0X10) //0-no software reset 1-initiate software rese
#define RTC_CTRL_1_CIE (0X04) //0-no correction interrupt generated 1-interrupt pulses are generated at every correction cycle
#define RTC_CTRL_1_12_24 (0X02) //0-24H 1-12H
#define RTC_CTRL_1_CAP_SEL (0X01) //0-7PF 1-12.5PF
//RTC_CTRL_2 registar
#define RTC_CTRL_2_AIE (0X80) //alarm interrupt 0-disalbe 1-enable
#define RTC_CTRL_2_AF (0X40) //alarm flag 0-inactive/cleared 1-active/unchanged
#define RTC_CTRL_2_MI (0X20) //minute interrupt 0-disalbe 1-enable
#define RTC_CTRL_2_HMI (0X10) //half minute interrupt
#define RTC_CTRL_2_TF (0X08)
//
#define RTC_OFFSET_MODE (0X80)
//
#define RTC_TIMER_MODE_TE (0X04) //timer enable 0-disalbe 1-enable
#define RTC_TIMER_MODE_TIE (0X02) //timer interrupt enable 0-disalbe 1-enable
#define RTC_TIMER_MODE_TI_TP (0X01) //timer interrupt mode 0-interrupt follows timer flag 1-interrupt generates a pulse
// format
#define RTC_ALARM (0x80) // set AEN_x registers
#define RTC_CTRL_1_DEFAULT (0x00)
#define RTC_CTRL_2_DEFAULT (0x00)
#define RTC_TIMER_FLAG (0x08)
typedef struct {
uint16_t year;
uint8_t month;
uint8_t day;
uint8_t dotw;
uint8_t hour;
uint8_t minute;
uint8_t second;
}datetime_t;
const unsigned char MonthStr[12][4] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov","Dec"};
const unsigned char Week[7][5] = {"SUN","Mon","Tues","Wed","Thur","Fri","Sat"};
extern datetime_t datetime;
void PCF85063_Init(void);
void PCF85063_Reset(void);
void PCF85063Task(void *parameter);
void PCF85063_Set_Time(datetime_t time);
void PCF85063_Set_Date(datetime_t date);
void PCF85063_Set_All(datetime_t time);
void PCF85063_Read_Time(datetime_t *time);
void PCF85063_Enable_Alarm(void);
uint8_t PCF85063_Get_Alarm_Flag();
void PCF85063_Set_Alarm(datetime_t time);
void PCF85063_Read_Alarm(datetime_t *time);
void datetime_to_str(char *datetime_str,datetime_t time);
// weekday format
// 0 - sunday
// 1 - monday
// 2 - tuesday
// 3 - wednesday
// 4 - thursday
// 5 - friday
// 6 - saturday

350
lib/ETH/WS_RTC.cpp Normal file
View File

@@ -0,0 +1,350 @@
#include "WS_RTC.h"
Timing_RTC CHx_State[Timing_events_Number_MAX]; // Set a maximum of Timing_events_Number_MAX timers
char Event_str[Timing_events_Number_MAX][1000];
static Timing_RTC CHx_State_Default; // Event initial state
const unsigned char Event_cycle[4][13] = {"Aperiodicity","everyday","Weekly","monthly"};
void RTC_Init(void){
PCF85063_Init();
xTaskCreatePinnedToCore(
RTCTask,
"RTCTask",
4096,
NULL,
3,
NULL,
0
);
}
uint8_t Timing_events_Num = 0;
void RTCTask(void *parameter)
{
static uint8_t Time_Old = 0;
while(1){
if(Timing_events_Num){
for (int i = 0; i < Timing_events_Number_MAX; i++){
if(CHx_State[i].Enable_Flag){
if(CHx_State[i].Time.hour == datetime.hour && CHx_State[i].Time.minute == datetime.minute && CHx_State[i].Time.second == datetime.second && datetime.second != Time_Old){ // The event time is consistent with the current time
switch(CHx_State[i].repetition_State){
case Repetition_NONE:
if(CHx_State[i].Time.year == datetime.year && CHx_State[i].Time.month == datetime.month && CHx_State[i].Time.day == datetime.day){ // Executes at the defined date and time
TimerEvent_handling(CHx_State[i]);
TimerEvent_Del(CHx_State[i]);
}
break;
case Repetition_everyday:
TimerEvent_handling(CHx_State[i]);
break;
case Repetition_Weekly:
if(CHx_State[i].Time.dotw == datetime.dotw){
TimerEvent_handling(CHx_State[i]);
}
break;
case Repetition_monthly:
if(CHx_State[i].Time.day == datetime.day){
TimerEvent_handling(CHx_State[i]);
}
break;
default:
printf("Event error!!!!\n");
break;
}
}
}
}
}
Time_Old = datetime.second;
vTaskDelay(pdMS_TO_TICKS(100));
}
vTaskDelete(NULL);
}
void TimerEvent_handling(Timing_RTC event){
uint8_t Retain_channels = 0;
printf("Event %d : \r\n", event.Event_Number);
char datetime_str[50];
datetime_to_str(datetime_str,event.Time);
for (int i = 0; i < Relay_Number_MAX; i++) {
if(*(&(event.Relay_CH1)+i) == STATE_Retain) // Find the modified channel
Retain_channels ++; // Number of unmodified channels
}
if(Retain_channels < Relay_Number_MAX - 1){
printf("%s\r\n", datetime_str);
printf("CHx Open : ");
int j = 0;
for (j = 0; j < Relay_Number_MAX; j++) {
if(*(&(event.Relay_CH1)+j) == STATE_Open)
printf("CH%d ", j+1);
}
printf("\r\nCHx Closs : ");
for (j = 0; j < Relay_Number_MAX; j++) {
if(*(&(event.Relay_CH1)+j) == STATE_Closs)
printf("CH%d ", j+1);
}
if(Retain_channels){
printf("\r\nCHx Retain : ");
for (j = 0; j < Relay_Number_MAX; j++) {
if(*(&(event.Relay_CH1)+j) == STATE_Retain)
printf("CH%d ", j+1);
}
}
printf("\r\n");
Relay_Immediate_CHxn(&(event.Relay_CH1), RTC_Mode);
printf("\r\n");
}
else if(Retain_channels == Relay_Number_MAX - 1){ // Modified a channel (use TimerEvent_CHx_Set())
printf("%s\r\n", datetime_str);
for (int x = 0; x < Relay_Number_MAX; x++) {
if(*(&(event.Relay_CH1)+x) != STATE_Retain){ // Find the modified channel
if(*(&(event.Relay_CH1)+x)){
printf("CH%d Open\r\n", x);
Relay_Immediate(x, true, RTC_Mode);
printf("\r\n");
}
else{
printf("CH%d Closs\r\n", x);
Relay_Immediate(x, false, RTC_Mode);
printf("\r\n");
}
break;
}
}
}
else{
printf("Event error or no relay control!!!\r\n");
}
}
void TimerEvent_CHx_Set(datetime_t time,uint8_t CHx, bool State, Repetition_event Repetition)
{
char datetime_str[50];
datetime_to_str(datetime_str,datetime);
printf("Now Time: %s!!!!\r\n", datetime_str);
if(CHx > Relay_Number_MAX){
printf("Timing_CHx_Set(function): Error passing parameter CHx!!!!\r\n");
return;
}
if(Timing_events_Num + 1 >= Timing_events_Number_MAX)
{
printf("Note : The number of scheduled events is full.\r\n");
}
else{
RGB_Open_Time(50, 36, 0, 1000, 0);
CHx_State[Timing_events_Num].Enable_Flag = true;
CHx_State[Timing_events_Num].Event_Number = Timing_events_Num + 1;
*(&(CHx_State[Timing_events_Num].Relay_CH1)+CHx) = (Status_adjustment)State;
CHx_State[Timing_events_Num].Time = time;
CHx_State[Timing_events_Num].repetition_State = Repetition;
Timing_events_Num ++;
datetime_to_str(datetime_str,time);
if(State){
printf("New timing event%d :\r\n %s set CH%d Open ----- %s\r\n\r\n", Timing_events_Num, datetime_str, CHx, Event_cycle[Repetition]);
sprintf(Event_str[Timing_events_Num-1], "Event %d : %s set CH%d Open ----- %s\\n\\n", Timing_events_Num, datetime_str, CHx, Event_cycle[Repetition]);
}
else{
printf("New timing event%d :\r\n %s set CH%d Closs ----- %s\r\n\r\n", Timing_events_Num, datetime_str, CHx, Event_cycle[Repetition]);
sprintf(Event_str[Timing_events_Num-1], "Event %d : %s set CH%d Closs ----- %s\\n\\n", Timing_events_Num, datetime_str, CHx, Event_cycle[Repetition]);
}
Buzzer_Open_Time(700, 0);
}
}
void TimerEvent_CHxs_Set(datetime_t time,uint8_t PinState, Repetition_event Repetition)
{
char datetime_str[50];
datetime_to_str(datetime_str,datetime);
printf("Now Time: %s!!!!\r\n", datetime_str);
if(Timing_events_Num + 1 >= Timing_events_Number_MAX)
{
printf("Note : The number of scheduled events is full.\r\n");
}
else{
RGB_Open_Time(50, 36, 0, 1000, 0);
CHx_State[Timing_events_Num].Enable_Flag = true;
CHx_State[Timing_events_Num].Event_Number = Timing_events_Num + 1;
for (int i = 0; i < Relay_Number_MAX; i++) {
*(&(CHx_State[Timing_events_Num].Relay_CH1)+i) = (Status_adjustment)((PinState >> i) & 0x01);
}
CHx_State[Timing_events_Num].Time = time;
CHx_State[Timing_events_Num].repetition_State = Repetition;
Timing_events_Num ++;
datetime_to_str(datetime_str,time);
printf("New timing event%d :\r\n %s \r\n",Timing_events_Num, datetime_str);
printf(" CHx :");
for (int i = 0; i < Relay_Number_MAX; i++)
printf("CH%d ", i+1);
printf("\r\n State :");
for (int i = 0; i < Relay_Number_MAX; i++) {
if((PinState >> i) & 0x01)
printf("Open ");
else
printf("Closs ");
}
printf("\r\n");
printf(" ----- %s\r\n\r\n", Event_cycle[Repetition]);
printf("\r\n");
Buzzer_Open_Time(700, 0);
int len = 0;
char Event_content[1000];
len += snprintf(Event_content + len, sizeof(Event_content) - len, "&nbsp;&nbsp;&nbsp;&nbsp;CHx&nbsp;&nbsp;:");
for (int i = 0; i < Relay_Number_MAX; i++) {
len += snprintf(Event_content + len, sizeof(Event_content) - len, "CH%d&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;", i + 1);
}
len += snprintf(Event_content + len, sizeof(Event_content) - len, "\\n &nbsp;&nbsp;&nbsp;&nbsp;State :");
for (int i = 0; i < Relay_Number_MAX; i++) {
if ((PinState >> i) & 0x01)
len += snprintf(Event_content + len, sizeof(Event_content) - len, "Open&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;");
else
len += snprintf(Event_content + len, sizeof(Event_content) - len, "Closs&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;");
}
len += snprintf(Event_content + len, sizeof(Event_content) - len, "\\n&nbsp;&nbsp;&nbsp;&nbsp;----- %s\\n\\n", Event_cycle[Repetition]);
// printf("%s\r\n", Event_content);
sprintf(Event_str[Timing_events_Num-1], "Event %d : %s \\n%s", Timing_events_Num, datetime_str,Event_content);
}
}
void TimerEvent_CHxn_Set(datetime_t time,Status_adjustment *Relay_n, Repetition_event Repetition)
{
char datetime_str[50];
datetime_to_str(datetime_str,datetime);
printf("Now Time: %s!!!!\r\n", datetime_str);
if(Timing_events_Num + 1 >= Timing_events_Number_MAX)
{
printf("Note : The number of scheduled events is full.\r\n");
}
else{
RGB_Open_Time(50, 36, 0, 1000, 0);
CHx_State[Timing_events_Num].Enable_Flag = true;
CHx_State[Timing_events_Num].Event_Number = Timing_events_Num + 1;
for (int i = 0; i < Relay_Number_MAX; i++) {
*(&(CHx_State[Timing_events_Num].Relay_CH1)+i) = Relay_n[i];
}
CHx_State[Timing_events_Num].Time = time;
CHx_State[Timing_events_Num].repetition_State = Repetition;
Timing_events_Num ++;
datetime_to_str(datetime_str,time);
printf("New timing event%d :\r\n %s \r\n",Timing_events_Num, datetime_str);
printf(" CHx :");
for (int i = 0; i < Relay_Number_MAX; i++)
printf("CH%d ", i+1);
printf("\r\n State :");
for (int i = 0; i < Relay_Number_MAX; i++) {
if(Relay_n[i] == STATE_Open)
printf("Open ");
else if(Relay_n[i] == STATE_Closs)
printf("Closs ");
else if(Relay_n[i] == STATE_Retain)
printf("Retain ");
}
printf("\r\n");
printf(" ----- %s\r\n\r\n", Event_cycle[Repetition]);
printf("\r\n");
Buzzer_Open_Time(700, 0);
int len = 0;
char Event_content[1000];
len += snprintf(Event_content + len, sizeof(Event_content) - len, "&nbsp;&nbsp;&nbsp;&nbsp;CHx&nbsp;&nbsp;:");
for (int i = 0; i < Relay_Number_MAX; i++) {
len += snprintf(Event_content + len, sizeof(Event_content) - len, "CH%d&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;", i + 1);
}
len += snprintf(Event_content + len, sizeof(Event_content) - len, "\\n&nbsp;&nbsp;&nbsp;&nbsp;State&nbsp;:");
for (int i = 0; i < Relay_Number_MAX; i++) {
if (Relay_n[i] == STATE_Open)
len += snprintf(Event_content + len, sizeof(Event_content) - len, "Open&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;");
else if(Relay_n[i] == STATE_Closs)
len += snprintf(Event_content + len, sizeof(Event_content) - len, "Closs&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;");
else if(Relay_n[i] == STATE_Retain)
len += snprintf(Event_content + len, sizeof(Event_content) - len, "Retain&nbsp;&nbsp;&nbsp;");
}
len += snprintf(Event_content + len, sizeof(Event_content) - len, "\\n&nbsp;&nbsp;&nbsp;&nbsp;----- %s\\n\\n", Event_cycle[Repetition]);
// printf("%s\r\n", Event_content);
sprintf(Event_str[Timing_events_Num-1], "Event %d : %s \\n%s", Timing_events_Num, datetime_str,Event_content);
}
}
void TimerEvent_printf(Timing_RTC event){
uint8_t Retain_channels = 0;
uint8_t open[8]={0};
printf("Event %d : \r\n", event.Event_Number);
char datetime_str[50];
datetime_to_str(datetime_str,event.Time);
for (int i = 0; i < Relay_Number_MAX; i++) {
if(*(&(event.Relay_CH1)+i) == STATE_Retain) // Find the modified channel
Retain_channels ++; // Number of unmodified channels
else
open[i] = *(&(event.Relay_CH1)+i);
}
if(Retain_channels == 0){ // All channels have been modified (use TimerEvent_CHxs_Set())
printf("%s\r\n", datetime_str);
printf(" CHx Open : ");
for (int j = 0; j < Relay_Number_MAX; j++) {
if(open[j])
printf("CH%d ", j);
}
printf("\r\n CHx Closs : ");
for (int k = 0; k < Relay_Number_MAX; k++) {
if(!open[k])
printf("CH%d ", k);
}
printf("\r\n");
}
else if(Retain_channels == Relay_Number_MAX - 1){ // Modified a channel (use TimerEvent_CHx_Set())
printf("%s ,", datetime_str);
for (int x = 0; x < Relay_Number_MAX; x++) {
if(*(&(event.Relay_CH1)+x) != STATE_Retain){ // Find the modified channel
if(*(&(event.Relay_CH1)+x))
printf("CH%d Open\r\n", x);
else
printf("CH%d Closs\r\n", x);
break;
}
}
}
else{
printf("%s\r\n", datetime_str);
printf("CHx Open : ");
int j = 0;
for (j = 0; j < Relay_Number_MAX; j++) {
if(open[j] == STATE_Open)
printf("CH%d ", j+1);
}
printf("\r\nCHx Closs : ");
for (j = 0; j < Relay_Number_MAX; j++) {
if(open[j] == STATE_Closs)
printf("CH%d ", j+1);
}
printf("\r\nCHx Retain : ");
for (j = 0; j < Relay_Number_MAX; j++) {
if(open[j] == STATE_Retain)
printf("CH%d ", j+1);
}
printf("\r\n");
}
}
void TimerEvent_printf_ALL(void)
{
printf("/******************* Current RTC event *******************/ \r\n");
for (int i = 0; i < Timing_events_Number_MAX; i++) {
if(CHx_State[i].Enable_Flag)
TimerEvent_printf(CHx_State[i]);
}
printf("/******************* Current RTC event *******************/\r\n\r\n ");
}
void TimerEvent_Del(Timing_RTC event){
RGB_Open_Time(20, 0, 50, 1000, 0);
printf("Example Delete an RTC event%d\r\n\r\n",event.Event_Number);
for (int i = event.Event_Number; i < Timing_events_Number_MAX; i++) {
CHx_State[i].Event_Number = CHx_State[i].Event_Number -1;
CHx_State[i-1] = CHx_State[i];
}
CHx_State[Timing_events_Number_MAX - 1] = CHx_State_Default;
memset(Event_str[Timing_events_Number_MAX - 1], 0, sizeof(Event_str[Timing_events_Number_MAX - 1]));
Timing_events_Num --;
}
void TimerEvent_Del_Number(uint8_t Event_Number){
TimerEvent_Del(CHx_State[Event_Number - 1]);
Buzzer_Open_Time(700, 300);
}

45
lib/ETH/WS_RTC.h Normal file
View File

@@ -0,0 +1,45 @@
#pragma once
#include "WS_PCF85063.h"
#include "WS_Relay.h"
#include "WS_GPIO.h"
#define Timing_events_Number_MAX 10 // Indicates the number of timers that can be set
typedef enum {
Repetition_NONE = 0, // aperiodicity
Repetition_everyday = 1, // The event is repeated at this time every day
Repetition_Weekly = 2, // This event is repeated every week at this time
Repetition_monthly = 3, // This event is repeated every month at this time
} Repetition_event;
typedef struct {
bool Enable_Flag = false; // The timer event enabled flag.
uint8_t Event_Number = 0; // Current event sequence number
Status_adjustment Relay_CH1 = STATE_Retain; // The CH1 status is changed periodically
Status_adjustment Relay_CH2 = STATE_Retain; // The CH2 status is changed periodically
Status_adjustment Relay_CH3 = STATE_Retain; // The CH3 status is changed periodically
Status_adjustment Relay_CH4 = STATE_Retain; // The CH4 status is changed periodically
Status_adjustment Relay_CH5 = STATE_Retain; // The CH5 status is changed periodically
Status_adjustment Relay_CH6 = STATE_Retain; // The CH6 status is changed periodically
Status_adjustment Relay_CH7 = STATE_Retain; // The CH7 status is changed periodically
Status_adjustment Relay_CH8 = STATE_Retain; // The CH8 status is changed periodically
datetime_t Time;
Repetition_event repetition_State = Repetition_NONE; // Periodic execution
}Timing_RTC;
extern uint8_t Timing_events_Num;
extern Timing_RTC CHx_State[Timing_events_Number_MAX];
extern char Event_str[Timing_events_Number_MAX][1000];
void RTCTask(void *parameter);
void TimerEvent_handling(Timing_RTC event);
void TimerEvent_printf(Timing_RTC event);
void TimerEvent_Del(Timing_RTC event);
void RTC_Init(void);
void TimerEvent_CHx_Set(datetime_t time,uint8_t CHx, bool State, Repetition_event Repetition);
void TimerEvent_CHxs_Set(datetime_t time,uint8_t PinState, Repetition_event Repetition);
void TimerEvent_CHxn_Set(datetime_t time,Status_adjustment *Relay_n, Repetition_event Repetition);
void TimerEvent_printf_ALL(void);
void TimerEvent_Del_Number(uint8_t Event_Number);