/*
*********************************************************************************************************
* WF_RxDataReadPacket()
*
* Description : Reads all or part of an Rx data packet from MRF24WB0M memory to Host CPU memory.
*
* Argument(s) : p_rxData - pointer to where Rx data packet will be written
* length - Number of bytes to read from MRF24WB0M memory
* startIndex - start index within MRF24WB0M memory to start read from
*
* Return(s) : None
*
* Caller(s) : Application
*
* Notes: : None
*
*********************************************************************************************************
*/
void WF_RxDataReadPacket(uint8_t *p_rxData,
uint16_t length,
uint16_t startIndex)
{
#if !defined(USE_WF_HOST_BUFFER)
uint16_t byteCount;
#endif
SYS_ASSERT(startIndex == 0);
/* if application calls this function, and gHostRAWDataPacketReceived is not true, then error, because */
/* driver has not received a data packet. */
if (!g_HostRAWDataPacketReceived)
{
SYS_ASSERT(false);
}
g_HostRAWDataPacketReceived = false; /* clear flag for next data packet */
/* Ensure the MRF24WB0M is awake (only applies if PS-Poll was enabled) */
EnsureWFisAwake();
#if !defined(USE_WF_HOST_BUFFER) /* when testing with MCHP stack the packet is already mounted */
/* Mount Read FIFO to RAW Rx window. Size of Rx data packet is returned */
byteCount = RawMountRxBuffer();
SYS_ASSERT(byteCount > 0);
#endif
/* now that buffer mounted it is safe to reenable interrupts */
WF_EintEnable();
/* read the requested bytes into callers buffer */
RawRead(RAW_RX_ID, RAW_RX_DEST_ADD_INDEX + startIndex, length, p_rxData);
}
static void startStroke( uint pointIndex, uint pointCount )
{
SYS_ASSERT( pointCount >= 2u );
Stroke* pStroke = &s_renderer.currentStroke;
pStroke->progress = 0.0f;
pStroke->activeSegment = 0u;
pStroke->segmentProgress = 0.0f;
// compute total length of this stroke:
float strokeLength = 0.0f;
float2 segmentStart = s_renderer.strokeBuffer.points[ pointIndex ];
for( uint i = 1u; i < pointCount; ++i )
{
const float2 segmentEnd = s_renderer.strokeBuffer.points[ pointIndex + i ];
float segmentLength = float2_distance( &segmentStart, &segmentEnd );
strokeLength += segmentLength;
segmentStart = segmentEnd;
}
pStroke->length = strokeLength;
SYS_ASSERT( strokeLength < 100000.0f );
//SYS_TRACE_DEBUG( "Starting new stroke (length=%.2f #segments=%i)\n", strokeLength, pointCount - 1u );
}
void DRV_USART_BufferEventHandlerSet
(
const DRV_HANDLE hClient,
const DRV_USART_BUFFER_EVENT_HANDLER eventHandler,
const uintptr_t context
)
{
DRV_USART_CLIENT_OBJ * clientObj;
/* Validate the driver handle */
if((DRV_HANDLE_INVALID == hClient) || (0 == hClient))
{
/* This means the handle is invalid */
SYS_ASSERT(false, "Driver Handle is invalid");
return;
}
clientObj = (DRV_USART_CLIENT_OBJ *)hClient;
if(!clientObj->inUse)
{
SYS_ASSERT(false, "Invalid driver handle");
return;
}
/* Register the event handler with the client */
clientObj->eventHandler = eventHandler;
clientObj->context = context;
}
void DRIVER DRV_USB_ClientEventCallBackSet
(
DRV_HANDLE client ,
uintptr_t hReferenceData ,
DRV_USB_EVENT_CALLBACK eventCallBack
)
{
DRV_USB_CLIENT_OBJ * hClient;
if(client == DRV_HANDLE_INVALID)
{
SYS_ASSERT(false, "Bad Client Handle");
return;
}
hClient = (DRV_USB_CLIENT_OBJ *) client;
if(!hClient->inUse)
{
SYS_ASSERT(false, "Invalid client handle");
return;
}
/* Assign event call back and reference data */
hClient->hClientArg = hReferenceData;
hClient->pEventCallBack = eventCallBack;
return;
}
int StreamStart(V3XA_STREAM handle)
{
DS_stream *pStr = g_pDSStreams + handle;
LPDIRECTSOUNDBUFFER pSrc = g_pDSHandles[pStr->channel].pbuffer;
SYS_ASSERT(pSrc);
SYS_ASSERT(pStr->nState & 1);
if (((pStr->nState&1)==0)||(!pSrc))
{
return 0;
}
if (SYS_DXTRACE(pSrc->Play(0, 0, DSBPLAY_LOOPING))!=DS_OK)
return 0;
SYS_DXTRACE(pSrc->SetCurrentPosition( 0 ));
SYS_DXTRACE(pSrc->SetFrequency( pStr->sample.samplingRate ));
pStr->m_nPreviousPosition = 0;
pStr->m_nUploadedBytes = 0;
pStr->m_nWritePosition = 0;
pStr->m_nStreamState = 1;
pStr->m_nTotalBytes = 0;
pStr->m_nUploadedBytes = 0;
pStr->m_nWriteBytes = 0;
return 0;
}
USB_ERROR DRIVER _DRV_USB_MAKE_NAME(DEVICE_IRPCancelAll)
(
DRV_HANDLE client,
USB_ENDPOINT endpointAndDirection
)
{
int direction;
uint8_t endpoint;
DRV_USB_OBJ * hDriver;
DRV_USB_BDT_ENTRY * pBDT;
DRV_USB_DEVICE_ENDPOINT_OBJ * endpointObject;
bool interruptWasEnabled = false;
endpoint = endpointAndDirection & 0xF;
direction = ((endpointAndDirection & 0x80) != 0);
if(endpoint >= DRV_USB_ENDPOINTS_NUMBER)
{
SYS_ASSERT(false,"Unsupported endpoint");
return USB_ERROR_DEVICE_ENDPOINT_INVALID;
}
if(DRV_HANDLE_INVALID == client)
{
SYS_ASSERT(false, "Driver Handle is invalid");
return USB_ERROR_PARAMETER_INVALID;
}
hDriver = _DRV_USB_OBJ;
/* Get the endpoint object */
endpointObject = _DRV_USB_ENDPOINT_OBJ(endpoint, direction);
/* Get the BDT entry for this endpoint */
pBDT = hDriver->pBDT + (4 * endpoint) + (2 * direction);
if(!hDriver->isInInterruptContext)
{
//OSAL : Get mutex
interruptWasEnabled = _DRV_USB_InterruptSourceDisable(DRV_USB_INTERRUPT_SOURCE);
}
/* Get the odd and even endpoint BDT back */
pBDT->byte[0] = 0x0;
(pBDT + 1)->byte[0] = 0x0;
/* Flush the endpoint */
_DRV_USB_DEVICE_IRPQueueFlush(endpointObject);
if(!hDriver->isInInterruptContext)
{
if(interruptWasEnabled)
{
_DRV_USB_InterruptSourceEnable(DRV_USB_INTERRUPT_SOURCE);
}
// OSAL: Release Mutex
}
return(USB_ERROR_NONE);
}
void DRIVER DRV_USB_Close( DRV_HANDLE client )
{
DRV_USB_CLIENT_OBJ * hClient;
DRV_USB_OBJ * hDriver;
if(client == DRV_HANDLE_INVALID)
{
SYS_ASSERT(false, "Bad Client Handle");
return;
}
hClient = (DRV_USB_CLIENT_OBJ *) client;
if(!hClient->inUse)
{
SYS_ASSERT(false, "Invalid client handle");
return;
}
hDriver = (DRV_USB_OBJ *)hClient->hDriver;
/* Remove this client from the driver client
* table */
hDriver->nClients--;
hDriver->pDrvUSBClientObj = (DRV_USB_CLIENT_OBJ *)DRV_HANDLE_INVALID;
/* Give back the client */
hClient->inUse = false;
hClient->pEventCallBack = NULL;
}
void APP_NVM_Write1(void)
{
int i;
uint8_t buf_t[10];
char c_tmp = 0;
for(i = 0;i<DRV_NVM_PAGE_SIZE;i++)
{
NVM_DATA_TEST_BUFF[i] = 0x55;
}
SYS_CONSOLE_MESSAGE("1. Open\r\n");
if(wifi_nvm_handle.nvmHandle == 0)
{
wifi_nvm_handle.nvmHandle = DRV_NVM_Open(0, DRV_IO_INTENT_READWRITE);
if(DRV_HANDLE_INVALID == wifi_nvm_handle.nvmHandle){ SYS_ASSERT(DRV_HANDLE_INVALID != wifi_nvm_handle.nvmHandle,"Error Opening Driver");}
}
SYS_CONSOLE_MESSAGE("2. erase\r\n");
wifi_nvm_handle.nvmbufferHandle = DRV_NVM_Erase(wifi_nvm_handle.nvmHandle,(uint8_t*)NVM_WF_CONFIG__ADDRESS, DRV_NVM_PAGE_SIZE);
if(DRV_NVM_BUFFER_HANDLE_INVALID == wifi_nvm_handle.nvmbufferHandle){SYS_ASSERT(false, "Driver Erase Failed");}
while(DRV_NVM_BUFFER_COMPLETED != DRV_NVM_BufferStatus(wifi_nvm_handle.nvmHandle, wifi_nvm_handle.nvmbufferHandle)) { ;}
SYS_CONSOLE_MESSAGE("3. Write\r\n");
wifi_nvm_handle.nvmbufferHandle = DRV_NVM_Write(wifi_nvm_handle.nvmHandle, (uint8_t *)(NVM_WF_CONFIG__ADDRESS), (uint8_t *)NVM_DATA_TEST_BUFF, DRV_NVM_ROW_SIZE);
if(DRV_NVM_BUFFER_HANDLE_INVALID == wifi_nvm_handle.nvmbufferHandle){SYS_ASSERT(false, "Driver Writing Failed");}
while(DRV_NVM_BUFFER_COMPLETED != DRV_NVM_BufferStatus(wifi_nvm_handle.nvmHandle, wifi_nvm_handle.nvmbufferHandle)){;}
SYS_CONSOLE_MESSAGE("4. Done\r\n");
}
void wifi_nvm_erase(int size)
{
if(wifi_nvm_handle.nvmHandle == 0)
{
wifi_nvm_handle.nvmHandle = DRV_NVM_Open(0, DRV_IO_INTENT_READWRITE);
if(DRV_HANDLE_INVALID == wifi_nvm_handle.nvmHandle){ SYS_ASSERT(DRV_HANDLE_INVALID != wifi_nvm_handle.nvmHandle,"Error Opening Driver");}
}
wifi_nvm_handle.nvmbufferHandle = DRV_NVM_Erase(wifi_nvm_handle.nvmHandle,(uint8_t*)NVM_WF_CONFIG__ADDRESS, DRV_NVM_PAGE_SIZE);
if(DRV_NVM_BUFFER_HANDLE_INVALID == wifi_nvm_handle.nvmbufferHandle){SYS_ASSERT(false, "Driver Erase Failed");}
while(DRV_NVM_BUFFER_COMPLETED != DRV_NVM_BufferStatus(wifi_nvm_handle.nvmHandle, wifi_nvm_handle.nvmbufferHandle)) { ;}
}
void wifi_nvm_read(uint8_t *data_comfig, int size)
{
if(wifi_nvm_handle.nvmHandle == 0)
{
wifi_nvm_handle.nvmHandle = DRV_NVM_Open(0, DRV_IO_INTENT_READWRITE);
if(DRV_HANDLE_INVALID == wifi_nvm_handle.nvmHandle){ SYS_ASSERT(DRV_HANDLE_INVALID != wifi_nvm_handle.nvmHandle,"Error Opening Driver");}
}
wifi_nvm_handle.nvmbufferHandle = DRV_NVM_Read(wifi_nvm_handle.nvmHandle, data_comfig, (uint8_t*)NVM_WF_CONFIG__ADDRESS, size);
if(DRV_NVM_BUFFER_HANDLE_INVALID == wifi_nvm_handle.nvmbufferHandle){ SYS_ASSERT(false, "Driver Read Failed");}
while(DRV_NVM_BUFFER_COMPLETED != DRV_NVM_BufferStatus(wifi_nvm_handle.nvmHandle, wifi_nvm_handle.nvmbufferHandle)){;}
}
void DRIVER DRV_USB_Deinitialize
(
const SYS_MODULE_INDEX object
)
{
DRV_USB_OBJ * drvObj;
USBHS_MODULE_ID usbID;
if(object == SYS_MODULE_OBJ_INVALID)
{
/* Invalid object */
SYS_ASSERT(false, "Invalid object");
return ;
}
if( object >= DRV_USB_INSTANCES_NUMBER)
{
SYS_ASSERT(false,"Invalid driver Index");
return ;
}
if(gDrvUSBObj[object].inUse == false)
{
/* Cannot deinitialize an object that is
* not already in use. */
SYS_ASSERT(false, "Instance not in use");
return ;
}
drvObj = &gDrvUSBObj[object];
usbID = drvObj->usbID;
/* Populate the driver object with
* the required data */
drvObj->inUse = false;
drvObj->status = SYS_STATUS_UNINITIALIZED;
/* Clear and disable the interrupts */
_DRV_USB_InterruptSourceDisable(drvObj->interruptSource);
_DRV_USB_InterruptSourceClear(drvObj->interruptSource);
/* Set number of clients to zero */
drvObj->nClients = 0;
drvObj->pDrvUSBClientObj = (DRV_USB_CLIENT_OBJ*)DRV_HANDLE_INVALID;
return;
} /* DRV_USB_Initialize */
DRV_HANDLE DRIVER _DRV_USB_MAKE_NAME(Open)
(
const DRV_IO_INTENT ioIntent
)
{
DRV_USB_CLIENT_OBJ * hClient;
DRV_USB_OBJ * drvObj;
drvObj = &gDrvUSBGroup.gDrvUSBObj;
if(drvObj->status != SYS_STATUS_READY)
{
/* The USB module should be ready */
SYS_ASSERT(false, "Was the driver initialized?");
return DRV_HANDLE_INVALID;
}
if(ioIntent != (DRV_IO_INTENT_EXCLUSIVE|DRV_IO_INTENT_NONBLOCKING
|DRV_IO_INTENT_READWRITE))
{
/* The driver only supports this mode */
SYS_ASSERT(false, "IO intent mode not supported");
return DRV_HANDLE_INVALID;
}
if(drvObj->nClients > 0)
{
/* Driver supports exclusive open only */
SYS_ASSERT(false, "Driver already opened once. Cannot open again");
return DRV_HANDLE_INVALID;
}
/* One to One mapping between client object
* and driver object */
hClient = &gDrvUSBGroup.gDrvUSBClientObj;
/* Clear prior value */
hClient->pEventCallBack = NULL;
/* Let the driver know that it has been opened once */
drvObj->nClients ++;
/* Return the client object */
return ( ( DRV_HANDLE ) hClient );
}
void SYS_Initialize ( void* data )
{
unsigned int cache_status;
/* enable cache */
cache_status = CHECON;
cache_status |= (3 << _CHECON_PREFEN_POSITION);
CHECON = cache_status;
CheKseg0CacheOn();
/* Initialize the BSP */
BSP_Initialize( );
/* Initialize the USB Controller driver */
appDrvObject.usbCDObject = DRV_USB_Initialize (DRV_USB_INDEX_0 ,
( SYS_MODULE_INIT* ) & usbCDInitData);
/* check if the object returned by the controller driver is valid */
SYS_ASSERT((SYS_MODULE_OBJ_INVALID != appDrvObject.usbCDObject), "Invalid USB CD object");
/* Initialize the USB device layer */
appDrvObject.usbDevObject = USB_DEVICE_Initialize (USB_DEVICE_INDEX_0 ,
( SYS_MODULE_INIT* ) & usbDevInitData);
/* check if the object returned by the device layer is valid */
SYS_ASSERT((SYS_MODULE_OBJ_INVALID != appDrvObject.usbDevObject), "Invalid USB DEVICE object");
/* open an instance of the device layer */
appData.usbDevHandle = USB_DEVICE_Open( USB_DEVICE_INDEX_0, DRV_IO_INTENT_READWRITE );
/* Register a callback with device layer to get event notification (for end point 0) */
USB_DEVICE_EventCallBackSet(appData.usbDevHandle, APP_UsbDeviceEventCallBack);
/* Initialize the Application */
APP_Initialize ( );
/* Initializethe interrupt system */
SYS_INT_Initialize();
/* set priority for USB interrupt source */
SYS_INT_PrioritySet(INT_SOURCE_USB_1, INT_PRIORITY_LEVEL3);
/* set sub-priority for USB interrupt source */
SYS_INT_SubprioritySet(INT_SOURCE_USB_1, INT_SUBPRIORITY_LEVEL3);
/* Initialize the global interrupts */
SYS_INT_Enable();
}
void APP_NVM_READ(uint32_t flag)
{
int i;
uint8_t buf_t[30];
uint32_t Source_Addr;
switch(flag)
{
case 0:
Source_Addr = NVM_WF_CONFIG__ADDRESS - DRV_NVM_PAGE_SIZE;
break;
case 1:
Source_Addr = NVM_WF_CONFIG__ADDRESS ;
break;
case 2:
Source_Addr = NVM_WF_CONFIG__ADDRESS + DRV_NVM_PAGE_SIZE;
break;
case 3:
Source_Addr = NVM_WF_CONFIG__ADDRESS + 2*DRV_NVM_PAGE_SIZE;
break;
case 4:
Source_Addr = NVM_WF_CONFIG__ADDRESS + 3*DRV_NVM_PAGE_SIZE;
break;
case 5:
Source_Addr = NVM_WF_CONFIG__ADDRESS + 4*DRV_NVM_PAGE_SIZE;
break;
default:
Source_Addr = NVM_WF_CONFIG__ADDRESS;
break;
}
if(wifi_nvm_handle.nvmHandle == 0)
{
wifi_nvm_handle.nvmHandle = DRV_NVM_Open(0, DRV_IO_INTENT_READWRITE);
if(DRV_HANDLE_INVALID == wifi_nvm_handle.nvmHandle){ SYS_ASSERT(DRV_HANDLE_INVALID != wifi_nvm_handle.nvmHandle,"Error Opening Driver");}
}
wifi_nvm_handle.nvmbufferHandle = DRV_NVM_Read(wifi_nvm_handle.nvmHandle, NVM_DATA_TEST_BUFF, (uint8_t*)Source_Addr, DRV_NVM_PAGE_SIZE);
if(DRV_NVM_BUFFER_HANDLE_INVALID == wifi_nvm_handle.nvmbufferHandle){ SYS_ASSERT(false, "Driver Read Failed");}
while(DRV_NVM_BUFFER_COMPLETED != DRV_NVM_BufferStatus(wifi_nvm_handle.nvmHandle, wifi_nvm_handle.nvmbufferHandle)){;}
SYS_CONSOLE_MESSAGE("\r\n---------");
for(i=0;i<DRV_NVM_PAGE_SIZE;i++)
{
if(i%64 == 0) {sprintf(buf_t,"\r\n[%08x]:",i+Source_Addr);SYS_CONSOLE_MESSAGE(buf_t);}
sprintf(buf_t,"%02x ",NVM_DATA_TEST_BUFF[i]);
SYS_CONSOLE_MESSAGE(buf_t);
}
SYS_CONSOLE_MESSAGE("\r\n---------");
}
/****************************************************************************
Function:
bool DRV_SPI_Initialize(SpiChannel chn, SpiOpenFlags oFlags, unsigned int fpbDiv)
Summary:
This function initializes the SPI channel and also sets the brg register.
Description:
This function initializes the SPI channel and also sets the brg register.
The SPI baudrate BR is given by: BR=Fpb/(2*(SPIBRG+1))
The input parametes fpbDiv specifies the Fpb divisor term (2*(SPIBRG+1)),
so the BRG is calculated as SPIBRG=fpbDiv/2-1.
Precondition:
None
Parameters:
chn - the channel to set
oFlags - a SpiOpenFlags or __SPIxCONbits_t structure that sets the module behavior
fpbDiv - Fpb divisor to extract the baud rate: BR=Fpb/fpbDiv.
Returns:
true if success
false otherwise
Remarks:
- The baud rate is always obtained by dividing the Fpb to an even number
between 2 and 1024.
- When selecting the number of bits per character, SPI_OPEN_MODE32 has the highest priority.
If SPI_OPEN_MODE32 is not set, then SPI_OPEN_MODE16 selects the character width.
- The SPI_OPEN_SSEN is taken into account even in master mode. If it is set the library
will properly se the SS pin as an digital output.
***************************************************************************/
bool DRV_SPI_Initialize(SpiChannel chn, SpiOpenFlags oFlags, unsigned int fpbDiv)
{
#if defined (__C32__)
SpiChnOpen(chn, oFlags, fpbDiv);
#elif defined (__C30__)
volatile uint16_t con1 = 0;
uint16_t con2 = 0;
uint16_t con3 = 0;
uint8_t i;
if((SYS_CLK_PeripheralClockGet()/fpbDiv) > 10000000ul)
{
SYS_ASSERT(false, "Requested SPI frequency is not supported!");
return false;
// the SPI clock is selected more than 10MHz.
// Select the frequency as per the data sheet of the particular 16bit device.
}
for(i = 0; i < SPI_CLK_TBL_ELEMENT_COUNT; i++)
{
if((SYS_CLK_PeripheralClockGet()/fpbDiv) <= SpiClkTbl[i].clock)
{
con1 = SpiClkTbl[i].scale;
break;
}
}
con1 |= oFlags;
con3 |= SPI_EN;
switch(chn)
{
case 1:
OpenSPI1(con1,con2,con3);
break;
case 2:
SPI2STAT &= 0x7FFF;
OpenSPI2(con1,con2,con3);
break;
default:
SYS_ASSERT(false, "Requested SPI channel is not supported!");
return false;
}
#endif
return true;
}
/*****************************************************************************
* FUNCTION: RawGetByte
*
* RETURNS: error code
*
* PARAMS:
* rawId - RAW ID
* pBuffer - Buffer to read bytes into
* length - number of bytes to read
*
* NOTES: Reads bytes from the RAW engine
*****************************************************************************/
void RawGetByte(uint16_t rawId, uint8_t *pBuffer, uint16_t length)
{
uint8_t regId;
#if defined(OUTPUT_RAW_TX_RX)
uint16_t i;
#endif
/* if reading a data message do following check */
if (!g_WaitingForMgmtResponse)
{
// if RAW index previously set out of range and caller is trying to do illegal read
if ( (rawId==RAW_RX_ID) &&
g_rxIndexSetBeyondBuffer &&
(GetRawWindowState(RAW_RX_ID) == WF_RAW_DATA_MOUNTED) )
{
SYS_ASSERT(false, ""); /* attempting to read past end of RAW buffer */
}
}
regId = (rawId==RAW_ID_0)?RAW_0_DATA_REG:RAW_1_DATA_REG;
ReadWFArray(regId, pBuffer, length);
#if defined(OUTPUT_RAW_TX_RX)
for (i = 0; i < length; ++i)
{
char buf[16];
sprintf(buf,"R: %#x\r\n", pBuffer[i]);
SYS_CONSOLE_MESSAGE(buf);
}
#endif
}
bool AllocateDataTxBuffer(uint16_t bytesNeeded)
{
uint16_t bufAvail;
uint16_t byteCount;
/* Ensure the MRF24W is awake (only applies if PS-Poll was enabled) */
EnsureWFisAwake();
/* get total bytes available for DATA tx memory pool */
bufAvail = Read16BitWFRegister(WF_HOST_WFIFO_BCNT0_REG) & 0x0fff; /* LS 12 bits contain length */
/* if enough bytes available to allocate */
if ( bufAvail >= bytesNeeded )
{
/* allocate and create the new Tx buffer (mgmt or data) */
byteCount = RawMove(RAW_TX_ID, RAW_DATA_POOL, true, bytesNeeded);
SYS_ASSERT(byteCount != 0, "");
}
/* else not enough bytes available at this time to satisfy request */
else
{
return false;
}
RawWindowReady[RAW_TX_ID] = true;
SetRawWindowState(RAW_TX_ID, WF_RAW_DATA_MOUNTED);
return true;
}
/*******************************************************************************
Function:
void WF_MulticastGetConfig(uint8_t filterId, t_wfMultiCastConfig *p_config);
Summary:
Gets a multicast address filter from one of the two multicast filters.
Description:
Gets the current state of the specified Multicast Filter.
Normally would call SendGetParamMsg, but this GetParam returns all 6 address
filters + 2 more bytes for a total of 48 bytes plus header. So, doing this
msg manually to not require a large stack allocation to hold all the data.
Exact format of management message stored on device is:
[0] -- always mgmt response (2)
[1] -- always WF_GET_PARAM_SUBTYPE (16)
[2] -- result (1 if successful)
[3] -- mac state (not used)
[4] -- data length (length of response data starting at index 6)
[5] -- not used
[6-11] -- Compare Address 0 address
[12] -- Compare Address 0 group
[13] -- Compare Address 0 type
[14] -- Compare Address 0 macBitMask
[15-17] -- Not used
[18-23] -- Compare Address 1 address
[24] -- Compare Address 1 group
[25] -- Compare Address 1 type
[26] -- Compare Address 1 macBitMask
[27-29] -- Not used
[30-35] -- Compare Address 2 address
[36] -- Compare Address 2 group
[37] -- Compare Address 2 type
[38] -- Compare Address 2 macBitMask
[39-41] -- Not used
[42-47] -- Compare Address 3 address
[48] -- Compare Address 3 group
[49] -- Compare Address 3 type
[50] -- Compare Address 3 macBitMask
[51-53] -- Not used
[54-59] -- Compare Address 4 address
[60] -- Compare Address 4 group
[61] -- Compare Address 4 type
[62] -- Compare Address 4 macBitMask
[63-65] -- Not used
[66-71] -- Compare Address 5 address
[72] -- Compare Address 5 group
[73] -- Compare Address 5 type
[74] -- Compare Address 5 macBitMask
[75-77] -- Not used
Precondition:
MACInit must be called first.
Parameters:
filterId -- ID of filter being retrieved. Must be:
DRV_WIFI_MULTICAST_FILTER_1 or DRV_WIFI_MULTICAST_FILTER_2
p_config -- Pointer to config structure filled in by this function.
Returns:
None.
Remarks:
None.
*****************************************************************************/
void WF_MulticastGetConfig(uint8_t filterId, DRV_WIFI_SWMULTICAST_CONFIG *p_config)
{
uint8_t hdr[4];
uint8_t paramData[12];
SYS_ASSERT( (filterId <= DRV_WIFI_MULTICAST_FILTER_16), "");
hdr[0] = WF_MGMT_REQUEST_TYPE;
hdr[1] = WF_GET_PARAM_SUBTYPE;
hdr[2] = 0x00; /* MS 8 bits of param Id, always 0 */
hdr[3] = PARAM_COMPARE_ADDRESS; /* LS 8 bits of param ID */
SendMgmtMsg(hdr, /* header */
sizeof(hdr), /* size of header */
&filterId, /* multicast filter id */
1); /* length is 1 */
WaitForMgmtResponseAndReadData(WF_GET_PARAM_SUBTYPE, /* expected subtype */
sizeof(paramData), /* num data bytes to read */
MSG_PARAM_START_DATA_INDEX, /* starting at this index */
paramData); /* write the response data here */
/* put param data into return structure */
p_config->filterId = filterId;
memcpy((void *)p_config->macBytes, (void *)¶mData[0], 6);
p_config->action = paramData[7];
p_config->macBitMask = paramData[8];
}
/*******************************************************************************
Function:
void DRV_WIFI_HWMulticastFilterSet(uint8_t multicastFilterId,
uint8_t multicastAddress[6])
Summary:
Sets a multicast address filter using one of the two hardware multicast filters.
Description:
This function allows the application to configure up to two hardware Multicast
Address Filters on the MRF24W. If two active multicast filters are set
up they are OR’d together – the MRF24W will receive and pass to the Host
CPU received packets from either multicast address.
The allowable values for the multicast filter are:
* DRV_WIFI_MULTICAST_FILTER_1
* DRV_WIFI_MULTICAST_FILTER_2
By default, both Multicast Filters are inactive.
Parameters:
multicastFilterId - DRV_WIFI_MULTICAST_FILTER_1 or DRV_WIFI_MULTICAST_FILTER_2
multicastAddress - 6-byte address (all 0xFF will inactivate the filter)
Returns:
None.
*****************************************************************************/
void DRV_WIFI_HWMulticastFilterSet(uint8_t multicastFilterId,
uint8_t multicastAddress[6])
{
int i;
bool deactivateFlag = true;
uint8_t msgData[8];
SYS_ASSERT( ((multicastFilterId == DRV_WIFI_MULTICAST_FILTER_1) || (multicastFilterId == DRV_WIFI_MULTICAST_FILTER_2)), "" );
/* check if all 6 bytes of the address are 0xff, implying that the caller wants to deactivate */
/* the multicast filter. */
for (i = 0; i < 6; ++i)
{
/* if any byte is not 0xff then a presume a valid multicast address */
if (multicastAddress[i] != 0xff)
{
deactivateFlag = false;
break;
}
}
msgData[0] = multicastFilterId; /* Address Compare Register number to use */
if (deactivateFlag)
{
msgData[1] = ADDRESS_FILTER_DEACTIVATE;
}
else
{
msgData[1] = MULTICAST_ADDRESS; /* type of address being used in the filter */
}
memcpy(&msgData[2], (void *)multicastAddress, WF_MAC_ADDRESS_LENGTH);
SendSetParamMsg(PARAM_COMPARE_ADDRESS, msgData, sizeof(msgData) );
}
void SYS_Initialize ( void * data )
{
/* Configure the cache and flash wait
* states for 80MHz. */
SYSTEMConfigPerformance(80000000);
/* Initializethe interrupt system */
SYS_INT_Initialize();
/* Initialize the global interrupts */
SYS_INT_Enable();
SYS_INT_VectorPrioritySet(INT_VECTOR_USB, INT_PRIORITY_LEVEL4);
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB, INT_SUBPRIORITY_LEVEL0);
SYS_INT_VectorPrioritySet(INT_VECTOR_CT, INT_PRIORITY_LEVEL3);
SYS_INT_VectorSubprioritySet(INT_VECTOR_USB, INT_SUBPRIORITY_LEVEL0);
BSP_Initialize();
/* Initialize the USB device layer */
deviceLayerObject = USB_DEVICE_Initialize (USB_DEVICE_INDEX_0 ,
( SYS_MODULE_INIT* ) & usbDevInitData);
/* check if the object returned by the device layer is valid */
SYS_ASSERT((SYS_MODULE_OBJ_INVALID != deviceLayerObject), "Invalid USB DEVICE object");
/* Initialize the Application */
APP_Initialize ( );
}
void DRIVER DRV_USB_Tasks_ISR( SYS_MODULE_OBJ object )
{
DRV_USB_OBJ * hDriver;
hDriver = &gDrvUSBObj[object];
hDriver->isInInterruptContext = true;
switch(hDriver->operationMode)
{
case USB_OPMODE_DEVICE:
_DRV_USB_DEVICE_TASKS_ISR(hDriver);
break;
case USB_OPMODE_HOST:
_DRV_USB_HOST_TASKS_ISR(hDriver);
break;
case USB_OPMODE_OTG:
break;
default:
SYS_ASSERT(false, "What mode are you trying?");
break;
}
/* Clear the interrupt */
_DRV_USB_InterruptSourceClear(hDriver->interruptSource);
hDriver->isInInterruptContext = false;
}
/*****************************************************************************
* Function:
* SYS_FS_MEDIA_BUFFER_HANDLE SYS_FS_MEDIA_MANAGER_SectorWrite
* (
* uint16_t diskNo,
* uint32_t sector,
* uint8_t * dataBuffer,
* uint32_t noSectors
* )
*
* Description:
* Function to write to a sector of specified media (disk). This is the function in
* media manager layer. This function in turn call the specific sector write function from
* the list of function pointer of media driver.
*
* Precondition:
* None
*
* Parameters:
* diskNo - media number
* sector - Sector # to which data to be written
* dataBuffer - pointer to buffer which holds the data to be written
* noSectors - Number of sectors to be written
*
* Returns:
* Buffer handle of type SYS_FS_MEDIA_BUFFER_HANDLE
*/
SYS_FS_MEDIA_BUFFER_HANDLE SYS_FS_MEDIA_MANAGER_SectorWrite
(
uint16_t diskNo, /* SYS_FS_MEDIA disk no */
uint32_t sector, /* Start sector */
uint8_t * dataBuffer, /* Application buffer */
uint32_t noSectors /* Number of sectors to write */
)
{
volatile SYS_FS_MEDIA *media;
if(diskNo >= SYS_FS_VOLUME_NUMBER)
{
SYS_ASSERT(false, "Invalid Disk");
return SYS_FS_MEDIA_BUFFER_HANDLE_INVALID;
}
media = &gSYSFSMediaObject[diskNo];
if(media->mediaDriverClientHandle == DRV_HANDLE_INVALID)
{
return SYS_FS_MEDIA_HANDLE_INVALID;
}
return(media->mediaDriverFunctions->sectorWrite(media->mediaDriverClientHandle,
sector, dataBuffer, noSectors));
}
bool DRIVER _DRV_USB_MAKE_NAME(DEVICE_EndpointIsStalled)(DRV_HANDLE client,
USB_ENDPOINT endpointAndDirection)
{
/* Return the state of the endpoint */
DRV_USB_DEVICE_ENDPOINT_OBJ * endpointObj;
uint8_t endpoint = endpointAndDirection & 0xF;
int direction = ((endpointAndDirection & 0x80) != 0);
if(DRV_HANDLE_INVALID == client)
{
SYS_ASSERT(false, "Driver Handle is invalid");
return false;
}
endpointObj = _DRV_USB_ENDPOINT_OBJ(endpoint, direction);
if((endpointObj->endpointState &
DRV_USB_DEVICE_ENDPOINT_STATE_STALLED) != 0)
{
return true;
}
else
{
return false;
}
}
void SYS_CLK_Initialize ( const SYS_CLK_INIT *clkInit )
{
CLK_SOURCES_SYSTEM systemSource;
uint32_t clockClosest = 0;
/* If the user has not passed anything that means he want to retain the
* configuration bit settings */
if ( clkInit != NULL )
{
systemSource = PLIB_OSC_CurrentSysClockGet ( OSC_PLIB_ID );
if (!_SYS_CLK_SystemClockSet ( systemSource, clkInit->systemClockFrequencyHz,
clkInit->waitTillComplete, &clockClosest ))
{
SYS_ASSERT(false, "Critical failure when setting system clock");
return;
}
#if defined(PLIB_OSC_ExistsOnWaitAction)
if ( PLIB_OSC_ExistsOnWaitAction ( OSC_PLIB_ID ) )
{
/* Sets the oscillator's response to a 'Wait' instruction */
PLIB_OSC_OnWaitActionSet ( OSC_PLIB_ID, clkInit->onWaitInstruction );
}
#endif
}
else
{
clkObject.systemClock = _SYS_CLK_SystemClockRead ();
}
clkObject.callback=NULL;
}
static void renderer_addSingleStroke( const float2* pStrokePoints, uint strokePointCount )
{
SYS_ASSERT( s_renderer.pageState == PageState_BeforeDraw );
if( !pStrokePoints || strokePointCount < 2u )
{
return;
}
const int isCycle=float2_isEqual(&pStrokePoints[0u],&pStrokePoints[strokePointCount-1u]);
StrokeCommand command;
createDrawCommand( &command );
const float variance = s_renderer.currentVariance;
// transform, randomize and copy positions
for( uint i = 0u; i < strokePointCount; ++i )
{
const float2 strokePoint = pStrokePoints[ i ];
// reduced variance in the beginning
const int isFirstVertexInStroke = command.data.draw.pointCount == 0u;
float2 point;
transformPoint( &point, &strokePoint, isFirstVertexInStroke ? variance / 4.0f : variance );
if( pushStrokePoint( &point ) )
{
command.data.draw.pointCount++;
}
}
computeStrokeNormals( &command, isCycle );
pushStrokeCommand( &command );
}
static int Open(void * hwnd)
{
CGLRendererInfoObj renderer;
long numRenderer;
CGDirectDisplayID l[32];
CGDisplayCount count;
SYS_ASSERT(g_pCGLC == 0);
UNUSED(hwnd);
CGGetActiveDisplayList (sizeof(l), l, &count);
#ifdef _DEBUG
// Debug in multiple monitor. Use the secondary monitor for rendering
g_cgDisplayID = l[count-1];
#else
g_cgDisplayID = CGMainDisplayID ();
#endif
g_cgPrevDisplayMode = CGDisplayCurrentMode (g_cgDisplayID);
g_cgDisplayModeList = CGDisplayAvailableModes (g_cgDisplayID);
CGLQueryRendererInfo(CGDisplayIDToOpenGLDisplayMask(g_cgDisplayID), &renderer, &numRenderer);
CGLDestroyRendererInfo(renderer);
return 0;
}
void NG_FXLoadList()
{
FILE *in = FIO_cur->fopen(".\\anim\\anim.lst", "rb");
SYS_ASSERT(in);
g_pszAnimList = array_loadtext(in, 32, -1);
FIO_cur->fclose(in);
}
/*****************************************************************************
* FUNCTION: RawSetByte
*
* RETURNS: None
*
* PARAMS:
* rawId - RAW ID
* pBuffer - Buffer containing bytes to write
* length - number of bytes to read
*
* NOTES: Writes bytes to RAW window
*****************************************************************************/
void RawSetByte(uint16_t rawId, uint8_t *pBuffer, uint16_t length)
{
uint8_t regId;
#if defined(OUTPUT_RAW_TX_RX)
uint16_t i;
#endif
/* if previously set index past legal range and now trying to write to RAW engine */
if ( (rawId == 0) && g_rxIndexSetBeyondBuffer && (GetRawWindowState(RAW_TX_ID) == WF_RAW_DATA_MOUNTED) )
{
SYS_ASSERT(false, ""); /* attempting to write past end of RAW window */
}
/* write RAW data to chip */
regId = (rawId==RAW_ID_0)?RAW_0_DATA_REG:RAW_1_DATA_REG;
WriteWFArray(regId, pBuffer, length);
#if defined(OUTPUT_RAW_TX_RX)
for (i = 0; i < length; ++i)
{
char buf[16];
sprintf(buf,"T: %#x\r\n", pBuffer[i]);
SYS_CONSOLE_MESSAGE(buf);
}
#endif
}
bool AllocateMgmtTxBuffer(uint16_t bytesNeeded)
{
uint16_t bufAvail;
uint16_t byteCount;
/* get total bytes available for MGMT tx memory pool */
bufAvail = Read16BitWFRegister(WF_HOST_WFIFO_BCNT1_REG) & 0x0fff; /* LS 12 bits contain length */
/* if enough bytes available to allocate */
if ( bufAvail >= bytesNeeded )
{
/* allocate and create the new Tx buffer (mgmt or data) */
byteCount = RawMove(RAW_TX_ID, RAW_MGMT_POOL, true, bytesNeeded);
SYS_ASSERT(byteCount != 0, "");
}
/* else not enough bytes available at this time to satisfy request */
else
{
return false;
}
RawWindowReady[RAW_TX_ID] = true;
SetRawWindowState(RAW_TX_ID, WF_RAW_MGMT_MOUNTED);
return true;
}
int32_t DRV_SPI1_ISRErrorTasks(struct DRV_SPI_OBJ * dObj)
{
if (dObj->currentJob == NULL)
{
return 0;
}
register DRV_SPI_JOB_OBJECT * currentJob = dObj->currentJob;
if (PLIB_SPI_ReceiverHasOverflowed(SPI_ID_2))
{
if (currentJob->completeCB != NULL)
{
(*currentJob->completeCB)(DRV_SPI_BUFFER_EVENT_ERROR, (DRV_SPI_BUFFER_HANDLE)currentJob, currentJob->context);
}
currentJob->status = DRV_SPI_BUFFER_EVENT_ERROR;
if (dObj->operationEnded != NULL)
{
(*dObj->operationEnded)(DRV_SPI_BUFFER_EVENT_ERROR, (DRV_SPI_BUFFER_HANDLE)currentJob, currentJob->context);
}
if (DRV_SPI_SYS_QUEUE_FreeElement(dObj->queue, currentJob) != DRV_SPI_SYS_QUEUE_SUCCESS)
{
SYS_ASSERT(false, "\r\nSPI Driver: Queue free element error.");
return 0;
}
dObj->currentJob = NULL;
PLIB_SPI_BufferClear(SPI_ID_2);
PLIB_SPI_ReceiverOverflowClear (SPI_ID_2 );
SYS_INT_SourceStatusClear(INT_SOURCE_SPI_2_ERROR);
}
return 0;
}
