int main()
{
uart_config_t uart_conf;
DISABLE_IRQ();
hal_clk_init();
sys_tick_init();
I2cInit( &I2c, I2C_SCL, I2C_SDA );
uart_conf.baud = 9600;
uart_conf.word_length = 8;
uart_conf.parity = NONE;
uart_conf.stop_bits = 1;
uart_init(&uart_conf);
ENABLE_IRQ();
app_init();
DISABLE_IRQ();
led_init();
while(1){
/** polling all events */
app_evt();
led_evt();
}
}
/*----------------------------------------------------------------------------*
* NAME
* I2CcommsInit
*
* DESCRIPTION
* This function initialises the I2C
*
* RETURNS
* Nothing
*
*----------------------------------------------------------------------------*/
extern void I2CcommsInit(void)
{
/* Initialise I2C if it is not already initialised */
if(!i2c_initialised)
{
i2c_initialised = TRUE;
PioSetModes( ((0x01L << I2C_SDA_PIO) | (0x01L << I2C_SCL_PIO)),
pio_mode_user);
/* Configure the PIOs as Input */
PioSetDirs( ((0x01L << I2C_SDA_PIO) | (0x01L << I2C_SCL_PIO)),
FALSE);
PioSetPullModes(((0x01L << I2C_SDA_PIO) | (0x01L << I2C_SCL_PIO)),
pio_mode_strong_pull_down);
PioSetEventMask(((0x01L << I2C_SDA_PIO) | (0x01L << I2C_SCL_PIO)),
pio_event_mode_disable);
/* Configure the I2C controller */
I2cInit(I2C_SDA_PIO,
I2C_SCL_PIO,
I2C_POWER_PIO_UNDEFINED,
pio_i2c_pull_mode_strong_pull_up);
/* Configure pull mode of the I2C pins */
PioSetI2CPullMode(pio_i2c_pull_mode_strong_pull_up);
/* Configure the I2C clock */
I2cConfigClock(I2C_SCL_100KBPS_HIGH_PERIOD, I2C_SCL_100KBPS_LOW_PERIOD);
// I2cConfigClock(I2C_SCL_400KBPS_HIGH_PERIOD, I2C_SCL_400KBPS_LOW_PERIOD);
/* Enable the I2C controller */
I2cEnable(TRUE);
}
}
void LcdDisplayInitI2c(void)
{
I2cEnable(TRUE);
/* I2cInit(uint8 sda_pio, uint8 scl_pio, uint8 power_pio, pio_pull_mode pull); */
/* I2cInit() resets clock to 100kHz. */
I2cInit(PIO_SDA, PIO_SCL, I2C_POWER_PIO_UNDEFINED, pio_i2c_pull_mode_strong_pull_up);
I2cConfigClock(I2C_SCL_400KBPS_HIGH_PERIOD, I2C_SCL_400KBPS_LOW_PERIOD);
} /* LcdDisplayInitI2c */
void BoardInitMcu( void )
{
Gpio_t ioPin;
if( McuInitialized == false )
{
HAL_Init( );
// LEDs
GpioInit( &Led1, LED_1, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &Led2, LED_2, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &Led3, LED_3, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, Led3Status );
SystemClockConfig( );
GpioInit( &ioPin, UART_RX, PIN_INPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
if( GpioRead( &ioPin ) == 1 ) // Debug Mode
{
UsbIsConnected = true;
FifoInit( &Uart1.FifoTx, UartTxBuffer, UART_FIFO_TX_SIZE );
FifoInit( &Uart1.FifoRx, UartRxBuffer, UART_FIFO_RX_SIZE );
// Configure your terminal for 8 Bits data (7 data bit + 1 parity bit), no parity and no flow ctrl
UartInit( &Uart1, UART_1, UART_TX, UART_RX );
UartConfig( &Uart1, RX_TX, 115200, UART_8_BIT, UART_1_STOP_BIT, NO_PARITY, NO_FLOW_CTRL );
}
else
{
UsbIsConnected = false;
UartDeInit( &Uart1 );
}
RtcInit( );
BoardUnusedIoInit( );
}
else
{
SystemClockReConfig( );
}
I2cInit( &I2c, I2C_SCL, I2C_SDA );
AdcInit( &Adc, BAT_LEVEL_PIN );
SpiInit( &SX1272.Spi, RADIO_MOSI, RADIO_MISO, RADIO_SCLK, NC );
SX1272IoInit( );
if( McuInitialized == false )
{
McuInitialized = true;
if( GetBoardPowerSource( ) == BATTERY_POWER )
{
CalibrateSystemWakeupTime( );
}
}
}
void InitSystem() {
// General init
InitOsc();
InitPort();
// Peripheral init
AdcInit();
I2cInit();
// Interrupt init
InterruptInit();
}
int main(void)
{
uint32_t current_time = 0;
SystemInit();
GpioInit();
//AdcInit();
TimerInit(0, 1ul * _millisecond);
CallbackRegister(MotorHandler, 10ul * _millisecond);
CallbackEnable(MotorHandler);
TimerEnable(0);
EncoderInit();
MotorInit();
MotorStart();
I2cInit(SENSOR_BUS);
current_time = now;
while(now < current_time + 1000);
// center the wheels if they aren't already
set_motor_position(MOTOR_FRONT_FRONT, FF_CENTER, 70);
set_motor_position(MOTOR_BACK_FRONT, BF_CENTER, 72);
while (motor[MOTOR_FRONT_FRONT].state == MOTOR_MOVING && motor[MOTOR_BACK_FRONT].state == MOTOR_MOVING);
current_time = now;
while(now < current_time + 5000);
// offset one motor
set_motor_position(MOTOR_FRONT_FRONT, FF_CENTER, 70);
set_motor_position(MOTOR_BACK_FRONT, BF_CENTER + 50, 72);
while (motor[MOTOR_FRONT_FRONT].state == MOTOR_MOVING && motor[MOTOR_BACK_FRONT].state == MOTOR_MOVING);
current_time = now;
while(now < current_time + 1000);
while (1)
{
if (get_ir_sen())
{
set_motor_position(MOTOR_FRONT_FRONT, FF_CENTER + 50, -70);
set_motor_position(MOTOR_BACK_FRONT, BF_CENTER, -72);
while (motor[MOTOR_FRONT_FRONT].state == MOTOR_MOVING && motor[MOTOR_BACK_FRONT].state == MOTOR_MOVING);
}
else
{
set_motor_position(MOTOR_FRONT_FRONT, FF_CENTER, 70);
set_motor_position(MOTOR_BACK_FRONT, BF_CENTER + 50, 72);
while (motor[MOTOR_FRONT_FRONT].state == MOTOR_MOVING && motor[MOTOR_BACK_FRONT].state == MOTOR_MOVING);
}
}
return 0;
}
void BoardInitMcu( void )
{
if( McuInitialized == false )
{
// We use IRQ priority group 4 for the entire project
// When setting the IRQ, only the preemption priority is used
NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
// Disable Systick
// SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk; // Systick IRQ off
// SCB->ICSR |= SCB_ICSR_PENDSTCLR_Msk; // Clear SysTick Exception pending flag
/* Setup SysTick Timer for 1 ms interrupts (not too often to save power) */
if (SysTick_Config(SystemCoreClock / 1000))
{
/* Capture error */
while (1);
}
I2cInit( &I2c, I2C_SCL, I2C_SDA );
SpiInit( &SX1276.Spi, RADIO_MOSI, RADIO_MISO, RADIO_SCLK, NC );
SX1276IoInit( );
#if defined( USE_DEBUG_PINS )
GpioInit( &DbgPin1, J1_1, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin2, J1_2, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin3, J1_3, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin4, J1_4, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
#endif
BoardInitPeriph( );
#if( LOW_POWER_MODE_ENABLE )
TimerSetLowPowerEnable( true );
#else
TimerSetLowPowerEnable( false );
#endif
BoardUnusedIoInit( );
if( TimerGetLowPowerEnable( ) == true )
{
RtcInit( );
}
else
{
TimerHwInit( );
}
McuInitialized = true;
}
}
int main(void)
{
I2cInit( &I2c, I2C_SCL, I2C_SDA );
GpioInit( &UsbDetect, USB_ON, PIN_INPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DcDcEnable, DC_DC_EN, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &RadioPushButton, RADIO_PUSH_BUTTON, PIN_INPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &Led1, LED_1, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &Led2, LED_2, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &Led3, LED_3, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
GpioInit( &Led4, LED_4, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1 );
if( GpioRead( &RadioPushButton ) == 0 )
{ /* Test if user code is programmed starting from address 0x8003000 */
if( ( ( *( volatile uint32_t* )ApplicationAddress ) & 0x2FFE0000 ) == 0x20000000 )
{ /* Jump to user application */
JumpAddress = *( volatile uint32_t* )( ApplicationAddress + 4 );
Jump_To_Application = ( pFunction ) JumpAddress;
/* Initialize user application's Stack Pointer */
__set_MSP( *( volatile uint32_t* ) ApplicationAddress );
Jump_To_Application( );
}
} /* Otherwise enters DFU mode to allow user to program his application */
/* Enter DFU mode */
DeviceState = STATE_dfuERROR;
DeviceStatus[0] = STATUS_ERRFIRMWARE;
DeviceStatus[4] = DeviceState;
UsbMcuInit( );
/* Main loop */
while (1)
{
GpioWrite( &Led1, 0 );
GpioWrite( &Led2, 0 );
GpioWrite( &Led3, 0 );
GpioWrite( &Led4, 0 );
DelayLoop( 500 );
GpioWrite( &Led1, 1 );
GpioWrite( &Led2, 1 );
GpioWrite( &Led3, 1 );
GpioWrite( &Led4, 1 );
DelayLoop( 500 );
}
}
void BoardInitMcu( void )
{
if( McuInitialized == false )
{
#if defined( USE_BOOTLOADER )
// Set the Vector Table base location at 0x3000
NVIC_SetVectorTable( NVIC_VectTab_FLASH, 0x3000 );
#endif
// We use IRQ priority group 4 for the entire project
// When setting the IRQ, only the preemption priority is used
NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
// Disable Systick
SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk; // Systick IRQ off
SCB->ICSR |= SCB_ICSR_PENDSTCLR_Msk; // Clear SysTick Exception pending flag
I2cInit( &I2c, I2C_SCL, I2C_SDA );
AdcInit( &Adc, BAT_LEVEL );
SpiInit( &SX1272.Spi, RADIO_MOSI, RADIO_MISO, RADIO_SCLK, NC );
SX1272IoInit( );
#if defined( USE_DEBUG_PINS )
GpioInit( &DbgPin1, CON_EXT_1, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin2, CON_EXT_3, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin3, CON_EXT_7, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin4, CON_EXT_9, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
#endif
BoardUnusedIoInit( );
#if defined( USE_USB_CDC )
UsbMcuInit( );
UartInit( &UartUsb, UART_USB_CDC, NC, NC );
UartConfig( &UartUsb, RX_TX, 115200, UART_8_BIT, UART_1_STOP_BIT, NO_PARITY, NO_FLOW_CTRL );
#endif
#ifdef LOW_POWER_MODE_ENABLE
RtcInit( );
#else
TimerHwInit( );
#endif
McuInitialized = true;
}
}
void BoardInitMcu( void )
{
if( McuInitialized == false )
{
#if defined( USE_BOOTLOADER )
// Set the Vector Table base location at 0x3000
SCB->VTOR = FLASH_BASE | 0x3000;
#endif
HAL_Init( );
SystemClockConfig( );
#if defined( USE_USB_CDC )
UartInit( &UartUsb, UART_USB_CDC, NC, NC );
UartConfig( &UartUsb, RX_TX, 115200, UART_8_BIT, UART_1_STOP_BIT, NO_PARITY, NO_FLOW_CTRL );
DelayMs( 1000 ); // 1000 ms for Usb initialization
#endif
RtcInit( );
BoardUnusedIoInit( );
I2cInit( &I2c, I2C_1, I2C_SCL, I2C_SDA );
}
else
{
SystemClockReConfig( );
}
AdcInit( &Adc, BAT_LEVEL_PIN );
SpiInit( &SX1272.Spi, SPI_1, RADIO_MOSI, RADIO_MISO, RADIO_SCLK, NC );
SX1272IoInit( );
if( McuInitialized == false )
{
McuInitialized = true;
if( GetBoardPowerSource( ) == BATTERY_POWER )
{
CalibrateSystemWakeupTime( );
}
}
}
void BoardInitMcu( void )
{
if( McuInitialized == false )
{
// We use IRQ priority group 4 for the entire project
// When setting the IRQ, only the preemption priority is used
NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
// Disable Systick
SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk; // Systick IRQ off
SCB->ICSR |= SCB_ICSR_PENDSTCLR_Msk; // Clear SysTick Exception pending flag
I2cInit( &I2c, I2C_SCL, I2C_SDA );
SpiInit( &SX1272.Spi, RADIO_MOSI, RADIO_MISO, RADIO_SCLK, NC );
SX1272IoInit( );
#if defined( USE_DEBUG_PINS )
GpioInit( &DbgPin1, J5_1, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin2, J5_2, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin3, J5_3, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
GpioInit( &DbgPin4, J5_4, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0 );
#endif
BoardInitPeriph( );
#if( LOW_POWER_MODE_ENABLE )
TimerSetLowPowerEnable( true );
#else
TimerSetLowPowerEnable( false );
#endif
BoardUnusedIoInit( );
if( TimerGetLowPowerEnable( ) == true )
{
RtcInit( );
}
else
{
TimerHwInit( );
}
McuInitialized = true;
}
}
void task_fxos_rtos( task_param_t param )
{
/*! I2C channel to be used by digital 3D accelerometer */
Fxos.instance = FXOS8700CQ_I2C_INSTANCE;
I2c.I2c = &Fxos;
I2cInit(&I2c, I2C_SCL, I2C_SDA);
/* Initialize accelerometer */
FxosInit (FXOS_I2C_ADDRESS);
while (1) {
accel_sensor_data_t sensorData;
if ( FxosReadSensorData(&sensorData) != FAIL ) {
LOG_DEBUG_BARE("DATA: Accelerometer (X/Y/Z) \t%d \t%d \t%d\r\n", sensorData.accelX,
sensorData.accelY, sensorData.accelZ);
}
OSA_TimeDelay(5000);
}
}
int main(int argc, char** argv) {
PowerOn();
ClockInit();
ANSELA = 0;
ANSELB = 0;
SPLIM = 0xFFFF; // TODO: implement proper handling of SPLIM.
ModuleInit();
I2cInit();
ShellTaskInit();
App * first = MainMenuAppInit(&main_menu_app);
// Comment out the next line to skip splash.
first = SplashAppInit(&splash_app, first);
AppTaskInit(first);
vTaskStartScheduler();
}
//-----------< FUNCTION: QuopterInit >---------------------------------------
// Purpose: quopter initialization
// Parameters: none
// Returns: none
//---------------------------------------------------------------------------
void QuopterInit ()
{
// global initialization
memzero(&g_Control, sizeof(g_Control));
g_Control.nThrustInput = 0.0f;
// protocol initialization
sei();
I2cInit();
SpiInit();
// hardware initialization
PinSetOutput(PIN_D4);
PinSetHi(PIN_D4);
Tlc5940Init(
&(TLC5940_CONFIG) {
.nPinBlank = PIN_D3,
.nPinSClk = PIN_D7,
.nPinSIn = PIN_D5,
.nPinXlat = PIN_B0,
.nPinGSClk = PIN_OC0A // PIN_D6, greyscale clock
}
);
void main(void)
{
WD_STOP();
CAL_CLOCK();
// TimerAInit();
HardwareInit();
I2cInit(0x02, 0x00);
_EINT();
while (1)
{
//LPM0;
//_NOP();
if (GetWriteEndpoint(0))
SET_LOW(RED_LED);
else
SET_HIGH(RED_LED);
SetReadEndpoint(0, READ_IN(LP_SWITCH));
}
}
void BoardInitMcu( void )
{
if( McuInitialized == false )
{
/* Chip errata */
CHIP_Init();
CMU_OscillatorEnable(cmuOsc_HFXO, true, true);
CMU_ClockSelectSet(cmuClock_HF,cmuSelect_HFXO);
/* Enable clock for HF peripherals */
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_GPIO, true);
GpioInit( &Led1, LED_1, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, LED_1_ON_STATE );
GpioInit( &Led2, LED_2, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, LED_2_ON_STATE );
#ifdef USE_I2C
I2cInit( &I2c, I2C_SCL, I2C_SDA );
#endif
SX1272IoInit( );
SpiInit( &SX1272.Spi, RADIO_MOSI, RADIO_MISO, RADIO_SCLK, NC );
BoardUnusedIoInit( );
#ifdef LOW_POWER_MODE_ENABLE
#error LOW_POWER_MODE_ENABLE not supported
RtcInit( );
#else
TimerHwInit( );
#endif
Led_1_Off();
Led_2_Off();
McuInitialized = true;
}
}
zx_status_t PlatformBus::PBusRegisterProtocol(uint32_t proto_id, const void* protocol,
size_t protocol_size,
const platform_proxy_cb_t* proxy_cb) {
if (!protocol || protocol_size < sizeof(ddk::AnyProtocol)) {
return ZX_ERR_INVALID_ARGS;
}
switch (proto_id) {
case ZX_PROTOCOL_GPIO_IMPL: {
if (proxy_cb->callback != nullptr) {
return ZX_ERR_INVALID_ARGS;
}
gpio_ = ddk::GpioImplProtocolClient(static_cast<const gpio_impl_protocol_t*>(protocol));
break;
}
case ZX_PROTOCOL_I2C_IMPL: {
if (proxy_cb->callback != nullptr) {
return ZX_ERR_INVALID_ARGS;
}
auto proto = static_cast<const i2c_impl_protocol_t*>(protocol);
auto status = I2cInit(proto);
if (status != ZX_OK) {
return status;
}
i2c_ = ddk::I2cImplProtocolClient(proto);
break;
}
case ZX_PROTOCOL_CLK: {
if (proxy_cb->callback != nullptr) {
return ZX_ERR_INVALID_ARGS;
}
clk_ = ddk::ClkProtocolClient(static_cast<const clk_protocol_t*>(protocol));
break;
}
case ZX_PROTOCOL_IOMMU: {
if (proxy_cb->callback != nullptr) {
return ZX_ERR_INVALID_ARGS;
}
iommu_ = ddk::IommuProtocolClient(static_cast<const iommu_protocol_t*>(protocol));
break;
}
default: {
if (proxy_cb->callback == nullptr) {
return ZX_ERR_NOT_SUPPORTED;
}
fbl::AutoLock lock(&proto_proxys_mutex_);
if (proto_proxys_.find(proto_id).IsValid()) {
zxlogf(ERROR, "%s: protocol %08x has already been registered\n", __func__, proto_id);
return ZX_ERR_BAD_STATE;
}
fbl::AllocChecker ac;
auto proxy = fbl::make_unique_checked<ProtoProxy>(&ac, proto_id,
static_cast<const ddk::AnyProtocol*>(protocol),
*proxy_cb);
if (!ac.check()) {
return ZX_ERR_NO_MEMORY;
}
proto_proxys_.insert(std::move(proxy));
sync_completion_signal(&proto_completion_);
return ZX_OK;
}
}
fbl::AutoLock lock(&proto_completion_mutex_);
sync_completion_signal(&proto_completion_);
return ZX_OK;
}
void I2cResetBus( I2c_t *obj )
{
I2cInitialized = false;
I2cInit( obj, I2C_SCL, I2C_SDA );
}
int main( void )
{
WdtInit();
InterruptControllerInit();
EventLogInit();
GpioInit();
// Configure !RSN/NMI pin for NMI mode early
ConfigureRstNmi();
ConfigureFll();
V1( EventLogAdd( EVENTLOG_TIMER_INIT ) );
TimerInit();
WdtStartTimer();
V1( EventLogAdd( EVENTLOG_SPI_INIT ) );
SpiInit();
#if !defined( PLATFORM_RIMEVALBOARD )
HostCtrlPmicRegisterReset( RESET_LCD_IO );
#if defined( PROCESSOR_PMU430 )
//resetting the fuel gauge LDO
PmicClear( PMIC_VRTC, 1<<7 );
HwDelay(25000000); //25 ms delay
PmicSet( PMIC_VRTC, 1<<7 );
#endif
#endif
ApiInit();
#if defined( DEVID_UPDATER_SUPPORT )
CodeUpdateStateInit( );
#endif
V1( EventLogAdd( EVENTLOG_ADC_HW_INIT ) );
AdcInitHw();
V1( EventLogAdd( EVENTLOG_MSGQUE_INIT ) );
CallQueueInit();
V1( EventLogAdd( EVENTLOG_PMIC_INTCTRL_INIT ) );
PmicIntCtrlInit();
// configure charger interrupt handler
PmicRegisterIntHandler( INT_CHARGER_IRQ, ChargerHandler );
PmicInterruptEnable( INT_CHARGER_IRQ );
// enable battery insertion/removal interrupts
PmicWrite( PMIC_CHG_INT, 0x00 );
PmicClear( PMIC_CHG_INT_MASK, CHGINT_MASK_BAT );
PmicClear( PMIC_MIRQ, INT_MASK_CHARGER );
I2cInitInternalBus();
// Need to enable GIE (PoR default is OFF)
__enable_interrupt();
RegisterTimerExpiry( RTC_EXTERNAL_XTAL_TIMER, SwitchToXtal, 0 );
// switch to external xtal after 2 seconds
SetTimer( RTC_EXTERNAL_XTAL_TIMER, 0x10000 );
#if defined( PLATFORM_RIMEVALBOARD )
I2cInit();
#else
HostCtrlInit();
#endif
for (;;) {
WdtHit();
if( !ExecuteCall() ) {
// if there was nothing to call, enter sleep mode
SCSleep();
}
}
}
void LCD_ZTOLED::begin()
{
I2cInit();
ScI2cMxReset(OLED_ADDRESS);
clear();
}
uint8_t I2cWrite( uint8_t deviceAddr, uint8_t data )
{
__IO int32_t i;
uint32_t timeOut;
I2cFsmcClkEnable( false );
/* Test on BUSY Flag */
timeOut = TIMEOUT_MAX;
while( I2C_GetFlagStatus( I2C_INTERFACE, I2C_FLAG_BUSY) )
{
if( ( timeOut-- ) == 0 )
{
I2cInit( );
I2cFsmcClkEnable( true );
return( SX_TIMEOUT );
}
}
/* Send START condition */
I2C_GenerateSTART( I2C_INTERFACE, ENABLE );
/* Test on EV5 and clear it */
timeOut = TIMEOUT_MAX;
while( !I2C_CheckEvent( I2C_INTERFACE, I2C_EVENT_MASTER_MODE_SELECT ) )
{
if( I2C_INTERFACE->SR1 & I2C_FLAG_RXNE )
{
volatile uint32_t drTemp;
drTemp = I2C_INTERFACE->DR;
}
if( ( timeOut-- ) == 0 )
{
I2cInit( );
I2cFsmcClkEnable( true );
return( SX_TIMEOUT );
}
}
/* Send device's address for write */
I2C_Send7bitAddress( I2C_INTERFACE, deviceAddr, I2C_Direction_Transmitter );
/* Test on EV6 and clear it */
timeOut = TIMEOUT_MAX;
while( !I2C_CheckEvent( I2C_INTERFACE, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED ) )
{
if( ( timeOut-- ) == 0 )
{
I2cInit( );
I2cFsmcClkEnable( true );
return( SX_TIMEOUT );
}
}
I2C_SendData( I2C_INTERFACE, data );
/* Test on EV8 and clear it */
timeOut = TIMEOUT_MAX;
while( !I2C_CheckEvent( I2C_INTERFACE, I2C_EVENT_MASTER_BYTE_TRANSMITTED ) )
{
if( ( timeOut-- ) == 0 )
{
I2cInit( );
I2cFsmcClkEnable( true );
return( SX_TIMEOUT );
}
}
I2C_GenerateSTOP( I2C_INTERFACE, ENABLE );
for( i = 0 ; i < 500 ; i++ ){ ; }
I2cFsmcClkEnable( true );
return( SX_OK );
}
uint8_t I2cWriteBuffer( uint8_t deviceAddr, uint16_t addr, uint8_t *buffer, uint16_t size, tI2cAddrSize addrSize )
{
__IO int32_t i;
uint32_t timeOut;
I2cFsmcClkEnable( false );
/* Test on BUSY Flag */
timeOut = TIMEOUT_MAX;
while( I2C_GetFlagStatus( I2C_INTERFACE, I2C_FLAG_BUSY) )
{
if( ( timeOut-- ) == 0 )
{
I2cInit( );
I2cFsmcClkEnable( true );
return( SX_TIMEOUT );
}
}
/* Send START condition */
I2C_GenerateSTART( I2C_INTERFACE, ENABLE );
/* Test on EV5 and clear it */
timeOut = TIMEOUT_MAX;
while( !I2C_CheckEvent( I2C_INTERFACE, I2C_EVENT_MASTER_MODE_SELECT ) )
{
if( I2C_INTERFACE->SR1 & I2C_FLAG_RXNE )
{
volatile uint32_t drTemp;
drTemp = I2C_INTERFACE->DR;
}
if( ( timeOut-- ) == 0 )
{
I2cInit( );
I2cFsmcClkEnable( true );
return( SX_TIMEOUT );
}
}
/* Send device's address for write */
I2C_Send7bitAddress( I2C_INTERFACE, deviceAddr, I2C_Direction_Transmitter );
/* Test on EV6 and clear it */
timeOut = TIMEOUT_MAX;
while( !I2C_CheckEvent( I2C_INTERFACE, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED ) )
{
if( ( timeOut-- ) == 0 )
{
I2cInit( );
I2cFsmcClkEnable( true );
return( SX_TIMEOUT );
}
}
if( addrSize == I2C_ADDR_SIZE_16 )
{
/* Send the device's internal address MSB to write to */
I2C_SendData( I2C_INTERFACE, ( uint8_t )( ( addr & 0xFF00 ) >> 8 ) );
/* Test on EV8 and clear it */
timeOut = TIMEOUT_MAX;
while( !I2C_CheckEvent( I2C_INTERFACE, I2C_EVENT_MASTER_BYTE_TRANSMITTED ) )
{
if( ( timeOut-- ) == 0 )
{
I2cInit( );
I2cFsmcClkEnable( true );
return( SX_TIMEOUT );
}
}
}
uint8_t I2cRead( uint8_t deviceAddr, uint8_t *data )
{
__IO int32_t i;
int32_t size = 1;
uint32_t timeOut;
I2cFsmcClkEnable( false );
/* Test on BUSY Flag */
timeOut = TIMEOUT_MAX;
while( I2C_GetFlagStatus( I2C_INTERFACE, I2C_FLAG_BUSY) )
{
if( ( timeOut-- ) == 0 )
{
I2cInit( );
I2cFsmcClkEnable( true );
return( SX_TIMEOUT );
}
}
/* Send START condition a second time */
I2C_GenerateSTART( I2C_INTERFACE, ENABLE );
/* Test on EV5 and clear it */
timeOut = TIMEOUT_MAX;
while( !I2C_CheckEvent( I2C_INTERFACE, I2C_EVENT_MASTER_MODE_SELECT ) )
{
if( ( timeOut-- ) == 0 )
{
I2cInit( );
I2cFsmcClkEnable( true );
return( SX_TIMEOUT );
}
}
/* Send device's address for read */
I2C_Send7bitAddress( I2C_INTERFACE, deviceAddr, I2C_Direction_Receiver );
/* Test on EV6 and clear it */
timeOut = TIMEOUT_MAX;
while( !I2C_CheckEvent( I2C_INTERFACE, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED ) )
{
if( ( timeOut-- ) == 0 )
{
I2cInit( );
I2cFsmcClkEnable( true );
return( SX_TIMEOUT );
}
}
/* While there is data to be read */
while( size )
{
if( size == 1 )
{
/* Disable Acknowledgement */
I2C_AcknowledgeConfig( I2C_INTERFACE, DISABLE );
/* Send STOP Condition */
I2C_GenerateSTOP( I2C_INTERFACE, ENABLE );
}
/* Test on EV7 and clear it */
timeOut = TIMEOUT_MAX;
if( I2C_CheckEvent( I2C_INTERFACE, I2C_EVENT_MASTER_BYTE_RECEIVED ) )
{
/* Read a byte from the device */
*data = I2C_ReceiveData( I2C_INTERFACE );
/* Decrement the read bytes counter */
size--;
}
else
{
if( ( timeOut-- ) == 0 )
{
I2cInit( );
I2cFsmcClkEnable( true );
return( SX_TIMEOUT );
}
}
}
/* Enable Acknowledgement to be ready for another reception */
I2C_AcknowledgeConfig( I2C_INTERFACE, ENABLE );
for( i = 0 ; i < 500 ; i++ ){ ; }
I2cFsmcClkEnable( true );
return( SX_OK );
}
