void ProcessIO(void)
{
BYTE numBytesRead;
//Blink the LEDs according to the USB device status
BlinkUSBStatus();
// User Application USB tasks
if((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1)) return;
if(buttonPressed)
{
if(stringPrinted == FALSE)
{
if(mUSBUSARTIsTxTrfReady())
{
putrsUSBUSART("Button Pressed data-- \r\n");
stringPrinted = TRUE;
}
}
}
else
{
stringPrinted = FALSE;
}
if(USBUSARTIsTxTrfReady())
{
numBytesRead = getsUSBUSART(USB_Out_Buffer,64);
if(numBytesRead != 0)
{
BYTE i;
for(i=0;i<numBytesRead;i++)
{
switch(USB_Out_Buffer[i])
{
case 0x0A:
case 0x0D:
putUSBUSART(&USB_Out_Buffer[i],numBytesRead);
break;
case 0x53://letter S to start sampling
ReadADC();
putUSBUSART(ADC_sample,SAMPLE_SIZE);
break;
case 0x51: //letter Q to stop
break;
default:
putUSBUSART(&USB_Out_Buffer[i],numBytesRead);
break;
}
}
//putUSBUSART(USB_In_Buffer,numBytesRead);
}
}
CDCTxService();
} //end ProcessIO
//IRman protocol: respond to IR with OK...
void IRmanString(void){
if( mUSBUSARTIsTxTrfReady() ){ //it's always ready, but this could be done better
irToy.usbOut[0]='O';//answer OK
irToy.usbOut[1]='K';
putUnsignedCharArrayUsbUsart(irToy.usbOut,2);
}
}
void send(unsigned char c){
unsigned char b[2];
if( mUSBUSARTIsTxTrfReady() ){ //it's always ready, but this could be done better
b[0]=c;
putUnsignedCharArrayUsbUsart(b,1);
}
}
void sendok(void){
unsigned char b[2];
if( mUSBUSARTIsTxTrfReady() ){ //it's always ready, but this could be done better
b[0]='1';//answer OK
putUnsignedCharArrayUsbUsart(b,1);
}
}
/********************************************************************
* Function: void ProcessIO(void)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: This function is a place holder for other user
* routines. It is a mixture of both USB and
* non-USB tasks.
*
* Note: None
*******************************************************************/
void ProcessIO(void)
{
BYTE numBytesRead;
//Blink the LEDs according to the USB device status
//
// User Application USB tasks
//
// If suspended, do nothing.
if((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1)) return;
// If character received, echo it
if(mUSBUSARTIsTxTrfReady())
{
numBytesRead = getsUSBUSART(USB_Out_Buffer,64);
if(numBytesRead != 0)
{
BYTE i;
#ifdef NETV
#else
for(i=0;i<numBytesRead;i++)
{
USB_In_Buffer[i] = USB_Out_Buffer[i];
}
//Test: Send SPI word to control motor
if(USB_In_Buffer[0] == 'u')
{
motor_speed += 250;
if(motor_speed > 3000)
motor_speed = 3000;
SpiChnPutC(4, motor_speed);
}
else if(USB_In_Buffer[0] == 'i')
{
motor_speed -= 250;
if(motor_speed < -3000)
motor_speed = -3000;
SpiChnPutC(4, motor_speed);
}
putUSBUSART(USB_In_Buffer,numBytesRead); //Echo
HBLED1 ^= 1; //Toggle LEDs
HBLED2 ^= 1;
#endif
}
}
// Service the USB CDC driver
CDCTxService();
} // End ProcessIO
// FIXME: implement for serial comms
BYTE GetUserMessage(char *buffer, BYTE len)
{
if(CommsChannel == COMMS_USB)
{
if (mUSBUSARTIsTxTrfReady())
return getsUSBUSART(buffer, len);
else
return 0;
}
return 0;
}
//setup for USB UART
void Usb2UartSetup(void){
if(mUSBUSARTIsTxTrfReady())
{
irToy.usbOut[0]='U';//answer OK
irToy.usbOut[1]='0';
irToy.usbOut[2]='1';
putUnsignedCharArrayUsbUsart(irToy.usbOut,3);
}
Sm_Usb_Uart=SM_USB_UART_CONFIG_MODE;
Configbuffctr=0;
}
/**
* シリアル・ポートの Ready を待つ
* timer1 を使ってオーバフローならば 0 を返す
* Ready になれば 1 を返す
*/
int WaitToReadySerial(void)
{
PIR1bits.TMR1IF = 0;
TMR1 = 0;
PIR1bits.TMR1IF = 0;
while (PIR1bits.TMR1IF==0) {
if (mUSBUSARTIsTxTrfReady())
return 1;
CDCTxService();
}
return 0;
}
/********************************************************************
* Function: void ProcessIO(void)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: This function is a place holder for other user
* routines. It is a mixture of both USB and
* non-USB tasks.
*
* Note: None
*******************************************************************/
void ProcessIO(void)
{
//Blink the LEDs according to the USB device status
BlinkUSBStatus();
// User Application USB tasks
if((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1)) return;
if(mUSBUSARTIsTxTrfReady())
{
putrsUSBUSART("test123");
}
CDCTxService();
} //end ProcessIO
BYTE cdc_get_conf(char *confstr, BYTE conflen)
{
char uart_c;
if (mUSBUSARTIsTxTrfReady()) {
if (getsUSBUSART(&uart_c, 1) != 0) {
if ((config_cycle>0) && (config_cycle<=conflen)) {
confstr[conflen-config_cycle] = uart_c;
}
config_cycle--; // advance to next state
if (config_cycle == 0)
return 1; // do more after this function returns..
} // if numBytesRead
}
config_cycle++; // correct for inactive cdc loops in up_cdc_cycle();
return 0;
}
/********************************************************************
* Function: void ProcessIO(void)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: This function is a place holder for other user
* routines. It is a mixture of both USB and
* non-USB tasks.
*
* Note: None
*******************************************************************/
void ProcessIO(void)
{
//Blink the LEDs according to the USB device status
BlinkUSBStatus();
// User Application USB tasks
if((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1)) return;
// only check for new USB buffer if the old RS232 buffer is
// empty.
// Additional USB packets will be NAK'd
// until the buffer is free.
if (RS232_Out_Data_Rdy == 0)
{
LastRS232Out = getsUSBUSART(RS232_Out_Data,64);
if(LastRS232Out > 0)
{
RS232_Out_Data_Rdy = 1; // signal
//buffer full
RS232cp = 0;// Reset the current position
}
}
if(RS232_Out_Data_Rdy && mTxRdyUSART())
{
putcUSART(RS232_Out_Data[RS232cp]);
++RS232cp;
if (RS232cp == LastRS232Out)
RS232_Out_Data_Rdy = 0;
}
if(mDataRdyUSART())
{
USB_Out_Buffer[NextUSBOut] = getcUSART();
++NextUSBOut;
USB_Out_Buffer[NextUSBOut] = 0;
}
if((mUSBUSARTIsTxTrfReady()) && (NextUSBOut > 0))
{
putUSBUSART(&USB_Out_Buffer[0], NextUSBOut);
NextUSBOut = 0;
}
CDCTxService();
} //end ProcessIO
// *--------------------------------------------------------------------------------*
void ProcessIO(void){
BYTE numBytesRead;
//Blink the LEDs according to the USB device status
BlinkUSBStatus();
// User Application USB tasks
if((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1)) return;
if(buttonPressed){
if(stringPrinted == FALSE){
if(mUSBUSARTIsTxTrfReady()){
putrsUSBUSART("Button Pressed -- \r\n");
stringPrinted = TRUE;
}
}
}else{
stringPrinted = FALSE;
}
if(USBUSARTIsTxTrfReady()){
numBytesRead = getsUSBUSART(USB_Out_Buffer,64);
if(numBytesRead != 0){
BYTE i;
for(i=0;i<numBytesRead;i++){
switch(USB_Out_Buffer[i]){
case 0x0A:
case 0x0D:
USB_In_Buffer[i] = USB_Out_Buffer[i];
break;
default:
USB_In_Buffer[i] = USB_Out_Buffer[i] + 1;
break;
}
}
putUSBUSART(USB_In_Buffer,numBytesRead);
}
}
CDCTxService();
}
void processUSBData(void) {
BYTE numBytesRead;
// User Application USB tasks
if ((USBDeviceState < CONFIGURED_STATE) || (USBSuspendControl == 1)) {
return;
}
// Si está preparado para recibir datos
if (mUSBUSARTIsTxTrfReady()) {
// Recibe un buffer de tamaño determinado
numBytesRead = getsUSBUSART(USB_Out_Buffer, 64);
// Si ha leído datos
if (numBytesRead != 0) {
// FIXME Usar constantes
if (strncmppgm2ram(USB_Out_Buffer, RTCC, strlen(RTCC)) == 0) {
//parseRTCCData(USB_Out_Buffer);
}
}
}
CDCTxService();
}
void usb_send(const char *format, ...)
{
//char *usb_msg;
static unsigned char usb_msg[CDC_DATA_OUT_EP_SIZE];
va_list args;
va_start(args,__format);
sprintf(usb_msg,format,args);
if (( USBGetDeviceState() < CONFIGURED_STATE ) || ( USBIsDeviceSuspended() == true ))
{
return;
}
else
{
if (mUSBUSARTIsTxTrfReady())
{
putUSBUSART(usb_msg,strlen(usb_msg));
}
CDCTxService();
}
}
void cdc_main_menu( rom char* name_str, rom char* ver_str)
{
char uart_c;
if (mUSBUSARTIsTxTrfReady()) {
if (getsUSBUSART(&uart_c, 1) != 0) {
switch (uart_c) {
case 't': cdc_start_set_time(); break;
case 'T': cdc_start_stop_time(); break;
case 'r': cdc_start_read(); break;
case 's': cdc_start_log(); break;
case 'v': cdc_print_ver(name_str, ver_str); break;
case '?': cdc_print_help(); break;
case 'f': cdc_start_format(); break;
case '0': cdc_start_erase(); break;
case 'i': cdc_start_init(); break;
case 'u': cdc_start_conf_read(); break;
case 'w': cdc_start_conf_write(); break;
case 'x': cdc_start_reset(); break;
} // switch
} // if numBytesRead!=0
} // if (mUSBUSARTIsTxTrfReady)
}
void CDCputs(u8 *buffer, u8 length)
{
u16 i;
for (i = 1000; i > 0; --i)
{
if (mUSBUSARTIsTxTrfReady())
break;
#if defined(__32MX220F032D__)||defined(__32MX250F128B__)||defined(__32MX220F032B__)
USB_Service();
#else
CDCTxService();
#endif
}
if (i > 0)
{
putUSBUSART(buffer, length);
#if defined(__32MX220F032D__)||defined(__32MX250F128B__)||defined(__32MX220F032B__)
USB_Service();
#else
CDCTxService();
#endif
}
}
void SUMPlogicCommand(unsigned char inByte){
static enum _SUMP {
C_IDLE = 0,
C_PARAMETERS,
C_PROCESS,
} sumpRXstate = C_IDLE;
static struct _sumpRX {
unsigned char command[5];
unsigned char parameters;
unsigned char parCnt;
} sumpRX;
switch(sumpRXstate){ //this is a state machine that grabs the incoming commands one byte at a time
case C_IDLE:
switch(inByte){//switch on the current byte
case SUMP_RESET://reset
T2IE=0; //disable interrupts...
T2ON=0;//tmr2 off
IRRX_IE = 0; //DISABLE RB port change interrupt
LAstate=LA_RESET;
break;
case SUMP_ID://SLA0 or 1 backwards: 1ALS
if( mUSBUSARTIsTxTrfReady() ){
//putsUSBUSART("1ALS"); //doesn't work b/c of 0x00
irToy.usbOut[0]='1';
irToy.usbOut[1]='A';
irToy.usbOut[2]='L';
irToy.usbOut[3]='S';
putUnsignedCharArrayUsbUsart(irToy.usbOut,4);
}
break;
case SUMP_RUN://arm the triger
LED_LAT |= LED_PIN;//ARMED, turn on LED
LAstate=LA_ARMED;
IRRX_IF = 0; //Reset the RB Port Change Interrupt Flag bit
IRRX_IE = 1; //Enables the RB port change interrupt
break;
case SUMP_XON://resume send data
// xflow=1;
break;
case SUMP_XOFF://pause send data
// xflow=0;
break;
default://long command
sumpRX.command[0]=inByte;//store first command byte
sumpRX.parameters=4; //all long commands are 5 bytes, get 4 parameters
sumpRX.parCnt=0;//reset the parameter counter
sumpRXstate=C_PARAMETERS;
break;
}
break;
case C_PARAMETERS:
sumpRX.command[sumpRX.parCnt]=inByte;//store each parameter
sumpRX.parCnt++;
if(sumpRX.parCnt<sumpRX.parameters) break; //if not all parameters, quit
case C_PROCESS: //ignore all long commands for now
sumpRXstate=C_IDLE;
break;
}
}
// to go back to the other default, user must unplug USB IR Toy
u8 Usb2UartService(void)
{
static u8 buff_config[5];
switch (Sm_Usb_Uart)
{
// get configuration data
case SM_USB_UART_CONFIG_MODE:
{
FlushUsbRx();
Usb2Uart_InitUart(TRUE);
// TRISC|= 0xC0;
// TXSTA= 0x24;
// RCSTA= 0x90;
// BAUDCON= 0x08;
// PIE1= 0x20;
//ResetUsbUartTxBuffers();
//ResetUsbUartRxBuffers();
Sm_Usb_Uart=SM_USB_UART_CONFIG_MODE_OK;
break;
}
case SM_USB_UART_CONFIG_MODE_OK:
{
Sm_Usb_Uart=SM_USB_UART_RUN_MODE;
break;
}
case SM_USB_UART_RUN_MODE:
{
#if 1
if(getUnsignedCharArrayUsbUart(UsbRxDataBuffer,1))
{
TxBuffer[TxBufferCtrIn]=UsbRxDataBuffer[0];
TxBufferCtrIn++;
TxBufferCtrIn&=USBUARTBUFCTRMASK;
}
#endif
if(RxBufferCtrIn!=RxBufferCtrOut)
//if ((Usb2UartPrepareTxData()==FALSE) && (RxBufferCtrIn!=RxBufferCtrOut))
{
if( mUSBUSARTIsTxTrfReady() )
{
LAT_LED_PIN^=1; // toggle led every sending
irToy.usbOut[0]=RxBuffer[RxBufferCtrOut];//answer OK
putUnsignedCharArrayUsbUsart(irToy.usbOut,1);
RxBufferCtrOut++;
RxBufferCtrOut&=USBUARTBUFCTRMASK;
}
}
break;
}
} // end of switch
// Usb2UartSendTxDataFromBuff();
#if 1
if((TxIf)&&(TxBufferCtrIn!=TxBufferCtrOut)) // If Uart is not full and no data to be sent
{
TXREG=TxBuffer[TxBufferCtrOut];
TxBufferCtrOut++;
TxBufferCtrOut&=USBUARTBUFCTRMASK;
}
#endif
if(RCSTA&0x06) // error handling
{
RCSTAbits.CREN=0;
RCSTAbits.CREN=1;
}
// this will contain the routine for receiving and transmit
return 0;//CONTINUE
}
void ProcessIO(void)
{
unsigned short result;
static char state=VALUES;
static char count=-1;
static char adc_nr=0;
static short adcchannel=0;
char overflow=0;
// User Application USB tasks
if((USBDeviceState < CONFIGURED_STATE)||(USBSuspendControl==1)) return;
if(state == PUTHEADER){
if( mUSBUSARTIsTxTrfReady() ){
putsUSBUSART(USB_Head_Buffer);
state = VALUES;
}
} else {
if( mUSBUSARTIsTxTrfReady() ){ // Wait for completion
USB_Out_Buffer[0]++;
count++;
if(count>=64){ //max channels
count=0;
USB_Out_Buffer[0] = 60; //start character
}
// if (count<=11) result = read_register(1, (0x0b+count) ); else
// result = read_register(2, (0x0b+count-12) );
adcchannel++;
if(adcchannel==16){
adcchannel=0;
overflow=1;
}
result = spi_transfer(adc_nr, ( WRITE_REG | (adcchannel<<10) ));
if(overflow==1){
overflow=0;
adc_nr++;
if(adc_nr==4) adc_nr=0;
}
USB_Out_Buffer[3] = result &0xFF;
USB_Out_Buffer[2] = (result &0xFF00)>>8;
putUSBUSART(USB_Out_Buffer,5);
LED = !LED;
}
}
CDCTxService();
} //end ProcessIO
void CDCTasks(void)
{
BYTE numBytesRead;
// Blink the LEDs according to the USB device status
if (blinkStatusValid)
{
BlinkUSBStatus();
}
// User Application USB tasks
if ((USBDeviceState < CONFIGURED_STATE) || (USBSuspendControl == 1))
{
return;
}
#if (HILSIM_USB == 1)
numBytesRead = getsUSBUSART(USB_In_Buffer, sizeof(USB_In_Buffer));
if (numBytesRead != 0)
{
int i = 0;
while (i < numBytesRead)
{
udb_gps_callback_received_byte(USB_In_Buffer[i++]);
}
}
if (mUSBUSARTIsTxTrfReady())
{
int i = 0;
int txchar;
while ((i < sizeof(USB_Out_Buffer)) && ((txchar = udb_gps_callback_get_byte_to_send()) != -1))
{
USB_Out_Buffer[i++] = txchar;
}
if (i > 0)
{
putUSBUSART(USB_Out_Buffer, i);
}
}
#else
if (mUSBUSARTIsTxTrfReady())
{
numBytesRead = getsUSBUSART(USB_Out_Buffer, sizeof(USB_Out_Buffer));
if (numBytesRead != 0)
{
BYTE i;
for (i = 0; i < numBytesRead; i++)
{
switch (USB_Out_Buffer[i])
{
case 0x0A:
case 0x0D:
USB_In_Buffer[i] = USB_Out_Buffer[i];
break;
default:
USB_In_Buffer[i] = USB_Out_Buffer[i] + 1;
break;
}
}
putUSBUSART(USB_In_Buffer, numBytesRead);
}
}
#endif
CDCTxService();
}
/*********************************************************************
* Function: void APP_DeviceCDCBasicDemoTasks(void);
*
* Overview: Keeps the demo running.
*
* PreCondition: The demo should have been initialized and started via
* the APP_DeviceCDCBasicDemoInitialize() and APP_DeviceCDCBasicDemoStart() demos
* respectively.
*
* Input: None
*
* Output: None
*
********************************************************************/
void APP_DeviceCDCBasicDemoTasks()
{
uint8_t numBytesWrite = 0;
uint8_t packet[MAX_PACKET_SIZE];
uint8_t packetSize;
packet_data_u data;
/* Make sure that the CDC driver is ready for a transmission.
*/
if (mUSBUSARTIsTxTrfReady() == true) {
uint16_t value;
uint32_t percent;
button_state_s cur_state[3];
memset(cur_state, 0x00, 3 * sizeof(button_state_s));
bool button1IsPressed = BUTTON_IsPressed(BUTTON_S1);
bool button2IsPressed = BUTTON_IsPressed(BUTTON_S2);
bool button3IsPressed = BUTTON_IsPressed(BUTTON_S3);
value = ADC_Read10bit(ADC_CHANNEL_1);
percent = ((uint32_t)100 * value) / 0x03FF;
cur_state[0].pos = 0;
cur_state[0].state = button1IsPressed ? BUTTON_PRESSED : BUTTON_RELEASED;
cur_state[0].state |= ((percent >= 95) ? BUTTON_UNMOUNTED : BUTTON_MOUNTED);
cur_state[0].uid = percent;
value = ADC_Read10bit(ADC_CHANNEL_2);
percent = ((uint32_t)100 * value) / 0x03FF;
cur_state[1].pos = 1;
cur_state[1].state = button2IsPressed ? BUTTON_PRESSED : BUTTON_RELEASED;
cur_state[1].state |= ((percent >= 95) ? BUTTON_UNMOUNTED : BUTTON_MOUNTED);
cur_state[1].uid = percent;
value = ADC_Read10bit(ADC_CHANNEL_3);
percent = ((uint32_t)100 * value) / 0x03FF;
cur_state[2].pos = 2;
cur_state[2].state = button3IsPressed ? BUTTON_PRESSED : BUTTON_RELEASED;
cur_state[2].state |= ((percent >= 95) ? BUTTON_UNMOUNTED : BUTTON_MOUNTED);
cur_state[2].uid = percent;
if ((buttons_state[0].state != cur_state[0].state) || (buttons_state[1].state != cur_state[1].state) || (buttons_state[2].state != cur_state[2].state)) {
memset(&data, 0x00, sizeof(packet_data_u));
memcpy(data.buttons_state, cur_state, 3 * sizeof(button_state_s));
assemblyPacket(GET_BUTTONS_STATE, &data, packet, &packetSize);
memcpy(writeBuffer, packet, packetSize);
numBytesWrite = packetSize;
if (numBytesWrite > 0) {
putUSBUSART(writeBuffer, numBytesWrite);
}
memcpy(buttons_state, cur_state, 3 * sizeof(button_state_s));
}
}
/* Check to see if there is a transmission in progress, if there isn't, then
* we can see about performing an echo response to data received.
*/
if( USBUSARTIsTxTrfReady() == true)
{
uint16_t i;
uint16_t validDataLen;
uint16_t numBytesRead;
char deviceID[] = "Keys 011";
char *e;
packet_type_e type;
uint8_t payload[MAX_DATA_SIZE];
uint8_t payloadSize;
// Collect incoming data in read buffer. Bear in mind, buffer have to had ability receive whole CDC packet.
if ((readPos + CDC_DATA_OUT_EP_SIZE) >= sizeof(readBuffer)) {
e = memchr(readBuffer, PREAMBLE, sizeof(readBuffer));
// Wipe out trash before valid data
if (e == 0) {
memset(readBuffer, 0x00, sizeof(readBuffer));
readPos = 0;
} else {
validDataLen = (uint16_t)(&readBuffer[sizeof(readBuffer)] - e);
memmove(readBuffer, e, validDataLen);
memset(&readBuffer[validDataLen], 0x00, sizeof(readBuffer) - validDataLen);
readPos = 0;
}
}
numBytesRead = getsUSBUSART(&readBuffer[readPos], CDC_DATA_OUT_EP_SIZE);
if (numBytesRead > 0) {
// Parse all collected incoming data
do {
e = memchr(readBuffer, PREAMBLE, sizeof(readBuffer));
if (e == 0) {
break;
}
i = (uint16_t)(e - readBuffer);
parsePacket(&readBuffer[i], sizeof(readBuffer) - i, &type, payload, &payloadSize);
numBytesWrite = 0;
if (type == GET_DEVICE_ID) {
memset(&data, 0x00, sizeof(packet_data_u));
memcpy(data.device_id, deviceID, 8);
assemblyPacket(GET_DEVICE_ID, &data, packet, &packetSize);
memcpy(writeBuffer, packet, packetSize);
numBytesWrite = packetSize;
} else if (type == GET_STATUS) {
memset(&data, 0x00, sizeof(packet_data_u));
data.device_status.errors = ERROR_NONE;
data.device_status.rtc = 0;
assemblyPacket(GET_STATUS, &data, packet, &packetSize);
memcpy(writeBuffer, packet, packetSize);
numBytesWrite = packetSize;
} else if (type == SET_LEDS_STATE) {
led_state_s *led = (led_state_s *)payload;
if (led->state == LED_TURN_ON) {
if (led->pos == 0)
LED_On(LED_D2);
if (led->pos == 1)
LED_On(LED_D3);
if (led->pos == 2)
LED_On(LED_D4);
} else {
if (led->pos == 0)
LED_Off(LED_D2);
if (led->pos == 1)
LED_Off(LED_D3);
if (led->pos == 2)
LED_Off(LED_D4);
}
} else if (type == RESET_DEVICE) {
LED_Off(LED_D2);
LED_Off(LED_D3);
LED_Off(LED_D4);
memset(readBuffer, 0x00, sizeof(readBuffer));
readPos = 0;
} else {
memcpy(writeBuffer, &readBuffer[i], 20);
numBytesWrite = 20;
}
// Clear packet's start marker - PREAMBLE
memset(&readBuffer[i], 0x00, 1);
// Send answer
if (numBytesWrite > 0) {
putUSBUSART(writeBuffer, numBytesWrite);
}
} while (1);
}
}
CDCTxService();
}
/*********************************************************************
* Function: void APP_DeviceCDCBasicDemoTasks(void);
*
* Overview: Keeps the demo running.
*
* PreCondition: The demo should have been initialized and started via
* the APP_DeviceCDCBasicDemoInitialize() and APP_DeviceCDCBasicDemoStart() demos
* respectively.
*
* Input: None
*
* Output: None
*
********************************************************************/
void APP_DeviceCDCBasicDemoTasks()
{
/* If the user has pressed the button associated with this demo, then we
* are going to send a "Button Pressed" message to the terminal.
*/
if(BUTTON_IsPressed(BUTTON_DEVICE_CDC_BASIC_DEMO) == true)
{
/* Make sure that we only send the message once per button press and
* not continuously as the button is held.
*/
if(buttonPressed == false)
{
/* Make sure that the CDC driver is ready for a transmission.
*/
if(mUSBUSARTIsTxTrfReady() == true)
{
putrsUSBUSART(buttonMessage);
buttonPressed = true;
}
}
}
else
{
/* If the button is released, we can then allow a new message to be
* sent the next time the button is pressed.
*/
buttonPressed = false;
}
/* Check to see if there is a transmission in progress, if there isn't, then
* we can see about performing an echo response to data received.
*/
if( USBUSARTIsTxTrfReady() == true)
{
uint8_t numBytesRead;
numBytesRead = getsUSBUSART(readBuffer, sizeof(readBuffer));
if (numBytesRead > 0) {
switch(readBuffer[0]) {
case 0x10:
{
unsigned char size = readBuffer[1];
debug_flag2 = !debug_flag2;
PORTCbits.RC1 = debug_flag2;
writeBuffer[0] = 0x90;
writeBuffer[1] = 4;
writeBuffer[2] = numBytesRead;
writeBuffer[3] = readBuffer[1];
writeBuffer[4] = readBuffer[2];
writeBuffer[5] = readBuffer[3];
writeBuffer[1] = 4+size;
for (unsigned char i = 0; i<size; i++) {
writeBuffer[i+6] = readBuffer[4 + i];
}
if (WaitToReadySerial())
putUSBUSART(writeBuffer, writeBuffer[1]+2);
WaitToReadySerial();
}
{
unsigned char size = readBuffer[1];
i2c_start(0x50, 0);
// address in big-endian format
i2c_send(readBuffer[3]); // address MSB
i2c_send(readBuffer[2]); // address LSB
for (unsigned char i = 0; i<size; i++) {
i2c_send(readBuffer[4 + i]);
}
i2c_stop();
__delay_ms(10);
}
break;
case 0x11:
{
unsigned char size = readBuffer[1];
unsigned char data;
unsigned char i;
i2c_start(0x50, 0);
// address in big-endian format
i2c_send(readBuffer[3]); // address MSB
i2c_send(readBuffer[2]); // address LSB
i2c_start(0x50, 1);
for (i=0; i<size-1; i++) {
writeBuffer[i+2] = i2c_receive(ACK);
}
writeBuffer[i+2] = i2c_receive(NOACK);
i2c_stop();
__delay_ms(10);
writeBuffer[0] = 0x12;
writeBuffer[1] = size;
putUSBUSART(writeBuffer, writeBuffer[1]+2);
}
break;
}
}
//if (debug_flag) {
// debug_flag = 0;
// writeBuffer[0] = 9;
// writeBuffer[1] = 1;
// writeBuffer[2] = debug_data;
// putUSBUSART(writeBuffer, writeBuffer[1]+2);
//}
}
CDCTxService();
}
static void USB_CDC_send(uint16_t length) {
if (mUSBUSARTIsTxTrfReady() == true) {
putUSBUSART(writeBuffer, length);
}
CDCTxService();
}
