int process_command(char** data){
if (!data[0]) return 0;
if (is_equal_string(data[0], "start")){
int gpio = 0;
int duty = 0;
if (!data[1] || !data[2]) return 0;
gpio = starts_with(data[1], "con:");
duty = starts_with(data[2], "duty:");
if (gpio == NA || duty == NA) return 0;
dbg_print("Starts con %d, duty %d\r\n", gpio, duty);
start_pwm(gpio, duty);
} else if (is_equal_string(data[0], "stop")){
int gpio = 0;
if (!data[1] ) return 0;
gpio = starts_with(data[1], "con:");
if (gpio == NA ) return 0;
dbg_print("Stops con %d\r\n", gpio);
stop_pwm(gpio);
} else if (is_equal_string(data[0], "period")){
int period = 0;
if (!data[1] ) return 0;
period = starts_with(data[1], "");
if (period == NA ) return 0;
dbg_print("Period %d\r\n", period);
set_period(period);
}
return 0;
}
/**
* Setup the PWM controller in serial mode on both channels using DMA to feed the PWM FIFO.
*
* @param ws2811 ws2811 instance pointer.
*
* @returns None
*/
static int setup_pwm(ws2811_t *ws2811)
{
ws2811_device_t *device = ws2811->device;
volatile dma_t *dma = device->dma;
volatile dma_cb_t *dma_cb = device->dma_cb;
volatile pwm_t *pwm = device->pwm;
volatile cm_pwm_t *cm_pwm = device->cm_pwm;
int maxcount = max_channel_led_count(ws2811);
uint32_t freq = ws2811->freq;
int32_t byte_count;
stop_pwm(ws2811);
// Setup the PWM Clock - Use OSC @ 19.2Mhz w/ 3 clocks/tick
cm_pwm->div = CM_PWM_DIV_PASSWD | CM_PWM_DIV_DIVI(OSC_FREQ / (3 * freq));
cm_pwm->ctl = CM_PWM_CTL_PASSWD | CM_PWM_CTL_SRC_OSC;
cm_pwm->ctl = CM_PWM_CTL_PASSWD | CM_PWM_CTL_SRC_OSC | CM_PWM_CTL_ENAB;
usleep(10);
while (!(cm_pwm->ctl & CM_PWM_CTL_BUSY))
;
// Setup the PWM, use delays as the block is rumored to lock up without them. Make
// sure to use a high enough priority to avoid any FIFO underruns, especially if
// the CPU is busy doing lots of memory accesses, or another DMA controller is
// busy. The FIFO will clock out data at a much slower rate (2.6Mhz max), so
// the odds of a DMA priority boost are extremely low.
pwm->rng1 = 32; // 32-bits per word to serialize
usleep(10);
pwm->ctl = RPI_PWM_CTL_CLRF1;
usleep(10);
pwm->dmac = RPI_PWM_DMAC_ENAB | RPI_PWM_DMAC_PANIC(7) | RPI_PWM_DMAC_DREQ(3);
usleep(10);
pwm->ctl = RPI_PWM_CTL_USEF1 | RPI_PWM_CTL_MODE1 |
RPI_PWM_CTL_USEF2 | RPI_PWM_CTL_MODE2;
usleep(10);
pwm->ctl |= RPI_PWM_CTL_PWEN1 | RPI_PWM_CTL_PWEN2;
// Initialize the DMA control block
byte_count = PWM_BYTE_COUNT(maxcount, freq);
dma_cb->ti = RPI_DMA_TI_NO_WIDE_BURSTS | // 32-bit transfers
RPI_DMA_TI_WAIT_RESP | // wait for write complete
RPI_DMA_TI_DEST_DREQ | // user peripheral flow control
RPI_DMA_TI_PERMAP(5) | // PWM peripheral
RPI_DMA_TI_SRC_INC; // Increment src addr
dma_cb->source_ad = addr_to_bus(device->pwm_raw);
dma_cb->dest_ad = (uint32_t)&((pwm_t *)PWM_PERIPH_PHYS)->fif1;
dma_cb->txfr_len = byte_count;
dma_cb->stride = 0;
dma_cb->nextconbk = 0;
dma->cs = 0;
dma->txfr_len = 0;
return 0;
}
/**
* Shut down DMA, PWM, and cleanup memory.
*
* @param ws2811 ws2811 instance pointer.
*
* @returns None
*/
void ws2811_fini(ws2811_t *ws2811)
{
ws2811_wait(ws2811);
stop_pwm(ws2811);
unmap_registers(ws2811);
ws2811_cleanup(ws2811);
}
void analise_command()
{
if (toupper(recvbuff[0]) == 'S' && toupper(recvbuff[1]) == 'T') {stop_pwm(); return;}
else if (toupper(recvbuff[0]) == 'T' && toupper(recvbuff[1]) == '+') {throttle_up(); return;}
else if (toupper(recvbuff[0]) == 'T' && toupper(recvbuff[1]) == '-') {throttle_down(); return;}
else if (toupper(recvbuff[0]) == 'C' && toupper(recvbuff[1]) == 'L') {sensor_calib(); return;}
else if (toupper(recvbuff[0]) == 'C' && toupper(recvbuff[1]) == 'N') {init(); sendstring("CONNECT\0"); return;}
else if (toupper(recvbuff[0]) == 'T' && toupper(recvbuff[1]) == 'M') {sendtemp(); return;}
else if (toupper(recvbuff[0]) == 'P' && toupper(recvbuff[1]) == 'R') {sendpress(); return;}
}
int main(void)
{
u8 t;
u8 len;
u8 acc_flag = 0;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
delay_init(168); //延时初始化
uart_init(115200); //串口初始化波特率为115200
LED_Init(); //初始化与LED连接的硬件接口
IIC_Init();
while(1)
{
if(USART_RX_STA&0x8000)
{
printf("\n");
len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
for(t=0;t<len;t++)
{
USART_SendData(USART2, USART_RX_BUF[t]); //向串口2发送数据
while(USART_GetFlagStatus(USART2,USART_FLAG_TC)!=SET);//等待发送结束
}
string_to_value_new();
if(COMD_FLAG != 1)
{
if(COMMAND_BUF[0]-'l' == 0 && COMMAND_BUF[1]-'e' == 0 && COMMAND_BUF[2]-'d' == 0)
{
stop_timer();
stop_pwm();
acc_flag = 0;
turn_off_led(0);
if(FACTOR[0] != 3 && FACTOR[0] != 4 && FACTOR[0] != 5 && FACTOR[0] != 6)
{
printf("\n命令错误！请重新输入！参数为3|4|5|6");
}
else
{
printf("\nLED控制: %d",FACTOR[0]);
turn_on_led(FACTOR[0]);
}
}
else if(COMMAND_BUF[0]-'p' == 0 && COMMAND_BUF[1]-'w' == 0 && COMMAND_BUF[2]-'m' == 0)
{
stop_timer();
acc_flag = 0;
turn_off_led(0);
if(FACTOR[0] - 100 > 0 || FACTOR[0] - 0 < 0)
{
printf("\n命令错误！请重新输入！参数范围在0到100");
}
else
{
printf("\nPWM占空比:%d",FACTOR[0]);
setPWMvalue(FACTOR[0]);
}
}
else if(COMMAND_BUF[0]-'t' == 0 && COMMAND_BUF[1]-'i' == 0 && COMMAND_BUF[2]-'m' == 0)
{
stop_pwm();
acc_flag = 0;
turn_off_led(0);
if(FACTOR[0] > 10000 || FACTOR[0] < 20)
{
printf("\n命令错误！请重新输入！参数范围在20到10000");
}
else
{
printf("\nTIMER定时时间：%d ",FACTOR[0]);
send_str("ms");
set_TIM3_time(FACTOR[0]);
}
}
else if(COMMAND_BUF[0]-'a' == 0 && COMMAND_BUF[1]-'c' == 0 && COMMAND_BUF[2]-'c' == 0)
{
acc_flag = 1;
if(FACTOR[0] != 0 && FACTOR[0] != 1 && FACTOR[0] != 2)
{
printf("\n参数输入有误；默认输出Z轴！");
}
}
else
{
acc_flag = 0;
turn_off_led(0);
printf("\n命令错误！请重新输入！");
}
}
}
if(acc_flag)
{
LSM303_ACC_Init();
LSM_ACC_Read();
ACC_Result_XYZ();
switch(FACTOR[0])
{
case 0:
printf("\nX轴：%f", ACC_XYZ[0]);
break;
case 1:
printf("\nY轴：%f", ACC_XYZ[1]);
break;
case 2:
printf("\nZ轴：%f.3", ACC_XYZ[2]);
break;
default:printf("\nZ轴：%f", ACC_XYZ[2]);
}
delay_ms(100);
}
};
}
int main()
{
seed_rand();
setup_mcu();
led_driver_init();
pwm_timer_init();
pir_init();
// the PIR sensor takes a few seconds
_delay_ms(5000);
sei();
uint8_t lower_pwm= 1;
uint8_t upper_pwm= 70;
uint8_t base_delay_interval= 10;
while(1)
{
while( !(PIND && PD2) );
uint8_t pins[4]= { PB1, PB2, PB3, PB4 };
uint8_t pin_starts[4];
uint8_t pin_pwm[4];
uint16_t delay_count= 0;
uint8_t still_fading= 1;
for( uint8_t i= 0; i < 4; ++i )
{
// number of base_delay_interval intervals to wait before lighting them up
pin_starts[i]= range_rand(50);
pin_pwm[i]= lower_pwm;
}
// fade them up
delay_count= 0;
still_fading= 1;
while( still_fading )
{
still_fading= 0;
for( uint8_t i= 0; i < 4; ++i )
{
if( delay_count >= pin_starts[i] && pin_pwm[i] < upper_pwm )
{
pin_pwm[i]++;
start_pwm( pins[i], pin_pwm[i] );
}
if( pin_pwm[i] < upper_pwm )
still_fading= 1;
}
_delay_ms( base_delay_interval );
delay_count++;
}
// wait for no more motion for 5 seconds
delay_count= 0;
while( delay_count < (5000/base_delay_interval) )
{
if( PIND && PD2 )
{
delay_count= 0;
continue;
}
_delay_ms( base_delay_interval );
delay_count++;
}
// fade them off
for( uint8_t i= 0; i < 4; ++i )
{
// number of base_delay_interval intervals to wait before shutting them down
pin_starts[i]= range_rand(60);
pin_pwm[i]= upper_pwm;
}
delay_count= 0;
still_fading= 1;
while( still_fading )
{
still_fading= 0;
for( uint8_t i= 0; i < 4; ++i )
{
if( delay_count >= pin_starts[i] )
{
if( pin_pwm[i] > lower_pwm )
{
pin_pwm[i]--;
start_pwm( pins[i], pin_pwm[i] );
}
if( pin_pwm[i] <= lower_pwm )
stop_pwm( pins[i] );
}
if( pin_pwm[i] > lower_pwm )
still_fading= 1;
}
_delay_ms( base_delay_interval );
delay_count++;
}
_delay_ms(2000);
}
return 0;
}
