ADS122U04: ADS122U04 Communication and Device Setup

Thank you for your inputs.

As you suggested, I did the following:-

a) After Microcontroller powerup [and initialization of UART1 (for communication with    

    ADS122U04) and UART5 (for sending out values to PC for debug purpose)], I just sent out the 

    RESET command to  ADS122U04 and after that allowed a delay (in firmware) of 1 Second.

b) After this I read the values of Config Reg 0 to Config Reg 4, one-after-another. 

    What is observed is that, other than ' Config Reg 3' all other config Regs contain 

    default (Reset)  values, but  ' Config Reg 3'  value keeps varying (as seen in it's value output  

    on UART5 every 1.5second). As seen in the screencap attached, the  value of ' Config Reg 3'

    is most of the time "0x02" or "0x03". I don't understand why this should happen as the code 

    section in firmware for reading the values of these Regs is exactly identical.     

The values of Config Reg that I set in actual code (not above test code) are as follows:-

/*Commands for Writing to the 'Configuration Registers' of ADC ADS122U04 IC*/
uint8_t CMD_WRITE_CONFIGREG_ZERO_ADC_PT100[3]  = {0x55,0x40,0x35}; //PGA enabled,Gain=16,AIN0 and AIN1 as differential analog inputs
uint8_t CMD_WRITE_CONFIGREG_ONE_ADC_PT100[3]   = {0x55,0x42,0x0A};//Internal 2.048vdc as ref.,Continuous conv.,Normal mode,Data Rate 20SPS
uint8_t CMD_WRITE_CONFIGREG_TWO_ADC_PT100[3]   = {0x55,0x44,0x05};//Data counter disabled,IDAC1=500uA,Data integrity check disabled
uint8_t CMD_WRITE_CONFIGREG_THREE_ADC_PT100[3] = {0x55,0x48,0x80};//Manual data read mode,IDAC2 disabled, IDAC1 connected to AIN3
uint8_t CMD_WRITE_CONFIGREG_FOUR_ADC_PT100[3]  = {0x55,0x4A,0x00};//GPIO2 configured as input which is default setting

Attached are the '.c' files containing ADC related functions and main() function for your reference.

/*---------------------------------------------------------------------------------
* PT100_SensorRead.c
*
* Created on: 19-Jun-2020
* Author: Milind Risbud
---------------------------------------------------------------------------------*/

//---------------------------------------------------------------------------------
#include "r_cg_macrodriver.h"

//---------------------------------------------------------------------------------
//Note:
//[1] UART of uC needs to be configured as follows for communication with ADC ADS122U04 IC
// Data bits=8
// Parity=NONE
// Stop Bits=1
//[2] ADC IC ADS122U04 has a universal asynchronous receiver transmitter (UART)compatible interface-
// for command and data transfer between the uC and ADS122U04 IC.
// The interface is half-duplex, meaning only either the uC or the ADS122U04 can communicate at any given time.
// The ADS122U04 actively synchronizes to the baud rate of the uC using the Synchronization Byte (0x55) that-
// has to be sent by uC prior to each and every Command. Thus, this 'baud rate Synchronization' happens every time-
// a command is sent by uC to ADS122U04 IC.
// Output data from ADS122U04 IC can be register contents or conversion results.
//[3] Here the ADC IC is configured to work in "CONTINUOUS CONVERSION" mode and-
// the A/D converted data output mode of the ADC IC is configured to be "MANUAL DATA READ" mode-
// which is it's default mode (instead of Automatic data read mode).
//---------------------------------------------------------------------------------
//Constants Declaration
#define PT100_ADC_RECBUFFLEN_MAX 6
#define ADC_CONFIG_READBACK_MAXLEN 10
//NOTE:- Value "0x55" hex is the "Synchronization Byte" needed to be sent before every command to ADC ADS122U04 IC.
// That is the reason why this value "0x55" hex is seen as the very first byte of each of the command array.
//Stand-alone commands (i.e. instructions) to ADC ADS122U04 IC
uint8_t CMD_RESET_ADC_PT100[2] = {0x55,0x06};
uint8_t CMD_STARTSYNC_ADC_PT100[2] = {0x55,0x09};
uint8_t CMD_POWERDOWN_ADC_PT100[2] = {0x55,0x02};
uint8_t CMD_READDATA_ADC_PT100[2] = {0x55,0x1C};

