Códigos para coleta de dados do sensor


serxmit.c
datacoll.c
serialio.c
printdec.c
analogpr.c


Listagem dos programas:


/* sermixt.c 

serial transmit test program
each time star button is pressed,
transmits 96 character ASCII set
set communications prameter to 9600 N 8 1
*/
#use printdec.c
#use serialio.c

//int SAMPLES = 1000;
//char data[1000];

void main(){
    int i;
    
    disable_pcode_serial();
    while (1){
        motor(0,100);
        motor(2,100);
        printf("Pressione Start para comecar \n");
        start_press();
        sleep(3.0);
        printf("Transmitindo... \n");
        
        //for(i = 0; i<SAMPLES; i++){
        //data[i]= analog(4);
        // printdec(data[i]);
        while(i<100){
            printdec(analog(4));
            serial_putchar(10);/*line feed*/
            serial_putchar(13);/*carriage return*/
            sleep(0.05);
            i++;            
        }
        printf("Fim da transmissao! \n");
        serial_putchar(10);
        serial_putchar(13);/*carriage return*/
        serial_putchar(10);/*line feed*/
        serial_putchar(13);/*carriage return*/
        i=0;
        sleep(3.0);
    }
}



/* 
data coll.c
Coletor e impressor de dados
*/
#use printdec.c
#use serialio.c

int SAMPLES = 1000;
char data[1000];

void main()
{
    disable_pcode_serial();
    
    printf("press Start to collect data\n");
    start_press();
    sleep(5.0);
    collect_data();
    beep();
    
    printf("press start to dump data\n");
    start_press();
    dump_data();
    beep();
    
    printf("done.\n");
}

void collect_data(){
    int i;
    
    for(i = 0; i<SAMPLES; i++){
        data[i]= analog(4);
        msleep(1L);
    }
}

void dump_data(){
    int i;
    
    for (i = 0; i <SAMPLES; i++){
        printdec(data[i]);
        serial_putchar(10);/*line feed*/
        serial_putchar(13);/*carriage return*/
    }
}



/*serialio.c

allows user interactive C programs
to send and receive serial data
*/

/*allows user programs to receive serial data*/
void disable_pcode_serial(){
    poke(0x3c, 1);
}

/*allows board interaction with IC on HOST computer*/
void enable_pcode_serial(){
    poke (0x3c, 0);
}

void serial_putchar(int c)
{
    /*wait until serial transmit empty*/
    while (!(peek(0x102e) & 0x80));
    
    /*send character*/
    poke(0x102f, c);
}

int serial_getchar(int c){
    /*wait until a character is received*/
    while(!(peek(0x102e) & 0x20));
    
    /*return it*/
    return peek(0x102f);
}
    


/*
printdec.c

routine to output an integer value
as a decimal number over the serial line

*/

/*prints number over serial line*/
#use serialio.c
void printdec(int n){
    int leading_digit = 0;
    int dig, div;
    
    for (div = 1000; div = div/10; div>0) {
        dig = n/div;
        n = n - dig*div;
        if (dig || leading_digit) {
            _printnum(dig);
            leading_digit = 1;
        }
    }
}

/*print digits from 0 to 9 over serial line */
void _printnum(int n){
    serial_putchar(n + '0');
}



/* 
analogpr.c

continuously prints analog sensor 0 over serial line

requires printdec.c, serialio.c

*/
#use printdec.c
#use serialio.c

void main(){
    disable_pcode_serial();
    while(1) {
        printdec(analog(4));
        serial_putchar(10);
        serial_putchar(13);
        
        /*waint 0.1 sec between each print */
    }
}


Estes são os arquivos para pegar os dados. O "serxmit" é contém o método MAIN(). Os outros são para configurar a máquina e imprimir em ASCII.
 
Basta baixá-los pra handboard, ligar o HIPERTERMINAL do windows, com 9600 bps, sem bit stop e sem paridade com 8 bits de dados, e apertar o botão "start" na handboard que os dados são coletados.

---------------------------------------------------

Código da interface de medidas do LDR claro/escuro:


int main(){
    while(!start_button());{
        
    while (1)
      
          {motor(0, 100);
            motor(2,100);
            printf("a2: %d a5: %d\n", analog(2), analog(5)); 
        msleep(100L);
          
        }
    }return 0;
}

----------------------------------------------------

Código do programa final (idenificar cores e seguir faixa escura) 


main.ic
seguir_linha2.ic
identificar_cores.ic


Listagem dos programas: 


#define IDENTIFICAR_CORES 1
#define SEGUIR_LINHA 2
#use seguir_linha2.ic
#use identificar_cores.ic



int main()
{
    int opcao = 0;
    
    mostrar_opcoes(&opcao);
    executar_opcao_escolhida(&opcao);
    
    return 0;
    
}


