// 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); }