//Commands for Reading the 'Configuration Registers' of ADC ADS122U04 IC
uint8_t CMD_READ_CONFIGREG_ZERO_ADC_PT100[2] = {0x55,0x20};
uint8_t CMD_READ_CONFIGREG_ONE_ADC_PT100[2] = {0x55,0x22};
uint8_t CMD_READ_CONFIGREG_TWO_ADC_PT100[2] = {0x55,0x24};
uint8_t CMD_READ_CONFIGREG_THREE_ADC_PT100[2] = {0x55,0x28};
uint8_t CMD_READ_CONFIGREG_FOUR_ADC_PT100[2] = {0x55,0x2A};

//Commands for Writing to the 'Configuration Registers' of ADC ADS122U04 IC
uint8_t CMD_WRITE_CONFIGREG_ZERO_ADC_PT100[3] = {0x55,0x40,0x35}; //PGA enabled,Gain=16,AIN0 and AIN1 as differential analog inputs
uint8_t CMD_WRITE_CONFIGREG_ONE_ADC_PT100[3] = {0x55,0x42,0x0A}; //Internal 2.048vdc as ref.,Continuous conv.,Normal mode,Data Rate 20SPS
uint8_t CMD_WRITE_CONFIGREG_TWO_ADC_PT100[3] = {0x55,0x44,0x05}; //Data counter disabled,IDAC1=500uA,Data integrity check disabled
uint8_t CMD_WRITE_CONFIGREG_THREE_ADC_PT100[3] = {0x55,0x48,0x80}; //Manual data read mode,IDAC2 disabled, IDAC1 connected to AIN3
uint8_t CMD_WRITE_CONFIGREG_FOUR_ADC_PT100[3] = {0x55,0x4A,0x00}; //GPIO2 configured as input which is default setting

//---------------------------------------------------------------------------------
//Variables Declaration
uint8_t PT100_ADC_DataReceiveBuff[PT100_ADC_RECBUFFLEN_MAX] = {0x00,0x00,0x00,0x00,0x00,0x00};
uint8_t PT100_ADC_ConfigRegReadBackBuff[ADC_CONFIG_READBACK_MAXLEN] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};

