xdc_Void A110x2500Radio::serviceInterrupt(xdc_UArg arg0, xdc_UArg arg1) {
while(1) {
Semaphore_pend(sem, BIOS_WAIT_FOREVER);
GateMutex_enter(GateMutex_handle(&mygate));
// Note: It is assumed that interrupts are disabled.
// The GDO0 ISR will only look for the EOP edge. Therefore, if the radio
// is not transmitting the EOP, it must be receiving an EOP signal.
if (gDataTransmitting)
{
/**
* Note: GDO0 is issued prior to the transmitter being completely
* finished. The state machine will remain in TX_END until transmission
* completes. The following waits for TX_END to correct the hardware
* behavior.
*/
while (CC1101GetMarcState(&gPhyInfo.cc1101) == eCC1101MarcStateTx_end);
gDataTransmitting = false;
}
else
{
gDataReceived = true;
readDataStream();
}
// Always go back to sleep.
sleep();
GateMutex_leave(GateMutex_handle(&mygate), 0);
}
}
/*
* ======== USBMSCHFatFsTiva_diskWrite ========
* This function writes sector(s) to the disk drive
*
* @param drv Drive Number
*
* @param buf Pointer to a buffer from which data is read
*
* @param sector Sector number to write to
*
* @param count Number of sectors to be written
*/
DRESULT USBMSCHFatFsTiva_diskWrite(BYTE drv, const BYTE *buf,
DWORD sector, BYTE count)
{
unsigned int key;
uint32_t driveWrite;
USBMSCHFatFsTiva_Object *object = USBMSCHFatFs_config->object;
Log_print2(Diags_USER1, "USBMSCHFatFs: diskWrite: Sector %d, Count %d",
sector, count);
if (!count) {
Log_print0(Diags_USER1, "USBMSCHFatFs: diskWrite: ERROR");
return (RES_PARERR);
}
if (object->state != USBMSCHFatFsTiva_CONNECTED) {
Log_print0(Diags_USER1, "USBMSCHFatFs: diskWrite: not initialized");
return (RES_NOTRDY);
}
key = GateMutex_enter(GateMutex_handle(&(object->gateUSBLibAccess)));
driveWrite = USBHMSCBlockWrite(object->MSCInstance, sector, (uint8_t *)buf, count);
GateMutex_leave(GateMutex_handle(&(object->gateUSBLibAccess)), key);
if (driveWrite == 0) {
Log_print0(Diags_USER2, "USBMSCHFatFs: diskWrite: OK");
return (RES_OK);
}
else {
Log_print0(Diags_USER2, "USBMSCHFatFs: diskWrite: ERROR");
return (RES_ERROR);
}
}
/*
* ======== USBMSCHFatFsTiva_diskRead ========
* This function reads sector(s) from the disk drive
*
* @param drv Drive Number
*
* @param buf Pointer to a buffer to which data is written
*
* @param sector Sector number to read from
*
* @param count Number of sectors to be read
*/
DRESULT USBMSCHFatFsTiva_diskRead(BYTE drv, BYTE *buf,
DWORD sector, BYTE count)
{
unsigned int key;
uint32_t driveRead;
USBMSCHFatFsTiva_Object *object = USBMSCHFatFs_config->object;
Log_print2(Diags_USER1, "USBMSCHFatFs: diskRead: Sector %d, Count %d",
sector, count);
if (object->state != USBMSCHFatFsTiva_CONNECTED) {
Log_print0(Diags_USER1, "USBMSCHFatFs: diskRead: not initialized");
return (RES_NOTRDY);
}
/* READ BLOCK */
key = GateMutex_enter(GateMutex_handle(&(object->gateUSBLibAccess)));
driveRead = USBHMSCBlockRead(object->MSCInstance, sector, buf, count);
GateMutex_leave(GateMutex_handle(&(object->gateUSBLibAccess)), key);
if (driveRead == 0) {
Log_print0(Diags_USER2, "USBMSCHFatFs: diskRead: OK");
return (RES_OK);
}
else {
Log_print0(Diags_USER2, "USBMSCHFatFs: diskRead: ERROR");
return (RES_ERROR);
}
}
/*
* ======== USBMSCHFatFsTiva_diskInitialize ========
* This function checks the USB Drive to see if it's ready to be accessed.
*
* This function attempts to read the USBHMSCDriveReady() function up to 10
* times to get a good return code. For some reason the first attempt to read
* this function doesn't return a good response value. Generally, you should
* get a good response on the second attempt.
* A gateMutex lock is required to prevent concurrent access to the USB
* Library's state machine variables within MSCInstance.
*
* @param drv Drive Number
*
* @return Returns the disk status to the FatFs module
*/
DSTATUS USBMSCHFatFsTiva_diskInitialize(BYTE drv)
{
unsigned char i;
unsigned int key;
uint32_t driveReady;
USBMSCHFatFsTiva_Object *object = USBMSCHFatFs_config->object;
/* Determine if the USB Drive is ready up to 10 times */
for (i = 0; i < 10; i++ ) {
key = GateMutex_enter(GateMutex_handle(&(object->gateUSBLibAccess)));
driveReady = USBHMSCDriveReady(object->MSCInstance);
GateMutex_leave(GateMutex_handle(&(object->gateUSBLibAccess)), key);
if (driveReady == 0) {
Log_print1(Diags_USER1, "USBMSCHFatFs: disk initialization: "
"ready after %d tries", i);
return (0x00); /* Disk OK */
}
}
Log_print0(Diags_USER1, "USBMSCHFatFs: disk initialization: not ready");
return (STA_NOINIT);
}
/*
* ======== USBMSCHFatFsTiva_serviceUSBHost ========
* Task to periodically service the USB Stack
*
* USBHCDMain handles the USB Stack's statemachine. For example it handles the
* enumeration process when a device connects.
* Future USB library improvement goal is to remove this polling requirement..
*/
static void USBMSCHFatFsTiva_serviceUSBHost(UArg arg0, UArg arg1)
{
unsigned int key;
USBMSCHFatFsTiva_Object *object = USBMSCHFatFs_config->object;
while (true) {
key = GateMutex_enter(GateMutex_handle(&(object->gateUSBLibAccess)));
USBHCDMain();
GateMutex_leave(GateMutex_handle(&(object->gateUSBLibAccess)), key);
/* Future enhancement to remove the Task_sleep */
Task_sleep(10);
}
}
uint8_t TwoWire::endTransmission(uint8_t sendStop)
{
bool ret;
WireContext *wc = getWireContext();
if (i2c == NULL) {
return (4); /* 4 = 'other error' */
}
ret = I2C_transfer(i2c, &(wc->i2cTransaction));
wc->txWriteIndex = 0;
wc->i2cTransaction.writeCount = 0;
wc->rxReadIndex = 0; //i2cTransaction will overwrite buffer staring at 0
wc->rxWriteIndex = wc->i2cTransaction.readCount;
wc->i2cTransaction.readCount = 0;
if (sendStop) {
wc->idle = true;
}
if (gateEnterCount) {
GateMutex_leave(GateMutex_handle(&gate), --gateEnterCount);
}
/* success = 0; 4 = other error */
return (ret ? 0 : 4);
}
/*
* ======== USBMSCHFatFsTiva_waitForConnect ========
*/
bool USBMSCHFatFsTiva_waitForConnect(USBMSCHFatFs_Handle handle,
unsigned int timeout)
{
unsigned int key;
bool ret = true;
USBMSCHFatFsTiva_Object *object = handle->object;
/* Need exclusive access to prevent a race condition */
key = GateMutex_enter(GateMutex_handle(&(object->gateUSBWait)));
if (object->state == USBMSCHFatFsTiva_NO_DEVICE) {
if (!Semaphore_pend(Semaphore_handle(&(object->semUSBConnected)),
timeout)) {
ret = false;
}
}
GateMutex_leave(GateMutex_handle(&(object->gateUSBWait)), key);
return (ret);
}
void TwoWire::beginTransmission(uint8_t address)
{
WireContext *wc = getWireContext();
GateMutex_enter(GateMutex_handle(&gate));
gateEnterCount++;
if (wc->idle) {
wc->i2cTransaction.slaveAddress = address;
wc->idle = false;
}
}
