/*******************************************************************************
* Function Name : USART1_IRQHandler
* Description : This function handles USART1 global interrupt request.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void USART1_IRQHandler(void)
{
if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) {
/* Send the received data to the PC Host*/
USART_To_USB_Send_Data();
}
/* If overrun condition occurs, clear the ORE flag and recover communication */
if (USART_GetFlagStatus(USART1, USART_FLAG_ORE) != RESET) {
(void)USART_ReceiveData(USART1);
}
#if 0
uint32_t t=1;
uint8_t value=1;
uint8_t *addr=0;
t = __STREXB(value,addr);
(void) t;
uint32_t u=1;
uint16_t value2=1;
uint16_t *addr2=0;
u = __STREXH(value2,addr2);
(void) u;
uint32_t v=1;
uint32_t value3=1;
uint32_t *addr3=0;
v = __STREXW(value3,addr3);
(void) v;
#endif
}
uint8_t core_util_atomic_decr_u8(uint8_t *valuePtr, uint8_t delta)
{
uint8_t newValue;
do {
newValue = __LDREXB((volatile uint8_t*)valuePtr) - delta;
} while (__STREXB(newValue, (volatile uint8_t*)valuePtr));
return newValue;
}
uint8_t core_util_atomic_incr_u8(volatile uint8_t *valuePtr, uint8_t delta)
{
uint8_t newValue;
do {
newValue = __LDREXB(valuePtr) + delta;
} while (__STREXB(newValue, valuePtr));
return newValue;
}
void mutex_lock(mutex_t* mutex)
{
for(;;){
if(__LDREXB(mutex) == MUTEX_LOCKED) continue;
if(__STREXB(MUTEX_LOCKED, mutex) == 0) break;
}
__DMB();
}
bool mutex_trylock(mutex_t* mutex)
{
for(;;){
if(__LDREXB(mutex) == MUTEX_LOCKED) return false;
if(__STREXB(MUTEX_LOCKED, mutex) == 0) break;
}
__DMB();
return true;
}
bool core_util_atomic_cas_u8(uint8_t *ptr, uint8_t *expectedCurrentValue, uint8_t desiredValue)
{
uint8_t currentValue = __LDREXB((volatile uint8_t*)ptr);
if (currentValue != *expectedCurrentValue) {
*expectedCurrentValue = currentValue;
__CLREX();
return false;
}
return !__STREXB(desiredValue, (volatile uint8_t*)ptr);
}
static void rsch_pending_evt_set(rsch_prio_t prio)
{
volatile uint8_t rsch_pending_evt; // Dummy variable to prevent compilers from removing ldrex
do
{
rsch_pending_evt = __LDREXB(&m_rsch_pending_evt);
(void)rsch_pending_evt;
}
while (__STREXB((uint8_t)prio, &m_rsch_pending_evt));
}
bool atomic_cas<uint8_t>(uint8_t *ptr, uint8_t *expectedCurrentValue, uint8_t desiredValue)
{
uint8_t currentValue = __LDREXB(ptr);
if (currentValue != *expectedCurrentValue) {
*expectedCurrentValue = currentValue;
__CLREX();
return false;
}
return !__STREXB(desiredValue, ptr);
}
bool core_util_atomic_cas_u8(volatile uint8_t *ptr, uint8_t *expectedCurrentValue, uint8_t desiredValue)
{
do {
uint8_t currentValue = __LDREXB(ptr);
if (currentValue != *expectedCurrentValue) {
*expectedCurrentValue = currentValue;
__CLREX();
return false;
}
} while (__STREXB(desiredValue, ptr));
return true;
}
static rsch_prio_t rsch_pending_evt_clear(void)
{
uint8_t evt_value;
do
{
evt_value = __LDREXB(&m_rsch_pending_evt);
}
while (__STREXB(RSCH_EVT_NONE, &m_rsch_pending_evt));
return (rsch_prio_t)evt_value;
}
void timer_check(void) {
for (unsigned i = 0; i < NTIMERS; i++) {
bool triggered = false;
uint8_t tmp;
do {
tmp = __LDREXB(&timer[i].flags);
triggered = (tmp & TIMER_FLAG_TRIGGERED);
if (triggered) {
tmp &= ~TIMER_FLAG_TRIGGERED;
}
} while (__STREXB(tmp, &timer[i].flags));
if (triggered) {
timer[i].timer_fn();
}
}
}