//---------------------------------------------------------------------------------
//Functions Declarations -These must be done after variable declaration otherwise-
//IDE misbehaves i.e. compiler says zero errors but bugs symbols seen-
//(for e.g. in case of 'OperatingMode.c' file), the 'stTime' structure elements-
//and they are signaled as undefined.
void InitADCandStartConversion_PT100(void);
void PT100_ClearADCdatareceivebuffer(void);
void ReadADC_ConversionResult_PT100(void);
void ReadBackConfigRegs(void);
//---------------------------------------------------------------------------------
//Functions Definitions
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//Function Name: InitADCandStartConversion_PT100
//Description: Initialize the external ADC IC ADS122U04, and Start A/D conversion.
//Here the ADC IC is configured to work in "CONTINUOUS CONVERSION" mode and-
//the A/D converted data output mode of the ADC IC is configured to be "MANUAL DATA READ" mode-
//which is it's default mode (instead of Automatic data read mode).
//-----------------------------------------------------------------------
void InitADCandStartConversion_PT100(void)
{
//Send the sync byte and RESET command to PT100 ADC
R_SCI1_Serial_Send(CMD_RESET_ADC_PT100,2);
delay_1000msec();
//--------------------------------------------------------------------------
//Write the respective register configurations with the WREG command, sending the synchronization byte each time
R_SCI1_Serial_Send(CMD_WRITE_CONFIGREG_ZERO_ADC_PT100,3); //write setting bits to configuration reg0
delay_100msec();
delay_100msec();
delay_50msec();
R_SCI1_Serial_Send(CMD_WRITE_CONFIGREG_TWO_ADC_PT100,3); //write setting bits to configuration reg2
delay_100msec();
delay_100msec();
delay_50msec();
R_SCI1_Serial_Send(CMD_WRITE_CONFIGREG_THREE_ADC_PT100,3); //write setting bits to configuration reg3
//delay_100msec();
//delay_100msec();
delay_500msec();
R_SCI1_Serial_Send(CMD_WRITE_CONFIGREG_FOUR_ADC_PT100,3); //write setting bits to configuration reg4
delay_100msec();
delay_100msec();
delay_50msec();
//Now, write to the config reg1 so as to select 'Continuous Conversion mode'
R_SCI1_Serial_Send(CMD_WRITE_CONFIGREG_ONE_ADC_PT100,3); //write setting bits to configuration reg1
//delay_100msec();
//delay_100msec();
delay_50msec();
//-------------------------------------------------------------------------------
//Send the START/SYNC command to start converting in continuous conversion mode
//The START/SYNC command needs to be given immediately after Setting (logic one) the Configuration mode 'CM' bit in-
//config reg1 which indicates that 'Continuous Conversion mode' is enabled.
R_SCI1_Serial_Send(CMD_STARTSYNC_ADC_PT100,2);
delay_500msec();
}//end of function void InitADCandStartConversion_PT100(void) ends

//---------------------------------------------------------------------------------
//Function Name: PT100_ClearADCdatareceivebuffer
//Description: Clear the PT100 ADC data receive buffer and-
// re-initialize uart1 serial reception buffer counter
//-----------------------------------------------------------------------
void PT100_ClearADCdatareceivebuffer(void)
{
uint8_t ucClearLoopCtr;
for (ucClearLoopCtr=0x00;ucClearLoopCtr<PT100_ADC_RECBUFFLEN_MAX;ucClearLoopCtr++)
{
PT100_ADC_DataReceiveBuff[ucClearLoopCtr] = 0x00;
}//end of for loop
R_SCI1_Serial_Receive(PT100_ADC_DataReceiveBuff,PT100_ADC_RECBUFFLEN_MAX); //re-initialize uart1 serial reception buffer counter
}//end of function PT100_ClearADCdatareceivebuffer ends
//---------------------------------------------------------------------------------
//Function Name: ReadADC_ConversionResult_PT100
//Description:
//-----------------------------------------------------------------------
void ReadADC_ConversionResult_PT100(void)
{
uint8_t ucStatusTemp;

//Send the START/SYNC command to start converting in Single-shot conversion mode
//R_SCI1_Serial_Send(CMD_STARTSYNC_ADC_PT100,2);
//delay_500msec();
//Clear the PT100 ADC data receive buffer and re-initialize uart1 serial reception buffer counter
PT100_ClearADCdatareceivebuffer();
//Send Command to Read the contents of Config Reg2 so as to check the status of "DRDY" (Bit7)-
//If ("DRDY" bit==1) it means that "New conversion result ready" for the host uC to read.
R_SCI1_Serial_Send(CMD_READ_CONFIGREG_TWO_ADC_PT100,2);
delay_100msec();
delay_100msec();
delay_50msec();
//Receive the contents of Config Reg2
R_SCI1_Serial_Receive(PT100_ADC_DataReceiveBuff,PT100_ADC_RECBUFFLEN_MAX);
delay_500msec();

ucStatusTemp = PT100_ADC_DataReceiveBuff[0]; //copy the value of Config Reg2 into temporary var
if(ucStatusTemp&0xF0) //mask all other bits except data ready status flag 'DRDY' bit7
{
//Clear the PT100 ADC data receive buffer and re-initialize uart1 serial reception buffer counter
PT100_ClearADCdatareceivebuffer();
//send command to read A/D converted data
R_SCI1_Serial_Send(CMD_READDATA_ADC_PT100,2);
delay_100msec();
delay_100msec();
delay_50msec();
//Receive the A/D converted data sent by ADC IC
R_SCI1_Serial_Receive(PT100_ADC_DataReceiveBuff,PT100_ADC_RECBUFFLEN_MAX);
delay_1000msec();//delay needed for serial transmission to complete via ISR
}
//send the received data on UART5 for monitoring purpose
R_SCI5_Serial_Send(PT100_ADC_DataReceiveBuff,PT100_ADC_RECBUFFLEN_MAX);
delay_100msec();
delay_100msec();
delay_50msec();
}//end of function ReadADC_ConversionResult_PT100 ends
//-----------------------------------------------------------------------

