void vBlinkerRequest(uint8_t cmd)
{
switch (cmd & CMD_MASK)
{
case CMD_LED_ON:
switch (cmd & LED_MASK)
{
case LED_RED:
LED_RED_ON();
break;
case LED_GREEN:
LED_GREEN_ON();
break;
case LED_BLUE:
LED_BLUE_ON();
break;
case LED_ALL:
LEDS_ON();
break;
}
break;
case CMD_LED_OFF:
switch (cmd & LED_MASK)
{
case LED_RED:
LED_RED_OFF();
break;
case LED_GREEN:
LED_GREEN_OFF();
break;
case LED_BLUE:
LED_BLUE_OFF();
break;
case LED_ALL:
LEDS_OFF();
break;
}
break;
case CMD_LED_TOGGLE:
switch (cmd & LED_MASK)
{
case LED_RED:
LED_RED_TOGGLE();
break;
case LED_GREEN:
LED_GREEN_TOGGLE();
break;
case LED_BLUE:
LED_BLUE_TOGGLE();
break;
case LED_ALL:
LED_RED_TOGGLE();
LED_GREEN_TOGGLE();
LED_BLUE_TOGGLE();
break;
}
break;
}
}
/**
* Generates a manual field rotation to give an initial impulse to the
* motor.
*/
int8_t bldc_start() {
unsigned long timer = START_MAX, i;
unsigned char maintain = START_MAINTAIN;
bldc_phase = 0;
DISABLE_BEMF_INT();
bldc_set_pwm(PWM_START);
bldc_set_comm();
while (1) {
for (i = 0; i < timer; i++) {
timer_wait(100);
}
timer -= START_DEC(timer);
if (timer < START_MIN) {
if (maintain) {
timer = START_MIN;
maintain--;
} else {
return 1;
}
}
bldc_set_comm();
bldc_phase++;
bldc_phase %= 6;
if (BEMF) {
LED_GREEN_TOGGLE();
}
}
return 0;
}
static THD_FUNCTION(Thread1, arg)
{
(void)arg;
chRegSetThreadName("blinker");
while (TRUE)
{
LED_GREEN_TOGGLE();
chThdSleepMilliseconds(500);
}
}
void usart3_irq_handler(void)
{
/* input (RX) handler */
if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET){
data_buf = USART_ReceiveData(USART3);
if(!gpc_handle_byte(data_buf)){
LED_GREEN_TOGGLE();
}else{
LED_RED_ON();
}
}
/* output (TX) handler */
if(USART_GetITStatus(USART3, USART_IT_TXE) != RESET){
if((data_buf = gpc_pickup_byte()) >= 0){
USART_SendData(USART3, data_buf);
LED_GREEN_TOGGLE();
}else{
usart_disable_send();
}
}
}
/*------------------------PIT Handler---------------------------*/
void PIT_IRQHandler(void)
{
if(PIT->CHANNEL[0].TFLG!=0) // Check Interrupt Timer0 Flag
{
LED_GREEN_TOGGLE(); //Toggle led green after 2s
}
if(PIT->CHANNEL[1].TFLG!=0) // Check Interrupt Timer1 Flag
{
LED_RED_TOGGLE(); //Toggle led red after 4s
}
PIT->CHANNEL[0].TFLG = 1UL; // Clear Interrupt Timer0 Flag
PIT->CHANNEL[1].TFLG = 1UL; // Clear Interrupt Timer1 Flag
}
uint16_t char_rx(uint8_t c) {
LED_GREEN_TOGGLE();
if (c=='t' || c=='l') {
LED_RED_TOGGLE();
// copy received character to cmd variable.
cmd = c;
// return not zero to wake up the CPU.
return 1;
} else {
LED_BLUE_TOGGLE();
// if not a valid command don't wake the CPU up.
return 0;
}
}
int main(void)
{
//设置NVIC中断分组2位抢占优先级，2位响应优先级
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2) ;
Ticker_Configuration();
LED_Configuration();
USART2_Configuration();
delay_init();
//Do_Loop_LED_Test();
//Do_Loop_Motor_Test();
//DISABLE_FOLLOWING_CODE(1);
//主控通信控制器初始化
Maincontrol_Configuration();
Encoder_Configuration();
Encoder_Start();
//速度采样控制器初始化
TIM2_Configuration(5);
TIM2_Start();
//电流检测
ADC_Configuration();
//电机初始化
Motor_Init();
while (1)
{
delay_ms(200);
LED_RED_TOGGLE();
LED_GREEN_TOGGLE();
}
}
/**
* Acknowledge waiting function.
*/
int rx_ack(void)
{
uint8_t length;
int retries = 0;
while ( flag == 0 )
{
if( retries == 100 ) return 0;
retries++;
}
flag = 0;
LED_GREEN_TOGGLE();
cc2420_fifo_get(&length, 1);
if ( length < 128 )
{
cc2420_fifo_get(rxframe, length);
printf("Acknowledge frame received with sequence number #%i\r\n\n", rxframe[length-3]);
LED_BLUE_TOGGLE();
}
return 1;
}
/** Functions *****************************************************************/
void updateLeds()
{
LED_GREEN_TOGGLE(); //Die gruene LED blinkt bei Daten
LED_YELLOW(ACM_CONTROL_LINE_DTR); //Funktioniert nicht so wie gedacht
LED_RED(0); //Ist einfach aus
}
/**
* The main function.
*/
int main( void )
{
/* Stop the watchdog timer. */
WDTCTL = WDTPW + WDTHOLD;
/* Setup MCLK 8MHz and SMCLK 1MHz */
set_mcu_speed_xt2_mclk_8MHz_smclk_1MHz();
/* Enable Interrupts */
eint();
uart0_init(UART0_CONFIG_1MHZ_115200);
uart0_register_callback(char_cb);
printf("CC1100 RXTX test program\r\n");
LEDS_INIT();
LEDS_OFF();
cc1100_init();
cc1100_cfg_append_status(CC1100_APPEND_STATUS_ENABLE);
cc1100_cfg_crc_autoflush(CC1100_CRC_AUTOFLUSH_DISABLE);
cc1100_cfg_white_data(CC1100_DATA_WHITENING_ENABLE);
cc1100_cfg_crc_en(CC1100_CRC_CALCULATION_ENABLE);
cc1100_cfg_freq_if(0x0C);
cc1100_cfg_fs_autocal(CC1100_AUTOCAL_NEVER);
cc1100_cfg_mod_format(CC1100_MODULATION_MSK);
cc1100_cfg_sync_mode(CC1100_SYNCMODE_30_32);
cc1100_cfg_manchester_en(CC1100_MANCHESTER_DISABLE);
printf("CC1100 initialized\r\nType 's' to send a message\r\n");
while(1)
{
// Enter RX
LED_RED_ON();
cc1100_cmd_idle();
cc1100_cmd_flush_rx();
cc1100_cmd_calibrate();
cc1100_cmd_rx();
cc1100_cfg_gdo0(CC1100_GDOx_SYNC_WORD);
cc1100_gdo0_int_set_falling_edge();
cc1100_gdo0_int_clear();
cc1100_gdo0_int_enable();
cc1100_gdo0_register_callback(rx_ok);
// Low Power Mode
LPM0;
// Check for send flag
if (send == 1) {
send = 0;
LED_RED_OFF();
cc1100_cmd_idle();
cc1100_cmd_flush_tx();
cc1100_cmd_calibrate();
cc1100_gdo0_int_disable();
frameseq ++;
length = sprintf((char *)frame, "Hello World #%i", frameseq);
printf("Sent : %s \r\n", frame);
cc1100_fifo_put(&length, 1);
cc1100_fifo_put(frame, length);
cc1100_cmd_tx();
// Wait for SYNC word sent
while (cc1100_gdo0_read() == 0);
// Wait for end of packet
while (cc1100_gdo0_read() != 0);
}
// Check for receive flag
if (receive == 1) {
receive = 0;
uint8_t i;
// verify CRC result
if ( !(cc1100_status_crc_lqi() & 0x80) ) {
continue;
}
cc1100_fifo_get(&length, 1);
if (length > 60) {
continue;
}
cc1100_fifo_get(frame, length+2);
uint16_t rssi = (uint16_t)frame[length];
int16_t rssi_d;
if (rssi >= 128)
rssi_d = (rssi-256)-140;
else
rssi_d = rssi-140;
printf("Frame received with RSSI=%d.%d dBm: ", rssi_d, 5*(rssi_d&0x1));
for (i=0; i<length; i++) {
printf("%c",frame[i]);
}
printf("\r\n");
LED_GREEN_TOGGLE();
}
}
return 0;
}
/**
* The main function.
*/
int main( void )
{
uint8_t i;
uint8_t length;
/* Stop the watchdog timer. */
WDTCTL = WDTPW + WDTHOLD;
/* Setup MCLK 8MHz and SMCLK 1MHz */
set_mcu_speed_xt2_mclk_8MHz_smclk_1MHz();
/* Enable Interrupts */
eint();
LEDS_INIT();
LEDS_ON();
uart0_init(UART0_CONFIG_1MHZ_115200);
printf("CC2420 RX test program with address recognition and acknowledge frames\r\n");
cc2420_init();
cc2420_io_sfd_register_cb(sfd_cb);
cc2420_io_sfd_int_set_falling();
cc2420_io_sfd_int_clear();
cc2420_io_sfd_int_enable();
uint8_t src_pan_id[2] = {0x22,0x00};
uint8_t src_addr[2] = {0x11,0x11};
while ( (cc2420_get_status() & 0x40) == 0 ); // waiting for xosc being stable
cc2420_set_panid(src_pan_id); // save pan id in ram
cc2420_set_shortadr(src_addr); // save short address in ram
printf("CC2420 initialized\r\n");
LEDS_OFF();
while(1)
{
cc2420_cmd_idle();
cc2420_cmd_flushrx();
cc2420_cmd_rx();
while (flag == 0) ;
micro_delay(0xFFFF);
flag = 0;
LED_GREEN_TOGGLE();
cc2420_fifo_get(&length, 1);
if ( length < 128 )
{
cc2420_fifo_get(rxframe, length);
// check CRC
if ( (rxframe[length-1] & 0x80) != 0 )
{
printf("Frame received with rssi=%ddBm:\r\n", ((signed int)((signed char)(rxframe[length-2])))-45);
LED_BLUE_TOGGLE();
// ignore 11 first bytes (fcf,seq,addr) and the 2 last ones (crc)
for (i=11; i<length-2; i++)
{
printf("%c",rxframe[i]);
}
printf("\r\n\n");
}
else {
printf("CRC non OK, erreur de transmission?\n");
printf("\r\n");
LED_RED_TOGGLE();
}
}
}
return 0;
}
/**
* Monitor the motor and control it's speed.
*/
void bldc_run() {
//wdt_enable(WDTO_2S);
uint16_t bldc_stop_detect_timer = timer_new_sw_ms(64);
uint16_t speed_report = timer_new_sw_ms(50);
while (1) {
wdt_reset();
static uint8_t uart_cmd = 0;
uint8_t ch = 0;
if (getch((char*) &ch) == UART_SUCCESS) {
if (ch <= '9' && ch >= '1') {
ch = ch - '0';
ch = ((uint16_t) ch) * 255 / 9;
bldc_set_pwm(uart_cmd = ch);
print_str("cmd:");
print_number(ch, 10);
print('\n');
} else if (ch == ',') {
print_str("=");
bldc_phase = 0;
bldc_old_phase = bldc_phase;
DISABLE_BEMF_INT();
bldc_set_pwm(5);
bldc_pwm = 0;
bldc_running = 0;
bldc_set_comm();
bldc_cnt_comm = 0;
} else if (ch == '.') {
do {
bldc_phase++;
bldc_phase %= 6;
bldc_set_comm();
bldc_cnt_comm++;
if (BEMF) {
LED_GREEN_TOGGLE();
}
for (int ee = 0; ee < 20 * 10; ee++)
timer_wait(100);
} while (bldc_phase != 0);
bldc_running = 0;
bldc_old_phase = bldc_phase;
print_str("stop.\n");
print_number(bldc_cnt_comm, 10);
} else {
// echo
while (!(UCSRA & (1 << UDRE)))
;
UDR = ch;
print_str("stop.\n");
bldc_set_pwm(0);
LED_RED_ON();
DISABLE_BEMF_INT();
bldc_running = 0;
SET_ALL_OFF();
uart_cmd = 0;
}
}
if (bldc_old_phase != bldc_phase) {
bldc_stop_detect_timer = timer_new_sw_ms(125);
bldc_running = 1;
bldc_old_phase = bldc_phase;
}
if (bldc_running && timer_sw_check(bldc_stop_detect_timer)) {
print_str("stalled\n");
LED_RED_ON();
DISABLE_BEMF_INT();
bldc_running = 0;
SET_ALL_OFF();
}
if (!bldc_running) {
LED_GREEN_OFF();
bldc_do_start = (bldc_pwm != 0);
}
if (bldc_running && timer_sw_check(speed_report)) {
const uint16_t dt = 20; //ms
speed_report = timer_new_sw_ms(dt);
static uint16_t previous_cnt = 0;
uint32_t rotations = (bldc_cnt_comm - previous_cnt);
uint32_t rps = rotations * (1000L / dt) / 66;
bldc_set_pwm(uart_cmd);
print_number(rps, 10);
print('\n');
previous_cnt = bldc_cnt_comm;
}
if (bldc_do_start) {
LED_RED_OFF();
bldc_do_start = 0;
print_str("starting...");
if (bldc_start()) {
print_str("done.\n");
LED_GREEN_ON();
bldc_running = 1;
BEMF_TOGGLE_INT();
ENABLE_BEMF_INT();
bldc_set_pwm(PWM_MIN);
bldc_stop_detect_timer = timer_new_sw_ms(75);
while (!timer_sw_check(bldc_stop_detect_timer)) {
asm("nop");
}
bldc_old_phase = 7;
} else
bldc_do_start = 1;
}
}
}
uint16_t alarm(void) {
LED_RED_TOGGLE();
LED_BLUE_TOGGLE();
LED_GREEN_TOGGLE();
return 0;
}
static void beacon(uint8_t id, uint16_t timestamp) {
LED_GREEN_TOGGLE();
}
