API tools faq
paste
Advertisement
steschm0712

thumbstick

steschm0712
Dec 31st, 2015
101
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 9.90 KB | None | 0 0
raw download clone embed print report
  1.  
  2. #include <stdbool.h>
  3. #include <inc/hw_memmap.h>
  4.  
  5.  
  6. #include <time.h>
  7. #include <stdlib.h>
  8.  
  9. #include <xdc/std.h>
  10. #include <xdc/runtime/System.h>
  11. #include <xdc/runtime/Error.h>
  12.  
  13. #include <ti/sysbios/BIOS.h>
  14. #include <ti/sysbios/knl/Clock.h>
  15. #include <ti/sysbios/knl/Task.h>
  16. #include <ti/sysbios/knl/Event.h>
  17. #include <ti/sysbios/knl/Semaphore.h>
  18. #include <ti/sysbios/knl/Queue.h>
  19. #include <ti/sysbios/hal/Hwi.h>
  20.  
  21. #include <driverlib/gpio.h>
  22. #include <driverlib/pin_map.h>/*supplies GPIO_PIN_x*/
  23. #include <driverlib/sysctl.h>
  24. #include <EK_TM4C1294XL.h>
  25. #include <ti/drivers/SPI.h>
  26. #include <ti/drivers/UART.h>
  27. #include <ti/drivers/GPIO.h>
  28. #include <ti/drivers/gpio/GPIOTiva.h>
  29.  
  30.  
  31. #include <driverlib/ssi.h>
  32. #include <inc/hw_ssi.h>
  33. #include <inc/hw_memmap.h>
  34. #include "inc/hw_ints.h"
  35.  
  36. #include "EK_TM4C1294XL.h"
  37. #include "Board.h"
  38.  
  39.  
  40. #define CLICKBUTTON GPIOTiva_PC_6 | GPIO_CFG_IN_PD | GPIO_CFG_IN_INT_RISING
  41.  
  42.  
  43. #define VERBOSE 0
  44.  
  45. #define UP 1
  46. #define DOWN 2
  47. #define LEFT 3
  48. #define RIGHT 4
  49. #define BUTTON 5
  50.  
  51. void click_init(char mikrobus);
  52. void readjoystick();
  53. void sendertsk();
  54. void initGPIO();
  55. void initUart(void);
  56. void initmiddle();
  57. void SSI_write(uint16_t address, uint16_t data);
  58. void SSI_write_data(uint8_t data[8]);
  59. void uarttask(UArg arg0, UArg arg1);
  60. void buttonpressedfxn(UArg arg0);
  61.  
  62.  
  63. Queue_Handle myQ;
  64. /* This structure can be added to a Queue because the first field is a Queue_Elem. */
  65. typedef struct Rec {
  66.     Queue_Elem elem;
  67.     Int data;
  68. } Rec;
  69.  
  70. uint32_t ui32SysClkFreq;
  71. uint8_t buttonpressed=0;
  72.  
  73. unsigned int left_right, up_down, old_left_right, old_up_down;
  74. unsigned int middle_left_right, middle_up_down;
  75.  
  76.  
  77.  
  78. /*
  79.  *  ======== main ========
  80.  */
  81. Int main()
  82.  {
  83.  
  84.     Task_Params tskParams;
  85.     Task_Params taskUARTParams;
  86.     Task_Handle taskUART;
  87.     Hwi_Params tempHWIParams;
  88.     Hwi_Handle tempHwi;
  89.  
  90.     Error_Block eb;
  91.  
  92.     ui32SysClkFreq=Board_initGeneral(120000000);
  93.     initGPIO();
  94.     initUart();
  95.  
  96.  
  97.  
  98.  
  99.  
  100.     Error_init(&eb);
  101.     myQ = Queue_create(NULL, &eb);
  102.     if (myQ == NULL) {
  103.         System_abort("Queue create failed");
  104.     }
  105.  
  106.     Hwi_Params_init(&tempHWIParams);
  107.     tempHWIParams.arg = 0;
  108.     tempHWIParams.enableInt = true;
  109.  
  110.  
  111.     tempHwi = Hwi_create(INT_GPIOC_TM4C129, buttonpressedfxn, &tempHWIParams, &eb);
  112.     if (tempHwi == NULL)
  113.     {
  114.            System_abort("HWI create failed");
  115.     }
  116.  
  117.     Hwi_enableInterrupt(INT_GPIOC_TM4C129);
  118.  
  119.     GPIOIntEnable(GPIO_PORTC_BASE, GPIO_PIN_6);
  120.     //GPIOTiva_PJ_0 | GPIO_CFG_IN_PU | GPIO_CFG_IN_INT_RISING,
  121.  
  122.     //GPIO_setCallback(GPIOTiva_PC_4 | GPIO_CFG_INPUT | GPIO_CFG_IN_INT_RISING, buttonpressed);
  123.     //GPIO_enableInt(GPIOTiva_PC_4 | GPIO_CFG_INPUT | GPIO_CFG_IN_INT_RISING);
  124.  
  125.  
  126.     /* create a ledblink task */
  127.     Task_Params_init(&tskParams);
  128.     tskParams.priority = 15;
  129.     tskParams.arg0 = NULL;
  130.     tskParams.arg1 = NULL;
  131.     Task_create(&readjoystick, &tskParams, NULL);
  132.  
  133.     //Create UART Task
  134.     Task_Params_init(&taskUARTParams);
  135.     taskUARTParams.priority = 15;/*15 is default 16 is highest priority -> see RTOS configuration*/
  136.     taskUARTParams.arg0 = NULL;
  137.     taskUARTParams.arg1 = NULL;
  138.     taskUART = Task_create((Task_FuncPtr)uarttask, &taskUARTParams, &eb);
  139.     if (taskUART == NULL) {
  140.         System_abort("TaskUART create failed");
  141.     }
  142.     BIOS_start();    /* does not return */
  143.     return(0);
  144. }
  145.  
  146. void initUart(void)
  147. {
  148.  
  149.     SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK);
  150.     SysCtlPeripheralEnable(SYSCTL_PERIPH_UART4);
  151.     GPIOPinConfigure(GPIO_PK0_U4RX);
  152.     GPIOPinConfigure(GPIO_PK1_U4TX);
  153.     GPIOPinTypeUART(GPIO_PORTK_BASE, GPIO_PIN_0 | GPIO_PIN_1);
  154.     UART_init();
  155.  
  156. }
  157.  
  158. void uarttask(UArg arg0, UArg arg1)
  159. {
  160.  
  161.     char input;
  162.     UART_Handle uart;
  163.     UART_Params uartParams;
  164.     Rec *rr;
  165.     //const char echoPrompt[] = "\fEchoing characters:\r\n";
  166.  
  167.         /* Create a UART with data processing off. */
  168.         UART_Params_init(&uartParams);
  169.         uartParams.writeDataMode = UART_DATA_BINARY;
  170.         uartParams.readDataMode = UART_DATA_BINARY;
  171.         uartParams.readReturnMode = UART_RETURN_FULL;
  172.         uartParams.readEcho = UART_ECHO_OFF;
  173.         uartParams.baudRate = 115200;
  174.         uart = UART_open(Board_UART4, &uartParams);
  175.  
  176.         if (uart == NULL) {
  177.             System_abort("Error opening the UART");
  178.         }
  179.  
  180.  
  181.         while (1) {
  182.             rr=Queue_get(myQ);
  183.             if((rr->data>0)&&(rr->data<6)) {
  184.                 input=(char)rr->data;
  185.                 UART_write(uart, &input, 1);
  186.                 input=0;
  187.                 UART_write(uart, &input, 1);
  188.             } else {
  189.                 input=0;
  190.             }
  191.             Task_sleep(50);
  192.  
  193.         }
  194.  
  195.  
  196. }
  197. // Get ADC values
  198. unsigned int GetADC(unsigned short channel) {    // Returns 0..4095
  199.   uint32_t tmp=0,tmp2;
  200.  
  201.  
  202.   GPIOPinWrite(GPIO_PORTH_BASE, GPIO_PIN_2, 0);             //set cs low
  203.   SSIDataPut(SSI2_BASE, 0x06);  //send address // SPI communication using 8-bit segments
  204.   channel = channel << 6;                        // Bits 7 & 6 define ADC input
  205.   SSIDataPut(SSI2_BASE, channel);
  206.   while (SSIBusy(SSI2_BASE));
  207.   while (SSIDataGetNonBlocking(SSI2_BASE,&tmp));
  208.   //while(!(SSIDataGetNonBlocking(SSI2_BASE,&tmp)));
  209.   tmp2=tmp & 0x0F;
  210.   tmp2 = tmp2 << 8;                                // Shift ADC value by 8
  211.   while (SSIDataGetNonBlocking(SSI2_BASE,&tmp));
  212.   //while(!(SSIDataGetNonBlocking(SSI2_BASE,&tmp)));
  213.  
  214.   //tmp2|=tmp & 0X0F;
  215.   tmp2|=tmp;
  216.  
  217.  
  218.   GPIOPinWrite(GPIO_PORTH_BASE, GPIO_PIN_2, GPIO_PIN_2);
  219.   return tmp2;                                    // Returns 12-bit ADC value
  220. }
  221. void buttonpressedfxn(UArg arg0)
  222. {
  223.  
  224.     //GPIOIntDisable(GPIO_PORTC_BASE, GPIO_PIN_6);
  225.     //Hwi_clearInterrupt(INT_GPIOC_TM4C129);
  226.  
  227.     buttonpressed=1;
  228.     GPIOIntClear(GPIO_PORTC_BASE, GPIO_PIN_6);
  229.  
  230. }
  231. void initGPIO()
  232. {
  233.     SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
  234.     GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_6);
  235.  
  236.  
  237.     SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); /* ist das obere booster board GPIOQ ist das untere */
  238.     SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI2);
  239.     SPI_init();
  240.  
  241.     GPIOPinConfigure(GPIO_PD3_SSI2CLK);/*hier nur Clock, RX und TX. Slave Select wird manuell gemacht */
  242.     GPIOPinConfigure(GPIO_PD1_SSI2XDAT0);
  243.     GPIOPinConfigure(GPIO_PD0_SSI2XDAT1);
  244.  
  245.     GPIOPinTypeSSI(GPIO_PORTD_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_3); /*SPI aktivieren wichtig PIN 2 für SS auslassen */
  246.  
  247.     SysCtlPeripheralEnable(GPIO_PORTH_BASE); /*H2 ist der Pin für Slave select */
  248.     GPIOPinTypeGPIOOutput(GPIO_PORTH_BASE, GPIO_PIN_2);
  249.  
  250.     SSIClockSourceSet(SSI2_BASE,SSI_CLOCK_SYSTEM); /*Clock festlegen für SPI */
  251.     SSIConfigSetExpClk(SSI2_BASE, 120000000, SSI_FRF_MOTO_MODE_0, SSI_MODE_MASTER, 1000000,8); /*CPU ist auf 120 Mhz, Click board/ SPI läuft auf 2 Mhz */
  252.     SSIEnable(SSI2_BASE);
  253.  
  254.  
  255.  
  256.     return;
  257. }
  258. void initmiddle()
  259. {
  260.     unsigned int votemid1=0,votemid2=0,votemid3=0;
  261.     unsigned int averagemid=0, countmid=0;
  262.  
  263.     votemid1 = GetADC(0);
  264.     averagemid=votemid1;
  265.     countmid++;
  266.     Task_sleep(10);
  267.     votemid1 = GetADC(0);
  268.     averagemid+=votemid1;
  269.     countmid++;
  270.     Task_sleep(10);
  271.     votemid1 = GetADC(0);
  272.     averagemid+=votemid1;
  273.     countmid++;
  274.     Task_sleep(10);         // let joystick settle down and then read middle value
  275.     votemid2 = GetADC(0);
  276.     averagemid+=votemid2;
  277.     countmid++;
  278.     Task_sleep(10);
  279.     votemid3 = GetADC(0);
  280.     averagemid+=votemid3;
  281.     countmid++;
  282.     Task_sleep(10);
  283.  
  284.     if((votemid1==votemid2)||(votemid2==votemid3))
  285.         middle_up_down=votemid2;
  286.     else if (votemid1==votemid3)
  287.         middle_up_down=votemid1;
  288.     else
  289.         middle_up_down=2048; //dont trust read init values and take logic middle
  290.  
  291. #ifdef VERBOSE
  292.     System_printf("middle_up_down: %d averagemid: %d\n",middle_up_down,(averagemid/countmid));
  293.     System_flush();
  294. #endif
  295.  
  296.     votemid1 = GetADC(1);
  297.     averagemid=votemid1;
  298.     countmid++;
  299.     Task_sleep(1);
  300.     votemid1 = GetADC(1);
  301.     averagemid+=votemid1;
  302.     countmid++;
  303.     Task_sleep(10);
  304.     votemid1 = GetADC(1);
  305.     averagemid+=votemid1;
  306.     countmid++;
  307.     Task_sleep(1);      // let joystick settle down and then read middle value
  308.     votemid2 = GetADC(1);
  309.     averagemid+=votemid2;
  310.     countmid++;
  311.     Task_sleep(1);
  312.     votemid3 = GetADC(1);
  313.     averagemid+=votemid3;
  314.     countmid++;
  315.     Task_sleep(1);
  316.  
  317.     if((votemid1==votemid2)||(votemid2==votemid3))
  318.         middle_left_right=votemid2;
  319.     else if (votemid1==votemid3)
  320.         middle_left_right=votemid1;
  321.     else
  322.         middle_left_right=2048; //dont trust read init values and take logic middle
  323. #ifdef VERBOSE
  324.     System_printf("middle_left_right: %d averagemid: %d\n",middle_left_right,(averagemid/countmid));
  325.     System_flush();
  326. #endif
  327. }
  328.  
  329. void readjoystick()
  330. {
  331.     //unsigned int last_leftright=2, last_updown=2;
  332.     unsigned int middle_percent_ud=416, middle_percent_lr=416;
  333.     Rec r1;
  334.     initmiddle();
  335.  
  336.     up_down=0;
  337.     left_right=0;
  338.       for(;;) {
  339.           if(buttonpressed!=0) {
  340.                 r1.data=BUTTON;
  341.                 Queue_put(myQ, &(r1.elem));
  342.                 buttonpressed=0;
  343. #ifdef VERBOSE
  344.                   System_printf("button\n");
  345.                   System_flush();
  346. #endif
  347.           }
  348.           up_down = GetADC(0);
  349.  
  350.           if ((up_down < (middle_up_down-middle_percent_ud))||(up_down > (middle_up_down+middle_percent_ud))) {
  351.               if ((up_down < middle_up_down)) {
  352.  
  353.                     r1.data=UP;
  354.                     Queue_put(myQ, &(r1.elem));
  355.  
  356. #ifdef VERBOSE
  357.                   System_printf("up\n");
  358. #endif
  359.               } else  {
  360.                     r1.data=DOWN;
  361.                     Queue_put(myQ, &(r1.elem));
  362. #ifdef VERBOSE
  363.                   System_printf("down\n");
  364. #endif
  365.               }
  366.               Task_sleep(150);
  367.               //System_printf("updown: %d middle_up_down:%d\n",up_down,middle_up_down);
  368. #ifdef VERBOSE
  369.               System_flush();
  370. #endif
  371.               continue;
  372.  
  373.           }
  374.           left_right = GetADC(1);
  375.           if ((left_right < (middle_left_right-middle_percent_lr))||(left_right > (middle_left_right+middle_percent_lr))) {
  376.               if ((left_right < middle_left_right)) {
  377.                     r1.data=LEFT;
  378.                     Queue_put(myQ, &(r1.elem));
  379. #ifdef VERBOSE
  380.                     System_printf("left\n");
  381. #endif
  382.               } else  {
  383.                     r1.data=RIGHT;
  384.                     Queue_put(myQ, &(r1.elem));
  385. #ifdef VERBOSE
  386.                     System_printf("right\n");
  387. #endif
  388.               }
  389. #ifdef VERBOSE
  390.               System_flush();
  391. #endif
  392.               Task_sleep(150);
  393.               continue;
  394.  
  395.           }
  396.           //r1.data=0;
  397.           //Queue_put(myQ, &(r1.elem));
  398.  
  399.           Task_sleep(50);
  400.       }
  401.  
  402. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!