//-----------------------------------------------------------------------
//Function Name: ReadBackConfigRegs
//Description: Read Back the config reg contents to verify that they have got written correctly
//-----------------------------------------------------------------------
void ReadBackConfigRegs(void)
{
//------------------------------
//Clear the PT100 ADC data receive buffer and re-initialize uart1 serial reception buffer counter
PT100_ClearADCdatareceivebuffer();
//Read Back the config reg contents to verify that they have got written correctly
R_SCI1_Serial_Send(CMD_READ_CONFIGREG_ZERO_ADC_PT100,2);
delay_100msec();
//Receive the contents of Config Reg
R_SCI1_Serial_Receive(PT100_ADC_DataReceiveBuff,PT100_ADC_RECBUFFLEN_MAX);
delay_100msec();
delay_100msec();
delay_50msec();
PT100_ADC_ConfigRegReadBackBuff[0] = PT100_ADC_DataReceiveBuff[0];
//------------------------------
//Clear the PT100 ADC data receive buffer and re-initialize uart1 serial reception buffer counter
PT100_ClearADCdatareceivebuffer();
//Read Back the config reg contents to verify that they have got written correctly
R_SCI1_Serial_Send(CMD_READ_CONFIGREG_ONE_ADC_PT100,2);
delay_100msec();
//Receive the contents of Config Reg
R_SCI1_Serial_Receive(PT100_ADC_DataReceiveBuff,PT100_ADC_RECBUFFLEN_MAX);
delay_100msec();
delay_100msec();
delay_50msec();
PT100_ADC_ConfigRegReadBackBuff[1] = PT100_ADC_DataReceiveBuff[0];
//------------------------------
//Clear the PT100 ADC data receive buffer and re-initialize uart1 serial reception buffer counter
PT100_ClearADCdatareceivebuffer();
//Read Back the config reg contents to verify that they have got written correctly
R_SCI1_Serial_Send(CMD_READ_CONFIGREG_TWO_ADC_PT100,2);
delay_100msec();
//Receive the contents of Config Reg
R_SCI1_Serial_Receive(PT100_ADC_DataReceiveBuff,PT100_ADC_RECBUFFLEN_MAX);
delay_100msec();
delay_100msec();
delay_50msec();
PT100_ADC_ConfigRegReadBackBuff[2] = PT100_ADC_DataReceiveBuff[0];
//------------------------------
//Clear the PT100 ADC data receive buffer and re-initialize uart1 serial reception buffer counter
PT100_ClearADCdatareceivebuffer();
//Read Back the config reg contents to verify that they have got written correctly
R_SCI1_Serial_Send(CMD_READ_CONFIGREG_THREE_ADC_PT100,2);
delay_100msec();
//Receive the contents of Config Reg
R_SCI1_Serial_Receive(PT100_ADC_DataReceiveBuff,PT100_ADC_RECBUFFLEN_MAX);
delay_100msec();
delay_100msec();
delay_50msec();
PT100_ADC_ConfigRegReadBackBuff[3] = PT100_ADC_DataReceiveBuff[0];
//------------------------------
//Clear the PT100 ADC data receive buffer and re-initialize uart1 serial reception buffer counter
PT100_ClearADCdatareceivebuffer();
//Read Back the config reg contents to verify that they have got written correctly
R_SCI1_Serial_Send(CMD_READ_CONFIGREG_FOUR_ADC_PT100,2);
delay_100msec();
//Receive the contents of Config Reg
R_SCI1_Serial_Receive(PT100_ADC_DataReceiveBuff,PT100_ADC_RECBUFFLEN_MAX);
delay_100msec();
delay_100msec();
delay_50msec();
PT100_ADC_ConfigRegReadBackBuff[4] = PT100_ADC_DataReceiveBuff[0];
//------------------------------
//send the received data on UART5 for monitoring purpose
R_SCI5_Serial_Send(PT100_ADC_ConfigRegReadBackBuff,PT100_ADC_RECBUFFLEN_MAX);
delay_100msec();
delay_100msec();
delay_50msec();
}
//-----------------------------------------------------------------------END OF FILE PT100_SensorRead.c-----------------------------------------------------------

