int8_t module(void *state, Message *msg)
#endif
{
app_state *s = (app_state*) state;
uint8_t data[1];
switch (msg->type){
case MSG_INIT:
{
s->pid = msg->did;
s->state = BLUE_OFF_IDLE;
if (ker_pushbutton_register(s->pid)==-EINVAL) {led_red_on();}
break;
}
case MSG_PUSHBUTTON_PRESSED:
{
if (s->state == BLUE_OFF_IDLE)
{
s->state = BLUE_ON_BUSY;
s->data = 0x41;
ker_i2c_send_data(IRMAN_ADDRESS, &(s->data), 1, s->pid);
led_yellow_toggle();
}
else if (s->state == BLUE_ON_IDLE)
{
s->state = BLUE_OFF_BUSY;
s->data = 0x40;
ker_i2c_send_data(IRMAN_ADDRESS, &(s->data), 1, s->pid);
led_yellow_toggle();
}
break;
}
case MSG_I2C_SEND_DONE:
{
if (s->state == BLUE_ON_BUSY)
{
s->state = BLUE_ON_IDLE;
led_red_toggle();
}
else if (s->state == BLUE_OFF_BUSY)
{
s->state = BLUE_OFF_IDLE;
led_red_toggle();
}
break;
}
case MSG_FINAL:
{
ker_pushbutton_deregister(s->pid);
break;
}
}
return SOS_OK;
}
void slab_gc( slab_t *slab, sos_pid_t pid )
{
slab_item_t *itr = slab->head;
slab_item_t *prev = NULL;
//
// Detect memory leak while marking the memory to malloc
//
while( itr != NULL ) {
if( itr->alloc != itr->gc_mark ) {
// leak!
DEBUG_GC("leak in slab %d %d\n", itr->alloc, itr->gc_mark);
led_red_toggle();
itr->alloc = itr->gc_mark;
if( itr->alloc == 0 && itr != slab->head ) {
prev->next = itr->next;
ker_free( itr );
itr = prev;
} else {
// mark it used to malloc
itr->gc_mark = 0;
ker_gc_mark( pid, itr );
}
} else {
itr->gc_mark = 0;
ker_gc_mark( pid, itr );
}
prev = itr;
itr = itr->next;
}
}
// ------------------------------------
// Fonction permettant d'éteindre la led verte
// ------------------------------------
void led_red_off(void)
{
P1OUT &= ~LEDR; // Mise à 0 du bit 6 du port 1
// xxxx xxxx
// TODO
//
led_red_toggle();
}
// ------------------------------------
// Fonction permettant d'allumer la led verte
// ------------------------------------
void led_red_on(void)
{
P1OUT |= LEDR; // Mise à 1 du bit 6 du port 1
// xxxx xxxx
// OR 1
// 1
led_red_toggle();
}
// --------------------------
// Fonction : bllth_run
// Description : ...
// Param(s) : ...
// Output : ...
// --------------------------
uint8_t bltth_parse(void)
{
uint8_t ret = 1;
char buffer[TRAME_MAX_SIZE];/* = "-v:+100,-100;"; test*/
while(1)
{
if(uart_gets_startWithAndUntil(buffer, TRAME_CAR_START, TRAME_CAR_END, TRAME_MAX_SIZE) > 0) // Si on a reçu des caracteres
{
switch(buffer[TRAME_CMD_INDEX])
{
case TRAME_CAR_VITESSE: // Type trame recue 2 vitesse des roues
{
unsigned vitesseA=0, vitesseB=0;
/* On peut réecrire la fonction atoi pour prendre que 3 caractere si tu veux, sinon comme sa c'est plus rapide que mettre en temp */
vitesseA = (buffer[TRAME_SENSA_INDEX+1]-48)*100 +(buffer[TRAME_SENSA_INDEX+2]-48)*10 + (buffer[TRAME_SENSA_INDEX+3]-48);
vitesseB = (buffer[TRAME_SENSB_INDEX+1]-48)*100 +(buffer[TRAME_SENSB_INDEX+2]-48)*10 + (buffer[TRAME_SENSB_INDEX+3]-48);
motor_setDir(buffer[TRAME_SENSA_INDEX],buffer[TRAME_SENSB_INDEX]);
motor_setSpd(vitesseA,vitesseB);
}
break;
case TRAME_CAR_AU:
TA1CCR1 = 0;
TA1CCR2 = 0;
break;
case TRAME_CAR_LED:
if(buffer[TRAME_LEDG_INDEX] == '1')
led_green_toggle();
/*else
led_green_off();
*/
if(buffer[TRAME_LEDD_INDEX]== '1')
led_red_toggle();
/*else
led_red_off();*/
break;
default:
break;
}
}
}
/* Inutile, la lecture est une tache bloquante (attente d'un caractere), on ne peut donc pas revenir sur une trame recue.
// Clear rx buffer
memset(rx_buff, ' ', sizeof(rx_buff) );
rx_buff[sizeof(rx_buff)-1] = '\0';
*/
return ret;
}
void keyboard_task()
{
uint16_t input;
while(1)
{
input = read_inputs_image();
if(input&BUTT_0_MASK) led_green_toggle();
if(input&BUTT_1_MASK) led_red_toggle();
if(input&BUTT_2_MASK) {led_green_toggle();led_red_toggle();}
if(input&BUTT_3_MASK) {led_green_set();led_red_set();}
if(input&BUTT_4_MASK) {led_green_reset();led_red_reset();}
if(input&BUTT_5_MASK) {led_green_set();}
if(input&BUTT_6_MASK) {led_red_set();}
if(input&BUTT_7_MASK) {led_green_reset();}
if(input&BUTT_8_MASK) {led_red_reset();}
if(input&BUTT_9_MASK) {}
if(input&BUTT_F_MASK) {}
if(input&BUTT_N_MASK) {}
}
}
int8_t ker_led(uint8_t action)
{
switch (action){
case LED_RED_ON: led_red_on(); break;
case LED_GREEN_ON: led_green_on(); break;
case LED_YELLOW_ON: led_yellow_on(); break;
case LED_RED_OFF: led_red_off(); break;
case LED_GREEN_OFF: led_green_off(); break;
case LED_YELLOW_OFF: led_yellow_off(); break;
case LED_RED_TOGGLE: led_red_toggle(); break;
case LED_GREEN_TOGGLE: led_green_toggle(); break;
case LED_YELLOW_TOGGLE: led_yellow_toggle(); break;
}
return 0;
}
void fft_task( void )
{
static fixed imag[NFFT];
static uint16_t i = 0;
TASK_BEGIN();
while(1) {
TASK_SEM_WAIT(&data_ready);
led_red_toggle();
for(i = 0; i < NFFT; i++) {
imag[i] = 0;
}
// compute FFT from 512 samples, the routines takes 200 ms
fix_fft(processing_buf, imag, M, 0);
processing_buf = NULL;
led_green_toggle();
}
TASK_END();
}
void blink(void *data){
led_red_toggle();
switch (state_){
case 0:
if (lastState_!=state_){
pcd8544_fill_screen(0);
pcd8544_print(4,0, "MOVEING LINES", &vertical_byte_font_6x8);
pcd8544_print(0,1, "==============", &vertical_byte_font_6x8);
pcd8544_print(0,2, "Displays a", &vertical_byte_font_6x8);
pcd8544_print(0,3, "pattern that", &vertical_byte_font_6x8);
pcd8544_print(0,4, "tests every", &vertical_byte_font_6x8);
pcd8544_print(0,5, "pixel", &vertical_byte_font_6x8);
}
break;
case 1:
pcd8544_test(bar_);
bar_++;
if (bar_==8) bar_=0;
break;
case 2:
if (lastState_!=state_){
pcd8544_fill_screen(0);
pcd8544_print(16,0, "4 COLOURS", &vertical_byte_font_6x8);
pcd8544_print(0,1, "==============", &vertical_byte_font_6x8);
pcd8544_print(0,2, "Fakes 4 grey", &vertical_byte_font_6x8);
pcd8544_print(0,3, "shades by", &vertical_byte_font_6x8);
pcd8544_print(0,4, "flickering", &vertical_byte_font_6x8);
pcd8544_print(0,5, "the display", &vertical_byte_font_6x8);
}
break;
}
lastState_ = state_;
stateTimer_--;
if (stateTimer_==0){
state_++;
if (state_>GREY_HACK_STATE) state_=0;
stateTimer_=STATE_LENGTH;
}
}
/**
* SPI task
*/
void spi_task(void *pvParameters) {
while (1) {
if(TEST_BIT_HIGH(SSI0_SR_R, 3))
{
// Receive full
led_red_toggle();
}
if(TEST_BIT_LOW(SSI0_SR_R, 1))
{
// Send full
led_green_toggle();
}
spi_send_task();
spi_receive_task();
vTaskDelay(10);
}
}
