Пример #1
0
void ADC0_IRQHandler (void)
{
   uint16_t value;
   uint32_t index = 0; // always using ADC0

	if(Chip_ADC_ReadStatus(adcsData[index].adc, ADC_CH1, ADC_DR_ADINT_STAT) == SET)
	{
	    Chip_ADC_ReadValue(adcsData[index].adc, ADC_CH1, &value);
	    ADCValues[0] = value;
        }

	if(Chip_ADC_ReadStatus(adcsData[index].adc, ADC_CH2, ADC_DR_ADINT_STAT) == SET)
	{
            Chip_ADC_ReadValue(adcsData[index].adc, ADC_CH2, &value);
            ADCValues[1] = value;
	}

	if(Chip_ADC_ReadStatus(adcsData[index].adc, ADC_CH3, ADC_DR_ADINT_STAT) == SET) 
	{
            Chip_ADC_ReadValue(adcsData[index].adc, ADC_CH3, &value);
            ADCValues[2] = value;
	}

   flagWaitingADCConv=0;
}
Пример #2
0
static uint16_t readADC(uint8_t id)
{
	uint16_t dataADC;
	uint16_t first;
	Chip_ADC_EnableChannel(LPC_ADC, id, ENABLE);
    Chip_ADC_SetStartMode(LPC_ADC, ADC_START_NOW, ADC_TRIGGERMODE_RISING);

	/* Waiting for A/D conversion complete */
	while (Chip_ADC_ReadStatus(LPC_ADC, id, ADC_DR_DONE_STAT) != SET) {}
	/* Read ADC value */
	Chip_ADC_ReadValue(LPC_ADC, id, &first);

	Chip_ADC_SetStartMode(LPC_ADC, ADC_START_NOW, ADC_TRIGGERMODE_RISING);

		/* Waiting for A/D conversion complete */
	while (Chip_ADC_ReadStatus(LPC_ADC, id, ADC_DR_DONE_STAT) != SET) {}
		/* Read ADC value */
	Chip_ADC_ReadValue(LPC_ADC, id, &dataADC);

	int32_t diff = first - dataADC;
	if(diff < 0 ) diff = -diff;
	while(diff > 200) {
		first = dataADC;
		Chip_ADC_SetStartMode(LPC_ADC, ADC_START_NOW, ADC_TRIGGERMODE_RISING);

				/* Waiting for A/D conversion complete */
		while (Chip_ADC_ReadStatus(LPC_ADC, id, ADC_DR_DONE_STAT) != SET) {}
				/* Read ADC value */
		Chip_ADC_ReadValue(LPC_ADC, id, &dataADC);
		diff = first - dataADC;
		if(diff < 0 ) diff = -diff;
	}
	Chip_ADC_EnableChannel(LPC_ADC, id, DISABLE);
	return dataADC;
}
Пример #3
0
void ADC_IRQHandler(void)
#endif
{
	static uint16_t data;
	Chip_ADC_ReadValue(LPC_ADC, ADC_CH1, &data);

#ifdef lpc4337_m4
	static uint32_t cont;
	cont++;
	if (cont == 4) {
		cont = 0;
#if(USAR_FUNCIONES_ASSEMBLER)
		asm_fir_q31_put(&filtro, data);
#else
		fir_q31_put(&filtro, data);
#endif
	}
#else
#if(USAR_FUNCIONES_ASSEMBLER)
	asm_fir_q31_put(&filtro, data>>2);
#else
	fir_q31_put(&filtro, data>>2);
#endif
#endif
	adcFlag=1;
}
Пример #4
0
/* Polling routine for ADC example */
static void App_Polling_Test(void)
{
	uint16_t dataADC;

	/* Select using burst mode or not */
	if (Burst_Mode_Flag) {
		Chip_ADC_SetBurstCmd(_LPC_ADC_ID, ENABLE);
	}
	else {
		Chip_ADC_SetBurstCmd(_LPC_ADC_ID, DISABLE);
	}

	/* Get  adc value until get 'x' character */
	while (DEBUGIN() != 'x') {
		/* Start A/D conversion if not using burst mode */
		if (!Burst_Mode_Flag) {
			Chip_ADC_SetStartMode(_LPC_ADC_ID, ADC_START_NOW, ADC_TRIGGERMODE_RISING);
		}
		/* Waiting for A/D conversion complete */
		while (Chip_ADC_ReadStatus(_LPC_ADC_ID, _ADC_CHANNLE, ADC_DR_DONE_STAT) != SET) {}
		/* Read ADC value */
		Chip_ADC_ReadValue(_LPC_ADC_ID, _ADC_CHANNLE, &dataADC);
		/* Print ADC value */
		App_print_ADC_value(dataADC);
	}

	/* Disable burst mode, if any */
	if (Burst_Mode_Flag) {
		Chip_ADC_SetBurstCmd(_LPC_ADC_ID, DISABLE);
	}
}
Пример #5
0
uint16_t LeerCanalADC(int canal){
	uint16_t* datos;
	Chip_ADC_SetStartMode(LPC_ADC0, ADC_START_NOW, ADC_TRIGGERMODE_RISING);
	while(Chip_ADC_ReadStatus(LPC_ADC0,ADC_CH1,ADC_DR_DONE_STAT)!=SET);
	Chip_ADC_ReadValue(LPC_ADC0, ADC_CH1, &datos);
	return datos;
};
Пример #6
0
uint16_t readAdc (const adc_t adcNumber)
{
	uint16_t dataADC = 0;

	if ((adcNumber > 0) && (adcNumber < (sizeof (adc) / sizeof (adc_t)))) {
		/* Select using burst mode or not */
		if (ADCSetup.burstMode)
			Chip_ADC_SetBurstCmd (_LPC_ADC_ID, ENABLE);
		else
			Chip_ADC_SetBurstCmd (_LPC_ADC_ID, DISABLE);

		/* Start A/D conversion if not using burst mode */
		if (!ADCSetup.burstMode)
			Chip_ADC_SetStartMode (_LPC_ADC_ID, ADC_START_NOW, ADC_TRIGGERMODE_RISING);

		/* Waiting for A/D conversion complete */
		while (Chip_ADC_ReadStatus (_LPC_ADC_ID, adc[adcNumber], ADC_DR_DONE_STAT) != SET);

		/* Read ADC value */
		Chip_ADC_ReadValue (_LPC_ADC_ID, adc[adcNumber], &dataADC);

		/* Disable burst mode, if any */
		if (ADCSetup.burstMode)
			Chip_ADC_SetBurstCmd (_LPC_ADC_ID, DISABLE);
	}

	return (dataADC);
}
/**
 * Interrupt Handler called when ADC is finished.
 */
