示例#1
0
void setup_interrupts()
{
	enable_interrupts(GLOBAL);
	enable_interrupts(INT_RDA2);

	if(DEVICE_CONFIG.USBDETECT_ENABLE == 0) {
		IS_USB_CONNECTED = true;
		disable_interrupts(INT_EXT1); 
	} else {
		// Check initial plug state
		if(input(PIN_B1)) {
			if(DEBUG){
				fprintf(RS232,"[DEBUG] Initial state of USB is high. Setting IS_USB_CONNECTED to true\r\n");
			}
			IS_USB_CONNECTED = true;
			ext_int_edge(1,H_TO_L); 
		} else {
			if(DEBUG){
				fprintf(RS232,"[DEBUG] Initial state of USB is low. Setting IS_USB_CONNECTED to false\r\n");
			}
			ext_int_edge(1,L_TO_H); 
		}

		clear_interrupt(INT_EXT1); 
   		enable_interrupts(INT_EXT1);

	
	}
}
示例#2
0
void main()
{
clock_int_4MHz(); //Função necessária para habilitar o dual clock (48MHz para USB e 4MHz para CPU)

   disparo=read_eeprom(10);  //carrega o último valo ajustado
   if (disparo==0xff) {disparo=0; write_eeprom(10,0);} //inicio de operação após gravação

   enable_interrupts(GLOBAL);
   enable_interrupts(INT_EXT);
   //enable_interrupts(INT_EXT1);
   ext_int_edge(L_TO_H);

 while(true)
   {
   ++i; if (i>=50000) {i=0; output_toggle(pin_b7);} //Led de visualização

      if(!input(botao))//botão de incremento de fase
      {  delay_ms(100);   while(!input(botao))  delay_ms(100); //filtro botão
         disparo++; // na prática está identificando o zero só uma vez por ciclo
         if(disparo>=7) {disparo=7;} //o botão no pino E3 regula o ângulo de disparo
         write_eeprom(10, disparo);
         
      }

    if(!input(botao1))
      {  delay_ms(100);   while(!input(botao1))  delay_ms(100);
         disparo--;
         if(disparo<=1) {disparo=1;}
         write_eeprom(10, disparo);
        }

   }
}
void main()
{
    setup_comparator(NC_NC_NC_NC);// This device COMP currently not supported by the PICWizard
    // enable_interrupts(INT_EXT);
    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_256); //32.7 ms overflow
    enable_interrupts(INT_TIMER0);
    enable_interrupts(INT_RDA);
    //enable_interrupts(INT_TIMER1);
    enable_interrupts(GLOBAL);

