Exemplo n.º 1
0
// 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));
}
Exemplo n.º 2
0
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
Exemplo n.º 3
0
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
Exemplo n.º 4
0
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;
}
Exemplo n.º 5
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;
}
Exemplo n.º 6
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;
}
Exemplo n.º 7
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));
}
Exemplo n.º 8
0
// 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));
}
Exemplo n.º 9
0
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
Exemplo n.º 10
0
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
Exemplo n.º 11
0
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.
Exemplo n.º 12
0
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;
}
Exemplo n.º 13
0
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;
}
Exemplo n.º 14
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
Exemplo n.º 15
0
// 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;
    }
}
Exemplo n.º 16
0
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;
}
Exemplo n.º 17
0
void
wiring_init()
{
    send_usb(41);
    sleep(1);
}
Exemplo n.º 18
0
// 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));
}
Exemplo n.º 19
0
void r_spi_array () { // прием массива из 32 байт

    send_usb(51);

}
Exemplo n.º 20
0
/********************************************************************************************************************
 *
 * 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;
     }

}
Exemplo n.º 21
0
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
Exemplo n.º 22
0
void
wiring_destroy()
{
    send_usb(40);
}
Exemplo n.º 23
0
// 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));
}
Exemplo n.º 24
0
void
wiring_set_gpio_value(uint8_t state)
{
    send_usb(10+state);
}