void ADC_IRQ_HANDLER(void) {
	/**
	 * g_dataADC : result of ADC
	 */
	// Read ADC Channel 0
	Chip_ADC_ReadValue(_LPC_ADC_ID, ADC_CH0, &g_dataADC);
}
Пример #8
0
/**
 * @brief	main routine for ADC example
 * @return	Function should not exit
 */
int main(void)
{
	uint16_t dataADC;
	int j;

	SystemCoreClockUpdate();
	Board_Init();
	Init_ADC_PinMux();
	DEBUGSTR("ADC Demo\r\n");

	/* ADC Init */
	Chip_ADC_Init(LPC_ADC, &ADCSetup);
	Chip_ADC_EnableChannel(LPC_ADC, ADC_CH0, ENABLE);

	while (1) {
		/* Start A/D conversion */
		Chip_ADC_SetStartMode(LPC_ADC, ADC_START_NOW, ADC_TRIGGERMODE_RISING);

		/* Waiting for A/D conversion complete */
		while (Chip_ADC_ReadStatus(LPC_ADC, ADC_CH0, ADC_DR_DONE_STAT) != SET) {}

		/* Read ADC value */
		Chip_ADC_ReadValue(LPC_ADC, ADC_CH0, &dataADC);

		/* Print ADC value */
		DEBUGOUT("ADC value is 0x%x\r\n", dataADC);

		/* Delay */
		j = 500000;
		while (j--) {}
	}

	/* Should not run to here */
	return 0;
}
Пример #9
0
void SysTick_Handler(void)
{
	uint16_t dataADC;
	//int i;
	uint32_t currentPWM;
	currentPWM=LPC_PWM1->MR1;

	//Board_LED_Toggle(0);
	Board_LED_Set(0,1);


	//Chip_ADC_SetStartMode(_LPC_ADC_ID, ADC_START_NOW, ADC_TRIGGERMODE_RISING);

	//while (Chip_ADC_ReadStatus(_LPC_ADC_ID, _ADC_CHANNLE, ADC_DR_DONE_STAT) != SET) {}
	/* Read ADC value */
	Chip_ADC_ReadValue(_LPC_ADC_ID, _ADC_CHANNLE, &dataADC);
	/* Print ADC value */
	//App_print_ADC_value(dataADC);
	/*
	if(rotation_time<MEMORY_CAPACITY){
		rotation_debug_holder[rotation_time]=(int) dataADC;
		rotation_time++;
	}
	*/

	rotation_time++;
	//if(rotation_counter<MEMORY_CAPACITY){	//debug line
    if(dataADC>sensor_threshold){
        if(rotation_phase==0){
            	//rotation_debug_holder[rotation_counter]=rotation_time;		//debug line
            	//rotation_debug_holder2[rotation_counter]=dataADC;				//debug line

            	if(currentPWM < (1000-regulation_step) && currentPWM > (regulation_step)){	//debug needed here
            		if(rotation_time>desired_rotation_time){
            			PWM_SetCycle(currentPWM+regulation_step,1000);
            		}else{
            			PWM_SetCycle(currentPWM-regulation_step,1000);
            		}
            	}
            rotation_counter++;
            rotation_time=0;
            rotation_phase=1;
        }

    }else{
    	rotation_phase = 0;
    }

	//}				//debug line

    if(rotation_time==1000){
    	if(currentPWM < (1000-regulation_step)){
    		PWM_SetCycle(currentPWM+10*regulation_step,1000);
    	}
    	rotation_time=0;
    }


	Board_LED_Set(0,0);
}
Пример #10
0
STATIC INLINE void printADCRead(uint8_t sensorId, uint8_t channel) {
	uint16_t data;
	if (Chip_ADC_ReadValue(LPC_ADC1, channel, &data) == SUCCESS) {
		xprintf("-S%d %u\n", sensorId, data);
	} else {
		xprintf("-S%d -1\n", sensorId);
	}
}
Пример #11
0
void adc_read(uint8_t channel, uint16_t *data)
{
	Chip_ADC_EnableChannel(LPC_ADC, (ADC_CHANNEL_T)channel, ENABLE);
	/* Start A/D conversion */
	Chip_ADC_SetStartMode(LPC_ADC, ADC_START_NOW, ADC_TRIGGERMODE_RISING);
	/* Waiting for A/D conversion complete */
	while (Chip_ADC_ReadStatus(LPC_ADC, (ADC_CHANNEL_T)channel, ADC_DR_DONE_STAT) != SET);
	/* Read ADC value */
	Chip_ADC_ReadValue(LPC_ADC, channel, data);
	Chip_ADC_EnableChannel(LPC_ADC, (ADC_CHANNEL_T)channel, DISABLE);
}
Пример #12
0
void ADC_IRQHandler(void)
{
    static uint16_t data;
    Chip_ADC_ReadValue(LPC_ADC, ADC_CH0, &data);
#if(USAR_FUNCIONES_ASSEMBLER)
    asm_fir_q31_put(&filtro, data>>2);
#else
    fir_q31_put(&filtro, data>>2);
#endif
    adcFlag=1;
}
Пример #13
0
uint16_t Board_TPS_2_ADC_Read(uint16_t *adc_data) {
	/* Enable this channel and disable all others (because burst mode not enabled) */
	Chip_ADC_EnableChannel(LPC_ADC, ADC_CH0, DISABLE);
	Chip_ADC_EnableChannel(LPC_ADC, ADC_CH1, ENABLE);
	/* Start A/D conversion */
    Chip_ADC_SetStartMode(LPC_ADC, ADC_START_NOW, ADC_TRIGGERMODE_RISING);

    /* Waiting for A/D conversion complete */
    while (!Chip_ADC_ReadStatus(LPC_ADC, ADC_CH1, ADC_DR_DONE_STAT)) {}
    /* Read ADC value */
    Chip_ADC_ReadValue(LPC_ADC, ADC_CH1, adc_data);
}
Пример #14
0
uint16_t ConvertDataADC(void)
{
	uint16_t dataADC;
    /*disparo conversion del ADC0, con Start Now*/
	Chip_ADC_SetStartMode(LPC_ADC0,ADC_START_NOW,ADC_TRIGGERMODE_RISING);
	/* ahora me quedo mirando un flag del registro del ADC0 que se va a poner a 1
	 * cuando termine de convertir. Entonces mientras sea diferente de 1, queda esperando*/

	while(Chip_ADC_ReadStatus(LPC_ADC0,ADC_CH1,ADC_DR_DONE_STAT)!=SET)
	{}

    Chip_ADC_ReadValue(LPC_ADC0, ADC_CH1, & dataADC);
    return dataADC;
}
Пример #15
0
/**
 * @brief	ADC0 interrupt handler sub-routine
 * @return	Nothing
 */
