Quando si ha più di una periferica PUZZLE con cui comunicare in CAN, il modo per gestirle è di inlcudere nel common.h la libreria puzzle.h
Nella libreria è presente anche la parte per la comunicazione in RS485.
Nel common.h o comunque in un file .h incluso nel common:
// For multiperif:
// #define PUZZLE_PERIFS 2, 3, 4, ...
#ifndef PUZZLE_PERIFS
#define PUZZLE_PERIFS 1
#endif
//----------------------------------------------
#ifdef linux
#define PortaCOM COM2
#else
#define PortaCOM COM3
#endif
// Tipo di comunicazione
#define P_RS485 0
#define P_CAN 1
// Configurazione connettori X1, ... X8
#define EMPTY 0 // Empty connector
#define UA13144 1 // Analog input 0-20mA
#define UA13143 2 // Analog input 0-10V
#define UA23141 3 // Digital input PNP
#define UA13151 4 // Digital output PNP
#define UA13152 5 // Digital output NPN
#define UA13171 6 // PT100
#define UA13161 7 // Analog output (PWM)
// Questi vanno in xn_config[]
#define C_EMPTY 21
#define C_ADC 22
#define C_PWM 23
#define C_IN 24
#define C_OUT 25
#define C_PT100 26
#define DIM_RX 33
#define DIM_TX 41
#define DIM_CONFIG 8
#define START_TX 0x00
volatile char xn_config[] = { C_EMPTY, // X1
C_EMPTY, // X2
C_EMPTY, // X3
C_EMPTY, // X4
C_EMPTY, // X5
C_EMPTY, // X6
C_EMPTY, // X7
C_EMPTY};// X8
char msg_rx[DIM_RX];
char msg_tx[DIM_TX];
int puzzle_version=0; // FW version
int puzzle_com=0;
// Encoders
volatile long p_encoder1;
volatile long p_encoder2;
volatile char puzzle_reset=0; // reset request flag
volatile char puzzle_reset_perif[] = {0,0,0,0,0,0,0,0};
volatile char puzzle_update=0; // update request flag
int puzzle_disc_cnt = 0;
int puzzle_perif_on = 1; // diventa 0 se scollego la periferica
int prx_cnt=0;
int ptx_cnt=0;
volatile char config_on = 0;
volatile char serial_port_on = 0;
volatile int puzzle_status = 0;
volatile int p_dipswitch_status = 0; // dip switch status
volatile int p_ext1_on = 0; // EXP1 & EXP2 I/O & ENC1 on (1) off (0)
volatile int p_ext2_on = 0; // EXP3 to EXP8 I/O & ENC2 on (1) off (0)
void puzzle_reboot(void); // fai il reboot della/le periferica/che
void create_config(void);
void parse_rx(void);
void create_tx(void);
void rw_puzzle(void);
void puzzle_task(void);
void puzzle_start(void); // RS485
void puzzle_start_can(char, char); // CAN (EXP ON/OFF, ENCODER ON/OFF)
void puzzle_task_can(void);
void puzzle_task_can_rx(void);
float pt100_calc(int, int);
// bootloader
void puzzle_stop(void); // RS485 - bootloader
void puzzle_stop_can(void); // CAN
// ----------------------- RS485 -------------------------
#define CMD_CONFIG 1
#define CMD_DRIVE 2
#define CMD_OK 3
#define CMD_NO 4
// Comandi bootloader (da definire anche all'interno del bootloader)
#define CMD_BOOT_WU 5 // wake up del bootloader (rx)
void RXCom(COM *);
void parsing_test_pettine_com(void);
void timer_tx_rx_perif(void);
//----------------------------------------------
COM *Com=0;
volatile char flag_test_tx_com3=0;
// struttura unificata buffer messaggi
typedef struct COM_MESSAGE
{
char cmd; // comando
short para[100]; // operandi
}COM_MESSAGE;
volatile COM_MESSAGE txmess;
volatile COM_MESSAGE rxmess;
volatile int rxsize;
volatile U32 cnt_reply=0;
volatile char flag_comunica_con_perif=0;
//----------------------------------------------
typedef struct COM_TX_RX_MESSAGE_test
{
char cmd; // comando
U8 emb_msg[DIM_TX+1]; // messaggio incapsulato // bootloader
}COM_TX_RX_MESSAGE_test __attribute__((PACKET));
//----------------------------------------------
void tx_cmd_msg(U8 command)
{
COM_TX_RX_MESSAGE_test *tx_1=(COM_TX_RX_MESSAGE_test *)&txmess;
tx_1->cmd = command;
int i;
for (i=0; i<DIM_TX; i++) {
tx_1->emb_msg[i] = msg_tx[i];
}
bsave(Com,tx_1,sizeof(COM_TX_RX_MESSAGE_test));
ptx_cnt++;
}
//----------------------------------------------
void install_port(void)
{
com_close(Com);
com_disable(Com);
com_open(Com,115200);
protocol_mode(Com,1); // COMx IN MODO 1 (BLOAD/BSAVE)
onrx(Com,RXCom); // RXCom() = callback linked/called/executed when received a complete packet Syel mode 1
//onrx(Com,0);
Com->centr=0x01; // centr = who sends
Com->perif=0x02; // perif = who receives
com_enable(Com); // ABILITA LA COM
}
//----------------------------------------------
void RXCom(COM *Com)
{
prx_cnt++;
puzzle_disc_cnt = 0;
rxsize=bload(Com,&rxmess,sizeof(rxmess));
int i;
if(rxsize) {
COM_TX_RX_MESSAGE_test* rx1 = (COM_TX_RX_MESSAGE_test*)&rxmess;
for (i=0; i<DIM_RX; i++) {
msg_rx[i] = rx1->emb_msg[i];
}
parse_rx(); // parsizzo gli input
}
}
//----------------------------------------------
void timer_tx_rx_perif(void)
{
flag_comunica_con_perif=1;
}
void puzzle_reboot()
{
puzzle_reset = 1;
puzzle_reset_perif[0] = 1;
puzzle_reset_perif[1] = 1;
puzzle_reset_perif[2] = 1;
puzzle_reset_perif[3] = 1;
puzzle_reset_perif[4] = 1;
puzzle_reset_perif[5] = 1;
puzzle_reset_perif[6] = 1;
puzzle_reset_perif[7] = 1;
}
// INGRESSI E USCITE
volatile char p_i1 = 0;
volatile char p_i2 = 0;
volatile char p_i3 = 0;
volatile char p_i4 = 0;
volatile char p_i5 = 0;
volatile char p_i6 = 0;
volatile char p_i7 = 0;
volatile char p_i8 = 0;
volatile char p_i9 = 0;
volatile char p_i10 = 0;
volatile char p_i11 = 0;
volatile char p_i12 = 0;
volatile char p_i13 = 0;
volatile char p_i14 = 0;
volatile char p_i15 = 0;
volatile char p_i16 = 0;
volatile char p_i17 = 0;
volatile char p_i18 = 0;
volatile char p_i19 = 0;
volatile char p_i20 = 0;
volatile char p_i21 = 0;
volatile char p_i22 = 0;
volatile char p_i23 = 0;
volatile char p_i24 = 0;
volatile char p_i25 = 0;
volatile char p_i26 = 0;
volatile char p_i27 = 0;
volatile char p_i28 = 0;
volatile char p_i29 = 0;
volatile char p_i30 = 0;
volatile char p_i31 = 0;
volatile char p_i32 = 0;
volatile char p_i33 = 0;
volatile char p_i34 = 0;
volatile char p_i35 = 0;
volatile char p_i36 = 0;
volatile char p_i37 = 0;
volatile char p_i38 = 0;
volatile char p_i39 = 0;
volatile char p_i40 = 0;
volatile char p_i41 = 0;
volatile char p_i42 = 0;
volatile char p_i43 = 0;
volatile char p_i44 = 0;
volatile char p_i45 = 0;
volatile char p_i46 = 0;
volatile char p_i47 = 0;
volatile char p_i48 = 0;
volatile char p_i49 = 0;
volatile char p_i50 = 0;
volatile char p_i51 = 0;
volatile char p_i52 = 0;
volatile char p_i53 = 0;
volatile char p_i54 = 0;
volatile char p_i55 = 0;
volatile char p_i56 = 0;
volatile char p_i57 = 0;
volatile char p_i58 = 0;
volatile char p_i59 = 0;
volatile char p_i60 = 0;
volatile char p_i61 = 0;
volatile char p_i62 = 0;
volatile char p_i63 = 0;
volatile char p_i64 = 0;
volatile unsigned char *p__i__[] = {&p_i1, &p_i2, &p_i3, &p_i4, &p_i5,
&p_i6, &p_i7, &p_i8, &p_i9, &p_i10,
&p_i11, &p_i12, &p_i13, &p_i14, &p_i15,
&p_i16, &p_i17, &p_i18, &p_i19, &p_i20,
&p_i21, &p_i22, &p_i23, &p_i24, &p_i25,
&p_i26, &p_i27, &p_i28, &p_i29, &p_i30,
&p_i31, &p_i32, &p_i33, &p_i34, &p_i35,
&p_i36, &p_i37, &p_i38, &p_i39, &p_i40,
&p_i41, &p_i42, &p_i43, &p_i44, &p_i45,
&p_i46, &p_i47, &p_i48, &p_i49, &p_i50,
&p_i51, &p_i52, &p_i53, &p_i54, &p_i55,
&p_i56, &p_i57, &p_i58, &p_i59, &p_i60,
&p_i61, &p_i62, &p_i63, &p_i64};
volatile char p_o1 = 0;
volatile char p_o2 = 0;
volatile char p_o3 = 0;
volatile char p_o4 = 0;
volatile char p_o5 = 0;
volatile char p_o6 = 0;
volatile char p_o7 = 0;
volatile char p_o8 = 0;
volatile char p_o9 = 0;
volatile char p_o10 = 0;
volatile char p_o11 = 0;
volatile char p_o12 = 0;
volatile char p_o13 = 0;
volatile char p_o14 = 0;
volatile char p_o15 = 0;
volatile char p_o16 = 0;
volatile char p_o17 = 0;
volatile char p_o18 = 0;
volatile char p_o19 = 0;
volatile char p_o20 = 0;
volatile char p_o21 = 0;
volatile char p_o22 = 0;
volatile char p_o23 = 0;
volatile char p_o24 = 0;
volatile char p_o25 = 0;
volatile char p_o26 = 0;
volatile char p_o27 = 0;
volatile char p_o28 = 0;
volatile char p_o29 = 0;
volatile char p_o30 = 0;
volatile char p_o31 = 0;
volatile char p_o32 = 0;
volatile char p_o33 = 0;
volatile char p_o34 = 0;
volatile char p_o35 = 0;
volatile char p_o36 = 0;
volatile char p_o37 = 0;
volatile char p_o38 = 0;
volatile char p_o39 = 0;
volatile char p_o40 = 0;
volatile char p_o41 = 0;
volatile char p_o42 = 0;
volatile char p_o43 = 0;
volatile char p_o44 = 0;
volatile char p_o45 = 0;
volatile char p_o46 = 0;
volatile char p_o47 = 0;
volatile char p_o48 = 0;
volatile char p_o49 = 0;
volatile char p_o50 = 0;
volatile char p_o51 = 0;
volatile char p_o52 = 0;
volatile char p_o53 = 0;
volatile char p_o54 = 0;
volatile char p_o55 = 0;
volatile char p_o56 = 0;
volatile char p_o57 = 0;
volatile char p_o58 = 0;
volatile char p_o59 = 0;
volatile char p_o60 = 0;
volatile char p_o61 = 0;
volatile char p_o62 = 0;
volatile char p_o63 = 0;
volatile char p_o64 = 0;
volatile unsigned char *p__o__[] = {&p_o1, &p_o2, &p_o3, &p_o4, &p_o5,
&p_o6, &p_o7, &p_o8, &p_o9, &p_o10,
&p_o11, &p_o12, &p_o13, &p_o14, &p_o15,
&p_o16, &p_o17, &p_o18, &p_o19, &p_o20,
&p_o21, &p_o22, &p_o23, &p_o24, &p_o25,
&p_o26, &p_o27, &p_o28, &p_o29, &p_o30,
&p_o31, &p_o32, &p_o33, &p_o34, &p_o35,
&p_o36, &p_o37, &p_o38, &p_o39, &p_o40,
&p_o41, &p_o42, &p_o43, &p_o44, &p_o45,
&p_o46, &p_o47, &p_o48, &p_o49, &p_o50,
&p_o51, &p_o52, &p_o53, &p_o54, &p_o55,
&p_o56, &p_o57, &p_o58, &p_o59, &p_o60,
&p_o61, &p_o62, &p_o63, &p_o64};
// Valori 0-4095 degli input analogici
volatile int x1_anal;
volatile int x2_anal;
volatile int x3_anal;
volatile int x4_anal;
volatile int x5_anal;
volatile int x6_anal;
volatile int x7_anal;
volatile int x8_anal;
volatile int* __xn_anal__[] = {&x1_anal, &x2_anal, &x3_anal, &x4_anal, &x5_anal, &x6_anal, &x7_anal, &x8_anal};
// Valori a 16 bit delle PT100
volatile int x1_pt100_raw;
volatile int x2_pt100_raw;
volatile int x3_pt100_raw;
volatile int x4_pt100_raw;
volatile int x5_pt100_raw;
volatile int x6_pt100_raw;
volatile int x7_pt100_raw;
volatile int x8_pt100_raw;
volatile int* __xn_pt100_raw__[] = {&x1_pt100_raw, &x2_pt100_raw, &x3_pt100_raw, &x4_pt100_raw, &x5_pt100_raw, &x6_pt100_raw, &x7_pt100_raw, &x8_pt100_raw};
// Valori float in Celsius
float x1_pt100;
float x2_pt100;
float x3_pt100;
float x4_pt100;
float x5_pt100;
float x6_pt100;
float x7_pt100;
float x8_pt100;
volatile float* __xn_pt100__[] = {&x1_pt100, &x2_pt100, &x3_pt100, &x4_pt100, &x5_pt100, &x6_pt100, &x7_pt100, &x8_pt100};
// Ingressi digitali XN
volatile char x1_digin;
volatile char x2_digin;
volatile char x3_digin;
volatile char x4_digin;
volatile char x5_digin;
volatile char x6_digin;
volatile char x7_digin;
volatile char x8_digin;
volatile char *__xn_digin__[] = {&x1_digin, &x2_digin, &x3_digin, &x4_digin, &x5_digin, &x6_digin, &x7_digin, &x8_digin};
volatile char x1_i1;
volatile char x1_i2;
volatile char x2_i1;
volatile char x2_i2;
volatile char x3_i1;
volatile char x3_i2;
volatile char x4_i1;
volatile char x4_i2;
volatile char x5_i1;
volatile char x5_i2;
volatile char x6_i1;
volatile char x6_i2;
volatile char x7_i1;
volatile char x7_i2;
volatile char x8_i1;
volatile char x8_i2;
// Valori ricalcolati
volatile float xn_ua13141[8]; // UA 13141 - 0-3V3
volatile float xn_ua13142[8]; // UA 13142 - 0-5V
volatile float xn_ua13143[8]; // UA 13143 - 0-10V
volatile float xn_ua13144[8]; // UA 13144 - 0-20mA
// TODO:
volatile float xn_ua13145[8]; // UA 13145 - NTC 10K
// Uscite digitali XN
volatile char x1_o1;
volatile char x1_o2;
volatile char x2_o1;
volatile char x2_o2;
volatile char x3_o1;
volatile char x3_o2;
volatile char x4_o1;
volatile char x4_o2;
volatile char x5_o1;
volatile char x5_o2;
volatile char x6_o1;
volatile char x6_o2;
volatile char x7_o1;
volatile char x7_o2;
volatile char x8_o1;
volatile char x8_o2;
char *__xn_outs__[] = {&x1_o1, &x1_o2, &x2_o1, &x2_o2, &x3_o1, &x3_o2, &x4_o1, &x4_o2,
&x5_o1, &x5_o2, &x6_o1, &x6_o2, &x7_o1, &x7_o2, &x8_o1, &x8_o2};
// Uscite PWM
volatile U16 x1_pwm = 2048;
volatile U16 x2_pwm = 2048;
volatile U16 x3_pwm = 2048;
volatile U16 x4_pwm = 2048;
volatile U16 x5_pwm = 2048;
volatile U16 x6_pwm = 2048;
volatile U16 x7_pwm = 2048;
volatile U16 x8_pwm = 2048;
U16 *__xn_pwms__[] = {&x1_pwm, &x2_pwm, &x3_pwm, &x4_pwm, &x5_pwm, &x6_pwm, &x7_pwm, &x8_pwm};
#ifdef COLLAUDO
float p_volt2[8];
float p_ohm[8];
#endif
float pt100_current = 0.000926;
float pt100_calc(int raw, int n)
{
float volt2, ohm, ret;
int lraw;
// trasformo raw a 18 bit
lraw = (raw << 2);
volt2 = (float)lraw * (0.000015625 / 8);
//ohm = volt2 / 0.000926;
ohm = volt2 / pt100_current;
ret = -245.19 + ohm * (2.5293 + ohm * (-0.066046 + ohm * (0.0040422 + ohm * (-0.0000020697)))) / (1 + ohm * (-0.025422 + ohm * (0.0016883 + ohm * (-0.0000013601))));
#ifdef COLLAUDO
p_volt2[n] = volt2;
p_ohm[n] = ohm;
#endif
return ret;
}
void create_config()
{
msg_tx[0] = START_TX;
int i;
for (i=0; i<8; i++) {
msg_tx[i+1] = xn_config[i];
}
}
void parse_rx()
{
// dipswitch
p_dipswitch_status = (msg_rx[0] & 0x0F);
// versione firmware
puzzle_version = (msg_rx[0] & 0xF0) >> 4;
// Dal byte 1 al byte 16 ho le informazioni sugli XN
int i, j;
for (i=1; i<9; i++) {
j = 2*i-1;
*__xn_anal__[i-1] = (msg_rx[j] << 8) | (msg_rx[j+1] & 0xff); // Analog
*__xn_digin__[i-1] = (msg_rx[j+1] & 0x03); // Digital
*__xn_pt100_raw__[i-1] = (msg_rx[j] << 8) | (msg_rx[j+1] & 0xff); // PT100
// calcoli PT100
if ( xn_config[i-1] == C_PT100 ) *__xn_pt100__[i-1] = pt100_calc(*__xn_pt100_raw__[i-1], i-1);
}
#if 0
// Ricalcola tutti i valori in virgola mobile
for (i=0; i<8; i++) { // ciclo sugli XN
// 0-3V3
xn_ua13141[i] = 3.3*(*__xn_anal__[i])/4095.;
// 0-5V
xn_ua13142[i] = 5.*(*__xn_anal__[i])/4095.;
// 0-10V
xn_ua13143[i] = 10.*(*__xn_anal__[i])/4095.;
// 0-20mA
xn_ua13144[i] = 20.*(*__xn_anal__[i])/4095.;
// TODO: NTC 10K, PT100, ...
}
#endif
// Ricalcola gli ingressi digitali
x1_i1 = x1_digin & 0x01;
x1_i2 = (x1_digin & 0x02) >> 1;
x2_i1 = x2_digin & 0x01;
x2_i2 = (x2_digin & 0x02) >> 1;
x3_i1 = x3_digin & 0x01;
x3_i2 = (x3_digin & 0x02) >> 1;
x4_i1 = x4_digin & 0x01;
x4_i2 = (x4_digin & 0x02) >> 1;
x5_i1 = x5_digin & 0x01;
x5_i2 = (x5_digin & 0x02) >> 1;
x6_i1 = x6_digin & 0x01;
x6_i2 = (x6_digin & 0x02) >> 1;
x7_i1 = x7_digin & 0x01;
x7_i2 = (x7_digin & 0x02) >> 1;
x8_i1 = x8_digin & 0x01;
x8_i2 = (x8_digin & 0x02) >> 1;
// SPI IN
// Dal byte 17 al 24 ho le informazioni degli 8 moduli
for (i=17, j=0; i<25; i++, j+=8) { // ciclo sui byte
*p__i__[j] = (msg_rx[i] >> 7) & 0x01;
*p__i__[j+1] = (msg_rx[i] >> 6) & 0x01;
*p__i__[j+2] = (msg_rx[i] >> 5) & 0x01;
*p__i__[j+3] = (msg_rx[i] >> 4) & 0x01;
*p__i__[j+4] = (msg_rx[i] >> 3) & 0x01;
*p__i__[j+5] = (msg_rx[i] >> 2) & 0x01;
*p__i__[j+6] = (msg_rx[i] >> 1) & 0x01;
*p__i__[j+7] = (msg_rx[i] >> 0) & 0x01;
}
// ENCODERS
// Dal byte 25 al byte 32 ho le informazioni sulle due quote
p_encoder1 = ( (msg_rx[25] << 24) & 0xFF000000 ) |
( (msg_rx[26] << 16) & 0xFF0000 ) |
( (msg_rx[27] << 8) & 0xFF00 ) |
(msg_rx[28] & 0xFF);
p_encoder2 = ( (msg_rx[29] << 24) & 0xFF000000 ) |
( (msg_rx[30] << 16) & 0xFF0000 ) |
( (msg_rx[31] << 8) & 0xFF00 ) |
(msg_rx[32] & 0xFF);
/*
p_encoder2 = (msg_rx[29] << 24) |
(msg_rx[30] << 16) |
(msg_rx[31] << 8) |
(msg_rx[32]);
*/
}
void create_tx()
{
msg_tx[0] = START_TX;
// Scrivi la configurazione
int i,j;
for (i=0; i<8; i++) {
msg_tx[i+1] = xn_config[i];
}
// X1
switch (xn_config[0]) {
case C_OUT: // Uscite digitali
msg_tx[9] = 0;
// msg_tx[10] = ((x1_o1 & 0x01) << 1) | (x1_o2 & 0x01); 04-12-2018
msg_tx[10] = ((x1_o2 & 0x01) << 1) | (x1_o1 & 0x01); // 04-12-2018
break;
case C_PWM: // Uscite PWM
msg_tx[9] = (x1_pwm & 0xFF00) >> 8;
msg_tx[10] = (x1_pwm & 0xFF);
break;
case C_EMPTY:
default:
msg_tx[9] = 0;
msg_tx[10] = 0;
break;
}
// X2
switch (xn_config[1]) {
case C_OUT: // Uscite digitali
msg_tx[11] = 0;
// msg_tx[12] = ((x2_o1 & 0x01) << 1) | (x2_o2 & 0x01); 04-12-2018
msg_tx[12] = ((x2_o2 & 0x01) << 1) | (x2_o1 & 0x01); // 04-12-2018
break;
case C_PWM: // Uscite PWM
msg_tx[11] = (x2_pwm & 0xFF00) >> 8;
msg_tx[12] = (x2_pwm & 0xFF);
break;
case C_EMPTY:
default:
msg_tx[11] = 0;
msg_tx[12] = 0;
break;
}
// X3
switch (xn_config[2]) {
case C_OUT: // Uscite digitali
msg_tx[13] = 0;
// msg_tx[14] = ((x3_o1 & 0x01) << 1) | (x3_o2 & 0x01); 04-12-2018
msg_tx[14] = ((x3_o2 & 0x01) << 1) | (x3_o1 & 0x01); // 04-12-2018
break;
case C_PWM: // Uscite PWM
msg_tx[13] = (x3_pwm & 0xFF00) >> 8;
msg_tx[14] = (x3_pwm & 0xFF);
break;
case C_EMPTY:
default:
msg_tx[13] = 0;
msg_tx[14] = 0;
break;
}
// X4
switch (xn_config[3]) {
case C_OUT: // Uscite digitali
msg_tx[15] = 0;
// msg_tx[16] = ((x4_o1 & 0x01) << 1) | (x4_o2 & 0x01); 04-12-2018
msg_tx[16] = ((x4_o2 & 0x01) << 1) | (x4_o1 & 0x01); // 04-12-2018
break;
case C_PWM: // Uscite PWM
msg_tx[15] = (x4_pwm & 0xFF00) >> 8;
msg_tx[16] = (x4_pwm & 0xFF);
break;
case C_EMPTY:
default:
msg_tx[15] = 0;
msg_tx[16] = 0;
break;
}
// X5
switch (xn_config[4]) {
case C_OUT: // Uscite digitali
msg_tx[17] = 0;
// msg_tx[18] = ((x5_o1 & 0x01) << 1) | (x5_o2 & 0x01); // 04-12-2018
msg_tx[18] = ((x5_o2 & 0x01) << 1) | (x5_o1 & 0x01); // 04-12-2018
break;
case C_PWM: // Uscite PWM
msg_tx[17] = (x5_pwm & 0xFF00) >> 8;
msg_tx[18] = (x5_pwm & 0xFF);
break;
case C_EMPTY:
default:
msg_tx[17] = 0;
msg_tx[18] = 0;
break;
}
// X6
switch (xn_config[5]) {
case C_OUT: // Uscite digitali
msg_tx[19] = 0;
// msg_tx[20] = ((x6_o1 & 0x01) << 1) | (x6_o2 & 0x01); // 04-12-2018
msg_tx[20] = ((x6_o2 & 0x01) << 1) | (x6_o1 & 0x01); // 04-12-2018
break;
case C_PWM: // Uscite PWM
msg_tx[19] = (x6_pwm & 0xFF00) >> 8;
msg_tx[20] = (x6_pwm & 0xFF);
break;
case C_EMPTY:
default:
msg_tx[19] = 0;
msg_tx[20] = 0;
break;
}
// X7
switch (xn_config[6]) {
case C_OUT: // Uscite digitali
msg_tx[21] = 0;
// msg_tx[22] = ((x7_o1 & 0x01) << 1) | (x7_o2 & 0x01); 04-12-2018
msg_tx[22] = ((x7_o2 & 0x01) << 1) | (x7_o1 & 0x01); // 04-12-2018
break;
case C_PWM: // Uscite PWM
msg_tx[21] = (x7_pwm & 0xFF00) >> 8;
msg_tx[22] = (x7_pwm & 0xFF);
break;
case C_EMPTY:
default:
msg_tx[21] = 0;
msg_tx[22] = 0;
break;
}
// X8
switch (xn_config[7]) {
case C_OUT: // Uscite digitali
msg_tx[23] = 0;
// msg_tx[24] = ((x8_o1 & 0x01) << 1) | (x8_o2 & 0x01); 04-12-2018
msg_tx[24] = ((x8_o2 & 0x01) << 1) | (x8_o1 & 0x01); // 04-12-2018
break;
case C_PWM: // Uscite PWM
msg_tx[23] = (x8_pwm & 0xFF00) >> 8;
msg_tx[24] = (x8_pwm & 0xFF);
break;
case C_EMPTY:
default:
msg_tx[23] = 0;
msg_tx[24] = 0;
break;
}
// SPI OUT
//int i,j;
for (i=25, j=0; i<33; i++, j+=8) {
msg_tx[i] = ( ((*p__o__[j]) & 0x01) << 7 |
((*p__o__[j+1]) & 0x01) << 6 |
((*p__o__[j+2]) & 0x01) << 5 |
((*p__o__[j+3]) & 0x01) << 4 |
((*p__o__[j+4]) & 0x01) << 3 |
((*p__o__[j+5]) & 0x01) << 2 |
((*p__o__[j+6]) & 0x01) << 1 |
((*p__o__[j+7]) & 0x01) << 0 );
}
// Valutazione richiesta reset
if (puzzle_reset) {
puzzle_reset=0;
msg_tx[39] = 0xFF;
msg_tx[40] = 0xAA;
} else {
msg_tx[39] = 0;
msg_tx[40] = 0;
}
// FINE
//msg_tx[DIM_TX-1] = END_TX;
}
volatile char config_sent = 0;
volatile char trigger_tx = 0;
int puzzle_task_cnt=0;
void puzzle_task()
{
while(1) {
puzzle_task_cnt++;
create_tx();
tx_cmd_msg(CMD_DRIVE);
if (puzzle_disc_cnt < 200) {
puzzle_disc_cnt++;
puzzle_perif_on = 1;
} else {
puzzle_perif_on = 0;
}
every(20);
}
}
void puzzle_start()
{
puzzle_com = P_RS485;
Com = PortaCOM;
install_port();
serial_port_on = 1;
exec_task(puzzle_task, 0, 4);
}
void puzzle_stop()
{
//remove_timer(rw_puzzle);
remove_task(puzzle_task);
com_close(Com);
com_disable(Com);
}
//------------------ MULTI PERIF --------------------------------
// BUFFER UNIVERSALE (perif 50)
volatile char p50_xn_config[] = { C_EMPTY, C_EMPTY, C_EMPTY, C_EMPTY,
C_EMPTY, C_EMPTY, C_EMPTY, C_EMPTY};
volatile long p50_encoder1, p50_encoder2;
// EXP - INGRESSI E USCITE
volatile U32 p50_i_low, p50_i_high;
volatile U32 p50_o_low, p50_o_high;
// Input analogici
volatile int p50_x1_anal, p50_x2_anal, p50_x3_anal, p50_x4_anal, p50_x5_anal, p50_x6_anal, p50_x7_anal, p50_x8_anal;
volatile int* p50__xn_anal__[] = {&p50_x1_anal, &p50_x2_anal, &p50_x3_anal, &p50_x4_anal, &p50_x5_anal, &p50_x6_anal, &p50_x7_anal, &p50_x8_anal};
// PT100 RAW
volatile int p50_x1_pt100_raw, p50_x2_pt100_raw, p50_x3_pt100_raw, p50_x4_pt100_raw,
p50_x5_pt100_raw, p50_x6_pt100_raw, p50_x7_pt100_raw, p50_x8_pt100_raw;
volatile int* p50__xn_pt100_raw__[] = {&p50_x1_pt100_raw, &p50_x2_pt100_raw, &p50_x3_pt100_raw, &p50_x4_pt100_raw,
&p50_x5_pt100_raw, &p50_x6_pt100_raw, &p50_x7_pt100_raw, &p50_x8_pt100_raw};
// PT100 CELSIUS
float p50_x1_pt100, p50_x2_pt100, p50_x3_pt100, p50_x4_pt100, p50_x5_pt100, p50_x6_pt100, p50_x7_pt100, p50_x8_pt100;
volatile float* p50__xn_pt100__[] = {&p50_x1_pt100, &p50_x2_pt100, &p50_x3_pt100, &p50_x4_pt100, &p50_x5_pt100, &p50_x6_pt100, &p50_x7_pt100, &p50_x8_pt100};
// Ingressi digitali XN
volatile char p50_x1_digin, p50_x2_digin, p50_x3_digin, p50_x4_digin,
p50_x5_digin, p50_x6_digin, p50_x7_digin, p50_x8_digin;
volatile char p50_x1_i1, p50_x1_i2, p50_x2_i1, p50_x2_i2, p50_x3_i1, p50_x3_i2, p50_x4_i1, p50_x4_i2,
p50_x5_i1, p50_x5_i2, p50_x6_i1, p50_x6_i2, p50_x7_i1, p50_x7_i2, p50_x8_i1, p50_x8_i2;
// Uscite digitali XN
volatile char p50_x1_o1, p50_x1_o2, p50_x2_o1, p50_x2_o2, p50_x3_o1, p50_x3_o2, p50_x4_o1, p50_x4_o2,
p50_x5_o1, p50_x5_o2, p50_x6_o1, p50_x6_o2, p50_x7_o1, p50_x7_o2, p50_x8_o1, p50_x8_o2;
// Uscite PWM
volatile U16 p50_x1_pwm = 2048;
volatile U16 p50_x2_pwm = 2048;
volatile U16 p50_x3_pwm = 2048;
volatile U16 p50_x4_pwm = 2048;
volatile U16 p50_x5_pwm = 2048;
volatile U16 p50_x6_pwm = 2048;
volatile U16 p50_x7_pwm = 2048;
volatile U16 p50_x8_pwm = 2048;
U16 *p50__xn_pwms__[] = {&p50_x1_pwm, &p50_x2_pwm, &p50_x3_pwm, &p50_x4_pwm, &p50_x5_pwm, &p50_x6_pwm, &p50_x7_pwm, &p50_x8_pwm};
#if PUZZLE_PERIFS >= 2
volatile char p1_xn_config[] = { C_EMPTY, C_EMPTY, C_EMPTY, C_EMPTY,
C_EMPTY, C_EMPTY, C_EMPTY, C_EMPTY};
volatile long p1_encoder1, p1_encoder2;
// EXP - INGRESSI E USCITE
volatile char p1_i1, p1_i2, p1_i3, p1_i4, p1_i5, p1_i6, p1_i7, p1_i8, p1_i9, p1_i10, p1_i11,
p1_i12, p1_i13, p1_i14, p1_i15, p1_i16, p1_i17, p1_i18, p1_i19, p1_i20, p1_i21,
p1_i22, p1_i23, p1_i24, p1_i25, p1_i26, p1_i27, p1_i28, p1_i29, p1_i30, p1_i31,
p1_i32, p1_i33, p1_i34, p1_i35, p1_i36, p1_i37, p1_i38, p1_i39, p1_i40, p1_i41,
p1_i42, p1_i43, p1_i44, p1_i45, p1_i46, p1_i47, p1_i48, p1_i49, p1_i50, p1_i51,
p1_i52, p1_i53, p1_i54, p1_i55, p1_i56, p1_i57, p1_i58, p1_i59, p1_i60, p1_i61,
p1_i62, p1_i63, p1_i64;
volatile unsigned char *p1__i__[] = {&p1_i1, &p1_i2, &p1_i3, &p1_i4, &p1_i5,
&p1_i6, &p1_i7, &p1_i8, &p1_i9, &p1_i10,
&p1_i11, &p1_i12, &p1_i13, &p1_i14, &p1_i15,
&p1_i16, &p1_i17, &p1_i18, &p1_i19, &p1_i20,
&p1_i21, &p1_i22, &p1_i23, &p1_i24, &p1_i25,
&p1_i26, &p1_i27, &p1_i28, &p1_i29, &p1_i30,
&p1_i31, &p1_i32, &p1_i33, &p1_i34, &p1_i35,
&p1_i36, &p1_i37, &p1_i38, &p1_i39, &p1_i40,
&p1_i41, &p1_i42, &p1_i43, &p1_i44, &p1_i45,
&p1_i46, &p1_i47, &p1_i48, &p1_i49, &p1_i50,
&p1_i51, &p1_i52, &p1_i53, &p1_i54, &p1_i55,
&p1_i56, &p1_i57, &p1_i58, &p1_i59, &p1_i60,
&p1_i61, &p1_i62, &p1_i63, &p1_i64};
volatile char p1_o1, p1_o2, p1_o3, p1_o4, p1_o5, p1_o6, p1_o7, p1_o8, p1_o9, p1_o10,
p1_o11, p1_o12, p1_o13, p1_o14, p1_o15, p1_o16, p1_o17, p1_o18, p1_o19, p1_o20,
p1_o21, p1_o22, p1_o23, p1_o24, p1_o25, p1_o26, p1_o27, p1_o28, p1_o29, p1_o30,
p1_o31, p1_o32, p1_o33, p1_o34, p1_o35, p1_o36, p1_o37, p1_o38, p1_o39, p1_o40,
p1_o41, p1_o42, p1_o43, p1_o44, p1_o45, p1_o46, p1_o47, p1_o48, p1_o49, p1_o50,
p1_o51, p1_o52, p1_o53, p1_o54, p1_o55, p1_o56, p1_o57, p1_o58, p1_o59, p1_o60,
p1_o61, p1_o62, p1_o63, p1_o64;
volatile unsigned char *p1__o__[] = {&p1_o1, &p1_o2, &p1_o3, &p1_o4, &p1_o5,
&p1_o6, &p1_o7, &p1_o8, &p1_o9, &p1_o10,
&p1_o11, &p1_o12, &p1_o13, &p1_o14, &p1_o15,
&p1_o16, &p1_o17, &p1_o18, &p1_o19, &p1_o20,
&p1_o21, &p1_o22, &p1_o23, &p1_o24, &p1_o25,
&p1_o26, &p1_o27, &p1_o28, &p1_o29, &p1_o30,
&p1_o31, &p1_o32, &p1_o33, &p1_o34, &p1_o35,
&p1_o36, &p1_o37, &p1_o38, &p1_o39, &p1_o40,
&p1_o41, &p1_o42, &p1_o43, &p1_o44, &p1_o45,
&p1_o46, &p1_o47, &p1_o48, &p1_o49, &p1_o50,
&p1_o51, &p1_o52, &p1_o53, &p1_o54, &p1_o55,
&p1_o56, &p1_o57, &p1_o58, &p1_o59, &p1_o60,
&p1_o61, &p1_o62, &p1_o63, &p1_o64};
// Input analogici
volatile int p1_x1_anal, p1_x2_anal, p1_x3_anal, p1_x4_anal, p1_x5_anal, p1_x6_anal, p1_x7_anal, p1_x8_anal;
volatile int* p1__xn_anal__[] = {&p1_x1_anal, &p1_x2_anal, &p1_x3_anal, &p1_x4_anal, &p1_x5_anal, &p1_x6_anal, &p1_x7_anal, &p1_x8_anal};
// PT100 RAW
volatile int p1_x1_pt100_raw, p1_x2_pt100_raw, p1_x3_pt100_raw, p1_x4_pt100_raw,
p1_x5_pt100_raw, p1_x6_pt100_raw, p1_x7_pt100_raw, p1_x8_pt100_raw;
volatile int* p1__xn_pt100_raw__[] = {&p1_x1_pt100_raw, &p1_x2_pt100_raw, &p1_x3_pt100_raw, &p1_x4_pt100_raw,
&p1_x5_pt100_raw, &p1_x6_pt100_raw, &p1_x7_pt100_raw, &p1_x8_pt100_raw};
// PT100 CELSIUS
float p1_x1_pt100, p1_x2_pt100, p1_x3_pt100, p1_x4_pt100, p1_x5_pt100, p1_x6_pt100, p1_x7_pt100, p1_x8_pt100;
volatile float* p1__xn_pt100__[] = {&p1_x1_pt100, &p1_x2_pt100, &p1_x3_pt100, &p1_x4_pt100, &p1_x5_pt100, &p1_x6_pt100, &p1_x7_pt100, &p1_x8_pt100};
// Ingressi digitali XN
volatile char p1_x1_digin, p1_x2_digin, p1_x3_digin, p1_x4_digin,
p1_x5_digin, p1_x6_digin, p1_x7_digin, p1_x8_digin;
volatile char *p1__xn_digin__[] = {&p1_x1_digin, &p1_x2_digin, &p1_x3_digin, &p1_x4_digin,
&p1_x5_digin, &p1_x6_digin, &p1_x7_digin, &p1_x8_digin};
volatile char p1_x1_i1, p1_x1_i2, p1_x2_i1, p1_x2_i2, p1_x3_i1, p1_x3_i2, p1_x4_i1, p1_x4_i2,
p1_x5_i1, p1_x5_i2, p1_x6_i1, p1_x6_i2, p1_x7_i1, p1_x7_i2, p1_x8_i1, p1_x8_i2;
// Uscite digitali XN
volatile char p1_x1_o1, p1_x1_o2, p1_x2_o1, p1_x2_o2, p1_x3_o1, p1_x3_o2, p1_x4_o1, p1_x4_o2,
p1_x5_o1, p1_x5_o2, p1_x6_o1, p1_x6_o2, p1_x7_o1, p1_x7_o2, p1_x8_o1, p1_x8_o2;
char *p1__xn_outs__[] = {&p1_x1_o1, &p1_x1_o2, &p1_x2_o1, &p1_x2_o2, &p1_x3_o1, &p1_x3_o2, &p1_x4_o1, &p1_x4_o2,
&p1_x5_o1, &p1_x5_o2, &p1_x6_o1, &p1_x6_o2, &p1_x7_o1, &p1_x7_o2, &p1_x8_o1, &p1_x8_o2};
// Uscite PWM
volatile U16 p1_x1_pwm = 2048;
volatile U16 p1_x2_pwm = 2048;
volatile U16 p1_x3_pwm = 2048;
volatile U16 p1_x4_pwm = 2048;
volatile U16 p1_x5_pwm = 2048;
volatile U16 p1_x6_pwm = 2048;
volatile U16 p1_x7_pwm = 2048;
volatile U16 p1_x8_pwm = 2048;
U16 *p1__xn_pwms__[] = {&p1_x1_pwm, &p1_x2_pwm, &p1_x3_pwm, &p1_x4_pwm, &p1_x5_pwm, &p1_x6_pwm, &p1_x7_pwm, &p1_x8_pwm};
#endif
#if PUZZLE_PERIFS >= 3
volatile char p2_xn_config[] = { C_EMPTY, C_EMPTY, C_EMPTY, C_EMPTY,
C_EMPTY, C_EMPTY, C_EMPTY, C_EMPTY};
volatile long p2_encoder1, p2_encoder2;
// EXP - INGRESSI E USCITE
volatile char p2_i1, p2_i2, p2_i3, p2_i4, p2_i5, p2_i6, p2_i7, p2_i8, p2_i9, p2_i10, p2_i11,
p2_i12, p2_i13, p2_i14, p2_i15, p2_i16, p2_i17, p2_i18, p2_i19, p2_i20, p2_i21,
p2_i22, p2_i23, p2_i24, p2_i25, p2_i26, p2_i27, p2_i28, p2_i29, p2_i30, p2_i31,
p2_i32, p2_i33, p2_i34, p2_i35, p2_i36, p2_i37, p2_i38, p2_i39, p2_i40, p2_i41,
p2_i42, p2_i43, p2_i44, p2_i45, p2_i46, p2_i47, p2_i48, p2_i49, p2_i50, p2_i51,
p2_i52, p2_i53, p2_i54, p2_i55, p2_i56, p2_i57, p2_i58, p2_i59, p2_i60, p2_i61,
p2_i62, p2_i63, p2_i64;
volatile unsigned char *p2__i__[] = {&p2_i1, &p2_i2, &p2_i3, &p2_i4, &p2_i5,
&p2_i6, &p2_i7, &p2_i8, &p2_i9, &p2_i10,
&p2_i11, &p2_i12, &p2_i13, &p2_i14, &p2_i15,
&p2_i16, &p2_i17, &p2_i18, &p2_i19, &p2_i20,
&p2_i21, &p2_i22, &p2_i23, &p2_i24, &p2_i25,
&p2_i26, &p2_i27, &p2_i28, &p2_i29, &p2_i30,
&p2_i31, &p2_i32, &p2_i33, &p2_i34, &p2_i35,
&p2_i36, &p2_i37, &p2_i38, &p2_i39, &p2_i40,
&p2_i41, &p2_i42, &p2_i43, &p2_i44, &p2_i45,
&p2_i46, &p2_i47, &p2_i48, &p2_i49, &p2_i50,
&p2_i51, &p2_i52, &p2_i53, &p2_i54, &p2_i55,
&p2_i56, &p2_i57, &p2_i58, &p2_i59, &p2_i60,
&p2_i61, &p2_i62, &p2_i63, &p2_i64};
volatile char p2_o1, p2_o2, p2_o3, p2_o4, p2_o5, p2_o6, p2_o7, p2_o8, p2_o9, p2_o10,
p2_o11, p2_o12, p2_o13, p2_o14, p2_o15, p2_o16, p2_o17, p2_o18, p2_o19, p2_o20,
p2_o21, p2_o22, p2_o23, p2_o24, p2_o25, p2_o26, p2_o27, p2_o28, p2_o29, p2_o30,
p2_o31, p2_o32, p2_o33, p2_o34, p2_o35, p2_o36, p2_o37, p2_o38, p2_o39, p2_o40,
p2_o41, p2_o42, p2_o43, p2_o44, p2_o45, p2_o46, p2_o47, p2_o48, p2_o49, p2_o50,
p2_o51, p2_o52, p2_o53, p2_o54, p2_o55, p2_o56, p2_o57, p2_o58, p2_o59, p2_o60,
p2_o61, p2_o62, p2_o63, p2_o64;
volatile unsigned char *p2__o__[] = {&p2_o1, &p2_o2, &p2_o3, &p2_o4, &p2_o5,
&p2_o6, &p2_o7, &p2_o8, &p2_o9, &p2_o10,
&p2_o11, &p2_o12, &p2_o13, &p2_o14, &p2_o15,
&p2_o16, &p2_o17, &p2_o18, &p2_o19, &p2_o20,
&p2_o21, &p2_o22, &p2_o23, &p2_o24, &p2_o25,
&p2_o26, &p2_o27, &p2_o28, &p2_o29, &p2_o30,
&p2_o31, &p2_o32, &p2_o33, &p2_o34, &p2_o35,
&p2_o36, &p2_o37, &p2_o38, &p2_o39, &p2_o40,
&p2_o41, &p2_o42, &p2_o43, &p2_o44, &p2_o45,
&p2_o46, &p2_o47, &p2_o48, &p2_o49, &p2_o50,
&p2_o51, &p2_o52, &p2_o53, &p2_o54, &p2_o55,
&p2_o56, &p2_o57, &p2_o58, &p2_o59, &p2_o60,
&p2_o61, &p2_o62, &p2_o63, &p2_o64};
// Input analogici
volatile int p2_x1_anal, p2_x2_anal, p2_x3_anal, p2_x4_anal, p2_x5_anal, p2_x6_anal, p2_x7_anal, p2_x8_anal;
volatile int* p2__xn_anal__[] = {&p2_x1_anal, &p2_x2_anal, &p2_x3_anal, &p2_x4_anal, &p2_x5_anal, &p2_x6_anal, &p2_x7_anal, &p2_x8_anal};
// PT100 RAW
volatile int p2_x1_pt100_raw, p2_x2_pt100_raw, p2_x3_pt100_raw, p2_x4_pt100_raw,
p2_x5_pt100_raw, p2_x6_pt100_raw, p2_x7_pt100_raw, p2_x8_pt100_raw;
volatile int* p2__xn_pt100_raw__[] = {&p2_x1_pt100_raw, &p2_x2_pt100_raw, &p2_x3_pt100_raw, &p2_x4_pt100_raw,
&p2_x5_pt100_raw, &p2_x6_pt100_raw, &p2_x7_pt100_raw, &p2_x8_pt100_raw};
// PT100 CELSIUS
float p2_x1_pt100, p2_x2_pt100, p2_x3_pt100, p2_x4_pt100, p2_x5_pt100, p2_x6_pt100, p2_x7_pt100, p2_x8_pt100;
volatile float* p2__xn_pt100__[] = {&p2_x1_pt100, &p2_x2_pt100, &p2_x3_pt100, &p2_x4_pt100, &p2_x5_pt100, &p2_x6_pt100, &p2_x7_pt100, &p2_x8_pt100};
// Ingressi digitali XN
volatile char p2_x1_digin, p2_x2_digin, p2_x3_digin, p2_x4_digin,
p2_x5_digin, p2_x6_digin, p2_x7_digin, p2_x8_digin;
volatile char *p2__xn_digin__[] = {&p2_x1_digin, &p2_x2_digin, &p2_x3_digin, &p2_x4_digin,
&p2_x5_digin, &p2_x6_digin, &p2_x7_digin, &p2_x8_digin};
volatile char p2_x1_i1, p2_x1_i2, p2_x2_i1, p2_x2_i2, p2_x3_i1, p2_x3_i2, p2_x4_i1, p2_x4_i2,
p2_x5_i1, p2_x5_i2, p2_x6_i1, p2_x6_i2, p2_x7_i1, p2_x7_i2, p2_x8_i1, p2_x8_i2;
// Uscite digitali XN
volatile char p2_x1_o1, p2_x1_o2, p2_x2_o1, p2_x2_o2, p2_x3_o1, p2_x3_o2, p2_x4_o1, p2_x4_o2,
p2_x5_o1, p2_x5_o2, p2_x6_o1, p2_x6_o2, p2_x7_o1, p2_x7_o2, p2_x8_o1, p2_x8_o2;
char *p2__xn_outs__[] = {&p2_x1_o1, &p2_x1_o2, &p2_x2_o1, &p2_x2_o2, &p2_x3_o1, &p2_x3_o2, &p2_x4_o1, &p2_x4_o2,
&p2_x5_o1, &p2_x5_o2, &p2_x6_o1, &p2_x6_o2, &p2_x7_o1, &p2_x7_o2, &p2_x8_o1, &p2_x8_o2};
// Uscite PWM
volatile U16 p2_x1_pwm = 2048;
volatile U16 p2_x2_pwm = 2048;
volatile U16 p2_x3_pwm = 2048;
volatile U16 p2_x4_pwm = 2048;
volatile U16 p2_x5_pwm = 2048;
volatile U16 p2_x6_pwm = 2048;
volatile U16 p2_x7_pwm = 2048;
volatile U16 p2_x8_pwm = 2048;
U16 *p2__xn_pwms__[] = {&p2_x1_pwm, &p2_x2_pwm, &p2_x3_pwm, &p2_x4_pwm, &p2_x5_pwm, &p2_x6_pwm, &p2_x7_pwm, &p2_x8_pwm};
#endif
#if PUZZLE_PERIFS >= 4
volatile char p3_xn_config[] = { C_EMPTY, C_EMPTY, C_EMPTY, C_EMPTY,
C_EMPTY, C_EMPTY, C_EMPTY, C_EMPTY};
volatile long p3_encoder1, p3_encoder2;
// EXP - INGRESSI E USCITE
volatile char p3_i1, p3_i2, p3_i3, p3_i4, p3_i5, p3_i6, p3_i7, p3_i8, p3_i9, p3_i10, p3_i11,
p3_i12, p3_i13, p3_i14, p3_i15, p3_i16, p3_i17, p3_i18, p3_i19, p3_i20, p3_i21,
p3_i22, p3_i23, p3_i24, p3_i25, p3_i26, p3_i27, p3_i28, p3_i29, p3_i30, p3_i31,
p3_i32, p3_i33, p3_i34, p3_i35, p3_i36, p3_i37, p3_i38, p3_i39, p3_i40, p3_i41,
p3_i42, p3_i43, p3_i44, p3_i45, p3_i46, p3_i47, p3_i48, p3_i49, p3_i50, p3_i51,
p3_i52, p3_i53, p3_i54, p3_i55, p3_i56, p3_i57, p3_i58, p3_i59, p3_i60, p3_i61,
p3_i62, p3_i63, p3_i64;
volatile unsigned char *p3__i__[] = {&p3_i1, &p3_i2, &p3_i3, &p3_i4, &p3_i5,
&p3_i6, &p3_i7, &p3_i8, &p3_i9, &p3_i10,
&p3_i11, &p3_i12, &p3_i13, &p3_i14, &p3_i15,
&p3_i16, &p3_i17, &p3_i18, &p3_i19, &p3_i20,
&p3_i21, &p3_i22, &p3_i23, &p3_i24, &p3_i25,
&p3_i26, &p3_i27, &p3_i28, &p3_i29, &p3_i30,
&p3_i31, &p3_i32, &p3_i33, &p3_i34, &p3_i35,
&p3_i36, &p3_i37, &p3_i38, &p3_i39, &p3_i40,
&p3_i41, &p3_i42, &p3_i43, &p3_i44, &p3_i45,
&p3_i46, &p3_i47, &p3_i48, &p3_i49, &p3_i50,
&p3_i51, &p3_i52, &p3_i53, &p3_i54, &p3_i55,
&p3_i56, &p3_i57, &p3_i58, &p3_i59, &p3_i60,
&p3_i61, &p3_i62, &p3_i63, &p3_i64};
volatile char p3_o1, p3_o2, p3_o3, p3_o4, p3_o5, p3_o6, p3_o7, p3_o8, p3_o9, p3_o10,
p3_o11, p3_o12, p3_o13, p3_o14, p3_o15, p3_o16, p3_o17, p3_o18, p3_o19, p3_o20,
p3_o21, p3_o22, p3_o23, p3_o24, p3_o25, p3_o26, p3_o27, p3_o28, p3_o29, p3_o30,
p3_o31, p3_o32, p3_o33, p3_o34, p3_o35, p3_o36, p3_o37, p3_o38, p3_o39, p3_o40,
p3_o41, p3_o42, p3_o43, p3_o44, p3_o45, p3_o46, p3_o47, p3_o48, p3_o49, p3_o50,
p3_o51, p3_o52, p3_o53, p3_o54, p3_o55, p3_o56, p3_o57, p3_o58, p3_o59, p3_o60,
p3_o61, p3_o62, p3_o63, p3_o64;
volatile unsigned char *p3__o__[] = {&p3_o1, &p3_o2, &p3_o3, &p3_o4, &p3_o5,
&p3_o6, &p3_o7, &p3_o8, &p3_o9, &p3_o10,
&p3_o11, &p3_o12, &p3_o13, &p3_o14, &p3_o15,
&p3_o16, &p3_o17, &p3_o18, &p3_o19, &p3_o20,
&p3_o21, &p3_o22, &p3_o23, &p3_o24, &p3_o25,
&p3_o26, &p3_o27, &p3_o28, &p3_o29, &p3_o30,
&p3_o31, &p3_o32, &p3_o33, &p3_o34, &p3_o35,
&p3_o36, &p3_o37, &p3_o38, &p3_o39, &p3_o40,
&p3_o41, &p3_o42, &p3_o43, &p3_o44, &p3_o45,
&p3_o46, &p3_o47, &p3_o48, &p3_o49, &p3_o50,
&p3_o51, &p3_o52, &p3_o53, &p3_o54, &p3_o55,
&p3_o56, &p3_o57, &p3_o58, &p3_o59, &p3_o60,
&p3_o61, &p3_o62, &p3_o63, &p3_o64};
// Input analogici
volatile int p3_x1_anal, p3_x2_anal, p3_x3_anal, p3_x4_anal, p3_x5_anal, p3_x6_anal, p3_x7_anal, p3_x8_anal;
volatile int* p3__xn_anal__[] = {&p3_x1_anal, &p3_x2_anal, &p3_x3_anal, &p3_x4_anal, &p3_x5_anal, &p3_x6_anal, &p3_x7_anal, &p3_x8_anal};
// PT100 RAW
volatile int p3_x1_pt100_raw, p3_x2_pt100_raw, p3_x3_pt100_raw, p3_x4_pt100_raw,
p3_x5_pt100_raw, p3_x6_pt100_raw, p3_x7_pt100_raw, p3_x8_pt100_raw;
volatile int* p3__xn_pt100_raw__[] = {&p3_x1_pt100_raw, &p3_x2_pt100_raw, &p3_x3_pt100_raw, &p3_x4_pt100_raw,
&p3_x5_pt100_raw, &p3_x6_pt100_raw, &p3_x7_pt100_raw, &p3_x8_pt100_raw};
// PT100 CELSIUS
float p3_x1_pt100, p3_x2_pt100, p3_x3_pt100, p3_x4_pt100, p3_x5_pt100, p3_x6_pt100, p3_x7_pt100, p3_x8_pt100;
volatile float* p3__xn_pt100__[] = {&p3_x1_pt100, &p3_x2_pt100, &p3_x3_pt100, &p3_x4_pt100, &p3_x5_pt100, &p3_x6_pt100, &p3_x7_pt100, &p3_x8_pt100};
// Ingressi digitali XN
volatile char p3_x1_digin, p3_x2_digin, p3_x3_digin, p3_x4_digin,
p3_x5_digin, p3_x6_digin, p3_x7_digin, p3_x8_digin;
volatile char *p3__xn_digin__[] = {&p3_x1_digin, &p3_x2_digin, &p3_x3_digin, &p3_x4_digin,
&p3_x5_digin, &p3_x6_digin, &p3_x7_digin, &p3_x8_digin};
volatile char p3_x1_i1, p3_x1_i2, p3_x2_i1, p3_x2_i2, p3_x3_i1, p3_x3_i2, p3_x4_i1, p3_x4_i2,
p3_x5_i1, p3_x5_i2, p3_x6_i1, p3_x6_i2, p3_x7_i1, p3_x7_i2, p3_x8_i1, p3_x8_i2;
// Uscite digitali XN
volatile char p3_x1_o1, p3_x1_o2, p3_x2_o1, p3_x2_o2, p3_x3_o1, p3_x3_o2, p3_x4_o1, p3_x4_o2,
p3_x5_o1, p3_x5_o2, p3_x6_o1, p3_x6_o2, p3_x7_o1, p3_x7_o2, p3_x8_o1, p3_x8_o2;
char *p3__xn_outs__[] = {&p3_x1_o1, &p3_x1_o2, &p3_x2_o1, &p3_x2_o2, &p3_x3_o1, &p3_x3_o2, &p3_x4_o1, &p3_x4_o2,
&p3_x5_o1, &p3_x5_o2, &p3_x6_o1, &p3_x6_o2, &p3_x7_o1, &p3_x7_o2, &p3_x8_o1, &p3_x8_o2};
// Uscite PWM
volatile U16 p3_x1_pwm = 2048;
volatile U16 p3_x2_pwm = 2048;
volatile U16 p3_x3_pwm = 2048;
volatile U16 p3_x4_pwm = 2048;
volatile U16 p3_x5_pwm = 2048;
volatile U16 p3_x6_pwm = 2048;
volatile U16 p3_x7_pwm = 2048;
volatile U16 p3_x8_pwm = 2048;
U16 *p3__xn_pwms__[] = {&p3_x1_pwm, &p3_x2_pwm, &p3_x3_pwm, &p3_x4_pwm, &p3_x5_pwm, &p3_x6_pwm, &p3_x7_pwm, &p3_x8_pwm};
#endif
#if PUZZLE_PERIFS >= 5
volatile char p4_xn_config[] = { C_EMPTY, C_EMPTY, C_EMPTY, C_EMPTY,
C_EMPTY, C_EMPTY, C_EMPTY, C_EMPTY};
volatile long p4_encoder1, p4_encoder2;
// EXP - INGRESSI E USCITE
volatile char p4_i1, p4_i2, p4_i3, p4_i4, p4_i5, p4_i6, p4_i7, p4_i8, p4_i9, p4_i10, p4_i11,
p4_i12, p4_i13, p4_i14, p4_i15, p4_i16, p4_i17, p4_i18, p4_i19, p4_i20, p4_i21,
p4_i22, p4_i23, p4_i24, p4_i25, p4_i26, p4_i27, p4_i28, p4_i29, p4_i30, p4_i31,
p4_i32, p4_i33, p4_i34, p4_i35, p4_i36, p4_i37, p4_i38, p4_i39, p4_i40, p4_i41,
p4_i42, p4_i43, p4_i44, p4_i45, p4_i46, p4_i47, p4_i48, p4_i49, p4_i50, p4_i51,
p4_i52, p4_i53, p4_i54, p4_i55, p4_i56, p4_i57, p4_i58, p4_i59, p4_i60, p4_i61,
p4_i62, p4_i63, p4_i64;
volatile unsigned char *p4__i__[] = {&p4_i1, &p4_i2, &p4_i3, &p4_i4, &p4_i5,
&p4_i6, &p4_i7, &p4_i8, &p4_i9, &p4_i10,
&p4_i11, &p4_i12, &p4_i13, &p4_i14, &p4_i15,
&p4_i16, &p4_i17, &p4_i18, &p4_i19, &p4_i20,
&p4_i21, &p4_i22, &p4_i23, &p4_i24, &p4_i25,
&p4_i26, &p4_i27, &p4_i28, &p4_i29, &p4_i30,
&p4_i31, &p4_i32, &p4_i33, &p4_i34, &p4_i35,
&p4_i36, &p4_i37, &p4_i38, &p4_i39, &p4_i40,
&p4_i41, &p4_i42, &p4_i43, &p4_i44, &p4_i45,
&p4_i46, &p4_i47, &p4_i48, &p4_i49, &p4_i50,
&p4_i51, &p4_i52, &p4_i53, &p4_i54, &p4_i55,
&p4_i56, &p4_i57, &p4_i58, &p4_i59, &p4_i60,
&p4_i61, &p4_i62, &p4_i63, &p4_i64};
volatile char p4_o1, p4_o2, p4_o3, p4_o4, p4_o5, p4_o6, p4_o7, p4_o8, p4_o9, p4_o10,
p4_o11, p4_o12, p4_o13, p4_o14, p4_o15, p4_o16, p4_o17, p4_o18, p4_o19, p4_o20,
p4_o21, p4_o22, p4_o23, p4_o24, p4_o25, p4_o26, p4_o27, p4_o28, p4_o29, p4_o30,
p4_o31, p4_o32, p4_o33, p4_o34, p4_o35, p4_o36, p4_o37, p4_o38, p4_o39, p4_o40,
p4_o41, p4_o42, p4_o43, p4_o44, p4_o45, p4_o46, p4_o47, p4_o48, p4_o49, p4_o50,
p4_o51, p4_o52, p4_o53, p4_o54, p4_o55, p4_o56, p4_o57, p4_o58, p4_o59, p4_o60,
p4_o61, p4_o62, p4_o63, p4_o64;
volatile unsigned char *p4__o__[] = {&p4_o1, &p4_o2, &p4_o3, &p4_o4, &p4_o5,
&p4_o6, &p4_o7, &p4_o8, &p4_o9, &p4_o10,
&p4_o11, &p4_o12, &p4_o13, &p4_o14, &p4_o15,
&p4_o16, &p4_o17, &p4_o18, &p4_o19, &p4_o20,
&p4_o21, &p4_o22, &p4_o23, &p4_o24, &p4_o25,
&p4_o26, &p4_o27, &p4_o28, &p4_o29, &p4_o30,
&p4_o31, &p4_o32, &p4_o33, &p4_o34, &p4_o35,
&p4_o36, &p4_o37, &p4_o38, &p4_o39, &p4_o40,
&p4_o41, &p4_o42, &p4_o43, &p4_o44, &p4_o45,
&p4_o46, &p4_o47, &p4_o48, &p4_o49, &p4_o50,
&p4_o51, &p4_o52, &p4_o53, &p4_o54, &p4_o55,
&p4_o56, &p4_o57, &p4_o58, &p4_o59, &p4_o60,
&p4_o61, &p4_o62, &p4_o63, &p4_o64};
// Input analogici
volatile int p4_x1_anal, p4_x2_anal, p4_x3_anal, p4_x4_anal, p4_x5_anal, p4_x6_anal, p4_x7_anal, p4_x8_anal;
volatile int* p4__xn_anal__[] = {&p4_x1_anal, &p4_x2_anal, &p4_x3_anal, &p4_x4_anal, &p4_x5_anal, &p4_x6_anal, &p4_x7_anal, &p4_x8_anal};
// PT100 RAW
volatile int p4_x1_pt100_raw, p4_x2_pt100_raw, p4_x3_pt100_raw, p4_x4_pt100_raw,
p4_x5_pt100_raw, p4_x6_pt100_raw, p4_x7_pt100_raw, p4_x8_pt100_raw;
volatile int* p4__xn_pt100_raw__[] = {&p4_x1_pt100_raw, &p4_x2_pt100_raw, &p4_x3_pt100_raw, &p4_x4_pt100_raw,
&p4_x5_pt100_raw, &p4_x6_pt100_raw, &p4_x7_pt100_raw, &p4_x8_pt100_raw};
// PT100 CELSIUS
float p4_x1_pt100, p4_x2_pt100, p4_x3_pt100, p4_x4_pt100, p4_x5_pt100, p4_x6_pt100, p4_x7_pt100, p4_x8_pt100;
volatile float* p4__xn_pt100__[] = {&p4_x1_pt100, &p4_x2_pt100, &p4_x3_pt100, &p4_x4_pt100, &p4_x5_pt100, &p4_x6_pt100, &p4_x7_pt100, &p4_x8_pt100};
// Ingressi digitali XN
volatile char p4_x1_digin, p4_x2_digin, p4_x3_digin, p4_x4_digin,
p4_x5_digin, p4_x6_digin, p4_x7_digin, p4_x8_digin;
volatile char *p4__xn_digin__[] = {&p4_x1_digin, &p4_x2_digin, &p4_x3_digin, &p4_x4_digin,
&p4_x5_digin, &p4_x6_digin, &p4_x7_digin, &p4_x8_digin};
volatile char p4_x1_i1, p4_x1_i2, p4_x2_i1, p4_x2_i2, p4_x3_i1, p4_x3_i2, p4_x4_i1, p4_x4_i2,
p4_x5_i1, p4_x5_i2, p4_x6_i1, p4_x6_i2, p4_x7_i1, p4_x7_i2, p4_x8_i1, p4_x8_i2;
// Uscite digitali XN
volatile char p4_x1_o1, p4_x1_o2, p4_x2_o1, p4_x2_o2, p4_x3_o1, p4_x3_o2, p4_x4_o1, p4_x4_o2,
p4_x5_o1, p4_x5_o2, p4_x6_o1, p4_x6_o2, p4_x7_o1, p4_x7_o2, p4_x8_o1, p4_x8_o2;
char *p4__xn_outs__[] = {&p4_x1_o1, &p4_x1_o2, &p4_x2_o1, &p4_x2_o2, &p4_x3_o1, &p4_x3_o2, &p4_x4_o1, &p4_x4_o2,
&p4_x5_o1, &p4_x5_o2, &p4_x6_o1, &p4_x6_o2, &p4_x7_o1, &p4_x7_o2, &p4_x8_o1, &p4_x8_o2};
// Uscite PWM
volatile U16 p4_x1_pwm = 2048;
volatile U16 p4_x2_pwm = 2048;
volatile U16 p4_x3_pwm = 2048;
volatile U16 p4_x4_pwm = 2048;
volatile U16 p4_x5_pwm = 2048;
volatile U16 p4_x6_pwm = 2048;
volatile U16 p4_x7_pwm = 2048;
volatile U16 p4_x8_pwm = 2048;
U16 *p4__xn_pwms__[] = {&p4_x1_pwm, &p4_x2_pwm, &p4_x3_pwm, &p4_x4_pwm, &p4_x5_pwm, &p4_x6_pwm, &p4_x7_pwm, &p4_x8_pwm};
#endif
#if PUZZLE_PERIFS >= 6
volatile char p5_xn_config[] = { C_EMPTY, C_EMPTY, C_EMPTY, C_EMPTY,
C_EMPTY, C_EMPTY, C_EMPTY, C_EMPTY};
volatile long p5_encoder1, p5_encoder2;
// EXP - INGRESSI E USCITE
volatile char p5_i1, p5_i2, p5_i3, p5_i4, p5_i5, p5_i6, p5_i7, p5_i8, p5_i9, p5_i10, p5_i11,
p5_i12, p5_i13, p5_i14, p5_i15, p5_i16, p5_i17, p5_i18, p5_i19, p5_i20, p5_i21,
p5_i22, p5_i23, p5_i24, p5_i25, p5_i26, p5_i27, p5_i28, p5_i29, p5_i30, p5_i31,
p5_i32, p5_i33, p5_i34, p5_i35, p5_i36, p5_i37, p5_i38, p5_i39, p5_i40, p5_i41,
p5_i42, p5_i43, p5_i44, p5_i45, p5_i46, p5_i47, p5_i48, p5_i49, p5_i50, p5_i51,
p5_i52, p5_i53, p5_i54, p5_i55, p5_i56, p5_i57, p5_i58, p5_i59, p5_i60, p5_i61,
p5_i62, p5_i63, p5_i64;
volatile unsigned char *p5__i__[] = {&p5_i1, &p5_i2, &p5_i3, &p5_i4, &p5_i5,
&p5_i6, &p5_i7, &p5_i8, &p5_i9, &p5_i10,
&p5_i11, &p5_i12, &p5_i13, &p5_i14, &p5_i15,
&p5_i16, &p5_i17, &p5_i18, &p5_i19, &p5_i20,
&p5_i21, &p5_i22, &p5_i23, &p5_i24, &p5_i25,
&p5_i26, &p5_i27, &p5_i28, &p5_i29, &p5_i30,
&p5_i31, &p5_i32, &p5_i33, &p5_i34, &p5_i35,
&p5_i36, &p5_i37, &p5_i38, &p5_i39, &p5_i40,
&p5_i41, &p5_i42, &p5_i43, &p5_i44, &p5_i45,
&p5_i46, &p5_i47, &p5_i48, &p5_i49, &p5_i50,
&p5_i51, &p5_i52, &p5_i53, &p5_i54, &p5_i55,
&p5_i56, &p5_i57, &p5_i58, &p5_i59, &p5_i60,
&p5_i61, &p5_i62, &p5_i63, &p5_i64};
volatile char p5_o1, p5_o2, p5_o3, p5_o4, p5_o5, p5_o6, p5_o7, p5_o8, p5_o9, p5_o10,
p5_o11, p5_o12, p5_o13, p5_o14, p5_o15, p5_o16, p5_o17, p5_o18, p5_o19, p5_o20,
p5_o21, p5_o22, p5_o23, p5_o24, p5_o25, p5_o26, p5_o27, p5_o28, p5_o29, p5_o30,
p5_o31, p5_o32, p5_o33, p5_o34, p5_o35, p5_o36, p5_o37, p5_o38, p5_o39, p5_o40,
p5_o41, p5_o42, p5_o43, p5_o44, p5_o45, p5_o46, p5_o47, p5_o48, p5_o49, p5_o50,
p5_o51, p5_o52, p5_o53, p5_o54, p5_o55, p5_o56, p5_o57, p5_o58, p5_o59, p5_o60,
p5_o61, p5_o62, p5_o63, p5_o64;
volatile unsigned char *p5__o__[] = {&p5_o1, &p5_o2, &p5_o3, &p5_o4, &p5_o5,
&p5_o6, &p5_o7, &p5_o8, &p5_o9, &p5_o10,
&p5_o11, &p5_o12, &p5_o13, &p5_o14, &p5_o15,
&p5_o16, &p5_o17, &p5_o18, &p5_o19, &p5_o20,
&p5_o21, &p5_o22, &p5_o23, &p5_o24, &p5_o25,
&p5_o26, &p5_o27, &p5_o28, &p5_o29, &p5_o30,
&p5_o31, &p5_o32, &p5_o33, &p5_o34, &p5_o35,
&p5_o36, &p5_o37, &p5_o38, &p5_o39, &p5_o40,
&p5_o41, &p5_o42, &p5_o43, &p5_o44, &p5_o45,
&p5_o46, &p5_o47, &p5_o48, &p5_o49, &p5_o50,
&p5_o51, &p5_o52, &p5_o53, &p5_o54, &p5_o55,
&p5_o56, &p5_o57, &p5_o58, &p5_o59, &p5_o60,
&p5_o61, &p5_o62, &p5_o63, &p5_o64};
// Input analogici
volatile int p5_x1_anal, p5_x2_anal, p5_x3_anal, p5_x4_anal, p5_x5_anal, p5_x6_anal, p5_x7_anal, p5_x8_anal;
volatile int* p5__xn_anal__[] = {&p5_x1_anal, &p5_x2_anal, &p5_x3_anal, &p5_x4_anal, &p5_x5_anal, &p5_x6_anal, &p5_x7_anal, &p5_x8_anal};
// PT100 RAW
volatile int p5_x1_pt100_raw, p5_x2_pt100_raw, p5_x3_pt100_raw, p5_x4_pt100_raw,
p5_x5_pt100_raw, p5_x6_pt100_raw, p5_x7_pt100_raw, p5_x8_pt100_raw;
volatile int* p5__xn_pt100_raw__[] = {&p5_x1_pt100_raw, &p5_x2_pt100_raw, &p5_x3_pt100_raw, &p5_x4_pt100_raw,
&p5_x5_pt100_raw, &p5_x6_pt100_raw, &p5_x7_pt100_raw, &p5_x8_pt100_raw};
// PT100 CELSIUS
float p5_x1_pt100, p5_x2_pt100, p5_x3_pt100, p5_x4_pt100, p5_x5_pt100, p5_x6_pt100, p5_x7_pt100, p5_x8_pt100;
volatile float* p5__xn_pt100__[] = {&p5_x1_pt100, &p5_x2_pt100, &p5_x3_pt100, &p5_x4_pt100, &p5_x5_pt100, &p5_x6_pt100, &p5_x7_pt100, &p5_x8_pt100};
// Ingressi digitali XN
volatile char p5_x1_digin, p5_x2_digin, p5_x3_digin, p5_x4_digin,
p5_x5_digin, p5_x6_digin, p5_x7_digin, p5_x8_digin;
volatile char *p5__xn_digin__[] = {&p5_x1_digin, &p5_x2_digin, &p5_x3_digin, &p5_x4_digin,
&p5_x5_digin, &p5_x6_digin, &p5_x7_digin, &p5_x8_digin};
volatile char p5_x1_i1, p5_x1_i2, p5_x2_i1, p5_x2_i2, p5_x3_i1, p5_x3_i2, p5_x4_i1, p5_x4_i2,
p5_x5_i1, p5_x5_i2, p5_x6_i1, p5_x6_i2, p5_x7_i1, p5_x7_i2, p5_x8_i1, p5_x8_i2;
// Uscite digitali XN
volatile char p5_x1_o1, p5_x1_o2, p5_x2_o1, p5_x2_o2, p5_x3_o1, p5_x3_o2, p5_x4_o1, p5_x4_o2,
p5_x5_o1, p5_x5_o2, p5_x6_o1, p5_x6_o2, p5_x7_o1, p5_x7_o2, p5_x8_o1, p5_x8_o2;
char *p5__xn_outs__[] = {&p5_x1_o1, &p5_x1_o2, &p5_x2_o1, &p5_x2_o2, &p5_x3_o1, &p5_x3_o2, &p5_x4_o1, &p5_x4_o2,
&p5_x5_o1, &p5_x5_o2, &p5_x6_o1, &p5_x6_o2, &p5_x7_o1, &p5_x7_o2, &p5_x8_o1, &p5_x8_o2};
// Uscite PWM
volatile U16 p5_x1_pwm = 2048;
volatile U16 p5_x2_pwm = 2048;
volatile U16 p5_x3_pwm = 2048;
volatile U16 p5_x4_pwm = 2048;
volatile U16 p5_x5_pwm = 2048;
volatile U16 p5_x6_pwm = 2048;
volatile U16 p5_x7_pwm = 2048;
volatile U16 p5_x8_pwm = 2048;
U16 *p5__xn_pwms__[] = {&p5_x1_pwm, &p5_x2_pwm, &p5_x3_pwm, &p5_x4_pwm, &p5_x5_pwm, &p5_x6_pwm, &p5_x7_pwm, &p5_x8_pwm};
#endif
#if PUZZLE_PERIFS >= 7
volatile char p6_xn_config[] = { C_EMPTY, C_EMPTY, C_EMPTY, C_EMPTY,
C_EMPTY, C_EMPTY, C_EMPTY, C_EMPTY};
volatile long p6_encoder1, p6_encoder2;
// EXP - INGRESSI E USCITE
volatile char p6_i1, p6_i2, p6_i3, p6_i4, p6_i5, p6_i6, p6_i7, p6_i8, p6_i9, p6_i10, p6_i11,
p6_i12, p6_i13, p6_i14, p6_i15, p6_i16, p6_i17, p6_i18, p6_i19, p6_i20, p6_i21,
p6_i22, p6_i23, p6_i24, p6_i25, p6_i26, p6_i27, p6_i28, p6_i29, p6_i30, p6_i31,
p6_i32, p6_i33, p6_i34, p6_i35, p6_i36, p6_i37, p6_i38, p6_i39, p6_i40, p6_i41,
p6_i42, p6_i43, p6_i44, p6_i45, p6_i46, p6_i47, p6_i48, p6_i49, p6_i50, p6_i51,
p6_i52, p6_i53, p6_i54, p6_i55, p6_i56, p6_i57, p6_i58, p6_i59, p6_i60, p6_i61,
p6_i62, p6_i63, p6_i64;
volatile unsigned char *p6__i__[] = {&p6_i1, &p6_i2, &p6_i3, &p6_i4, &p6_i5,
&p6_i6, &p6_i7, &p6_i8, &p6_i9, &p6_i10,
&p6_i11, &p6_i12, &p6_i13, &p6_i14, &p6_i15,
&p6_i16, &p6_i17, &p6_i18, &p6_i19, &p6_i20,
&p6_i21, &p6_i22, &p6_i23, &p6_i24, &p6_i25,
&p6_i26, &p6_i27, &p6_i28, &p6_i29, &p6_i30,
&p6_i31, &p6_i32, &p6_i33, &p6_i34, &p6_i35,
&p6_i36, &p6_i37, &p6_i38, &p6_i39, &p6_i40,
&p6_i41, &p6_i42, &p6_i43, &p6_i44, &p6_i45,
&p6_i46, &p6_i47, &p6_i48, &p6_i49, &p6_i50,
&p6_i51, &p6_i52, &p6_i53, &p6_i54, &p6_i55,
&p6_i56, &p6_i57, &p6_i58, &p6_i59, &p6_i60,
&p6_i61, &p6_i62, &p6_i63, &p6_i64};
volatile char p6_o1, p6_o2, p6_o3, p6_o4, p6_o5, p6_o6, p6_o7, p6_o8, p6_o9, p6_o10,
p6_o11, p6_o12, p6_o13, p6_o14, p6_o15, p6_o16, p6_o17, p6_o18, p6_o19, p6_o20,
p6_o21, p6_o22, p6_o23, p6_o24, p6_o25, p6_o26, p6_o27, p6_o28, p6_o29, p6_o30,
p6_o31, p6_o32, p6_o33, p6_o34, p6_o35, p6_o36, p6_o37, p6_o38, p6_o39, p6_o40,
p6_o41, p6_o42, p6_o43, p6_o44, p6_o45, p6_o46, p6_o47, p6_o48, p6_o49, p6_o50,
p6_o51, p6_o52, p6_o53, p6_o54, p6_o55, p6_o56, p6_o57, p6_o58, p6_o59, p6_o60,
p6_o61, p6_o62, p6_o63, p6_o64;
volatile unsigned char *p6__o__[] = {&p6_o1, &p6_o2, &p6_o3, &p6_o4, &p6_o5,
&p6_o6, &p6_o7, &p6_o8, &p6_o9, &p6_o10,
&p6_o11, &p6_o12, &p6_o13, &p6_o14, &p6_o15,
&p6_o16, &p6_o17, &p6_o18, &p6_o19, &p6_o20,
&p6_o21, &p6_o22, &p6_o23, &p6_o24, &p6_o25,
&p6_o26, &p6_o27, &p6_o28, &p6_o29, &p6_o30,
&p6_o31, &p6_o32, &p6_o33, &p6_o34, &p6_o35,
&p6_o36, &p6_o37, &p6_o38, &p6_o39, &p6_o40,
&p6_o41, &p6_o42, &p6_o43, &p6_o44, &p6_o45,
&p6_o46, &p6_o47, &p6_o48, &p6_o49, &p6_o50,
&p6_o51, &p6_o52, &p6_o53, &p6_o54, &p6_o55,
&p6_o56, &p6_o57, &p6_o58, &p6_o59, &p6_o60,
&p6_o61, &p6_o62, &p6_o63, &p6_o64};
// Input analogici
volatile int p6_x1_anal, p6_x2_anal, p6_x3_anal, p6_x4_anal, p6_x5_anal, p6_x6_anal, p6_x7_anal, p6_x8_anal;
volatile int* p6__xn_anal__[] = {&p6_x1_anal, &p6_x2_anal, &p6_x3_anal, &p6_x4_anal, &p6_x5_anal, &p6_x6_anal, &p6_x7_anal, &p6_x8_anal};
// PT100 RAW
volatile int p6_x1_pt100_raw, p6_x2_pt100_raw, p6_x3_pt100_raw, p6_x4_pt100_raw,
p6_x5_pt100_raw, p6_x6_pt100_raw, p6_x7_pt100_raw, p6_x8_pt100_raw;
volatile int* p6__xn_pt100_raw__[] = {&p6_x1_pt100_raw, &p6_x2_pt100_raw, &p6_x3_pt100_raw, &p6_x4_pt100_raw,
&p6_x5_pt100_raw, &p6_x6_pt100_raw, &p6_x7_pt100_raw, &p6_x8_pt100_raw};
// PT100 CELSIUS
float p6_x1_pt100, p6_x2_pt100, p6_x3_pt100, p6_x4_pt100, p6_x5_pt100, p6_x6_pt100, p6_x7_pt100, p6_x8_pt100;
volatile float* p6__xn_pt100__[] = {&p6_x1_pt100, &p6_x2_pt100, &p6_x3_pt100, &p6_x4_pt100, &p6_x5_pt100, &p6_x6_pt100, &p6_x7_pt100, &p6_x8_pt100};
// Ingressi digitali XN
volatile char p6_x1_digin, p6_x2_digin, p6_x3_digin, p6_x4_digin,
p6_x5_digin, p6_x6_digin, p6_x7_digin, p6_x8_digin;
volatile char *p6__xn_digin__[] = {&p6_x1_digin, &p6_x2_digin, &p6_x3_digin, &p6_x4_digin,
&p6_x5_digin, &p6_x6_digin, &p6_x7_digin, &p6_x8_digin};
volatile char p6_x1_i1, p6_x1_i2, p6_x2_i1, p6_x2_i2, p6_x3_i1, p6_x3_i2, p6_x4_i1, p6_x4_i2,
p6_x5_i1, p6_x5_i2, p6_x6_i1, p6_x6_i2, p6_x7_i1, p6_x7_i2, p6_x8_i1, p6_x8_i2;
// Uscite digitali XN
volatile char p6_x1_o1, p6_x1_o2, p6_x2_o1, p6_x2_o2, p6_x3_o1, p6_x3_o2, p6_x4_o1, p6_x4_o2,
p6_x5_o1, p6_x5_o2, p6_x6_o1, p6_x6_o2, p6_x7_o1, p6_x7_o2, p6_x8_o1, p6_x8_o2;
char *p6__xn_outs__[] = {&p6_x1_o1, &p6_x1_o2, &p6_x2_o1, &p6_x2_o2, &p6_x3_o1, &p6_x3_o2, &p6_x4_o1, &p6_x4_o2,
&p6_x5_o1, &p6_x5_o2, &p6_x6_o1, &p6_x6_o2, &p6_x7_o1, &p6_x7_o2, &p6_x8_o1, &p6_x8_o2};
// Uscite PWM
volatile U16 p6_x1_pwm = 2048;
volatile U16 p6_x2_pwm = 2048;
volatile U16 p6_x3_pwm = 2048;
volatile U16 p6_x4_pwm = 2048;
volatile U16 p6_x5_pwm = 2048;
volatile U16 p6_x6_pwm = 2048;
volatile U16 p6_x7_pwm = 2048;
volatile U16 p6_x8_pwm = 2048;
U16 *p6__xn_pwms__[] = {&p6_x1_pwm, &p6_x2_pwm, &p6_x3_pwm, &p6_x4_pwm, &p6_x5_pwm, &p6_x6_pwm, &p6_x7_pwm, &p6_x8_pwm};
#endif
#if PUZZLE_PERIFS >= 8
volatile char p7_xn_config[] = { C_EMPTY, C_EMPTY, C_EMPTY, C_EMPTY,
C_EMPTY, C_EMPTY, C_EMPTY, C_EMPTY};
volatile long p7_encoder1, p7_encoder2;
// EXP - INGRESSI E USCITE
volatile char p7_i1, p7_i2, p7_i3, p7_i4, p7_i5, p7_i6, p7_i7, p7_i8, p7_i9, p7_i10, p7_i11,
p7_i12, p7_i13, p7_i14, p7_i15, p7_i16, p7_i17, p7_i18, p7_i19, p7_i20, p7_i21,
p7_i22, p7_i23, p7_i24, p7_i25, p7_i26, p7_i27, p7_i28, p7_i29, p7_i30, p7_i31,
p7_i32, p7_i33, p7_i34, p7_i35, p7_i36, p7_i37, p7_i38, p7_i39, p7_i40, p7_i41,
p7_i42, p7_i43, p7_i44, p7_i45, p7_i46, p7_i47, p7_i48, p7_i49, p7_i50, p7_i51,
p7_i52, p7_i53, p7_i54, p7_i55, p7_i56, p7_i57, p7_i58, p7_i59, p7_i60, p7_i61,
p7_i62, p7_i63, p7_i64;
volatile unsigned char *p7__i__[] = {&p7_i1, &p7_i2, &p7_i3, &p7_i4, &p7_i5,
&p7_i6, &p7_i7, &p7_i8, &p7_i9, &p7_i10,
&p7_i11, &p7_i12, &p7_i13, &p7_i14, &p7_i15,
&p7_i16, &p7_i17, &p7_i18, &p7_i19, &p7_i20,
&p7_i21, &p7_i22, &p7_i23, &p7_i24, &p7_i25,
&p7_i26, &p7_i27, &p7_i28, &p7_i29, &p7_i30,
&p7_i31, &p7_i32, &p7_i33, &p7_i34, &p7_i35,
&p7_i36, &p7_i37, &p7_i38, &p7_i39, &p7_i40,
&p7_i41, &p7_i42, &p7_i43, &p7_i44, &p7_i45,
&p7_i46, &p7_i47, &p7_i48, &p7_i49, &p7_i50,
&p7_i51, &p7_i52, &p7_i53, &p7_i54, &p7_i55,
&p7_i56, &p7_i57, &p7_i58, &p7_i59, &p7_i60,
&p7_i61, &p7_i62, &p7_i63, &p7_i64};
volatile char p7_o1, p7_o2, p7_o3, p7_o4, p7_o5, p7_o6, p7_o7, p7_o8, p7_o9, p7_o10,
p7_o11, p7_o12, p7_o13, p7_o14, p7_o15, p7_o16, p7_o17, p7_o18, p7_o19, p7_o20,
p7_o21, p7_o22, p7_o23, p7_o24, p7_o25, p7_o26, p7_o27, p7_o28, p7_o29, p7_o30,
p7_o31, p7_o32, p7_o33, p7_o34, p7_o35, p7_o36, p7_o37, p7_o38, p7_o39, p7_o40,
p7_o41, p7_o42, p7_o43, p7_o44, p7_o45, p7_o46, p7_o47, p7_o48, p7_o49, p7_o50,
p7_o51, p7_o52, p7_o53, p7_o54, p7_o55, p7_o56, p7_o57, p7_o58, p7_o59, p7_o60,
p7_o61, p7_o62, p7_o63, p7_o64;
volatile unsigned char *p7__o__[] = {&p7_o1, &p7_o2, &p7_o3, &p7_o4, &p7_o5,
&p7_o6, &p7_o7, &p7_o8, &p7_o9, &p7_o10,
&p7_o11, &p7_o12, &p7_o13, &p7_o14, &p7_o15,
&p7_o16, &p7_o17, &p7_o18, &p7_o19, &p7_o20,
&p7_o21, &p7_o22, &p7_o23, &p7_o24, &p7_o25,
&p7_o26, &p7_o27, &p7_o28, &p7_o29, &p7_o30,
&p7_o31, &p7_o32, &p7_o33, &p7_o34, &p7_o35,
&p7_o36, &p7_o37, &p7_o38, &p7_o39, &p7_o40,
&p7_o41, &p7_o42, &p7_o43, &p7_o44, &p7_o45,
&p7_o46, &p7_o47, &p7_o48, &p7_o49, &p7_o50,
&p7_o51, &p7_o52, &p7_o53, &p7_o54, &p7_o55,
&p7_o56, &p7_o57, &p7_o58, &p7_o59, &p7_o60,
&p7_o61, &p7_o62, &p7_o63, &p7_o64};
// Input analogici
volatile int p7_x1_anal, p7_x2_anal, p7_x3_anal, p7_x4_anal, p7_x5_anal, p7_x6_anal, p7_x7_anal, p7_x8_anal;
volatile int* p7__xn_anal__[] = {&p7_x1_anal, &p7_x2_anal, &p7_x3_anal, &p7_x4_anal, &p7_x5_anal, &p7_x6_anal, &p7_x7_anal, &p7_x8_anal};
// PT100 RAW
volatile int p7_x1_pt100_raw, p7_x2_pt100_raw, p7_x3_pt100_raw, p7_x4_pt100_raw,
p7_x5_pt100_raw, p7_x6_pt100_raw, p7_x7_pt100_raw, p7_x8_pt100_raw;
volatile int* p7__xn_pt100_raw__[] = {&p7_x1_pt100_raw, &p7_x2_pt100_raw, &p7_x3_pt100_raw, &p7_x4_pt100_raw,
&p7_x5_pt100_raw, &p7_x6_pt100_raw, &p7_x7_pt100_raw, &p7_x8_pt100_raw};
// PT100 CELSIUS
float p7_x1_pt100, p7_x2_pt100, p7_x3_pt100, p7_x4_pt100, p7_x5_pt100, p7_x6_pt100, p7_x7_pt100, p7_x8_pt100;
volatile float* p7__xn_pt100__[] = {&p7_x1_pt100, &p7_x2_pt100, &p7_x3_pt100, &p7_x4_pt100, &p7_x5_pt100, &p7_x6_pt100, &p7_x7_pt100, &p7_x8_pt100};
// Ingressi digitali XN
volatile char p7_x1_digin, p7_x2_digin, p7_x3_digin, p7_x4_digin,
p7_x5_digin, p7_x6_digin, p7_x7_digin, p7_x8_digin;
volatile char *p7__xn_digin__[] = {&p7_x1_digin, &p7_x2_digin, &p7_x3_digin, &p7_x4_digin,
&p7_x5_digin, &p7_x6_digin, &p7_x7_digin, &p7_x8_digin};
volatile char p7_x1_i1, p7_x1_i2, p7_x2_i1, p7_x2_i2, p7_x3_i1, p7_x3_i2, p7_x4_i1, p7_x4_i2,
p7_x5_i1, p7_x5_i2, p7_x6_i1, p7_x6_i2, p7_x7_i1, p7_x7_i2, p7_x8_i1, p7_x8_i2;
// Uscite digitali XN
volatile char p7_x1_o1, p7_x1_o2, p7_x2_o1, p7_x2_o2, p7_x3_o1, p7_x3_o2, p7_x4_o1, p7_x4_o2,
p7_x5_o1, p7_x5_o2, p7_x6_o1, p7_x6_o2, p7_x7_o1, p7_x7_o2, p7_x8_o1, p7_x8_o2;
char *p7__xn_outs__[] = {&p7_x1_o1, &p7_x1_o2, &p7_x2_o1, &p7_x2_o2, &p7_x3_o1, &p7_x3_o2, &p7_x4_o1, &p7_x4_o2,
&p7_x5_o1, &p7_x5_o2, &p7_x6_o1, &p7_x6_o2, &p7_x7_o1, &p7_x7_o2, &p7_x8_o1, &p7_x8_o2};
// Uscite PWM
volatile U16 p7_x1_pwm = 2048;
volatile U16 p7_x2_pwm = 2048;
volatile U16 p7_x3_pwm = 2048;
volatile U16 p7_x4_pwm = 2048;
volatile U16 p7_x5_pwm = 2048;
volatile U16 p7_x6_pwm = 2048;
volatile U16 p7_x7_pwm = 2048;
volatile U16 p7_x8_pwm = 2048;
U16 *p7__xn_pwms__[] = {&p7_x1_pwm, &p7_x2_pwm, &p7_x3_pwm, &p7_x4_pwm, &p7_x5_pwm, &p7_x6_pwm, &p7_x7_pwm, &p7_x8_pwm};
#endif
//---------------------- CAN ------------------------------------
int ntx_frame = 0;
CANBASE_MSG CAN_TXBuf;
CANBASE_MSG CAN_RXBuf;
int puzzle_can_cnt = 0;
int puzzle_can_rx_cnt = 0;
int puzzle_nperif = 0; // serve per ciclare sulle periferiche nel task di invio frame
void puzzle_prepare_perif(int); // nperif
void puzzle_parse_perif(int); // nperif
void puzzle_send_frame(int, int); // nperif, nframe
void puzzle_parse_frame(CANBASE_MSG);
void puzzle_prepare_perif(int nper)
{
int i;
switch (nper) {
case 0: // PERIF 0
// config
for (i = 0; i < 8; i++) p50_xn_config[i] = xn_config[i];
// dig outs
p50_x1_o1 = x1_o1; p50_x1_o2 = x1_o2;
p50_x2_o1 = x2_o1; p50_x2_o2 = x2_o2;
p50_x3_o1 = x3_o1; p50_x3_o2 = x3_o2;
p50_x4_o1 = x4_o1; p50_x4_o2 = x4_o2;
p50_x5_o1 = x5_o1; p50_x5_o2 = x5_o2;
p50_x6_o1 = x6_o1; p50_x6_o2 = x6_o2;
p50_x7_o1 = x7_o1; p50_x7_o2 = x7_o2;
p50_x8_o1 = x8_o1; p50_x8_o2 = x8_o2;
// pwms
p50_x1_pwm = x1_pwm;
p50_x2_pwm = x2_pwm;
p50_x3_pwm = x3_pwm;
p50_x4_pwm = x4_pwm;
p50_x5_pwm = x5_pwm;
p50_x6_pwm = x6_pwm;
p50_x7_pwm = x7_pwm;
p50_x8_pwm = x8_pwm;
// exp
p50_o_low = 0;
p50_o_high = 0;
for (i = 0; i < 32; i++) p50_o_low |= ((*p__o__[i] & 1) << i);
for (i = 0; i < 32; i++) p50_o_high |= ((*p__o__[i+32] & 1) << i);
break;
#if PUZZLE_PERIFS >= 2
case 1: // PERIF 1
// config
for (i = 0; i < 8; i++) p50_xn_config[i] = p1_xn_config[i];
// dig outs
p50_x1_o1 = p1_x1_o1; p50_x1_o2 = p1_x1_o2;
p50_x2_o1 = p1_x2_o1; p50_x2_o2 = p1_x2_o2;
p50_x3_o1 = p1_x3_o1; p50_x3_o2 = p1_x3_o2;
p50_x4_o1 = p1_x4_o1; p50_x4_o2 = p1_x4_o2;
p50_x5_o1 = p1_x5_o1; p50_x5_o2 = p1_x5_o2;
p50_x6_o1 = p1_x6_o1; p50_x6_o2 = p1_x6_o2;
p50_x7_o1 = p1_x7_o1; p50_x7_o2 = p1_x7_o2;
p50_x8_o1 = p1_x8_o1; p50_x8_o2 = p1_x8_o2;
// pwms
p50_x1_pwm = p1_x1_pwm;
p50_x2_pwm = p1_x2_pwm;
p50_x3_pwm = p1_x3_pwm;
p50_x4_pwm = p1_x4_pwm;
p50_x5_pwm = p1_x5_pwm;
p50_x6_pwm = p1_x6_pwm;
p50_x7_pwm = p1_x7_pwm;
p50_x8_pwm = p1_x8_pwm;
// exp
p50_o_low = 0;
p50_o_high = 0;
for (i = 0; i < 32; i++) p50_o_low |= ((*p1__o__[i] & 1) << i);
for (i = 0; i < 32; i++) p50_o_high |= ((*p1__o__[i+32] & 1) << i);
break;
#endif
#if PUZZLE_PERIFS >= 3
case 2: // PERIF 2
// config
for (i = 0; i < 8; i++) p50_xn_config[i] = p2_xn_config[i];
// dig outs
p50_x1_o1 = p2_x1_o1; p50_x1_o2 = p2_x1_o2;
p50_x2_o1 = p2_x2_o1; p50_x2_o2 = p2_x2_o2;
p50_x3_o1 = p2_x3_o1; p50_x3_o2 = p2_x3_o2;
p50_x4_o1 = p2_x4_o1; p50_x4_o2 = p2_x4_o2;
p50_x5_o1 = p2_x5_o1; p50_x5_o2 = p2_x5_o2;
p50_x6_o1 = p2_x6_o1; p50_x6_o2 = p2_x6_o2;
p50_x7_o1 = p2_x7_o1; p50_x7_o2 = p2_x7_o2;
p50_x8_o1 = p2_x8_o1; p50_x8_o2 = p2_x8_o2;
// pwms
p50_x1_pwm = p2_x1_pwm;
p50_x2_pwm = p2_x2_pwm;
p50_x3_pwm = p2_x3_pwm;
p50_x4_pwm = p2_x4_pwm;
p50_x5_pwm = p2_x5_pwm;
p50_x6_pwm = p2_x6_pwm;
p50_x7_pwm = p2_x7_pwm;
p50_x8_pwm = p2_x8_pwm;
// exp
p50_o_low = 0;
p50_o_high = 0;
for (i = 0; i < 32; i++) p50_o_low |= ((*p2__o__[i] & 1) << i);
for (i = 0; i < 32; i++) p50_o_high |= ((*p2__o__[i+32] & 1) << i);
break;
#endif
#if PUZZLE_PERIFS >= 4
case 3: // PERIF 3
// config
for (i = 0; i < 8; i++) p50_xn_config[i] = p3_xn_config[i];
// dig outs
p50_x1_o1 = p3_x1_o1; p50_x1_o2 = p3_x1_o2;
p50_x2_o1 = p3_x2_o1; p50_x2_o2 = p3_x2_o2;
p50_x3_o1 = p3_x3_o1; p50_x3_o2 = p3_x3_o2;
p50_x4_o1 = p3_x4_o1; p50_x4_o2 = p3_x4_o2;
p50_x5_o1 = p3_x5_o1; p50_x5_o2 = p3_x5_o2;
p50_x6_o1 = p3_x6_o1; p50_x6_o2 = p3_x6_o2;
p50_x7_o1 = p3_x7_o1; p50_x7_o2 = p3_x7_o2;
p50_x8_o1 = p3_x8_o1; p50_x8_o2 = p3_x8_o2;
// pwms
p50_x1_pwm = p3_x1_pwm;
p50_x2_pwm = p3_x2_pwm;
p50_x3_pwm = p3_x3_pwm;
p50_x4_pwm = p3_x4_pwm;
p50_x5_pwm = p3_x5_pwm;
p50_x6_pwm = p3_x6_pwm;
p50_x7_pwm = p3_x7_pwm;
p50_x8_pwm = p3_x8_pwm;
// exp
p50_o_low = 0;
p50_o_high = 0;
for (i = 0; i < 32; i++) p50_o_low |= ((*p3__o__[i] & 1) << i);
for (i = 0; i < 32; i++) p50_o_high |= ((*p3__o__[i+32] & 1) << i);
break;
#endif
#if PUZZLE_PERIFS >= 5
case 4: // PERIF 4
// config
for (i = 0; i < 8; i++) p50_xn_config[i] = p4_xn_config[i];
// dig outs
p50_x1_o1 = p4_x1_o1; p50_x1_o2 = p4_x1_o2;
p50_x2_o1 = p4_x2_o1; p50_x2_o2 = p4_x2_o2;
p50_x3_o1 = p4_x3_o1; p50_x3_o2 = p4_x3_o2;
p50_x4_o1 = p4_x4_o1; p50_x4_o2 = p4_x4_o2;
p50_x5_o1 = p4_x5_o1; p50_x5_o2 = p4_x5_o2;
p50_x6_o1 = p4_x6_o1; p50_x6_o2 = p4_x6_o2;
p50_x7_o1 = p4_x7_o1; p50_x7_o2 = p4_x7_o2;
p50_x8_o1 = p4_x8_o1; p50_x8_o2 = p4_x8_o2;
// pwms
p50_x1_pwm = p4_x1_pwm;
p50_x2_pwm = p4_x2_pwm;
p50_x3_pwm = p4_x3_pwm;
p50_x4_pwm = p4_x4_pwm;
p50_x5_pwm = p4_x5_pwm;
p50_x6_pwm = p4_x6_pwm;
p50_x7_pwm = p4_x7_pwm;
p50_x8_pwm = p4_x8_pwm;
// exp
p50_o_low = 0;
p50_o_high = 0;
for (i = 0; i < 32; i++) p50_o_low |= ((*p4__o__[i] & 1) << i);
for (i = 0; i < 32; i++) p50_o_high |= ((*p4__o__[i+32] & 1) << i);
break;
#endif
#if PUZZLE_PERIFS >= 6
case 5: // PERIF 5
// config
for (i = 0; i < 8; i++) p50_xn_config[i] = p5_xn_config[i];
// dig outs
p50_x1_o1 = p5_x1_o1; p50_x1_o2 = p5_x1_o2;
p50_x2_o1 = p5_x2_o1; p50_x2_o2 = p5_x2_o2;
p50_x3_o1 = p5_x3_o1; p50_x3_o2 = p5_x3_o2;
p50_x4_o1 = p5_x4_o1; p50_x4_o2 = p5_x4_o2;
p50_x5_o1 = p5_x5_o1; p50_x5_o2 = p5_x5_o2;
p50_x6_o1 = p5_x6_o1; p50_x6_o2 = p5_x6_o2;
p50_x7_o1 = p5_x7_o1; p50_x7_o2 = p5_x7_o2;
p50_x8_o1 = p5_x8_o1; p50_x8_o2 = p5_x8_o2;
// pwms
p50_x1_pwm = p5_x1_pwm;
p50_x2_pwm = p5_x2_pwm;
p50_x3_pwm = p5_x3_pwm;
p50_x4_pwm = p5_x4_pwm;
p50_x5_pwm = p5_x5_pwm;
p50_x6_pwm = p5_x6_pwm;
p50_x7_pwm = p5_x7_pwm;
p50_x8_pwm = p5_x8_pwm;
// exp
p50_o_low = 0;
p50_o_high = 0;
for (i = 0; i < 32; i++) p50_o_low |= ((*p5__o__[i] & 1) << i);
for (i = 0; i < 32; i++) p50_o_high |= ((*p5__o__[i+32] & 1) << i);
break;
#endif
#if PUZZLE_PERIFS >= 7
case 6: // PERIF 6
// config
for (i = 0; i < 8; i++) p50_xn_config[i] = p6_xn_config[i];
// dig outs
p50_x1_o1 = p6_x1_o1; p50_x1_o2 = p6_x1_o2;
p50_x2_o1 = p6_x2_o1; p50_x2_o2 = p6_x2_o2;
p50_x3_o1 = p6_x3_o1; p50_x3_o2 = p6_x3_o2;
p50_x4_o1 = p6_x4_o1; p50_x4_o2 = p6_x4_o2;
p50_x5_o1 = p6_x5_o1; p50_x5_o2 = p6_x5_o2;
p50_x6_o1 = p6_x6_o1; p50_x6_o2 = p6_x6_o2;
p50_x7_o1 = p6_x7_o1; p50_x7_o2 = p6_x7_o2;
p50_x8_o1 = p6_x8_o1; p50_x8_o2 = p6_x8_o2;
// pwms
p50_x1_pwm = p6_x1_pwm;
p50_x2_pwm = p6_x2_pwm;
p50_x3_pwm = p6_x3_pwm;
p50_x4_pwm = p6_x4_pwm;
p50_x5_pwm = p6_x5_pwm;
p50_x6_pwm = p6_x6_pwm;
p50_x7_pwm = p6_x7_pwm;
p50_x8_pwm = p6_x8_pwm;
// exp
p50_o_low = 0;
p50_o_high = 0;
for (i = 0; i < 32; i++) p50_o_low |= ((*p6__o__[i] & 1) << i);
for (i = 0; i < 32; i++) p50_o_high |= ((*p6__o__[i+32] & 1) << i);
break;
#endif
#if PUZZLE_PERIFS >= 8
case 7: // PERIF 7
// config
for (i = 0; i < 8; i++) p50_xn_config[i] = p7_xn_config[i];
// dig outs
p50_x1_o1 = p7_x1_o1; p50_x1_o2 = p7_x1_o2;
p50_x2_o1 = p7_x2_o1; p50_x2_o2 = p7_x2_o2;
p50_x3_o1 = p7_x3_o1; p50_x3_o2 = p7_x3_o2;
p50_x4_o1 = p7_x4_o1; p50_x4_o2 = p7_x4_o2;
p50_x5_o1 = p7_x5_o1; p50_x5_o2 = p7_x5_o2;
p50_x6_o1 = p7_x6_o1; p50_x6_o2 = p7_x6_o2;
p50_x7_o1 = p7_x7_o1; p50_x7_o2 = p7_x7_o2;
p50_x8_o1 = p7_x8_o1; p50_x8_o2 = p7_x8_o2;
// pwms
p50_x1_pwm = p7_x1_pwm;
p50_x2_pwm = p7_x2_pwm;
p50_x3_pwm = p7_x3_pwm;
p50_x4_pwm = p7_x4_pwm;
p50_x5_pwm = p7_x5_pwm;
p50_x6_pwm = p7_x6_pwm;
p50_x7_pwm = p7_x7_pwm;
p50_x8_pwm = p7_x8_pwm;
// exp
p50_o_low = 0;
p50_o_high = 0;
for (i = 0; i < 32; i++) p50_o_low |= ((*p7__o__[i] & 1) << i);
for (i = 0; i < 32; i++) p50_o_high |= ((*p7__o__[i+32] & 1) << i);
break;
#endif
}
}
void puzzle_parse_perif(int nper)
{
int i;
switch (nper) {
case 0:
// dig in
x1_i1 = p50_x1_i1; x1_i2 = p50_x1_i2;
x2_i1 = p50_x2_i1; x2_i2 = p50_x2_i2;
x3_i1 = p50_x3_i1; x3_i2 = p50_x3_i2;
x4_i1 = p50_x4_i1; x4_i2 = p50_x4_i2;
x5_i1 = p50_x5_i1; x5_i2 = p50_x5_i2;
x6_i1 = p50_x6_i1; x6_i2 = p50_x6_i2;
x7_i1 = p50_x7_i1; x7_i2 = p50_x7_i2;
x8_i1 = p50_x8_i1; x8_i2 = p50_x8_i2;
for (i = 0; i < 8; i++) *(__xn_anal__[i]) = *(p50__xn_anal__[i]); // analog in
for (i = 0; i < 8; i++) *(__xn_pt100_raw__[i]) = *(p50__xn_pt100_raw__[i]); // PT100 RAW
for (i = 0; i < 8; i++) *(__xn_pt100__[i]) = *(p50__xn_pt100__[i]); // PT100 CELSIUS
// EXP
for (i = 0; i < 32; i++) *(p__i__[i]) = ((p50_i_low >> i) & 1);
for (i = 0; i < 32; i++) *(p__i__[i+32]) = ((p50_i_high >> i) & 1);
// ENC
p_encoder1 = p50_encoder1;
p_encoder2 = p50_encoder2;
break;
#if PUZZLE_PERIFS >= 2
case 1:
// dig in
p1_x1_i1 = p50_x1_i1; p1_x1_i2 = p50_x1_i2;
p1_x2_i1 = p50_x2_i1; p1_x2_i2 = p50_x2_i2;
p1_x3_i1 = p50_x3_i1; p1_x3_i2 = p50_x3_i2;
p1_x4_i1 = p50_x4_i1; p1_x4_i2 = p50_x4_i2;
p1_x5_i1 = p50_x5_i1; p1_x5_i2 = p50_x5_i2;
p1_x6_i1 = p50_x6_i1; p1_x6_i2 = p50_x6_i2;
p1_x7_i1 = p50_x7_i1; p1_x7_i2 = p50_x7_i2;
p1_x8_i1 = p50_x8_i1; p1_x8_i2 = p50_x8_i2;
for (i = 0; i < 8; i++) *(p1__xn_anal__[i]) = *(p50__xn_anal__[i]); // analog in
for (i = 0; i < 8; i++) *(p1__xn_pt100_raw__[i]) = *(p50__xn_pt100_raw__[i]); // PT100 RAW
for (i = 0; i < 8; i++) *(p1__xn_pt100__[i]) = *(p50__xn_pt100__[i]); // PT100 CELSIUS
// EXP
for (i = 0; i < 32; i++) *(p1__i__[i]) = ((p50_i_low >> i) & 1);
for (i = 0; i < 32; i++) *(p1__i__[i+32]) = ((p50_i_high >> i) & 1);
// ENC
p1_encoder1 = p50_encoder1;
p1_encoder2 = p50_encoder2;
break;
#endif
#if PUZZLE_PERIFS >= 3
case 2:
// dig in
p2_x1_i1 = p50_x1_i1; p2_x1_i2 = p50_x1_i2;
p2_x2_i1 = p50_x2_i1; p2_x2_i2 = p50_x2_i2;
p2_x3_i1 = p50_x3_i1; p2_x3_i2 = p50_x3_i2;
p2_x4_i1 = p50_x4_i1; p2_x4_i2 = p50_x4_i2;
p2_x5_i1 = p50_x5_i1; p2_x5_i2 = p50_x5_i2;
p2_x6_i1 = p50_x6_i1; p2_x6_i2 = p50_x6_i2;
p2_x7_i1 = p50_x7_i1; p2_x7_i2 = p50_x7_i2;
p2_x8_i1 = p50_x8_i1; p2_x8_i2 = p50_x8_i2;
for (i = 0; i < 8; i++) *(p2__xn_anal__[i]) = *(p50__xn_anal__[i]); // analog in
for (i = 0; i < 8; i++) *(p2__xn_pt100_raw__[i]) = *(p50__xn_pt100_raw__[i]); // PT100 RAW
for (i = 0; i < 8; i++) *(p2__xn_pt100__[i]) = *(p50__xn_pt100__[i]); // PT100 CELSIUS
// EXP
for (i = 0; i < 32; i++) *(p2__i__[i]) = ((p50_i_low >> i) & 1);
for (i = 0; i < 32; i++) *(p2__i__[i+32]) = ((p50_i_high >> i) & 1);
// ENC
p2_encoder1 = p50_encoder1;
p2_encoder2 = p50_encoder2;
break;
#endif
#if PUZZLE_PERIFS >= 4
case 3:
// dig in
p3_x1_i1 = p50_x1_i1; p3_x1_i2 = p50_x1_i2;
p3_x2_i1 = p50_x2_i1; p3_x2_i2 = p50_x2_i2;
p3_x3_i1 = p50_x3_i1; p3_x3_i2 = p50_x3_i2;
p3_x4_i1 = p50_x4_i1; p3_x4_i2 = p50_x4_i2;
p3_x5_i1 = p50_x5_i1; p3_x5_i2 = p50_x5_i2;
p3_x6_i1 = p50_x6_i1; p3_x6_i2 = p50_x6_i2;
p3_x7_i1 = p50_x7_i1; p3_x7_i2 = p50_x7_i2;
p3_x8_i1 = p50_x8_i1; p3_x8_i2 = p50_x8_i2;
for (i = 0; i < 8; i++) *(p3__xn_anal__[i]) = *(p50__xn_anal__[i]); // analog in
for (i = 0; i < 8; i++) *(p3__xn_pt100_raw__[i]) = *(p50__xn_pt100_raw__[i]); // PT100 RAW
for (i = 0; i < 8; i++) *(p3__xn_pt100__[i]) = *(p50__xn_pt100__[i]); // PT100 CELSIUS
// EXP
for (i = 0; i < 32; i++) *(p3__i__[i]) = ((p50_i_low >> i) & 1);
for (i = 0; i < 32; i++) *(p3__i__[i+32]) = ((p50_i_high >> i) & 1);
// ENC
p3_encoder1 = p50_encoder1;
p3_encoder2 = p50_encoder2;
break;
#endif
#if PUZZLE_PERIFS >= 5
case 4:
// dig in
p4_x1_i1 = p50_x1_i1; p4_x1_i2 = p50_x1_i2;
p4_x2_i1 = p50_x2_i1; p4_x2_i2 = p50_x2_i2;
p4_x3_i1 = p50_x3_i1; p4_x3_i2 = p50_x3_i2;
p4_x4_i1 = p50_x4_i1; p4_x4_i2 = p50_x4_i2;
p4_x5_i1 = p50_x5_i1; p4_x5_i2 = p50_x5_i2;
p4_x6_i1 = p50_x6_i1; p4_x6_i2 = p50_x6_i2;
p4_x7_i1 = p50_x7_i1; p4_x7_i2 = p50_x7_i2;
p4_x8_i1 = p50_x8_i1; p4_x8_i2 = p50_x8_i2;
for (i = 0; i < 8; i++) *(p4__xn_anal__[i]) = *(p50__xn_anal__[i]); // analog in
for (i = 0; i < 8; i++) *(p4__xn_pt100_raw__[i]) = *(p50__xn_pt100_raw__[i]); // PT100 RAW
for (i = 0; i < 8; i++) *(p4__xn_pt100__[i]) = *(p50__xn_pt100__[i]); // PT100 CELSIUS
// EXP
for (i = 0; i < 32; i++) *(p4__i__[i]) = ((p50_i_low >> i) & 1);
for (i = 0; i < 32; i++) *(p4__i__[i+32]) = ((p50_i_high >> i) & 1);
// ENC
p4_encoder1 = p50_encoder1;
p4_encoder2 = p50_encoder2;
break;
#endif
#if PUZZLE_PERIFS >= 6
case 5:
// dig in
p5_x1_i1 = p50_x1_i1; p5_x1_i2 = p50_x1_i2;
p5_x2_i1 = p50_x2_i1; p5_x2_i2 = p50_x2_i2;
p5_x3_i1 = p50_x3_i1; p5_x3_i2 = p50_x3_i2;
p5_x4_i1 = p50_x4_i1; p5_x4_i2 = p50_x4_i2;
p5_x5_i1 = p50_x5_i1; p5_x5_i2 = p50_x5_i2;
p5_x6_i1 = p50_x6_i1; p5_x6_i2 = p50_x6_i2;
p5_x7_i1 = p50_x7_i1; p5_x7_i2 = p50_x7_i2;
p5_x8_i1 = p50_x8_i1; p5_x8_i2 = p50_x8_i2;
for (i = 0; i < 8; i++) *(p5__xn_anal__[i]) = *(p50__xn_anal__[i]); // analog in
for (i = 0; i < 8; i++) *(p5__xn_pt100_raw__[i]) = *(p50__xn_pt100_raw__[i]); // PT100 RAW
for (i = 0; i < 8; i++) *(p5__xn_pt100__[i]) = *(p50__xn_pt100__[i]); // PT100 CELSIUS
// EXP
for (i = 0; i < 32; i++) *(p5__i__[i]) = ((p50_i_low >> i) & 1);
for (i = 0; i < 32; i++) *(p5__i__[i+32]) = ((p50_i_high >> i) & 1);
// ENC
p5_encoder1 = p50_encoder1;
p5_encoder2 = p50_encoder2;
break;
#endif
#if PUZZLE_PERIFS >= 7
case 6:
// dig in
p6_x1_i1 = p50_x1_i1; p6_x1_i2 = p50_x1_i2;
p6_x2_i1 = p50_x2_i1; p6_x2_i2 = p50_x2_i2;
p6_x3_i1 = p50_x3_i1; p6_x3_i2 = p50_x3_i2;
p6_x4_i1 = p50_x4_i1; p6_x4_i2 = p50_x4_i2;
p6_x5_i1 = p50_x5_i1; p6_x5_i2 = p50_x5_i2;
p6_x6_i1 = p50_x6_i1; p6_x6_i2 = p50_x6_i2;
p6_x7_i1 = p50_x7_i1; p6_x7_i2 = p50_x7_i2;
p6_x8_i1 = p50_x8_i1; p6_x8_i2 = p50_x8_i2;
for (i = 0; i < 8; i++) *(p6__xn_anal__[i]) = *(p50__xn_anal__[i]); // analog in
for (i = 0; i < 8; i++) *(p6__xn_pt100_raw__[i]) = *(p50__xn_pt100_raw__[i]); // PT100 RAW
for (i = 0; i < 8; i++) *(p6__xn_pt100__[i]) = *(p50__xn_pt100__[i]); // PT100 CELSIUS
// EXP
for (i = 0; i < 32; i++) *(p6__i__[i]) = ((p50_i_low >> i) & 1);
for (i = 0; i < 32; i++) *(p6__i__[i+32]) = ((p50_i_high >> i) & 1);
// ENC
p6_encoder1 = p50_encoder1;
p6_encoder2 = p50_encoder2;
break;
#endif
#if PUZZLE_PERIFS >= 8
case 7:
// dig in
p7_x1_i1 = p50_x1_i1; p7_x1_i2 = p50_x1_i2;
p7_x2_i1 = p50_x2_i1; p7_x2_i2 = p50_x2_i2;
p7_x3_i1 = p50_x3_i1; p7_x3_i2 = p50_x3_i2;
p7_x4_i1 = p50_x4_i1; p7_x4_i2 = p50_x4_i2;
p7_x5_i1 = p50_x5_i1; p7_x5_i2 = p50_x5_i2;
p7_x6_i1 = p50_x6_i1; p7_x6_i2 = p50_x6_i2;
p7_x7_i1 = p50_x7_i1; p7_x7_i2 = p50_x7_i2;
p7_x8_i1 = p50_x8_i1; p7_x8_i2 = p50_x8_i2;
for (i = 0; i < 8; i++) *(p7__xn_anal__[i]) = *(p50__xn_anal__[i]); // analog in
for (i = 0; i < 8; i++) *(p7__xn_pt100_raw__[i]) = *(p50__xn_pt100_raw__[i]); // PT100 RAW
for (i = 0; i < 8; i++) *(p7__xn_pt100__[i]) = *(p50__xn_pt100__[i]); // PT100 CELSIUS
// EXP
for (i = 0; i < 32; i++) *(p7__i__[i]) = ((p50_i_low >> i) & 1);
for (i = 0; i < 32; i++) *(p7__i__[i+32]) = ((p50_i_high >> i) & 1);
// ENC
p7_encoder1 = p50_encoder1;
p7_encoder2 = p50_encoder2;
break;
#endif
}
}
void puzzle_send_frame(int nper, int nframe)
{
U32 da, db, msgid;
int i;
msgid = (nper & 0xFF) | ((nframe & 0xFF) << 8) | ((p_ext1_on & 0x01) << 16) | ((p_ext2_on & 0x01) << 17);
// Reset request (bit-18 del msgid)
/*
if (puzzle_reset == 1) {
puzzle_reset = 0;
msgid |= (1 << 18);
}
*/
if (puzzle_reset_perif[nper] == 1) {
puzzle_reset_perif[nper] = 0;
msgid |= (1 << 18);
}
da = 0;
db = 0;
// prepara periferica sul buffer della periferica 50
puzzle_prepare_perif(nper);
switch (nframe) {
case 0: // XN config
// 6-bit per ogni slot, 2 moduli EXP
da = ((p50_xn_config[5] & 0x03) << 30) |
((p50_xn_config[4] & 0x3F) << 24) |
((p50_xn_config[3] & 0x3F) << 18) |
((p50_xn_config[2] & 0x3F) << 12) |
((p50_xn_config[1] & 0x3F) << 6) |
(p50_xn_config[0] & 0x3F);
db |= ( (p50_o_low & 0xFFFF) << 16 ) |
((p50_xn_config[7] & 0x3F) << 10) |
((p50_xn_config[6] & 0x3F) << 4) |
((p50_xn_config[5] >> 2) & 0x0F);
/*
db = ((p_o1 & 0x01) << 16) | ((p_o2 & 0x01) << 17) | ((p_o3 & 0x01) << 18) |
((p_o4 & 0x01) << 19) | ((p_o5 & 0x01) << 20) | ((p_o6 & 0x01) << 21) |
((p_o7 & 0x01) << 22) | ((p_o8 & 0x01) << 23) |
((p_o9 & 0x01) << 24) | ((p_o10 & 0x01) << 25) | ((p_o11 & 0x01) << 26) |
((p_o12 & 0x01) << 27) | ((p_o13 & 0x01) << 28) | ((p_o14 & 0x01) << 29) |
((p_o15 & 0x01) << 30) | ((p_o16 & 0x01) << 31) |
((xn_config[7] & 0x3F) << 10) |
((xn_config[6] & 0x3F) << 4) |
(xn_config[5] & 0x0F);
*/
break;
case 1: // X1... X4
switch (p50_xn_config[0]) { // X1
case C_OUT:
da |= ((p50_x1_o2 & 0x01) << 1) | (p50_x1_o1 & 0x01);
break;
case C_PWM:
da |= (p50_x1_pwm & 0xFFFF);
break;
case C_EMPTY:
break;
}
switch (p50_xn_config[1]) { // X2
case C_OUT:
da |= ((p50_x2_o2 & 0x01) << 17) | ((p50_x2_o1 & 0x01) << 16);
break;
case C_PWM:
da |= ((p50_x2_pwm & 0xFFFF) << 16);
break;
case C_EMPTY:
break;
}
switch (p50_xn_config[2]) { // X3
case C_OUT:
db |= ((p50_x3_o2 & 0x01) << 1) | (p50_x3_o1 & 0x01);
break;
case C_PWM:
db |= (p50_x3_pwm & 0xFFFF);
break;
case C_EMPTY:
break;
}
switch (p50_xn_config[3]) { // X4
case C_OUT:
db |= ((p50_x4_o2 & 0x01) << 17) | ((p50_x4_o1 & 0x01) << 16);
break;
case C_PWM:
db |= ((p50_x4_pwm & 0xFFFF) << 16);
break;
case C_EMPTY:
break;
}
break;
case 2: // X5... X8
switch (p50_xn_config[4]) { // X5
case C_OUT:
da |= ((p50_x5_o2 & 0x01) << 1) | (p50_x5_o1 & 0x01);
break;
case C_PWM:
da |= (p50_x5_pwm & 0xFFFF);
break;
case C_EMPTY:
break;
}
switch (p50_xn_config[5]) { // X6
case C_OUT:
da |= ((p50_x6_o2 & 0x01) << 17) | ((p50_x6_o1 & 0x01) << 16);
break;
case C_PWM:
da |= ((p50_x6_pwm & 0xFFFF) << 16);
break;
case C_EMPTY:
break;
}
switch (p50_xn_config[6]) { // X7
case C_OUT:
db |= ((p50_x7_o2 & 0x01) << 1) | (p50_x7_o1 & 0x01);
break;
case C_PWM:
db |= (p50_x7_pwm & 0xFFFF);
break;
case C_EMPTY:
break;
}
switch (p50_xn_config[7]) { // X8
case C_OUT:
db |= ((p50_x8_o2 & 0x01) << 17) | ((p50_x8_o1 & 0x01) << 16);
break;
case C_PWM:
db |= ((p50_x8_pwm & 0xFFFF) << 16);
break;
case C_EMPTY:
break;
}
break;
case 3: // EXP (opzionale)
da = p50_o_low;
db = p50_o_high;
/*
for (i = 0; i < 32; i++) da |= (*p__o__[i] & 0x01) << i;
for (i = 32; i< 64; i++) db |= (*p__o__[i] & 0x01) << (i-32);
*/
break;
}
//CAN_TXBuf.Frame = 0x00080000;
CAN_TXBuf.Frame = 0x80080000;
CAN_TXBuf.MsgID = msgid;
CAN_TXBuf.DatA = da;
CAN_TXBuf.DatB = db;
puzzle_can_cnt++;
canbase_txmsg(&CAN_TXBuf);
}
float PT100_X1_perif0, PT100_X2_perif0, PT100_X3_perif0, PT100_X4_perif0;
float PT100_X5_perif0, PT100_X6_perif0, PT100_X7_perif0, PT100_X8_perif0;
float PT100_X1_perif1, PT100_X2_perif1, PT100_X3_perif1, PT100_X4_perif1;
float PT100_X5_perif1, PT100_X6_perif1, PT100_X7_perif1, PT100_X8_perif1;
short int cnt_rx0, cnt_rx1, cnt_rx2, cnt_rx3;
void puzzle_parse_frame(CANBASE_MSG mcan_msg)
{
int i;
U32 msgid = mcan_msg.MsgID;
U32 da = mcan_msg.DatA;
U32 db = mcan_msg.DatB;
int nperif, nmess;
p_dipswitch_status = (msgid >> 20) & 0xF;
puzzle_version = (msgid >> 16) & 0x0F;
nmess = (msgid >> 8) & 0xFF;
nperif = (msgid & 0xFF);
if(nperif == 0)
{
if(nmess == 0)
{
p50_x1_pt100 = pt100_calc((da & 0xFFFF), 0);
PT100_X1_perif0 = p50_x1_pt100;
///
p50_x2_pt100 = pt100_calc(((da & 0xFFFF0000) >> 16), 0);
PT100_X2_perif0 = p50_x2_pt100;
///
p50_x3_pt100 = pt100_calc((db & 0xFFFF), 0);
PT100_X3_perif0 = p50_x3_pt100;
///
p50_x4_pt100 = pt100_calc(((db & 0xFFFF0000) >> 16), 0);
PT100_X4_perif0 = p50_x4_pt100;
cnt_rx0++;
}
if(nmess == 1)
{
p50_x5_pt100 = pt100_calc((da & 0xFFFF), 0);
PT100_X5_perif0 = p50_x5_pt100;
///
p50_x6_pt100 = pt100_calc(((da & 0xFFFF0000) >> 16), 0);
PT100_X6_perif0 = p50_x6_pt100;
///
p50_x7_pt100 = pt100_calc((db & 0xFFFF), 0);
PT100_X7_perif0 = p50_x7_pt100;
///
p50_x8_pt100 = pt100_calc(((db & 0xFFFF0000) >> 16), 0);
PT100_X8_perif0 = p50_x8_pt100;
cnt_rx1++;
}
}
else if(nperif == 1)
{
if(nmess == 0)
{
p50_x1_pt100 = pt100_calc((da & 0xFFFF), 0);
PT100_X1_perif1 = p50_x1_pt100;
///
p50_x2_pt100 = pt100_calc(((da & 0xFFFF0000) >> 16), 0);
PT100_X2_perif1 = p50_x2_pt100;
///
p50_x3_pt100 = pt100_calc((db & 0xFFFF), 0);
PT100_X3_perif1 = p50_x3_pt100;
///
p50_x4_pt100 = pt100_calc(((db & 0xFFFF0000) >> 16), 0);
PT100_X4_perif1 = p50_x4_pt100;
cnt_rx2++;
}
if(nmess == 1)
{
p50_x5_pt100 = pt100_calc((da & 0xFFFF), 0);
PT100_X5_perif1 = p50_x5_pt100;
///
p50_x6_pt100 = pt100_calc(((da & 0xFFFF0000) >> 16), 0);
PT100_X6_perif1 = p50_x6_pt100;
///
p50_x7_pt100 = pt100_calc((db & 0xFFFF), 0);
PT100_X7_perif1 = p50_x7_pt100;
///
p50_x8_pt100 = pt100_calc(((db & 0xFFFF0000) >> 16), 0);
PT100_X8_perif1 = p50_x8_pt100;
cnt_rx3++;
}
}
// Scrivi sulla periferica 50
switch (nmess) {
case 0: // X1... X4
p50_x1_anal = (da & 0xFFFF);
p50_x1_i1 = (da & 0x01);
p50_x1_i2 = (da & 0x02) >> 1;
p50_x1_pt100_raw = (da & 0xFFFF);
p50_x1_pt100 = pt100_calc(x1_pt100_raw, 0);
p50_x2_anal = (da & 0xFFFF0000) >> 16;
p50_x2_i1 = (da & 0x10000) >> 16;
p50_x2_i2 = (da & 0x20000) >> 16;
p50_x2_pt100_raw = (da & 0xFFFF0000) >> 16;
p50_x2_pt100 = pt100_calc(x2_pt100_raw, 1);
p50_x3_anal = (db & 0xFFFF);
p50_x3_i1 = (db & 0x1);
p50_x3_i2 = (db & 0x2);
p50_x3_pt100_raw = (db & 0xFFFF);
p50_x3_pt100 = pt100_calc(x3_pt100_raw, 2);
p50_x4_anal = (db & 0xFFFF0000) >> 16;
p50_x4_i1 = (db & 0x10000) >> 16;
p50_x4_i2 = (db & 0x20000) >> 16;
p50_x4_pt100_raw = (db & 0xFFFF0000) >> 16;
p50_x4_pt100 = pt100_calc(x4_pt100_raw, 3);
break;
case 1: // X5... X8
p50_x5_anal = (da & 0xFFFF);
p50_x5_i1 = (da & 0x01);
p50_x5_i2 = (da & 0x02) >> 1;
p50_x5_pt100_raw = (da & 0xFFFF);
p50_x5_pt100 = pt100_calc(x5_pt100_raw, 4);
p50_x6_anal = (da & 0xFFFF0000) >> 16;
p50_x6_i1 = (da & 0x10000) >> 16;
p50_x6_i2 = (da & 0x20000) >> 16;
p50_x6_pt100_raw = (da & 0xFFFF0000) >> 16;
p50_x6_pt100 = pt100_calc(x6_pt100_raw, 5);
p50_x7_anal = (db & 0xFFFF);
p50_x7_i1 = (db & 0x1);
p50_x7_i2 = (db & 0x2);
p50_x7_pt100_raw = (db & 0xFFFF);
p50_x7_pt100 = pt100_calc(x7_pt100_raw, 6);
p50_x8_anal = (db & 0xFFFF0000) >> 16;
p50_x8_i1 = (db & 0x10000) >> 16;
p50_x8_i2 = (db & 0x20000) >> 16;
p50_x8_pt100_raw = (db & 0xFFFF0000) >> 16;
p50_x8_pt100 = pt100_calc(x8_pt100_raw, 7);
break;
case 2: // EXP 1-4 + ENC1.
p50_i_low = da;
p50_encoder1 = db;
break;
case 3: // EXP 5-8 + ENC2
p50_i_high = da;
p50_encoder2 = db;
break;
default:
break;
}
if (nperif == 0)
{
if (nmess == 0)
{
x1_pt100 = p50_x1_pt100;
x2_pt100 = p50_x2_pt100;
x3_pt100 = p50_x3_pt100;
x4_pt100 = p50_x4_pt100;
x1_i1 = p50_x1_i1;
x1_i2 = p50_x1_i2;
x2_i1 = p50_x2_i1;
x2_i2 = p50_x2_i2;
x3_i1 = p50_x3_i1;
x3_i2 = p50_x3_i2;
x4_i1 = p50_x4_i1;
x4_i2 = p50_x4_i2;
}
else if (nmess == 1)
{
x5_pt100 = p50_x5_pt100;
x6_pt100 = p50_x6_pt100;
x7_pt100 = p50_x7_pt100;
x8_pt100 = p50_x8_pt100;
x5_i1 = p50_x5_i1;
x5_i2 = p50_x5_i2;
x6_i1 = p50_x6_i1;
x6_i2 = p50_x6_i2;
x7_i1 = p50_x7_i1;
x7_i2 = p50_x7_i2;
x8_i1 = p50_x8_i1;
x8_i2 = p50_x8_i2;
}
}
else if (nperif == 1)
{
if (nmess == 0)
{
p1_x1_pt100 = p50_x1_pt100;
p1_x2_pt100 = p50_x2_pt100;
p1_x3_pt100 = p50_x3_pt100;
p1_x4_pt100 = p50_x4_pt100;
p1_x1_i1 = p50_x1_i1;
p1_x1_i2 = p50_x1_i2;
p1_x2_i1 = p50_x2_i1;
p1_x2_i2 = p50_x2_i2;
p1_x3_i1 = p50_x3_i1;
p1_x3_i2 = p50_x3_i2;
p1_x4_i1 = p50_x4_i1;
p1_x4_i2 = p50_x4_i2;
}
else if (nmess == 1)
{
p1_x5_pt100 = p50_x5_pt100;
p1_x6_pt100 = p50_x6_pt100;
p1_x7_pt100 = p50_x7_pt100;
p1_x8_pt100 = p50_x8_pt100;
p1_x5_i1 = p50_x5_i1;
p1_x5_i2 = p50_x5_i2;
p1_x6_i1 = p50_x6_i1;
p1_x6_i2 = p50_x6_i2;
p1_x7_i1 = p50_x7_i1;
p1_x7_i2 = p50_x7_i2;
p1_x8_i1 = p50_x8_i1;
p1_x8_i2 = p50_x8_i2;
}
}
for (i = 0; i < 8; i++) *(__xn_pt100_raw__[i]) = *(p50__xn_pt100_raw__[i]); // PT100 RAW
for (i = 0; i < 8; i++) *(__xn_pt100__[i]) = *(p50__xn_pt100__[i]); // PT100 CELSIUS
// fai il parsing in base al numero di periferica
//puzzle_parse_perif(nperif);
}
void puzzle_task_can_rx()
{
while (1) {
if ( canbase_rxmsg(&CAN_RXBuf) ) {
puzzle_parse_frame(CAN_RXBuf);
puzzle_can_rx_cnt++;
puzzle_disc_cnt = 0;
}
idle();
}
}
int puzzle_max = 0;
void puzzle_task_can()
{
int nper = 0;
puzzle_nperif = PUZZLE_PERIFS;
while (1) {
//puzzle_can_cnt++;
// ciclo sulle periferiche
puzzle_send_frame(nper, ntx_frame);
ntx_frame = (ntx_frame + 1) % 4;
if ((ntx_frame == 3) && !p_ext2_on) { ntx_frame = 0; }
// scatta alla periferica successiva
if (ntx_frame == 0) nper = (nper + 1) % PUZZLE_PERIFS;
if (puzzle_disc_cnt < 1000) {
puzzle_disc_cnt++;
puzzle_perif_on = 1;
} else {
puzzle_perif_on = 0;
}
every(3);
}
}
void puzzle_start_can(char e1, char e2)
{
puzzle_com = P_CAN;
p_ext1_on = e2;
p_ext2_on = e1;
#ifdef linux
canbase_init(4, 670000);
#else
canbase_init(4, 0x0048c003);
CAN_AFMR = 0x00000002L;
CAN1IER = 0;
CAN1MOD = 1;
CAN1GSR = 0;
CAN1BTR = 0x003CC004; // 670KHz
CAN1IER = 1;
CAN1MOD = 4;
#endif
exec_task(puzzle_task_can, 0, 4);
exec_task(puzzle_task_can_rx, 0, 4);
}
void puzzle_stop_can()
{
remove_task(puzzle_task_can);
remove_task(puzzle_task_can_rx);
}
//------------------- BOOTLOADER ------------------
#define N_HIGH(x) (((x)>>8) & 0xFF)
#define N_LOW(x) ((x) & 0xFF)
void install_fupdate(void);
U8 byte_chsum(U8 b);
U8 chsum(U8 *buf, int len);
void RX_fupdate(COM *);
void puzzle_fupdate(void);
int pfile_nchunks(FILE *);
int firmware_present(void);
int pboot_status=0;
int pupdate_perc=0;
int rxflag=0; // setto a 1 dall'interrupt di rx
U8 prx_buf[10];
U8 ptx_buf[36]; // byte 0: start, bytes 1-2: nprog, bytes 3-34: payload, byte 35: chsum
int update_cnt=0;
int num_pacchetti=0;
int pnprog=0;
FILE *pfile;
U8 *pfhead; // puntatore alla porzione di heap che contiene il file
int pfirmware_source=0; // 0: USB, 1: SD
void install_fupdate()
{
Com = PortaCOM;
com_close(Com);
com_disable(Com);
com_open(Com,115200);
protocol_mode(Com,1); // COMx IN MODO 1 (BLOAD/BSAVE)
onrx(Com,RX_fupdate);
Com->centr=0x01; // centr = who sends
Com->perif=0x02; // perif = who receives
com_enable(Com); // ABILITA LA COM
}
void RX_fupdate(COM *Com)
{
rxflag=1;
int rxsize=0;
rxsize = bload(PortaCOM, prx_buf, 3);
}
U8 byte_chsum(U8 b)
{
int i=0;
U8 ret=0;
for (i=0; i<8; i++) {
ret += (b >> i) & 1;
}
return (U8)ret;
}
U8 chsum(U8 *buf, int len)
{
// len must be <= 256
if (len > 256) len=256;
int i=0;
U8 ret=0;
for (i=0; i<len; i++) ret += byte_chsum(buf[i]);
return (U8)ret;
}
int pfile_nchunks(FILE *mfp)
{
// ritorna il numero di chunks da 32 bytes ciascuno del file
int size, ret;
fseek(mfp, 0, SEEK_END);
size = ftell(mfp);
fseek(mfp, 0, SEEK_SET);
ret = size / 32;
if ( (size%32) > 0 ) ret++;
return ret;
}
int firmware_present() // NB: vale solo per terminale Puzzle
{
/*
int usb = 0;
usb = usb_present();
if ( !usb ) return 0;
*/
char pfname[20];
if (pfirmware_source == 0) sprintf(pfname, "D:\\FIRMWARE.BIN");
else sprintf(pfname, "C:\\FIRMWARE.BIN");
FILE *fwfp;
//fwfp = fopen("D:\\FIRMWARE.BIN","r");
fwfp = fopen(pfname,"r");
if (fwfp) { fclose(fwfp); return 1; }
else { fclose(fwfp); return 0; }
}
void puzzle_fupdate()
{
while (1) {
update_cnt++;
switch (pboot_status) {
case 0: // reset variabili
num_pacchetti=0;
pupdate_perc=0;
pnprog=0;
pboot_status=1;
break;
case 1: // invio segnale di freezing del boot
pnprog = 0;
ptx_buf[0] = 0xFB;
ptx_buf[1] = 0xC1;
ptx_buf[2] = 0xBB;
bsave(PortaCOM, ptx_buf, 3);
rxflag=0;
if ( num_pacchetti > 0 ) pboot_status=5;
else pboot_status=3;
break;
case 3: // preparo il file
if (pfirmware_source == 0) {
pfile = fopen("D:\\FIRMWARE.BIN","r");
} else {
pfile = fopen("C:\\FIRMWARE.BIN","r");
}
if (pfile) {
num_pacchetti = pfile_nchunks(pfile);
pboot_status = 5;
} else {
pboot_status = 900;
}
break;
case 5: // attesa ricezione ACK
if (rxflag==1) { rxflag=0; pboot_status=10; }
else { pboot_status=1; }
break;
case 10: // verifica ACK
if (prx_buf[0]==0xC1 && prx_buf[1]==0xFB && prx_buf[2]==0xBB) pboot_status=15;
else pboot_status=1;
break;
case 15: // ACK ricevuto, calcolo e mando il numero di chunks
ptx_buf[0] = 0xC1; // byte di controllo
ptx_buf[1] = N_HIGH(num_pacchetti); // n pacchetti
ptx_buf[2] = N_LOW(num_pacchetti); // n pacchetti
ptx_buf[3] = chsum(&ptx_buf[1], 2); // checksum
rxflag=0;
bsave(PortaCOM, ptx_buf, 4);
pboot_status=20;
break;
case 20: // attesa ACK header
if (rxflag==1) { rxflag=0; pboot_status=25; } // pacchetto ricevuto
else pboot_status=15; // rimando il pacchetto
break;
case 25: // verifica ACK, se OK vai avanti
if (prx_buf[0]==0xC2 && prx_buf[1]==0xFB && prx_buf[2]==0xBB) pboot_status=28;
else pboot_status=15; // rimando l'header
break;
case 28: // leggo chunk dal file
fread( (U8 *)(&ptx_buf[3]), 32, 1, pfile );
pboot_status = 30;
break;
case 30: // mando i pacchetti
ptx_buf[0] = 0xB1; // start
ptx_buf[1] = N_HIGH(pnprog);
ptx_buf[2] = N_LOW(pnprog);
ptx_buf[35] = chsum(&ptx_buf[3], 32); // checksum
rxflag=0;
bsave(PortaCOM, ptx_buf, 36);
pboot_status = 35;
break;
case 35: // attesa ACK pacchetto
if (rxflag==1) { rxflag=0; pboot_status=40; }
else pboot_status=30; // rimando il pacchetto
break;
case 40: // verifica ACK
if (prx_buf[0] == 0xC3 && prx_buf[1] == N_HIGH(pnprog) && prx_buf[2] == N_LOW(pnprog)) {
// ACK ok, manda pacchetto successivo o vai alla fine se era l'ultimo
pnprog++;
pupdate_perc = (100*pnprog)/num_pacchetti;
if (pnprog < num_pacchetti) { pboot_status = 28; break; } // pacchetto successivo
else { pboot_status = 70; } // manda flag di fine trasmissione
} else {
pboot_status = 30; // rimando pacchetto pnprog
}
break;
case 70: // flag di fine trasmissione
ptx_buf[0] = 0xC9;
ptx_buf[1] = 0xFB;
ptx_buf[2] = 0xBB;
bsave(PortaCOM, ptx_buf, 3);
pboot_status = 1000;
break;
case 900: // file D:\\FIRMWARE.BIN non presente
fclose(pfile); // prova
break;
case 1000: // fine invio
fclose(pfile);
// riavvia il task puzzle, e resetta tutte le variabili del caso
pboot_status = 0;
if ( puzzle_com == P_RS485 ) puzzle_start();
else puzzle_start_can(p_ext1_on, p_ext2_on);
remove_task(puzzle_fupdate);
break;
default:
break;
}
wait(20);
}
}