/*A funcao "mostrar_opcoes" exibe as opcoes disponiveis
  para este trabalho pratico, ou seja, exibe as seguintes 
opcoes: 1 - Seguir linha; 2 - Detectar cores*/
int mostrar_opcoes(int *opcao)
{
    
    /* a variavel "mudou" serve apenas para evitar a impressao
       continua das opcoes. Se a ultima opcao impressa nao
       mudou desde a ultam iteracao, o programa nao imprime 
       a mesma opcao novamente.*/
    int mudou;
    mudou = 0;
    
    while(1)
      {
        /*mostra opcao "IDENTIFICAR CORES" se knob() > 220.*/ 
        if(knob() > 220)
          {
            if(mudou != 1)
              {          
                printf("\n(start)         Identificar cor");
                mudou = 1;
            }
            if(start_button())
              {
                beep();
                sleep(0.3);  
                *opcao = IDENTIFICAR_CORES;
                break;
            }
        }
        
        /*mostra opcao "SEGUIR LINHA" se knob() <= 220.*/    
        else if(knob() <= 220 )
            {
              if(mudou != 2)
                {
                  printf("\n(stop)          Seguir linha");
                  mudou = 2;
              }
              if(stop_button())
                {
                  beep();
                  sleep(0.3);  
                  *opcao = SEGUIR_LINHA;
                  break;
              }
          }
    }//fim while(1)
}

/*apenas espera um pouco...*/
void aguardar()
{
    int i;
    for(i = 4; i > 0; i--)
      {
        sleep(1.5);
        printf("\nPlease wait... %d",i);
    }
    
    
    beep();
    printf("\nTudo ok!");
}


/*Executa a opcao escolhida pelo usuario*/
void executar_opcao_escolhida(int *opcao)
{
    if(*opcao == IDENTIFICAR_CORES)
      {
        detectar_cores();
    }
    else if( *opcao == SEGUIR_LINHA)
        {
          seguir_linha();
      }
      
}



/* MOTOR DIREITO e' o motor 
   mais fraco (falando em termos de potencia)*/
#define DIR_FRACO 0

/* MOTOR Esquerdo e' o motor 
   mais forte (falando em termos de potencia)*/
#define ESQ_FORTE 2

/*sentido horario ao seguir a linha*/
#define HORARIO 1

/*sentido anti-horario ao seguir a linha*/
#define ANTI_HORARIO 2

/*Valor que informa que o robo bateu na parede.
olhar a funcao "bateu_na_parede" para entender...*/
#define VALOR 220

/*valor do que o ldr retorna quando esta sob a luz*/
#define VALOR_LDR_COM_LUZ 230




/*A funcao "seguir_linha" faz com que o robo siga a linha 
preta no chao*/
void seguir_linha()
{
    /*Indica o sentido (horario ou anti-horario) em que 
    o robo deve seguir o caminho*/
    int sentido;
    
    
    printf("\nPressione start");    
    while(!start_button());
    beep();
    sleep(0.3);
    
    /*Sentido default = ANTI_HORARIO*/
    sentido = ANTI_HORARIO;
    
    
    while(1)
      {
        
        
        
        
        
        
        /*adicionei -- tirar se der problema.
          esta parte e' pra ver se bateu na parede.
          vai utilizar o analog(4) (mesmo sensor utilizado pra
          detectar cores.*/
        if(bateu_na_parede())
          {
            motor(DIR_FRACO,-100);
            motor(ESQ_FORTE,-65);
            sleep(5.0);
            motor(DIR_FRACO,-65);
            motor(ESQ_FORTE,100);
            sleep(2.0);
            if(sentido == HORARIO)
              {
                sentido = ANTI_HORARIO;
            }
            else
              {
                sentido = HORARIO;
            }
        }   
        /*a parte adicionada acaba aqui*/
        
        
        
        
        
        
        /*Isso e' apenas um comentario para lembrar a 
          localizacao das portas*/     
        /******************************************************/
        //analog(2) = direita
        //analog(5) = esquerda
        /******************************************************/
        
        
        
        
        /* Se os dois sensores(LDR's) detectam branco,
           anda em linha reta*/
        if((analog(5) < VALOR_LDR_COM_LUZ) && (analog(2) < VALOR_LDR_COM_LUZ))
          {
            motor(DIR_FRACO, 100);
            motor (ESQ_FORTE, 65);
        }
        
        
        /*Se o sensor da direita (analog(2)) detecta preto e
        o sensor da esquerda(analog(5)) detecta branco,
        vira pra direita*/
        else if(analog(5) < 230 && analog(2) > 230)
            {
              motor(DIR_FRACO, -40);
              motor (ESQ_FORTE, 100);
          }
          
          
          /*Se o sensor da direita (analog(2)) detecta branco e
        o sensor da esquerda(analog(5)) detecta preto,
        vira pra esquerda*/
          else if(analog(5) > 230 && analog(2) < 230)
              {
                motor(DIR_FRACO, 100);
                motor (ESQ_FORTE, -30);
            }
            
            
            
            /*Se os dois sensores detectam preto, vira pra direita ou
        pra esquerda dependendo do sentido definido
        (horario ou anti_horario) */
            else if((analog(5) > 230 && analog(2) > 230) )
                {
                  if( sentido == HORARIO)
                    {
                      motor(DIR_FRACO, -30);
                      motor (ESQ_FORTE, 100);
                  }
                  
                  
                  
                  
                  /*outra parte adicionada - tambm retirar se der problema
             Entra aqui se sentido = anti_horario)*/
                  else 
                    {
                      motor(DIR_FRACO, 100);
                      motor (ESQ_FORTE, -20);
                  }
                  /*acaba aqui a parte adicionada*/
                  
                  
                  
                  
                  
              }
              
    }
}



