static void ephemeris_new(ephemeris_t *e)
{
gps_time_t t = get_current_time();
if (!ephemeris_good(&es[e->sid.sat], t)) {
/* Our currently used ephemeris is bad, so we assume this is better. */
log_info("New untrusted ephemeris for PRN %02d", e->sid.sat+1);
chMtxLock(&es_mutex);
es[e->sid.sat] = es_candidate[e->sid.sat] = *e;
chMtxUnlock();
} else if (ephemeris_equal(&es_candidate[e->sid.sat], e)) {
/* The received ephemeris matches our candidate, so we trust it. */
log_info("New trusted ephemeris for PRN %02d", e->sid.sat+1);
chMtxLock(&es_mutex);
es[e->sid.sat] = *e;
chMtxUnlock();
} else {
/* This is our first reception of this new ephemeris, so treat it with
* suspicion and call it the new candidate. */
log_info("New ephemeris candidate for PRN %02d", e->sid.sat+1);
chMtxLock(&es_mutex);
es_candidate[e->sid.sat] = *e;
chMtxUnlock();
}
}
bool_t gadcLowSpeedStart(uint32_t physdev, adcsample_t *buffer, GADCCallbackFunction fn, void *param) {
struct lsdev *p;
DoInit();
/* Start the Low Speed Timer */
chMtxLock(&gadcmutex);
if (!gtimerIsActive(&LowSpeedGTimer))
gtimerStart(&LowSpeedGTimer, LowSpeedGTimerCallback, NULL, TRUE, TIME_INFINITE);
/* Find a slot */
for(p = ls; p < &ls[GADC_MAX_LOWSPEED_DEVICES]; p++) {
if (!(p->flags & GADC_FLG_ISACTIVE)) {
/* We know we have a slot - this should never wait anyway */
chSemWaitTimeout(&gadcsem, TIME_IMMEDIATE);
p->lld.physdev = physdev;
p->lld.buffer = buffer;
p->fn = fn;
p->param = param;
p->flags = GADC_FLG_ISACTIVE;
chMtxUnlock();
StartADC(FALSE);
return TRUE;
}
}
chMtxUnlock();
return FALSE;
}
static void rawd_new(struct netconn *nc)
{
int i;
int free = -1;
chMtxLock(&rawd_mutex);
/* check for existing connections */
for (i = 0; i < NC_COUNT; i++) {
if (ncs[i] == NULL) {
free = i;
} else if (ncs[i]->pcb.tcp->state != ESTABLISHED) {
/* kill stale connections */
netconn_close(ncs[i]);
netconn_delete(ncs[i]);
ncs[i] = NULL;
free = i;
}
}
if (free < 0) {
netconn_write(nc, RAWD_FULL, sizeof(RAWD_FULL) - 1, NETCONN_COPY);
netconn_close(nc);
netconn_delete(nc);
chMtxUnlock();
return;
}
ncs[free] = nc;
chMtxUnlock();
netconn_write(nc, RAWD_READY, sizeof(RAWD_READY) - 1, NETCONN_COPY);
}
/**
* Uart transmit buffer implementation
*/
void uart_put_buffer(struct uart_periph *p, long fd, const uint8_t *data, uint16_t len)
{
struct SerialInit *init_struct = (struct SerialInit*)(p->init_struct);
if (fd == 0) {
// if fd is zero, assume the driver is not already locked
// and available space should be checked
chMtxLock(init_struct->tx_mtx);
int16_t space = p->tx_extract_idx - p->tx_insert_idx;
if (space <= 0) {
space += UART_TX_BUFFER_SIZE;
}
if ((uint16_t)(space - 1) < len) {
chMtxUnlock(init_struct->tx_mtx);
return; // no room
}
}
// insert data into buffer
int i;
for (i = 0; i < len; i++) {
p->tx_buf[p->tx_insert_idx] = data[i];
p->tx_insert_idx = (p->tx_insert_idx + 1) % UART_TX_BUFFER_SIZE;
}
// unlock if needed
if (fd == 0) {
chMtxUnlock(init_struct->tx_mtx);
// send signal to start transmission
chSemSignal (init_struct->tx_sem);
}
}
uint8_t cmp_lists(uint16_t leaf, void *buf, uint8_t length)
{
chMtxLock(&tree_mtx);
uint16_t b = memory_get_ids_head(leaf);
if (b == NO_BUCKET) {
chMtxUnlock();
return 0;
}
uint64_t hash = BUCKET_READ_FIELD(b, type.id, 64);
uint8_t nb_to_send = 0;
unsigned int i = 0;
while(b != NO_NEXT && i < length)
if(hash == ((uint64_t *) buf)[i+1]) {
b = BUCKET_READ_FIELD(b, next_id, 16);
i++;
} else if(BUCKET_READ_FIELD(b, type.id, 64) < ((uint64_t *) buf)[i+1]){
i++;
} else {
((uint16_t *) buf)[nb_to_send++] = b;
b = BUCKET_READ_FIELD(b, next_id, 16);
}
while(b != NO_NEXT) {
((uint16_t *) buf)[nb_to_send++] = b;
b = BUCKET_READ_FIELD(b, next_id, 16);
}
chMtxUnlock();
return nb_to_send;
}
uint16_t tree_insert(struct Bucket *b)
{
chMtxLock(&tree_mtx);
uint16_t id = place_message(b);
if(id == MEM_FULL) {
chMtxUnlock();
return MEM_FULL;
}
update_branch(id);
chMtxUnlock();
return id;
}
static THD_FUNCTION(thread11, p) {
chMtxLock(&m2);
chMtxLock(&m1);
#if CH_CFG_USE_CONDVARS_TIMEOUT || defined(__DOXYGEN__)
chCondWaitTimeout(&c1, TIME_INFINITE);
#else
chCondWait(&c1);
#endif
test_emit_token(*(char *)p);
chMtxUnlock(&m1);
chMtxUnlock(&m2);
}
void motor_beep(int frequency, int duration_msec)
{
chMtxLock(&_mutex);
if (motor_rtctl_get_state() == MOTOR_RTCTL_STATE_IDLE) {
_state.beep_frequency = frequency;
_state.beep_duration_msec = duration_msec;
chMtxUnlock();
chEvtBroadcastFlags(&_setpoint_update_event, ALL_EVENTS); // Wake the control thread
} else {
chMtxUnlock();
}
}
/* Low priority thread */
static THD_FUNCTION(thread3L, p) {
(void)p;
chThdSleepMilliseconds(10);
chMtxLock(&m2);
test_cpu_pulse(20);
chMtxLock(&m1);
test_cpu_pulse(10);
chMtxUnlock(&m1);
test_cpu_pulse(10);
chMtxUnlock(&m2);
test_emit_token('D');
}
/* Low priority thread */
static msg_t thread3L(void *p) {
(void)p;
chThdSleepMilliseconds(10);
chMtxLock(&m2);
test_cpu_pulse(20);
chMtxLock(&m1);
test_cpu_pulse(10);
chMtxUnlock();
test_cpu_pulse(10);
chMtxUnlock();
test_emit_token('D');
return 0;
}
void geventSendEvent(GSourceListener *psl) {
chMtxLock(&geventMutex);
if (psl->pListener->callback) { // This test needs to be taken inside the mutex
chMtxUnlock();
// We already know we have the event lock
psl->pListener->callback(psl->pListener->param, &psl->pListener->event);
} else {
// Wake up the listener
if (chSemGetCounterI(&psl->pListener->waitqueue) < 0)
chSemSignal(&psl->pListener->waitqueue);
chMtxUnlock();
}
}
static msg_t thread11(void *p) {
chMtxLock(&m2);
chMtxLock(&m1);
#if CH_USE_CONDVARS_TIMEOUT || defined(__DOXYGEN__)
chCondWaitTimeout(&c1, TIME_INFINITE);
#else
chCondWait(&c1);
#endif
test_emit_token(*(char *)p);
chMtxUnlock();
chMtxUnlock();
return 0;
}
void toggleLeds( uint32_t arg )
{
chMtxLock( &mutex );
value = ( value & ( ~arg ) ) |
( (value ^ arg ) & (arg & 0x07) );
chMtxUnlock();
}
int motor_get_limit_mask(void)
{
chMtxLock(&_mutex);
int ret = _state.limit_mask;
chMtxUnlock();
return ret;
}
bool_t gdispInit(void) {
bool_t res;
unsigned i;
/* Mark all the Messages as free */
for(i=0; i < GDISP_QUEUE_SIZE; i++)
gdispMsgs[i].action = GDISP_LLD_MSG_NOP;
/* Initialise our Mailbox, Mutex's and Counting Semaphore.
* A Mutex is required as well as the Mailbox and Thread because some calls have to be synchronous.
* Synchronous calls get handled by the calling thread, asynchronous by our worker thread.
*/
chMBInit(&gdispMailbox, gdispMailboxQueue, sizeof(gdispMailboxQueue)/sizeof(gdispMailboxQueue[0]));
chMtxInit(&gdispMutex);
chMtxInit(&gdispMsgsMutex);
chSemInit(&gdispMsgsSem, GDISP_QUEUE_SIZE);
lldThread = chThdCreateStatic(waGDISPThread, sizeof(waGDISPThread), NORMALPRIO, GDISPThreadHandler, NULL);
/* Initialise driver - synchronous */
chMtxLock(&gdispMutex);
res = gdisp_lld_init();
chMtxUnlock();
return res;
}
static msg_t clarityMgmtResponseMonitoringThd(void *arg)
{
uint32_t attempts = 0;
(void)arg;
#if CH_USE_REGISTRY == TRUE
chRegSetThreadName(__FUNCTION__);
#endif
while (chThdShouldTerminate() == FALSE)
{
if (chMtxTryLock(cc3000Mtx) == TRUE)
{
chMtxUnlock();
attempts = 0;
}
else
{
attempts++;
if (attempts == CC3000_MUTEX_POLL_COUNT)
{
unresponsiveCb();
}
}
chThdSleep(MS2ST(CC3000_MUTEX_POLL_TIME_MS));
}
return CLARITY_SUCCESS;
}
void state( uint8_t index, uint32_t * val )
{
// Mutex protected.
chMtxLock( &mutex );
*val = ins[index];
chMtxUnlock();
}
static THD_FUNCTION(thread4b, p) {
(void)p;
chThdSleepMilliseconds(150);
chMtxLock(&m1);
chMtxUnlock(&m1);
}
bool motor_is_idle(void)
{
chMtxLock(&_mutex);
bool ret = motor_rtctl_get_state() == MOTOR_RTCTL_STATE_IDLE;
chMtxUnlock();
return ret;
}
void sc_extint_clear(ioportid_t port, uint8_t pin)
{
uint8_t need_stop = 1;
uint8_t i;
EXTChannelConfig cfg;
(void)port;
chMtxLock(&cfg_mtx);
chDbgAssert(pin < EXT_MAX_CHANNELS , "EXT pin number outside range");
chDbgAssert(extcfg.channels[pin].cb != NULL,
"EXT pin cb not registered");
// FIXME: should check that port matches as well?
cfg.cb = NULL;
cfg.mode = EXT_CH_MODE_DISABLED;
extSetChannelMode(&EXTD1, pin, &cfg);
for (i = 0; i < EXT_MAX_CHANNELS; ++i) {
if (extcfg.channels[pin].cb != NULL) {
need_stop = 0;
break;
}
}
if (need_stop) {
extStop(&EXTD1);
}
chMtxUnlock(&cfg_mtx);
}
int motor_test_motor(void)
{
chMtxLock(&_mutex);
const int res = motor_rtctl_test_motor();
chMtxUnlock();
return res;
}
bool motor_is_running(void)
{
chMtxLock(&_mutex);
bool ret = motor_rtctl_get_state() == MOTOR_RTCTL_STATE_RUNNING;
chMtxUnlock();
return ret;
}
static msg_t thread1(void *p) {
chMtxLock(&m1);
test_emit_token(*(char *)p);
chMtxUnlock();
return 0;
}
enum motor_control_mode motor_get_control_mode(void)
{
chMtxLock(&_mutex);
enum motor_control_mode ret = _state.mode;
chMtxUnlock();
return ret;
}
void setOutput( uint8_t index, uint32_t * val )
{
// Mutex protected.
chMtxLock( &mutex );
pendOuts[index] = *val;
chMtxUnlock();
}
static msg_t OscAutosendThread(void *arg)
{
UNUSED(arg);
uint8_t i;
const OscNode* node;
OscChannelData* chd;
while (!chThdShouldTerminate()) {
if (osc.autosendDestination == NONE) {
sleep(250);
}
else {
chd = oscGetChannelByType(osc.autosendDestination);
i = 0;
node = oscRoot.children[i++];
chMtxLock(&chd->lock);
while (node != 0) {
if (node->autosender != 0)
node->autosender(osc.autosendDestination);
node = oscRoot.children[i++];
}
oscSendPendingMessages(osc.autosendDestination);
chMtxUnlock();
sleep(osc.autosendPeriod);
}
}
return 0;
}
void clarityCC3000ApiUnlock(void)
{
if (cc3000Mtx != NULL)
{
chMtxUnlock();
}
}
static msg_t ledsThread( void *arg )
{
(void)arg;
chRegSetThreadName( "ld" );
while ( 1 )
{
static uint32_t arg;
chMtxLock( &mutex );
arg = value;
if ( arg & 1 )
palTogglePad( LED_0_PORT, LED_0_PIN );
else
palClearPad( LED_0_PORT, LED_0_PIN );
if ( arg & 2 )
palTogglePad( LED_1_PORT, LED_1_PIN );
else
palClearPad( LED_1_PORT, LED_1_PIN );
chMtxUnlock();
chThdSleepMilliseconds( DURATION_MS );
processDfu( DURATION_MS );
}
return 0;
}
static THD_FUNCTION(thread10, p) {
chMtxLock(&m1);
chCondWait(&c1);
test_emit_token(*(char *)p);
chMtxUnlock(&m1);
}
bool motor_is_blocked(void)
{
chMtxLock(&_mutex);
bool ret = _state.num_unexpected_stops >= _params.num_unexpected_stops_to_latch;
chMtxUnlock();
return ret;
}