/**
* @brief Main routine for DAC example
* @return Nothing
*/
int main(void)
{
bool end_Flag = false;
uint8_t bufferUART;
Board_Init();
Board_DAC_Init(LPC_DAC);
/* DAC Init */
Chip_DAC_Init(LPC_DAC);
/* set time out for DAC*/
Chip_DAC_SetDMATimeOut(LPC_DAC, 0xFFFF);
Chip_DAC_ConfigDAConverterControl(LPC_DAC, (DAC_CNT_ENA | DAC_DMA_ENA));
while (!end_Flag) {
DEBUGOUT(WelcomeMenu);
while (!end_Flag) {
bufferUART = 0xFF;
bufferUART = DEBUGIN();
if (bufferUART == 'c') {
DEBUGOUT(SelectMenu);
bufferUART = 0xFF;
while (bufferUART == 0xFF) {
bufferUART = DEBUGIN();
if ((bufferUART != '1') && (bufferUART != '2') && (bufferUART != '3')) {
bufferUART = 0xFF;
}
}
switch (bufferUART) {
case '1': /* Polling Mode */
App_Polling_Test();
break;
case '2': /* Interrupt Mode */
App_Interrupt_Test();
break;
case '3': /* DMA mode */
App_DMA_Test();
break;
}
break;
}
else if (bufferUART == 'x') {
end_Flag = true;
DEBUGOUT("\r\nDAC demo terminated!");
}
}
}
return 0;
}
/* The main menu of the example. Allow user select the SSP mode (master or slave) and Transfer
mode (Polling, Interrupt or DMA) */
static void appSSPMainMenu(void)
{
int key;
DEBUGOUT(helloMenu);
DEBUGOUT(sspMenu);
DEBUGOUT(sspMainMenu);
while (1) {
key = 0xFF;
do {
key = DEBUGIN();
} while ((key & 0xFF) == 0xFF);
switch (key) {
case SSP_MODE_SEL: /* Select SSP Mode */
appSSPSelectModeMenu();
break;
case SSP_TRANSFER_MODE_SEL: /* Select Transfer Mode */
appSSPTest();
break;
default:
break;
}
DEBUGOUT(sspMainMenu);
}
}
/* Polling routine for ADC example */
static void App_Polling_Test(void)
{
uint16_t dataADC;
/* Select using burst mode or not */
if (Burst_Mode_Flag) {
Chip_ADC_SetBurstCmd(_LPC_ADC_ID, ENABLE);
}
else {
Chip_ADC_SetBurstCmd(_LPC_ADC_ID, DISABLE);
}
/* Get adc value until get 'x' character */
while (DEBUGIN() != 'x') {
/* Start A/D conversion if not using burst mode */
if (!Burst_Mode_Flag) {
Chip_ADC_SetStartMode(_LPC_ADC_ID, ADC_START_NOW, ADC_TRIGGERMODE_RISING);
}
/* Waiting for A/D conversion complete */
while (Chip_ADC_ReadStatus(_LPC_ADC_ID, _ADC_CHANNLE, ADC_DR_DONE_STAT) != SET) {}
/* Read ADC value */
Chip_ADC_ReadValue(_LPC_ADC_ID, _ADC_CHANNLE, &dataADC);
/* Print ADC value */
App_print_ADC_value(dataADC);
}
/* Disable burst mode, if any */
if (Burst_Mode_Flag) {
Chip_ADC_SetBurstCmd(_LPC_ADC_ID, DISABLE);
}
}
/* Select the SSP mode : Master or Slave */
static void appSSPSelectModeMenu(void)
{
int key;
DEBUGOUT(sspSelectModeMenu);
while (1) {
key = 0xFF;
do {
key = DEBUGIN();
} while ((key & 0xFF) == 0xFF);
switch (key) {
case SSP_MASTER_MODE_SEL: /* Master */
Chip_SSP_SetMaster(LPC_SSP, 1);
DEBUGOUT("Master Mode\n\r");
return;
case SSP_SLAVE_MODE_SEL: /* Slave */
Chip_SSP_SetMaster(LPC_SSP, 0);
DEBUGOUT("Slave Mode\n\r");
return;
case 'q':
return;
default:
break;
}
DEBUGOUT(sspSelectModeMenu);
}
}
/*****************************************************************************
* Private functions
****************************************************************************/
static void PMC_Get_Wakeup_option(uint8_t *Wakeup_rtc)
{
FlagStatus exitflag;
uint8_t buffer = 0xFF;
DEBUGOUT(menu1);
exitflag = RESET;
while (exitflag == RESET) {
/* Get user input */
buffer = DEBUGIN();
if ((buffer == 'W') || (buffer == 'w')) {
DEBUGOUT("WAKEUP0 pin selected \r\n");
*Wakeup_rtc = 0;
exitflag = SET;
}
if ((buffer == 'R') || (buffer == 'r')) {
DEBUGOUT("RTC Alarm selected \r\n");
*Wakeup_rtc = 1;
exitflag = SET;
}
}
}
/**
* @brief DAC interrupt handler sub-routine
* @return Nothing
*/
void DAC_IRQHandler(void)
{
NVIC_DisableIRQ(DAC_IRQn);
DAC_Interrupt_Done_Flag = 1;
if (DEBUGIN() == 'x') {
Interrupt_Continue_Flag = 0;
}
}
/* Get a string to save from the UART */
static uint32_t MakeString(uint8_t *str)
{
int index, byte;
char strOut[2];
/* Get a string up to 32 bytes to write into Flash */
DEBUGSTR("\r\nEnter a string to write into Flash\r\n");
DEBUGSTR("Up to 32 bytes in length, press ESC to accept\r\n");
/* Setup header */
strncpy((char *) str, CHKTAG, CHKTAG_SIZE);
/* Read until escape, but cap at 32 characters */
index = 0;
strOut[1] = '\0';
#if defined(DEBUG_ENABLE)
byte = DEBUGIN();
while ((index < 32) && (byte != ESC_CHAR)) {
if (byte != EOF) {
strOut[0] = str[4 + index] = (uint8_t) byte;
DEBUGSTR(strOut);
index++;
}
byte = DEBUGIN();
}
#else
/* Suppress warnings */
(void) byte;
(void) strOut;
/* Debug input not enabled, so use a pre-setup string */
strncpy((char *) &str[4], "12345678", 8);
index = 8;
#endif
str[3] = (uint8_t) index;
return (uint32_t) index;
}
/**
* @brief ADC0 interrupt handler sub-routine
* @return Nothing
*/
void ADC_IRQHandler(void)
{
uint16_t dataADC;
/* Interrupt mode: Call the stream interrupt handler */
NVIC_DisableIRQ(_LPC_ADC_IRQ);
Chip_ADC_Int_SetChannelCmd(_LPC_ADC_ID, _ADC_CHANNLE, DISABLE);
Chip_ADC_ReadValue(_LPC_ADC_ID, _ADC_CHANNLE, &dataADC);
ADC_Interrupt_Done_Flag = 1;
App_print_ADC_value(dataADC);
if (DEBUGIN() != 'x') {
NVIC_EnableIRQ(_LPC_ADC_IRQ);
Chip_ADC_Int_SetChannelCmd(_LPC_ADC_ID, _ADC_CHANNLE, ENABLE);
}
else {Interrupt_Continue_Flag = 0; }
}
/* DMA routine for ADC example */
static void App_DMA_Test(void)
{
uint16_t dataADC;
/* Initialize GPDMA controller */
Chip_GPDMA_Init(LPC_GPDMA);
/* Setting GPDMA interrupt */
NVIC_DisableIRQ(DMA_IRQn);
NVIC_SetPriority(DMA_IRQn, ((0x01 << 3) | 0x01));
NVIC_EnableIRQ(DMA_IRQn);
/* Setting ADC interrupt, ADC Interrupt must be disable in DMA mode */
NVIC_DisableIRQ(_LPC_ADC_IRQ);
Chip_ADC_Int_SetChannelCmd(_LPC_ADC_ID, _ADC_CHANNLE, ENABLE);
/* Get the free channel for DMA transfer */
dmaChannelNum = Chip_GPDMA_GetFreeChannel(LPC_GPDMA, _GPDMA_CONN_ADC);
/* Enable burst mode if any, the AD converter does repeated conversions
at the rate selected by the CLKS field in burst mode automatically */
if (Burst_Mode_Flag) {
Chip_ADC_SetBurstCmd(_LPC_ADC_ID, ENABLE);
}
/* Get adc value until get 'x' character */
while (DEBUGIN() != 'x') {
/* Start A/D conversion if not using burst mode */
if (!Burst_Mode_Flag) {
Chip_ADC_SetStartMode(_LPC_ADC_ID, ADC_START_NOW, ADC_TRIGGERMODE_RISING);
}
channelTC = 0;
Chip_GPDMA_Transfer(LPC_GPDMA, dmaChannelNum,
_GPDMA_CONN_ADC,
(uint32_t) &DMAbuffer,
GPDMA_TRANSFERTYPE_P2M_CONTROLLER_DMA,
1);
/* Waiting for reading ADC value completed */
while (channelTC == 0) {}
/* Get the ADC value fron Data register*/
dataADC = ADC_DR_RESULT(DMAbuffer);
App_print_ADC_value(dataADC);
}
/* Disable interrupts, release DMA channel */
Chip_GPDMA_Stop(LPC_GPDMA, dmaChannelNum);
NVIC_DisableIRQ(DMA_IRQn);
/* Disable burst mode if any */
if (Burst_Mode_Flag) {
Chip_ADC_SetBurstCmd(_LPC_ADC_ID, DISABLE);
}
}
/* Polling routine for DAC example */
static void App_Polling_Test(void)
{
uint32_t tmp = 0;
volatile uint32_t i = 0;
while (DEBUGIN() != 'x') {
tmp++;
if (tmp == (DATA_SIZE - 1)) {
tmp = 0;
}
Chip_DAC_UpdateValue(LPC_DAC, tmp);
while (!(Chip_DAC_GetIntStatus(LPC_DAC))) {}
for (i = 0; i < 0x10000; i++) ;
}
}
/* DMA routine for DAC example */
static void App_DMA_Test(void)
{
uint32_t tmp = 0;
volatile uint32_t i = 0;
/* Initialize GPDMA controller */
Chip_GPDMA_Init(LPC_GPDMA);
/* Setting GPDMA interrupt */
NVIC_DisableIRQ(DMA_IRQn);
NVIC_SetPriority(DMA_IRQn, ((0x01 << 3) | 0x01));
NVIC_EnableIRQ(DMA_IRQn);
/* Get the free channel for DMA transfer */
dmaChannelNum = Chip_DMA_GetFreeChannel(LPC_GPDMA, GPDMA_CONN_DAC);
/* Output DAC value until get 'x' character */
while (DEBUGIN() != 'x') {
/* Start D/A conversion */
tmp++;
if (tmp == (DATA_SIZE - 1)) {
tmp = 0;
}
/* pre-format the data to DACR register */
DMAbuffer = (uint32_t) (DAC_VALUE(tmp) | DAC_BIAS_EN);
for (i = 0; i < 0x10000; i++) ;
channelTC = 0;
Chip_DMA_Transfer(LPC_GPDMA, dmaChannelNum,
(uint32_t) &DMAbuffer,
GPDMA_CONN_DAC,
GPDMA_TRANSFERTYPE_M2P_CONTROLLER_DMA,
1);
/* Waiting for writing DAC value completed */
while (channelTC == 0) {}
}
/* Disable interrupts, release DMA channel */
Chip_DMA_Stop(LPC_GPDMA, dmaChannelNum);
NVIC_DisableIRQ(DMA_IRQn);
}
TransactionState::~TransactionState()
{
DEBUGIN();
}
/**
* @brief Main entry point
* @return Nothing
*/
int main(void)
{
FlagStatus exitflag;
uint8_t buffer = 0xFF;
uint8_t Wake_RTC = 0;
Board_Init();
/* Initialize the Event Router */
Chip_EVRT_Init();
/* Print user menu on UART console */
DEBUGOUT(menu);
exitflag = RESET;
/* Read user option from UART prompt */
while (exitflag == RESET) {
/* Get user input */
buffer = DEBUGIN();
switch (buffer) {
case '1': /* Sleep/Wake up Mode */
DEBUGOUT("'Sleep' state test selected \r\n");
PMC_Get_Wakeup_option(&Wake_RTC);
PMC_PwrState_Handler(buffer, Wake_RTC);
DEBUGOUT(menu);
break;
case '2': /* Deep sleep/Wakeup Mode */
DEBUGOUT("'Deep Sleep' state test selected \r\n");
PMC_Get_Wakeup_option(&Wake_RTC);
PMC_PwrState_Handler(buffer, Wake_RTC);
DEBUGOUT(menu);
break;
case '3': /* Power Down/Wakeup Mode */
DEBUGOUT("'Power Down' state test selected \r\n");
PMC_Get_Wakeup_option(&Wake_RTC);
PMC_PwrState_Handler(buffer, Wake_RTC);
DEBUGOUT(menu);
break;
case '4': /* Deep Power Down/Wakeup Mode */
DEBUGOUT("'Deep Power Down' state test selected \r\n");
PMC_Get_Wakeup_option(&Wake_RTC);
PMC_PwrState_Handler(buffer, Wake_RTC);
DEBUGOUT(menu);
break;
case 'X':
DEBUGOUT(menu2);
exitflag = SET;
break;
case 'x':
DEBUGOUT(menu2);
exitflag = SET;
break;
}
}
while (1) {}
}
/**
* Power State handler function
*/
static void PMC_PwrState_Handler(uint8_t buffer, uint8_t Wake_RTC)
{
CHIP_EVRT_SRC_T Evrt_Src;
CHIP_PMC_PWR_STATE_T Pwr_state;
uint8_t confirm = 0xFF;
if (Wake_RTC) {
/* Configure EVRT_SRC_RTC as wake up signal */
Evrt_Src = EVRT_SRC_RTC;
/* Disable interrupt signal from Evrt_Src pin to EVRT */
Chip_EVRT_SetUpIntSrc(Evrt_Src, DISABLE);
/* Initialize and configure RTC */
Chip_RTC_Init(LPC_RTC);
Chip_RTC_ResetClockTickCounter(LPC_RTC);
Chip_RTC_SetTime(LPC_RTC, RTC_TIMETYPE_SECOND, 0);
/* Set alarm time = RTC_ALARM_TIME seconds.
* So after each RTC_ALARM_TIME seconds, RTC will generate and wake-up system
*/
Chip_RTC_SetAlarmTime(LPC_RTC, RTC_TIMETYPE_SECOND, RTC_ALARM_TIME);
Chip_RTC_CntIncrIntConfig(LPC_RTC, RTC_AMR_CIIR_IMSEC, DISABLE);
/* Set the AMR for RTC_ALARM_TIME match alarm interrupt */
Chip_RTC_AlarmIntConfig(LPC_RTC, RTC_AMR_CIIR_IMSEC, ENABLE);
Chip_RTC_ClearIntPending(LPC_RTC, RTC_INT_ALARM);
}
else {
Evrt_Src = EVRT_SRC_WAKEUP0;
}
/* Configure wake up signal */
PMC_Evrt_Configure(Evrt_Src);
/* Get confirmation from user to continue
* Print wake up signal information to user
*/
DEBUGOUT(menu3);
while ( (confirm != 'C') && (confirm != 'c')) {
confirm = DEBUGIN();
}
switch (buffer) {
case '1':
DEBUGOUT("Entering 'Sleep' state ...\r\n");
if (Wake_RTC) {
DEBUGOUT("Wait for %d seconds, RTC alarm will wake up from 'Sleep' mode \r\n", RTC_ALARM_TIME);
Chip_RTC_Enable(LPC_RTC, ENABLE);
}
else {
DEBUGOUT("Press WAKEUP0 button/Connect WAKEUP0 pin to 3.3V to exit 'Sleep' mode \r\n");
}
Chip_PMC_Sleep();
Chip_RTC_DeInit(LPC_RTC);
DEBUGOUT("Woken up \r\n");
break;
case '2':
DEBUGOUT("Entering 'Deep Sleep' state ...\r\n");
if (Wake_RTC) {
DEBUGOUT("Wait for %d seconds, RTC alarm will wake up from 'Deep Sleep' mode \r\n", RTC_ALARM_TIME);
Chip_RTC_Enable(LPC_RTC, ENABLE);
}
else {
DEBUGOUT("Press WAKEUP0 button/Connect WAKEUP0 pin to 3.3V to exit 'Deep Sleep' mode \r\n");
}
Pwr_state = PMC_DeepSleep;
/* Call Pre SleepPowerDown function */
PMC_Pre_SleepPowerDown();
/* Goto Deep Sleep mode */
Chip_PMC_Set_PwrState(Pwr_state);
/* Call Post Wake up Initialisation function */
PMC_Post_Wakeup(buffer);
DEBUGOUT("\r\nWoken up \r\n");
break;
case '3':
DEBUGOUT("Entering 'Power Down' state ...\r\n");
if (Wake_RTC) {
DEBUGOUT("Wait for %d seconds, RTC alarm will wake up from 'Power Down' mode \r\n", RTC_ALARM_TIME);
Chip_RTC_Enable(LPC_RTC, ENABLE);
}
else {
DEBUGOUT("Press WAKEUP0 button/Connect WAKEUP0 pin to 3.3V to exit 'Power Down' mode \r\n");
}
Pwr_state = PMC_PowerDown;
/* Call Pre SleepPowerDown function */
PMC_Pre_SleepPowerDown();
/* Goto Deep Sleep mode */
Chip_PMC_Set_PwrState(Pwr_state);
/* Call Post Wake up Initialisation function */
PMC_Post_Wakeup(buffer);
DEBUGOUT("\r\nWoken up \r\n");
break;
case '4':
DEBUGOUT("Entering 'Deep Power Down' state ...\r\n");
if (Wake_RTC) {
DEBUGOUT("Wait for %d seconds, RTC alarm will wake up from 'Deep Power Down' mode \r\n", RTC_ALARM_TIME);
Chip_RTC_Enable(LPC_RTC, ENABLE);
}
else {
DEBUGOUT("Press WAKEUP0 button/Connect WAKEUP0 pin to 3.3V to exit 'Deep Power Down' mode \r\n");
}
Pwr_state = PMC_DeepPowerDown;
/* Call Pre SleepPowerDown function */
PMC_Pre_SleepPowerDown();
/* Goto Deep Sleep mode */
Chip_PMC_Set_PwrState(Pwr_state);
/* Wake up from Deep power down state is as good as RESET */
while (1) {}
break;
default:
break;
}
}
/**
* @brief Main routine for ADC example
* @return Nothing
*/
int main(void)
{
bool end_Flag = false;
uint32_t _bitRate = ADC_MAX_SAMPLE_RATE;
uint8_t bufferUART;
SystemCoreClockUpdate();
Board_Init();
/* Chip_IOCON_PinMux(0, 25, IOCON_ADMODE_EN, IOCON_FUNC1); */
/*ADC Init */
Chip_ADC_Init(_LPC_ADC_ID, &ADCSetup);
Chip_ADC_EnableChannel(_LPC_ADC_ID, _ADC_CHANNLE, ENABLE);
while (!end_Flag) {
DEBUGOUT(WelcomeMenu);
while (!end_Flag) {
bufferUART = 0xFF;
bufferUART = DEBUGIN();
if (bufferUART == 'c') {
DEBUGOUT(SelectMenu);
bufferUART = 0xFF;
while (bufferUART == 0xFF) {
bufferUART = DEBUGIN();
if ((bufferUART != '1') && (bufferUART != '2') && (bufferUART != '3')) {
bufferUART = 0xFF;
}
}
switch (bufferUART) {
case '1': /* Polling Mode */
App_Polling_Test();
break;
case '2': /* Interrupt Mode */
App_Interrupt_Test();
break;
case '3': /* DMA mode */
App_DMA_Test();
break;
}
break;
}
else if (bufferUART == 'x') {
end_Flag = true;
DEBUGOUT("\r\nADC demo terminated!");
}
else if (bufferUART == 'o') {
_bitRate -= _bitRate > 0 ? 1000 : 0;
Chip_ADC_SetSampleRate(_LPC_ADC_ID, &ADCSetup, _bitRate);
DEBUGOUT("Rate : %ld Sample/s\r\n", _bitRate);
}
else if (bufferUART == 'p') {
_bitRate += _bitRate < 400000 ? 1000 : 0;
Chip_ADC_SetSampleRate(_LPC_ADC_ID, &ADCSetup, _bitRate);
DEBUGOUT("Rate : %ld Sample/s\r\n", _bitRate);
}
else if (bufferUART == 'b') {
Burst_Mode_Flag = !Burst_Mode_Flag;
ADCSetup.burstMode = Burst_Mode_Flag;
Chip_ADC_SetSampleRate(_LPC_ADC_ID, &ADCSetup, _bitRate);
if (Burst_Mode_Flag) {
DEBUGOUT("Burst Mode ENABLED\r\n");
}
else {
DEBUGOUT("Burst Mode DISABLED\r\n");
}
}
}
}
return 0;
}
/* Select the Transfer mode : Polling, Interrupt or DMA */
static void appSSPTest(void)
{
int key;
DEBUGOUT(sspTransferModeSel);
dmaChSSPTx = Chip_GPDMA_GetFreeChannel(LPC_GPDMA, LPC_GPDMA_SSP_TX);
dmaChSSPRx = Chip_GPDMA_GetFreeChannel(LPC_GPDMA, LPC_GPDMA_SSP_RX);
xf_setup.length = BUFFER_SIZE;
xf_setup.tx_data = Tx_Buf;
xf_setup.rx_data = Rx_Buf;
while (1) {
key = 0xFF;
do {
key = DEBUGIN();
} while ((key & 0xFF) == 0xFF);
Buffer_Init();
switch (key) {
case SSP_POLLING_SEL: /* SSP Polling Read Write Mode */
DEBUGOUT(sspWaitingMenu);
xf_setup.rx_cnt = xf_setup.tx_cnt = 0;
Chip_SSP_RWFrames_Blocking(LPC_SSP, &xf_setup);
if (Buffer_Verify() == 0) {
DEBUGOUT(sspPassedMenu);
}
else {
DEBUGOUT(sspFailedMenu);
}
break;
case SSP_INTERRUPT_SEL:
DEBUGOUT(sspIntWaitingMenu);
isXferCompleted = 0;
xf_setup.rx_cnt = xf_setup.tx_cnt = 0;
Chip_SSP_Int_FlushData(LPC_SSP);/* flush dummy data from SSP FiFO */
if (SSP_DATA_BYTES(ssp_format.bits) == 1) {
Chip_SSP_Int_RWFrames8Bits(LPC_SSP, &xf_setup);
}
else {
Chip_SSP_Int_RWFrames16Bits(LPC_SSP, &xf_setup);
}
Chip_SSP_Int_Enable(LPC_SSP); /* enable interrupt */
while (!isXferCompleted) {}
if (Buffer_Verify() == 0) {
DEBUGOUT(sspPassedMenu);
}
else {
DEBUGOUT(sspFailedMenu);
}
break;
case SSP_DMA_SEL: /* SSP DMA Read and Write: fixed on 8bits */
DEBUGOUT(sspDMAWaitingMenu);
isDmaTxfCompleted = isDmaRxfCompleted = 0;
Chip_SSP_DMA_Enable(LPC_SSP);
/* data Tx_Buf --> SSP */
Chip_GPDMA_Transfer(LPC_GPDMA, dmaChSSPTx,
(uint32_t) &Tx_Buf[0],
LPC_GPDMA_SSP_TX,
GPDMA_TRANSFERTYPE_M2P_CONTROLLER_DMA,
BUFFER_SIZE);
/* data SSP --> Rx_Buf */
Chip_GPDMA_Transfer(LPC_GPDMA, dmaChSSPRx,
LPC_GPDMA_SSP_RX,
(uint32_t) &Rx_Buf[0],
GPDMA_TRANSFERTYPE_P2M_CONTROLLER_DMA,
BUFFER_SIZE);
while (!isDmaTxfCompleted || !isDmaRxfCompleted) {}
if (Buffer_Verify() == 0) {
DEBUGOUT(sspPassedMenu);
}
else {
DEBUGOUT(sspFailedMenu);
}
Chip_SSP_DMA_Disable(LPC_SSP);
break;
case 'q':
case 'Q':
Chip_GPDMA_Stop(LPC_GPDMA, dmaChSSPTx);
Chip_GPDMA_Stop(LPC_GPDMA, dmaChSSPRx);
return;
default:
break;
}
DEBUGOUT(sspTransferModeSel);
}
}
/* Get an integer input from UART */
static int con_get_input(const char *str)
{
#ifdef DEBUG_ENABLE
int input_valid = 0;
int x;
char ch[16], *ptr;
int i = 0;
while (!input_valid) {
DEBUGOUT("%s", str);
while (1) {
/* Setting poll mode for slave is a very bad idea, it works nevertheless */
if ((mode_poll & (1 << i2cDev)) && Chip_I2C_IsStateChanged(i2cDev)) {
Chip_I2C_SlaveStateHandler(i2cDev);
}
x = DEBUGIN();
if (x == EOF) {
continue;
}
if (i >= sizeof(ch) - 2) {
break;
}
if (((x == '\r') || (x == '\n')) && i) {
DEBUGOUT("\r\n");
break;
}
if (x == '\b') {
if (i) {
DEBUGOUT("\033[1D \033[1D");
i--;
}
continue;
}
DEBUGOUT("%c", x);
ch[i++] = x;
}
ch[i] = 0;
i = strtol(ch, &ptr, 0);
if (*ptr) {
i = 0;
DEBUGOUT("Invalid input. Retry!\r\n");
continue;
}
input_valid = 1;
}
return i;
#else
static int sind = -1;
static uint8_t val[] = {5, I2C_SLAVE_IOX_ADDR, 1, 0};
if (sind >= sizeof(val)) {
sind = -1;
}
while (sind < 0 && (tick_cnt & 0x7F)) {}
if (sind < 0) {
sind = 0;
val[3] = !val[3];
tick_cnt++;
}
return val[sind++];
#endif
}
TransactionState::TransactionState(const string &name) : name(name), branch(""),
client(false), cseq(0), cseqMethod(""), lastReceivedMessage(""),
lastResponseCode(0), transactionResponseHash(0), ackIndex(0)
{
DEBUGIN();
}