//  setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);//128ms overflow

    ext_int_edge( H_TO_L );   // Sets up EXT
    setup_timer_1 (T1_DISABLED );
    printf("NguyenHung \n \r DT5 - K53 - DHBKHN \n \r");
    printf("Ready to use !! \n\r ");
    TC3 = 0;
    RC3 = 1;

    while(true)
    {
        if(get_timer1() > MAX_PULSE_WIDTH)
        {
            if(pulse_count>FILTER_VALUE)
            {
                printf("W");
                IDLE_MODE();
            }
        }
    }
}
示例#4
0
void main()
{

   setup_adc_ports(NO_ANALOGS|VSS_VDD);
   setup_adc(ADC_OFF);
   setup_spi(SPI_SS_DISABLED);
   setup_wdt(WDT_OFF);
   setup_timer_0(RTCC_INTERNAL);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
   enable_interrupts(INT_EXT);
   ext_int_edge(L_to_H);
   enable_interrupts(GLOBAL);
   output_low(PIN_B7);
//Setup_Oscillator parameter not selected from Intr Oscillator Config tab

   // TODO: USER CODE!!
   
   while(TRUE)
   {
   }

}
void Configurar_interrupciones(){

   enable_interrupts(INT_EXT);    // Habilita la interrupcion RB0
   ext_int_edge(L_TO_H);         // Flag INTF si flanco de bajada / H_TO_L bajada
   enable_interrupts(GLOBAL);

}
void Configurar_interrupciones() {
    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_2);   //Configuración timer0
    set_timer0 (0x00);                 //Carga del timer0
    ext_int_edge(L_TO_H);         // Flag INTF si flanco de bajada / H_TO_L bajada
    enable_interrupts(INT_EXT);   // habilitar interrupcion del RB0 /INTE
    enable_interrupts(INT_RB);   // habilitar interrupcion del RB
    enable_interrupts(GLOBAL);
}
/* Habilita los sensores segun corresponda para comenzar la lectura*/
void startReading(int sensors)
{
	// Sensor1
	if (bit_test(sensors, 0) == 1)
		sensor1 = SENSOR_ON;

	// Sensor2
	if (bit_test(sensors, 1) == 1)
		sensor2 = SENSOR_ON;

	// Sensor3
	if (bit_test(sensors, 2) == 1)
		sensor3 = SENSOR_ON;

	// Sensor4
	if (bit_test(sensors, 3) == 1)
		sensor4 = SENSOR_ON;

	// Sensor5
	if (bit_test(sensors, 4) == 1)
		sensor5 = SENSOR_ON;

	// Sensor6
#if TRIGGER_TYPE == ULTRASONIC_SENSOR
	// Sensor6 -> ULTRASONIC_SENSOR
	if (bit_test(sensors, 5) == 1)
	{
		// Comienza el pulso de habilitacion -> TRIGGER como escritura
		bit_clear(trisB_value, 0);
		set_tris_b(trisB_value);
		// Pin en estado habilitado -> envio del pulso INIT
		trigger = 1;
		delay_us(ULTRASONIC_INIT_PULSE_WIDTH_US);
		trigger = 0;
		// Termina el pulso de habilitacion -> TRIGGER como lectura
		bit_set(trisB_value, 0);
		set_tris_b(trisB_value);
		// Setea la interrupcion sobre RB0 en flanco ascendente
		ext_int_edge(L_TO_H);
		// Seteo el estado actual del pulso del sensor de ultrasonido
		usonic_state = USONIC_STATE_START;
		// Habilita la interrupcion
		enable_interrupts(INT_EXT);
	}
#elif TRIGGER_TYPE == SWITCH_SENSOR
	// Sensor6 -> SWITCH_SENSOR
	if (bit_test(sensors, 5) == 1)
	{
		if (trigger == 1)
			values[5] = 0xFFFF;
		else
			values[5] = 0;		
	} 
#endif

	return;
}	
void ACTIVE_MODE(void)
{
    disable_interrupts(INT_TIMER0);
    RC3 =1 ;
    wait(0x100);// so luyen: 01686269854
//   wait(0xffff);
    set_timer0(0);
    enable_interrupts(INT_TIMER0);
    set_timer1(0);
    enable_interrupts(INT_EXT);
    ext_int_edge( H_TO_L );   // higt to low
    pulse_count =0;
}
示例#9
0
//======================================
//Chuong trinh chinh
//======================================
void main()
{
enable_interrupts(int_rda); //Cai datngattruyen thong
ext_int_edge( H_TO_L );
   setup_timer_1(T1_INTERNAL | T1_DIV_BY_8); //Cai dat bo chia Timer 1
enable_interrupts(INT_TIMER1); //Timer1 65536
   set_timer1(3036); //Cai dat Timer 1 ngat trong 0.1s
enable_interrupts(INT_EXT);
enable_interrupts(global);
   //Datcac gia tri ban dau cho cacbien
xung = 0;
vantoc = 0;
Vdat = 0;
kp = 0;
ki = 0;
kpi = 0;
kii = 0;
kd = 0; //Bien TG khoi dong
//Cai dat vao ra
set_tris_a(0xFF);
set_tris_b(0xFF);
set_tris_c(0xc0);
set_tris_d(0x00);
delay_ms(50);
   //Cai dat ADC
setup_adc(ADC_CLOCK_INTERNAL);
setup_adc_ports(RA0_ANALOG);
set_adc_channel(0);
setup_comparator(NC_NC_NC_NC); 
setup_vref(FALSE); 
delay_ms(50);
while(1)
   {
   //Do dong dien
do_dong();
delay_ms(50); 
do_dong();
delay_ms(50);
   //Xuat len may tinh
printf("!%4.0f|%1.3f@",(float)vantoc,(float)ampe);
  }
}
示例#10
0
文件: MICROPF.c 项目: mr3m/MICRO
//Incluye las cabeceras antes descritas
void main(){                           //Rutina principal
    output_high(LED);                  //Enciende el LED indicador
    lcd_init();                         
    //Rutina de incializacion del LCD
    lcd_putc("\fListo      \n");        
    //Despliega el mensaje "Listo" en el LCD
    setup_adc_ports(AN0);               
    //Fija el pin 0 del puerto A como entrada analogica
    setup_adc (adc_clock_internal);     
    //El tiempo para la conversion AD esta dado por el oscilador 
    //interno
    set_adc_channel(0);                 //El puerto AD activo es el 0
    enable_interrupts(INT_EXT);        
    //Habilita la interrupcion externa en RB0
    ext_int_edge(L_to_H);
    //Fija la interrupcion por flanco de subida.
    setup_timer_2(T2_DIV_BY_16,129,16);
    //El tiempo de oscilacion del timer 2 sirve tanto para la
    //interrupcion por timer2 como para el PWM. 
    setup_ccp1(CCP_PWM);              
    //Da de alta el modulo CCP1 como PWM 
    //y lo inicializa en duty cycle 0
    set_pwm1_duty(0);
    setup_ccp2(CCP_PWM);
    //Da de alta el modulo CCP2 como PWM 
    //y lo inicializa en duty cycle 0
    set_pwm2_duty(0);
    enable_interrupts(GLOBAL);          
    //Habilita las interrupciones globales
    output_low(LED);        //Apaga el led antes encendido.
    
    while(TRUE){           
        //Esta rutina espera a la interrupcion y parpadea el LED
        //indicador
        output_low(LED);
        delay_ms(100);
        output_high(LED);
        delay_ms(100);
    }
   }
