TI

【TI 技术资料分享】+lantchpad的电容式触摸板的源码

2019-07-30 18:46发布

站内问答 / TI MCU
4774 0 1480
本帖最后由 必胜客A 于 2015-3-9 21:52 编辑

TI公司MSP430芯片评估板lantchpad的电容式触摸板的源码 TI公司MSP430芯片评估板lantchpad的电容式触摸板的源码.zip (9.96 KB, 下载次数: 4) 2015-3-9 21:50 上传 点击文件名下载附件

  2. #include "CTS_Layer.h"
  3. #include "uart.h"


  6. #define WAKE_UP_UART_CODE       0xBE
  7. #define WAKE_UP_UART_CODE2      0xEF
  8. #define SLEEP_MODE_UART_CODE    0xDE
  9. #define SLEEP_MODE_UART_CODE2   0xAD
  10. #define MIDDLE_BUTTON_CODE      0x80
  11. #define INVALID_GESTURE         0xFD
  12. #define GESTURE_START           0xFC
  13. #define GESTURE_STOP            0xFB
  14. #define COUNTER_CLOCKWISE       1
  15. #define CLOCKWISE               2
  16. #define GESTURE_POSITION_OFFSET 0x20
  17. #define WHEEL_POSITION_OFFSET   0x30

  19. #define WHEEL_TOUCH_DELAY       12  //Delay between re-sendings of touches
  20. #define MAX_IDLE_TIME           200
  21. #define PROXIMITY_THRESHOLD     60

  23. unsigned int wheel_position=ILLEGAL_SLIDER_WHEEL_POSITION, last_wheel_position=ILLEGAL_SLIDER_WHEEL_POSITION;
  24. unsigned int deltaCnts[1];
  25. unsigned int prox_raw_Cnts;




  30. /*----------------- LED definition---------------------------------------------
  31. * There are 8 LEDs to represent different positions around the wheel. They are
  32. * controlled by 5 pins of Port 1 using a muxing scheme. The LEDs are divided
  33. * vertically into two groups of 4, in which each LED is paired up [muxed] with
  34. * the LED mirrored on the other side of the imaginary center vertical line via
  35. * the use of pin P1.3 and one specific port pin.
  36. * Specifically, the pairs are LEDs [0,7], [1,6], [2,5], [3,4], as shown in the
  37. * diagram below.
  38. *     LED                        Position (degrees, clockwise)
  39. * --RIGHT SIDE--
  40. *      0       BIT4,!BIT3                  45
  41. *      1       BIT5,!BIT3                  80
  42. *      2       BIT6,!BIT3                 100
  43. *      3       BIT7,!BIT3                 135 *
  44. *
  45. * --LEFT SIDE--
  46. *      4       BIT3,(BIT4,5,6)             225
  47. *      5       BIT3,(BIT4,5,7)             260
  48. *      6       BIT3,(BIT4,6,7)             280
  49. *      7       BIT3,(BIT5,6,7)             315
  50. *----------------------------------------------------------------------------*/
  51. #define MASK7                   BIT4
  52. #define MASK6                   BIT5
  53. #define MASK5                   BIT6
  54. #define MASK4                   BIT7

  56. #define MASK3                   (BIT3+BIT4+BIT5+BIT6)
  57. #define MASK2                   (BIT3+BIT4+BIT5+BIT7)
  58. #define MASK1                   (BIT3+BIT4+BIT6+BIT7)
  59. #define MASK0                   (BIT3+BIT5+BIT6+BIT7)

  61. const unsigned char LedWheelPosition[16] =
  62.                                 {
  63.                                   MASK0, MASK0, MASK0 & MASK1, MASK1,
  64.                                   MASK1 & MASK2, MASK2, MASK2 & MASK3, MASK3,
  65.                                   MASK4, MASK4, MASK4 | MASK5, MASK5,
  66.                                   MASK5 | MASK6,  MASK6, MASK6 | MASK7, MASK7
  67.                                 };
  68. const unsigned char startSequence[8] =
  69.                                 {
  70.                                   MASK0,
  71.                                   MASK1,
  72.                                   MASK2,
  73.                                   MASK3,
  74.                                   MASK4,
  75.                                   MASK5,
  76.                                   MASK6,
  77.                                   MASK7
  78.                                 };
  79. /*----------------- LED definition------------------------------*/


  82. void InitLaunchPadCore(void)

  84. {
  85.   BCSCTL1 |= DIVA_0;                    // ACLK/(0:1,1:2,2:4,3:8)
  86.   BCSCTL3 |= LFXT1S_2;                  // LFXT1 = VLO  
  87.   
  88.   // Port init
  89.   P1OUT &= ~(BIT3+BIT4+BIT5+BIT6+BIT7+BIT0);
  90.   P1DIR |= BIT3+BIT4+BIT5+BIT6+BIT7+BIT0;
  91.   P2SEL = 0x00;                         // No XTAL
  92.   P2DIR |= (BIT0+BIT4+BIT2+BIT3+BIT1+BIT5);
  93.   P2OUT &= ~(BIT0+BIT4+BIT2+BIT3+BIT1+BIT5);
  94. }

  96. void SendByte(unsigned char touch)
  97. {
  98.   TimerA_UART_init();
  99.   TimerA_UART_tx(touch);
  100.   TimerA_UART_shutdown();  
  101. }

  103. /* ----------------CapTouchIdleMode-----------------------------------------
  104. * Device stays in LPM3 'sleep' mode, only Proximity Sensor is used to detect
  105. * any movement triggering device wake up                                 
  106. * ------------------------------------------------------------------------*/
  107. void CapTouchIdleMode(void)
  108. {
  109.   /* Send status via UART: 'sleep' = [0xDE, 0xAD] */  
  110.   SendByte(SLEEP_MODE_UART_CODE);
  111.   SendByte(SLEEP_MODE_UART_CODE2);
  112.   
  113.   /* Set DCO to 1MHz */
  114.   /* Set SMCLK to 1MHz / 8 = 125kHz */
  115.   BCSCTL1 = CALBC1_1MHZ;               
  116.   DCOCTL = CALDCO_1MHZ;
  117.   BCSCTL2 |= DIVS_3;  
  118.   
  119.   P1OUT |= BIT0;                            // Turn on center LED   
  120.   deltaCnts[0] = 0;
  121.   
  122.   /* Sleeping in LPM3 with ACLK/100 = 12Khz/100 = 120Hz wake up interval */
  123.   /* Measure proximity sensor count upon wake up */
  124.   /* Wake up if proximity deltaCnts > THRESHOLD */  
  125.   do
  126.   {
  127.     TACCR0 = 100;                                                                                                                                               
  128.     TACTL = TASSEL_1 + MC_1;                  
  129.     TACCTL0 |= CCIE;   
  130.     __bis_SR_register(LPM3_bits+GIE);
  131.     TACCTL0 &= ~CCIE;                             
  132.     TI_CAPT_Custom(&proximity_sensor,deltaCnts);
  133.   }
  134.   while (deltaCnts[0] <= PROXIMITY_THRESHOLD);
  135.   
  136.   P1OUT &= ~BIT0;                           // Turn off center LED
  137. }

  139. /* ----------------MeasureCapBaseLine--------------------------------------
  140. * Re-measure the baseline capacitance of the wheel elements & the center  
  141. * button. To be called after each wake up event.                          
  142. * ------------------------------------------------------------------------*/
  143. void MeasureCapBaseLine(void)
  144. {
  145.   P1OUT = BIT0;
  146.   /* Set DCO to 8MHz */
  147.   /* SMCLK = 8MHz/8 = 1MHz */
  148.   BCSCTL1 = CALBC1_8MHZ;     
  149.   DCOCTL = CALDCO_8MHZ;
  150.   BCSCTL2 |= DIVS_3;
  151.   
  152.   TI_CAPT_Init_Baseline(&wheel);
  153.   TI_CAPT_Update_Baseline(&wheel,2);
  154.   TI_CAPT_Init_Baseline(&middle_button);
  155.   TI_CAPT_Update_Baseline(&middle_button,2);  
  156. }

  158. /* ----------------LedStartUpSequence--------------------------------------
  159. * Display an LED lighting sequence to indicate the wake up event
  160. * ------------------------------------------------------------------------*/
  161. void LedStartUpSequence(void)
  162. {
  163.   unsigned char i;
  164.   TACCTL0 = CCIE;                           // CCR0 interrupt enabled
  165.   TACTL |= TACLR;
  166.   TACCR0 = TAR + 500;                       // 50ms                             
  167.   TACTL = TASSEL_1 + MC_1;                  // ACLK, upmode
  168.   
  169.   /* Slow clockwise sequence */
  170.   for(i=0; i<8; i++)
  171.   {
  172.       P1OUT = startSequence[i];
  173.       __bis_SR_register(LPM3_bits+GIE);
  174.      
  175.       __delay_cycles(1000000);
  176.       TACCR0 = TAR + 500;   // 50ms                             
  177.   }

  179.   P1OUT = BIT0;
  180.   /* Fast counter-clockwise sequence */
  181.   while(i)
  182.   {
  183.       i--;
  184.       P1OUT = startSequence[i];
  185.       __bis_SR_register(LPM3_bits+GIE);
  186.       TACCR0 = TAR + 500;   // 50ms                             
  187.   }
  188.   TACCTL0 &= ~CCIE;                         // CCR0 interrupt disabled
  189.   P1OUT = 0;                                // Turn off all LEDs
  190. }

  192. /* ----------------GetGesture----------------------------------------------
  193. * Determine immediate gesture based on current & previous wheel position
  194. * ------------------------------------------------------------------------*/
  195. unsigned char GetGesture(unsigned char wheel_position)
  196. {
  197. unsigned char gesture = INVALID_GESTURE, direction, ccw_check, cw_check;
  198. // ******************************************************************************
  199. // gesturing
  200. // determine if a direction/swipe is occuring
  201. // the difference between the initial position and
  202. // the current wheel position should not exceed 8
  203. // 0-1-2-3-4-5-6-7-8-9-A-B-C-D-E-F-0...
  204. //
  205. // E-F-0-1-2:  cw, 4
  206. // 2-1-0-F-E: ccw, 4
  207. // A-B-C-D-E-F

  209.   //if(initial_wheel_position == INVALID_WHEEL_POSITION)
  210.   //{
  211.     //gesture = 0;
  212.     //initial_wheel_position = wheel_position;
  213.   //}
  214.   //else

  216.   if(last_wheel_position != ILLEGAL_SLIDER_WHEEL_POSITION)
  217.   {
  218.     if(last_wheel_position  > wheel_position)
  219.     {
  220.       // E-D-C-B-A:  ccw, 4
  221.       // counter clockwise: 0 < (init_wheel_position - wheel_position) < 8
  222.       //                    gesture = init_wheel_position - wheel_position
  223.       //
  224.       // E-F-0-1-2:  cw, 4
  225.       // clockwise:        0 < (init_wheel_position+wheel_position)-16 <8
  226.       //                    
  227.       ccw_check = last_wheel_position  - wheel_position;
  228.       if(ccw_check < 8)
  229.       {
  230.         gesture = ccw_check;
  231.         direction = COUNTER_CLOCKWISE;
  232.       }
  233.       else
  234.       {
  235.         // E-F-0-1-2:  cw, 4
  236.         // 16 - 14 + 2 = 4
  237.         cw_check = 16 - last_wheel_position  + wheel_position ;
  238.         if(cw_check < 8)
  239.         {
  240.             gesture = cw_check;
  241.             direction = CLOCKWISE;
  242.         }
  243.       }
  244.     }
  245.     else
  246.     {
  247.       // initial_wheel_position <= wheel_position
  248.       //
  249.       // 2-1-0-F-E: ccw, 4
  250.       // counter clockwise:
  251.       //                    0 < (init_wheel_position+wheel_position)-16 <8
  252.       //                    gesture = init_wheel_position - wheel_position
  253.       //
  254.       // 0-1-2-3-4:  cw, 4
  255.       // clockwise:        0 < (wheel_position - init_wheel_position) < 8
  256.       //   
  257.       cw_check = wheel_position - last_wheel_position ;
  258.       if(cw_check < 8)
  259.       {
  260.         gesture = cw_check;
  261.         direction = CLOCKWISE;
  262.       }
  263.       else
  264.       {
  265.         // 2-1-0-F-E: ccw, 4
  266.         // 16 + 2 - 14 = 4
  267.         ccw_check = 16 + last_wheel_position  - wheel_position ;
  268.         if(ccw_check < 8)
  269.         {
  270.           gesture = ccw_check;
  271.           direction = COUNTER_CLOCKWISE;
  272.         }
  273.       }
  274.     }
  275.   }
  276.   if (gesture == INVALID_GESTURE)
  277.           return gesture;
  278.   if (direction == COUNTER_CLOCKWISE)
  279.     return (gesture + 16);
  280.   else
  281.     return gesture;
  282. }

  284. /* ----------------CapTouchActiveMode----------------------------------------------
  285. * Determine immediate gesture based on current & previous wheel position
  286. *
  287. *
  288. *
  289. *
  290. *
  291. *
  292. *
  293. * -------------------------------------------------------------------------------*/
  294. void CapTouchActiveMode()
  295. {
  296.   unsigned char idleCounter, activeCounter;
  297.   unsigned char gesture, gestureDetected;
  298.   unsigned char centerButtonTouched = 0;
  299.   unsigned int wheelTouchCounter = WHEEL_TOUCH_DELAY - 1;
  300.   
  301.      
  302.   gesture = INVALID_GESTURE;            // Wipes out gesture history
  303.   
  304.   /* Send status via UART: 'wake up' = [0xBE, 0xEF] */  
  305.   SendByte(WAKE_UP_UART_CODE);
  306.   SendByte(WAKE_UP_UART_CODE2);

  308.   idleCounter = 0;      
  309.   activeCounter = 0;
  310.   gestureDetected = 0;
  311.   
  312.   while (idleCounter++ < MAX_IDLE_TIME)
  313.   {  
  314.           /* Set DCO to 8MHz */
  315.           /* SMCLK = 8MHz/8 = 1MHz */
  316.     BCSCTL1 = CALBC1_8MHZ;     
  317.     DCOCTL = CALDCO_8MHZ;
  318.     BCSCTL2 |= DIVS_3;  
  319.     TACCTL0 &= ~CCIE;   
  320.    
  321.     wheel_position = ILLEGAL_SLIDER_WHEEL_POSITION;      
  322.     wheel_position = TI_CAPT_Wheel(&wheel);
  323.    
  324.     /* Process wheel touch/position/gesture  if a wheel touch is registered*/
  325.     /* Wheel processing has higher priority than center button*/
  326.    
  327.     if(wheel_position != ILLEGAL_SLIDER_WHEEL_POSITION)
  328.     {
  329.       centerButtonTouched = 0;
  330.       
  331.       /* Adjust wheel position based: rotate CCW by 2 positions */
  332.       if (wheel_position < 0x08)
  333.       {
  334.          wheel_position += 0x40 - 0x08;
  335.       }
  336.       else
  337.       {
  338.          wheel_position -= 0x08;
  339.             /* Adjust wheel position based: rotate CCW by 2 positions */
  340.       }
  341.       
  342.       wheel_position = wheel_position >>2;  // divide by four
  343.                
  344.       gesture = GetGesture(wheel_position);            
  345.       
  346.       /* Add hysteresis to reduce toggling between wheel positions if no gesture
  347.        * has been TRULY detected. */  
  348.                   
  349.       if ( (gestureDetected==0) && ((gesture<=1) || (gesture==0x11) || (gesture==0x10)))
  350.       {
  351.         if (last_wheel_position != ILLEGAL_SLIDER_WHEEL_POSITION)
  352.             wheel_position = last_wheel_position;
  353.         gesture = 0;
  354.       }
  355.       
  356.       /* Turn on corresponding LED(s) */
  357.       P1OUT = (P1OUT & BIT0) | LedWheelPosition[wheel_position];
  358.       
  359.      
  360.       if ((gesture != 0) && (gesture != 16) && (gesture != INVALID_GESTURE))           
  361.       { /* A gesture has been detected */
  362.         
  363.         if (gestureDetected ==0)
  364.         { /* Starting of a new gesture sequence */
  365.           gestureDetected = 1;
  366.          
  367.           /* Transmit gesture start status update & position via UART to PC */
  368.           SendByte(GESTURE_START);
  369.           SendByte(last_wheel_position + GESTURE_POSITION_OFFSET);
  370.         }
  371.                  
  372.         /* Transmit gesture & position via UART to PC */
  373.         SendByte(gesture);
  374.         SendByte(wheel_position + GESTURE_POSITION_OFFSET);
  375.       }      
  376.       else
  377.         if (gestureDetected==0)
  378.         { /* If no gesture was detected, this is constituted as a touch/tap */
  379.           if (++wheelTouchCounter >= WHEEL_TOUCH_DELAY)
  380.           {
  381.                   /* Transmit wheel position [twice] via UART to PC */
  382.                   wheelTouchCounter = 0;
  383.                   SendByte(wheel_position + WHEEL_POSITION_OFFSET );
  384.                   SendByte(wheel_position + WHEEL_POSITION_OFFSET );
  385.           }
  386.         }
  387.                else
  388.           wheelTouchCounter = WHEEL_TOUCH_DELAY - 1;             
  389.         
  390.       idleCounter = 0;                      // Reset idle counter
  391.       activeCounter++;
  392.       last_wheel_position = wheel_position;
  393.     }
  394.     else   
  395.     { /* no wheel position was detected */
  396.       
  397.       if(TI_CAPT_Button(&middle_button))
  398.       { /* Middle button was touched */   
  399.         if (centerButtonTouched==0)
  400.         {
  401.           /* Transmit center button code [twice] via UART to PC */
  402.           SendByte(MIDDLE_BUTTON_CODE);         
  403.           SendByte(MIDDLE_BUTTON_CODE);
  404.                     
  405.           centerButtonTouched = 1;
  406.          
  407.           P1OUT = (P1OUT&BIT0) ^ BIT0;      // Toggle Center LED
  408.         }
  409.         idleCounter = 0;
  410.       }
  411.       else   
  412.       { /* No touch was registered at all [Not wheel or center button */
  413.         centerButtonTouched = 0;
  414.         P1OUT &= BIT0;      
  415.         if ( (gesture == INVALID_GESTURE) || (gestureDetected ==0))
  416.         { /* No gesture was registered previously */
  417.           if (last_wheel_position  != ILLEGAL_SLIDER_WHEEL_POSITION)
  418.             {
  419.               /* Transmit last wheel position [twice] via UART to PC */
  420.               SendByte(last_wheel_position  + WHEEL_POSITION_OFFSET );
  421.               SendByte(last_wheel_position  + WHEEL_POSITION_OFFSET );
  422.               wheelTouchCounter = WHEEL_TOUCH_DELAY - 1;
  423.             }
  424.         }
  425.          
  426.           if (gestureDetected == 1)
  427.           { /* A gesture was registered previously */
  428.             
  429.             /* Transmit status update: stop gesture tracking [twice] via UART to PC */
  430.             SendByte(GESTURE_STOP);
  431.             SendByte(GESTURE_STOP);
  432.           }
  433.          
  434.       }
  435.       
  436.       // Reset all touch conditions, turn off LEDs,
  437.       last_wheel_position= ILLEGAL_SLIDER_WHEEL_POSITION;      
  438.       gesture = INVALID_GESTURE;
  439.       gestureDetected = 0;

  441.     }
  442.    
  443.   /* ------------------------------------------------------------------------
  444.    * Option:
  445.    * Add delay/sleep cycle here to reduce active duty cycle. This lowers power
  446.    * consumption but sacrifices wheel responsiveness. Additional timing
  447.    * refinement must be taken into consideration when interfacing with PC
  448.    * applications GUI to retain proper communication protocol.
  449.    * -----------------------------------------------------------------------*/
  450.      
  451.   }
  452. }


  455. void main(void)
  456. {   

  458.   WDTCTL = WDTPW + WDTHOLD;             // Stop watchdog timer
  459.   
  460.   InitLaunchPadCore();
  461.    
  462.   
  463.   /* Set DCO to 1MHz */
  464.   /* Set SMCLK to 1MHz / 8 = 125kHz */
  465.   BCSCTL1 = CALBC1_1MHZ;               
  466.   DCOCTL = CALDCO_1MHZ;
  467.   BCSCTL2 |= DIVS_3;
  468.   /* Establish baseline for the proximity sensor */  
  469.   TI_CAPT_Init_Baseline(&proximity_sensor);
  470.   TI_CAPT_Update_Baseline(&proximity_sensor,5);
  471.   
  472.   while (1)
  473.   {
  474.     CapTouchIdleMode();  
  475.   
  476.     MeasureCapBaseLine();
  477.     LedStartUpSequence();
  478.     CapTouchActiveMode();
  479.   }
  480. }
复制代码
发送
 看不清?
0条回答

一周热门 更多>

相关文章