/**
* @brief Interrupt callback to be used in the EXT driver config
* for sensor reads. Used with interrupt driven sensors.
*
* @param[in] extp Pointer to the EXTDriver object.
* @param[in] channel Pointer the ext channel.
*
*
*/
void sensors_interrupt_callback(EXTDriver *extp, expchannel_t channel)
{
const interrupt_sensor_t *p;
osalSysLockFromISR();
/* Check if the driver is in the correct state,
else disable the interrupt */
if (SRD1.state == SRD_STARTED)
{
p = extchannel2interrupt_sensor(&SRD1, channel);
if (p != NULL)
{
/* Tell the reading thread to read the sensor requested sensor */
if (queueReadI(&SRD1, &p->sensor) != MSG_OK)
{
#if SRD_DEBUG
SRD1.dbg_mailbox_overflow = true;
#endif
}
}
else
/* Something in the initial settings structures are faulty */
extChannelDisableI(extp, channel);
}
else
extChannelDisableI(extp, channel);
osalSysUnlockFromISR();
}
/**
* @brief Stops the interrupts and timers so sensors will stop
* beeing serviced. The queued sensor reads are lost as
* well.
*
* @param[in] srdp Pointer to the SensorReadDriver object.
*
* @return The operation status.
* @retval MSG_OK The disabling of interrupts and starting of the
* virtual timers was successful.
* @retval MSG_RESET The driver was not in the correct state.
*
* @api
*/
msg_t SensorReadStop(SensorReadDriver *srdp)
{
size_t i;
chDbgCheck(srdp != NULL);
if (srdp->state == SRD_STARTED)
{
osalSysLock();
/* Disable interrupts for interrupt driven sensors */
for (i = 0; i < srdp->interrupt_sensor_cnt; i++)
extChannelDisableI(&SRD_EXT_DRIVER,
srdp->interrupt_sensor_ptr[i].interrupt_channel);
/* Reset timers for polled driven sensors */
for (i = 0; i < srdp->polled_sensor_cnt; i++)
chVTResetI(srdp->polled_sensor_ptr[i].polling_vt);
osalSysUnlock();
/* Reset the mailbox */
chMBReset(&srdp->srd_mailbox);
/* Everything OK, transverse the state */
srdp->state = SRD_STOPPED;
return MSG_OK;
}
else
return MSG_RESET;
}
/*
* GPT callback.
*/
static void gptcb(GPTDriver *gptp) {
(void)gptp;
chSysLockFromIsr();
extChannelDisableI(&EXT_DRIVER, ECHO);
measure = 0xFFFF;
chSysUnlockFromIsr();
palSetPad(LED_GPIO, LED3);
}
/**
* @brief Disables an EXT channel.
* @pre The channel must not be in @p EXT_CH_MODE_DISABLED mode.
*
* @param[in] extp pointer to the @p EXTDriver object
* @param[in] channel channel to be disabled
*
* @api
*/
void extChannelDisable(EXTDriver *extp, expchannel_t channel) {
osalDbgCheck((extp != NULL) && (channel < (expchannel_t)EXT_MAX_CHANNELS));
osalSysLock();
osalDbgAssert((extp->state == EXT_ACTIVE) &&
((extp->config->channels[channel].mode &
EXT_CH_MODE_EDGES_MASK) != EXT_CH_MODE_DISABLED),
"invalid state");
extChannelDisableI(extp, channel);
osalSysUnlock();
}
/*
* Disable PLLB interrupt, enable PLLG, PLLR interrupts, switch to Blue LED
*/
void Blue_Team(void) {
//Disable further PLLB interrupts
extChannelDisableI(&EXTD1, PLLB_EXTCHAN);
//Enable PLLG, PLLR interrupts
extChannelEnableI(&EXTD1, PLLG_EXTCHAN);
extChannelEnableI(&EXTD1, PLLR_EXTCHAN);
//Change PWM frequency to PLLB Frequency
pwmChangePeriodI(&PWMD2, BLUE_PERIOD);
//Turn on Blue LED, turn off Red, Green LED's
Blue_LED();
}
/*
* Disable PLLG interrupt, enable PLLR, PLLB interrupts, switch to Green LED
*/
void Green_Team(void) {
//Disable further PLLG interrupts
extChannelDisableI(&EXTD1, PLLG_EXTCHAN);
//Enable PLLR, PLLB interrupts
extChannelEnableI(&EXTD1, PLLR_EXTCHAN);
extChannelEnableI(&EXTD1, PLLB_EXTCHAN);
//Change PWM frequency to PLLG Frequency
pwmChangePeriodI(&PWMD2, GREEN_PERIOD);
//Turn on Green LED, turn off Red, Blue LED's
Green_LED();
}
/*
* Disable PLLR interrupt, enable PLLG, PLLB interrupts, switch to Red LED
*/
void Red_Team(void) {
//Disable further PLLR interrupts
extChannelDisableI(&EXTD1, PLLR_EXTCHAN);
//Enable PLLG, PLLB interrupts
extChannelEnableI(&EXTD1, PLLG_EXTCHAN);
extChannelEnableI(&EXTD1, PLLB_EXTCHAN);
//Change PWM frequency to PLLR Frequency
pwmChangePeriodI(&PWMD2, RED_PERIOD);
//Turn on Red LED, turn off Green, Blue LED's
Red_LED();
}
/*
* GPIO_TRIGGER interrupt callback. Start transmit burst, disable additional
* transmit interrupts for TRANSMIT_LOCKOUT.
*/
static void extTransmit(EXTDriver *extp, expchannel_t channel) {
(void)extp;
(void)channel;
//Start transmitting
pwmEnableChannel(&PWMD2, 3, PWM_PERCENTAGE_TO_WIDTH(&PWMD2, 5000));
palClearPad(GPIOA, GPIO_RX);
//Disable Transmit interrupt and start timer to reenable
extChannelDisableI(&EXTD1, 0); //Disable transmit interrupt
gptStartOneShotI(&GPTD1, TRANSMIT_TIME); //Start timer for transmit
gptStartOneShotI(&GPTD3, TRANSMIT_LOCKOUT); //Start timer for transmit unlock
chSysUnlockFromIsr();
}
/*
* @brief ...
* @details ...
*/
static void dht11_lld_ext_handler(EXTDriver *extp, expchannel_t channel) {
//
(void)extp;
dht11_t *sensor = sensor_handlers[channel];
if (sensor == NULL) {
return;
}
//
if (lldLockISR(&sensor->lock) == true) {
switch (sensor->state) {
case DHT11_WAIT_RESPONSE:
sensor->bit_count++;
if (sensor->bit_count == 3) {
sensor->bit_count = 0;
sensor->data = 0;
sensor->state = DHT11_READ_DATA;
}
break;
case DHT11_READ_DATA:
sensor->bit_count++;
if (sensor->bit_count % 2 == 1) {
tmStartMeasurement(&sensor->time_measurment);
sensor->data <<= 1;
} else {
tmStopMeasurement(&sensor->time_measurment);
if (RTT2US(sensor->time_measurment.last) > 50) {
sensor->data += 1;
}
}
if (sensor->bit_count == 64) {
sensor->bit_count = 0;
sensor->crc = 0;
sensor->state = DHT11_READ_CRC;
}
break;
case DHT11_READ_CRC:
sensor->bit_count++;
//sensor->crc = sensor->crc << 1;
if (sensor->bit_count % 2 == 1) {
tmStartMeasurement(&sensor->time_measurment);
sensor->crc <<= 1;
} else {
tmStopMeasurement(&sensor->time_measurment);
if (RTT2US(sensor->time_measurment.last) > 40) {
sensor->crc += 1;
}
}
if (sensor->bit_count == 16) {
chSysLockFromIsr();
extChannelDisableI(sensor->ext_drv, sensor->ext_pin);
if (chVTIsArmedI(&sensor->timer) == true) {
chVTResetI(&sensor->timer);
}
chSysUnlockFromIsr();
sensor->temp = (sensor->data & 0xFF00) >> 8;
sensor->humidity = (sensor->data & 0xFF000000) >> 24;
sensor->state = DHT11_READ_OK;
}
break;
case DHT11_UNINIT:
case DHT11_IDLE:
case DHT11_READ_REQUEST:
case DHT11_READ_OK:
case DHT11_BUSY:
case DHT11_ERROR:
break;
}
lldUnlockISR(&sensor->lock);
}
