触控设备手势唤醒的设计思路及其实现 设计, 设备

forsuccess

示例代码2
　　// example interrupt function where this might be implemented
　　__interrupt void TimedInterrupt（ void ）
　　{
　　uint8 proximity_counts;
　　uint8 filtered_counts;
　　....
　　....
　　if （ device_status == SLEEP_MODE ）
　　{
　　// read one byte from register 0x16
　　proximity_counts = read_i2c_register（MAX44000_ADDR，0x16，1）;
　　// weights［QUEUE_SIZE］ contains the filter weights for the FIR filter
　　// data_queue［QUEUE_SIZE］ is a FIFO queue meant to be the input to the filter
　　filtered_counts = fir_filter（proximity_counts，weights，data_queue）;
　　if （filtered_counts 》 WAKEUP_THRESHOLD）
　　{
　　device_status = WAKE_MODE;
　　...
　　}
　　else
　　{
　　// do whatever it is you need to in sleep mode
　　...
　　...
　　}
　　}
　　...
　　...
　　}
　　/**
　　* fir_filter（）
　　*
　　* Implements an FIR filter in the form
　　* y = w［0］*x［0］ + w［1］*x［1］ + 。。.+ w［QUEUE_SIZE］*x［QUEUE_SIZE］
　　*
　　* Arguments：
　　* uint8 input - newest datapoint taken （that is， x［0］）
　　* uint8 *weights - w［0］。。.w［QUEUE_SIZE］
　　* uint8 *queue - the discrete sequence x［0］。。.x［QUEUE_SIZE］
　　*
　　* Returns：
　　* The FIR-filtered output， y
　　*/
　　uint8 fir_filter（uint8 input， uint8 *weights， uint8 *queue）
　　{
　　uint8 i;
　　int sum = 0;
　　// pop first entry in the queue， then
　　// push new data into the last position
　　push_into_queue（queue，input）;
　　// input is now x［0］
　　for （i=0; i {
　　sum += weights［i］*queue［i］;
　　}
　　return （sum/QUEUE_SIZE）;
　　}示例代码3

　　// this handles hardware-level interrupts on the micro
　　__interrupt void irq_handler（ void ）
　　{
　　...
　　// if the hardware interrupt came from the MAX44000 sensor
　　// pulling its INT pin low
　　if （ irq_source == MAX44000 ）
　　{
　　// if the device is in sleep mode
　　if （device_status == SLEEP_MODE）
　　{
　　device_status = WAKE_MODE; // wake up the device
　　...
　　// reconfigure whatever else you need here as the system wakes up
　　}
　　// otherwise， handle it however it is you wish
　　else
　　{
　　...
　　}
　　}
　　...
　　}
　　/**
　　* configure_max44000_for_sleep_mode（）
　　*
　　* Sets up the MAX44000 to trigger a hardware interrupt when the proximity
　　* counts go above some set threshold.
　　*
　　* Arguments：
　　* uint8 upper_threshold - the set threshold （8-bit mode）
　　*
　　* Returns：
　　* n/a
　　*/
　　void configure_max44000_for_sleep_mode（uint8 upper_threshold）
　　{
　　uint8 max44000_thresh_registers［］ = {0x0B，0x0C};
　　uint8 max44000_upper_thresh［］ = {0x40，0};
　　max44000_upper_thresh［1］ = upper_threshold;
　　// do a consecutive write of 0 followed by upper_threshold to
　　// registers 0xB and 0xC， respectively
　　// MAX44000_ADDR is usually 0x94
　　// interrupt will trigger only if proximity value is above the threshold
　　write_i2c_register（MAX44000_ADDR，max44000_thresh_registers，
　　max44000_upper_thresh，2）;
　　// write to bits 2 and 3 of register 0x0A here if you wish to set the
　　// persist time to anything other than one sample
　　// writes to register 0x01 to enable interrupts on the MAX44000
　　max44000_enable_interrupt（）;
　　return;
　　}