void massive_cancel(void)
{
int count;
for (count=0;count<10;count++)
send_short(CAN_CHR);
}
int receiver_driven_start(int mode)
{
int attempts = 0;
char charbuf;
char mode_letter;
int cur_timer;
switch (mode)
{
case X_MODEM_PROTOCOL: mode_letter = NAK_CHR;
break;
case X_MODEM_CRC_PROTOCOL: mode_letter = 'C';
break;
case X_MODEM_1K_PROTOCOL: mode_letter = 'C';
break;
case Y_MODEM_PROTOCOL: mode_letter = 'C';
break;
}
while (attempts++ < 20)
{
delay(10);
empty_inbuffer(tswitch);
send_short(mode_letter);
wait_for_xmit(tswitch,30);
cur_timer = dans_counter;
while (((dans_counter - cur_timer) < SMALL_TIMEOUT_TICKS) &&
(!(charbuf=char_in_buf(tswitch)))) next_task();
if (charbuf) return (0);
}
return (-1);
}
void send_packet(char *buffer, int length, char packetno, char checksum_type)
{
if (length == 128) send_short(SOH_CHR);
else send_short(STX_CHR);
send_short(packetno);
send_short(~packetno);
send_buffer(buffer,length);
switch (checksum_type)
{
case CRC_8: send_short(calc_8bit_checksum(buffer,length));
break;
case CRC_16: send_integer(calc_crc_checksum((unsigned char *)buffer,length));
break;
}
wait_for_xmit(tswitch,30);
};
static void calculate_and_publish(capture_channel_definition_t *channel_definition)
{
// signal one more clock timeout
channel_definition->publish_count++;
if(channel_definition->publish_count >= channel_definition->can_channel.publish_frequency)
{
float result;
// calculate the result first
if(channel_definition->capture_count == 0)
channel_definition->result = 0;
else
{
// take the average value
channel_definition->result /= channel_definition->capture_count;
// the result is a count of 20mhz / 256 intervals
channel_definition->result *= 0.0000128;
// convert to a frequency
channel_definition->result = 1 / channel_definition->result;
}
// otherwise use the parameter driven conversions.
if(channel_definition->can_channel.scale != 1.0)
channel_definition->result *= channel_definition->can_channel.scale;
if(channel_definition->can_channel.offset != 0.0)
channel_definition->result += channel_definition->can_channel.offset;
// if we have a result processor then we just pass the filtered value to it to be processed.
if(channel_definition->result_proc != 0)
result = channel_definition->result_proc(channel_definition, channel_definition->result);
else
result = channel_definition->result;
// we send the value (frequency) as a 16 bit number
send_short(result, &(channel_definition->can_channel));
// reset counter so that we calculate the next period
channel_definition->result = -1;
channel_definition->capture_count = 0;
}
}
int main()
{
int class; //da trasformate in alt_u8 o 16 in base alle dimensioni
int vote;
int end_class;
alt_u16 command[256];
alt_u16 ack_cmd[3];
alt_u32 tr_size;
alt_u32 tr_size_count;
alt_u8 q_size;
alt_u32 n_packet;
alt_u32 tr_val;
alt_u64 addr; //verificare dimensione
alt_u64 q_addr;
alt_u32 q_val;
alt_u32 i = 0;
alt_u32 k = 0;
alt_u8 k_val;
alt_u16 n_dim;
alt_u16 n_load;
alt_u16 n_load_count;
alt_u16 n_cell;
alt_u16 n_cell_last;
alt_u64 count = 0;
alt_u16 cache_q_addr = 0;
alt_dma_txchan txchan;
alt_dma_rxchan rxchan;
alt_u32 memptr = 0;
alt_u8 empty0 = 0;
alt_u8 empty1 = 0;
alt_u8 overflow = 0;
unsigned char ledvalue = 1;
void* tx_data; /* pointer to data to send */
void* rx_buffer; /* pointer to rx buffer */
while(1)
{
command[0] = 0;
recv_short(command, 8);
//send back the ACK
ack_cmd[0] = ACK;
ack_cmd[1] = ACK;
ack_cmd[2] = command[3];
send_short(ack_cmd, 3);
if(command[0] == FLUSH_COMM)
{
tr_size = 0;
tr_size = command[1];
tr_size = tr_size<<16;
tr_size = tr_size | command[2];
n_packet = 0;
n_packet = command[3];
n_packet = n_packet<<16;
n_packet = n_packet | command[4];
cache_q_addr = command[5];
addr = 0;
tr_size_count = 0;
for(i = 0; i < n_packet;i++)
{
recv_short(command, 256);
send_short(command, 256);
for(k = 0;k < 127; k++)
{
if(tr_size_count < tr_size)
{
tr_size_count = tr_size_count + 1;
tr_val = 0;
tr_val = command[2+2*k];
tr_val = tr_val<<16;
tr_val = tr_val | command[3+2*k];
IOWR_32DIRECT(SDRAM_CONTROLLER_BASE,addr,tr_val);
addr = addr + 0x04;
}
}
}
ack_cmd[0] = ACK;
ack_cmd[1] = ACK;
ack_cmd[2] = command[3];
send_short(ack_cmd, 3);
}
else if(command[0] == CLASS_CMD)
{
q_size = 0;
q_size = command[1];
q_size = q_size<<16;
q_size = q_size | command[2];
n_dim = 0;
n_dim = command[3];
k_val = 0;
k_val = command[4];
n_load = 0;
n_load = command[5];
n_cell = 0;
n_cell = command[6];
n_cell_last = 0;
n_cell_last = command[7];
for(i = 0; i < 1;i++)
{
recv_short(command, 256);
send_short(command, 256);
}
q_addr = SDRAM_Q_ADDR_BASE;
for(i = 0;i < q_size; i++)
{
q_val = 0;
q_val = command[2*i];
q_val = q_val<<16;
q_val = q_val | command[1+2*i];
IOWR_32DIRECT(SDRAM_CONTROLLER_BASE, q_addr, q_val);
q_addr = q_addr + 0x04;
}
// set the number of dimension MAX = 256
IOWR_32DIRECT(KNNCLASSCORE_BASE, STARTCLREG,0x00000000);
IOWR_32DIRECT(BASEQADDR_0_BASE,0x00,cache_q_addr);
IOWR_32DIRECT(SKIPADDRREG_0_BASE,0x00,(q_size+1)*4);
IOWR_32DIRECT(NDIMREG_BASE,0x00,n_dim);
// number of training val in each mem
IOWR_32DIRECT(NTRREG_0_BASE,0x00,3);
IOWR_32DIRECT(NTRREG_1_BASE,0x00,3);
// k val
IOWR_32DIRECT(KNNCLASSCORE_BASE,KVALREG,k_val);
IOWR_32DIRECT(ENDTSETREG_0_BASE,0x00,0);
IOWR_32DIRECT(ENDTSETREG_1_BASE,0x00,0);
load_q_cache1 = 0;
load_q_cache0 = 0;
IOWR_32DIRECT(FULLREG_0_BASE,0x00,0x00000000);
IOWR_32DIRECT(FULLREG_1_BASE,0x00,0x00000000);
PERF_RESET(PERFORMANCE_COUNTER_0_BASE);
PERF_START_MEASURING(PERFORMANCE_COUNTER_0_BASE);
PERF_BEGIN(PERFORMANCE_COUNTER_0_BASE,1);
IOWR_32DIRECT(KNNCLASSCORE_BASE, STARTCLREG,0x00000001);
txchan = alt_dma_txchan_open("/dev/dma");
rxchan = alt_dma_rxchan_open("/dev/dma");
alt_dma_txchan_ioctl(txchan, ALT_DMA_SET_MODE_32, NULL);
alt_dma_rxchan_ioctl(rxchan, ALT_DMA_SET_MODE_32, NULL);
txrx_doneCache0 = 0;
tx_data = (void*)(SDRAM_CONTROLLER_BASE+SDRAM_Q_ADDR_BASE); /* pointer to data to send */
rx_buffer = (void*)(DMA_WRITE_MASTER_CACHE_0_BASE+cache_q_addr);//CUSTOM_RAM_0_BASE
alt_dma_txchan_send (txchan,tx_data,q_size*4,NULL,NULL);
alt_dma_rxchan_prepare (rxchan,rx_buffer,q_size*4, txrxDoneCache0,NULL);
alt_dma_txchan_ioctl(txchan, ALT_DMA_SET_MODE_32, NULL);
alt_dma_rxchan_ioctl(rxchan, ALT_DMA_SET_MODE_32, NULL);
txrx_doneCache1 = 0;
tx_data = (void*)(SDRAM_CONTROLLER_BASE+SDRAM_Q_ADDR_BASE); /* pointer to data to send */
rx_buffer = (void*)(DMA_WRITE_MASTER_CACHE_1_BASE+cache_q_addr);//CUSTOM_RAM_0_BASE
alt_dma_txchan_send (txchan,tx_data,q_size*4,NULL,NULL);
alt_dma_rxchan_prepare (rxchan,rx_buffer,q_size*4, txrxDoneCache1,NULL);
IOWR_ALTERA_AVALON_PIO_DATA(PIO_0_BASE, ledvalue);
ledvalue++;
n_load_count = 0;
memptr = 0;
IOWR_32DIRECT(KNNCLASSCORE_BASE,STARTCLREG,1); //modificato qui
//fill cache 0
empty0 = IORD_32DIRECT(EMPTYREG_0_BASE,0x00);
empty1 = IORD_32DIRECT(EMPTYREG_1_BASE,0x00);
while(txrx_doneCache1==0 || txrx_doneCache1==0);
while(n_load_count < n_load)
{
if(empty0 && (n_load_count < n_load) && txrx_doneCache0 ) // && !endmem0
{
IOWR_32DIRECT(FULLREG_0_BASE,0x00,0x00000000);
IOWR_32DIRECT(ENDTSETREG_0_BASE,0x00,0);
if(n_load_count == n_load-1)
IOWR_32DIRECT(NTRREG_0_BASE, 0x00,n_cell_last/(4*(q_size+1)));
else
IOWR_32DIRECT(NTRREG_0_BASE, 0x00,n_cell/(4*(q_size+1)));
txrx_doneCache0 = 0;
alt_dma_txchan_ioctl(txchan, ALT_DMA_SET_MODE_32, NULL);
alt_dma_rxchan_ioctl(rxchan, ALT_DMA_SET_MODE_32, NULL);
tx_data = (void*)(SDRAM_CONTROLLER_BASE+memptr); /* pointer to data to send */
rx_buffer = (void*)(DMA_WRITE_MASTER_CACHE_0_BASE);//CUSTOM_RAM_0_BASE
if(n_load_count == n_load-1)
{
alt_dma_txchan_send (txchan,tx_data,n_cell_last,NULL,NULL);
alt_dma_rxchan_prepare (rxchan,rx_buffer,n_cell_last, txrxDoneCache0,NULL);
}
else
{
alt_dma_txchan_send (txchan,tx_data,n_cell,NULL,NULL);
alt_dma_rxchan_prepare (rxchan,rx_buffer,n_cell, txrxDoneCache0,NULL);
}
memptr = memptr + n_cell;
n_load_count++;
IOWR_32DIRECT(FULLREG_0_BASE,0x00,0x00000001);
}
if(empty1 && (n_load_count< n_load) && txrx_doneCache1) // && !endmem0
{
//fill cache 1
IOWR_32DIRECT(FULLREG_1_BASE,0x00,0x00000000);
IOWR_32DIRECT(ENDTSETREG_1_BASE,0x00,0); //era 1
if(n_load_count == n_load-1)
IOWR_32DIRECT(NTRREG_1_BASE, 0x00,n_cell_last/(4*(q_size+1)));
else
IOWR_32DIRECT(NTRREG_1_BASE, 0x00,n_cell/(4*(q_size+1)));
alt_dma_txchan_ioctl(txchan, ALT_DMA_SET_MODE_32, NULL);
alt_dma_rxchan_ioctl(rxchan, ALT_DMA_SET_MODE_32, NULL);
txrx_doneCache1 = 0;
tx_data = (void*)(SDRAM_CONTROLLER_BASE+memptr); /* pointer to data to send */
rx_buffer = (void*)(DMA_WRITE_MASTER_CACHE_1_BASE);//CUSTOM_RAM_0_BASE
if(n_load_count == n_load-1)
{
alt_dma_txchan_send (txchan,tx_data,n_cell_last,NULL,NULL);
alt_dma_rxchan_prepare (rxchan,rx_buffer,n_cell_last, txrxDoneCache1,NULL);
}
else
{
alt_dma_txchan_send (txchan,tx_data,n_cell,NULL,NULL);
alt_dma_rxchan_prepare (rxchan,rx_buffer,n_cell, txrxDoneCache1,NULL);
}
memptr = memptr + n_cell;
n_load_count++;
IOWR_32DIRECT(FULLREG_1_BASE,0x00,0x00000001);
}
empty0 = IORD_32DIRECT(EMPTYREG_0_BASE,0x00);
empty1 = IORD_32DIRECT(EMPTYREG_1_BASE,0x00);
}
while(txrx_doneCache1==0 || txrx_doneCache1==0);
//while(empty0==0 || empty1==0);
IOWR_32DIRECT(ENDTSETREG_0_BASE,0x00,1); //era 1
IOWR_32DIRECT(ENDTSETREG_1_BASE,0x00,1); //era 1
end_class = 0;
while (!end_class)
end_class = IORD_32DIRECT(KNNCLASSCORE_BASE,ENDCLASSREG);
alt_dma_txchan_close(txchan);
alt_dma_rxchan_close(rxchan);
PERF_END(PERFORMANCE_COUNTER_0_BASE,1);
class = IORD_32DIRECT(KNNCLASSCORE_BASE,CLREG);
vote = IORD_32DIRECT(KNNCLASSCORE_BASE,NVOTREG);
count = perf_get_section_time(PERFORMANCE_COUNTER_0_BASE,1);
overflow = IORD_32DIRECT(KNNCLASSCORE_BASE,OVERFLOWREG);
command[0] = class;
command[1] = vote;
command[2] = count;
count = count>>16;
command[3] = count;
count = count>>16;
command[4] = count;
count = count>>16;
command[5] = count;
command[6] = overflow;
addr = 0;
for(i=0; i < 16; i++)
{
command[7+i] = IORD_32DIRECT(KNNCLASSCORE_BASE,addr);
addr = addr + 0x04;
}
send_short(command, 23);
}
}
int receive_ymodem_protocol(char *filename, int mode, int *last_file)
{
int result;
int packetno = 0;
int gotpacketno;
char *buffer;
FILE *fileptr = 0;
unsigned long int curlength = 0;
unsigned long int maxlength = 0;
int flag = 1;
int not_received;
int not_got_mode_type = 1;
int length;
int attempts;
int keep_packet;
int ymodem_block0 = 1;
#ifdef DEBUG
char s[80];
#endif
#ifdef DEBUG
print_str_cr_to("Started protocol",0);
#endif
buffer = g_malloc(MAX_PROTO_BUFFER_SIZE,"RECVYMDM");
if (!buffer)
{
massive_cancel();
return (-1);
}
wait_for_sending_state(SMALL_TIMEOUT_TICKS,0);
empty_inbuffer(tswitch);
while (flag)
{
not_received = 1;
attempts = 0;
while (not_received && (attempts++ < 20))
{
if (not_got_mode_type)
{
if (receiver_driven_start(mode))
{
massive_cancel();
if (fileptr) g_fclose(fileptr);
g_free(buffer);
return (-1);
}
}
result=recv_packet(buffer,&length,&gotpacketno,CRC_16);
wait_for_sending_state(SMALL_TIMEOUT_TICKS,0);
empty_inbuffer(tswitch);
#ifdef DEBUG
sprintf(s,"Received packet %03d result %03d",gotpacketno,result);
print_str_cr_to(s,0);
#endif
switch (result)
{
case CAN_CHR: if (check_cancel())
{
massive_cancel();
if (fileptr) g_fclose(fileptr);
g_free(buffer);
return (-1);
}
break;
case ACK_CHR: if (((unsigned char)gotpacketno) ==
((unsigned char)last_packet(packetno)))
{
keep_packet = 0;
send_short(ACK_CHR);
not_received = 0;
} else
if (((unsigned char)gotpacketno) ==
((unsigned char)packetno))
{
keep_packet = 1;
send_short(ACK_CHR);
not_received = 0;
not_got_mode_type = 0;
} else
send_short(NAK_CHR);
break;
case NAK_CHR: if (!not_got_mode_type)
{
massive_cancel();
if (fileptr) g_fclose(fileptr);
g_free(buffer);
return (-1);
}
break;
case EOT_CHR: flag = 0;
keep_packet = 0;
send_short(ACK_CHR);
not_received = 0;
break;
case (-1): if (!not_got_mode_type) send_short(NAK_CHR);
break;
}
}
if (not_received)
{
massive_cancel();
if (fileptr) g_fclose(fileptr);
g_free(buffer);
return (-1);
}
if (keep_packet)
{
if (ymodem_block0)
{
ymodem_block0 = 0;
decode_ymodem_block0(buffer,filename,&maxlength);
#ifdef DEBUG
sprintf(s,"Filename: %s length: %ld",filename,maxlength);
print_str_cr_to(s,0);
#endif
*last_file = !(*filename);
if (*last_file) flag = 0;
if (*filename)
{
if (proto_open_file(filename,&fileptr,"wb"))
{
g_free(buffer);
massive_cancel();
return (-1);
}
}
not_got_mode_type = 1;
} else
{
proto_write_buffer(fileptr,buffer,(int)
((maxlength-curlength)>(unsigned long int) length) ?
(unsigned long int) length :
(unsigned long int) (maxlength-curlength) );
curlength += length;
}
packetno++;
}
}
if (fileptr) g_fclose(fileptr);
g_free(buffer);
return (0);
}
int send_ymodem_protocol(char *filename, int mode)
{
int result;
int packetno = 0;
int attempts;
int crc_type;
char *buffer;
FILE *fileptr;
long int curlength = 0;
long int maxlength;
int blocklength;
int not_got_sensible;
int not_sent;
int ymodem_block0 = 1;
int lastpacket = 0;
#ifdef DEBUG
char s[80];
#endif
#ifdef DEBUG
print_str_cr_to("Started protocol",0);
#endif
result = sender_start(&crc_type);
if ((result == -1) || (result == CAN_CHR))
{
massive_cancel();
return (-1);
}
#ifdef DEBUG
print_str_cr_to("Received start",0);
#endif
if (*filename)
{
if (proto_open_file(filename,&fileptr,"rb"))
{
massive_cancel();
return (-1);
}
} else fileptr = 0;
#ifdef DEBUG
print_str_cr_to("opened file",0);
#endif
buffer = g_malloc(MAX_PROTO_BUFFER_SIZE,"SNDYMDM");
if (!buffer)
{
massive_cancel();
if (fileptr) g_fclose(fileptr);
return (-1);
}
if (fileptr) maxlength = 128 + proto_file_length(fileptr);
else maxlength = 128;
while (!lastpacket)
{
if (curlength >= maxlength) lastpacket = 1;
if (!lastpacket)
{
if (ymodem_block0)
{
create_ymodem_block0(buffer,filename,maxlength-128);
} else proto_read_buffer(fileptr,buffer,1024,&blocklength);
}
not_sent = 1;
attempts = 0;
while ((not_sent) && (attempts++ < 10))
{
empty_inbuffer(tswitch);
#ifdef DEBUG
if (lastpacket) print_str_cr_to("Last packet",0);
else
{
sprintf(s,"Sending packet %03d",packetno);
print_str_cr_to(s,0);
}
#endif
if (lastpacket) send_short(EOT_CHR);
else
{
if (ymodem_block0)
{
send_packet(buffer,128,packetno,crc_type);
if (!(*filename)) lastpacket = 1;
}
else
send_packet(buffer,1024,packetno,crc_type);
}
not_got_sensible = 1;
while (not_got_sensible)
{
result = time_char();
#ifdef DEBUG
sprintf(s,"Received char %03d",result);
print_str_cr_to(s,0);
#endif
switch (result)
{
case (-1): not_got_sensible = 0;
break;
case ACK_CHR: not_sent = 0;
not_got_sensible = 0;
break;
case NAK_CHR: not_got_sensible = 0;
break;
case CAN_CHR: if (check_cancel())
{
massive_cancel();
if (fileptr) g_fclose(fileptr);
g_free(buffer);
return (-1);
}
not_got_sensible = 0;
break;
}
}
}
if (not_sent)
{
massive_cancel();
g_free(buffer);
if (fileptr) g_fclose(fileptr);
return (-1);
}
if (!lastpacket)
{
if (ymodem_block0)
{
curlength += 128;
ymodem_block0 = 0;
} else curlength += 1024;
packetno++;
}
}
if (fileptr) g_fclose(fileptr);
g_free(buffer);
return 0;
}
void receive_xmodem_protocol(char *filename, int crc_type, int mode)
{
int result;
int packetno = 1;
int gotpacketno;
char *buffer;
FILE *fileptr;
long int curlength = 0;
int flag = 1;
int not_received;
int not_got_mode_type = 1;
int length;
int attempts;
int keep_packet;
#ifdef DEBUG
char s[80];
#endif
#ifdef DEBUG
print_str_cr_to("Started protocol",0);
#endif
if (proto_open_file(filename,&fileptr,"wb"))
{
massive_cancel();
return;
}
buffer = g_malloc(MAX_PROTO_BUFFER_SIZE,"RCVXMDM");
if (!buffer)
{
massive_cancel();
g_fclose(fileptr);
return;
}
#ifdef DEBUG
print_str_cr_to("Opened file",0);
#endif
wait_for_sending_state(SMALL_TIMEOUT_TICKS,0);
empty_inbuffer(tswitch);
while (flag)
{
not_received = 1;
attempts = 0;
while (not_received && (attempts++ < 20))
{
if (not_got_mode_type)
{
if (receiver_driven_start(mode))
{
massive_cancel();
g_fclose(fileptr);
g_free(buffer);
return;
}
}
result=recv_packet(buffer,&length,&gotpacketno,crc_type);
wait_for_xmit(tswitch,20);
wait_for_sending_state(SMALL_TIMEOUT_TICKS,0);
empty_inbuffer(tswitch);
#ifdef DEBUG
sprintf(s,"Received packet %03d result %03d",gotpacketno,result);
print_str_cr_to(s,0);
#endif
switch (result)
{
case CAN_CHR: if (check_cancel())
{
massive_cancel();
g_fclose(fileptr);
g_free(buffer);
return;
}
break;
case ACK_CHR: if (((unsigned char)gotpacketno) ==
((unsigned char)last_packet(packetno)))
{
keep_packet = 0;
send_short(ACK_CHR);
not_received = 0;
} else
if (((unsigned char)gotpacketno) ==
((unsigned char)packetno))
{
keep_packet = 1;
send_short(ACK_CHR);
not_received = 0;
not_got_mode_type = 0;
} else
send_short(NAK_CHR);
break;
case NAK_CHR: if (!not_got_mode_type)
{
send_short(NAK_CHR);
}
break;
case EOT_CHR: flag = 0;
keep_packet = 0;
send_short(ACK_CHR);
not_received = 0;
break;
case (-1): if (!not_got_mode_type) send_short(NAK_CHR);
break;
}
}
if (not_received)
{
massive_cancel();
g_fclose(fileptr);
g_free(buffer);
return;
}
if (keep_packet)
{
proto_write_buffer(fileptr,buffer,length);
curlength += length;
packetno++;
}
}
g_fclose(fileptr);
g_free(buffer);
}
void send_xmodem_protocol(char *filename, int length)
{
int result;
int packetno = 1;
int attempts;
int crc_type;
char *buffer;
FILE *fileptr;
long int curlength = 0;
long int maxlength;
int blocklength;
int not_got_sensible;
int not_sent;
#ifdef DEBUG
char s[80];
#endif
#ifdef DEBUG
print_str_cr_to("Started protocol",0);
#endif
result = sender_start(&crc_type);
if ((result == -1) || (result == CAN_CHR))
{
massive_cancel();
return;
}
#ifdef DEBUG
print_str_cr_to("Received start",0);
#endif
if (proto_open_file(filename,&fileptr,"rb"))
{
massive_cancel();
return;
}
#ifdef DEBUG
print_str_cr_to("opened file",0);
#endif
buffer = g_malloc(MAX_PROTO_BUFFER_SIZE,"SNDXMDM");
if (!buffer)
{
massive_cancel();
g_fclose(fileptr);
return;
}
maxlength = proto_file_length(fileptr);
while (curlength < maxlength)
{
proto_read_buffer(fileptr,buffer,length,&blocklength);
not_sent = 1;
attempts = 0;
while ((not_sent) && (attempts++ < 10))
{
empty_inbuffer(tswitch);
#ifdef DEBUG
sprintf(s,"Sending packet %03d",packetno);
print_str_cr_to(s,0);
#endif
send_packet(buffer,length,packetno,crc_type);
not_got_sensible = 1;
while (not_got_sensible)
{
result = time_char();
#ifdef DEBUG
sprintf(s,"Received char %03d",result);
print_str_cr_to(s,0);
#endif
switch (result)
{
case (-1): not_got_sensible = 0;
break;
case ACK_CHR: not_sent = 0;
not_got_sensible = 0;
break;
case NAK_CHR: not_got_sensible = 0;
break;
case CAN_CHR: if (check_cancel())
{
massive_cancel();
g_fclose(fileptr);
g_free(buffer);
return;
}
not_got_sensible = 0;
break;
}
}
}
if (not_sent)
{
massive_cancel();
g_free(fileptr);
g_fclose(fileptr);
return;
}
curlength += length;
packetno++;
}
send_short(EOT_CHR);
delay(10);
send_short(EOT_CHR);
g_fclose(fileptr);
g_free(fileptr);
}
void message_processing(unsigned char inMessage)
{
static char nb_recu = 0;
static int boolConfig = 0;
static TrameAsser t;
static TrameConfig tc;
short valeur;
Trame32 t32;
TrameAsser t16;
if(nb_recu == 0)
{
t.trShort.Xo = inMessage;
if (t.trDelta.codet == 0b010 ||t.trDelta.codet == 0b101 ||t.trDelta.codet == 0b000 ||
t.trDelta.codet == CODE_CONFIG || t.trDelta.codet == CODE_GET_XY || t.trDelta.codet == CODE_GET_ALPHA )
nb_recu++;
}
else if (nb_recu == 1)
{
t.trShort.oX = inMessage;
switch (t.trDelta.codet)
{
case CODE_DELTA : //0b10 : //delta
if (t.trDelta.signe == 1)
valeur = - t.trDelta.delta;
else
valeur = t.trDelta.delta;
//AD_consDelta = valeur*10950./1000.;
AD_consDelta = valeur*MM_TO_TICKS;
AD_consAlpha = 0;
nb_recu=0;
reset = 1;
break;
case CODE_ALPHA : //0b101 : //alpha
if (t.trAlpha.signe == 1)
valeur = - t.trAlpha.alpha;
else
valeur = t.trAlpha.alpha;
AD_consDelta = 0;
//AD_consAlpha = valeur*3.14/180.0;
AD_consAlpha = valeur*TICK_TOUR/360;
nb_recu=0;
reset = 1;
break;
case CODE_STOP : //0b000 :
AD_consDelta = 0;
AD_consAlpha = 0;
nb_recu=0;
reset = 1;
break;
case CODE_CONFIG : //0b111
boolConfig = 1;
tc.tr4Char.Xooo = t.trShort.Xo;
tc.tr4Char.oXoo = t.trShort.oX;
nb_recu++;
break;
case CODE_GET_XY :
nb_recu = 0;
t32.tpos.y = posY;
t32.tpos.x = posX;
if(posY < 0)
t32.tpos.y = 0;
if(posX <0)
t32.tpos.x = 0;
t32.tpos.codet = CODE_GET_XY;
send_long(t32.l);
break;
case CODE_GET_ALPHA :
nb_recu = 0 ;
if((AD_alphaTotal +AD_alpha) < 0)
{
unsigned long alphaCalc = - (AD_alphaTotal + AD_alpha);
alphaCalc %= (long int)TICK_TOUR;
alphaCalc *= 360;
alphaCalc /= (unsigned long int)TICK_TOUR;
t16.trAlpha.alpha = alphaCalc;
t16.trAlpha.signe = 1;
}
else
{
unsigned long alphaCalc = (AD_alphaTotal + AD_alpha);
alphaCalc %= (long int)TICK_TOUR;
alphaCalc *= 360;
alphaCalc /= (unsigned long int)TICK_TOUR;
t16.trAlpha.alpha = alphaCalc;
t16.trAlpha.signe = 0;
}
t16.trAlpha.codet = CODE_GET_ALPHA;
send_short(t16.us);
break;
}
}
else if (nb_recu == 2 )
{
tc.tr4Char.ooXo = inMessage;
nb_recu++;
}
else
{
tc.tr4Char.oooX = inMessage;
switch (tc.conf.pid)
{
case CODE_P : //0b00
switch (tc.conf.ad1)
{
case CODE_CONFIG_DELTA : //0b0
switch (tc.conf.ad2)
{
case CODE_CONFIG_DELTA : // 0b0
kP_delta.delta = tc.conf.ent;//(double)(tc.conf.ent + tc.conf.dec/100.);
break;
case CODE_CONFIG_ALPHA : // 0b1
kP_delta.alpha = tc.conf.ent;//(double)(tc.conf.ent + tc.conf.dec/100.);
break;
}
break;
case CODE_CONFIG_ALPHA : //0b1
switch (tc.conf.ad2)
{
case CODE_CONFIG_DELTA : // 0b0
kP_alpha.delta = tc.conf.ent;//(double)(tc.conf.ent + tc.conf.dec/100.);
break;
case CODE_CONFIG_ALPHA : // 0b1
kP_alpha.alpha = tc.conf.ent;//(double)(tc.conf.ent + tc.conf.dec/100.);
break;
}
break;
}
break;
case CODE_D : //0b10
switch (tc.conf.ad1)
{
case CODE_CONFIG_DELTA : //0b0
switch (tc.conf.ad2)
{
case CODE_CONFIG_DELTA : // 0b0
kD_delta.delta = tc.conf.ent;//(double)(tc.conf.ent + tc.conf.dec/100.);
break;
case CODE_CONFIG_ALPHA : // 0b1
kD_delta.alpha = tc.conf.ent;//(double)(tc.conf.ent + tc.conf.dec/100.);
break;
}
break;
case CODE_CONFIG_ALPHA : //0b1
switch (tc.conf.ad2)
{
case CODE_CONFIG_DELTA : // 0b0
kD_alpha.delta = tc.conf.ent;//(double)(tc.conf.ent + tc.conf.dec/100.);
break;
case CODE_CONFIG_ALPHA : // 0b1
kD_alpha.alpha = tc.conf.ent;//(double)(tc.conf.ent + tc.conf.dec/100.);
break;
}
break;
}
break;
}
nb_recu = 0;
}
}
void message_processing(unsigned char inMessage)
{
static char nb_recu = 0;
static int boolConfig = 0;
static TrameAsser t;
static TrameConfig tc;
short valeur;
Trame32 t32;
TrameAsser t16;
if (nb_recu == 0)
{
t.trShort.Xo = inMessage;
if (t.trGenShort.codet == 0b0100|| t.trGenShort.codet == 0b0101 ||
t.trGenShort.codet == CODE_ALPHA || t.trGenShort.codet == CODE_STOP ||
t.trGenShort.codet == CODE_CONFIG || t.trGenShort.codet == CODE_GET_XY ||
t.trGenShort.codet == CODE_GET_ALPHA || t.trGenShort.codet == CODE_SET_XY ||
t.trGenShort.codet == CODE_ALPHA_ABS ||
t.trGenShort.codet == CODE_PRES_GROS ||
t.trGenShort.codet == CODE_PRES_PRECIS ||
t.trGenShort.codet == CODE_SET_ALPHA || t.trGenShort.codet == CODE_FREE_WHEEL
)
nb_recu++;
}
else if (nb_recu == 1)
{
t.trShort.oX = inMessage;
switch (t.trGenShort.codet)
{
/*Cas du delta*/
/*C'set moche mais visiblement case 0x4 || 0x5: marche pas*/
case 0x4 :
if (t.trDelta.signe == 1)
valeur = -t.trDelta.delta;
else
valeur = t.trDelta.delta;
//AD_consDelta = valeur*10950./1000.;
AD_consDelta = valeur*MM_TO_TICKS;
AD_consAlpha = 0;
nb_recu = 0;
reset = 1;
freeWheel = 0;
break;
case 0x5 :
if (t.trDelta.signe == 1)
valeur = -t.trDelta.delta;
else
valeur = t.trDelta.delta;
//AD_consDelta = valeur*10950./1000.;
AD_consDelta = valeur*MM_TO_TICKS;
AD_consAlpha = 0;
nb_recu = 0;
reset = 1;
freeWheel = 0;
break;
/*Autre cas*/
case CODE_ALPHA: //0b101 : //alpha
if (t.trAlpha.signe == 1)
valeur = -t.trAlpha.alpha;
else
valeur = t.trAlpha.alpha;
AD_consDelta = 0;
//AD_consAlpha = valeur*3.14/180.0;
AD_consAlpha = valeur * TICK_TOUR / 360;
nb_recu = 0;
reset = 1;
freeWheel = 0;
break;
case CODE_ALPHA_ABS:
if (t.trAlpha.signe == 1)
valeur = -t.trAlpha.alpha;
else
valeur = t.trAlpha.alpha;
long int actuel = AD_alphaTotal; //alpha actuel
actuel %= (long int)TICK_TOUR;
long int demande = (long int)valeur;
demande *= TICK_TOUR;
demande /= 360;
demande %= (long int) TICK_TOUR;
long int diff = demande - actuel;
if (diff > TICK_TOUR/2)
{
diff = diff - TICK_TOUR;
}
else if (diff < -(TICK_TOUR/2))
{
diff = TICK_TOUR + diff;
}
AD_consDelta = 0;
AD_consAlpha = diff;
nb_recu = 0;
reset = 1;
freeWheel = 0;
break;
case CODE_SET_ALPHA:
nb_recu = 0;
if (t.trAlpha.signe == 1)
valeur = -t.trAlpha.alpha;
else
valeur = t.trAlpha.alpha;
alphaRad = (double)valeur*PI/180.0;//conversion en radian
AD_alphaTotal = alphaRad*(TICK_TOUR/DEUX_PI);//conversion en ticks
break;
case CODE_STOP: //0b0000 :
AD_consDelta = 0;
AD_consAlpha = 0;
nb_recu = 0;
reset = 1;
freeWheel = 0;
break;
case CODE_CONFIG: //0b111
boolConfig = 1;
tc.tr4Char.Xooo = t.trShort.Xo;
tc.tr4Char.oXoo = t.trShort.oX;
nb_recu++;
break;
case CODE_GET_XY:
nb_recu = 0;
t32.tpos.x = (int)(dXdouble*TICKS_TO_MM);
t32.tpos.y = (int)(dYdouble*TICKS_TO_MM);
if ((int)t32.tpos.y < 0)
t32.tpos.y = 0;
if ( (int)t32.tpos.x < 0)
t32.tpos.x = 0;
t32.tpos.codet = CODE_GET_XY;
send_long(t32.l);
break;
case CODE_GET_ALPHA:
nb_recu = 0;
if ((AD_alphaTotal ) < 0)
{
unsigned long alphaCalc = -(AD_alphaTotal);
alphaCalc %= (long int) TICK_TOUR;
alphaCalc *= 360;
alphaCalc /= (unsigned long int) TICK_TOUR;
t16.trAlpha.alpha = alphaCalc;
t16.trAlpha.signe = 1;
}
else
{
unsigned long alphaCalc = (AD_alphaTotal);
alphaCalc %= (long int) TICK_TOUR;
alphaCalc *= 360;
alphaCalc /= (unsigned long int) TICK_TOUR;
t16.trAlpha.alpha = alphaCalc;
t16.trAlpha.signe = 0;
}
t16.trAlpha.codet = CODE_GET_ALPHA;
send_short(t16.us);
break;
case CODE_SET_XY:
nb_recu++;
tc.tr4Char.Xooo = t.trShort.Xo;
tc.tr4Char.oXoo = t.trShort.oX;
break;
case CODE_PRES_GROS:
nb_recu = 0;
setGros();
break;
case CODE_PRES_PRECIS:
nb_recu = 0;
setPrecis();
break;
case CODE_FREE_WHEEL :
freeWheel = 1;
nb_recu = 0;
break;
}
}
else if (nb_recu == 2)
{
tc.tr4Char.ooXo = inMessage;
nb_recu++;
}
else
{
tc.tr4Char.oooX = inMessage;
if (tc.tpos.codet == CODE_SET_XY)//Le psoc veut définir la position
{
int px = (int)tc.tpos.x;
int py = (int)tc.tpos.y;
// on l'un des param est -1 on ne le met pas a jour
if (px < 0xFFF)//sur 12 bits
dXdouble = (double) (px * MM_TO_TICKS);
if (py < 0xFFF)
dYdouble = (double) (py * MM_TO_TICKS);
if (dYdouble < 0)
dYdouble = 0;
if (dXdouble < 0)
dXdouble = 0;
}
else
{
switch (tc.conf.pid)
{
case CODE_P: //0b00
switch (tc.conf.ad1)
{
case CODE_CONFIG_DELTA: //0b0
switch (tc.conf.ad2)
{
case CODE_CONFIG_DELTA: // 0b0
kP_delta.delta = tc.conf.ent; //(double)(tc.conf.ent + tc.conf.dec/100.);
break;
case CODE_CONFIG_ALPHA: // 0b1
kP_delta.alpha = tc.conf.ent; //(double)(tc.conf.ent + tc.conf.dec/100.);
break;
}
break;
case CODE_CONFIG_ALPHA: //0b1
switch (tc.conf.ad2)
{
case CODE_CONFIG_DELTA: // 0b0
kP_alpha.delta = tc.conf.ent; //(double)(tc.conf.ent + tc.conf.dec/100.);
break;
case CODE_CONFIG_ALPHA: // 0b1
kP_alpha.alpha = tc.conf.ent; //(double)(tc.conf.ent + tc.conf.dec/100.);
break;
}
break;
}
break;
case CODE_D: //0b10
switch (tc.conf.ad1)
{
case CODE_CONFIG_DELTA: //0b0
switch (tc.conf.ad2)
{
case CODE_CONFIG_DELTA: // 0b0
kD_delta.delta = tc.conf.ent; //(double)(tc.conf.ent + tc.conf.dec/100.);
break;
case CODE_CONFIG_ALPHA: // 0b1
kD_delta.alpha = tc.conf.ent; //(double)(tc.conf.ent + tc.conf.dec/100.);
break;
}
break;
case CODE_CONFIG_ALPHA: //0b1
switch (tc.conf.ad2)
{
case CODE_CONFIG_DELTA: // 0b0
kD_alpha.delta = tc.conf.ent; //(double)(tc.conf.ent + tc.conf.dec/100.);
break;
case CODE_CONFIG_ALPHA: // 0b1
kD_alpha.alpha = tc.conf.ent; //(double)(tc.conf.ent + tc.conf.dec/100.);
break;
}
break;
}
break;
}
}
nb_recu = 0;
}
}