void ADC_IRQHandler(void)
{
	uint16_t dataADC;
	/* Interrupt mode: Call the stream interrupt handler */
	NVIC_DisableIRQ(_LPC_ADC_IRQ);
	Chip_ADC_Int_SetChannelCmd(_LPC_ADC_ID, _ADC_CHANNLE, DISABLE);
	Chip_ADC_ReadValue(_LPC_ADC_ID, _ADC_CHANNLE, &dataADC);
	ADC_Interrupt_Done_Flag = 1;
	App_print_ADC_value(dataADC);
	if (DEBUGIN() != 'x') {
		NVIC_EnableIRQ(_LPC_ADC_IRQ);
		Chip_ADC_Int_SetChannelCmd(_LPC_ADC_ID, _ADC_CHANNLE, ENABLE);
	}
	else {Interrupt_Continue_Flag = 0; }
}
Пример #16
0
uint16_t skynetbase_windvane_measure(void) {
	skynetbase_windvane_start();

	// Waiting for A/D conversion complete
	while (Chip_ADC_ReadStatus(LPC_ADC, WINDVANE_ADC, ADC_DR_DONE_STAT) != SET) {}

	// Read ADC value
	Chip_ADC_ReadValue(LPC_ADC, WINDVANE_ADC, &windvane_buffer);

	skynetbase_windvane_stop();

	uint32_t upscaled = (uint32_t)windvane_buffer * (uint32_t)windvane_max_target;

	return upscaled / windvane_max;
}
Пример #17
0
/*
 * @brief   Get the value of one ADC channel. Mode: BLOCKING
 * @param   AI0 ... AIn
 * @return  analog value
 */