/*A funcao "bateu_na_parede" informa se o rob bateu a parede
  baseada mna informacao do sensor da porta analog(4).*/ 
int bateu_na_parede()
{
    if(analog(4) < VALOR)
      return 1;
    else
      return 0;
}



/* Variaveis globais que armazenam os valores
   basicos das cores coletados durante os testes.
   Estes valores podem ser alterados se for realizado 
   uma calibracao*/ 
float amarelo = 0.00,
azul = 0.00,
verde = 0.00,
vermelho = 0.000,
valor=0.000,
tolerancia=2.0,
T_AM=2.0,
T_VD=2.0,
T_AZ=2.0,
T_VL=2.0;



//int main()
/* A funcao "detectar_cores" avalia e imprime a cor 
   do bloco colocado na frente do sensor otico*/
void detectar_cores()
{
    printf("\nPressione start");    
    while(!start_button());
    beep();
    sleep(0.3);       
    
    /* Calibra o sensor para detectar as cores */
    calibrar();
    
    /* Calcula a tolerancia dinamicamente */
    calc_tolerancia();
    
    T_AM=T_VD=T_AZ=T_VL=tolerancia;
    
    
    //Enquanto nao aperta stop continua...
    while(!stop_button())
      {
        printf("\nPosicione o    Bloco de teste");
        while(!start_button());
        beep();
        
        valor=media_sensor();
        
        printf("\nNenhum bloco detectado");
        
        
        /* Se o bloco for amarelo */
        if(((amarelo - T_AM)<= valor) && (valor <=(amarelo + T_AM)))
          {            
            printf("\nBloco Amarelo");
            sleep(0.3);
            
        }
        
        /* Se o bloco for azul */
        else if(((azul - T_AZ)<= valor) && (valor <=(azul + T_AZ)))
            {            
              printf("\nBloco Azul");
              sleep(0.3);
             
          }
          
          /* Se o bloco for verde */  
          else if(((verde - T_VD)<= valor) && (valor <=(verde + T_VD)))
              {            
                printf("\nBloco Verde");
                sleep(0.3);
                
            }
            
            /* Se o bloco for vermelho */    
            else if(((vermelho - T_VL)<= valor) && (valor <=(vermelho + T_VL)))
                {            
                  printf("\nBloco Vermelho");
                  sleep(0.3);
              
              }
              
              /* Se nenhuma das cores foi detectada*/      
              else sleep(1.0);
        
    }//fim while(!stop_button())    
}//fim detectar_cores()


/* A funcao "calibrar" efetua a inicializacao dos parametros 
   referentes as cores de acordo com uma calibracao em 
   "tempo real"*/
void calibrar()
{
    /* Calibrando amarelo */
    printf("\nCalibrar Amarelo");
    while(!start_button());
    beep();
    amarelo = media_sensor();
    sleep(0.8);
    
    /* Calibrando azul */
    printf("\nCalibrar Azul");
    while(!start_button());
    beep();
    azul = media_sensor();
    sleep(0.8);
    
    /* Calibrando verde */
    printf("\nCalibrar Verde");
    while(!start_button());
    beep();
    verde = media_sensor();
    sleep(0.8);
    
    /* Calibrando vermelho */
    printf("\nCalibrar Vermelho");
    while(!start_button());
    beep();
    vermelho = media_sensor();       
    sleep(0.8);
    
}

float media_sensor()
{
    float aux=0.0;
    int i=0;
    
    printf("\nColetando.....");
    for (i=0;i<100;i++)
      {
        aux=aux+(float)(analog(4));
        msleep(10L);
    }
    
    return(aux/100.0);
}

void calc_tolerancia ()
{
    float menor = 255.0,
      aux=0.0;
    
    aux=abs(vermelho-verde);  
    if(menor>aux)
      menor=aux;
    
    aux=abs(vermelho-azul);  
    if(menor>aux)
      menor=aux;
    
    aux=abs(vermelho-amarelo);  
    if(menor>aux)
      menor=aux;
    
    aux=abs(verde-azul);  
    if(menor>aux)
      menor=aux;
    
    aux=abs(verde-amarelo);  
    if(menor>aux)
      menor=aux;
    
    aux=abs(azul-amarelo);  
    if(menor>aux)
      menor=aux;
    
    tolerancia=(menor/2.0)-0.1;
}

float abs(float num)
{
    if(num<0.0)
      num=(-1.0)*num;
    
    return(num);
}