// Set the date on the MFD
void out_saitek_t::set_date(int year, int month, int day)
{
if (!a_attached) return;
int res;
if (a_product == x52_other_device) return;
unsigned short datedata = day | (month<<8);
unsigned short yeardata = year;
res = send_usb(0xC4,datedata);
if (res < 0) debug_out(err,"out_saitek: cannot set day to %d and month to %d: %s",day,month,usb_error(res));
res = send_usb(0xC8,yeardata);
if (res < 0) debug_out(err,"out_saitek: cannot set year to %d: %s",year,usb_error(res));
}
int writeLCD(char * buffer, byte length, struct usb_dev_handle * USB_handle)
{
int RecvLength;
int SendLength;
//int Comm_OK=0;
byte send_buf[64],receive_buf[64];
int retval=0;
int errchk;
int i;
send_buf[0]=PUT_LCD; //Set main command.
send_buf[1]= (byte)length;
for (i=0;i<length; ++i){ //Copy print buffer into send buffer
send_buf[i+2]=(buffer[i]);
}
SendLength=2+length; // Outbound packet length
RecvLength=2; // [1]token, [2]length
send_usb(USB_handle, SendLength, send_buf);
recv_usb(USB_handle, RecvLength, receive_buf);
errchk=receive_buf[1];
if (length != errchk){
printf("writeLCD: Wrong string length returned: Requested:%d Returned:%d\n", length, errchk);
retval=1;
}
return (retval);
} //END: writeLCD
int readADC (unsigned char channel, struct usb_dev_handle * USB_handle)
{
int RecvLength;
int SendLength;
//int Comm_OK=0;
byte send_buf[64],receive_buf[64];
int retval=0;
int errchk;
send_buf[0]=READ_ADC; //Set main command.
send_buf[1]= channel;
SendLength=2; //5 bytes in the outbound packet.
RecvLength=4;
send_usb(USB_handle, SendLength, send_buf);
recv_usb(USB_handle, RecvLength, receive_buf);
errchk=receive_buf[3];
if (channel != errchk){
printf("readADC: Wrong ADC channel returned: Requested:%d Returned:%d\n", channel, errchk);
//retval=1;
}
retval=(unsigned char)receive_buf[1]*256+(unsigned char)receive_buf[2];
return (retval);
} //END: readADC
int send_picline(struct astribank_device *astribank, uint8_t card_type, enum pic_command pcmd, int offs, uint8_t *data, int data_len)
{
int recv_answer = 0;
char buf[PACKET_SIZE];
struct xpp_packet_header *phead = (struct xpp_packet_header *)buf;
int pack_len;
int ret;
assert(astribank != NULL);
pack_len = data_len + sizeof(phead->header) + sizeof(phead->d.pic_packet.pic_header);
phead->header.len = pack_len;
phead->header.op = PIC_REQ_XOP;
phead->header.unit = 0x00;
phead->d.pic_packet.pic_header.flags = pcmd;
phead->d.pic_packet.pic_header.card_type = card_type;
phead->d.pic_packet.pic_header.offs = offs;
if(data)
memcpy(phead->d.pic_packet.data, data, data_len);
switch (pcmd) {
case PIC_START_FLAG:
break;
case PIC_DATA_FLAG:
break;
case PIC_END_FLAG:
recv_answer = 1;
break;
case PIC_ENDS_FLAG:
break;
}
DBG("PICLINE: pack_len=%d pcmd=%d\n", pack_len, pcmd);
dump_packet(LOG_DEBUG, "dump:picline[W]", (char *)phead, pack_len);
ret = send_usb(astribank, buf, pack_len, TIMEOUT);
if(ret < 0) {
ERR("send_usb failed: %d\n", ret);
return ret;
}
DBG("send_usb: Written %d bytes\n", ret);
if (recv_answer) {
ret = recv_usb(astribank, buf, sizeof(buf), TIMEOUT);
if(ret <= 0) {
ERR("No USB packs to read\n");
return ret;
} else {
phead = (struct xpp_packet_header *)buf;
if(phead->header.op != PIC_REP_XOP) {
ERR("Got unexpected reply OP=0x%02X\n", phead->header.op);
dump_packet(LOG_ERR, "hexline[ERR]", buf, ret);
return -EINVAL;
}
DBG("received OP=0x%02X, checksum=%02X\n", phead->header.op, phead->d.pic_packet.data[0]);
if(phead->d.pic_packet.data[0] != 0) {
ERR("PIC burning, bad checksum\n");
return -EINVAL;
}
}
}
return 0;
}
int eeprom_set(struct my_usb_device *mydev, const struct myeeprom *eeprom)
{
int ret;
int len;
char buf[PACKET_SIZE];
struct fpga_packet_header *phead = (struct fpga_packet_header *)buf;
DBG("%s Start...\n", __FUNCTION__);
assert(mydev != NULL);
phead->header.op = PT_EEPROM_SET;
memcpy(&phead->d.eeprom_set.data, eeprom, EEPROM_SIZE);
len = sizeof(phead->d.eeprom_set) + sizeof(phead->header.op);
ret = send_usb("eeprom_set[W]", mydev, phead, len, TIMEOUT);
if(ret < 0)
return ret;
ret = recv_usb("eeprom_set[R]", mydev, buf, sizeof(buf), TIMEOUT);
if(ret <= 0)
return ret;
phead = (struct fpga_packet_header *)buf;
if(phead->header.op == PT_BAD_COMMAND) {
ERR("Firmware rejected PT_EEPROM_SET command\n");
return -EINVAL;
} else if(phead->header.op != PT_EEPROM_SET) {
ERR("Got unexpected reply op=%d\n", phead->header.op);
return -EINVAL;
}
return 0;
}
int eeprom_get(struct my_usb_device *mydev)
{
int ret;
int len;
char buf[PACKET_SIZE];
struct fpga_packet_header *phead = (struct fpga_packet_header *)buf;
struct myeeprom *eeprom;
assert(mydev != NULL);
eeprom = &mydev->eeprom;
DBG("%s Start...\n", __FUNCTION__);
phead->header.op = PT_EEPROM_GET;
len = sizeof(phead->header.op); /* warning: sending small packet */
ret = send_usb("eeprom_get[W]", mydev, phead, len, TIMEOUT);
if(ret < 0)
return ret;
ret = recv_usb("eeprom_get[R]", mydev, buf, sizeof(buf), TIMEOUT);
if(ret <= 0)
return ret;
phead = (struct fpga_packet_header *)buf;
if(phead->header.op == PT_BAD_COMMAND) {
ERR("PT_BAD_COMMAND\n");
return -EINVAL;
} else if(phead->header.op != PT_EEPROM_GET) {
ERR("Got unexpected reply op=%d\n", phead->header.op);
return -EINVAL;
}
memcpy(eeprom, &phead->d.eeprom_get.data, EEPROM_SIZE);
return 0;
}
// Set the display brightness
void out_saitek_t::set_display_brightness(char brightness) {
if (!a_attached) return;
int res = 0;
bool mfd = true; // Turn the lights on for the MFD
res = send_usb(mfd?0xB1:0xB2,brightness);
if (res < 0) debug_out(err,"out_saitek: error while setting brightness %c on display: %s",brightness,usb_error(res));
}
// Set the time on the MFD
void out_saitek_t::set_time(bool h24, int hour, int minute)
{
if (!a_attached) return;
unsigned short timedata = minute | (hour<<8) | (h24?0x8000:0);
int res = send_usb(0xC0,timedata);
if (res < 0) debug_out(err,"out_saitek: cannot set time to %c:%c: %s",hour,minute,usb_error(res));
}
int buzz (unsigned char duration, struct usb_dev_handle * USB_handle)
{
int RecvLength;
int SendLength;
//DWORD Comm_OK=0;
byte send_buf[64],receive_buf[64];
int retval=0;
int errchk;
send_buf[0]=BUZZER; //Set main command.
send_buf[1]= duration;
SendLength=2; //5 bytes in the outbound packet.
RecvLength=2;
send_usb(USB_handle, SendLength, send_buf);
recv_usb(USB_handle, RecvLength, receive_buf);
errchk=receive_buf[1];
if (duration != errchk){
printf("BUZZER: Wrong duration value returned: Requested:%d Returned:%d\n", duration, errchk);
retval=1;
}
return (retval);
} //END: buzz
void picdem_fs_usb_reset(struct usb_dev_handle * d)
{
// byte answer[reqLen];
byte question[reqLen];
question[0] = RESET;
send_usb(d, 1, question);
// recv_usb(d, 3, answer);
printf("Board resetted\n");
} //END: picdem_fs_usb_reset
void picdem_fs_usb_read_version(struct usb_dev_handle * d)
{
byte resp[reqLen];
byte query[reqLen];
query[0] = READ_VERSION;
query[1] = READ_VERSION_LEN;
send_usb(d, 2, query);
recv_usb(d, 2+READ_VERSION_LEN, resp);
if( (int)resp[0] == READ_VERSION && (int)resp[1] == READ_VERSION_LEN )
printf("USB firmware stack version is %d.%d\n",(int)resp[3],(int)resp[2]);
} //END: Read version.
uint8_t
wiring_write_then_read(uint8_t* out, uint16_t out_len,
uint8_t* in, uint16_t in_len)
{
int i;
send_usb(21);
if (NULL != out) for (i=0; i<out_len; i++) // отправить
#if 1
if (i+4<= out_len) { // отправка 4 байта за раз
//printf ("data %d\n",i);
w_spi_array(out[i],out[i+1],out[i+2],out[i+3]);
i+=3;
}
else
#endif
wr_spi(out[i]);
if (NULL != in) for (i=0; i<in_len; i++)
#if 1
if (i+32<= in_len) { // прием 32 байта за раз
r_spi_array();
memcpy(&in[i],buffer, 32);
i+=31;
}
else
#endif
in[i]=wr_spi(0); // прочитать
send_usb(20);
return in_len+out_len;
}
int send_hexline(struct my_usb_device *mydev, struct hexline *hexline, int seq)
{
int ret;
int len;
uint8_t *data;
char buf[PACKET_SIZE];
struct fpga_packet_header *phead = (struct fpga_packet_header *)buf;
enum fpga_load_status status;
assert(mydev != NULL);
assert(hexline != NULL);
if(hexline->d.content.header.tt != TT_DATA) {
DBG("Non data record %d type = %d\n", seq, hexline->d.content.header.tt);
return 0;
}
len = hexline->d.content.header.ll; /* don't send checksum */
data = hexline->d.content.tt_data.data;
phead->header.op = PT_DATA_PACKET;
phead->d.data_packet.seq = seq;
phead->d.data_packet.reserved = 0x00;
memcpy(phead->d.data_packet.data, data, len);
len += sizeof(hexline->d.content.header);
DBG("%04d+\r", seq);
ret = send_usb("hexline[W]", mydev, phead, len, TIMEOUT);
if(ret < 0)
return ret;
ret = recv_usb("hexline[R]", mydev, buf, sizeof(buf), TIMEOUT);
if(ret <= 0)
return ret;
DBG("%04d-\r", seq);
phead = (struct fpga_packet_header *)buf;
if(phead->header.op != PT_STATUS_REPLY) {
ERR("Got unexpected reply op=%d\n", phead->header.op);
dump_packet("hexline[ERR]", buf, ret);
return -EINVAL;
}
status = (enum fpga_load_status)phead->d.status_reply.status;
switch(status) {
case FW_TRANS_OK:
case FW_CONFIG_DONE:
break;
case FW_FAIL_RESET:
case FW_FAIL_TRANS:
ERR("status reply %s (%d)\n", load_status2str(status), status);
dump_packet("hexline[ERR]", buf, ret);
return -EPROTO;
default:
ERR("Unknown status reply %d\n", status);
dump_packet("hexline[ERR]", buf, ret);
return -EPROTO;
}
return 0;
}
void picdem_fs_usb_led(struct usb_dev_handle * d, int lednum, int onoff)
{
if( lednum < 3 || lednum > 4 )
return;
byte answer[reqLen];
byte question[reqLen];
question[0] = UPDATE_LED;
question[1] = lednum;
question[2] = (onoff==0) ? 0 : 1;
send_usb(d, 3, question);
recv_usb(d, 1, answer);
printf("LED #%i is now %s\n", lednum, (onoff==0) ? "off" : "on");
} //END: picdem_fs_usb_led
// Print the given text on the given line
void out_saitek_t::print_line(int line, const char *text, int length)
{
int res;
if (!text) return;
debug_out(debug,"out_saitek: printing line %d: '%s'",line,text);
unsigned char line_writectl[3] = {0xD1, 0xD2, 0xD4};
clear_line(line);
while (length >= 1)
{
unsigned short charpair;
if (length == 1) charpair = (0 << 8) + *text;
else charpair = *(unsigned short*) text;
res = send_usb(line_writectl[line],charpair);
if (res < 0) debug_out(err,"out_saitek: cannot print line %d with text '%s': %s",line,text,usb_error(res));
length -= 2;
text += 2;
}
}
int renumerate_device(struct my_usb_device *mydev, enum fpga_load_packet_types pt)
{
char buf[PACKET_SIZE];
struct fpga_packet_header *phead = (struct fpga_packet_header *)buf;
int ret;
assert(mydev != NULL);
DBG("Renumerating with 0x%X\n", pt);
phead->header.op = pt;
ret = send_usb("renumerate[W]", mydev, phead, 1, TIMEOUT);
if(ret < 0 && ret != -ENODEV)
return ret;
#if 0
/*
* FIXME: we count on our USB firmware to reset the device... should we?
*/
ret = usb_reset(mydev->handle);
if(ret < 0) {
ERR("usb_reset: %s\n", usb_strerror());
return -ENODEV;
}
#endif
return 0;
}
void
wiring_init()
{
send_usb(41);
sleep(1);
}
// Turn on a led
void out_saitek_t::set_led(int led, int on)
{
if (!a_attached) return;
int res = send_usb(0xB8,on | (led<<8));
if (res < 0) debug_out(err,"out_saitek: cannot set let %d on %d: %s",led,on,usb_error(res));
}
void r_spi_array () { // прием массива из 32 байт
send_usb(51);
}
/********************************************************************************************************************
*
* Processa os comandos enviados pelo display
*
********************************************************************************************************************/
void process_cmd_usb(){
uint8_t mani2, mani3 = 0;
//uint8_t Rx[11] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0,};
uint32_t uLong = 0;
switch(MensagemUsb.CMD){
// Comandos de consulta de parâmetros, pede que seja enviado o parametro requerido
// Endereço RS-485
case 0x00:
MensagemUsb.CMD = 0x00;
MensagemUsb.NDADO = 0x01;
//MensagemUsb.DADO[0] = Parametros.End;
send_usb(); // Envia mensagem para a usb
break;
// Modelo da fonte
case 0x01:
MensagemUsb.CMD = 0x01;
MensagemUsb.NDADO = 0x01;
//MensagemUsb.DADO[0] = Parametros.MdFnt;
send_usb(); // Envia mensagem para a usb
break;
// Data e hora
case 0x02:
// Chamar sub rotina de coleta de dados do RTC
//Read_Rtc_Clock(true); // Faz a leitura do RTC
MensagemUsb.CMD = 0x02;
MensagemUsb.NDADO = 0x06;
//MensagemUsb.DADO[0] = Rtc.RTCano;
//MensagemUsb.DADO[1] = Rtc.RTCmes;
//MensagemUsb.DADO[2] = Rtc.RTCdia;
//MensagemUsb.DADO[3] = Rtc.RTChora;
//MensagemUsb.DADO[4] = Rtc.RTCmin;
//MensagemUsb.DADO[5] = Rtc.RTCseg;
send_usb(); // Envia mensagem para a usb
break;
//
case 0x03:
break;
// Configuração do interlock
case 0x04:
MensagemUsb.CMD = 0x04;
MensagemUsb.NDADO = 0x02;
//MensagemUsb.DADO[0] = Parametros.ItlkAnalog;
//MensagemUsb.DADO[1] = Parametros.ItlkStatInput;
send_usb(); // Envia mensagem para a usb
break;
// Configuração de Alarme
case 0x05:
MensagemUsb.CMD = 0x05;
MensagemUsb.NDADO = 0x02;
//MensagemUsb.DADO[0] = Parametros.AlrmAnlog;
//MensagemUsb.DADO[1] = Parametros.AlrmStatInput;
send_usb(); // Envia mensagem para a usb
break;
// Status local/remoto
case 0x06:
MensagemUsb.CMD = 0x06;
MensagemUsb.NDADO = 0x01;
//MensagemUsb.DADO[0] = Parametros.LocRem;
send_usb(); // Envia mensagem para a usb
break;
// Senha
case 0x07:
MensagemUsb.CMD = 0x07;
MensagemUsb.NDADO = 0x03;
//MensagemUsb.DADO[0] = Parametros.Senha >> 16;
//MensagemUsb.DADO[1] = Parametros.Senha >> 8;
//MensagemUsb.DADO[2] = Parametros.Senha;
send_usb(); // Envia mensagem para a usb
break;
// Setpoint das para geração de alarme ou interlock por meio das medidas analogicas
case 0x08:
MensagemUsb.CMD = 0x08;
MensagemUsb.NDADO = 0x0F;
/*
MensagemUsb.DADO[0] = Parametros.SetPointAn1 >> 8;
MensagemUsb.DADO[1] = Parametros.SetPointAn1;
MensagemUsb.DADO[2] = Parametros.SetPointAn2 >> 8;
MensagemUsb.DADO[3] = Parametros.SetPointAn2;
MensagemUsb.DADO[4] = Parametros.SetPointAn3 >> 8;
MensagemUsb.DADO[5] = Parametros.SetPointAn3;
MensagemUsb.DADO[6] = Parametros.SetPointAn4 >> 8;
MensagemUsb.DADO[7] = Parametros.SetPointAn4;
MensagemUsb.DADO[8] = Parametros.SetPointAn5 >> 8;
MensagemUsb.DADO[9] = Parametros.SetPointAn5;
MensagemUsb.DADO[10] = Parametros.SetPointAn6 >> 8;
MensagemUsb.DADO[11] = Parametros.SetPointAn6;
MensagemUsb.DADO[12] = Parametros.SetPointAn7 >> 8;
MensagemUsb.DADO[13] = Parametros.SetPointAn7;
MensagemUsb.DADO[14] = Parametros.SetPointAn8 >> 8;
MensagemUsb.DADO[15] = Parametros.SetPointAn8; */
send_usb(); // Envia mensagem para a usb
break;
// Numero de série
case 0x09:
MensagemUsb.CMD = 0x09;
MensagemUsb.NDADO = 0x08;
//MensagemUsb.DADO[0] = Parametros.NSerie >> 56;
//MensagemUsb.DADO[1] = Parametros.NSerie >> 48;
//MensagemUsb.DADO[2] = Parametros.NSerie >> 40;
//MensagemUsb.DADO[3] = Parametros.NSerie >> 32;
//MensagemUsb.DADO[4] = Parametros.NSerie >> 24;
//MensagemUsb.DADO[5] = Parametros.NSerie >> 16;
//MensagemUsb.DADO[6] = Parametros.NSerie >> 8;
//MensagemUsb.DADO[7] = Parametros.NSerie;
send_usb(); // Envia mensagem para a usb
break;
// Comandos de leitura, pede para retornar os dados requeridos
// Corrente de saída
case 0x10:
//shm_getIout();
MensagemUsb.CMD = 0x10;
MensagemUsb.NDADO = 0x03;
//MensagemUsb.DADO[0] = 0x03 & LeituraVarDin.IoutReadI >> 16;
//MensagemUsb.DADO[1] = LeituraVarDin.IoutReadI >> 8;
//MensagemUsb.DADO[2] = LeituraVarDin.IoutReadI;
send_usb(); // Envia mensagem para a usb
break;
//
case 0x11:
break;
// Entadas On/Off
case 0x12:
// Chama subrotina que faz a leitura das entradas digitais de status
MensagemUsb.CMD = 0x12;
MensagemUsb.NDADO = 0x02;
//MensagemUsb.DADO[0] = LeituraVarDin.SobreCorrente;
//MensagemUsb.DADO[1] = LeituraVarDin.Fusivel;
send_usb(); // Envia mensagem para a usb
break;
// Log de eventos
case 0x13:
break;
// Post-Mortem
case 0x14:
break;
// Status do interlock
case 0x15:
break;
// Sem definição
case 0x16:
break;
// Sem definição
case 0x17:
break;
// Sem definição
case 0x18:
break;
// Comandos de atuação
// Seta corrente de saída
case 0x20:
uLong = 0x00000003 & MensagemUsb.DADO[0];
uLong = uLong << 8;
uLong |= MensagemUsb.DADO[1];
uLong = uLong << 8;
uLong |= MensagemUsb.DADO[2];
//shm_setPiRef( uLong );
break;
// Liga/desliga saida da fonte
case 0x22:
//ShmSetStatusFonteOp(MensagemUsb.DADO[0]);
break;
// Liga/desliga malha de realimentação da Fonte
case 0x23:
//ShmSetStatusMalha(MensagemUsb.DADO[0]);
break;
// Comandos de alteração de parâmetro - essas funções são utilizadas para tratar o ACK
// Os valores recebidos devem ser ajustados
// Endereço RS-485
case 0x30:
//Parametros.End = MensagemUsb.DADO[0];
// Chama subrotina para salvar o novo dado na memória não volátil
break;
// Data e hora
case 0x32:
//Rtc.RTCano = MensagemUsb.DADO[0];
//Rtc.RTCmes = MensagemUsb.DADO[1];
//Rtc.RTCdia = MensagemUsb.DADO[2];
//Rtc.RTChora = MensagemUsb.DADO[3];
//Rtc.RTCmin = MensagemUsb.DADO[4];
//Rtc.RTCseg = MensagemUsb.DADO[5];
// Chamar subrotina de ajuste dos dados no RTC
//Write_Rtc_Clock();
// Retornar ACK para PIC32 sinalizando que a tarefa foi executada com sucesso
break;
// Ganho controlador Proporcional
case 0x33:
//ShmSetControlKp(atof(MensagemUsb.DADO));
// Chama subrotina para salvar o novo dado na memória FLASH
// Retornar ACK para PIC32 sinalizando que a tarefa foi executada com sucesso
break;
// Ganho controlador Integral
case 0x34:
//ShmSetControlKi(atof(MensagemUsb.DADO));
break;
// Configuração do alarme
case 0x35:
break;
// Alteração local/remoto
case 0x36:
//Parametros.LocRem = MensagemUsb.DADO[0];
// Retornar ACK para PIC32 sinalizando que a tarefa foi executada com sucesso
break;
// Salva nova Senha
case 0x37:
//Parametros.Senha = MensagemUsb.DADO[0];
mani2 = MensagemUsb.DADO[1];
mani3 = MensagemUsb.DADO[2];
//Parametros.Senha = Parametros.Senha << 8;
//Parametros.Senha |= mani2;
//Parametros.Senha = Parametros.Senha << 8;
//Parametros.Senha |= mani3;
// Chamar função que salva a nova senha na memória FLASH
// Retornar ACK para PIC32 sinalizando que a tarefa foi executada com sucesso
break;
// Salva novo ajuste de setpoint para ADC
case 0x38:
/*Parametros.SetPointAn1 = MensagemUsb.DADO[0];
Parametros.SetPointAn1 = Parametros.SetPointAn1 << 8;
Parametros.SetPointAn1 |= MensagemUsb.DADO[1];
Parametros.SetPointAn2 = MensagemUsb.DADO[2];
Parametros.SetPointAn2 = Parametros.SetPointAn2 << 8;
Parametros.SetPointAn2 |= MensagemUsb.DADO[3];
Parametros.SetPointAn3 = MensagemUsb.DADO[4];
Parametros.SetPointAn3 = Parametros.SetPointAn3 << 8;
Parametros.SetPointAn3 |= MensagemUsb.DADO[5];
Parametros.SetPointAn4 = MensagemUsb.DADO[6];
Parametros.SetPointAn4 = Parametros.SetPointAn4 << 8;
Parametros.SetPointAn4 |= MensagemUsb.DADO[7];
Parametros.SetPointAn5 = MensagemUsb.DADO[8];
Parametros.SetPointAn5 = Parametros.SetPointAn5 << 8;
Parametros.SetPointAn5 |= MensagemUsb.DADO[9];
Parametros.SetPointAn6 = MensagemUsb.DADO[10];
Parametros.SetPointAn6 = Parametros.SetPointAn6 << 8;
Parametros.SetPointAn6 |= MensagemUsb.DADO[11];
Parametros.SetPointAn7 = MensagemUsb.DADO[12];
Parametros.SetPointAn7 = Parametros.SetPointAn4 << 8;
Parametros.SetPointAn7 |= MensagemUsb.DADO[13];
Parametros.SetPointAn8 = MensagemUsb.DADO[14];
Parametros.SetPointAn8 = Parametros.SetPointAn8 << 8;
Parametros.SetPointAn8 |= MensagemUsb.DADO[15];*/
// Chama função que grava o setpoint na memória FLASH
// Chamar função que envia os setpoints para o ADCP
// Retornar ACK para PIC32 sinalizando que a tarefa foi executada com sucesso
break;
// Comandos de consulta de curva, deve retornar os dados recebidos
// Os valores recebidos devem ser ajustados
// Curvas armazenadas
case 0x40:
break;
// Visualizar curva
case 0x41:
break;
// Visualizar parametro da curva
case 0x42:
break;
// Comandos de ajuste para curva - essas funções são utilizadas para tratar o ACK
// Seleciona curva
case 0x50:
break;
// Inicia curva
case 0x51:
break;
// Ajusta parametro da curva
case 0x52:
break;
default:
break;
}
}
int setPWM (unsigned char motor_no, int PWM_value, struct usb_dev_handle * USB_handle)
{
int RecvLength;
int SendLength;
//DWORD Comm_OK=0;
byte send_buf[64],receive_buf[64];
int retval=0;
int errchk;
send_buf[0]=SET_PWM; //Set main command.
if (motor_no==1) //Insert motor number in the packet.
send_buf[1]=1;
else if (motor_no==2)
send_buf[1]=2;
else {
printf("setPWM: Motor number is out of range: %d\n", motor_no);
send_buf[1]=0;
retval=1;
}
if (PWM_value>1023){ //Check for overflow in PWM value.
printf("setPWM: PWM value is out of range: %d\n", PWM_value);
PWM_value =1023;
retval=1;
}
if (PWM_value < -1023){
printf("setPWM: PWM value is out of range: %d\n", PWM_value);
PWM_value =-1023;
retval=1;
}
if (PWM_value <0){ //Insert direction in the packet.
send_buf[2]=1; //Negative
PWM_value = PWM_value*-1; //Set PWM_value as a positive number.
}
else
send_buf[2]=0;
send_buf[3]=(byte)(PWM_value%256); //index 3 is low value.
send_buf[4]=(byte)(PWM_value/256); //index 4 is high value.
/*
printf ("Send buffer value 0= %d\n",(unsigned char)send_buf[0]);
printf ("Send buffer value 1= %d\n",(unsigned char)send_buf[1]);
printf ("Send buffer value 2= %d\n",(unsigned char)send_buf[2]);
printf ("Send buffer value 3= %d\n",(unsigned char)send_buf[3]);
printf ("Send buffer value 4= %d\n",(unsigned char)send_buf[4]);
*/
SendLength=5; //5 bytes in the outbound packet.
RecvLength=3;
send_usb(USB_handle, SendLength, send_buf);
recv_usb(USB_handle, RecvLength, receive_buf);
/*
printf ("Buffer value 0= %d\n",(unsigned char)receive_buf[0]);
printf ("Buffer value 1= %d\n",(unsigned char)receive_buf[1]);
printf ("Buffer value 2= %d\n",(unsigned char)receive_buf[2]);
*/
errchk=(unsigned char)receive_buf[1]+256*(unsigned char)receive_buf[2];
if (PWM_value != errchk){
printf("setPWM: Wrong PWM value returned: Requested:%d Returned:%d\n", PWM_value,errchk);
retval=1;
}
return (retval);
} //END: set_PWM
void
wiring_destroy()
{
send_usb(40);
}
// clear a given line
void out_saitek_t::clear_line(int line)
{
unsigned char line_clearctl[3] = {0xD9, 0xDA, 0xDC};
int res = send_usb(line_clearctl[line],0x00);
if (res < 0) debug_out(err,"out_saitek: cannot clear line %d: %s",line,usb_error(res));
}
void
wiring_set_gpio_value(uint8_t state)
{
send_usb(10+state);
}
