static void SerialDrv_RxOctet (SERIAL_DEV *pdev,
CPU_INT08U *pdatum,
SERIAL_ERR *perr)
{
CPU_INT32U reg_val;
SERIAL_DRV_REG *p_reg;
SERIAL_DEV_CFG *p_cfg;
p_cfg = pdev->Dev_Cfg;
p_reg = (SERIAL_DRV_REG *)p_cfg->BaseAddr;
reg_val = p_reg->LSR;
/* If the receive data doesn't contain data ... */
if (DEF_BIT_IS_CLR(reg_val, SERIAL_DRV_LPCXXXX_BIT_LSR_RDR)) {
*perr = SERIAL_ERR_DRV_IO_ERR;
return;
}
/* Check for Rx errors. */
if (DEF_BIT_IS_SET_ANY(reg_val, SERIAL_DRV_LPCXXXX_BIT_LSR_RX_ERR)) {
*perr = SERIAL_ERR_DRV_IO_ERR;
return;
}
*pdatum = (CPU_INT08U)(p_reg->RBR & DEF_INT_08_MASK);
*perr = SERIAL_ERR_NONE;
}
void OSTimeDlyHMSM (CPU_INT16U hours,
CPU_INT16U minutes,
CPU_INT16U seconds,
CPU_INT32U milli,
OS_OPT opt,
OS_ERR *p_err)
{
#if OS_CFG_ARG_CHK_EN > 0u
CPU_BOOLEAN opt_invalid;
CPU_BOOLEAN opt_non_strict;
#endif
OS_OPT opt_time;
OS_RATE_HZ tick_rate;
OS_TICK ticks;
CPU_SR_ALLOC();
#ifdef OS_SAFETY_CRITICAL
if (p_err == (OS_ERR *)0) {
OS_SAFETY_CRITICAL_EXCEPTION();
return;
}
#endif
#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
if (OSIntNestingCtr > (OS_NESTING_CTR)0u) { /* Not allowed to call from an ISR */
*p_err = OS_ERR_TIME_DLY_ISR;
return;
}
#endif
if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0u) { /* Can't delay when the scheduler is locked */
*p_err = OS_ERR_SCHED_LOCKED;
return;
}
opt_time = opt & OS_OPT_TIME_MASK; /* Retrieve time options only. */
switch (opt_time) {
case OS_OPT_TIME_DLY:
case OS_OPT_TIME_TIMEOUT:
case OS_OPT_TIME_PERIODIC:
if (milli == (CPU_INT32U)0u) { /* Make sure we didn't specify a 0 delay */
if (seconds == (CPU_INT16U)0u) {
if (minutes == (CPU_INT16U)0u) {
if (hours == (CPU_INT16U)0u) {
*p_err = OS_ERR_TIME_ZERO_DLY;
return;
}
}
}
}
break;
case OS_OPT_TIME_MATCH:
break;
default:
*p_err = OS_ERR_OPT_INVALID;
return;
}
#if OS_CFG_ARG_CHK_EN > 0u /* Validate arguments to be within range */
opt_invalid = DEF_BIT_IS_SET_ANY(opt, ~OS_OPT_TIME_OPTS_MASK);
if (opt_invalid == DEF_YES) {
*p_err = OS_ERR_OPT_INVALID;
return;
}
opt_non_strict = DEF_BIT_IS_SET(opt, OS_OPT_TIME_HMSM_NON_STRICT);
if (opt_non_strict != DEF_YES) {
if (milli > (CPU_INT32U)999u) {
*p_err = OS_ERR_TIME_INVALID_MILLISECONDS;
return;
}
if (seconds > (CPU_INT16U)59u) {
*p_err = OS_ERR_TIME_INVALID_SECONDS;
return;
}
if (minutes > (CPU_INT16U)59u) {
*p_err = OS_ERR_TIME_INVALID_MINUTES;
return;
}
if (hours > (CPU_INT16U)99u) {
*p_err = OS_ERR_TIME_INVALID_HOURS;
return;
}
} else {
if (minutes > (CPU_INT16U)9999u) {
*p_err = OS_ERR_TIME_INVALID_MINUTES;
return;
}
if (hours > (CPU_INT16U)999u) {
*p_err = OS_ERR_TIME_INVALID_HOURS;
return;
}
}
#endif
/* Compute the total number of clock ticks required.. */
/* .. (rounded to the nearest tick) */
tick_rate = OSCfg_TickRate_Hz;
ticks = ((OS_TICK)hours * (OS_TICK)3600u + (OS_TICK)minutes * (OS_TICK)60u + (OS_TICK)seconds) * tick_rate
+ (tick_rate * ((OS_TICK)milli + (OS_TICK)500u / tick_rate)) / (OS_TICK)1000u;
if (ticks > (OS_TICK)0u) {
OS_CRITICAL_ENTER();
OSTCBCurPtr->TaskState = OS_TASK_STATE_DLY;
OS_TickListInsert(OSTCBCurPtr,
ticks,
opt_time,
p_err);
if (*p_err != OS_ERR_NONE) {
OS_CRITICAL_EXIT_NO_SCHED();
return;
}
OS_RdyListRemove(OSTCBCurPtr); /* Remove current task from ready list */
OS_CRITICAL_EXIT_NO_SCHED();
OSSched(); /* Find next task to run! */
*p_err = OS_ERR_NONE;
} else {
*p_err = OS_ERR_TIME_ZERO_DLY;
}
}
void BSP_GPIO_Cfg (CPU_INT08U gpio_port,
CPU_INT32U gpio_pins,
CPU_INT16U gpio_opt)
{
BSP_GPIO_FAST_REG *p_gpio_fast_reg;
CPU_REG32 *p_gpio_pinsel;
CPU_REG32 *p_gpio_pinmode;
CPU_REG32 *p_gpio_pinmode_od;
CPU_INT32U pinsel_opt;
CPU_INT32U pinmode_opt;
CPU_INT32U pin_nbr;
switch (gpio_port) {
case BSP_GPIO_PORT0_FAST:
p_gpio_fast_reg = (BSP_GPIO_FAST_REG *)(BSP_GPIO_REG_PORT0_FAST_BASE_ADDR);
p_gpio_pinsel = (CPU_REG32 *)(BSP_GPIO_REG_PINSEL_BASE_ADDR + 0x00);
p_gpio_pinmode = (CPU_REG32 *)(BSP_GPIO_REG_PINMODE_BASE_ADDR + 0x00);
p_gpio_pinmode_od = (CPU_REG32 *)(BSP_GPIO_REG_PINMODE_OD0_BASE_ADDR);
break;
case BSP_GPIO_PORT1_FAST:
p_gpio_fast_reg = (BSP_GPIO_FAST_REG *)(BSP_GPIO_REG_PORT1_FAST_BASE_ADDR);
p_gpio_pinsel = (CPU_REG32 *)(BSP_GPIO_REG_PINSEL_BASE_ADDR + 0x08);
p_gpio_pinmode = (CPU_REG32 *)(BSP_GPIO_REG_PINMODE_BASE_ADDR + 0x08);
p_gpio_pinmode_od = (CPU_REG32 *)(BSP_GPIO_REG_PINMODE_OD1_BASE_ADDR);
break;
case BSP_GPIO_PORT2_FAST:
p_gpio_fast_reg = (BSP_GPIO_FAST_REG *)(BSP_GPIO_REG_PORT2_FAST_BASE_ADDR);
p_gpio_pinsel = (CPU_REG32 *)(BSP_GPIO_REG_PINSEL_BASE_ADDR + 0x10);
p_gpio_pinmode = (CPU_REG32 *)(BSP_GPIO_REG_PINMODE_BASE_ADDR + 0x10);
p_gpio_pinmode_od = (CPU_REG32 *)(BSP_GPIO_REG_PINMODE_OD2_BASE_ADDR);
break;
case BSP_GPIO_PORT3_FAST:
p_gpio_fast_reg = (BSP_GPIO_FAST_REG *)(BSP_GPIO_REG_PORT3_FAST_BASE_ADDR);
p_gpio_pinsel = (CPU_REG32 *)(BSP_GPIO_REG_PINSEL_BASE_ADDR + 0x18);
p_gpio_pinmode = (CPU_REG32 *)(BSP_GPIO_REG_PINMODE_BASE_ADDR + 0x18);
p_gpio_pinmode_od = (CPU_REG32 *)(BSP_GPIO_REG_PINMODE_OD3_BASE_ADDR);
break;
case BSP_GPIO_PORT4_FAST:
p_gpio_fast_reg = (BSP_GPIO_FAST_REG *)(BSP_GPIO_REG_PORT4_FAST_BASE_ADDR);
p_gpio_pinsel = (CPU_REG32 *)(BSP_GPIO_REG_PINSEL_BASE_ADDR + 0x20);
p_gpio_pinmode = (CPU_REG32 *)(BSP_GPIO_REG_PINMODE_BASE_ADDR + 0x20);
p_gpio_pinmode_od = (CPU_REG32 *)(BSP_GPIO_REG_PINMODE_OD4_BASE_ADDR);
break;
case BSP_GPIO_PORT0:
case BSP_GPIO_PORT1:
default:
return;
}
/* ------------ I/O DIRECTION CONFIGURATION ----------- */
if (DEF_BIT_IS_SET(gpio_opt, BSP_GPIO_OPT_OUT_EN)) {
DEF_BIT_SET(p_gpio_fast_reg->FIODIR, gpio_pins);
}
if (DEF_BIT_IS_SET(gpio_opt, BSP_GPIO_OPT_IN_EN)) {
DEF_BIT_CLR(p_gpio_fast_reg->FIODIR, gpio_pins);
}
if (DEF_BIT_IS_SET(gpio_opt, BSP_GPIO_OPT_RD_WR_EN)) {
DEF_BIT_CLR(p_gpio_fast_reg->FIOMASK, gpio_pins);
}
if (DEF_BIT_IS_SET(gpio_opt, BSP_GPIO_OPT_RD_WR_DIS)) {
DEF_BIT_SET(p_gpio_fast_reg->FIOMASK, gpio_pins);
}
/* ---- I/O MODE/PERIPHERAL FUNCTION CONFIGURATION ---- */
pinsel_opt = BSP_GPIO_OPT_FNCT_INVALID;
pinmode_opt = BSP_GPIO_OPT_MODE_INVALID;
/* Set PINSELxx based on BSP_GPIO_OPT_FNCT_xxx */
if (DEF_BIT_IS_SET_ANY(gpio_opt, BSP_GPIO_OPT_FNCT_ANY)) {
if (DEF_BIT_IS_SET(gpio_opt, BSP_GPIO_OPT_FNCT_1)) {
pinsel_opt = 0x00;
} else if (DEF_BIT_IS_SET(gpio_opt, BSP_GPIO_OPT_FNCT_2)) {
pinsel_opt = 0x01;
} else if (DEF_BIT_IS_SET(gpio_opt, BSP_GPIO_OPT_FNCT_3)) {
pinsel_opt = 0x02;
} else if (DEF_BIT_IS_SET(gpio_opt, BSP_GPIO_OPT_FNCT_4)) {
pinsel_opt = 0x03;
} else {
return;
}
}
/* Set PMODExx based on BSP_GPIO_OPT_MDOE_xxx */
if (DEF_BIT_IS_SET_ANY(gpio_opt, BSP_GPIO_OPT_MODE_ANY)) {
if (DEF_BIT_IS_SET(gpio_opt, BSP_GPIO_OPT_MODE_PULLUP)) {
pinmode_opt = 0x00;
} else if (DEF_BIT_IS_SET(gpio_opt, BSP_GPIO_OPT_MODE_REPEATER)) {
pinmode_opt = 0x01;
} else if (DEF_BIT_IS_SET(gpio_opt, BSP_GPIO_OPT_MODE_NONE)) {
pinmode_opt = 0x02;
} else if (DEF_BIT_IS_SET(gpio_opt, BSP_GPIO_OPT_MODE_PULLDOWN)) {
pinmode_opt = 0x03;
}
}
if ((pinsel_opt != BSP_GPIO_OPT_FNCT_INVALID) ||
(pinmode_opt != BSP_GPIO_OPT_MODE_INVALID)) {
for (pin_nbr = 0; pin_nbr < 32; pin_nbr++) {
if (DEF_BIT_IS_SET(gpio_pins, DEF_BIT(pin_nbr))) {
if (pinsel_opt != BSP_GPIO_OPT_FNCT_INVALID) {
if (pin_nbr < 16) {
DEF_BIT_CLR(*p_gpio_pinsel, DEF_BIT_FIELD(2, pin_nbr * 2));
DEF_BIT_SET(*p_gpio_pinsel, DEF_BIT_MASK(pinsel_opt, pin_nbr * 2));
} else {
DEF_BIT_CLR(*((CPU_REG32 *)((CPU_INT32U)p_gpio_pinsel + 0x04)), DEF_BIT_FIELD(2, (pin_nbr - 16) * 2));
DEF_BIT_SET(*((CPU_REG32 *)((CPU_INT32U)p_gpio_pinsel + 0x04)), DEF_BIT_MASK(pinsel_opt, (pin_nbr - 16) * 2));
}
}
if (DEF_BIT_IS_SET(gpio_pins, DEF_BIT(pin_nbr))) {
if (pinmode_opt != BSP_GPIO_OPT_MODE_INVALID) {
if (pin_nbr < 16) {
DEF_BIT_CLR(*p_gpio_pinmode, DEF_BIT_FIELD(2, pin_nbr * 2));
DEF_BIT_SET(*p_gpio_pinmode, DEF_BIT_MASK(pinmode_opt, pin_nbr * 2));
} else {
DEF_BIT_CLR(*((CPU_REG32 *)((CPU_INT32U)p_gpio_pinmode + 0x04)), DEF_BIT_FIELD(2, (pin_nbr - 16) * 2));
DEF_BIT_SET(*((CPU_REG32 *)((CPU_INT32U)p_gpio_pinmode + 0x04)), DEF_BIT_MASK(pinmode_opt, (pin_nbr - 16) * 2));
}
}
}
}
}
}
if (DEF_BIT_IS_SET(gpio_opt, BSP_GPIO_OPT_MODE_OPEN_DRAIN)) {
*p_gpio_pinmode_od = gpio_pins;
}
}