示例#11
0
void int_trigger(void)
{
#if TRIGGER_TYPE == ULTRASONIC_SENSOR
	if (usonic_state == USONIC_STATE_START)
	{
		// Tomo el tiempo en que comienza el pulso
		pulseStart = get_timer1();
		// Cambio el tipo de flanco
		ext_int_edge(H_TO_L);
		// Cambio el estado
		usonic_state = USONIC_STATE_STOP;
	} else {
		// Tomo el tiempo y guardo el valor
		values[5] = (get_timer1() - pulseStart)/2;
		// Deshabilita la interupcion
		disable_interrupts(INT_EXT);
	}
#elif TRIGGER_TYPE == SWITCH_SENSOR
	triggerAlarm = 1;
#endif


}
示例#12
0
void main()
{
   disable_interrupts(GLOBAL);
   
   setup_spi(SPI_MASTER | SPI_MODE_0_0 | SPI_CLK_DIV_16 );
   setup_spi2(SPI_MASTER | SPI_MODE_0_0 | SPI_CLK_DIV_16 );
   
   setup_adc_ports(sAN0|sAN1|sAN2|sAN3|sAN4|VSS_4V096);
   setup_adc(ADC_CLOCK_INTERNAL|ADC_TAD_MUL_0);

   // TIMER 0 is being used to service the WTD
   setup_timer_0(T0_INTERNAL|T0_DIV_256);
   /* sets the internal clock as source and prescale 256. 
      At 10 Mhz timer0 will increment every 0.4us (Fosc*4) in this setup and overflows every
      6.71 seconds. Timer0 defaults to 16-bit if RTCC_8_BIT is not used.
      Fosc = 10 MHz, Fosc/4 = 2.5 Mhz, div 256 = 0.0001024 s, 65536 increments = 6.71 sec
      Fosc = 64 MHz, Fosc/4 = 16 Mhz, div 256 = 0.000016 s, 65536 increments = 1.05 sec
      .. pre-load with 3036 to get exact 1.0000 sec value
   */
   
   // TIMER 1 is used to extinguish the LED
   setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
   /* sets the internal clock as source and prescale 4. 
      At 10Mhz timer0 will increment every 0.4us in this setup and overflows every
      104.8 ms. Timer1 is 16-bit.
      Fosc = 10 Mhz ... 2.5 MHz / div 4  = 0.00000160 s * 65536 = 0.104858 sec
      Fosc = 64 Mhz ... 16 MHz /  div 4  = 0.00000025 s * 65536 = 0.016384 sec
      Fosc = 64 Mhz ... 16 MHz /  div 8  = 0.00000200 s * 65536 = 0.032768 sec
   */   
   
   setup_stepper_pwm();  // Uses TIMER 2
   
   // TIMER 3 is used for stepper motor intervals
   setup_timer_3(T3_INTERNAL | T3_DIV_BY_1);   // 16 bit timer
   
   // TIMER 4 is use for serial time-outs. 8-bit timer.
   setup_timer_4(T4_DIV_BY_4, 127, 1);           
   
   setup_comparator(NC_NC_NC_NC);
   
   setup_oscillator(OSC_16MHZ | OSC_PLL_ON);  // Fosc = 64 MHz
          
   ext_int_edge(0, H_TO_L);         // Set up PIC18 EXT0
   enable_interrupts(INT_EXT);
   
   start_heartbeat();
   
   enable_interrupts(GLOBAL);

   init_hardware();
   motor_sleep_rdy();
   
   sleep_mode = FALSE;   
   busy_set();
   
   init_nv_vars();
   get_step_vars();
   init_aws();
   
   blink();
   
   //Add for TCP/IP interface
   //delay_ms(15000);
   
   signon();
   
   RTC_read();
   RTC_last_power();
   RTC_reset_HT();  
   RTC_read();    
   RTC_read_flags();
   
   if(nv_sd_status>0) fprintf(COM_A,"@SD=%Lu\r\n", nv_sd_status);
   init_rtc(); // This is the FAT RTC
   sd_status = init_sdcard();
   if(sd_status>0) msg_card_fail();
   
   reset_event();
   
   if(m_error[0] > 0 || m_error[1] > 0) msg_mer();  
   
   if (m_comp[0]==FALSE) {
      e_port[0]=0;
      write16(ADDR_E1_PORT,0);
      fprintf(COM_A, "@MC1,%Lu,%Ld\r\n", m_comp[0],e_port[0]);
   }
   if (m_comp[1]==FALSE) {
      m_lin_pos[1]=-1;
      write16(ADDR_M2_LIN_POS, -1);
      fprintf(COM_A, "@MC2,%Lu,%Ld\r\n", m_comp[1],m_lin_pos[1]);
   }
   
   if (nv_cmd_mode == FALSE){
      for(dt=0; dt<100; ++dt){
         blip();
         if (nv_cmd_mode == TRUE) {
            busy_clear();
            fputs("@OK!", COM_A);
            command_prompt();
            dt = 100;
         }
      }
   }
   else command_prompt();
   
   user_quit = auto_sample_ready();
   
   reset_cpu();
}
示例#13
0
main()   {

   ext_buffer_next_in = 0;                      // init variables
   ext_buffer_next_out = 0;

   ext_int_edge(H_TO_L);                        // init interrupts
   enable_interrupts(INT_EXT);
   enable_interrupts(GLOBAL);

   while(TRUE)                                  // loop always
   {
      int i;

      if(MESSAGE_SEND)                          // if button pushed
      {
         packet_buffer[0] = SEND_ADDRESS;
         packet_buffer[1] = MACHINE_ADDRESS;
         packet_buffer[2] = 0;
         packet_buffer[3] = 0;
         packet_buffer[4] = 9;
         packet_buffer[5] = 'H';
         packet_buffer[6] = 'i';
         packet_buffer[7] = ' ';
         packet_buffer[8] = 't';
         packet_buffer[9] = 'h';
         packet_buffer[10] = 'e';
         packet_buffer[11] = 'r';
         packet_buffer[12] = 'e';
         packet_buffer[13] = '!';
         send_packet(packet_buffer, 14);        // send message
      }

      delay_ms(100);

      if(!DATA_IN)                              // if no data in
         continue;                              // loop back

      if(get_packet(packet_buffer))             // if valid packet
      {
         int16 length,i;
         int16 CRC;

         printf("Message from unit# %U\n",packet_buffer[1]);

         length = ((int16)(packet_buffer[3]<<8)) + packet_buffer[4];

         if(packet_buffer[2] == ACK)
            printf("Previous message sent was received by unit.\n");

         if(length)                             // display message
         {
            printf("Message is:\n\n");
            for(i=0;i<length; i++)
               putc(packet_buffer[i+5]);
         }
         printf("\n\n... Message End ...\n\n\n");

         if(length)
         {
            packet_buffer[0] = packet_buffer[1];//send an ACK
            packet_buffer[1] = MACHINE_ADDRESS;
            packet_buffer[2] = ACK;
            packet_buffer[3] = 0;
            packet_buffer[4] = 0;
            send_packet(packet_buffer, 5);
         }
      }
      else                                      // if not valid packet
      {
         if(packet_buffer[0] != MACHINE_ADDRESS)
            break;                              // message is not for this PIC
         else if(packet_buffer[2] == NACK)      // tried to send and failed error
            printf("Previous message sent was not received by unit.\n");
         else
         {                                      // tried to receive and failed error
            printf("Message received was corrupted.\n");

            packet_buffer[0] = packet_buffer[1];//send a NACK
            packet_buffer[1] = MACHINE_ADDRESS;
            packet_buffer[2] = NACK;
            packet_buffer[3] = 0;
            packet_buffer[4] = 0;
            send_packet(packet_buffer, 5);

         }
      }
   }
}
示例#14
0
/* Verifica que el comando sea valido y lo ejecuta */
void doCommand(struct command_t * cmd)
{
	int crc, i, len;
		
	// Calculo del CRC
	crc = generate_8bit_crc((char *)cmd, cmd->len, CRC_PATTERN);
	
	// CRC ok?
	if (cmd->crc != crc)
	{		
		// Creo respuesta de error
		response.len = MIN_LENGTH + cmd->len + 2 + 1;
		response.to = cmd->from;
		response.from = THIS_CARD;
		response.cmd = COMMON_ERROR;
		response.data[0] = 0x00;
		// Agrego el paquete que contiene el error de CRC
		response.data[1] = cmd->len;
		response.data[2] = cmd->to;
		response.data[3] = cmd->from;
		response.data[4] = cmd->cmd;
		// Campo data
		len = cmd->len - MIN_LENGTH;
		for (i = 0; i < len; i++)
			response.data[5 + i] = (cmd->data)[i];
		// CRC erroneo
		response.data[5 + len] = cmd->crc;
		// CRC esperado
		response.data[5 + len + 1] = crc;
		// CRC de la respuesta
		response.crc = generate_8bit_crc((char *)(&response), response.len, CRC_PATTERN);
	
		crcOK = false;
		return;
	}

	crcOK = true;
	
	// Minimo todos setean esto
	response.len = MIN_LENGTH;
	response.to = cmd->from & 0x77;
	response.from = THIS_CARD;
	response.cmd = cmd->cmd | 0x80;

	switch (cmd->cmd)
	{
		// Comandos comunes
		case COMMON_INIT:
			init();
			// Enviar la descripcion de la placa en texto plano
			strcpy(response.data, DESC);
			response.len += strlen(response.data);
		break;
		case COMMON_RESET:
			// Enviar la descripcion de la placa en texto plano
			strcpy(response.data, DESC);
			response.len += strlen(response.data);
			// Reset!
			reset = true;
		break;
		case COMMON_PING:
			// No hace falta hacer mas nada
		break;
 		case COMMON_ERROR:
			// Por ahora se ignora el comando
		break;
		
		/* Comandos especificos */

 		case DISTANCE_SENSOR_ON_DISTANCE_SENSOR:
			/* Enciende el sensor de distancia indicado.
			:DATO:
			Valor de 0x00 a 0x05 que representa el ID del sensor a encender.
			El ID 0x05 hace referencia al led de la placa si esta presente, 
			en caso contrario se ignora.
			:RESP:
			-
			*/
			// Enciende los sensores segun corresponda
			if ((cmd->data)[0] == 0)
				// Sensor1
				sensor1 = SENSOR_ON;
			else if ((cmd->data)[0] == 1)
				// Sensor2
				sensor2 = SENSOR_ON;
			else if ((cmd->data)[0] == 2)
				// Sensor3
				sensor3 = SENSOR_ON;
			else if ((cmd->data)[0] == 3)
				// Sensor4
				sensor4 = SENSOR_ON;
			else if ((cmd->data)[0] == 4)
				// Sensor5
				sensor5 = SENSOR_ON;
#if TRIGGER_TYPE == LED
			else if ((cmd->data)[0] == 5)
				// Led
				led1 = 1;
#endif
		break;
 		case DISTANCE_SENSOR_OFF_DISTANCE_SENSOR:
			/* Apaga el sensor de distancia indicado.
			:DATO:
			Valor de 0x00 a 0x05 que representa el ID del sensor a apagar. El
			ID 0x05 hace referencia al sensor de ultrasonido o switch de la placa.
			:RESP:
			-
			*/
			// Apaga los sensores segun corresponda
			if ((cmd->data)[0] == 0)
				// Sensor1
				sensor1 = SENSOR_OFF;
			else if ((cmd->data)[0] == 1)
				// Sensor2
				sensor2 = SENSOR_OFF;
			else if ((cmd->data)[0] == 2)
				// Sensor3
				sensor3 = SENSOR_OFF;
			else if ((cmd->data)[0] == 3)
				// Sensor4
				sensor4 = SENSOR_OFF;
			else if ((cmd->data)[0] == 4)
				// Sensor5
				sensor5 = SENSOR_OFF;
#if TRIGGER_TYPE == LED
			else if ((cmd->data)[0] == 5)
				// Led
				led1 = 0;
#endif
		break;
 		case DISTANCE_SENSOR_SET_MASK:
			/* Habilita o deshabilita cada uno de los sensores de distancia conectados al
			controlador. Permite identificar los sensores a los que se debera tener en
			cuenta para futuras lecturas.
			:DATO:
			Valor de 0x00 a 0x3F donde cada bit representa el ID del sensor a
			habilitar o deshabilitar. Si 2^ID = 1 entonces el sensor ID esta habilitado.
			Si 2^ID = 0 entonces el sensor ID esta deshabilitado.
			:RESP:
			-
			*/
			sensorMask = (cmd->data)[0];
		break;
 		case DISTANCE_SENSOR_GET_MASK:
			/* Obtiene el estado de habilitacion de cada uno de los sensores de distancia
			conectados al controlador.
			:DATO:
			-
			:RESP:
			Valor de 0x00 a 0x3F donde cada bit representa el ID del sensor a
			habilitar o deshabilitar. Si 2^ID = 1 entonces el sensor ID esta habilitado.
			Si 2^ID = 0 entonces el sensor ID esta deshabilitado.
			*/
			// Envio la mascara de sensores
			response.data[0] = sensorMask;
			// Corrijo el largo del paquete
			response.len++;
		break;
 		case DISTANCE_SENSOR_GET_VALUE:
			/* Obtiene el valor promedio de la entrada de los sensores indicados.
			:DATO:
			Valor de 0x00 a 0x3F donde cada bit representa el ID del sensor
			del cual obtener la lectura.
			:RESP:
			Valor de 0x00 a 0x3F donde cada bit representa el ID del sensor
			del cual proviene el la lectura de distancia. Secuencia de numeros enteros
			positivos de 16 bits en el rango desde 0x0000 hasta 0x03FF, con el valor de
			la lectura que representa la distancia al objeto. En la secuencia de numeros
			el orden esta dado de izquierda a derecha comenzando por el bit menos
			significativo.
			En el caso del sensor de ultrasonido el rango es desde 0x0000 hasta 0x7594
			que representa la minima y maxima lectura del sensor.
			En el caso del switch, un estado logico bajo se lee como 0x0000 y un estado
			logico alto se lee como 0xFFFF.
			*/
			readSensor = (cmd->data)[0];
			requestFrom = 	response.to;
			requestCmd = response.cmd;
			sendResponse = false;
			samples = SAMPLES_DEFAULT;
		break;
 		case DISTANCE_SENSOR_GET_ONE_VALUE:
			/* Obtiene el valor de la entrada del sensor indicado. Igual al comando 8.5 pero
			sin realizar un promedio de lecturas.
			:DATO:
			Valor de 0x00 a 0x3F donde cada bit representa el ID del sensor
			del cual obtener la lectura.
			:RESP:
			Valor de 0x00 a 0x3F donde cada bit representa el ID del sensor
			del cual proviene el la lectura de distancia. Secuencia de numeros enteros
			positivos de 16 bits en el rango desde 0x0000 hasta 0x03FF, con el valor de
			la lectura que representa la distancia al objeto. En la secuencia de numeros
			el orden esta dado de izquierda a derecha comenzando por el bit menos
			significativo.
			En el caso del sensor de ultrasonido el rango es desde 0x0000 hasta 0x7594
			que representa la minima y maxima lectura del sensor.
			En el caso del switch, un estado logico bajo se lee como 0x0000 y un estado
			logico alto se lee como 0xFFFF.
			*/
			readSensor = (cmd->data)[0];
			requestFrom = 	response.to;
			requestCmd = response.cmd;
			sendResponse = false;
			samples = 1;
		break;
		case DISTANCE_SENSOR_ALARM_ON_STATE:
			/* Cuando un switch esta presente en el ID: 0x05, establece si se desea o no
			recibir una alarma ante cierto cambio de estado en el mismo. Puede ser ante
			cualquier cambio o sobre un anco ascendente o descendente.
			:DATO:
			Valor entre 0x00 y 0x03 con el tipo de cambio ante el cual generar
			la alarma. Con un 0x00 ignora cualquier cambio en el switch. Se utiliza
			0x01 para que cualquier cambio en el switch genere el mensaje, 0x02 para
			que sea solo ante un flanco ascendente y 0x03 para que sea solo ante un
			flanco descendente.
			:RESP:
			-
			*/
#if TRIGGER_TYPE == SWITCH_SENSOR
			switch ((cmd->data)[0])
			{
				case 0x00:
					// Ignorar
					disable_interrupts(INT_EXT);
					break;
				case 0x01:
					// Cualquier cambio
					enable_interrupts(INT_EXT);
					break;
				case 0x02:
					// flanco ascendente
					ext_int_edge(H_TO_L);
					enable_interrupts(INT_EXT);
					break;
				case 0x03:
					// flanco descendente
					ext_int_edge(L_TO_H);
					enable_interrupts(INT_EXT);
					break;
				default:
					(cmd->data)[0] = 0x00;
					break;
			}
			alarmType = (cmd->data)[0];
#endif
		break;
		default:
			response.len++;
			response.cmd = COMMON_ERROR;
			response.data[0] = 0x01; // Comando desconocido
		break;
	}	

	// CRC de la respuesta
	response.crc = generate_8bit_crc((char *)(&response), response.len, CRC_PATTERN);

	return;
}
示例#15
0
void init()
{
	// Inicializa puertos
	set_tris_a(0b11111111);
	set_tris_b(trisB_value);

	// ***ADC***
	setup_port_a(sAN0);
	setup_adc(ADC_CLOCK_INTERNAL);
	set_adc_channel(0);
	setup_adc_ports(sAN0);
	setup_vref(VREF_HIGH | 8);
	
	// Seteo el Timer1 como fuente interna
	setup_timer_1(T1_INTERNAL | T1_DIV_BY_8);
	set_timer1(26786);
	
	// Interrupcion sobre el Timer1
	enable_interrupts(INT_TIMER1);

	// Seteo el pin RB0 - Sensor de ultrasonido :)
	ext_int_edge(L_TO_H);
	enable_interrupts(INT_EXT);

	// Habilito las interrupciones
	enable_interrupts(GLOBAL);
	
	// Variable para hacer el reset
	reset = false;

	// Apaga todos los sensores
	sensor1 = SENSOR_OFF;
	sensor2 = SENSOR_OFF;
	sensor3 = SENSOR_OFF;
	sensor4 = SENSOR_OFF;
	sensor5 = SENSOR_OFF;

	// Inicializa los valores
	values[0] = 0x0000;
	values[1] = 0x0000;
	values[2] = 0x0000;
	values[3] = 0x0000;
	values[4] = 0x0000;
	values[5] = 0x0000;

	// Muestras iniciales
	samples = SAMPLES_DEFAULT;
	
	// Inicializa la mascara -> todos habilitados (0x3F)
	sensorMask = DEFAULT_MASK;
	
	//Determina el estado actual
	state = STATE_FREE;
	
	// Sin lectura temprana
	readSensor = 0x00;
	bufferedReadSensor = 0x00;
	actalTO = 0x00;
	requestFrom = 0x00;
	bufferedFrom = 0x00;
	actalCmd = 0x00;
	requestCmd = 0x00;
	bufferedCmd = 0x00;

	alarmType = 0x00;
	triggerAlarm = 0;
#if TRIGGER_TYPE == SWITCH_SENSOR
	disable_interrupts(INT_EXT);
#endif

#if TRIGGER_TYPE == LED
	// TRIGGER como escritura
	bit_clear(trisB_value, 0);
	set_tris_b(trisB_value);
#endif

	return;	
}	
示例#16
0
void Configurar_interrupciones(){
   enable_interrupts(INT_EXT);   // habilitar interrupcion del RB0 /INTE
   ext_int_edge(L_TO_H);         // Flag INTF si flanco de bajada / H_TO_L bajada
   enable_interrupts(INT_RB);
   enable_interrupts(GLOBAL);
}