PUBLIC float HCSR04_read(uint8_t index)
{
float fl_distancia = 0.0;
UWord count_timer;
//limpa contador
timer_set_counter(timerM, 0);
//Pulso
digitalWrite(ultrason[index].trig, 1);
Delay_us(10);
digitalWrite(ultrason[index].trig, 0);
//ECO
while(!digitalRead(ultrason[index].eco));
timer_start(timerM,1);//start
while(digitalRead(ultrason[index].eco));
timer_start(timerM,0);//stop
//Calculo de distancia.
count_timer.value = timer_get_counter(timerM);
//fl_distancia = (float)distancia.value*0.011328;
fl_distancia = (float)count_timer.value*k;
return (fl_distancia);
}
static int command(char *command, size_t length)
{
size_t i;
calculate_crc_and_ack(command, length);
for (i = 0; i < length; i++)
usart_send_blocking(USART2, command[i]);
timer_set_counter(TIM5, 0);
timer_clear_flag(TIM5, TIM_SR_UIF);
timer_enable_counter(TIM5);
for (i = 0; i < sizeof(expect_ack); )
{
while (!timer_get_flag(TIM5, TIM_SR_UIF) &&
!usart_get_flag(USART2, USART_SR_RXNE));
if (timer_get_flag(TIM5, TIM_SR_UIF))
break;
if (expect_ack[i] != usart_recv(USART2))
break;
}
timer_disable_counter(TIM5);
return (i == sizeof(expect_ack));
}
void busy_wait(unsigned int ds)
{
timer_enable(0);
timer_set_reload(0);
timer_set_counter(get_system_frequency()/10*ds);
timer_enable(1);
while(timer_get());
}
int timer_init(tim_t dev, unsigned int ticks_per_us, void (*callback)(int))
{
PIT_Type *timer = TIMER_BASE;
/* enable timer peripheral clock */
TIMER_CLKEN();
timer->MCR = PIT_MCR_FRZ_MASK;
switch (dev) {
#if TIMER_0_EN
case TIMER_0:
NVIC_SetPriority(TIMER_0_IRQ_CHAN, TIMER_IRQ_PRIO);
timer_set_prescaler(TIMER_0_PRESCALER_CH, ticks_per_us);
timer_set_counter(TIMER_0_COUNTER_CH);
break;
#endif
#if TIMER_1_EN
case TIMER_1:
NVIC_SetPriority(TIMER_1_IRQ_CHAN, TIMER_IRQ_PRIO);
timer_set_prescaler(TIMER_1_PRESCALER_CH, ticks_per_us);
timer_set_counter(TIMER_1_COUNTER_CH);
break;
#endif
case TIMER_UNDEFINED:
default:
return -1;
}
/* set callback function */
config[dev].cb = callback;
cu_timer[dev].counter32b = 0;
cu_timer[dev].diff = 0;
/* enable the timer's interrupt */
timer_irq_enable(dev);
/* start the timer */
timer_start(dev);
return 0;
}
// init common timer
// use SOFTI2C_TIMER_1 timer
void delay_timer_init() {
rcc_periph_clock_enable(get_rcc_by_port(SOFTI2C_TIMER_1));
timer_set_prescaler(SOFTI2C_TIMER_1, 72);
timer_direction_up(SOFTI2C_TIMER_1);
timer_continuous_mode(SOFTI2C_TIMER_1);
timer_set_counter(SOFTI2C_TIMER_1, 0);
/* Start timer. */
TIM_CR1(SOFTI2C_TIMER_1) |= TIM_CR1_CEN;
timer_enable_counter(SOFTI2C_TIMER_1);
}
void delay_nus(sGrpDev* pGrpDev, uint32_t nCount) {
volatile uint16_t TIMCounter = nCount;
if (pGrpDev->pTimer) {
/* Counter enable. */
/* Reset prescaler value. */
timer_set_prescaler(pGrpDev->pTimer, 72);
timer_direction_down(pGrpDev->pTimer);
timer_enable_counter(pGrpDev->pTimer);
timer_set_counter(pGrpDev->pTimer, TIMCounter);
/* Start timer. */
TIM_CR1(pGrpDev->pTimer) |= TIM_CR1_CEN;
while (TIMCounter > 1) {
TIMCounter = timer_get_counter(pGrpDev->pTimer);
}
timer_disable_counter(pGrpDev->pTimer);
}
}
void timer_init(void)
{
// 1193180 / 1.19318MHz = 1 sec --> overflow for 16bit
// 119318 / 1.19318MHz = 100msec --> overflow for 16bit
// 59659 / 1.19318MHz = 50msec = 1/20sec
// 11932 / 1.19318MHz = 10msec = 1/100sec
// 1193 / 1.19318MHz = 1msec = 1/1000sec
// 119 / 1.19318MHz = 100micro-sec = 1/10000sec
int counter = 11932;
intr_define(0x20+PIC_IRQ_TIMER, INTR_INTR_ENTRY(timer_intr),INTR_DPL_SYSTEM);
timer_set_counter(counter);
memset(&timer_systime_counter,0,sizeof(timer_systime_counter));
return;
}
static int silence_nmea()
{
int attempt;
size_t i;
/* Configure the GPS */
for (attempt = 0; attempt < 4; attempt++)
{
calculate_crc_and_ack(set_port, sizeof(silence_nmea));
for (i = 0; i < sizeof(set_port); i++)
usart_send_blocking(USART2, set_port[i]);
timer_clear_flag(TIM5, TIM_SR_UIF);
timer_set_counter(TIM5, 0);
timer_enable_counter(TIM5);
for (i = 0; i < sizeof(expect_ack); )
{
while (!timer_get_flag(TIM5, TIM_SR_UIF) &&
!usart_get_flag(USART2, USART_SR_RXNE));
if (timer_get_flag(TIM5, TIM_SR_UIF))
break;
if (expect_ack[i] == usart_recv(USART2))
i++;
else
i = 0;
}
timer_disable_counter(TIM5);
if (i < sizeof(expect_ack))
continue;
else
break;
}
while (usart_get_flag(USART2, USART_SR_RXNE))
usart_recv(USART2);
return attempt < 4;
}
void delay_ms(sGrpDev* pGrpDev, uint32_t nCount) {
volatile uint16_t TIMCounter;// = nCount;
uint16_t cnt2;
/* Counter enable. */
/* Reset prescaler value. */
timer_set_prescaler(pGrpDev->pTimer, 7200);
timer_direction_down(pGrpDev->pTimer);
timer_enable_counter(pGrpDev->pTimer);
for (cnt2 = 0; cnt2 < 750; cnt2++) {
TIMCounter = nCount;
timer_set_counter(pGrpDev->pTimer, TIMCounter);
/* Start timer. */
TIM_CR1(pGrpDev->pTimer) |= TIM_CR1_CEN;
while (TIMCounter > 1) {
TIMCounter = timer_get_counter(pGrpDev->pTimer);
}
}
timer_disable_counter(pGrpDev->pTimer);
}
void ws2812_send( void )
{
/* init the DMA data transfer */
dma_clear_interrupt_flags( DMA1, DMA_CHANNEL2, DMA_TEIF | DMA_HTIF | DMA_TCIF | DMA_GIF);
dma_clear_interrupt_flags( DMA1, DMA_CHANNEL3, DMA_TEIF | DMA_HTIF | DMA_TCIF | DMA_GIF);
dma_clear_interrupt_flags( DMA1, DMA_CHANNEL4, DMA_TEIF | DMA_HTIF | DMA_TCIF | DMA_GIF);
dma_set_memory_address( DMA1, DMA_CHANNEL4, (uint32_t)actual_bitframe);
dma_set_number_of_data( DMA1, DMA_CHANNEL2, WS2812_BUFFERSIZE);
dma_set_number_of_data( DMA1, DMA_CHANNEL3, WS2812_BUFFERSIZE);
dma_set_number_of_data( DMA1, DMA_CHANNEL4, WS2812_BUFFERSIZE);
TIM3_SR = 0;
dma_enable_channel( DMA1, DMA_CHANNEL2);
dma_enable_channel( DMA1, DMA_CHANNEL3);
dma_enable_channel( DMA1, DMA_CHANNEL4);
//timer_enable_irq( TIM3, TIM_DIER_TDE);
timer_enable_irq( TIM3, TIM_DIER_CC1DE);
timer_enable_irq( TIM3, TIM_DIER_CC3DE);
timer_enable_irq( TIM3, TIM_DIER_UDE);
timer_set_counter(TIM3, 60);
timer_enable_counter(TIM3);
SCB_ICSR |= SCB_ICSR_PENDSVSET;
}
int main (void) {
clock_setup(); //setup the main clock for 168MHz
usart_setup(); //setup usart1 for debug messages
debug_send("\n\n\n*************************************\n");
debug_send("* Lynx test starting up *\n");
debug_send("* Waveforms *\n");
debug_send("* Joe Roberts *\n");
debug_send("* UROP - Summer 2013 *\n");
debug_send("*************************************\n\n\n");
debug_send("ledpins_setup()\n");
ledpins_setup(); //setup the status led's gpio's
debug_send("dac_setup()\n");
dac_setup(); //setup the dac gpio's
debug_send("transmit_timer_setup(1)\n");
transmit_timer_setup(1); //setup the transmit timer and its interrupt
debug_send("Starting the transmission timer\n");
timer_enable_counter(TIM2);
while(1) {
usart_wait_recv_ready(USART2);
timer_disable_counter(TIM2);
timer_set_counter(TIM2, 0);
char message = usart_recv_blocking(USART2);
debug_send("\nRecieved ");
usart_send_blocking(USART2, message);
bool done = false;
char param;
while(!done) {
debug_send(": Send your parameter [0-9]\n");
usart_wait_recv_ready(USART2);
param = usart_recv_blocking(USART2);
if((param>47)&&(param<58)) {
done = true;
param = param-48; //ASCII to number
}
else
debug_send("\nParameter must be [0-9] - try again\n");
}
if(message=='n')
n = 1000*param;
if(message=='t') {
transmit_timer_setup(10*param);
timer_enable_counter(TIM2);
}
if(message=='w')
set_waveform(param);
}
debug_send("We somehow escaped the for ever loop\n");
debug_send("..This is a little sad, there's not much you can do to fix this\n\n\n\n");
debug_send("goodbye, cruel world");
while(1);
return 1;
}
