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
|
/*
* DiagnosticActions.c
*
* Created on: Aug 20, 2018
* Author: shlomo
*/
#include <DataDef.h>
#include "include.h"
#include "diagnostics.h"
#include <inc/hw_ints.h>
#include <Container.h>
#include <PMR/Diagnostics/SetComponentValueRequest.pb-c.h>
#include <PMR/Diagnostics/SetComponentValueResponse.pb-c.h>
#include <PMR/Diagnostics/SetDigitalOutRequest.pb-c.h>
#include <PMR/Diagnostics/SetDigitalOutResponse.pb-c.h>
#include <PMR/Diagnostics/SetValveStateRequest.pb-c.h>
#include <PMR/Diagnostics/SetValveStateResponse.pb-c.h>
#include <PMR/Diagnostics/ValveType.pb-c.h>
#include <PMR/Diagnostics/ValveStateCode.pb-c.h>
#include <PMR/Diagnostics/SetBlowerStateRequest.pb-c.h>
#include <PMR/Diagnostics/SetBlowerStateResponse.pb-c.h>
#include <PMR/Hardware/HardwareBlowerType.pb-c.h>
#include <Drivers/I2C_Communication/RFID_NFC/I2C_IFS_Mux.h>
#include "drivers/FPGA/FPGA_GPIO/FPGA_GPIO.h"
#include "drivers/I2C_Communication/DAC/blower.h"
#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
#include "Drivers/I2C_Communication/Head_Card/Fan/Head_Fan.h"
#include <Drivers/I2C_Communication/WHS_Card/D_EMC2302_Fan/WHS_Fan.h>
#include "drivers/Valves/Valve.h"
#include "drivers/Heater/Heater.h"
#include "modules/waste/waste_ex.h"
#include "Drivers/I2C_Communication/I2C_Task.h"
#include "Drivers/I2C_Communication/I2C.h"
#include "modules/ids/ids_ex.h"
/********************************************************************************
*Blower Diagnostic
********************************************************************************/
uint32_t SetComponentValueRequestRequestFunc(MessageContainer* requestContainer)
{
MessageContainer responseContainer;
uint8_t* container_buffer;
//uint32_t status = 0;
uint32_t intvoltage;
SetComponentValueRequest* request = set_component_value_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
SetComponentValueResponse response = SET_COMPONENT_VALUE_RESPONSE__INIT;
responseContainer = createContainer(MESSAGE_TYPE__SetComponentValueResponse, requestContainer->token, true, &response, &set_component_value_response__pack, &set_component_value_response__get_packed_size);
container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
switch (request->component)
{
case VALUE_COMPONENT__BlowerVoltage:
blowervolatgedisplay = true;
intvoltage = (int)request->value;
if (intvoltage < 10.0)
Turn_the_Blower_Off();
else
{
Turn_the_Blower_On();
Control_Voltage_To_Blower(intvoltage);
}
break;
default:
break;
}
size_t container_size = message_container__pack(&responseContainer, container_buffer);
my_free(responseContainer.data.data);
SendChars(container_buffer, container_size);
set_component_value_request__free_unpacked(request,NULL);
return OK;
}
/********************************************************************************
*Set digital output Diagnostic
********************************************************************************/
uint32_t SetDigitalOutRequestRequestFunc(MessageContainer* requestContainer)
{
MessageContainer responseContainer;
uint8_t* container_buffer;
//uint32_t status = 0;
int portId;
SetDigitalOutRequest* request = set_digital_out_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
SetDigitalOutResponse response = SET_DIGITAL_OUT_RESPONSE__INIT;
responseContainer = createContainer(MESSAGE_TYPE__SetDigitalOutResponse, requestContainer->token, true, &response, &set_digital_out_response__pack, &set_digital_out_response__get_packed_size);
container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
switch (request->interfaceio)
{
case INTERFACE_IOS__Midtank1Air:
case INTERFACE_IOS__Midtank2Air:
case INTERFACE_IOS__Midtank3Air:
case INTERFACE_IOS__Midtank4Air:
case INTERFACE_IOS__Midtank5Air:
case INTERFACE_IOS__Midtank6Air:
case INTERFACE_IOS__Midtank7Air:
case INTERFACE_IOS__Midtank8Air:
portId = (request->interfaceio - INTERFACE_IOS__Midtank1Air) ; //0-7
if (request->value == Atm_MidTank_OFF)
Disable_MidTank_Pressure_Reading(portId);
else
Enable_MidTank_Pressure_Reading(portId);
Valve_Set(IDS_Id_to_AirValve[portId], request->value ); //Atm_MidTank_OFF/ON
break;
case INTERFACE_IOS__Midtank1Cartridge:
case INTERFACE_IOS__Midtank2Cartridge:
case INTERFACE_IOS__Midtank3Cartridge:
case INTERFACE_IOS__Midtank4Cartridge:
case INTERFACE_IOS__Midtank5Cartridge:
case INTERFACE_IOS__Midtank6Cartridge:
case INTERFACE_IOS__Midtank7Cartridge:
case INTERFACE_IOS__Midtank8Cartridge:
portId = (request->interfaceio - INTERFACE_IOS__Midtank1Cartridge) ; //0-7
Valve_Set(IDS_Id_to_CartrideValve[portId], request->value ); //Atm_MidTank_OFF/ON
break;
case INTERFACE_IOS__GPO_DRYER_SSR3_CTRL:
//CLEANER_PUMP_SSR3_CTRL
if (request->value == true)
ActivateCleanerPump();
else
DeActivateCleanerPump();
break;
case INTERFACE_IOS__GPO_DRYER_SSR1_CTRL:
if (request->value == true)
ActivateHeater(1);
else
DeActivateHeater(1);
break;
case INTERFACE_IOS__GPO_DRYER_SSR2_CTRL:
if (request->value == true)
ActivateHeater(2);
else
DeActivateHeater(2);
break;
case INTERFACE_IOS__GPO_DYEINGH_SSR8_CTRL:
if (request->value == true)
ActivateHeater(3);
else
DeActivateHeater(3);
break;
case INTERFACE_IOS__GPO_DYEINGH_SSR7_CTRL:
if (request->value == true)
ActivateHeater(4);
else
DeActivateHeater(4);
break;
case INTERFACE_IOS__GPO_DYEINGH_SSR6_CTRL:
if (request->value == true)
ActivateHeater(5);
else
DeActivateHeater(5);
break;
case INTERFACE_IOS__GPO_DYEINGH_SSR5_CTRL:
if (request->value == true)
ActivateHeater(6);
else
DeActivateHeater(6);
break;
case INTERFACE_IOS__GPO_DILUTORPUMP_SSR10_CTRL:
if (request->value == true)
ActivateHeater(7);
else
DeActivateHeater(7);
break;
case INTERFACE_IOS__GPO_EXTWINDER_SSR11_CTRL:
if (request->value == true)
ActivateHeater(8);
else
DeActivateHeater(8);
break;
case INTERFACE_IOS__GPO_MIXCHIP_SSR4_CTRL:
if (request->value == true)
ActivateHeater(9);
else
DeActivateHeater(9);
break;
case INTERFACE_IOS__GPO_SPARE_SSR13_CTRL:
if (request->value == true)
ActivateHeadMagnet();
else
DeActivateHeadMagnet();
break;
/* case INTERFACE_IOS__GPO_LED4:
DataUpdated = request->value;
break;*/
case INTERFACE_IOS__VALVE_WASTE_TANK:
if (request->value == true)
Valve_Set(VALVE_MIXCHIP_WASTECH,1);
else
Valve_Set(VALVE_MIXCHIP_WASTECH,0);
break;
case INTERFACE_IOS__GPO_BLOWER_PWM:
if (request->value == true)
Control_Dryer_Fan(START,75);//use START or STOP, 0 - 100%();
else
Control_Dryer_Fan(STOP,0);//use START or STOP, 0 - 100%();
break;
case INTERFACE_IOS__GPO_WASTECH_PUMP2://valve
if (WHS_Type == WHS_TYPE_UNKNOWN)
Valve_Set(VALVE_WASTE_TANK, request->value);
else
Trigger_SetWHSValveWatseCartridge(request->value);
break;
case INTERFACE_IOS__GPO_WHS_WTANKPUMP2:
if ((IFS_Availability[1] == IFS_RECOGNIZED_INIT_PASSED)&&(IFS_Availability[2] == IFS_RECOGNIZED_INIT_PASSED)) //ifs installed -check cartridges
{
if (NoCartAvailable())
return ERROR;
}
SetWastePump( request->value);
break;
case INTERFACE_IOS__GPO_SPARE_SSR12_CTRL:
if (request->value == true)
Lubricant_2Way_Valve(START);//use START or STOP, 0 - 100%();
else
Lubricant_2Way_Valve(STOP);//use START or STOP, 0 - 100%();
break;
case INTERFACE_IOS__GPO_TFEED_BREAK_1:
Pumps_Control(WASTECH_PUMP2, request->value);
break;
case INTERFACE_IOS__GPO_LED3:
if (request->value == true)
Trigger_Head_Actuators_Control(ACTIN, LOW,request->value);
else
HeadCard_Actuators_Relocate();
break;
case INTERFACE_IOS__GPO_LED4:
Trigger_Head_Actuators_Control(ACTOT, LOW,request->value);
break;
case INTERFACE_IOS__GPO_BUZZER:
if (request->value == true)
Buzzer(MODE_ON);//use START or STOP, 0 - 100%();
else
Buzzer(MODE_OFF);//use START or STOP, 0 - 100%();
break;
default:
responseContainer.has_error = true;
responseContainer.error = ERROR_CODE__GENERAL_ERROR;
break;
}
size_t container_size = message_container__pack(&responseContainer, container_buffer);
my_free(responseContainer.data.data);
SendChars(container_buffer, container_size);
set_digital_out_request__free_unpacked(request,NULL);
return OK;
}
/********************************************************************************
*Valve Setting
********************************************************************************/
uint32_t SetValveStateRequestFunc(MessageContainer* requestContainer)
{
MessageContainer responseContainer;
uint8_t* container_buffer;
uint32_t status = OK;
uint32_t valve;
SetValveStateRequest* request = set_valve_state_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
SetValveStateResponse response = SET_VALVE_STATE_RESPONSE__INIT;
responseContainer = createContainer(MESSAGE_TYPE__SetValveStateResponse, requestContainer->token, true, &response, &set_valve_state_response__pack, &set_valve_state_response__get_packed_size);
container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
if (request->valvetype <= VALVE_TYPE__DispenserValve8 ) //dispenser 3 way valves
{
valve = request->valvetype;
if (request->state == VALVE_STATE_CODE__MidTank)
{
Control3WayValvesWithCallback(request->valvetype,MidTank_Dispenser,NULL);
}
else if (request->state == VALVE_STATE_CODE__VGroove)
{
Control3WayValvesWithCallback(request->valvetype,Dispenser_Mixer,NULL);
}
else
status = ERROR;
}
else if (request->valvetype <= VALVE_TYPE__MidTankInkValve8 ) //midtank toward dispenser
{
valve = IDS_Id_to_CartrideValve[request->valvetype - VALVE_TYPE__MidTankInkValve1];
if (request->state == VALVE_STATE_CODE__Open)
{
Valve_Set(valve,Cartridge_MidTank_ON);
}
else if (request->state == VALVE_STATE_CODE__Close)
{
Valve_Set(valve,Cartridge_MidTank_OFF);
}
else
status = ERROR;
}
else if (request->valvetype <= VALVE_TYPE__MidTankAirValve8 )//midtank toward air
{
valve = IDS_Id_to_AirValve[request->valvetype - VALVE_TYPE__MidTankAirValve1];
if (request->state == VALVE_STATE_CODE__Open)
{
Valve_Set(valve,Atm_MidTank_ON);
}
else if (request->state == VALVE_STATE_CODE__Close)
{
Valve_Set(valve,Atm_MidTank_OFF);
}
else
status = ERROR;
}
else if (request->valvetype <= VALVE_TYPE__CartridgeWasteValve ) //not supported
{
status = FAILED;
}
else if (request->valvetype <= VALVE_TYPE__CartridgeInkValve8 ) //cartridge - not supported yet
{
status = FAILED;
}
else
{
status = FAILED;
}
if (status == FAILED)
{
status = ERROR;
responseContainer.has_error = true;
responseContainer.error = ERROR_CODE__GENERAL_ERROR;
}
size_t container_size = message_container__pack(&responseContainer, container_buffer);
my_free(responseContainer.data.data);
SendChars(container_buffer, container_size);
set_valve_state_request__free_unpacked(request,NULL);
return status;
}
/********************************************************************************
*Blower Setting
********************************************************************************/
uint32_t SetBlowerStateRequestFunc(MessageContainer* requestContainer)
{
MessageContainer responseContainer;
uint8_t* container_buffer;
uint32_t status = OK;
SetBlowerStateRequest* request = set_blower_state_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
SetBlowerStateResponse response = SET_BLOWER_STATE_RESPONSE__INIT;
responseContainer = createContainer(MESSAGE_TYPE__SetBlowerStateResponse, requestContainer->token, true, &response, &set_blower_state_response__pack, &set_blower_state_response__get_packed_size);
container_buffer = my_malloc(message_container__get_packed_size(&responseContainer));
if (request->has_blowertype)
{
Report("SetBlowerStateRequest",__FILE__,request->blowertype,(int)request->voltage,RpWarning,(int)request->isactive,0);
switch (request->blowertype)
{
case HARDWARE_BLOWER_TYPE__DefaultBlower:
case HARDWARE_BLOWER_TYPE__WHSBlower2:
if ((request->has_voltage)&&(request->isactive == true))
{
Turn_the_Blower_On();//Turn on with the Default_Voltage
Control_Voltage_To_Blower(request->voltage);
}
else
Turn_the_Blower_Off();
break;
case HARDWARE_BLOWER_TYPE__HeadBlower1:
if (Head_Type == HEAD_TYPE_ARC)
{
if ((request->has_voltage)&&(request->isactive == true))
Trigger_Head_Fan_Control(HEAD_FAN_RIGHT,request->voltage);
else if (request->isactive == false)
Trigger_Head_Fan_Control(HEAD_FAN_RIGHT,0);
}
else
status = NOT_SUPPORTED;
break;
case HARDWARE_BLOWER_TYPE__HeadBlower2:
if (Head_Type == HEAD_TYPE_ARC)
{
if ((request->has_voltage)&&(request->isactive == true))
Trigger_Head_Fan_Control(HEAD_FAN_LEFT,request->voltage);
else if (request->isactive == false)
Trigger_Head_Fan_Control(HEAD_FAN_LEFT,0);
}
else
status = NOT_SUPPORTED;
break;
case HARDWARE_BLOWER_TYPE__WHSSmallFans:
Trigger_SetWHSFanSpeed(FAN1, request->voltage);
Trigger_SetWHSFanSpeed(FAN2, request->voltage);
Trigger_SetWHSFanSpeed(FAN3, request->voltage);
Trigger_SetWHSFanSpeed(FAN4, request->voltage);
break;
case HARDWARE_BLOWER_TYPE__WHSLargeFans:
Trigger_SetWHSFanSpeed(FAN5, request->voltage);
Trigger_SetWHSFanSpeed(FAN6, request->voltage);
break;
default:
status = NOT_SUPPORTED;
break;
}
}
else
status = NOT_SUPPORTED;
if (status != OK)
{
status = ERROR;
responseContainer.has_error = true;
responseContainer.error = ERROR_CODE__GENERAL_ERROR;
}
size_t container_size = message_container__pack(&responseContainer, container_buffer);
my_free(responseContainer.data.data);
SendChars(container_buffer, container_size);
set_blower_state_request__free_unpacked(request,NULL);
return status;
}
|