//-----------------------------------------------------------------------START OF FILE main.c-----------------------------------------------------------

/***********************************************************************************************************************
* File Name : r_cg_main.c
* Version : Code Generator for RX113 V1.02.05.01 [11 Nov 2016]
* Device(s) : R5F51136AxFM
* Tool-Chain : CCRX
* Description : This file implements main function.
* Creation Date: 21-Jun-20
***********************************************************************************************************************/

/***********************************************************************************************************************
Pragma directive
***********************************************************************************************************************/
/* Start user code for pragma. Do not edit comment generated here */
/* End user code. Do not edit comment generated here */

/***********************************************************************************************************************
Includes
***********************************************************************************************************************/
#include "r_cg_macrodriver.h"
#include "r_cg_cgc.h"
#include "r_cg_port.h"
#include "r_cg_rtc.h"
#include "r_cg_iwdt.h"
#include "r_cg_sci.h"
#include "r_cg_riic.h"
/* Start user code for include. Do not edit comment generated here */
#include "stdint.h"
#include "CommonDefines.h"
/* End user code. Do not edit comment generated here */
#include "r_cg_userdefine.h"

/***********************************************************************************************************************
Global variables and functions
***********************************************************************************************************************/
/* Start user code for global. Do not edit comment generated here */

//------------------------------------------------------------------------------------
uint8_t ucTestToggle = 0x00; // for test purpose only

rtc_calendarcounter_value_t GSM_nw_Time; // get the GSM network time in his structure
uint8_t Hours,Minutes,Seconds;
uint8_t Year,Month,Day;
uint8_t Temp_Var;
uint8_t Year_Decimal,Month_Decimal,Day_Decimal;
uint8_t Hours_Decimal,Minutes_Decimal,Seconds_Decimal;
extern volatile uint8_t Send_End;

//typedef struct
//{
// uint8_t ucSecond;
// uint8_t ucMinute;
// uint8_t ucHour;
// uint8_t ucDay;
// uint8_t ucWeek;
// uint8_t ucMonth;
// uint16_t uiYear;
//} DateAndTime_t;
//DateAndTime_t stDMYHMS_BCD,stDMYHMS_Decimal;

//structures used when updating latest GSM date and time periodically
rtc_calendarcounter_value_t stDateTimeBCD,stDateTimeDecimal;

rtc_calendar_alarm_enable_t stAlarmEnable;
rtc_calendar_alarm_value_t stAlarmTime;

//An unsigned long value used as input parameter to srand() function that-
//sets an initial value of the pseudo-random number sequence generated by the rand() function.
//Functions srand() and rand() are used for generating the 'Main Interval' of random duration-
//in minutes (20min to 60min) when 'Main Interval Type' is set as 'RANDOM' via Settings SMS.
uint32_t ulSeedValueForRandomNumFunct = 0x00000000; // A 32bit initialization value

