T_uezError Network_lwIP_SocketConnect( void *aWorkspace, T_uezNetworkSocket aSocket, T_uezNetworkAddr *aAddr, TUInt16 aPort) { T_Network_lwIP_Workspace *p = (T_Network_lwIP_Workspace *)aWorkspace; T_uezError error = UEZ_ERROR_NONE; T_lwIPSocket *p_socket = p->iSockets + aSocket; struct ip_addr ip; // Only valid sockets if ((aSocket == 0) || (aSocket > NETWORK_LWIP_NUM_SOCKETS)) return UEZ_ERROR_HANDLE_INVALID; UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); if (p_socket->iState == SOCKET_STATE_FREE) { error = UEZ_ERROR_HANDLE_INVALID; } else { IP4_ADDR(&ip, aAddr->v4[0], aAddr->v4[1], aAddr->v4[2], aAddr->v4[3]); error = IConvertErrorCode(netconn_connect(p_socket->iNetconn, &ip, aPort)); if (error == UEZ_ERROR_NONE) p_socket->iFlags |= SOCKET_FLAG_CONNECTED; } UEZSemaphoreRelease(p->iSem); return error; }
/*---------------------------------------------------------------------------* * Routine: Flash_Renesas_RX63N_Read *---------------------------------------------------------------------------* * Description: * Read bytes out of the Flash. * Inputs: * void *aW -- Workspace * TUInt32 aOffset -- Byte Offset address into flash to read * TUInt8 *aBuffer -- Pointer to buffer to receive data * TUInt32 aNumBytes -- Number of bytes to read * Outputs: * T_uezError -- Error code *---------------------------------------------------------------------------*/ T_uezError Flash_Renesas_RX63N_Read( void *aWorkspace, TUInt32 aOffset, TUInt8 *aBuffer, TUInt32 aNumBytes) { T_Flash_Renesas_RX63N_Workspace *p = (T_Flash_Renesas_RX63N_Workspace *)aWorkspace; T_uezError error = UEZ_ERROR_NONE; //TUInt8* Temp; // Make sure its not in a programming mode. UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); IExitProgramMode(p); current_mode = READ_MODE; // The memory is now accessible, copy the data over // Simple copy with check to see if the requested area is within the data flash if((void *)(((volatile TUInt8 *)p->iBaseAddr)+aOffset)>=(void*)DF_ADDRESS && (void *)(((volatile TUInt8 *)p->iBaseAddr)+aOffset)<=(void*)(DF_ADDRESS+DF_NUM_BLOCKS*DF_BLOCK_SIZE)) { memcpy(aBuffer, (void *)(((volatile TUInt8 *)p->iBaseAddr)+aOffset), aNumBytes); } else{ UEZSemaphoreRelease(p->iSem); return UEZ_ERROR_OUT_OF_RANGE; } UEZSemaphoreRelease(p->iSem); return error; }
/*---------------------------------------------------------------------------* * Routine: SetLevel *---------------------------------------------------------------------------* * Description: * Set the gain of the audio amp to the desired level * Inputs: * void *aWorkspace * TUInt8 aLevel --new level to set the amp to * Outputs: * T_uezError -- Error code *---------------------------------------------------------------------------*/ T_uezError AudioAmp_LM48110_SetLevel(void *aWorkSpace, TUInt8 aLevel) { T_AudioAmp_LM48110_Workspace *p = (T_AudioAmp_LM48110_Workspace *)aWorkSpace; T_uezDevice i2c; TUInt8 data[5] = { 0x1C, //Turn on both inputs 0x20, //Mask for Diagnostic 0x40, //Mask for Fault }; TUInt8 setLevel; UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); p->iLevel = aLevel; setLevel = ((p->iLevel * (p->iMaxLevel - p->iMinLevel))/0xFF) + p->iMinLevel; data[3] = (VOLUME_1_MASK | setLevel); data[4] = (VOLUME_2_MASK | setLevel); if(!p->iIsMuted){ if(UEZI2COpen(p->iI2CBus, &i2c) == UEZ_ERROR_NONE){ UEZI2CWrite(i2c, LM48100_ADDR, LM48100_SPEED, data, 5, 100);//UEZ_TIMEOUT_INFINITE); UEZI2CClose(i2c); } } UEZSemaphoreRelease(p->iSem); return UEZ_ERROR_NONE; }
/*---------------------------------------------------------------------------* * Routine: LED_Generic_GPIO_Off *---------------------------------------------------------------------------* * Description: * Get the current PCA9551 LEDBank reading * Inputs: * void *aW -- Workspace * T_uezTimeDate *aTimeDate -- Time and date returned * Outputs: * T_uezError -- Error code *---------------------------------------------------------------------------*/ T_uezError LED_Generic_GPIO_Off(void *aWorkspace, TUInt32 aLEDs) { T_LED_Generic_GPIO_Workspace *p = (T_LED_Generic_GPIO_Workspace *)aWorkspace; TUInt32 bitMask; TUInt8 i; T_LEDGPIOEntry *p_entry; UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); p_entry = p->iEntries; for (i = 0, bitMask = 1; i < p->iNumEntries; i++, bitMask <<= 1, p_entry++) { // Set the bits to on if bit is set if (aLEDs & bitMask) { p_entry->iLEDState = STATE_OFF; if (p_entry->iIsHighTrue) { (*p_entry->iGPIOPort)->Clear(p_entry->iGPIOPort, (1 << p_entry->iGPIOPinIndex)); } else { (*p_entry->iGPIOPort)->Set(p_entry->iGPIOPort, (1 << p_entry->iGPIOPinIndex)); } (*p_entry->iGPIOPort)->SetOutputMode(p_entry->iGPIOPort, (1 << p_entry->iGPIOPinIndex)); } } UEZSemaphoreRelease(p->iSem); return UEZ_ERROR_NONE; }
/*---------------------------------------------------------------------------*/ static TBool IHandleForward(WM_MESSAGE * pMsg, int aNCode, int aID) { T_ImageMessage message; TUInt32 *tempPointer; if (aNCode == WM_NOTIFICATION_RELEASED) { UEZSemaphoreGrab(G_LoadingSemaphore, UEZ_TIMEOUT_INFINITE); tempPointer = G_PreviousImage; G_PreviousImage = G_CurrentImage; G_CurrentImage = G_NextImage; G_NextImage = tempPointer; if (G_CurrentImage_Number < G_NumImagesOnCard){ G_CurrentImage_Number++; } else { G_CurrentImage_Number = 1; } UEZSemaphoreRelease(G_LoadingSemaphore); message = IMAGE_ADVANCED; UEZQueueSend(G_ImageLoadQueue, (void*)&message, 50); WM_InvalidateWindow(pMsg->hWin); IHideButtonsAndText(pMsg); } return EFalse; }
/*---------------------------------------------------------------------------* * Routine: SetLevel *---------------------------------------------------------------------------* * Description: * Set the gain of the audio amp to the desired level * Inputs: * void *aWorkspace * TUInt8 aLevel --new level to set the amp to * Outputs: * T_uezError -- Error code *---------------------------------------------------------------------------*/ T_uezError AudioAmp_WM8731_SetLevel(void *aWorkSpace, TUInt8 aLevel) { T_AudioAmp_WM8731_Workspace *p = (T_AudioAmp_WM8731_Workspace *)aWorkSpace; T_uezDevice i2c; TUInt8 data[4]; TUInt8 setLevel; UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); p->iLevel = aLevel; setLevel = ((p->iLevel * (p->iMaxLevel - p->iMinLevel))/0xFF) + p->iMinLevel; if(!p->iIsMuted){ if(UEZI2COpen(p->iI2CBus, &i2c) == UEZ_ERROR_NONE){ data[0] = WM8731_LOUT1V; data[1] = (0 << 7) | //RZCEN setLevel; //VOL UEZI2CWrite(i2c, WM8731_ADDR, WM8731_I2C_Speed, data, 2, 100); data[0] = WM8731_ROUT1V; data[1] = (0 << 7) | //RZCEN setLevel; //VOL UEZI2CWrite(i2c, WM8731_ADDR, WM8731_I2C_Speed, data, 3, 100); UEZI2CClose(i2c); } } UEZSemaphoreRelease(p->iSem); return UEZ_ERROR_NONE; }
/*---------------------------------------------------------------------------* * Routine: Flash_NXP_LPC17xx_40xx_Read *---------------------------------------------------------------------------* * Description: * Read bytes out of the Flash. * Inputs: * void *aW -- Workspace * TUInt32 aOffset -- Byte Offset address into flash to read * TUInt8 *aBuffer -- Pointer to buffer to receive data * TUInt32 aNumBytes -- Number of bytes to read * Outputs: * T_uezError -- Error code *---------------------------------------------------------------------------*/ T_uezError Flash_NXP_LPC17xx_40xx_Read( void *aWorkspace, TUInt32 aOffset, TUInt8 *aBuffer, TUInt32 aNumBytes) { T_Flash_NXP_LPC17xx_40xx_Workspace *p = (T_Flash_NXP_LPC17xx_40xx_Workspace *)aWorkspace; T_uezError error = UEZ_ERROR_NONE; // Make sure its not in a programming mode. UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); ILPC17xx_40xx_IAP_End(); // The memory is now accessible, copy the data over // Simple copy with check to see if the requested area is within the data flash if ((aOffset + (TUInt32)aNumBytes) <= (512 * 1024)) { memcpy(aBuffer, (void *)(aOffset), aNumBytes); } else { return UEZ_ERROR_OUT_OF_RANGE; } UEZSemaphoreRelease(p->iSem); return error; }
/*---------------------------------------------------------------------------* * Routine: Flash_NXP_LPC17xx_40xx_Write *---------------------------------------------------------------------------* * Description: * Write bytes into the Flash * Inputs: * void *aW -- Workspace * TUInt32 aOffset -- Byte Offset into flash to write * TUInt8 *aBuffer -- Pointer to buffer of data * TUInt32 aNumBytes -- Number of bytes to write * Outputs: * T_uezError -- Error code. Returns * UEZ_ERROR_BAD_ALIGNMENT if offset * or number of bytes * is not on word boundary. *---------------------------------------------------------------------------*/ T_uezError Flash_NXP_LPC17xx_40xx_Write( void *aWorkspace, TUInt32 aOffset, TUInt8 *aBuffer, TUInt32 aNumBytes) { T_Flash_NXP_LPC17xx_40xx_Workspace *p = (T_Flash_NXP_LPC17xx_40xx_Workspace *)aWorkspace; T_uezError error = UEZ_ERROR_NONE; // Let's do it UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); // Write the given block of data to the given address // Cut up the write command into blocks of BLOCK_SIZE size. // Keep doing this until all the bytes are processed while (aNumBytes) { error = IIAPWrite(&aOffset, &aBuffer, &aNumBytes); if (error != UEZ_ERROR_NONE) break; } UEZSemaphoreRelease(p->iSem); return error; }
/*---------------------------------------------------------------------------* * Routine: Serial_GenericHalfDuplex_Write *---------------------------------------------------------------------------* * Description: * Write data out the serial port or timeout trying. If a timeout, * the number of bytes written is reported. * Inputs: * void *aWorkspace -- This serial GenericHalfDuplex workspace * TUInt8 *aData -- Data to send * TUInt32 aNumBytes -- Number of bytes to read. * TUInt32 *aNumBytesWritten -- Number of bytes actually written. If * timeout occurs, this value is less than * aNumBytes. * Outputs: * T_uezError -- Error code. UEZ_ERROR_TIMEOUT is returned * if timeout occurs trying to write * the full amount and not enough room was * available. UEZ_ERROR_NONE is reported if * all data is written. *---------------------------------------------------------------------------*/ T_uezError Serial_GenericHalfDuplex_Write( void *aWorkspace, TUInt8 *aData, TUInt32 aNumBytes, TUInt32 *aNumBytesWritten, TUInt32 aTimeout) { // Decrement use count. Are we done? T_Serial_GenericHalfDuplex_Workspace *p = (T_Serial_GenericHalfDuplex_Workspace *)aWorkspace; T_uezError error = UEZ_ERROR_NONE; TUInt32 i; for (i=0; i<aNumBytes; i++) { // Send bytes one at a time UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); // Don't let interrupts occur while we do this one (*p->iSerial)->Deactivate((T_halWorkspace *)p->iSerial); // Are we currently busy sending data? if (p->iTxBusy) { // Yes, busy, stuff another byte into the end of the queue error = UEZQueueSend(p->iQueueSend, aData, aTimeout); } else { // Transmit is not busy yet. But we're about to be // Start driving again if (p->iDriveEnablePort) { if (p->iDriveEnablePolarity) { (*p->iDriveEnablePort)->Set(p->iDriveEnablePort, p->iDriveEnablePin); } else { (*p->iDriveEnablePort)->Clear(p->iDriveEnablePort, p->iDriveEnablePin); } } // Declare transmit busy p->iTxBusy = ETrue; UEZSemaphoreGrab(p->iSemEmpty, 0); p->iDidOutput = ETrue; error = (*p->iSerial)->OutputByte((T_halWorkspace *)p->iSerial, *aData); } (*p->iSerial)->Activate((T_halWorkspace *)p->iSerial); UEZSemaphoreRelease(p->iSem); // Report any errors up to this point if (error) break; // Next byte aData++; } // Report how many bytes we did get if (aNumBytesWritten) *aNumBytesWritten = i; // Report final error return error; }
/*---------------------------------------------------------------------------* * Routine: Network_lwIP_Scan *---------------------------------------------------------------------------* * Description: * Start a scan and setup a callback routine for receiving events. * Inputs: * void *aWorkspace -- Workspace * T_uezNetworkScanCallback *aCallback -- Routine to call when a scan is * found or the scan is complete * void *aCallbackWorkspace -- Workspace to use with the callback * char *aScanSSID -- ID to scan under (null string if none) * TUInt32 aTimeout -- Total time in ms to attempt scan before timing out. * Outputs: * T_uezError -- Error code *---------------------------------------------------------------------------*/ T_uezError Network_lwIP_Scan( void *aWorkspace, TUInt32 aChannelNumber, const char *aScanSSID, T_uezNetworkScanCallback aCallback, void *aCallbackWorkspace, TUInt32 aTimeout) { T_Network_lwIP_Workspace *p = (T_Network_lwIP_Workspace *)aWorkspace; T_uezError error = UEZ_ERROR_NONE; T_uezNetworkInfo scanInfo; PARAM_NOT_USED(aCallback); PARAM_NOT_USED(aCallbackWorkspace); // Doing a scan is an exclusive command. Nothing else can be // processing. UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); scanInfo.iRSSILevel = 0; scanInfo.iSecurityMode = UEZ_NETWORK_SECURITY_MODE_OPEN; scanInfo.iChannel = 0; strcpy(scanInfo.iName, "lwIP"); p->iInfo = scanInfo; p->iScanStatus = UEZ_NETWORK_SCAN_STATUS_COMPLETE; if (aCallback) { aCallback(aCallbackWorkspace, &scanInfo); } UEZSemaphoreRelease(p->iSem); return error; }
/*---------------------------------------------------------------------------* * Routine: PWM_Generic_SetMatchRegister *---------------------------------------------------------------------------* * Description: * Configure one of the several match registers for this PWM bank. * Outputs: * void *aWorkspace -- PWM's workspace * TUInt8 aMatchRegister -- Index to match register (0-7) * TUInt32 aMatchPoint -- Number of PWM cycles until match * TBool aDoInterrupt -- ETrue if want an interrupt, else EFalse * (NOTE: Interrupts currently not * implemented) * TBool aDoCounterReset -- ETrue if counter for this PWM bank is * to be reset on match. * TBool aDoStop -- ETrue if counter is to be stopped * when match occurs. *---------------------------------------------------------------------------*/ static T_uezError PWM_Generic_SetMatchRegister( void *aWorkspace, TUInt8 aMatchRegister, TUInt32 aMatchPoint, TBool aDoInterrupt, TBool aDoCounterReset, TBool aDoStop) { T_PWM_Generic_Workspace *p = (T_PWM_Generic_Workspace *)aWorkspace; T_uezError error; UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); error = (*p->iPWM)->SetMatchRegister( p->iPWM, aMatchRegister, aMatchPoint, aDoInterrupt, aDoCounterReset, aDoStop); UEZSemaphoreRelease(p->iSem); return error; }
/*---------------------------------------------------------------------------* * Routine: Button_NXP_PCA9551_Blink *---------------------------------------------------------------------------* * Description: * Blink the given Buttons with the blink register. * Inputs: * void *aW -- Workspace * TUInt32 aBlinkReg -- Blink register used to control blink * TUInt32 aButtons -- Bit mask of Buttons to blink * Outputs: * T_uezError -- Error code *---------------------------------------------------------------------------*/ T_uezError Button_NXP_PCA9551_Blink( void *aWorkspace, TUInt32 aBlinkReg, TUInt32 aButtons) { T_Button_NXP_PCA9551_Workspace *p = (T_Button_NXP_PCA9551_Workspace *)aWorkspace; TUInt8 i; TUInt32 bitMask; T_uezError error; TUInt8 state = STATE_BLINK0; if (aBlinkReg) state = STATE_BLINK1; // Allow only one transfer at a time UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); for (i=0, bitMask=1; i<8; i++, bitMask<<=1) { // Set the bits to on if bit is set if (aButtons & bitMask) p->iButtonsState[i] = state; } // Update the Buttons state error = IUpdateButtons(p); UEZSemaphoreRelease(p->iSem); return error; }
T_uezError Network_lwIP_SocketClose( void *aWorkspace, T_uezNetworkSocket aSocket) { T_Network_lwIP_Workspace *p = (T_Network_lwIP_Workspace *)aWorkspace; T_uezError error = UEZ_ERROR_UNKNOWN; T_lwIPSocket *p_socket = p->iSockets + aSocket; // Only valid sockets if ((aSocket == 0) || (aSocket > NETWORK_LWIP_NUM_SOCKETS)) return UEZ_ERROR_HANDLE_INVALID; UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); if (p_socket->iState == SOCKET_STATE_FREE) { error = UEZ_ERROR_HANDLE_INVALID; } else if ((p_socket->iFlags & SOCKET_FLAG_CONNECTED) == 0) { error = UEZ_ERROR_NOT_OPEN; } else { // Delete any receive buffers still open if (p_socket->iReceiveNetBuf) { netbuf_delete(p_socket->iReceiveNetBuf); } p_socket->iReceiveData = 0; p_socket->iReceiveLength = 0; p_socket->iReceiveRemaining = 0; p_socket->iReceiveNetBuf = 0; p_socket->iFlags = 0; error = IConvertErrorCode(netconn_close(p_socket->iNetconn)); } UEZSemaphoreRelease(p->iSem); return error; }
/*---------------------------------------------------------------------------* * Routine: RTC_PCF8563_Get *---------------------------------------------------------------------------* * Description: * Get the current RTC clock reading. * Inputs: * void *aW -- Workspace * T_uezTimeDate *aTimeDate -- Time and date returned * Outputs: * T_uezError -- Error code *---------------------------------------------------------------------------*/ T_uezError RTC_PCF8563_Get(void *aWorkspace, T_uezTimeDate *aTimeDate) { T_uezError error; T_RTC_PCF8563_Workspace *p = (T_RTC_PCF8563_Workspace *)aWorkspace; I2C_Request r; TUInt8 data[16]; TUInt8 reg0[1] = {0x00}; r.iAddr = PCF8563_I2C_ADDR; r.iSpeed = PCF8563_I2C_SPEED; r.iWriteData = reg0; r.iWriteLength = 1; r.iWriteTimeout = UEZ_TIMEOUT_INFINITE; r.iReadData = data; r.iReadLength = 16; r.iReadTimeout = UEZ_TIMEOUT_INFINITE; // wait until bus ready // Allow only one transfer at a time UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); error = (*p->iI2C)->ProcessRequest(p->iI2C, &r); if (!error) { aTimeDate->iTime.iSecond = IBCDToDecimal(data[2] & 0x7F); aTimeDate->iTime.iMinute = IBCDToDecimal(data[3] & 0x7F); aTimeDate->iTime.iHour = IBCDToDecimal(data[4] & 0x3F); aTimeDate->iDate.iMonth = IBCDToDecimal(data[7] & 0x1F); aTimeDate->iDate.iDay = IBCDToDecimal(data[5] & 0x3F); aTimeDate->iDate.iYear = 2000+IBCDToDecimal(data[8] & 0xFF); } UEZSemaphoreRelease(p->iSem); return error; }
T_uezError Network_lwIP_SocketDelete( void *aWorkspace, T_uezNetworkSocket aSocket) { T_Network_lwIP_Workspace *p = (T_Network_lwIP_Workspace *)aWorkspace; T_uezError error = UEZ_ERROR_NONE; T_lwIPSocket *p_socket = p->iSockets + aSocket; // Only valid sockets if ((aSocket == 0) || (aSocket > NETWORK_LWIP_NUM_SOCKETS)) return UEZ_ERROR_HANDLE_INVALID; UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); if (p_socket->iState == SOCKET_STATE_FREE) { error = UEZ_ERROR_HANDLE_INVALID; } else if ((p_socket->iFlags & SOCKET_FLAG_CONNECTED) != 0) { error = UEZ_ERROR_MUST_CLOSE_FIRST; } else { netconn_delete(p_socket->iNetconn); ISocketFree(p, aSocket); } UEZSemaphoreRelease(p->iSem); return error; }
T_uezError Network_lwIP_SocketListen( void *aWorkspace, T_uezNetworkSocket aSocket) { T_Network_lwIP_Workspace *p = (T_Network_lwIP_Workspace *)aWorkspace; T_uezError error = UEZ_ERROR_UNKNOWN; T_lwIPSocket *p_socket = p->iSockets + aSocket; // Only valid sockets if ((aSocket == 0) || (aSocket > NETWORK_LWIP_NUM_SOCKETS)) return UEZ_ERROR_HANDLE_INVALID; UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); if (p_socket->iState == SOCKET_STATE_FREE) { error = UEZ_ERROR_HANDLE_INVALID; } else { error = IConvertErrorCode(netconn_listen(p_socket->iNetconn)); if (error == UEZ_ERROR_NONE) { p_socket->iState = SOCKET_STATE_LISTENING; } } UEZSemaphoreRelease(p->iSem); return error; }
T_uezError RTC_PCF8563_SetClockOutHz( void *aWorkspace, TUInt32 aHertz) { T_uezError error = UEZ_ERROR_NOT_SUPPORTED; T_RTC_PCF8563_Workspace *p = (T_RTC_PCF8563_Workspace *)aWorkspace; TUInt8 value; typedef struct { TUInt32 iHertz; TUInt8 iControl; } T_pcf8563_clockOut; const T_pcf8563_clockOut clockOutLookupTable[] = { { 32768, CLKOUT_FE|0 }, { 1024, CLKOUT_FE|1 }, { 32, CLKOUT_FE|2 }, { 1, CLKOUT_FE|3 }, { 0, 0 }, }; TUInt32 i; UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); // Look in the above table and if found, change the value // otherwise, fall through and report NOT_SUPPORTED for (i=0; i<ARRAY_COUNT(clockOutLookupTable); i++) { if (clockOutLookupTable[i].iHertz == aHertz) { error = RTC_PCF8563_ReadReg(p, CLKOUT_control, &value); value &= ~0x83; if (error == UEZ_ERROR_NONE) error = RTC_PCF8563_WriteReg(p, CLKOUT_control, value|clockOutLookupTable[i].iControl); break; } } UEZSemaphoreRelease(p->iSem); return error; }
/*---------------------------------------------------------------------------* * Routine: Network_lwIP_Join *---------------------------------------------------------------------------* * Description: * Join a network access point * Inputs: * void *aWorkspace -- Workspace * char *aJoinName -- Name of network to join * char *aJoinPassword -- Password for access (or empty string for none) * TUInt32 aTimeout -- Time out until abort join * Outputs: * T_uezError -- Error code *---------------------------------------------------------------------------*/ T_uezError Network_lwIP_Join( void *aWorkspace, const char *aJoinName, const char *aJoinPassword, TUInt32 aTimeout) { T_Network_lwIP_Workspace *p = (T_Network_lwIP_Workspace *)aWorkspace; T_uezError error = UEZ_ERROR_NONE; // Doing a join is an exclusive command. Nothing else can be // processing. UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); // You can only join the group "lwIP" if (strcmp(aJoinName, "lwIP")) { error = UEZ_ERROR_NOT_FOUND; p->iJoinStatus = UEZ_NETWORK_JOIN_STATUS_FAIL; } else { // Passwords are ignored // Right name p->iJoinStatus = UEZ_NETWORK_JOIN_STATUS_SUCCESS; error = UEZ_ERROR_NONE; } UEZSemaphoreRelease(p->iSem); return error; }
/*---------------------------------------------------------------------------* * Routine: Flash_Renesas_RX63N_BlockErase *---------------------------------------------------------------------------* * Description: * Erase one ore more blocks in the given location * Inputs: * void *aW -- Workspace * TUInt32 aAddress -- Base address into device to write * TUInt8 *aBuffer -- Pointer to buffer of data * TUInt32 aNumBytes -- Number of bytes to write * Outputs: * T_uezError -- Error code *---------------------------------------------------------------------------*/ T_uezError Flash_Renesas_RX63N_BlockErase( void *aWorkspace, TUInt32 aBlockNum, TUInt32 aNumBytes) { T_Flash_Renesas_RX63N_Workspace *p = (T_Flash_Renesas_RX63N_Workspace *)aWorkspace; T_uezError error = UEZ_ERROR_NONE; if(aNumBytes!= DF_BLOCK_SIZE) { error = UEZ_ERROR_NOT_ENOUGH_DATA; }else{ IEnsureChipInfo(aWorkspace); // Let's do it UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); error = (T_uezError)R_FlashErase((TUInt8)aBlockNum); //<<---- Check for Error Here // Go ahead and force out of program mode IExitProgramMode(p); // Done erasing, resume normal control UEZSemaphoreRelease(p->iSem); } return error; }
/*---------------------------------------------------------------------------* * Routine: Serial_GenericHalfDuplex_Flush *---------------------------------------------------------------------------* * Description: * Write data out the serial port or timeout trying. If a timeout, * the number of bytes written is reported. * Inputs: * void *aWorkspace -- This serial generic workspace * TUInt32 aTimeout -- Timeout to wait for flush to finish * Outputs: * T_uezError -- Error code. UEZ_ERROR_TIMEOUT is returned * if timeout occurs trying to write * the full amount and not enough room was * available. UEZ_ERROR_NONE is reported if * all data is written. *---------------------------------------------------------------------------*/ T_uezError Serial_GenericHalfDuplex_Flush(void *aWorkspace) { // Decrement use count. Are we done? T_Serial_GenericHalfDuplex_Workspace *p = (T_Serial_GenericHalfDuplex_Workspace *)aWorkspace; T_uezError error = UEZ_ERROR_NONE; // Send bytes one at a time UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); // Don't let interrupts occur while we do this one (*p->iSerial)->Deactivate((T_halWorkspace *)p->iSerial); // Are we currently busy sending data? if (p->iTxBusy) { (*p->iSerial)->Activate((T_halWorkspace *)p->iSerial); // Yes, busy, wait for it to flush error = UEZSemaphoreGrab(p->iSemEmpty, UEZ_TIMEOUT_INFINITE); } else { (*p->iSerial)->Activate((T_halWorkspace *)p->iSerial); // Transmit is not busy yet. But we're about to be } UEZSemaphoreRelease(p->iSem); // Report final error return error; }
/*---------------------------------------------------------------------------* * Routine: RTC_PCF8563_Validate *---------------------------------------------------------------------------* * Description: * Validate the current RTC date and time. If the date or time is * invalid, reset to the given time and date. If no date and time is * given, just report that the RTC is invalid by returning * UEZ_ERROR_INVALID. * Inputs: * void *aW -- Workspace * const T_uezTimeDate *aTimeDate -- Time and date to set to * Outputs: * T_uezError -- Error code *---------------------------------------------------------------------------*/ T_uezError RTC_PCF8563_Validate( void *aWorkspace, const T_uezTimeDate *aTimeDate) { T_RTC_PCF8563_Workspace *p = (T_RTC_PCF8563_Workspace *)aWorkspace; T_uezError error; T_uezError ret_error = UEZ_ERROR_NONE; TUInt8 vlsec; // Allow only one transfer at a time UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); // Do the read error = RTC_PCF8563_ReadReg(p, VL_seconds, &vlsec); if (error) { // An error occurred in the communication to the part // Stop and return this error UEZSemaphoreRelease(p->iSem); return error; } // Is the data still got integrity? // (check high bit of VL_seconds) if (vlsec & 0x80) { // Integrity of data is bad ret_error = UEZ_ERROR_INVALID; // Was a new time/date setup passed in? if (aTimeDate) { // Set the time and date (without using semaphores since // we already have captured the semaphore) error = RTC_PCF8563_LowLevelSet(aWorkspace, aTimeDate); // Report any problems setting the time/date if (error) { UEZSemaphoreRelease(p->iSem); return error; } } } UEZSemaphoreRelease(p->iSem); // Return if we were invalid or not return ret_error; }
/*---------------------------------------------------------------------------* * Routine: Temperature_AnalogDevices_ADT7420_Read *---------------------------------------------------------------------------* * Description: * Get the current ADT7420 temperature reading * Inputs: * void *aW -- Workspace * T_uezTimeDate *aTimeDate -- Time and date returned * Outputs: * T_uezError -- Error code *---------------------------------------------------------------------------*/ T_uezError Temperature_AnalogDevices_ADT7420_Read( void *aWorkspace, TInt32 *aTemperature) { T_uezError error = UEZ_ERROR_NONE; T_Temperature_AnalogDevices_ADT7420_Workspace *p = (T_Temperature_AnalogDevices_ADT7420_Workspace *)aWorkspace; I2C_Request r; TUInt8 data[2]; TUInt8 reg0[2] = { 0x00, 0x00 }; TInt32 v; // Allow only one transfer at a time UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); if (!p->iConfigured) { r.iAddr = p->iI2CAddr; r.iSpeed = ADT7420_I2C_SPEED; r.iWriteData = reg0; r.iWriteLength = 2; r.iWriteTimeout = UEZ_TIMEOUT_INFINITE; r.iReadData = 0; r.iReadLength = 0; r.iReadTimeout = 0; p->iConfigured = ETrue; reg0[0] = ADT7420_CONFIG_REG; reg0[1] = 0; error = (*p->iI2C)->ProcessRequest(p->iI2C, &r); } if (error) { UEZSemaphoreRelease(p->iSem); return error; } r.iAddr = p->iI2CAddr; r.iSpeed = ADT7420_I2C_SPEED; r.iWriteData = reg0; r.iWriteLength = 1; r.iWriteTimeout = UEZ_TIMEOUT_INFINITE; r.iReadData = data; r.iReadLength = 2; r.iReadTimeout = UEZ_TIMEOUT_INFINITE; // wait until bus ready reg0[0] = ADT7420_TEMP_MSB_REG; error = (*p->iI2C)->ProcessRequest(p->iI2C, &r); if (!error) { // This temperature sensor is 11 bits up to about 125 C. // 3 bits are fraction, 7 bits are integer, and 1 sign bit // Put in the highest bits (masking off unused bits) v = (TInt32)((((data[0] << 8) | ((data[1]) << 0)) & 0xFFF8) << 16); // Now shift down to sign extend and get final result in 16.15 format v >>= 7; *aTemperature = (TInt32)v; }
T_uezError Network_lwIP_InfrastructureBringUp(void *aWorkspace) { T_Network_lwIP_Workspace *p = (T_Network_lwIP_Workspace *)aWorkspace; T_uezError error; UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); error = IStartup(p, &p->iInfrastructureSettings); UEZSemaphoreRelease(p->iSem); return error; }
/*---------------------------------------------------------------------------* * Routine: RTC_PCF8563_Set *---------------------------------------------------------------------------* * Description: * Set the current RTC clock. * Inputs: * void *aW -- Workspace * const T_uezTimeDate *aTimeDate -- Time and date to set to * Outputs: * T_uezError -- Error code *---------------------------------------------------------------------------*/ T_uezError RTC_PCF8563_Set(void *aWorkspace, const T_uezTimeDate *aTimeDate) { T_RTC_PCF8563_Workspace *p = (T_RTC_PCF8563_Workspace *)aWorkspace; T_uezError error; UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); error = RTC_PCF8563_LowLevelSet(p, aTimeDate); UEZSemaphoreRelease(p->iSem); return error; }
/*---------------------------------------------------------------------------* * Routine: Network_lwIP_Open *---------------------------------------------------------------------------* * Description: * Open up a new network user * Inputs: * void *aWorkspace -- Workspace * Outputs: * T_uezError -- Error code *---------------------------------------------------------------------------*/ T_uezError Network_lwIP_Open(void *aWorkspace) { T_Network_lwIP_Workspace *p = (T_Network_lwIP_Workspace *)aWorkspace; T_uezError error = UEZ_ERROR_NONE; UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); p->iNumOpen++; UEZSemaphoreRelease(p->iSem); return error; }
/*---------------------------------------------------------------------------* * Routine: RTC_Generic_Validate *---------------------------------------------------------------------------* * Description: * Normally, validate the current RTC date and time for integrity * if the power has been out. For generic usage, we'll always assume * that the RTC is NOT valid and set it to the given setting. * Inputs: * void *aW -- Workspace * const T_uezTimeDate *aTimeDate -- Time and date to set to * Outputs: * T_uezError -- Error code, always UEZ_ERROR_INVALID *---------------------------------------------------------------------------*/ static T_uezError RTC_Generic_Validate( void *aWorkspace, const T_uezTimeDate *aTimeDate) { T_RTC_Generic_Workspace *p = (T_RTC_Generic_Workspace *)aWorkspace; T_uezError error; // If the HAL driver has a Validate command, go ahead and use that // otherwise, assume its invalid UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); if ((*p->iRTC)->Validate) { error = (*p->iRTC)->Validate(p->iRTC, aTimeDate); UEZSemaphoreRelease(p->iSem); } else { UEZSemaphoreRelease(p->iSem); RTC_Generic_Set(aWorkspace, aTimeDate); error = UEZ_ERROR_INVALID; } return error; }
T_uezError Network_lwIP_InfrastructureConfigure( void *aWorkspace, T_uezNetworkSettings *aSettings) { T_Network_lwIP_Workspace *p = (T_Network_lwIP_Workspace *)aWorkspace; UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); p->iInfrastructureSettings = *aSettings; UEZSemaphoreRelease(p->iSem); return UEZ_ERROR_NONE; }
/*---------------------------------------------------------------------------* * Routine: ST_Accelo_LIS3LV02DQ_I2C_ReadXYZ *---------------------------------------------------------------------------* * Description: * Try to get the XYZ reading of the accelerometer * Inputs: * void *aW -- Workspace * AccelerometerReading *aReading -- Place to store reading * TUInt32 aTimeout -- Time to wait until reading is ready * Outputs: * T_uezError -- Error code, UEZ_ERROR_TIMEOUT if no * reading. *---------------------------------------------------------------------------*/ T_uezError ST_Accelo_LIS3LV02DQ_I2C_ReadXYZ( void *aWorkspace, AccelerometerReading *aReading, TUInt32 aTimeout) { TUInt32 i; TUInt8 status; T_uezError error; T_ST_Accelo_LIS3LV02DQ_I2C_Workspace *p = (T_ST_Accelo_LIS3LV02DQ_I2C_Workspace *)aWorkspace; static TUInt8 accdata[18]; aReading->iX = 0; aReading->iY = 0; aReading->iZ = 0; // Allow only one transfer at a time error = UEZSemaphoreGrab(p->iSem, aTimeout); if (error) return error; for (i=0; i<10; i++) { // try 10 times memset(accdata, 0xCC, sizeof(accdata)); error = IReadData(p, accdata, 0x27, 7, 100); status = accdata[0]; if (status & (1<<3)) { aReading->iX = ICalcG(accdata[2], accdata[1]); aReading->iY = ICalcG(accdata[4], accdata[3]); aReading->iZ = ICalcG(accdata[6], accdata[5]); p->iLastReading = *aReading; break; // break if successful } UEZTaskDelay(2); /* Array Contents After Read accdata[0] - STATUS_REG (0x27) accdata[1] - OUTX_L (0x28) accdata[2] - OUTX_H (0x29) accdata[3] - OUTY_L (0x2A) accdata[4] - OUTY_H (0x2B) accdata[5] - OUTZ_L (0x2C) accdata[6] - OUTZ_H (0x2D) */ } if (i==10) { *aReading = p->iLastReading; } UEZSemaphoreRelease(p->iSem); return error; }
T_uezError Network_lwIP_SocketWrite( void *aWorkspace, T_uezNetworkSocket aSocket, void *aData, TUInt32 aNumBytes, TBool aFlush, TUInt32 aTimeout) { T_Network_lwIP_Workspace *p = (T_Network_lwIP_Workspace *)aWorkspace; T_uezError error = UEZ_ERROR_UNKNOWN; T_lwIPSocket *p_socket = p->iSockets + aSocket; TUInt16 numWrite; PARAM_NOT_USED(aTimeout); if ((aSocket == 0) || (aSocket > NETWORK_LWIP_NUM_SOCKETS)) return UEZ_ERROR_HANDLE_INVALID; UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); if (p_socket->iState == SOCKET_STATE_FREE) { error = UEZ_ERROR_HANDLE_INVALID; } else if ((p_socket->iFlags & SOCKET_FLAG_CONNECTED) == 0) { error = UEZ_ERROR_NOT_OPEN; } else { while (aNumBytes) { // Send data up to a 16-bit value if (aNumBytes > 0xFFFF) numWrite = 0xFFFF; else numWrite = (TUInt16)aNumBytes; aNumBytes -= numWrite; // Clean up any previous timeout errors if (p_socket->iNetconn->err == ERR_TIMEOUT) p_socket->iNetconn->err = ERR_OK; // Write out this segment (noting if there is data past this one) error = IConvertErrorCode(netconn_write(p_socket->iNetconn, aData, numWrite, NETCONN_COPY | ((aFlush) ? 0 : NETCONN_MORE))); // Stop on any errors if (error != UEZ_ERROR_NONE) break; aData = (void *)(((char *)aData) + numWrite); } } UEZSemaphoreRelease(p->iSem); return error; }
/*---------------------------------------------------------------------------* * Routine: Flash_Renesas_RX63N_Write *---------------------------------------------------------------------------* * Description: * Write bytes into the Flash * Inputs: * void *aW -- Workspace * TUInt32 aOffset -- Byte Offset into flash to write * TUInt8 *aBuffer -- Pointer to buffer of data * TUInt32 aNumBytes -- Number of bytes to write * Outputs: * T_uezError -- Error code. Returns * UEZ_ERROR_BAD_ALIGNMENT if offset * or number of bytes * is not on word boundary. *---------------------------------------------------------------------------*/ T_uezError Flash_Renesas_RX63N_Write( void *aWorkspace, TUInt32 aOffset, TUInt8 *aBuffer, TUInt32 aNumBytes) { T_Flash_Renesas_RX63N_Workspace *p = (T_Flash_Renesas_RX63N_Workspace *)aWorkspace; T_uezError error = UEZ_ERROR_NONE; TUInt8 padBuffer[256]; TUInt8 ret = 0; TUInt8* flash_ptr = (TUInt8*)(p->iBaseAddr) + aOffset; // Let's do it UEZSemaphoreGrab(p->iSem, UEZ_TIMEOUT_INFINITE); memset(padBuffer, 0x00, 256); memcpy((void*)padBuffer, (void*)aBuffer, aNumBytes); while (1) { /* Check if number of bytes is greater than 256 */ if (aNumBytes > 256) { /* Number of bytes to write too high, set error flag to 1 */ error = UEZ_ERROR_READ_WRITE_ERROR; break; } /* Check if number of bytes to write is a multiple of 8 */ else if (aNumBytes % 8u) { /* Pad the data to write so it makes up to the nearest multiple of 8 */ aNumBytes += 8u - (aNumBytes % 8u); } // Passing the both the addresses, total offset and buffer(from where we want to write), as a value!! error = (T_uezError)R_FlashWrite(((TUInt32)(p->iBaseAddr)+aOffset), (TUInt32)padBuffer,(TUInt16)aNumBytes ); //<<---- Check for error here if(error) { error = UEZ_ERROR_READ_WRITE_ERROR; break; } ret = memcmp(aBuffer, flash_ptr, aNumBytes); if(ret!=0) { error = UEZ_ERROR_READ_WRITE_ERROR; break; } break; } UEZSemaphoreRelease(p->iSem); return error; }