void exti9_5_isr(void)
{
gpio_toggle(PLED, LEDGREEN0);
exti_reset_request(EXTI5);
exti_reset_request(EXTI6);
exti_reset_request(EXTI7);
exti_reset_request(EXTI8);
exti_reset_request(EXTI9);
}
void exti9_5_isr(void)
{
/* clear EXTI */
if (EXTI_PR & EXTI6) {
exti_reset_request(EXTI6);
imu_krooz.hmc_eoc = TRUE;
}
if (EXTI_PR & EXTI5) {
exti_reset_request(EXTI5);
imu_krooz.mpu_eoc = TRUE;
}
}
/*
* Accel data ready
*/
void exti2_isr(void) {
/* clear EXTI */
exti_reset_request(EXTI2);
//adxl345_start_reading_data();
}
interrupt(PORT1_VECTOR) PORT1_ISR(void)
{
P1IFG &= ~BIT0; // Clear interrupt flag
#else
void exti2_isr(void)
{
exti_reset_request(EXTI2); // Clear interrupt flag
#endif
int s;
// set ACK payload to next squence number
ptx.data[0]++;
s = nrf_write_ack_pl(&ptx, 0);
if(s == NRF_ERR_TX_FULL) {
cio_printf("Unable to send back ACK payload (TX_FULL)\n\r");
}
// receive non-blocking since IRQ already indicates that payload arived
s = nrf_receive(&prx);
if(s == NRF_ERR_RX_FULL) {
cio_printf("Unable to receive any more (RX_FULL)\n\r");
}
else {
cio_printf("Received payload: %c; sending back %u\n\r", prx.data[0], ptx.data[0]);
}
}
void exti0_isr(void)
{
//gpio_toggle(GPIOD, GPIO12);
exti_reset_request(EXTI0);
button=1;
/*
exti_reset_request(EXTI0);
if (exti_direction == FALLING)
{
//gpio_toggle(GPIOD, GPIO13);
exti_direction = RISING;
exti_set_trigger(EXTI0, EXTI_TRIGGER_RISING);
V_hall_1_V1=0.0f;
}
else
{
//gpio_toggle(GPIOD, GPIO14);
exti_direction = FALLING;
exti_set_trigger(EXTI0, EXTI_TRIGGER_FALLING);
V_hall_1_V1=3.0f;
}
*/
}
void rtc_wkup_isr(void)
{
/* clear flag, not write protected */
RTC_ISR &= ~(RTC_ISR_WUTF);
exti_reset_request(EXTI20);
state.rtc_ticked = true;
}
//Setup hardware
TouchADS7843::TouchADS7843(void)
{
//Enable clocks
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_SPI1EN); //SPI
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPAEN); //SPI
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_IOPCEN); //PEN_INT
rcc_peripheral_enable_clock(&RCC_APB2ENR, RCC_APB2ENR_AFIOEN); //AFIO (EXTI)
//Setup GPIO
gpio_set_mode(GPIOC, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, BIT13); //PEN_INT
gpio_set_mode(GPIOA, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, BIT6); //MISO
gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, BIT4); //CS
gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_2_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, BIT5 | BIT7); //MOSI, SCK
//Set up SPI as mater
_cs(1);
spi_enable_software_slave_management(SPI1);
spi_set_nss_high(SPI1);
spi_set_baudrate_prescaler(SPI1, 7);
spi_set_clock_polarity_0(SPI1);
spi_set_clock_phase_0(SPI1);
spi_set_dff_8bit(SPI1);
spi_set_master_mode(SPI1);
spi_enable(SPI1);
//Enable PEN_INT
nvic_enable_irq(NVIC_EXTI15_10_IRQ);
exti_select_source(EXTI13, GPIOC);
exti_set_trigger(EXTI13, EXTI_TRIGGER_BOTH);
exti_reset_request(EXTI13);
exti_enable_request(EXTI13);
}
void exti2_isr(void) {
/* clear EXTI */
exti_reset_request(EXTI2);
max1168_status = MAX1168_GOT_EOC;
}
void exti9_5_isr(void)
{
if( R.STARTED == 1 )
{
ULTRA_checkEchoOnExti(EXTI9_5);
exti_reset_request(EXTI9_5); // reset flag
}
}
void exti4_isr(void)
{
exti_reset_request(EXTI4);
/* Call interrupt handler */
if (hal_irq_callback) {
(void)hal_irq_callback();
PRINTF("exti4_isr\r\n ");
}
}
/* *************** HAL API functions **************************************** */
void hal_init( void ) {
int ret = 0;
/* Reset variables used in file. */
hal_system_time = 0;
// hal_reset_flags();
/* Enable GPIOA clock. Enable AFIO clock. */
rcc_peripheral_enable_clock(&RCC_APB2ENR,
RCC_APB2ENR_IOPAEN |
RCC_APB2ENR_IOPBEN |
RCC_APB2ENR_IOPCEN |
RCC_APB2ENR_SPI1EN |
RCC_APB2ENR_AFIOEN );
/* The following pins are output pins. */
gpio_set_mode(GPIOB, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL,RST); //reset
gpio_set_mode(GPIOC, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL,SLP_TR); //sleep
gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL,SEL); //cs
gpio_set_mode(GPIOA, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL,
SCK | MOSI | MISO); //sck mosi miso
spi_disable(RF_SPI);
SPI2_I2SCFGR = 0;
/* Setup SPI parameters. */
spi_init_master(RF_SPI, SPI_CR1_BAUDRATE_FPCLK_DIV_16, SPI_CR1_CPOL_CLK_TO_0_WHEN_IDLE,
SPI_CR1_CPHA_CLK_TRANSITION_1, SPI_CR1_DFF_8BIT, SPI_CR1_MSBFIRST);
spi_set_unidirectional_mode(RF_SPI);
spi_set_full_duplex_mode(RF_SPI); /* Not receive-only */
spi_enable_software_slave_management(RF_SPI);
spi_set_nss_high(RF_SPI);
spi_enable_ss_output(RF_SPI); /* Required, see NSS, 25.3.1 section. */
/* Finally enable the SPI. */
spi_enable(RF_SPI);
/* Set GPIO4 (in GPIO port C) to 'input float'. */
gpio_set_mode(RF_IRQ_PORT, GPIO_MODE_INPUT, GPIO_CNF_INPUT_FLOAT, RF_IRQ_PIN);
gpio_clear(RF_IRQ_PORT, RF_IRQ_PIN);
/* Configure the EXTI subsystem. */
exti_select_source(EXTI4, RF_IRQ_PORT);
exti_set_trigger(EXTI4, EXTI_TRIGGER_RISING);
exti_enable_request(EXTI4);
exti_reset_request(EXTI4);
PRINTF("Enabling interrupts\r\n");
/* Enable EXTI0 interrupt. */
nvic_enable_irq(NVIC_EXTI4_IRQ);
nvic_set_priority(NVIC_EXTI4_IRQ,4);
//@@@!? timer_init();
// ret = trx_init();
// if(ret!=0)
// {
// PRINTF("rf231:hal init failed\r\n");
// }else
// {
// PRINTF("rf231:hal init success\r\n");
// }
}
/*
* Gyro data ready
*/
void exti15_10_isr(void) {
/* clear EXTI */
exti_reset_request(EXTI14);
#ifdef ASPIRIN_USE_GYRO_INT
imu_aspirin.gyro_eoc = TRUE;
imu_aspirin.status = AspirinStatusReadingGyro;
#endif
}
void exti1_isr(void)
{
if (gpio_get(JACK_SENSE_PORT,JACK_SENSE_PIN) != 0) {
speaker_shutdown();
} else {
speaker_start();
}
exti_reset_request(EXTI1);
}
void exti0_isr()
{
exti_line_state = GPIOA_IDR;
if ((exti_line_state & (1 << 0)) != 0) {
gpio_clear(GPIOC, GPIO12);
} else {
gpio_set(GPIOC, GPIO12);
}
exti_reset_request(EXTI0);
}
void exti9_5_isr(void)
{
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_PWREN);
rcc_peripheral_enable_clock(&RCC_APB1ENR, RCC_APB1ENR_BKPEN);
pwr_disable_backup_domain_write_protect();
BKP_DR2 = 0x4242;
gpio_clear(LED3_PORT, LED3_PIN);
exti_reset_request(EXTI9);
}
void exti0_isr(void)
{
exti_line_state = GPIOA_IDR;
/* The LED (PC12) is on, but turns off when the button is pressed. */
if ((exti_line_state & (1 << 0)) != 0) {
gpio_clear(GPIOC, GPIO12);
} else {
gpio_set(GPIOC, GPIO12);
}
exti_reset_request(EXTI0);
}
void exti0_isr()
{
exti_reset_request(EXTI0);
if (exti_direction == FALLING) {
gpio_set(GPIOC, GPIO12);
exti_direction = RISING;
exti_set_trigger(EXTI0, EXTI_TRIGGER_RISING);
} else {
gpio_clear(GPIOC, GPIO12);
exti_direction = FALLING;
exti_set_trigger(EXTI0, EXTI_TRIGGER_FALLING);
}
}
void BUTTON_DISCO_USER_isr(void)
{
exti_reset_request(BUTTON_DISCO_USER_EXTI);
state.pressed = true;
if (state.falling) {
state.falling = false;
exti_set_trigger(BUTTON_DISCO_USER_EXTI, EXTI_TRIGGER_RISING);
state.hold_time = TIM_CNT(TIMER_BUTTON_PRESS);
} else {
state.falling = true;
exti_set_trigger(BUTTON_DISCO_USER_EXTI, EXTI_TRIGGER_FALLING);
state.hold_time = TIM_CNT(TIMER_BUTTON_PRESS) = 0;
}
}
void exti1_isr(void)
{
uint8_t actExti = EXTI0;
if( exti_get_flag_status(actExti) != 0)
{
//gpio_toggle(PLED,LEDBLUE3);
if( R.STARTED == 1 )
{ // the robot is already alive - button does not work!
ROBOT_handleUltraEchoOnExti(EXTI1);
// flag reseting is done in ULTRA_handleEcho(..)
}
exti_reset_request(actExti); // reset flag
}
}
void exti9_5_isr(void)
{
u16 t1 = 0;
u16 t = 0;
t1 = timer_get_counter(TIM1); // get the counter(TIM1) value
exti_reset_request(_PWM_EXTI); // reset(clean) the IRQ
t = (t1>=t0) ? (t1-t0) : (65536+t1-t0); // none-stop TIM1 counter, compute ppm-signal width (2MHz = 0.5uSecond)
t0 = t1;
if (!ppmSync) { // ppm-in status : not Sync
/* (1) capture pmSync (for ppm-timing > MIN_PPMin_Sync : 3300uSecond) */
if (t>MIN_PPMin_Sync) { // ppm-input Sync-signal
if (j<3) { // set 3-times for count total channels number, k[0], k[1], k[2]
j++; // set for next count ppm-in total channels number
k[j] = 0; // initial ppm-in total channels number =0
} else { // accumulate 3-times total channels number k[0], k[1], k[2]
/* (2) count channels and set to "ppmin_num_channels" */
j = 0; // initial ppm-in Sync counter=0 (or missed signal)
k[0] = 0; // set ppm-in signal beginning k[0]=0, ignore the first count total channels number
if (k[1]>1 && k[1]==k[2]) { // compare total channels number k[1], k[2]
ppmin_num_channels = k[1]; // save number of channels found
ppmSync = 1; // in-sync
i = 0;
}
}
} else { // t<MIN_PPMin_Sync, ppm-input each Channel-signal
k[j]++; // conut 3-times for total channels number, k[0], k[1], k[2].
// ignore the first count total channels number k[0]
}
} else { // ppm-in status : Sync,
/* (3) get each channel value and set to "Channel[i]" ,
[0...ppmin_num_channels-1] for each Channel-signal */
int ch = (t - (Model.ppmin_centerpw * 2))*10000 / (Model.ppmin_deltapw * 2); //Convert input to channel value
ppmChannels[i] = ch;
i++; // set for next count ppm-signal width
/* (4) continue count channels and compare "num_channels",
if not equal => disconnect(no-Sync) and re-connect (re-Sync) */
if (t>MIN_PPMin_Sync) { // Got the ppm-input Sync-signal
if ((i-1) != ppmin_num_channels) { // Trainer disconnect (coach-trainee disconnect or noise)
ppmSync = 0; // set ppm-in status to "Not Sync"
}
i = 0; // initial counter for capture next period
}
}
}
void BUTTON_DISCO_USER_isr(void)
{
exti_reset_request(BUTTON_DISCO_USER_EXTI);
if (state.falling) {
gpio_clear(LED_DISCO_BLUE_PORT, LED_DISCO_BLUE_PIN);
state.falling = false;
exti_set_trigger(BUTTON_DISCO_USER_EXTI, EXTI_TRIGGER_RISING);
unsigned int x = TIM_CNT(TIM7);
printf("held: %u ms\n", x);
} else {
gpio_set(LED_DISCO_BLUE_PORT, LED_DISCO_BLUE_PIN);
printf("Pushed down!\n");
TIM_CNT(TIM7) = 0;
state.falling = true;
exti_set_trigger(BUTTON_DISCO_USER_EXTI, EXTI_TRIGGER_FALLING);
}
}
void RHT_isr(void)
{
exti_reset_request(RHT_EXTI);
int cnt = TIM7_CNT;
TIM7_CNT = 0;
// Skip catching ourself pulsing the start line until the 150uS start.
if (!state.seen_startbit) {
if (cnt < RHT_LOW_HIGH_THRESHOLD) {
return;
} else {
state.seen_startbit = true;
}
}
if (state.bitcount > 0) { // but skip that start bit...
stuff_bit(state.bitcount - 1, cnt, state.rht_bytes);
}
state.bitcount++;
}
//____________________________________________________
// interrupts request handlers = interrupt handler functions
void exti0_isr(void)
{
// btnStart was pressed or ultraL triggered
uint8_t actExti = EXTI0;
if( exti_get_flag_status(actExti) != 0)
{
// btn and ultra
if( R.STARTED == 0 )
{
R.STARTED = 1;
}
else
{ // the robot is already alive - button does not work!
ROBOT_handleUltraEchoOnExti(actExti);
}
exti_reset_request(actExti); // reset flag
}
}
void exti0_isr(void)
{
exti_reset_request(EXTI0);
button=1;
/*
if (exti_direction == FALLING) {
//gpio_toggle(GPIOD, GPIO13);
exti_direction = RISING;
exti_set_trigger(EXTI0, EXTI_TRIGGER_RISING);
} else {
//gpio_toggle(GPIOD, GPIO13);
exti_direction = FALLING;
exti_set_trigger(EXTI0, EXTI_TRIGGER_FALLING);
//timer_generate_event(TIM1, TIM_EGR_COMG);
//capture compare event
//timer_generate_event(TIM1, TIM_EGR_UG);
}*/
}
void exti15_10_isr(void)
{
exti_reset_request(EXTI13);
}
void exti0_isr(void)
{
exti_reset_request(EXTI0);
simrf_interrupt_handler();
}
void exti9_5_isr(void) {
exti_reset_request(EXTI5);
}
// CTS RISING ISR
void exti15_10_isr(void){
exti_reset_request(EXTI13);
(*cts_irq_handler)();
}
void BTN_BIND_ISR(void) {
exti_reset_request(BTN_BIND_EXTI);
if (button_pressed_bind != NULL)
button_pressed_bind();
}
void exti3_isr(void) {
int i, j;
uint16_t endFillByte;
gpio_set(GREEN_LED_PORT, GREEN_LED_PIN);
// gpio_set(RED_LED_PORT, RED_LED_PIN);
// iprintf("fill bytes\r\n");
exti_reset_request(EXTI3);
iprintf("exti3_isr\r\n");
if(media_file.buffer_ready[media_file.active_buffer] == 0) {
iprintf("Buffer %d was ready...\r\n", media_file.active_buffer);
while(gpio_get(CODEC_DREQ_PORT, CODEC_DREQ)) {
// iprintf("loop\r\n");
gpio_set(CODEC_PORT, CODEC_CS);
if(!media_file.near_end) {
for(i=0;i<32;i++) {
spi_xfer(CODEC_SPI, media_file.buffer[media_file.active_buffer][current_track.byte_count++]);
}
if((current_track.byte_count % 512) == 0) {
gpio_clear(CODEC_PORT, CODEC_CS);
}
if(current_track.byte_count == MEDIA_BUFFER_SIZE) {
// iprintf("reading\r\n");
sdfat_read_media();
current_track.byte_count = 0;
gpio_clear(CODEC_PORT, CODEC_CS);
// iprintf("swapping...\r\n");
/* fetch the value of current decode position */
vs1053_SCI_write(SCI_WRAMADDR, PARAM_POSITION_LO);
for(i=0;i<150;i++) {__asm__("nop\n\t");}
current_track.pos = vs1053_SCI_read(SCI_WRAM);
for(i=0;i<150;i++) {__asm__("nop\n\t");}
vs1053_SCI_write(SCI_WRAMADDR, PARAM_POSITION_HI);
for(i=0;i<150;i++) {__asm__("nop\n\t");}
current_track.pos += vs1053_SCI_read(SCI_WRAM) << 16;
// iprintf("swap\r\n");
gpio_set(CODEC_PORT, CODEC_CS);
while(media_file.buffer_ready[media_file.active_buffer]) {__asm__("nop\n\t");}
// iprintf("Breaking out\r\n");
// break;
// }
}
} else {
for(i=0;i<32;i++) {
if(current_track.byte_count > media_file.file_end) {
iprintf("ending\r\n");
// Ought to do this next bit by issuing a player_stop job so that the cleanup code
// is all in one place and we can power down everything automatically for power saving
/* now need to clean up the fifos and stop the player */
gpio_clear(CODEC_PORT, CODEC_CS);
/* fetch the value of endFillByte */
vs1053_SCI_write(SCI_WRAMADDR, PARAM_END_FILL_BYTE);
while(!gpio_get(CODEC_DREQ_PORT, CODEC_DREQ)) {__asm__("nop\n\t");}
endFillByte = vs1053_SCI_read(SCI_WRAM) & 0xFF;
iprintf("End Fill Byte %02X\r\n", endFillByte);
gpio_set(CODEC_PORT, CODEC_CS);
for(i=0;i<65;i++) {
while(!gpio_get(CODEC_DREQ_PORT, CODEC_DREQ)) {__asm__("nop\n\t");}
for(j=0;j<32;j++) {
spi_xfer(CODEC_SPI, endFillByte);
}
}
gpio_clear(CODEC_PORT, CODEC_CS);
i = vs1053_SCI_read(SCI_MODE);
i |= SM_CANCEL;
vs1053_SCI_write(SCI_MODE, i);
gpio_set(CODEC_PORT, CODEC_CS);
j = 0;
while(j < 2048) {
while(!gpio_get(CODEC_DREQ_PORT, CODEC_DREQ)) {__asm__("nop\n\t");}
for(i=0;i<32;i++) {
spi_xfer(CODEC_SPI, endFillByte);
}
j += 32;
if(!(vs1053_SCI_read(SCI_MODE) & SM_CANCEL)) {
break;
}
}
gpio_clear(CODEC_PORT, CODEC_CS);
if(j >= 2048) {
/* need to do a software reset */
vs1053_SCI_write(SCI_MODE, SM_RESET);
}
iprintf("End Fill Byte %02X\r\n", endFillByte);
current_track_playing = 0;
exti_reset_request(EXTI3);
exti_disable_request(EXTI3);
nvic_disable_irq(NVIC_EXTI3_IRQ);
return;
} else {
spi_xfer(CODEC_SPI, media_file.buffer[media_file.active_buffer][current_track.byte_count++]);
}
}
}
}
}
gpio_clear(GREEN_LED_PORT, GREEN_LED_PIN);
}