uint8_t LineFeed[1] ={0x0A};
uint8_t cmd1[] ={"AT\r"};
uint8_t cmd2[] ={"ATD"};
uint8_t PhoneNum[] ={"9423570299;"};
uint8_t cmd3[] ={"ATH"};
uint8_t cmd4[] ={"AT+CMGF=1\r"}; //select TEXT mode
uint8_t cmd6[] ={"AT+QINISTAT\r"};
uint8_t cmd7[] ={"AT+QNSTATUS\r"};
uint8_t cmd8[] ={"AT+QNITZ=0\r"};//After receiving network time message, DO-NOT send URC (unsolicited Result)
uint8_t cmd9[] ={"AT+CCLK?\r"};
uint8_t cmd10[] ={"ATE0\r"};
uint8_t cmd11[] ={"AT+CMGD=1,4\r"}; //Delete SMS,ALL
uint8_t cmd13[] ={"AT+CTZU=3\r"}; //Network Time Synchronization and Update the RTC Time
uint8_t cmd14[] ={"AT+CSCS="}; //send command AT+CSCS="IRA" to set the character set to IRA
uint8_t cmd15[] ={"AT+CSCS?\r"};
uint8_t chset_IRA[] ={"IRA"};
uint8_t chset_HEX[] ={"HEX"};
uint8_t chset_GSM[] ={"GSM"};
uint8_t DoubleQuote[1] ={0x22}; //double-quote character hex code
uint8_t Comma_Char[1] ={0x2c}; //Comma character hex code
uint8_t cmd16[] ={"AT+QMGDA=6\r"}; //Delete all SMS - PDU MODE
uint8_t cmd17[] ={"AT+CMGF=0\r"}; //select PDU mode
uint8_t cmd18[] ={"AT+QMGDA="}; //Delete all SMS
uint8_t DEL_ALL[] ={"DEL ALL"}; //string send as parameter following "AT+QMGDA=" command to delete all SMS
uint8_t DummySMS[] = {"Hello Evincere"};
uint8_t cmd19[] ={"AT&W\r"}; // command for Storing the current settings in M66 user profile
uint8_t cmd20[] ={"AT+CPMS="}; // Set the SMS storage memory as SIM memory
uint8_t SIM_mem[] ={"SM"}; //used when sending the command:AT+CPMS="SM","SM","SM";here SM means SIM memory
uint8_t cmd21[] ={"AT+CREG?\r"}; //Get network registration status of M66 module
//_Bool TestVar;
//------------------------------------------------------------------
//Function Declarations
//------------------------------------------------------------------
void delay_625msec(void); // for 5sec delay
void delay_6msec(void); // for 50msec delay
void delay_50msec(void); // for 50msec delay
void delay_500msec(void); // for 500msec delay
void delay_100msec(void); // for 100msec delay
void delay_1000msec(void);// for 1000msec delay
void ClearReceiveBuffer(void);
void UpdtNwTimeToRTC(void);
void SetAlarmTime(uint8_t);
void Disable_RTCAlarm(void);
void SetUnitPowerupSMSFlags(void);
void ObtainGSMtimeInRuntime(void);
//------------------------------------------------------------------
/* End user code. Do not edit comment generated here */

static void R_MAIN_UserInit(void);
/***********************************************************************************************************************
* Function Name: main
* Description : This function implements main function.
* Arguments : None
* Return Value : None
***********************************************************************************************************************/
void main(void)
{
R_MAIN_UserInit();
/* Start user code. Do not edit comment generated here */
PORT2.PODR.BIT.B7=0; //ACK LED OFF
PORT2.PODR.BIT.B6=0; //BUZZER OFF
delay_100msec();
while (1U)
{
//----------------------------------
PORT2.PODR.BIT.B7=1; //ACK LED ON
PORT2.PODR.BIT.B6=1; //BUZZER ON
delay_500msec();
PORT2.PODR.BIT.B7=0; //ACK LED OFF
PORT2.PODR.BIT.B6=0; //BUZZER OFF
delay_500msec();
//----------------------------------
//----------------------------------
ReadADC_ConversionResult_PT100();
//Send the sync byte and RESET command to PT100 ADC
//ReadBackConfigRegs();
}
//-----------------------------------------------------------------------------
/* End user code. Do not edit comment generated here */
}
/***********************************************************************************************************************
* Function Name: R_MAIN_UserInit
* Description : This function adds user code before implementing main function.
* Arguments : None
* Return Value : None
***********************************************************************************************************************/
void R_MAIN_UserInit(void)
{
/* Start user code. Do not edit comment generated here */
delay_500msec();
R_SCI1_Start(); //initialization of UART1
nop();nop();nop();nop();nop();nop();nop();nop();nop();nop();
R_SCI5_Start(); //initialization of UART5
nop();nop();nop();nop();nop();nop();nop();nop();nop();nop();
InitADCandStartConversion_PT100(); //initialization of ADS122U04
nop();nop();nop();nop();nop();nop();nop();nop();nop();nop();
/* End user code. Do not edit comment generated here */
}