uint16_t analogRead( uint8_t analogInput ){

   uint8_t lpcAdcChannel = 49 - analogInput;
   uint16_t analogValue = 0;

   Chip_ADC_EnableChannel(LPC_ADC0, lpcAdcChannel, ENABLE);
   Chip_ADC_SetStartMode(LPC_ADC0, ADC_START_NOW, ADC_TRIGGERMODE_RISING);

   while( (Chip_ADC_ReadStatus(LPC_ADC0, lpcAdcChannel, ADC_DR_DONE_STAT) != SET) );
   Chip_ADC_ReadValue( LPC_ADC0, lpcAdcChannel, &analogValue );

   Chip_ADC_EnableChannel( LPC_ADC0, lpcAdcChannel, DISABLE );

   return analogValue;
}
Пример #18
0
/** \brief ADC Ch1 Acquisition method by pooling */
uint16_t read_ADC_value_pooling(void)
{
	/** \details
	 * This function initialize the DAC peripheral in the EDU-CIAA board,
	 * with the correct parameters with LPCOpen methods.
	 *
	 * \param none
	 *
	 * \return uint8_t: TBD (to support errors in the init function)
	 * */
	uint16_t valueRead = 0 ;

	/** Start Acquisition */
	Chip_ADC_SetStartMode(LPC_ADC0, ADC_START_NOW, ADC_TRIGGERMODE_RISING);
	/** The pooling magic! */
	while (Chip_ADC_ReadStatus(LPC_ADC0, ADC_CH1, ADC_DR_DONE_STAT) != SET)
	{
		/** pooooliiinnggg maaagggicccc plif plif pluf pluf */
	}
	/** Conversion complete, and value reading */
	Chip_ADC_ReadValue(LPC_ADC0,ADC_CH1, &valueRead);

	return valueRead;
}
Пример #19
0
int ADC_GetValue() {
	uint16_t value;
	while(Chip_ADC_ReadStatus(LPC_ADC0,ADC_CH1,ADC_DR_DONE_STAT) != SET);
	Chip_ADC_ReadValue(LPC_ADC0,ADC_CH1,&value);
	return value;
}
Пример #20
0
uint32_t LeerADC(uint8_t canal)
{
	uint16_t aux;
	Chip_ADC_ReadValue(LPC_ADC0, canal, &aux);
	return aux;
}
Пример #21
0
/**
 * @brief    Main routine for W5500 EVB firmware
 * @return   Function should not exit.
 */
