1394 lines
39 KiB
C++
1394 lines
39 KiB
C++
#define F_NUM "2506250001"
|
|
|
|
/*********************************************
|
|
IOTGW-OTA by qst
|
|
|
|
+ 20250625-버전관리_ 2506250001
|
|
|
|
+ 지온 센서 값 추가
|
|
|
|
+ PinChangeInterrupt.h 추가 (펄스 인터럽트 계산용)
|
|
- 기본 인터럽트 함수는 사용할수있는 인터럽트 핀이 맞지않아 사용불가
|
|
- ModbusRTUMaster.h 라이브러리와 충돌이 생겨서 해당 라이브러리안에 있는 SoftwareSerial 라이브러리 사용을 다 제거하고 사용함
|
|
- 펄스값 저장 필요, 노이즈로인한 보드 리셋 대비 - 펄스값이 인입될경우 SD카드에 저장
|
|
|
|
+ 20250521 - 버그수정
|
|
|
|
+ github test
|
|
|
|
+ V15_2505160001
|
|
- Ethernet.linkStatus 상태체크 추가
|
|
- 와치독 4초확인으로 셋팅 - 20250516
|
|
- <avr/wdt.h> - 20250428 와치독 추가
|
|
|
|
+ V14_2412170001
|
|
- mqtt sub (debugging)
|
|
- th sensor (debugging)
|
|
|
|
+ V13_2403132007
|
|
- farm sensor board
|
|
|
|
+ V13_2403122005
|
|
* farm only *** +
|
|
- ini file
|
|
|
|
- D8 ~ D15
|
|
- D_IN0/D_OUT0 emergency
|
|
|
|
- ph & nt sensor scan
|
|
- cd sensor (4-20mA)
|
|
|
|
+ V13_2403122004
|
|
- modbusRTUmaster z_filter (0,rx,0)
|
|
|
|
+ V13_2403122003
|
|
- NET_VEN control (bd_v2)
|
|
- true json topic
|
|
- D_OUT control speed doubled
|
|
|
|
+ V12_3c_2402260000
|
|
- mqtt reconnection
|
|
|
|
+ V12_3c
|
|
- OTA by LAN
|
|
- th sensor scan debugged (0,rx,0)
|
|
- simple task switch
|
|
- gw_server(?) removed
|
|
|
|
+ V10_3 (original)
|
|
*********************************************/
|
|
|
|
#include <avr/wdt.h> // 20250428 추가
|
|
#include <PinChangeInterrupt.h> // 20250528 추가
|
|
|
|
#include <MsTimer2.h>
|
|
|
|
#include <SD.h>
|
|
#include <IniFile.h>
|
|
|
|
#include <Ethernet.h>
|
|
#include <ArduinoOTA.h>
|
|
#include <PubSubClient.h>
|
|
|
|
#include "iotgw_cfg.h"
|
|
#include "iotgw_pin_v2.h"
|
|
|
|
#include "ModbusRTUMaster.h"
|
|
|
|
ModbusRTUMaster modbus_2(RS485_2, RS485_DE2);
|
|
ModbusRTUMaster modbus_3(RS485_3, RS485_DE3);
|
|
|
|
/*******************************************************/
|
|
/* setup variable */
|
|
/*******************************************************/
|
|
IPAddress subnet(255, 255, 255, 0);
|
|
IPAddress myDns (168, 126, 63, 1);
|
|
|
|
static int mqttPort = 1883;
|
|
|
|
const char* ota_user = "arduino"; // can not be changed by its bug
|
|
const char* ota_pass = "passpass";
|
|
|
|
/*******************************************************/
|
|
/* task table & general variable */
|
|
/*******************************************************/
|
|
void task_farm_emg();
|
|
void task_RS485_2_tx();
|
|
void task_RS485_2_rx();
|
|
|
|
void task_mqtt_dn();
|
|
void task_mqtt_up();
|
|
void task_http();
|
|
void task_io();
|
|
void task_ota();
|
|
void task_th_tx();
|
|
void task_th_rx();
|
|
|
|
void (*func_task[10])() = {
|
|
task_th_tx,
|
|
task_io,
|
|
task_mqtt_up,
|
|
task_th_rx,
|
|
0,//task_mqtt_dn,
|
|
|
|
task_RS485_2_tx,
|
|
task_http,
|
|
task_ota, // task_farm_emg
|
|
task_RS485_2_rx,
|
|
0,//task_mqtt_dn,
|
|
};
|
|
|
|
EthernetServer http_server(80);
|
|
|
|
int8_t task_count = 0;
|
|
|
|
bool timer1_fire = false;
|
|
|
|
bool Ethernet_reinitial = false;
|
|
|
|
uint8_t timeout_cnt = 0;
|
|
|
|
// --- 전역 변수 ---
|
|
const char* countFilename = "status.ini";
|
|
|
|
char rcvScheduleSeq[7];
|
|
char rcvtotalInIntervals[7];
|
|
|
|
volatile unsigned long pulseCount = 0; // 펄스 카운트 (ISR에서 사용되므로 volatile)
|
|
volatile unsigned long last_interrupt_time = 0; // 마지막으로 유효한 펄스가 들어온 시간
|
|
const unsigned long debounce_delay = 50; // 바운싱을 무시할 시간 (50ms)
|
|
|
|
unsigned long totalInIntervals = 0; // 총 펄스 카운트
|
|
unsigned long lastCalcTime = 0; // 마지막 카운트 계산 시간
|
|
const unsigned long CALC_INTERVAL = 1000; // 카운트 계산 주기 (밀리초)
|
|
unsigned long lastSavedPulseCount = 0; // 마지막으로 저장했던 카운트 값
|
|
|
|
void countPulse() { //테스트로 스위치를 연결했을경우 발생하는 바운싱 문제 해결용.
|
|
unsigned long interrupt_time = millis(); // 현재 시간을 측정
|
|
|
|
// 마지막 유효 펄스로부터 debounce_delay(50ms)보다 긴 시간이 지났는지 확인
|
|
if (interrupt_time - last_interrupt_time > debounce_delay) {
|
|
// 시간이 충분히 지났다면, 새로운 유효 펄스로 간주하고 카운트
|
|
pulseCount++;
|
|
// 현재 시간을 마지막 유효 펄스 시간으로 기록
|
|
last_interrupt_time = interrupt_time;
|
|
}
|
|
// 만약 50ms 이내에 또 인터럽트가 발생하면, 이 if문은 무시됩니다. (바운싱 무시)
|
|
}
|
|
|
|
/*
|
|
void countPulse() {
|
|
pulseCount++;
|
|
}
|
|
*/
|
|
|
|
void loadPulseCount();
|
|
void savePulseTotal(unsigned long total);
|
|
|
|
/*******************************************************/
|
|
/* setup & loop */
|
|
/*******************************************************/
|
|
void setup()
|
|
{
|
|
// 20250428 추가 / 20250516 와치독 제거 - 와치독 실행시 OTA 업데이트 안되는 증상 발현
|
|
byte mcusr_mirror = MCUSR; // 리셋 원인 저장
|
|
MCUSR = 0; // 레지스터 초기화
|
|
wdt_disable(); // 부트할 때 와치독 끄기
|
|
|
|
pinMode(nLED_USER, OUTPUT);
|
|
|
|
#ifdef bd_v2
|
|
pinMode(NET_VEN, OUTPUT);
|
|
digitalWrite(NET_VEN, HIGH);
|
|
|
|
pinMode(SD_SCSn, OUTPUT);
|
|
digitalWrite(SD_SCSn, HIGH);
|
|
#endif
|
|
|
|
pinMode(NET_RSTn, OUTPUT);
|
|
digitalWrite(NET_RSTn, HIGH);
|
|
|
|
pinMode(D_IN0, INPUT_PULLUP);
|
|
pinMode(D_IN1, INPUT_PULLUP);
|
|
pinMode(D_IN2, INPUT_PULLUP);
|
|
pinMode(D_IN3, INPUT_PULLUP);
|
|
pinMode(D_IN4, INPUT_PULLUP);
|
|
pinMode(D_IN5, INPUT_PULLUP);
|
|
pinMode(D_IN6, INPUT_PULLUP);
|
|
pinMode(D_IN7, INPUT_PULLUP);
|
|
pinMode(D_IN8, INPUT_PULLUP);
|
|
pinMode(D_IN9, INPUT_PULLUP);
|
|
pinMode(D_IN10, INPUT_PULLUP);
|
|
pinMode(D_IN11, INPUT_PULLUP);
|
|
pinMode(D_IN12, INPUT_PULLUP);
|
|
pinMode(D_IN13, INPUT_PULLUP);
|
|
pinMode(D_IN14, INPUT_PULLUP);
|
|
pinMode(D_IN15, INPUT_PULLUP);
|
|
|
|
pinMode(D_OUT0, OUTPUT);
|
|
pinMode(D_OUT1, OUTPUT);
|
|
pinMode(D_OUT2, OUTPUT);
|
|
pinMode(D_OUT3, OUTPUT);
|
|
pinMode(D_OUT4, OUTPUT);
|
|
pinMode(D_OUT5, OUTPUT);
|
|
pinMode(D_OUT6, OUTPUT);
|
|
pinMode(D_OUT7, OUTPUT);
|
|
|
|
#ifdef bd_v2
|
|
pinMode(D_OUT8, OUTPUT);
|
|
pinMode(D_OUT9, OUTPUT);
|
|
pinMode(D_OUT10, OUTPUT);
|
|
pinMode(D_OUT11, OUTPUT);
|
|
pinMode(D_OUT12, OUTPUT);
|
|
pinMode(D_OUT13, OUTPUT);
|
|
pinMode(D_OUT14, OUTPUT);
|
|
pinMode(D_OUT15, OUTPUT);
|
|
#endif
|
|
|
|
pinMode(RS485_DE2, OUTPUT);
|
|
pinMode(RS485_DE3, OUTPUT);
|
|
|
|
pinMode(PIN_RX0, INPUT_PULLUP);
|
|
pinMode(PIN_RX1, INPUT_PULLUP);
|
|
pinMode(PIN_RX2, INPUT_PULLUP);
|
|
pinMode(PIN_RX3, INPUT_PULLUP);
|
|
|
|
#ifdef dbg_serial
|
|
dbg_serial.begin(115200);
|
|
#endif
|
|
|
|
Serial1.begin(9600);
|
|
|
|
modbus_2.begin(9600);
|
|
modbus_3.begin(9600);
|
|
|
|
#ifdef bd_v2
|
|
pinMode(SD_DETn, INPUT_PULLUP);
|
|
if (digitalRead(SD_DETn)) {
|
|
dbg_println("sd: none");
|
|
}
|
|
else {
|
|
dbg_println("sd: detected");
|
|
}
|
|
|
|
ini_setup();
|
|
#endif
|
|
|
|
net_setup();
|
|
|
|
MsTimer2::set(100, timer1);
|
|
MsTimer2::start(); // simple task switch
|
|
|
|
// 리셋 원인 판별 20250428 추가
|
|
if (mcusr_mirror & (1 << PORF)) {
|
|
if (Serial1) {Serial1.println("mainlog_ Power-On Reset");}
|
|
}
|
|
else if (mcusr_mirror & (1 << EXTRF)) {
|
|
if (Serial1) {Serial1.println("mainlog_ External Reset Pin");}
|
|
}
|
|
else if (mcusr_mirror & (1 << BORF)) {
|
|
if (Serial1) {Serial1.println("mainlog_ Brown-Out Reset");}
|
|
}
|
|
else if (mcusr_mirror & (1 << WDRF)) {
|
|
if (Serial1) {Serial1.println("mainlog_ Watchdog-Reset 4S");}
|
|
}
|
|
else {
|
|
if (Serial1) {Serial1.println("mainlog_ Unknown Reset");}
|
|
}
|
|
|
|
// loadPulseCount(); 실시간 pulse값 전송으로 변경 _ 20250613
|
|
|
|
// EF (Open Collector NPN) 또는 EV (GND 연결) 타입은 펄스 시 LOW가 되므로 FALLING 엣지 감지
|
|
// ---------------------------------------- attachInterrupt(digitalPinToInterrupt(FLOW_SENSOR_PIN), countPulse, FALLING);
|
|
// attachInterrupt(digitalPinToInterrupt(D_IN1), countPulse, FALLING); // 인터럽트핀을 사용 안하고있어서 못씀(2, 3, 18, 19, 20, 21번 핀)
|
|
attachPCINT(digitalPinToPCINT(D_IN1), countPulse, FALLING); // ModbusRTUMaster.h 와 충돌 - SoftwareSerial 라이브러리 제거 후 사용
|
|
|
|
lastCalcTime = millis();
|
|
|
|
wdt_enable(WDTO_4S);
|
|
}
|
|
|
|
#ifdef bd_v2
|
|
|
|
void ini_setup()
|
|
{
|
|
const size_t bufferLen = 80;
|
|
char buffer[bufferLen];
|
|
|
|
const char *filename = "cfg_farm.ini";
|
|
// SPI.begin();
|
|
if (!SD.begin(SD_SCSn)) {
|
|
dbg_println("SD.begin() failed");
|
|
return;
|
|
}
|
|
|
|
IniFile ini(filename);
|
|
if (!ini.open()) {
|
|
dbg_println("ini.open() failed");
|
|
return;
|
|
}
|
|
|
|
if (!ini.validate(buffer, bufferLen)) {
|
|
dbg_print(ini.getFilename());
|
|
dbg_println(" not valid: ");
|
|
return;
|
|
}
|
|
|
|
if (ini.getMACAddress("network", "mac", buffer, bufferLen, mac)) {
|
|
dbg_print("mac=");
|
|
for(uint8_t i=0; i<6; i++) {
|
|
dbg_print_(mac[i], HEX);
|
|
if (i < 5) {
|
|
dbg_print(":");
|
|
}
|
|
}
|
|
dbg_println("");
|
|
}
|
|
|
|
if (ini.getIPAddress("network", "ip", buffer, bufferLen, ip)) {
|
|
dbg_print("ip=");
|
|
dbg_println(ip);
|
|
}
|
|
|
|
if (ini.getIPAddress("network", "gateway", buffer, bufferLen, gateway)) {
|
|
dbg_print("gateway=");
|
|
dbg_println(gateway);
|
|
}
|
|
|
|
// if (ini.getIPAddress("mqtt", "server", buffer, bufferLen, mqttServer)) {
|
|
if (ini.getValue("mqtt", "server", buffer, bufferLen, mqttServer, sizeof(mqttServer))) {
|
|
dbg_print("server=");
|
|
dbg_println(mqttServer);
|
|
}
|
|
|
|
if (ini.getValue("mqtt", "client", buffer, bufferLen, ClientID_NUM, sizeof(ClientID_NUM))) {
|
|
dbg_print("client=");
|
|
dbg_println(ClientID_NUM);
|
|
}
|
|
|
|
if (ini.getValue("topic", "head", buffer, bufferLen, topic_head, sizeof(topic_head))) {
|
|
dbg_print("head=");
|
|
dbg_println(topic_head);
|
|
}
|
|
|
|
if (ini.getValue("topic", "tail", buffer, bufferLen, topic_tail, sizeof(topic_tail))) {
|
|
dbg_print("tail=");
|
|
dbg_println(topic_tail);
|
|
}
|
|
|
|
SDIloggersensorNames[0] = "DEFAULT";
|
|
for(uint8_t i=1; i<=MAX_RS485_2_COUNT; i++) {
|
|
String key = "NO"+String(i);
|
|
if (ini.getValue("RS485-2", key.c_str(), buffer, sizeof(buffer))) {
|
|
SDIloggersensorNames[i] = String(buffer);
|
|
} else {
|
|
SDIloggersensorNames[i] = "";
|
|
}
|
|
}
|
|
|
|
ini.close();
|
|
}
|
|
|
|
#endif
|
|
|
|
void net_setup()
|
|
{
|
|
Ethernet_reinitial = true;
|
|
|
|
digitalWrite(NET_RSTn, LOW);
|
|
delay(50); // enough
|
|
digitalWrite(NET_RSTn, HIGH);
|
|
delay(100); // enough
|
|
|
|
Ethernet.init(NET_SCSn);
|
|
Ethernet.begin(mac, ip, myDns, gateway, subnet);
|
|
|
|
do {
|
|
delay(100); // blink fast if something wrong
|
|
digital_toggle(nLED_USER);
|
|
} while (Ethernet.hardwareStatus() == EthernetNoHardware);
|
|
|
|
http_server.begin();
|
|
SetMQTTInfo();
|
|
|
|
// OTA 시작 시 콜백: WDT 비활성화
|
|
ArduinoOTA.onStart([]() {
|
|
if (Serial1) {Serial1.println("mainlog_ OTA Start - Disabling WDT");}
|
|
wdt_disable(); // OTA 중에는 WDT 끔
|
|
});
|
|
|
|
ArduinoOTA.begin(Ethernet.localIP(), &ota_pass[0], &ota_pass[0], InternalStorage);
|
|
}
|
|
|
|
void timer1() { timer1_fire = true; }
|
|
|
|
void task_ota()
|
|
{
|
|
ArduinoOTA.poll();
|
|
task_farm_emg();
|
|
}
|
|
|
|
// total 값을 INI 파일에 저장
|
|
void savePulseTotal(unsigned long total) {
|
|
|
|
SD.remove(countFilename); // 아래 코드에서 기존 내역을 지우고 새로운 내용을 저장해야 되는데 추가가 되고있어서 지우는 로직 추가
|
|
|
|
// 파일을 쓰기 모드로 열면 기존 내용은 자동으로 삭제됩니다.
|
|
File configFile = SD.open(countFilename, FILE_WRITE);
|
|
|
|
if (configFile) {
|
|
// "TotalCount=값" 형식으로 파일에 데이터를 씁니다.
|
|
configFile.print("TotalCount");
|
|
configFile.print("=");
|
|
configFile.println(total); // println은 줄바꿈 문자를 포함합니다.
|
|
|
|
configFile.print("rcvScheduleSeq");
|
|
configFile.print("=");
|
|
configFile.println(rcvScheduleSeq); // println은 줄바꿈 문자를 포함합니다.
|
|
|
|
configFile.close(); // 파일 쓰기가 끝나면 반드시 닫아주어야 합니다.
|
|
|
|
if (Serial1) { // 시리얼 모니터에 결과 출력
|
|
Serial1.print("mainlog_ savePulseTotal_TotalCount: ");
|
|
Serial1.print(total);
|
|
Serial1.println(" ");
|
|
}
|
|
|
|
// 시리얼 모니터로 저장된 값 확인
|
|
//dbg_print("Pulse count saved: ");
|
|
//dbg_println(total);
|
|
} else {
|
|
//dbg_println("Error opening config file for writing.");
|
|
}
|
|
}
|
|
|
|
void loadPulseCount() {
|
|
File configFile = SD.open(countFilename, FILE_READ);
|
|
if (configFile) {
|
|
// 파일 내용이 "TotalCount=12345" 형식이라고 가정
|
|
if (configFile.find("TotalCount") && configFile.find("=")) {
|
|
// find 함수로 키워드를 찾은 후, parseInt로 숫자만 읽어옴
|
|
totalInIntervals = configFile.parseInt();
|
|
lastSavedPulseCount = totalInIntervals; // 저장한 값을 기록
|
|
|
|
if (Serial1) { // 시리얼 모니터에 결과 출력
|
|
Serial1.print("mainlog_ loadPulseCount_totalInIntervals: ");
|
|
Serial1.print(totalInIntervals);
|
|
Serial1.println(" ");
|
|
}
|
|
|
|
}
|
|
|
|
// "rcvScheduleSeq=값" 형식으로 파일 내용 읽기
|
|
if (configFile.find("rcvScheduleSeq") && configFile.find("=")) {
|
|
// '=' 다음부터 줄바꿈 문자('\n') 전까지 문자열을 읽어옵니다.
|
|
// rcvScheduleSeq 배열의 크기는 6이므로, 최대 5개의 문자와 1개의 NULL 문자를 저장할 수 있습니다.
|
|
int bytesRead = configFile.readBytesUntil('\n', rcvScheduleSeq, sizeof(rcvScheduleSeq) - 1);
|
|
rcvScheduleSeq[bytesRead] = '\0'; // 읽어온 문자열 끝에 NULL 문자를 추가하여 C-string으로 만듭니다.
|
|
|
|
// readBytesUntil은 개행 문자를 소비하지만, println으로 저장 시 \r\n이 들어갔다면 \r이 남아있을 수 있습니다.
|
|
// 필요하다면 문자열 끝의 \r 제거 로직 추가:
|
|
if (bytesRead > 0 && rcvScheduleSeq[bytesRead-1] == '\r') {
|
|
rcvScheduleSeq[bytesRead-1] = '\0';
|
|
}
|
|
if (Serial1) {
|
|
Serial1.print("mainlog_ loadPulseCount_rcvScheduleSeq: ");
|
|
Serial1.print(rcvScheduleSeq);
|
|
Serial1.println(" ");
|
|
}
|
|
}
|
|
|
|
configFile.close();
|
|
//dbg_print("Loaded value from SD card: ");
|
|
//dbg_println(totalInIntervals);
|
|
} else {
|
|
// 파일이 없는 경우, 처음 시작하는 것으로 간주
|
|
//dbg_println("Config file not found. Starting count from 0.");
|
|
}
|
|
}
|
|
|
|
void loop()
|
|
{
|
|
|
|
wdt_reset();
|
|
|
|
unsigned long currentTime = millis();
|
|
|
|
if (currentTime - lastCalcTime >= CALC_INTERVAL) {
|
|
unsigned long currentPulseCountSnapshot;
|
|
|
|
noInterrupts(); // 인터럽트 비활성화
|
|
currentPulseCountSnapshot = pulseCount;
|
|
pulseCount = 0; // 다음 계산을 위해 펄스 카운트 리셋
|
|
interrupts(); // 인터럽트 다시 활성화
|
|
|
|
totalInIntervals += currentPulseCountSnapshot; // 총 출수량 업데이트
|
|
|
|
/* 실시간 pulse값 전송으로 변경 _ 20250613
|
|
if (currentPulseCountSnapshot > 0) {
|
|
if (lastSavedPulseCount != totalInIntervals) { // 마지막으로 저장했던 값과 현재 값이 다를 경우에만 파일에 저장
|
|
savePulseTotal(totalInIntervals);
|
|
lastSavedPulseCount = totalInIntervals; // 저장한 값을 기록
|
|
}
|
|
if (Serial1) { // 시리얼 모니터에 결과 출력
|
|
Serial1.print("currentPulseCountSnapshot: ");
|
|
Serial1.print(currentPulseCountSnapshot);
|
|
Serial1.print(" , ");
|
|
Serial1.print("totalInIntervals : ");
|
|
Serial1.print(totalInIntervals);
|
|
Serial1.println(" ");
|
|
}
|
|
}
|
|
*/
|
|
|
|
lastCalcTime = currentTime;
|
|
}
|
|
|
|
unsigned long now = millis();
|
|
|
|
if (timer1_fire) {
|
|
timer1_fire = false;
|
|
if (func_task[task_count]) func_task[task_count]();
|
|
if (++task_count == 10) task_count = 0;
|
|
}
|
|
|
|
task_mqtt_dn();
|
|
}
|
|
|
|
/*******************************************************/
|
|
/* i/o & http */
|
|
/*******************************************************/
|
|
uint8_t DI[16] = {0,};
|
|
uint8_t DO[16] = {0,};
|
|
uint16_t AI[4] = {0,};
|
|
|
|
bool flag_emergency = false;
|
|
|
|
void task_io()
|
|
{
|
|
DI[0] = !digitalRead(D_IN0);
|
|
|
|
if (DI[0]) {
|
|
if (!flag_emergency) {
|
|
PORTA = 0x00; // D_OUT15 ~ 0
|
|
PORTC = 0x01; // D_OUT7 ~ 0
|
|
|
|
flag_emergency = true;
|
|
}
|
|
}
|
|
else {
|
|
if (flag_emergency) {
|
|
digitalWrite(D_OUT0, LOW);
|
|
|
|
flag_emergency = false;
|
|
}
|
|
}
|
|
|
|
DI[1] = !digitalRead(D_IN1);
|
|
DI[2] = !digitalRead(D_IN2);
|
|
DI[3] = !digitalRead(D_IN3);
|
|
DI[4] = !digitalRead(D_IN4);
|
|
DI[5] = !digitalRead(D_IN5);
|
|
DI[6] = !digitalRead(D_IN6);
|
|
DI[7] = !digitalRead(D_IN7);
|
|
DI[8] = !digitalRead(D_IN8);
|
|
DI[9] = !digitalRead(D_IN9);
|
|
DI[10] = !digitalRead(D_IN10);
|
|
DI[11] = !digitalRead(D_IN11);
|
|
DI[12] = !digitalRead(D_IN12);
|
|
DI[13] = !digitalRead(D_IN13);
|
|
DI[14] = !digitalRead(D_IN14);
|
|
DI[15] = !digitalRead(D_IN15);
|
|
|
|
DO[0] = digitalRead(D_OUT0);
|
|
DO[1] = digitalRead(D_OUT1);
|
|
DO[2] = digitalRead(D_OUT2);
|
|
DO[3] = digitalRead(D_OUT3);
|
|
DO[4] = digitalRead(D_OUT4);
|
|
DO[5] = digitalRead(D_OUT5);
|
|
DO[6] = digitalRead(D_OUT6);
|
|
DO[7] = digitalRead(D_OUT7);
|
|
|
|
#ifdef bd_v2
|
|
DO[8] = digitalRead(D_OUT8);
|
|
DO[9] = digitalRead(D_OUT9);
|
|
DO[10] = digitalRead(D_OUT10);
|
|
DO[11] = digitalRead(D_OUT11);
|
|
DO[12] = digitalRead(D_OUT12);
|
|
DO[13] = digitalRead(D_OUT13);
|
|
DO[14] = digitalRead(D_OUT14);
|
|
DO[15] = digitalRead(D_OUT15);
|
|
#endif
|
|
|
|
AI[0] = analogRead(A_IN0);
|
|
AI[1] = analogRead(A_IN1);
|
|
AI[2] = analogRead(A_IN2);
|
|
AI[3] = analogRead(A_IN3);
|
|
}
|
|
|
|
void task_http()
|
|
{
|
|
char s0[17];
|
|
char tmpS[100];
|
|
|
|
EthernetClient client = http_server.available();
|
|
if (client) {
|
|
// an http request ends with a blank line
|
|
boolean currentLineIsBlank = true;
|
|
while (client.connected()) {
|
|
if (client.available()) {
|
|
char c = client.read();
|
|
|
|
// if you've gotten to the end of the line (received a newline
|
|
// character) and the line is blank, the http request has ended,
|
|
// so you can send a reply
|
|
if (c == '\n' && currentLineIsBlank) {
|
|
// send a standard http response header
|
|
client.println("HTTP/1.1 200 OK");
|
|
client.println("Content-Type: text/html");
|
|
client.println("Connection: close"); // the connection will be closed after completion of the response
|
|
client.println("Refresh: 5"); // refresh the page automatically every 5 sec
|
|
client.println();
|
|
client.println("<!DOCTYPE HTML>");
|
|
client.println("<html>");
|
|
|
|
client.print("FWV=");
|
|
client.print(F_NUM);
|
|
client.println("<br />");
|
|
|
|
client.print("MAC=");
|
|
for(uint8_t i=0; i<6; i++) {
|
|
client.print(mac[i], HEX);
|
|
if (i < 5) client.print('-');
|
|
}
|
|
client.println("<br />");
|
|
|
|
client.print("MID=");
|
|
client.print(ClientID_NUM);
|
|
client.println("<br />");
|
|
|
|
uint8_t val1 = (DI[0]<<3)+(DI[1]<<2)+(DI[2]<<1)+DI[3];
|
|
uint8_t val2 = (DI[4]<<3)+(DI[5]<<2)+(DI[6]<<1)+DI[7];
|
|
uint8_t val3 = (DI[8]<<3)+(DI[9]<<2)+(DI[10]<<1)+DI[11];
|
|
uint8_t val4 = (DI[12]<<3)+(DI[13]<<2)+(DI[14]<<1)+DI[15];
|
|
client.print("D/I=");
|
|
client.print(val1, HEX);
|
|
client.print(val2, HEX);
|
|
client.print(val3, HEX);
|
|
client.print(val4, HEX);
|
|
client.println("<br />");
|
|
|
|
val1 = (DO[0]<<3)+(DO[1]<<2)+(DO[2]<<1)+DO[3];
|
|
val2 = (DO[4]<<3)+(DO[5]<<2)+(DO[6]<<1)+DO[7];
|
|
client.print("D/O=");
|
|
client.print(val1, HEX);
|
|
client.print(val2, HEX);
|
|
#ifdef bd_v2
|
|
val3 = (DO[8]<<3)+(DO[9]<<2)+(DO[10]<<1)+DO[11];
|
|
val4 = (DO[12]<<3)+(DO[13]<<2)+(DO[14]<<1)+DO[15];
|
|
client.print(val3, HEX);
|
|
client.print(val4, HEX);
|
|
#endif
|
|
client.println("<br />");
|
|
|
|
client.print("232=00"); // unused
|
|
client.println("<br />");
|
|
|
|
uint8_t state_ph = 0;
|
|
for(uint8_t i=1; i<=MAX_RS485_2_COUNT; i++) {
|
|
if (RS485_2_dog[i]) {
|
|
state_ph = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for(uint8_t i=1; i<=MAX_RS485_2_COUNT; i++) {
|
|
client.print("RS485-2_");
|
|
client.print(i);
|
|
client.print(" = ");
|
|
client.print(SDIloggersensorNames[i]);
|
|
client.println("<br />");
|
|
}
|
|
|
|
uint8_t state_th = 0;
|
|
for(uint8_t i=1; i<=MAX_TH_COUNT; i++) {
|
|
if (th_dog[i]) {
|
|
state_th = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
client.print("485=");
|
|
client.print(state_ph, HEX);
|
|
client.print(state_th, HEX);
|
|
client.println("<br />");
|
|
|
|
client.println("</html>");
|
|
break;
|
|
}
|
|
if (c == '\n') {
|
|
// you're starting a new line
|
|
currentLineIsBlank = true;
|
|
} else if (c != '\r') {
|
|
// you've gotten a character on the current line
|
|
currentLineIsBlank = false;
|
|
}
|
|
}
|
|
}
|
|
// give the web browser time to receive the data
|
|
delay(1);
|
|
// close the connection:
|
|
client.stop();
|
|
}
|
|
}
|
|
|
|
/*******************************************************/
|
|
/* th sensor */
|
|
/*******************************************************/
|
|
#define MAX_TEMP_CNT 10
|
|
uint8_t th_addr = 0;
|
|
|
|
uint16_t sHumid[11] = {0,};
|
|
int16_t sTemperature[11] = {0,};
|
|
|
|
void task_th_tx()
|
|
{
|
|
if (++th_addr > MAX_TEMP_CNT) th_addr = 1;
|
|
modbus_3.begin_readHoldingRegisters(th_addr, 0, 2);
|
|
}
|
|
|
|
void task_th_rx()
|
|
{
|
|
uint16_t th_val[2];
|
|
|
|
uint8_t ret = modbus_3.readHoldingRegisters_end(th_addr, th_val, 2);
|
|
if (ret) {
|
|
sHumid[th_addr] = th_val[0];
|
|
sTemperature[th_addr] = th_val[1];
|
|
|
|
th_dog[th_addr] = 10; // 10 * 5 sec
|
|
}
|
|
else {
|
|
if (th_dog[th_addr]) {
|
|
if (--th_dog[th_addr] == 0) { // saturated
|
|
sHumid[th_addr] = 0;
|
|
sTemperature[th_addr] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
uint8_t ph_addr = 0;
|
|
|
|
uint16_t sPH[6] = {0,}; // PH - QSENTECH
|
|
uint16_t sNT[6] = {0,}; // EC - QSENTECH
|
|
uint16_t sCD[6] = {0,}; // CO2 - QSENTECH
|
|
uint16_t sGT[6] = {0,}; // 지온 - TEROS12
|
|
uint16_t sGM[6] = {0,}; // 지습 - TEROS12
|
|
uint16_t sGNT[6] = {0,};// EC - TEROS12
|
|
uint16_t sWP[6] = {0,}; // WP - 수분장력 - TEROS21
|
|
uint16_t sGT2[6] = {0,}; // 지온 - TEROS21
|
|
|
|
void task_farm_emg()
|
|
{
|
|
if (flag_emergency) {
|
|
digital_toggle(D_OUT0);
|
|
}
|
|
}
|
|
|
|
void task_RS485_2_tx()
|
|
{
|
|
if (++ph_addr > MAX_RS485_2_COUNT) ph_addr = 1;
|
|
|
|
if (ph_addr == 1) {
|
|
RS485_2_TEROS12_Count = 0;
|
|
RS485_2_TEROS21_Count = 0;
|
|
RS485_2_QSENTECH_Count = 0;
|
|
}
|
|
|
|
if (SDIloggersensorNames[ph_addr] == "TEROS12") {
|
|
RS485_2_TEROS12_Count++;
|
|
modbus_2.begin_readHoldingRegisters(ph_addr, 0, 3); // 지온,지습,EC
|
|
} else
|
|
if (SDIloggersensorNames[ph_addr] == "TEROS21") {
|
|
RS485_2_TEROS21_Count++;
|
|
modbus_2.begin_readHoldingRegisters(ph_addr, 0, 2); // 수분장력,지온
|
|
} else
|
|
if (SDIloggersensorNames[ph_addr] == "QSENTECH") {
|
|
RS485_2_QSENTECH_Count++;
|
|
modbus_2.begin_readHoldingRegisters(ph_addr, 0, 3); // ph, ec & co2
|
|
} else { // 기본값 QSENTECH
|
|
RS485_2_QSENTECH_Count++;
|
|
modbus_2.begin_readHoldingRegisters(ph_addr, 0, 3); // ph, ec & co2
|
|
}
|
|
}
|
|
|
|
void task_RS485_2_rx()
|
|
{
|
|
uint16_t RS485_2_val[3];
|
|
|
|
if (SDIloggersensorNames[ph_addr] == "TEROS12") {
|
|
uint8_t ret = modbus_2.readHoldingRegisters_end(ph_addr, RS485_2_val, 3);
|
|
if (ret) {
|
|
sGT[RS485_2_TEROS12_Count] = RS485_2_val[0] / 10;
|
|
sGM[RS485_2_TEROS12_Count] = RS485_2_val[1] / 10;
|
|
sGNT[RS485_2_TEROS12_Count] = RS485_2_val[2];
|
|
RS485_2_dog[ph_addr] = 10; // 10 * 5 sec
|
|
}
|
|
else {
|
|
if (RS485_2_dog[ph_addr]) {
|
|
if (--RS485_2_dog[ph_addr] == 0) { // saturated
|
|
sGT[RS485_2_TEROS12_Count] = 0;
|
|
sGM[RS485_2_TEROS12_Count] = 0;
|
|
sGNT[RS485_2_TEROS12_Count] = 0;
|
|
}
|
|
}
|
|
}
|
|
} else
|
|
if (SDIloggersensorNames[ph_addr] == "TEROS21") {
|
|
uint8_t ret = modbus_2.readHoldingRegisters_end(ph_addr, RS485_2_val, 2);
|
|
if (ret) {
|
|
sWP[RS485_2_TEROS21_Count] = RS485_2_val[0] / 100;
|
|
sGT2[RS485_2_TEROS21_Count] = RS485_2_val[1] ;
|
|
RS485_2_dog[ph_addr] = 10; // 10 * 5 sec
|
|
}
|
|
else {
|
|
if (RS485_2_dog[ph_addr]) {
|
|
if (--RS485_2_dog[ph_addr] == 0) { // saturated
|
|
sWP[RS485_2_TEROS21_Count] = 0;
|
|
sGT2[RS485_2_TEROS21_Count] = 0;
|
|
}
|
|
}
|
|
}
|
|
} else
|
|
if (SDIloggersensorNames[ph_addr] == "QSENTECH") {
|
|
uint8_t ret = modbus_2.readHoldingRegisters_end(ph_addr, RS485_2_val, 3);
|
|
if (ret) {
|
|
sPH[RS485_2_QSENTECH_Count] = RS485_2_val[0];
|
|
sNT[RS485_2_QSENTECH_Count] = RS485_2_val[1];
|
|
sCD[RS485_2_QSENTECH_Count] = RS485_2_val[2];
|
|
RS485_2_dog[ph_addr] = 10; // 10 * 5 sec
|
|
}
|
|
else {
|
|
if (RS485_2_dog[ph_addr]) {
|
|
if (--RS485_2_dog[ph_addr] == 0) { // saturated
|
|
sPH[RS485_2_QSENTECH_Count] = 0;
|
|
sNT[RS485_2_QSENTECH_Count] = 0;
|
|
sCD[RS485_2_QSENTECH_Count] = 0;
|
|
}
|
|
}
|
|
}
|
|
} else { // 기본값 QSENTECH
|
|
uint8_t ret = modbus_2.readHoldingRegisters_end(ph_addr, RS485_2_val, 3);
|
|
if (ret) {
|
|
sPH[RS485_2_QSENTECH_Count] = RS485_2_val[0];
|
|
sNT[RS485_2_QSENTECH_Count] = RS485_2_val[1];
|
|
sCD[RS485_2_QSENTECH_Count] = RS485_2_val[2];
|
|
RS485_2_dog[ph_addr] = 10; // 10 * 5 sec
|
|
}
|
|
else {
|
|
if (RS485_2_dog[ph_addr]) {
|
|
if (--RS485_2_dog[ph_addr] == 0) { // saturated
|
|
sPH[RS485_2_QSENTECH_Count] = 0;
|
|
sNT[RS485_2_QSENTECH_Count] = 0;
|
|
sCD[RS485_2_QSENTECH_Count] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*******************************************************/
|
|
/* mqtt up/dn */
|
|
/*******************************************************/
|
|
EthernetClient ethClient;
|
|
PubSubClient mqttClient(mqttServer, mqttPort, callback_, ethClient);
|
|
|
|
void task_mqtt_dn()
|
|
{
|
|
{
|
|
mqttClient.loop();
|
|
}
|
|
}
|
|
|
|
char UP_TOPICNAME[128];
|
|
char DN_TOPICNAME[128];
|
|
|
|
unsigned long lastReconnectAttempt = 0;
|
|
|
|
void task_mqtt_up()
|
|
{
|
|
char s0[32];
|
|
char tmpS[100];
|
|
char sndbuf[100];
|
|
char sndPacket[512];
|
|
|
|
sndPacket[0] = 0;
|
|
|
|
// Digital Input
|
|
sndbuf[0] = 0;
|
|
tmpS[0] = 0;
|
|
for(uint8_t i=0; i<16; i++) {
|
|
s0[0] = 0;
|
|
if (i == 1) {
|
|
sprintf(s0, "%d|", totalInIntervals);
|
|
}
|
|
else {
|
|
sprintf(s0, "%d|", DI[i]);
|
|
}
|
|
strcat(tmpS, s0);
|
|
}
|
|
tmpS[strlen(tmpS)-1] = 0;
|
|
sprintf(sndbuf, "{\x22\x44I\x22:\x22%s\x22,", tmpS); // "D
|
|
strcat(sndPacket, sndbuf);
|
|
|
|
// Digital Output
|
|
sndbuf[0] = 0;
|
|
tmpS[0] = 0;
|
|
#ifdef bd_v2
|
|
for(uint8_t i=0; i<16; i++) {
|
|
#else
|
|
for(uint8_t i=0; i<8; i++) {
|
|
#endif
|
|
s0[0] = 0;
|
|
sprintf(s0, "%d|", DO[i]);
|
|
strcat(tmpS, s0);
|
|
}
|
|
tmpS[strlen(tmpS)-1] = 0;
|
|
sprintf(sndbuf, "\x22\x44O\x22:\x22%s\x22,", tmpS); // "D
|
|
strcat(sndPacket, sndbuf);
|
|
|
|
// Analog Input
|
|
sndbuf[0] = 0;
|
|
tmpS[0] = 0;
|
|
for(uint8_t i=0; i<4; i++) {
|
|
s0[0] = 0;
|
|
sprintf(s0, "%d|", AI[i]);
|
|
strcat(tmpS, s0);
|
|
}
|
|
tmpS[strlen(tmpS)-1] = 0;
|
|
sprintf(sndbuf, "\x22\x41I\x22:\x22%s\x22,", tmpS); // "A
|
|
strcat(sndPacket, sndbuf);
|
|
|
|
// H Input
|
|
sndbuf[0] = 0;
|
|
tmpS[0] = 0;
|
|
for(uint8_t i=1; i<=MAX_TH_COUNT; i++) {
|
|
s0[0] = 0;
|
|
sprintf(s0, "%d|", sHumid[i]);
|
|
strcat(tmpS, s0);
|
|
}
|
|
tmpS[strlen(tmpS)-1] = 0;
|
|
sprintf(sndbuf, "\x22HM\x22:\x22%s\x22,", tmpS);
|
|
strcat(sndPacket, sndbuf);
|
|
|
|
// T Input
|
|
sndbuf[0] = 0;
|
|
tmpS[0] = 0;
|
|
for(uint8_t i=1; i<=MAX_TH_COUNT; i++) {
|
|
s0[0] = 0;
|
|
sprintf(s0, "%d|", sTemperature[i]);
|
|
strcat(tmpS, s0);
|
|
}
|
|
tmpS[strlen(tmpS)-1] = 0;
|
|
sprintf(sndbuf, "\x22TM\x22:\x22%s\x22,", tmpS);
|
|
strcat(sndPacket, sndbuf);
|
|
|
|
sndbuf[0] = 0;
|
|
tmpS[0] = 0;
|
|
for(uint8_t i=1; i<=MAX_RS485_2_COUNT; i++) {
|
|
s0[0] = 0;
|
|
sprintf(s0, "%d|", sCD[i]);
|
|
strcat(tmpS, s0);
|
|
}
|
|
tmpS[strlen(tmpS)-1] = 0;
|
|
sprintf(sndbuf, "\x22\x43\x44\x22:\x22%s\x22,", tmpS); // "CD
|
|
strcat(sndPacket, sndbuf);
|
|
|
|
sndbuf[0] = 0;
|
|
tmpS[0] = 0;
|
|
for(uint8_t i=1; i<=MAX_RS485_2_COUNT; i++) {
|
|
s0[0] = 0;
|
|
sprintf(s0, "%d|", sNT[i]);
|
|
strcat(tmpS, s0);
|
|
}
|
|
tmpS[strlen(tmpS)-1] = 0;
|
|
sprintf(sndbuf, "\x22NT\x22:\x22%s\x22,", tmpS);
|
|
strcat(sndPacket, sndbuf);
|
|
|
|
sndbuf[0] = 0;
|
|
tmpS[0] = 0;
|
|
for(uint8_t i=1; i<=MAX_RS485_2_COUNT; i++) {
|
|
s0[0] = 0;
|
|
sprintf(s0, "%d|", sPH[i]);
|
|
strcat(tmpS, s0);
|
|
}
|
|
tmpS[strlen(tmpS)-1] = 0;
|
|
sprintf(sndbuf, "\x22PH\x22:\x22%s\x22,", tmpS);
|
|
strcat(sndPacket, sndbuf);
|
|
|
|
sndbuf[0] = 0;
|
|
tmpS[0] = 0;
|
|
for(uint8_t i=1; i<=MAX_RS485_2_COUNT; i++) {
|
|
s0[0] = 0;
|
|
sprintf(s0, "%d|", sGT[i]);
|
|
strcat(tmpS, s0);
|
|
}
|
|
tmpS[strlen(tmpS)-1] = 0;
|
|
sprintf(sndbuf, "\x22GT\x22:\x22%s\x22,", tmpS);
|
|
strcat(sndPacket, sndbuf);
|
|
|
|
sndbuf[0] = 0;
|
|
tmpS[0] = 0;
|
|
for(uint8_t i=1; i<=MAX_RS485_2_COUNT; i++) {
|
|
s0[0] = 0;
|
|
sprintf(s0, "%d|", sGM[i]);
|
|
strcat(tmpS, s0);
|
|
}
|
|
tmpS[strlen(tmpS)-1] = 0;
|
|
sprintf(sndbuf, "\x22GM\x22:\x22%s\x22,", tmpS);
|
|
strcat(sndPacket, sndbuf);
|
|
|
|
sndbuf[0] = 0;
|
|
tmpS[0] = 0;
|
|
for(uint8_t i=1; i<=MAX_RS485_2_COUNT; i++) {
|
|
s0[0] = 0;
|
|
sprintf(s0, "%d|", sGNT[i]);
|
|
strcat(tmpS, s0);
|
|
}
|
|
tmpS[strlen(tmpS)-1] = 0;
|
|
sprintf(sndbuf, "\x22GNT\x22:\x22%s\x22,", tmpS);
|
|
strcat(sndPacket, sndbuf);
|
|
|
|
sndbuf[0] = 0;
|
|
tmpS[0] = 0;
|
|
for(uint8_t i=1; i<=MAX_RS485_2_COUNT; i++) {
|
|
s0[0] = 0;
|
|
sprintf(s0, "%d|", sWP[i]);
|
|
strcat(tmpS, s0);
|
|
}
|
|
tmpS[strlen(tmpS)-1] = 0;
|
|
sprintf(sndbuf, "\x22WP\x22:\x22%s\x22,", tmpS);
|
|
strcat(sndPacket, sndbuf);
|
|
|
|
sndbuf[0] = 0;
|
|
tmpS[0] = 0;
|
|
for(uint8_t i=1; i<=MAX_RS485_2_COUNT; i++) {
|
|
s0[0] = 0;
|
|
sprintf(s0, "%d|", sGT2[i]);
|
|
strcat(tmpS, s0);
|
|
}
|
|
tmpS[strlen(tmpS)-1] = 0;
|
|
sprintf(sndbuf, "\x22GT2\x22:\x22%s\x22}", tmpS);
|
|
strcat(sndPacket, sndbuf);
|
|
|
|
/* 스케쥴번호 사용 제거 _ 20250613
|
|
sndbuf[0] = 0;
|
|
sprintf(sndbuf, "\x22SC\x22:\x22%s\x22}", rcvScheduleSeq);
|
|
strcat(sndPacket, sndbuf);
|
|
*/
|
|
|
|
unsigned long now = millis();
|
|
|
|
if (mqttClient.connected()) {
|
|
mqttClient.publish(UP_TOPICNAME, sndPacket);
|
|
|
|
totalInIntervals = 0;
|
|
|
|
digital_toggle(nLED_USER);
|
|
|
|
lastReconnectAttempt = now;
|
|
}
|
|
else {
|
|
if (now - lastReconnectAttempt > 2000) { // 마지막 MQTT publish 와 2초 이상 차이나면 mqtt or LAN 리셋
|
|
lastReconnectAttempt = now;
|
|
if ((!Ethernet_reinitial) && (Ethernet.linkStatus() != LinkON)) {
|
|
// 링크 문제 있을 때만 LAN 리셋
|
|
#ifdef bd_v2
|
|
digitalWrite(NET_VEN, LOW);
|
|
delay(100);
|
|
digitalWrite(NET_VEN, HIGH);
|
|
#endif
|
|
|
|
if (Serial1) Serial1.print("mainlog_ Ethernet.linkStatus - FALSE / Millis : ");
|
|
if (Serial1) Serial1.println(now);
|
|
|
|
net_setup();
|
|
} else {
|
|
// 링크는 OK → MQTT만 재연결 시도
|
|
beginConnection();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
char ClientID[16];
|
|
|
|
boolean beginConnection()
|
|
{
|
|
unsigned long now = millis();
|
|
if(mqttClient.connect(ClientID, mqtt_user, mqtt_pass))
|
|
{
|
|
mqttClient.subscribe(DN_TOPICNAME);
|
|
if (Serial1) Serial1.print("mainlog_ MQTT Connected & Subscribed re_cnt : ");
|
|
if (Serial1) Serial1.print(timeout_cnt);
|
|
if (Serial1) Serial1.print(" / Millis : ");
|
|
if (Serial1) Serial1.println(now);
|
|
if (Serial1) Serial1.println("mainlog_ ---------------------------------------------------------------------------------");
|
|
timeout_cnt = 0;
|
|
Ethernet_reinitial = false;
|
|
return true; // 연결 성공
|
|
}
|
|
else {
|
|
if (timeout_cnt > 1) { //세번 재접속 실패시 리셋 -> 2번 시도 / 로그확인결과 1,2번째 재접속 시도시 붙은 적이 없음 세번까지 재접속할 필요 없음
|
|
mqttClient.disconnect();
|
|
|
|
#ifdef bd_v2
|
|
digitalWrite(NET_VEN, LOW);
|
|
delay(100);
|
|
digitalWrite(NET_VEN, HIGH);
|
|
#endif
|
|
|
|
net_setup();
|
|
|
|
timeout_cnt = 0;
|
|
|
|
if (Serial1) Serial1.print("mainlog_Ethernet reinitialized (Millis : ");
|
|
if (Serial1) Serial1.print(now);
|
|
if (Serial1) Serial1.println(")");
|
|
} else {
|
|
|
|
if (Serial1) Serial1.print("mainlog_ MQTT not Connected re_cnt : ");
|
|
if (Serial1) Serial1.print(timeout_cnt);
|
|
if (Serial1) Serial1.print(" / Millis : ");
|
|
if (Serial1) Serial1.println(now);
|
|
timeout_cnt++;
|
|
return false; // 연결 실패
|
|
}
|
|
}
|
|
}
|
|
|
|
char rcvPacket[128];
|
|
int rcv_cnt = 0;
|
|
int step = 0;
|
|
|
|
String p_str = "";
|
|
char p_val;
|
|
|
|
void relay_on_00() {digitalWrite(D_OUT0, HIGH);}
|
|
void relay_on_01() {digitalWrite(D_OUT1, HIGH);}
|
|
void relay_on_02() {digitalWrite(D_OUT2, HIGH);}
|
|
void relay_on_03() {digitalWrite(D_OUT3, HIGH);}
|
|
void relay_on_04() {digitalWrite(D_OUT4, HIGH);}
|
|
void relay_on_05() {digitalWrite(D_OUT5, HIGH);}
|
|
void relay_on_06() {digitalWrite(D_OUT6, HIGH);}
|
|
void relay_on_07() {digitalWrite(D_OUT7, HIGH);}
|
|
void relay_on_08() {digitalWrite(D_OUT8, HIGH);}
|
|
void relay_on_09() {digitalWrite(D_OUT9, HIGH);}
|
|
void relay_on_10() {digitalWrite(D_OUT10, HIGH);}
|
|
void relay_on_11() {digitalWrite(D_OUT11, HIGH);}
|
|
void relay_on_12() {digitalWrite(D_OUT12, HIGH);}
|
|
void relay_on_13() {digitalWrite(D_OUT13, HIGH);}
|
|
void relay_on_14() {digitalWrite(D_OUT14, HIGH);}
|
|
void relay_on_15() {digitalWrite(D_OUT15, HIGH);}
|
|
|
|
void relay_off_00() {digitalWrite(D_OUT0, LOW);}
|
|
void relay_off_01() {digitalWrite(D_OUT1, LOW);}
|
|
void relay_off_02() {digitalWrite(D_OUT2, LOW);}
|
|
void relay_off_03() {digitalWrite(D_OUT3, LOW);}
|
|
void relay_off_04() {digitalWrite(D_OUT4, LOW);}
|
|
void relay_off_05() {digitalWrite(D_OUT5, LOW);}
|
|
void relay_off_06() {digitalWrite(D_OUT6, LOW);}
|
|
void relay_off_07() {digitalWrite(D_OUT7, LOW);}
|
|
void relay_off_08() {digitalWrite(D_OUT8, LOW);}
|
|
void relay_off_09() {digitalWrite(D_OUT9, LOW);}
|
|
void relay_off_10() {digitalWrite(D_OUT10, LOW);}
|
|
void relay_off_11() {digitalWrite(D_OUT11, LOW);}
|
|
void relay_off_12() {digitalWrite(D_OUT12, LOW);}
|
|
void relay_off_13() {digitalWrite(D_OUT13, LOW);}
|
|
void relay_off_14() {digitalWrite(D_OUT14, LOW);}
|
|
void relay_off_15() {digitalWrite(D_OUT15, LOW);}
|
|
|
|
void (*func_relay_on[16])() = {
|
|
relay_on_00,
|
|
relay_on_01,
|
|
relay_on_02,
|
|
relay_on_03,
|
|
relay_on_04,
|
|
relay_on_05,
|
|
relay_on_06,
|
|
relay_on_07,
|
|
|
|
relay_on_08,
|
|
relay_on_09,
|
|
relay_on_10,
|
|
relay_on_11,
|
|
relay_on_12,
|
|
relay_on_13,
|
|
relay_on_14,
|
|
relay_on_15,
|
|
};
|
|
|
|
void (*func_relay_off[16])() = {
|
|
relay_off_00,
|
|
relay_off_01,
|
|
relay_off_02,
|
|
relay_off_03,
|
|
relay_off_04,
|
|
relay_off_05,
|
|
relay_off_06,
|
|
relay_off_07,
|
|
|
|
relay_off_08,
|
|
relay_off_09,
|
|
relay_off_10,
|
|
relay_off_11,
|
|
relay_off_12,
|
|
relay_off_13,
|
|
relay_off_14,
|
|
relay_off_15,
|
|
};
|
|
|
|
#if 1
|
|
void relay_on(uint8_t p)
|
|
{
|
|
if (p_val == '1') func_relay_on[p]();
|
|
else if (p_val == '0') func_relay_off[p]();
|
|
}
|
|
#else
|
|
void relay_on(uint8_t p)
|
|
{
|
|
if (p_val == '1') {
|
|
if (p==0) digitalWrite(D_OUT0, HIGH);
|
|
else if (p==1) digitalWrite(D_OUT1, HIGH);
|
|
else if (p==2) digitalWrite(D_OUT2, HIGH);
|
|
else if (p==3) digitalWrite(D_OUT3, HIGH);
|
|
else if (p==4) digitalWrite(D_OUT4, HIGH);
|
|
else if (p==5) digitalWrite(D_OUT5, HIGH);
|
|
else if (p==6) digitalWrite(D_OUT6, HIGH);
|
|
else if (p==7) digitalWrite(D_OUT7, HIGH);
|
|
|
|
#ifdef bd_v2
|
|
else if (p==8) digitalWrite(D_OUT8, HIGH);
|
|
else if (p==9) digitalWrite(D_OUT9, HIGH);
|
|
else if (p==10) digitalWrite(D_OUT10, HIGH);
|
|
else if (p==11) digitalWrite(D_OUT11, HIGH);
|
|
else if (p==12) digitalWrite(D_OUT12, HIGH);
|
|
else if (p==13) digitalWrite(D_OUT13, HIGH);
|
|
else if (p==14) digitalWrite(D_OUT14, HIGH);
|
|
else if (p==15) digitalWrite(D_OUT15, HIGH);
|
|
#endif
|
|
}
|
|
else if (p_val == '0') {
|
|
if (p==0) digitalWrite(D_OUT0, LOW);
|
|
else if (p==1) digitalWrite(D_OUT1, LOW);
|
|
else if (p==2) digitalWrite(D_OUT2, LOW);
|
|
else if (p==3) digitalWrite(D_OUT3, LOW);
|
|
else if (p==4) digitalWrite(D_OUT4, LOW);
|
|
else if (p==5) digitalWrite(D_OUT5, LOW);
|
|
else if (p==6) digitalWrite(D_OUT6, LOW);
|
|
else if (p==7) digitalWrite(D_OUT7, LOW);
|
|
|
|
#ifdef bd_v2
|
|
else if (p==8) digitalWrite(D_OUT8, LOW);
|
|
else if (p==9) digitalWrite(D_OUT9, LOW);
|
|
else if (p==10) digitalWrite(D_OUT10, LOW);
|
|
else if (p==11) digitalWrite(D_OUT11, LOW);
|
|
else if (p==12) digitalWrite(D_OUT12, LOW);
|
|
else if (p==13) digitalWrite(D_OUT13, LOW);
|
|
else if (p==14) digitalWrite(D_OUT14, LOW);
|
|
else if (p==15) digitalWrite(D_OUT15, LOW);
|
|
#endif
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void callback_(char* topic, byte* payload, unsigned int length)
|
|
{
|
|
if (flag_emergency) return;
|
|
|
|
if (length == 29) {
|
|
/* 실시간 pulse 값 전송으로 변경 _ 20250613
|
|
if (((char)payload[2] == 'S') and
|
|
((char)payload[3] == 'C') and
|
|
((char)payload[16] == 'P') and
|
|
((char)payload[17] == 'S')) {
|
|
rcvScheduleSeq[0] = 0;
|
|
for (int i = 0; i < 6; i++) {
|
|
char c = (char)payload[i+7];
|
|
rcvScheduleSeq[i] = c;
|
|
}
|
|
rcvScheduleSeq[6] = '\0';
|
|
|
|
rcvtotalInIntervals[0] = 0;
|
|
for (int i = 0; i < 6; i++) {
|
|
char c = (char)payload[i+21];
|
|
rcvtotalInIntervals[i] = c;
|
|
}
|
|
rcvtotalInIntervals[6] = '\0';
|
|
|
|
char *endptr; // 오류 검사를 위해 사용 가능
|
|
totalInIntervals = strtoul(rcvtotalInIntervals, &endptr, 10);
|
|
savePulseTotal(totalInIntervals);
|
|
}
|
|
*/
|
|
}
|
|
else {
|
|
// handle message arrived
|
|
for (int i = 0; i < length; i++) {
|
|
char c = (char)payload[i];
|
|
|
|
switch(step) {
|
|
case 1 :
|
|
if (c == '}') {
|
|
step = 2;
|
|
}
|
|
else {
|
|
if(rcv_cnt > sizeof(rcvPacket)) { // overflow
|
|
step = 0;
|
|
break;
|
|
}
|
|
|
|
rcvPacket[rcv_cnt] = c;
|
|
rcv_cnt++;
|
|
break;
|
|
}
|
|
case 2 :
|
|
if (!(rcvPacket[1] == 'D') || !(rcvPacket[2] == 'O')) {
|
|
step = 0;
|
|
break;
|
|
}
|
|
#if 1 // issue 241227
|
|
if (rcvPacket[4] == ':') {
|
|
for(uint8_t p=0; p<DO_NUM; p++) {
|
|
p_val = rcvPacket[6+2*p];
|
|
relay_on(p);
|
|
}
|
|
}
|
|
else if ((rcvPacket[3] == '_') && (rcvPacket[7] == ':')) {
|
|
#if 1 // issue 241227
|
|
uint8_t p = 0;
|
|
if (rcvPacket[4] == '1') p = 10;
|
|
p += (rcvPacket[5] - '0');
|
|
if (p <= 15) {
|
|
p_val = rcvPacket[9];
|
|
relay_on(p);
|
|
}
|
|
#else
|
|
p_str = &rcvPacket[4];
|
|
rcvPacket[6] = 0;
|
|
|
|
p_val = rcvPacket[9];
|
|
relay_on(p_str.toInt());
|
|
#endif
|
|
}
|
|
#endif
|
|
step = 0;
|
|
break;
|
|
case 0:
|
|
if (c == '{') {
|
|
step = 1;
|
|
rcv_cnt = 0;
|
|
rcvPacket[0] = 0;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SetMQTTInfo()
|
|
{
|
|
mqttClient.setBufferSize(512); // default 256
|
|
|
|
String _ClientID = "GWID_"+(String)ClientID_NUM;
|
|
_ClientID.toCharArray(ClientID, sizeof(ClientID));
|
|
|
|
String _UP_TOPICNAME = (String)topic_head+"PUB/"+(String)topic_tail+(String)ClientID_NUM;
|
|
_UP_TOPICNAME.toCharArray(UP_TOPICNAME, sizeof(UP_TOPICNAME));
|
|
|
|
String _DN_TOPICNAME = (String)topic_head+"SUB/"+(String)topic_tail+(String)ClientID_NUM;
|
|
_DN_TOPICNAME.toCharArray(DN_TOPICNAME, sizeof(DN_TOPICNAME));
|
|
}
|
|
|
|
/*eof*/ |