/* Start user code for adding. Do not edit comment generated here */
//-----------------------------------------------------------------------
/***********************************************************************************************************************
* Function Name: delay
* Description : This function clears the receive buffer
* Arguments : None
* Return Value : None
***********************************************************************************************************************/
void ClearReceiveBuffer(void)
{
uint16_t i;
for(i=0;i<SMS_RECBUFFLEN_MAX;i++)
{
ReceiveBuffer[i] = 0x00; // clear the receive buffer
}
R_SCI9_Serial_Receive(ReceiveBuffer,SMS_RECBUFFLEN_MAX); //re-initialize uart0 serial reception buffer counter
}

/***********************************************************************************************************************
* Function Name: delay_50msec
* Description : This function implements a delay of 50msec at 16MHz Main clk.
* Measured using Frequency Gen/Counter and verified that 50msec delay is obtained.
* Arguments : None
* Return Value : None
***********************************************************************************************************************/
void delay_50msec(void)
{
uint16_t outerloop,innerloop;
for(outerloop=0;outerloop<100;outerloop++)
{
for(innerloop=0;innerloop<1000;innerloop++)
{
continue;
}
}
}
/***********************************************************************************************************************
* Function Name: delay_100msec
* Description : This function implements a delay of 100msec at 16MHz Main clk.
* Measured using Frequency Gen/Counter and verified that 100msec delay is obtained.
* Arguments : None
* Return Value : None
***********************************************************************************************************************/
void delay_100msec(void)
{
uint16_t outerloop,innerloop;
for(outerloop=0;outerloop<200;outerloop++)
{
for(innerloop=0;innerloop<1000;innerloop++)
{
continue;
}
}
}
/***********************************************************************************************************************
* Function Name: delay_500msec
* Description : This function implements a delay of 500msec at 16MHz Main clk.
* Yet to be Measured using Frequency Gen/Counter and verified that 500msec delay is obtained.
* Arguments : None
* Return Value : None
***********************************************************************************************************************/
void delay_500msec(void)
{
uint16_t outerloop,innerloop;
R_IWDT_Restart(); //Refresh the I-WDT to avoid I-WDT-Reset
for(outerloop=0;outerloop<1000;outerloop++)
{
for(innerloop=0;innerloop<1000;innerloop++)
{
continue;
}
}
}
/***********************************************************************************************************************
* Function Name: delay_1000msec
* Description : This function implements a delay of 1000msec at 16MHz Main clk.
* Yet to be Measured using Frequency Gen/Counter and verified that 1000msec delay is obtained.
* Arguments : None
* Return Value : None
***********************************************************************************************************************/
void delay_1000msec(void)
{
uint16_t outerloop,innerloop;
R_IWDT_Restart(); //Refresh the I-WDT to avoid I-WDT-Reset
for(outerloop=0;outerloop<2000;outerloop++)
{
for(innerloop=0;innerloop<1000;innerloop++)
{
continue;
}
}
}
//-----------------------------------------------------------------------
/* End user code. Do not edit comment generated here */

//-----------------------------------------------------------------------END OF FILE main.c-----------------------------------------------------------