int main(void) {

#if defined (__USE_LPCOPEN)
#if !defined(NO_BOARD_LIB)
    // Read clock settings and update SystemCoreClock variable
    SystemCoreClockUpdate();
    // Set up and initialize all required blocks and
    // functions related to the board hardware
    Board_Init();
#endif
#endif

    uint16_t dataADC;
    int16_t calc_temp;

    /* Flag for running user's code  */
    bool run_user_applications = true;

	/* Enable and setup SysTick Timer at a periodic rate */
	SysTick_Config(SystemCoreClock / TICKRATE_HZ1);

	/* ADC Init */
	Init_ADC_PinMux();
	Chip_ADC_Init(LPC_ADC, &ADCSetup);
	Chip_ADC_EnableChannel(LPC_ADC, TEMP_SENSOR_CH, ENABLE);

#ifdef _MAIN_DEBUG_
    printf("\r\n=======================================\r\n");
	printf(" WIZnet W5500 EVB\r\n");
	printf(" On-board Temperature sensor demo example v%d.%.2d\r\n", VER_H, VER_L);
	printf("=======================================\r\n");
	printf(">> This example using ADC, SysTick\r\n");
	printf("=======================================\r\n");
#endif

	/* Main loop ***************************************/
	while(1)
	{
    	// TODO: insert user's code here
    	if(run_user_applications)
    	{
    		if(ADC_read_enable)
    		{
    			ADC_read_enable = false;

				/* Start A/D conversion */
    			Chip_ADC_SetStartMode(LPC_ADC, ADC_START_NOW, ADC_TRIGGERMODE_RISING);

				/* Waiting for A/D conversion complete */
				while (Chip_ADC_ReadStatus(LPC_ADC, TEMP_SENSOR_CH, ADC_DR_DONE_STAT) != SET) {}

				/* Read ADC value */
				Chip_ADC_ReadValue(LPC_ADC, TEMP_SENSOR_CH, &dataADC);

				/* Calculate ADC value to Celsius temperature */
				calc_temp = (((dataADC * SUPPLY_VOLTAGE) / 1023) - 500) / 10;

				/* Print ADC value */
				printf("ADC value is 0x%x, ", dataADC);
				/* Print Celsius temperature */
				printf("Celsius temperature : %d C\r\n", calc_temp);
    		}
    	} // End of user's code
	} // End of Main loop

    return 0;
}
Пример #22
0
// funcion de atenci+on de interrupcion
void MyEocAdcISR(void){
	Chip_ADC_ReadValue(LPC_ADC0, 1, &adc_value);
	EOCFlag = 1;

}
Пример #23
0
void batteryReport() {
	uint16_t adcRead;
	if (Chip_ADC_ReadValue(LPC_ADC1, 1, &adcRead) == SUCCESS) {
		uint32_t data = (adcRead * 2800 * VBAT_DIVISOR) >> 10; //divide by 1024
		xprintf("-S0 %u\n", data);
	} else {
Пример #24
0
/**
 * The Systick handler is used for a lot more tasks than sensor timing.
 * It also provides a timer for decaying for the motor velocity, motor control
 * and second timer used for the LED blinking and Retina event rate.
 */
void SysTick_Handler(void) {  // now the systick handler function is called every 1/50000 second
	static uint16_t second_timer = 0;
	static uint16_t data_left = 0;
	static uint16_t data_right = 0;
	static uint32_t debug_timer = 0;
	//static uint16_t data0,data1;
#if USE_PUSHBOT
	static uint16_t one_k_hertz_timer = 0;
	static uint16_t ten_hertz_timer = 0;
	if (++ten_hertz_timer >= 5000) {  // 100
		ten_hertz_timer = 0;
		if (motor0.controlMode & DECAY_MODE) {
			if (motor0.decayCounter == 0) {
				if (motor0.controlMode & DIRECT_MODE) {
					if (motor0.requestedWidth != 0) {
						motor0.requestedWidth = (motor0.requestedWidth * 90) / 100;
						updateMotorWidth(0, motor0.requestedWidth);
					}
				} else {
					if (motor0.requestedVelocity > 0) {
						motor0.requestedVelocity--;
					} else if (motor0.requestedVelocity < 0) {
						motor0.requestedVelocity++;
					}
				}
			} else {
				motor0.decayCounter--;
			}
		}
		if (motor1.controlMode & (DECAY_MODE)) {
			if (motor1.decayCounter == 0) {
				if (motor1.controlMode & DIRECT_MODE) {
					if (motor1.requestedWidth != 0) {
						motor1.requestedWidth = (motor1.requestedWidth * 90) / 100;
						updateMotorWidth(1, motor1.requestedWidth);
					}
				} else {
					if (motor1.requestedVelocity > 0) {
						motor1.requestedVelocity--;
					} else if (motor1.requestedVelocity < 0) {
						motor1.requestedVelocity++;
					}
				}
			} else {
				motor1.decayCounter--;
			}
		}
	}
	if(one_k_hertz_timer == 50){
		one_k_hertz_timer = 0;
		if (motor0.controlMode & VELOCITY_MODE) {
			motor0.updateRequired = 1;
		}
		if (motor1.controlMode & VELOCITY_MODE) {
			motor1.updateRequired = 1;
		}
	}
#endif
	if (++second_timer >= 50000) { //1000
		lastEventCount = events.currentEventRate;
#if USE_SDCARD
		lastByteCount = sdcard.bytesWrittenPerSecond;
		lastEventRecordedCount = sdcard.eventsRecordedPerSecond;
#endif
		__DSB(); //Ensure it has been saved
		events.currentEventRate = 0;
#if USE_SDCARD
		sdcard.bytesWrittenPerSecond = 0;
		sdcard.eventsRecordedPerSecond = 0;
#endif

		second_timer = 0;
		toggleLed0 = 1;
	}
	// send left&right channel adc values through serial
	if(++debug_timer >= 1000){
		debug_timer = 0;
		if(stream_adc_flag){
			if (Chip_ADC_ReadValue(LPC_ADC1, ADC1_CHANNEL, &data_left) == SUCCESS){
				if (Chip_ADC_ReadValue(LPC_ADC1, ADC5_CHANNEL, &data_right) == SUCCESS){
					xprintf("L%uR%u\r\n", data_left, data_right);
				}
			}
		}
	}
/*
	//GET adc value every 1/50000 second
	// only when both channels successfully get the data that we increase the buf length
	//if(++debug_timer >= 100){
		//xputs("1\n");
		//debug_timer = 0;
		if(!buf_flag){
			//xputs("22\n");
			if(Chip_ADC_ReadValue(LPC_ADC1, ADC1_CHANNEL, &left0[buf_length]) == SUCCESS){  // &left0[buf_length].real
				//xputs("in1\n");
				if(Chip_ADC_ReadValue(LPC_ADC1, ADC5_CHANNEL, &right0[buf_length]) == SUCCESS){
					//xprintf("   %d\n", data0);
					//left0[buf_length].real = data0;
					//right0[buf_length].real = data1;

					if(++buf_length == BUFFER_MAX_SIZE){
						buf_length = 0;
						buf_flag = !buf_flag;
						process_flag = 0;
						//xputs(">>>>>");
					}
				}
			}
		}else{
			//xputs("333\n");
			if(Chip_ADC_ReadValue(LPC_ADC1, ADC1_CHANNEL, &left1[buf_length]) == SUCCESS){
				//xputs("in2\n");
				if(Chip_ADC_ReadValue(LPC_ADC1, ADC5_CHANNEL, &right1[buf_length]) == SUCCESS){
					//xprintf("   %d\n", data0);
					//left1[buf_length].real = data0;
					//right1[buf_length].real = data1;
					if(++buf_length == BUFFER_MAX_SIZE){
						buf_length = 0;
						buf_flag = !buf_flag;
						process_flag = 1;
						//xputs("<<");
					}
				}
			}
		}
	//}
	 */


	/*
	for (int i = 0; i < sensorsEnabledCounter; ++i) {
		if (--enabledSensors[i]->counter == 0) {
			enabledSensors[i]->counter = enabledSensors[i]->reload;
			enabledSensors[i]->triggered = 1;
			sensorRefreshRequested = 1;
		}
	}
	*/
}