1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
| #include <SoftwareSerial.h>
#include <FlexiTimer2.h>
#define DIR2 8 // переключатель прием\передача
#define DIR3 9 // переключатель прием\передача
#define BUT 49
#define RDTYPE (82)
#define WRTYPE (67)
#define ERR_OK (0)
#define ERR_ERROR (1)
#define ERR_TIMEOUT (2)
#define ERR_INVALIED_PARAM (3)
volatile int totalSec = 0;
uint16_t Val = 0; //значение для записи
void to_Timer() {
totalSec ++;//каждую мл.сек увеличиваем totalSek
}
static uint8_t u8InputStandard = 0;
bool read_package_nano(Stream &, byte*);
bool read_package_pc(Stream &, byte*);
int sensorValue = 0;
struct tagREQ_FRM_T
{
uint8_t u8DevAddr1;
uint8_t u8DevAddr2;
uint8_t u8ReqType;
uint8_t u8DevPara;
uint8_t u8LoParam;
uint8_t u8HiParam;
uint8_t u8LoSumCheck;
uint8_t u8HiSumCheck;
} ;
struct tagANS_FRM_T
{
uint8_t u8LoPV;
uint8_t u8HiPV;
uint8_t u8LoSV;
uint8_t u8HiSV;
uint8_t u8MV;
uint8_t u8ALm;
uint8_t u8LoParam;
uint8_t u8HiParam;
uint8_t u8LoSumCheck;
uint8_t u8HiSumCheck;
};
struct packet_big //пакет PC
{
byte start_byte_one;//в длинном пакете равен 254
byte start_byte_two;//в длинном пакете равен 232
byte temp_pomp;//температура охлаждения
byte on_of_pomp;//on-off насоса (1 или 0)
byte ex_temp_reactor;//текущая температура в реакторе
byte current_temp_reactor;//выставленная температура в реакторе
byte timer_ex;//таймер
byte tmp;//пока не трогаем
byte CRC8;//пока не трогаем
void pask()
{
CRC8 = (start_byte_one + start_byte_two + temp_pomp + on_of_pomp + ex_temp_reactor + current_temp_reactor + timer_ex + tmp) / 10;
}
/*проверка упаковки*/
bool test_pask()
{
if (CRC8 == ((start_byte_one + start_byte_two + temp_pomp + on_of_pomp + ex_temp_reactor + current_temp_reactor + timer_ex + tmp)) / 10) return 0; //ОК
return 1; // ошибка
}
};
struct packet_arduino_pomp //пакет Arduino nano
{
byte start_byte_one;//в коротком пакете равен 212
byte start_byte_two;//в коротком пакете равен 211
byte temp_pomp;//температура охлаждения
byte on_of_pomp;//on-off насоса (1 или 0)
byte tmp;//пока не трогаем
byte CRC8;//пока не трогаем
/*упаковать*/
void pask()
{
CRC8 = (start_byte_one + start_byte_two + temp_pomp + on_of_pomp + tmp) / 10;
}
/*проверка упаковки*/
bool test_pask()
{
if (CRC8 == (start_byte_one + start_byte_two + temp_pomp + on_of_pomp + tmp) / 10) return 0; //ОК
return 1; // ошибка
}
};
packet_big one = {254, 232, 0, 0, 0, 0, 0, 0, 0};
packet_arduino_pomp one_pomp = {212, 211, 0, 0, 0, 0};
byte buttonState = 0;
void setup()
{
Serial.begin(9600);//на PC
Serial2.begin(9600); // SoftwareSerial на Arduino nano
Serial3.begin(9600, SERIAL_8N2);
pinMode(BUT, INPUT);
pinMode(DIR2, OUTPUT);
pinMode(DIR3, OUTPUT);
}
void loop()
{
tagANS_FRM_T stAnsFrm = {0};
uint16_t u16ParamAddr = 0;
int nTempVal = 0;
int nTempPv = 0;
int nTempSv = 0;
uint8_t u8Alm = 0;
buttonState = digitalRead(BUT); //кнопка
byte* ptr28 = (byte* )&one;//приводим структуру у массиву байт
byte *ptr_pomp = (byte*)&one_pomp;
digitalWrite(DIR2, LOW); // включаем прием
if (read_package_nano(Serial2, ptr_pomp)) {
one.temp_pomp = one_pomp.temp_pomp;//по хорошему переделать так, чтобы записывалась во временную переменную
}
if (ReadParam(Serial3, 1, u16ParamAddr, stAnsFrm) == ERR_OK)
{
nTempVal = Get2Byte(stAnsFrm.u8LoPV, stAnsFrm.u8HiPV);
nTempPv = IntToFloat(nTempVal, 0);
u8Alm = Get2Byte(stAnsFrm.u8LoSumCheck, stAnsFrm.u8LoSumCheck) % 16; // stAnsFrm.u8SumCheck % 16;
nTempVal = Get2Byte(stAnsFrm.u8LoSV, stAnsFrm.u8HiSV);
nTempSv = IntToFloat(nTempVal, u8Alm);
if (one.ex_temp_reactor == 0) {
one.ex_temp_reactor = (int)nTempPv / 10;
}
else if ((((int)nTempPv) / 10) >= ((one.ex_temp_reactor) + 2) || (((int)nTempPv) / 10) <= ((one.ex_temp_reactor) - 2)) {//костыль
one.ex_temp_reactor = one.ex_temp_reactor;
}
else
one.ex_temp_reactor = (int)nTempPv / 10;
}
if (read_package_pc(Serial, ptr28)) { //читаем с COM порта
one_pomp.on_of_pomp = one.on_of_pomp;//по хорошему переделать так, чтобы записывалась во временную переменную
}
if ((int)nTempSv / 10 != (int)one.current_temp_reactor) {
Val = one.current_temp_reactor;
Val = Val * 10;
uint8_t loVal = Val & 0xff;
uint8_t hiVal = ( Val >> 8) & 0xff;
WriteParam(Serial3, 1, 0, loVal, hiVal, stAnsFrm);
}
one.pask();
one_pomp.pask();
Serial.write(ptr28, sizeof(packet_big)); //передаем на PC
digitalWrite(DIR2, HIGH); // включаем передачу
Serial2.write(ptr_pomp, sizeof(packet_arduino_pomp)); //передаем на Arduino nano
delay(60);
}
bool read_package_nano(Stream &p_Serial, byte* fptr)//функция записи на ардуино нано, по сути передает пакет с вкл/выкл насоса
{
if (p_Serial.available() >= sizeof(packet_arduino_pomp))
{
byte buf_pump = 0;
for (size_t i = 0; i < sizeof(packet_arduino_pomp); i++)
{
if (i == 0 && (buf_pump = p_Serial.read()) != 212)
{
i = 0;
continue;
}
if (i == 1 && (buf_pump = p_Serial.read()) != 211)
{
i = 0;
continue;
}
if (i >= 2)
{
buf_pump = p_Serial.read();
fptr[i] = buf_pump;
if (i == sizeof(packet_arduino_pomp) - 1)
{
if (one_pomp.test_pask()) //проверяем контрольную сумму
{
return 0;
}
return 1;
}
}
}
}
}
bool read_package_pc(Stream &p_Serial, byte* fptr)// чтение с COM порта компа
{
if (p_Serial.available() >= sizeof(packet_big))
{
byte buf_pump = 0;
for (size_t i = 0; i < sizeof(packet_big); i++)
{
if (i == 0 && (buf_pump = p_Serial.read()) != 254)
{
i = 0;
continue;
}
if (i == 1 && (buf_pump = p_Serial.read()) != 232)
{
i = 0;
continue;
}
if (i >= 2)
{
buf_pump = p_Serial.read();
fptr[i] = buf_pump;
if (i == sizeof(packet_big) - 1)
{
if (one.test_pask()) //проверяем контрольную сумму
{
return 0;
}
return 1;
}
}
}
}
}
//Коннект к контроллеру
int WriteParam(Stream &p_Serial, uint8_t u8DevAddr, uint16_t u16DevPara, uint8_t u8LoParam, uint8_t u8HiParam, struct tagANS_FRM_T &stAnsFrm)
{
struct tagREQ_FRM_T stReqFrm;
uint32_t n32CheckSum = 0;
uint8_t u8Temp = 0;
int nErrCnt = 0;
int nError = ERR_ERROR;
u8Temp = u16DevPara;
stReqFrm.u8DevAddr1 = 0x80 + u8DevAddr;
stReqFrm.u8DevAddr2 = 0x80 + u8DevAddr;
stReqFrm.u8ReqType = WRTYPE;
stReqFrm.u8DevPara = u8Temp;
stReqFrm.u8LoParam = u8LoParam;
stReqFrm.u8HiParam = u8HiParam;
n32CheckSum = u8DevAddr + (stReqFrm.u8DevPara << 8) + stReqFrm.u8ReqType + Get2Byte(stReqFrm.u8LoParam , stReqFrm.u8HiParam);
stReqFrm.u8LoSumCheck = n32CheckSum & 0xff;
stReqFrm.u8HiSumCheck = ( n32CheckSum >> 8) & 0xff;
while (nErrCnt < 6)
{
if (SendFrame(p_Serial, (const byte *)&stReqFrm, sizeof(struct tagREQ_FRM_T), 200))
{
if (ReceiveFrame(p_Serial, (byte *)&stAnsFrm, sizeof(struct tagANS_FRM_T), 200))
{
if (GetSumCheck(stAnsFrm))
{
if (u16DevPara == 0x16)
{
u8InputStandard = stAnsFrm.u8LoParam;
}
nErrCnt = 10;
nError = ERR_OK;
}
}
}
nErrCnt++;
}
return nError;
}
int ReadParam(Stream &p_Serial, uint8_t u8DevAddr, uint16_t u16DevPara, struct tagANS_FRM_T &stAnsFrm)
{
struct tagREQ_FRM_T stReqFrm;
uint32_t n32CheckSum = 0;
uint8_t u8Temp = 0;
int nErrCnt = 0;
int nError = ERR_ERROR;
u8Temp = u16DevPara;//подозрения
stReqFrm.u8DevAddr1 = 0x80 + u8DevAddr;
stReqFrm.u8DevAddr2 = 0x80 + u8DevAddr;
stReqFrm.u8ReqType = RDTYPE;
stReqFrm.u8DevPara = 0;
stReqFrm.u8LoParam = 0;
stReqFrm.u8HiParam = 0;
n32CheckSum = u8DevAddr + (stReqFrm.u8DevPara << 8) + stReqFrm.u8ReqType;
stReqFrm.u8LoSumCheck = n32CheckSum & 0xff;
stReqFrm.u8HiSumCheck = ( n32CheckSum >> 8) & 0xff;
while (nErrCnt < 6)
{
if (SendFrame(p_Serial, (const byte *)&stReqFrm, sizeof(tagREQ_FRM_T), 200))
{
if (ReceiveFrame(p_Serial, (byte *)&stAnsFrm, sizeof(tagANS_FRM_T), 200))
{
if (GetSumCheck(stAnsFrm))
{
if (u16DevPara == 0x16)
{
u8InputStandard = stAnsFrm.u8LoParam;//????что это
}
nErrCnt = 10;
nError = ERR_OK;
}
}
}
nErrCnt++;
}
return nError;
}
bool SendFrame(Stream &p_Serial, const byte *pcFrameBuff, uint64_t nFrameSize, int nTimeOut)
{
FlexiTimer2::set(1, 1000, to_Timer); // Здесь задаем период 1 м.секунда
totalSec = 0;
FlexiTimer2::start();//Стартуем, теперь таймер запущен
while ((totalSec < nTimeOut) && (nFrameSize > 0))
{
uint64_t nWriteBytes = WriteData(p_Serial, pcFrameBuff, nFrameSize);
pcFrameBuff += nWriteBytes;
nFrameSize -= nWriteBytes;
}
totalSec = 0;
FlexiTimer2::stop();
return (nFrameSize == 0);
}
bool ReceiveFrame(Stream &p_Serial, byte *pcFrameBuff, uint64_t nFrameSize, int nTimeOut)
{
uint64_t nReadCurCount = 0;
FlexiTimer2::set(1, 1000, to_Timer); // Здесь задаем период 1 м.секунда
totalSec = 0;
FlexiTimer2::start();//Стартуем, теперь таймер запущен
while ((totalSec < nTimeOut) && (nReadCurCount < nFrameSize))
{
uint64_t nReadBytes = ReadData(p_Serial, pcFrameBuff, nFrameSize);
pcFrameBuff += nReadBytes;
nReadCurCount += nReadBytes;
}
totalSec = 0;
FlexiTimer2::stop();
return (nReadCurCount == nFrameSize);
}
uint64_t WriteData(Stream &p_Serial, const byte *pcWriteBuff, uint64_t nWriteLenth)//нужно переписать
{
digitalWrite(DIR3, HIGH); // включаем передачу
uint64_t nTempWriteLenth = nWriteLenth;
delay(20);
p_Serial.write(pcWriteBuff, nWriteLenth);
// }
delay(50);
return nTempWriteLenth;
}
uint64_t ReadData(Stream &p_Serial, byte *pcReadBuff, uint64_t nReadLenth)//вот эту нужно переписать
{
digitalWrite(DIR3, LOW);//включить прием
uint64_t nTempReadLenth = 0;
delay(50);
if (p_Serial.available() > 0) {
for (nTempReadLenth = 0; nTempReadLenth < nReadLenth; nTempReadLenth++) {
pcReadBuff[nTempReadLenth] = p_Serial.read();
}
}
delay(30);
return nTempReadLenth;
}
uint16_t Get2Byte(uint8_t u8LoByte, uint8_t u8HiByte)
{
uint16_t nsValue = 0;
nsValue |= (u8HiByte << 8);
nsValue &= 0xFF00;
nsValue |= u8LoByte;
return nsValue;
}
int IntToFloat(uint32_t n32Value, uint8_t u8Value)
{
int nRetVal = 0;
int nTemp = 1;
if (n32Value < 0)
{
nTemp = -1;
n32Value = -n32Value;
}
if (n32Value < 10000)
{
nRetVal = n32Value;
}
else if (n32Value < 19000)
{
nRetVal = (n32Value - 9000) * 10 + u8Value;
}
else if (n32Value < 28000)
{
nRetVal = ((n32Value - 18000) * 10 + u8Value) * 10;
}
else
{
nRetVal = ((n32Value - 27000) * 10 + u8Value) * 100 ;
}
return nRetVal * nTemp;
}
bool GetSumCheck(struct tagANS_FRM_T stAnsFrm)
{
uint8_t u8CrcVal = 0;
uint8_t u8CalCrcVal = 0;
uint8_t u8TempCheck;
bool bResult = false;
u8TempCheck = Get2Byte(stAnsFrm.u8LoSumCheck, stAnsFrm.u8LoSumCheck);
u8CrcVal = Get2Byte(stAnsFrm.u8LoPV, stAnsFrm.u8HiPV) + Get2Byte(stAnsFrm.u8LoSV, stAnsFrm.u8HiSV) +
(stAnsFrm.u8ALm * 256 + stAnsFrm.u8MV) + Get2Byte(stAnsFrm.u8LoParam, stAnsFrm.u8HiParam) + 1;
u8CalCrcVal = Get2Byte(stAnsFrm.u8LoSumCheck, stAnsFrm.u8LoSumCheck);
if (u8CrcVal == u8CalCrcVal)
{
bResult = true;
}
return bResult;
} |