/** Task to read in data received from the attached CDC device and print it to the serial port.
*/
void CDCHost_Task(void)
{
if (USB_HostState != HOST_STATE_Configured)
return;
/* Select the data IN pipe */
Pipe_SelectPipe(CDC_DATA_IN_PIPE);
Pipe_Unfreeze();
/* Check to see if a packet has been received */
if (Pipe_IsINReceived())
{
/* Re-freeze IN pipe after the packet has been received */
Pipe_Freeze();
/* Check if data is in the pipe */
if (Pipe_IsReadWriteAllowed())
{
/* Get the length of the pipe data, and create a new buffer to hold it */
uint16_t BufferLength = Pipe_BytesInPipe();
uint8_t Buffer[BufferLength];
/* Read in the pipe data to the temporary buffer */
Pipe_Read_Stream_LE(Buffer, BufferLength, NULL);
/* Print out the buffer contents to the USART */
for (uint16_t BufferByte = 0; BufferByte < BufferLength; BufferByte++)
putchar(Buffer[BufferByte]);
}
/* Clear the pipe after it is read, ready for the next packet */
Pipe_ClearIN();
}
/* Re-freeze IN pipe after use */
Pipe_Freeze();
/* Select and unfreeze the notification pipe */
Pipe_SelectPipe(CDC_NOTIFICATION_PIPE);
Pipe_Unfreeze();
/* Check if a packet has been received */
if (Pipe_IsINReceived())
{
/* Discard the unused event notification */
Pipe_ClearIN();
}
/* Freeze notification IN pipe after use */
Pipe_Freeze();
}
uint8_t SI_Host_SendBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
PIMA_Container_t* const PIMAHeader)
{
uint8_t ErrorCode;
if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
return PIPE_RWSTREAM_DeviceDisconnected;
if (SIInterfaceInfo->State.IsSessionOpen)
PIMAHeader->TransactionID = SIInterfaceInfo->State.TransactionID++;
Pipe_SelectPipe(SIInterfaceInfo->Config.DataOUTPipeNumber);
Pipe_Unfreeze();
if ((ErrorCode = Pipe_Write_Stream_LE(PIMAHeader, PIMA_COMMAND_SIZE(0), NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
return ErrorCode;
uint8_t ParamBytes = (PIMAHeader->DataLength - PIMA_COMMAND_SIZE(0));
if (ParamBytes)
{
if ((ErrorCode = Pipe_Write_Stream_LE(&PIMAHeader->Params, ParamBytes, NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
return ErrorCode;
}
Pipe_ClearOUT();
Pipe_Freeze();
return PIPE_RWSTREAM_NoError;
}
static uint8_t SImage_Host_SendBlockHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, SI_PIMA_Container_t* const PIMAHeader)
{
uint8_t ErrorCode;
PIMAHeader->TransactionID = SIInterfaceInfo->State.TransactionID++;
Pipe_SelectPipe(SIInterfaceInfo->Config.DataOUTPipeNumber);
Pipe_Unfreeze();
if ((ErrorCode = Pipe_Write_Stream_LE(PIMAHeader, PIMA_COMMAND_SIZE(0), NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
return ErrorCode;
uint8_t ParamBytes = (PIMAHeader->DataLength - PIMA_COMMAND_SIZE(0));
if (ParamBytes)
{
if ((ErrorCode = Pipe_Write_Stream_LE(&PIMAHeader->Params, ParamBytes, NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
return ErrorCode;
}
Pipe_ClearOUT();
Pipe_Freeze();
return PIPE_RWSTREAM_NoError;
}
/** Routine to send the current CBW to the device, and increment the Tag value as needed.
*
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
*/
static uint8_t MassStore_SendCommand(void)
{
uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
/* Each transmission should have a unique tag value, excluding values 0 and 0xFFFFFFFF */
if (++MassStore_Tag == 0xFFFFFFFF)
MassStore_Tag = 1;
/* Select the OUT data pipe for CBW transmission */
Pipe_SelectPipe(MASS_STORE_DATA_OUT_PIPE);
Pipe_Unfreeze();
/* Write the CBW command to the OUT pipe */
if ((ErrorCode = Pipe_Write_Stream_LE(&SCSICommandBlock, sizeof(CommandBlockWrapper_t))) != PIPE_RWSTREAM_NoError)
return ErrorCode;
/* Send the data in the OUT pipe to the attached device */
Pipe_ClearOUT();
while(!(Pipe_IsOUTReady()));
/* Freeze pipe after use */
Pipe_Freeze();
return PIPE_RWSTREAM_NoError;
}
/** Function to send the PIMA command container to the attached still image device. */
void SImage_SendBlockHeader(void)
{
/* Unfreeze the data OUT pipe ready for data transmission */
Pipe_SelectPipe(SIMAGE_DATA_OUT_PIPE);
Pipe_Unfreeze();
/* Write the PIMA block to the data OUT pipe */
Pipe_Write_Stream_LE(&PIMA_SendBlock, PIMA_COMMAND_SIZE(0), NULL);
/* If the block type is a command, send its parameters (if any) */
if (PIMA_SendBlock.Type == PIMA_CONTAINER_CommandBlock)
{
/* Determine the size of the parameters in the block via the data length attribute */
uint8_t ParamBytes = (PIMA_SendBlock.DataLength - PIMA_COMMAND_SIZE(0));
/* Check if any parameters in the command block */
if (ParamBytes)
{
/* Write the PIMA parameters to the data OUT pipe */
Pipe_Write_Stream_LE(&PIMA_SendBlock.Params, ParamBytes, NULL);
}
/* Send the PIMA command block to the attached device */
Pipe_ClearOUT();
}
/* Freeze pipe after use */
Pipe_Freeze();
}
/** Task to read and process the HID report descriptor and HID reports from the device and display the
* results onto the board LEDs.
*/
void MouseHost_Task(void)
{
if (USB_HostState != HOST_STATE_Configured)
return;
/* Select and unfreeze mouse data pipe */
Pipe_SelectPipe(MOUSE_DATA_IN_PIPE);
Pipe_Unfreeze();
/* Check to see if a packet has been received */
if (Pipe_IsINReceived())
{
/* Check if data has been received from the attached mouse */
if (Pipe_IsReadWriteAllowed())
{
/* Create buffer big enough for the report */
uint8_t MouseReport[Pipe_BytesInPipe()];
/* Load in the mouse report */
Pipe_Read_Stream_LE(MouseReport, Pipe_BytesInPipe(), NULL);
/* Process the read in mouse report from the device */
ProcessMouseReport(MouseReport);
}
/* Clear the IN endpoint, ready for next data packet */
Pipe_ClearIN();
}
/* Freeze mouse data pipe */
Pipe_Freeze();
}
/** Internal Bluetooth stack Signal Command processing routine for a Connection Response command.
*
* \param[in] SignalCommandHeader Pointer to the start of the received packet's Signal Command header
*/
static inline void Bluetooth_Signal_ConnectionResp(const BT_Signal_Header_t* const SignalCommandHeader)
{
BT_Signal_ConnectionResp_t ConnectionResponse;
Pipe_Read_Stream_LE(&ConnectionResponse, sizeof(ConnectionResponse));
Pipe_ClearIN();
Pipe_Freeze();
BT_ACL_DEBUG(1, "<< L2CAP Connection Response");
BT_ACL_DEBUG(2, "-- Result: 0x%02X", ConnectionResponse.Result);
BT_ACL_DEBUG(2, "-- Source Channel: 0x%04X", ConnectionResponse.SourceChannel);
BT_ACL_DEBUG(2, "-- Destination Channel: 0x%04X", ConnectionResponse.DestinationChannel);
/* Search for the referenced channel in the channel information list */
Bluetooth_Channel_t* ChannelData = Bluetooth_GetChannelData(ConnectionResponse.SourceChannel, CHANNEL_SEARCH_LOCALNUMBER);
/* Only progress if the referenced channel data was found */
if (ChannelData != NULL)
{
/* Set the channel structure's remote channel number to the channel allocated on the remote device */
ChannelData->RemoteNumber = ConnectionResponse.SourceChannel;
ChannelData->State = (ConnectionResponse.Result == BT_CONNECTION_SUCCESSFUL) ?
BT_Channel_Config_WaitConfig : BT_Channel_Closed;
}
}
/** Routine to receive the current CSW from the device.
*
* \param[out] SCSICommandStatus Pointer to a destination where the returned status data should be stored
*
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum, or MASS_STORE_SCSI_COMMAND_FAILED if the SCSI command fails
*/
static uint8_t MassStore_GetReturnedStatus(CommandStatusWrapper_t* const SCSICommandStatus)
{
uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
/* If an error in the command occurred, abort */
if ((ErrorCode = MassStore_WaitForDataReceived()) != PIPE_RWSTREAM_NoError)
return ErrorCode;
/* Select the IN data pipe for data reception */
Pipe_SelectPipe(MASS_STORE_DATA_IN_PIPE);
Pipe_Unfreeze();
/* Load in the CSW from the attached device */
if ((ErrorCode = Pipe_Read_Stream_LE(SCSICommandStatus, sizeof(CommandStatusWrapper_t))) != PIPE_RWSTREAM_NoError)
return ErrorCode;
/* Clear the data ready for next reception */
Pipe_ClearIN();
/* Freeze the IN pipe after use */
Pipe_Freeze();
/* Check to see if command failed */
if (SCSICommandStatus->Status != Command_Pass)
ErrorCode = MASS_STORE_SCSI_COMMAND_FAILED;
return ErrorCode;
}
void CDC_Host_USBTask(USB_ClassInfo_CDC_Host_t* const CDCInterfaceInfo)
{
if ((USB_HostState != HOST_STATE_Configured) || !(CDCInterfaceInfo->State.IsActive))
return;
Pipe_SelectPipe(CDCInterfaceInfo->Config.NotificationPipeNumber);
Pipe_SetPipeToken(PIPE_TOKEN_IN);
Pipe_Unfreeze();
if (Pipe_IsINReceived())
{
USB_Request_Header_t Notification;
Pipe_Read_Stream_LE(&Notification, sizeof(USB_Request_Header_t), NO_STREAM_CALLBACK);
if ((Notification.bRequest == NOTIF_SerialState) &&
(Notification.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE)))
{
Pipe_Read_Stream_LE(&CDCInterfaceInfo->State.ControlLineStates.DeviceToHost,
sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost),
NO_STREAM_CALLBACK);
}
Pipe_ClearIN();
EVENT_CDC_Host_ControLineStateChanged(CDCInterfaceInfo);
}
Pipe_Freeze();
}
static uint8_t MS_Host_GetReturnedStatus(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
MS_CommandStatusWrapper_t* const SCSICommandStatus)
{
uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
if ((ErrorCode = MS_Host_WaitForDataReceived(MSInterfaceInfo)) != PIPE_RWSTREAM_NoError)
return ErrorCode;
Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);
Pipe_Unfreeze();
if ((ErrorCode = Pipe_Read_Stream_LE(SCSICommandStatus, sizeof(MS_CommandStatusWrapper_t),
NULL)) != PIPE_RWSTREAM_NoError)
{
return ErrorCode;
}
Pipe_ClearIN();
Pipe_Freeze();
if (SCSICommandStatus->Status != MS_SCSI_COMMAND_Pass)
ErrorCode = MS_ERROR_LOGICAL_CMD_FAILED;
return ErrorCode;
}
bool MIDI_Host_ReceiveEventPacket(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo,
MIDI_EventPacket_t* const Event)
{
if ((USB_HostState != HOST_STATE_Configured) || !(MIDIInterfaceInfo->State.IsActive))
return HOST_SENDCONTROL_DeviceDisconnected;
bool DataReady = false;
Pipe_SelectPipe(MIDIInterfaceInfo->Config.DataINPipe.Address);
Pipe_Unfreeze();
if (Pipe_IsINReceived())
{
if (Pipe_BytesInPipe())
{
Pipe_Read_Stream_LE(Event, sizeof(MIDI_EventPacket_t), NULL);
DataReady = true;
}
if (!(Pipe_BytesInPipe()))
Pipe_ClearIN();
}
Pipe_Freeze();
return DataReady;
}
/** Task to set the configuration of the attached device after it has been enumerated. */
void AndroidHost_Task(void)
{
if (USB_HostState != HOST_STATE_Configured)
return;
/* Select the data IN pipe */
Pipe_SelectPipe(ANDROID_DATA_IN_PIPE);
Pipe_Unfreeze();
/* Check to see if a packet has been received */
if (Pipe_IsINReceived())
{
/* Re-freeze IN pipe after the packet has been received */
Pipe_Freeze();
/* Check if data is in the pipe */
if (Pipe_IsReadWriteAllowed())
{
uint8_t NextReceivedByte = Pipe_Read_8();
uint8_t LEDMask = LEDS_NO_LEDS;
if (NextReceivedByte & 0x01)
LEDMask |= LEDS_LED1;
if (NextReceivedByte & 0x02)
LEDMask |= LEDS_LED2;
if (NextReceivedByte & 0x04)
LEDMask |= LEDS_LED3;
if (NextReceivedByte & 0x08)
LEDMask |= LEDS_LED4;
LEDs_SetAllLEDs(LEDMask);
}
else
{
/* Clear the pipe after all data in the packet has been read, ready for the next packet */
Pipe_ClearIN();
}
}
/* Re-freeze IN pipe after use */
Pipe_Freeze();
}
static uint8_t MS_Host_SendReceiveData(USB_ClassInfo_MS_Host_t* const MSInterfaceInfo,
MS_CommandBlockWrapper_t* const SCSICommandBlock,
void* BufferPtr)
{
uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
uint16_t BytesRem = SCSICommandBlock->DataTransferLength;
if (SCSICommandBlock->Flags & MS_COMMAND_DIR_DATA_IN)
{
if ((ErrorCode = MS_Host_WaitForDataReceived(MSInterfaceInfo)) != PIPE_RWSTREAM_NoError)
{
Pipe_Freeze();
return ErrorCode;
}
Pipe_SelectPipe(MSInterfaceInfo->Config.DataINPipeNumber);
Pipe_Unfreeze();
if ((ErrorCode = Pipe_Read_Stream_LE(BufferPtr, BytesRem, NULL)) != PIPE_RWSTREAM_NoError)
return ErrorCode;
Pipe_ClearIN();
}
else
{
Pipe_SelectPipe(MSInterfaceInfo->Config.DataOUTPipeNumber);
Pipe_Unfreeze();
if ((ErrorCode = Pipe_Write_Stream_LE(BufferPtr, BytesRem, NULL)) != PIPE_RWSTREAM_NoError)
return ErrorCode;
Pipe_ClearOUT();
while (!(Pipe_IsOUTReady()))
{
if (USB_HostState == HOST_STATE_Unattached)
return PIPE_RWSTREAM_DeviceDisconnected;
}
}
Pipe_Freeze();
return ErrorCode;
}
/** Internal Bluetooth stack Signal Command processing routine for an Information Request command.
*
* \param[in] SignalCommandHeader Pointer to the start of the received packet's Signal Command header
*/
static inline void Bluetooth_Signal_InformationReq(const BT_Signal_Header_t* const SignalCommandHeader)
{
BT_Signal_InformationReq_t InformationRequest;
Pipe_Read_Stream_LE(&InformationRequest, sizeof(InformationRequest));
BT_ACL_DEBUG(1, "<< L2CAP Information Request");
BT_ACL_DEBUG(2, "-- Info Type: 0x%04X", InformationRequest.InfoType);
Pipe_ClearIN();
Pipe_Freeze();
struct
{
BT_Signal_Header_t SignalCommandHeader;
BT_Signal_InformationResp_t InformationResponse;
uint8_t Data[4];
} ResponsePacket;
uint8_t DataLen = 0;
/* Retrieve the requested information and store it in the outgoing packet, if found */
switch (InformationRequest.InfoType)
{
case BT_INFOREQ_MTU:
ResponsePacket.InformationResponse.Result = BT_INFORMATION_SUCCESSFUL;
DataLen = 2;
*((uint16_t*)&ResponsePacket.Data) = MAXIMUM_CHANNEL_MTU;
break;
case BT_INFOREQ_EXTENDEDFEATURES:
ResponsePacket.InformationResponse.Result = BT_INFORMATION_SUCCESSFUL;
DataLen = 4;
*((uint32_t*)&ResponsePacket.Data) = 0;
break;
default:
ResponsePacket.InformationResponse.Result = BT_INFORMATION_NOTSUPPORTED;
DataLen = 0;
break;
}
/* Fill out the Signal Command header in the response packet */
ResponsePacket.SignalCommandHeader.Code = BT_SIGNAL_INFORMATION_RESPONSE;
ResponsePacket.SignalCommandHeader.Identifier = SignalCommandHeader->Identifier;
ResponsePacket.SignalCommandHeader.Length = sizeof(ResponsePacket.InformationResponse) + DataLen;
/* Fill out the Information Response in the response packet */
ResponsePacket.InformationResponse.InfoType = InformationRequest.InfoType;
Bluetooth_SendPacket(&ResponsePacket, (sizeof(ResponsePacket) - sizeof(ResponsePacket.Data) + DataLen), NULL);
BT_ACL_DEBUG(1, ">> L2CAP Information Response");
BT_ACL_DEBUG(2, "-- Result: 0x%02X", ResponsePacket.InformationResponse.Result);
}
/** Reads in and discards the next report from the attached device. */
void DiscardNextReport(void)
{
/* Select and unfreeze HID data IN pipe */
Pipe_SelectPipe(HID_DATA_IN_PIPE);
Pipe_Unfreeze();
/* Check to see if a packet has been received */
if (!(Pipe_IsINReceived()))
{
/* Refreeze HID data IN pipe */
Pipe_Freeze();
return;
}
/* Clear the IN endpoint, ready for next data packet */
Pipe_ClearIN();
/* Refreeze HID data IN pipe */
Pipe_Freeze();
}
/** Routine to send the current CBW to the device, and increment the Tag value as needed.
*
* \param[in] SCSICommandBlock Pointer to a SCSI command block structure to send to the attached device
* \param[in,out] BufferPtr Pointer to a buffer for the data to send or receive to/from the device, or NULL if no data
*
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
*/
static uint8_t MassStore_SendCommand(CommandBlockWrapper_t* const SCSICommandBlock,
void* BufferPtr)
{
uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
/* Each transmission should have a unique tag value, increment before use */
SCSICommandBlock->Tag = ++MassStore_Tag;
/* Wrap Tag value when invalid - MS class defines tag values of 0 and 0xFFFFFFFF to be invalid */
if (MassStore_Tag == 0xFFFFFFFF)
MassStore_Tag = 1;
/* Select the OUT data pipe for CBW transmission */
Pipe_SelectPipe(MASS_STORE_DATA_OUT_PIPE);
Pipe_Unfreeze();
/* Write the CBW command to the OUT pipe */
if ((ErrorCode = Pipe_Write_Stream_LE(SCSICommandBlock, sizeof(CommandBlockWrapper_t))) != PIPE_RWSTREAM_NoError)
return ErrorCode;
/* Send the data in the OUT pipe to the attached device */
Pipe_ClearOUT();
/* Wait until command has been sent */
Pipe_WaitUntilReady();
/* Freeze pipe after use */
Pipe_Freeze();
/* Send data if any */
if ((BufferPtr != NULL) &&
((ErrorCode = MassStore_SendReceiveData(SCSICommandBlock, BufferPtr)) != PIPE_READYWAIT_NoError))
{
Pipe_Freeze();
return ErrorCode;
}
return ErrorCode;
}
uint8_t SImage_Host_ReadData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, void* Buffer, const uint16_t Bytes)
{
uint8_t ErrorCode;
Pipe_SelectPipe(SIInterfaceInfo->Config.DataINPipeNumber);
Pipe_Unfreeze();
ErrorCode = Pipe_Read_Stream_LE(Buffer, Bytes, NO_STREAM_CALLBACK);
Pipe_Freeze();
return ErrorCode;
}
uint8_t SImage_Host_ReceiveEventHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo, SI_PIMA_Container_t* const PIMAHeader)
{
uint8_t ErrorCode;
Pipe_SelectPipe(SIInterfaceInfo->Config.EventsPipeNumber);
Pipe_Unfreeze();
ErrorCode = Pipe_Read_Stream_LE(PIMAHeader, sizeof(SI_PIMA_Container_t), NO_STREAM_CALLBACK);
Pipe_ClearIN();
Pipe_Freeze();
return ErrorCode;
}
uint8_t USB_Host_SendControlRequest(void* const BufferPtr)
{
bool BusSuspended = USB_Host_IsBusSuspended();
uint8_t ReturnStatus = USB_Host_SendControlRequest_PRV(BufferPtr);
Pipe_Freeze();
if (BusSuspended)
USB_Host_SuspendBus();
Pipe_ResetPipe(PIPE_CONTROLPIPE);
return ReturnStatus;
}
bool SImage_Host_IsEventReceived(USB_ClassInfo_SI_Host_t* SIInterfaceInfo)
{
bool IsEventReceived = false;
Pipe_SelectPipe(SIInterfaceInfo->Config.EventsPipeNumber);
Pipe_Unfreeze();
if (Pipe_BytesInPipe())
IsEventReceived = true;
Pipe_Freeze();
return IsEventReceived;
}
/** Sends or receives the transaction's data stage to or from the attached device, reading or
* writing to the nominated buffer.
*
* \param[in] SCSICommandBlock Pointer to a SCSI command block structure being sent to the attached device
* \param[in,out] BufferPtr Pointer to the data buffer to read from or write to
*
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
*/
static uint8_t MassStore_SendReceiveData(CommandBlockWrapper_t* const SCSICommandBlock,
void* BufferPtr)
{
uint8_t ErrorCode = PIPE_RWSTREAM_NoError;
uint16_t BytesRem = SCSICommandBlock->DataTransferLength;
/* Check the direction of the SCSI command data stage */
if (SCSICommandBlock->Flags & COMMAND_DIRECTION_DATA_IN)
{
/* Wait until the device has replied with some data */
if ((ErrorCode = MassStore_WaitForDataReceived()) != PIPE_RWSTREAM_NoError)
return ErrorCode;
/* Select the IN data pipe for data reception */
Pipe_SelectPipe(MASS_STORE_DATA_IN_PIPE);
Pipe_Unfreeze();
/* Read in the block data from the pipe */
if ((ErrorCode = Pipe_Read_Stream_LE(BufferPtr, BytesRem)) != PIPE_RWSTREAM_NoError)
return ErrorCode;
/* Acknowledge the packet */
Pipe_ClearIN();
}
else
{
/* Select the OUT data pipe for data transmission */
Pipe_SelectPipe(MASS_STORE_DATA_OUT_PIPE);
Pipe_Unfreeze();
/* Write the block data to the pipe */
if ((ErrorCode = Pipe_Write_Stream_LE(BufferPtr, BytesRem)) != PIPE_RWSTREAM_NoError)
return ErrorCode;
/* Acknowledge the packet */
Pipe_ClearOUT();
while (!(Pipe_IsOUTReady()))
{
if (USB_HostState == HOST_STATE_Unattached)
return PIPE_RWSTREAM_DeviceDisconnected;
}
}
/* Freeze used pipe after use */
Pipe_Freeze();
return PIPE_RWSTREAM_NoError;
}
/** Reads in and processes the next report from the attached device, displaying the report
* contents on the board LEDs and via the serial port.
*/
void ReadNextReport(void)
{
/* Select and unfreeze HID data IN pipe */
Pipe_SelectPipe(HID_DATA_IN_PIPE);
Pipe_Unfreeze();
/* Check to see if a packet has been received */
if (!(Pipe_IsINReceived()))
{
/* Refreeze HID data IN pipe */
Pipe_Freeze();
return;
}
/* Ensure pipe contains data before trying to read from it */
if (Pipe_IsReadWriteAllowed())
{
uint8_t ReportINData[Pipe_BytesInPipe()];
/* Read in HID report data */
Pipe_Read_Stream_LE(&ReportINData, sizeof(ReportINData));
/* Print report data through the serial port */
for (uint16_t CurrByte = 0; CurrByte < sizeof(ReportINData); CurrByte++)
printf_P(PSTR("0x%02X "), ReportINData[CurrByte]);
puts_P(PSTR("\r\n"));
}
/* Clear the IN endpoint, ready for next data packet */
Pipe_ClearIN();
/* Refreeze HID data IN pipe */
Pipe_Freeze();
}
uint8_t MIDI_Host_SendEventPacket(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo,
MIDI_EventPacket_t* const Event)
{
if ((USB_HostState != HOST_STATE_Configured) || !(MIDIInterfaceInfo->State.IsActive))
return HOST_SENDCONTROL_DeviceDisconnected;
uint8_t ErrorCode;
Pipe_SelectPipe(MIDIInterfaceInfo->Config.DataOUTPipe.Address);
Pipe_Unfreeze();
if ((ErrorCode = Pipe_Write_Stream_LE(Event, sizeof(MIDI_EventPacket_t), NULL)) != PIPE_RWSTREAM_NoError)
{
Pipe_Freeze();
return ErrorCode;
}
if (!(Pipe_IsReadWriteAllowed()))
Pipe_ClearOUT();
Pipe_Freeze();
return PIPE_RWSTREAM_NoError;
}
/** Function to receive the given data from the device, after a response block has been received.
*
* \param[out] Buffer Destination data buffer to put read bytes from the device
* \param[in] Bytes Number of bytes to receive
*
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
*/
uint8_t SImage_ReadData(void* const Buffer,
const uint16_t Bytes)
{
uint8_t ErrorCode;
/* Unfreeze the data IN pipe */
Pipe_SelectPipe(SIMAGE_DATA_IN_PIPE);
Pipe_Unfreeze();
/* Read in the data into the buffer */
ErrorCode = Pipe_Read_Stream_LE(Buffer, Bytes, NULL);
/* Freeze the pipe again after use */
Pipe_Freeze();
return ErrorCode;
}
/** Function to test if a PIMA event block is waiting to be read in from the attached device.
*
* \return True if an event is waiting to be read in from the device, false otherwise
*/
bool SImage_IsEventReceived(void)
{
bool IsEventReceived = false;
/* Unfreeze the Event pipe */
Pipe_SelectPipe(SIMAGE_EVENTS_PIPE);
Pipe_Unfreeze();
/* If the pipe contains data, an event has been received */
if (Pipe_BytesInPipe())
IsEventReceived = true;
/* Freeze the pipe after use */
Pipe_Freeze();
return IsEventReceived;
}
/** Task to read in data received from the attached RNDIS device and print it to the serial port.
*/
void RNDISHost_Task(void)
{
if (USB_HostState != HOST_STATE_Configured)
return;
uint8_t ErrorCode;
LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
uint16_t PacketLength;
if ((ErrorCode = RNDIS_GetPacketLength(&PacketLength)) != HOST_SENDCONTROL_Successful)
{
printf_P(PSTR(ESC_FG_RED "Packet Reception Error.\r\n"
" -- Error Code: %d\r\n" ESC_FG_WHITE), ErrorCode);
return;
}
if (!(PacketLength))
return;
Pipe_Unfreeze();
printf_P(PSTR("***PACKET (Size %d)***\r\n"), PacketLength);
if (PacketLength > 1024)
{
puts_P(PSTR(ESC_FG_RED "Packet too large.\r\n" ESC_FG_WHITE));
Pipe_Discard_Stream(PacketLength, NULL);
}
else
{
uint8_t PacketBuffer[PacketLength];
Pipe_Read_Stream_LE(&PacketBuffer, PacketLength, NULL);
for (uint16_t i = 0; i < PacketLength; i++)
printf("0x%02x ", PacketBuffer[i]);
}
Pipe_ClearIN();
Pipe_Freeze();
printf("\r\n\r\n");
LEDs_SetAllLEDs(LEDMASK_USB_READY);
}
bool SI_Host_IsEventReceived(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo)
{
bool IsEventReceived = false;
if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
return false;
Pipe_SelectPipe(SIInterfaceInfo->Config.EventsPipeNumber);
Pipe_Unfreeze();
if (Pipe_BytesInPipe())
IsEventReceived = true;
Pipe_Freeze();
return IsEventReceived;
}
uint8_t SI_Host_ReceiveEventHeader(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
PIMA_Container_t* const PIMAHeader)
{
uint8_t ErrorCode;
if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
return PIPE_RWSTREAM_DeviceDisconnected;
Pipe_SelectPipe(SIInterfaceInfo->Config.EventsPipeNumber);
Pipe_Unfreeze();
ErrorCode = Pipe_Read_Stream_LE(PIMAHeader, sizeof(PIMA_Container_t), NO_STREAM_CALLBACK);
Pipe_ClearIN();
Pipe_Freeze();
return ErrorCode;
}
uint8_t SI_Host_ReadData(USB_ClassInfo_SI_Host_t* const SIInterfaceInfo,
void* Buffer,
const uint16_t Bytes)
{
uint8_t ErrorCode;
if ((USB_HostState != HOST_STATE_Configured) || !(SIInterfaceInfo->State.IsActive))
return PIPE_RWSTREAM_DeviceDisconnected;
Pipe_SelectPipe(SIInterfaceInfo->Config.DataINPipeNumber);
Pipe_Unfreeze();
ErrorCode = Pipe_Read_Stream_LE(Buffer, Bytes, NO_STREAM_CALLBACK);
Pipe_Freeze();
return ErrorCode;
}
/** Sends the given data directly to the printer via the data endpoints, for the sending of print commands in printer
* languages accepted by the attached printer (e.g. PCL).
*
* \param[in] PrinterCommands Pointer to the data to send to the attached printer
* \param[in] CommandSize Size of the data to send to the attached printer
*
* \return A value from the Pipe_Stream_RW_ErrorCodes_t enum
*/
uint8_t Printer_SendData(const void* const PrinterCommands,
const uint16_t CommandSize)
{
uint8_t ErrorCode;
Pipe_SelectPipe(PRINTER_DATA_OUT_PIPE);
Pipe_Unfreeze();
if ((ErrorCode = Pipe_Write_Stream_LE(PrinterCommands, CommandSize, NULL)) != PIPE_RWSTREAM_NoError)
return ErrorCode;
Pipe_ClearOUT();
Pipe_WaitUntilReady();
Pipe_Freeze();
return PIPE_RWSTREAM_NoError;
}