/** * @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); }