//static
void tshw_prepare_wait(void)
{
/*
* Drive Y low and enable a pull-up on X. When touchscreen is
* pressed X will be pulled low by Y and an interrupt will be
* generated
*/
GPIO_SetOutput(TS_PIN_YD, 0);
GPIO_SetOutput(TS_PIN_YU, 0);
GPIO_SetInputPulledUp(TS_PIN_XL | TS_PIN_XR);
}
/*************************************************************************
* Function Name: LED_Init
* Parameters:None
*
* Return:None
*
* Description: Init LED ports
*
*************************************************************************/
void LED_Init()
{
/*Set PG bit0~3 output and turn off all leds*/
GPIO_SetOutput(GPIO_PG, GPIO_BIT_0);
GPIO_SetOutput(GPIO_PG, GPIO_BIT_1);
GPIO_SetOutput(GPIO_PG, GPIO_BIT_2);
GPIO_SetOutput(GPIO_PG, GPIO_BIT_3);
GPIO_WriteDataBit(GPIO_PG, GPIO_BIT_0, GPIO_BIT_VALUE_0);
GPIO_WriteDataBit(GPIO_PG, GPIO_BIT_1, GPIO_BIT_VALUE_0);
GPIO_WriteDataBit(GPIO_PG, GPIO_BIT_2, GPIO_BIT_VALUE_0);
GPIO_WriteDataBit(GPIO_PG, GPIO_BIT_3, GPIO_BIT_VALUE_0);
}
void Commands_SetPinConfig(uint8_t* data)
{
switch (data[1])
{
case MakeDigitalInput:
GPIO_SetInput(data[0], data[2]);
pinConfigs[data[0]] = DigitalInput;
break;
case MakeDigitalOutput:
GPIO_SetOutput(data[0]);
pinConfigs[data[0]] = DigitalOutput;
break;
case SetDigitalValue:
GPIO_WriteValue(data[0], data[2]);
break;
case MakeAnalogInput:
ADC_SetInput(data[0]);
pinConfigs[data[0]] = AnalogInput;
break;
case MakePWMPin:
PWM_SetOutput(data[0], data[2]);
break;
case SetPWMValue:
PWM_SetValue(data[0], data[2], data[3]);
break;
}
}
/*******************************************************************************
* Function Name : SW_Init
* Description : Initialize the GPIO to SW
* Input : None
* Return : None.
*******************************************************************************/
void SW_Init(void)
{
GPIO_SetInput(GPIO_PH, 0x03U);
GPIO_SetInput(GPIO_PK, 0x03U);
GPIO_SetOutput(SWS_DATA_PORT, GPIO_BIT_2);
}
/**
* @brief TMRB_PPG demo
* @param None
* @retval None
*/
void Example_TimerPpg(void)
{
uint8_t Rate = 0U;
uint32_t Duty[5] = { 0x8CAU, 0x753U, 0x4E2U, 0x271U, 0xFAU }; /* duty: 10%, 25%, 50%, 75%, 90% */
uint8_t keyvalue;
TMRB_InitTypeDef m_tmrb;
TMRB_FFOutputTypeDef PPGFFInital;
GPIO_SetInput(KEYPORT, GPIO_BIT_0); /* set KEY port to input */
/* Set PF1 as TB7OUT for PPG output */
GPIO_SetOutput(GPIO_PF, GPIO_BIT_1);
GPIO_EnableFuncReg(GPIO_PF, GPIO_FUNC_REG_1, GPIO_BIT_1);
GPIO_SetPullUp(GPIO_PF, GPIO_BIT_1, ENABLE);
m_tmrb.Mode = TMRB_INTERVAL_TIMER;
m_tmrb.ClkDiv = TMRB_CLK_DIV_8;
m_tmrb.UpCntCtrl = TMRB_AUTO_CLEAR;
m_tmrb.Cycle = TMRB7TIME; /* T = 250us */
m_tmrb.Duty = Duty[Rate];
PPGFFInital.FlipflopCtrl = TMRB_FLIPFLOP_CLEAR;
PPGFFInital.FlipflopReverseTrg = TMRB_FLIPFLOP_MATCH_CYCLE | TMRB_FLIPFLOP_MATCH_DUTY;
TMRB_Enable(TSB_TB7);
TMRB_Init(TSB_TB7, &m_tmrb);
TMRB_SetFlipFlop(TSB_TB7, &PPGFFInital);
TMRB_SetDoubleBuf(TSB_TB7, ENABLE, TMRB_WRITE_REG_SEPARATE); /* enable double buffer */
TMRB_SetRunState(TSB_TB7, TMRB_RUN);
do { /* wait if key is pressed */
keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0);
} while (GPIO_BIT_VALUE_1 == keyvalue);
delay(0xFFFU); /* noise cancel */
while (1) {
do { /* wait if key is released */
keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0);
} while (GPIO_BIT_VALUE_0 == keyvalue);
delay(0xFFFU); /* noise cancel */
Rate++;
if (Rate >= DUTYMAX) { /* change duty rate */
Rate = DUTYINIT;
} else {
/* Do nothing */
}
TMRB_ChangeDuty(TSB_TB7, Duty[Rate]); /* change duty rate */
do { /* wait if key is pressed */
keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0);
} while (GPIO_BIT_VALUE_1 == keyvalue);
delay(0xFFFU); /* noise cancel */
}
}
/*************************************************************************
* Function Name: LED_Init
* Parameters:None
*
* Return:None
*
* Description: Init LED ports
*
*************************************************************************/
void LED_Init(void)
{
uint8_t led_off;
led_off = (uint8_t) (~LED_ALL);
GPIO_SetOutput(LED_DATA_PORT, LED_ALL);
GPIO_WriteData(LED_DATA_PORT, led_off);
}
/**
* @brief CAN port initialization
* @param None.
* @retval None.
*/
void CAN_PortInit(void)
{
GPIO_SetOutput(GPIO_PE, GPIO_BIT_4); /* Set TX pin as output */
GPIO_SetInput(GPIO_PE, GPIO_BIT_5); /* Set RX pin as input */
GPIO_EnableFuncReg(GPIO_PE, GPIO_FUNC_REG_3, (uint8_t) (GPIO_BIT_4 | GPIO_BIT_5)); /* Enable TX and RX pin functions */
GPIO_SetOpenDrain(GPIO_PE, GPIO_BIT_4, DISABLE); /* Set TX pin as CMOS output */
GPIO_SetPullUp(GPIO_PE, (uint8_t) (GPIO_BIT_4 | GPIO_BIT_5), DISABLE); /* Disable pull-ups for CAN pins */
}
/**
* @brief The main function of TMRB_PPG demo
* @param None
* @retval None
*/
void Example_TMRB_PPG(void)
{
uint32_t Duty[5] = { 0x1194U, 0xEA6U, 0x9C4U, 0x4E2U, 0x1F4U }; /* duty: 10%, 25%, 50%, 75%, 90% */
uint8_t keyvalue;
TMRB_InitTypeDef m_tmrb;
TMRB_FFOutputTypeDef PPGFFInital;
/* LCD & switch initialization */
LCD_Configuration();
SW_Init();
/* Set PA5 as TB6OUT for PPG output */
GPIO_SetOutput(GPIO_PA, GPIO_BIT_5);
GPIO_EnableFuncReg(GPIO_PA, GPIO_FUNC_REG_2, GPIO_BIT_5);
m_tmrb.Mode = TMRB_INTERVAL_TIMER;
m_tmrb.ClkDiv = TMRB_CLK_DIV_8;
m_tmrb.UpCntCtrl = TMRB_AUTO_CLEAR;
m_tmrb.Cycle = TMRB6TIME; /* T = 500us */
m_tmrb.Duty = Duty[Rate];
PPGFFInital.FlipflopCtrl = TMRB_FLIPFLOP_CLEAR;
PPGFFInital.FlipflopReverseTrg = TMRB_FLIPFLOP_MATCH_CYCLE | TMRB_FLIPFLOP_MATCH_DUTY;
TMRB_Enable(TSB_TB6);
TMRB_Init(TSB_TB6, &m_tmrb);
TMRB_SetFlipFlop(TSB_TB6, &PPGFFInital);
TMRB_SetDoubleBuf(TSB_TB6, ENABLE, TMRB_WRITE_REG_SEPARATE); /* enable double buffer */
TMRB_SetRunState(TSB_TB6, TMRB_RUN);
do { /* Handle the condition that start with the SW0 is high*/
keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0);
duty_display();
} while (GPIO_BIT_VALUE_1 == keyvalue);
delay(0xFFFFU); /* noise cancel */
while (1) {
do {
keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0); /* display when switch is low */
duty_display();
} while (GPIO_BIT_VALUE_0 == keyvalue);
delay(0xFFFFU); /* noise cancel */
Rate++;
if (Rate >= DUTYMAX) { /* change duty rate */
Rate = DUTYINIT;
} else {
/* Do nothing */
}
TMRB_ChangeDuty(TSB_TB6, Duty[Rate]);
do {
keyvalue = GPIO_ReadDataBit(KEYPORT, GPIO_BIT_0); /* display when switch is high */
duty_display();
} while (GPIO_BIT_VALUE_1 == keyvalue);
delay(0xFFFFU); /* noise cancel */
}
}
/*******************************************************************************
* Function Name : SW_Init
* Description : Initialize the GPIO to SW
* Input : None
* Return : None.
*******************************************************************************/
void SW_Init(void)
{
GPIO_SetInput(GPIO_PI, GPIO_BIT_0);
GPIO_SetInput(GPIO_PI, GPIO_BIT_1);
GPIO_SetInput(GPIO_PI, GPIO_BIT_2);
GPIO_SetInput(GPIO_PI, GPIO_BIT_3);
GPIO_SetOutput(GPIO_PJ, GPIO_BIT_2);
}
int main(void) {
GPIO_SETTING gpiosettings;
WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer
#if 0
// initialize P1.0 output Low and P1.6 output High
gpiosettings.r.Direction= GPIO_Output;
gpiosettings.r.output = GPIO_Low;
GPIO_SetOutput( GPIO_Port1, BIT0, &gpiosettings);
gpiosettings.r.output = GPIO_High;
GPIO_SetOutput( GPIO_Port1, BIT6, &gpiosettings);
while (1) {
P1OUT ^= BIT0; // Toggle LED on P1.0
P1OUT ^= BIT6; // Toggle LED on P1.6
__delay_cycles(100000); // Wait ~100ms at default DCO of ~1MHz
}
}
void set_segment(uint8_t seg, uint8_t state)
{
GPIO_HANDLE* handle = 0;
switch(seg) {
case 0: handle = &SEGA; break;
case 1: handle = &SEGB; break;
case 2: handle = &SEGC; break;
case 3: handle = &SEGD; break;
case 4: handle = &SEGE; break;
case 5: handle = &SEGF; break;
case 6: handle = &SEGG; break;
case 7: handle = &SEGDP; break;
default:
return;
}
if (state == 0)
GPIO_SetOutput(GPIO_HIGH, handle);
else if (state == 1)
GPIO_SetOutput(GPIO_LOW, handle);
}
//static
void tshw_get_raw(uint16_t *adc_x, uint16_t *adc_y)
{
uint32_t val1, val2;
/*
* YD=0 YU=1, measure XL and XR
* YD=1 YU=0, measure XL and XR
* The average of the previous four samples is the X value.
*
* XL=0 XR=1, measure YD and YU
* XL=1 XR=0, measure YD and YU
* The average of the previous four samples is the Y value.
*
* A total of 8 ADC measurements are needed!
*/
GPIO_SetAnalog(TS_PIN_XL | TS_PIN_XR);
GPIO_SetOutput(TS_PIN_YD, 0);
GPIO_SetOutput(TS_PIN_YU, 1);
delay(100);
val1 = (ADC_Measure(TS_ADCCH_XL) + ADC_Measure(TS_ADCCH_XR))/2;
GPIO_SetOutput(TS_PIN_YD, 1);
GPIO_SetOutput(TS_PIN_YU, 0);
delay(100);
val2 = (ADC_Measure(TS_ADCCH_XL) + ADC_Measure(TS_ADCCH_XR))/2;
*adc_y = (val1+((1<<12)-val2))/4;
GPIO_SetAnalog(TS_PIN_YD | TS_PIN_YU);
GPIO_SetOutput(TS_PIN_XL, 0);
GPIO_SetOutput(TS_PIN_XR, 1);
delay(100);
val1 = (ADC_Measure(TS_ADCCH_YD) + ADC_Measure(TS_ADCCH_YU))/2;
GPIO_SetOutput(TS_PIN_XL, 1);
GPIO_SetOutput(TS_PIN_XR, 0);
delay(100);
val2 = (ADC_Measure(TS_ADCCH_YD) + ADC_Measure(TS_ADCCH_YU))/2;
*adc_x = (val1+((1<<12)-val2))/4;
}
void Example_VLTD_Reset(void)
{
WDT_Disable(); /* Disable WDT explicitly */
GPIO_SetOutput(GPIO_PG, GPIO_BIT_0); /* Set PG0 as output port */
if (CG_GetResetFlag().Bit.VLTDReset == 0U) {
VLTD_SetVoltage(VLTD_DETECT_VOLTAGE_46); /* change the parameter to select
different detection voltage */
VLTD_Enable(); /* Enable VLTD function */
GPIO_WriteData(GPIO_PG, 0x00); /* Set PG0 to LOW */
} else {
VLTD_Disable(); /* Disable VLTD function */
GPIO_WriteData(GPIO_PG, 0x01); /* Set PG0 to HIGH */
}
while (1) {
/* Do nothing */
}
}
void TMRB_TIMER(void)
{
TMRB_InitTypeDef m_tmrb;
CG_InitSystem(); /* CG_SetSystem */
GPIO_SetOutput(GPIO_PA,0xFFU);
GPIO_WriteData(GPIO_PA,0xFFU); /* LED initialize */
LedOff(LED1 | LED2 | LED3 | LED4);
m_tmrb.Mode = TMRB_INTERVAL_TIMER;
m_tmrb.ClkDiv = TMRB_CLK_DIV_8;
m_tmrb.Cycle = TMRB_1MS; /* periodic time is 1ms */
m_tmrb.UpCntCtrl = TMRB_AUTO_CLEAR;
m_tmrb.Duty = TMRB_1MS; /* periodic time is 1ms */
TMRB_Enable(TSB_TB0);
TMRB_Init(TSB_TB0, &m_tmrb);
NVIC_EnableIRQ(INTTB0_IRQn);
TMRB_SetRunState(TSB_TB0, TMRB_RUN);
while (1) {
/* Do nothing */
}
}
/*************************************************************************
* Function Name: LED_Init
* Parameters:None
*
* Return:None
*
* Description: Init LED ports
*
*************************************************************************/
void LED_Init(void)
{
/* PC0,PC1,PC2,PC3 */
GPIO_SetOutput(LED_DATA_PORT, 0x0FU);
GPIO_WriteData(LED_DATA_PORT, 0x00U);
}
void SSP_LoopBack(void)
{
SSP_InitTypeDef initSSP;
SSP_FIFOState fifoState;
uint16_t datTx = 0U; /* must use 16bit type */
uint32_t cntTx = 0U;
uint32_t cntRx = 0U;
uint16_t receive = 0U;
uint16_t Rx_Buf[MAX_BUFSIZE] = { 0U };
uint16_t Tx_Buf[MAX_BUFSIZE] = { 0U };
/* configure the SSP module */
initSSP.FrameFormat = SSP_FORMAT_SPI;
/* default is to run at maximum bit rate */
initSSP.PreScale = 2U;
initSSP.ClkRate = 1U;
/* define BITRATE_MIN to run at minimum bit rate */
/* BitRate = fSYS / (PreScale x (1 + ClkRate)) */
#ifdef BITRATE_MIN
initSSP.PreScale = 254U;
initSSP.ClkRate = 255U;
#endif
initSSP.ClkPolarity = SSP_POLARITY_LOW;
initSSP.ClkPhase = SSP_PHASE_FIRST_EDGE;
initSSP.DataSize = 16U;
initSSP.Mode = SSP_MASTER;
SSP_Init(TSB_SSP0, &initSSP);
/* enable loop back mode for self test */
SSP_SetLoopBackMode(TSB_SSP0, ENABLE);
/* enable and run SSP module */
SSP_Enable(TSB_SSP0);
/* initialize LEDs on M366-SK board before display something */
GPIO_SetOutput(GPIO_PA,0xFFU);
GPIO_WriteData(GPIO_PA,0xFFU);
while (1) {
datTx++;
/* send data if Tx FIFO is available */
fifoState = SSP_GetFIFOState(TSB_SSP0, SSP_TX);
if ((fifoState == SSP_FIFO_EMPTY) || (fifoState == SSP_FIFO_NORMAL)) {
SSP_SetTxData(TSB_SSP0, datTx);
if (cntTx < MAX_BUFSIZE) {
Tx_Buf[cntTx] = datTx;
cntTx++;
} else {
/* do nothing */
}
} else {
/* do nothing */
}
/* check if there is data arrived */
fifoState = SSP_GetFIFOState(TSB_SSP0, SSP_RX);
if ((fifoState == SSP_FIFO_FULL) || (fifoState == SSP_FIFO_NORMAL)) {
receive = SSP_GetRxData(TSB_SSP0);
if (cntRx < MAX_BUFSIZE) {
Rx_Buf[cntRx] = receive;
cntRx++;
} else {
/* Place a break point here to check if receive data is right. */
/* Success Criteria: */
/* Every data transmited from Tx_Buf is received in Rx_Buf. */
/* When the line "#define BITRATE_MIN" is commented, the SSP is run in maxium */
/* bit rate, so we can find there is enough time to transmit date from 1 to */
/* MAX_BUFSIZE one by one. but if we uncomment that line, SSP is run in */
/* minimum bit rate, we will find that receive data can't catch "datTx++", */
/* in this so slow bit rate, when the Tx FIFO is available, the cntTx has */
/* been increased so much. */
__NOP();
result = Buffercompare(Tx_Buf, Rx_Buf, MAX_BUFSIZE);
}
} else {
/* do nothing */
}
DisplayLED(receive);
}
}
