单片机/MCU论坛
直播中

卢松涛

12年用户 450经验值
擅长:嵌入式技术
私信 关注

【MAX32660试用体验】freertos+dht11+rgy灯

` 本帖最后由 lustao 于 2019-4-3 13:15 编辑

freertos+dht11+rgy灯
Maxim带的例子有freertos的，看着研究了下，加在vTask0加了 2019-3-12 15:36:19   用彩色灯制作红绿灯程序，加在vTask1加了6 天前DHT11程序

  1. /*******************************************************************************
  2. * Copyright (C) 2016 Maxim Integrated Products, Inc., All Rights Reserved.
  3. *
  4. * Permission is hereby granted, free of charge, to any person obtaining a
  5. * copy of this software and associated documentation files (the "Software"),
  6. * to deal in the Software without restriction, including without limitation
  7. * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  8. * and/or sell copies of the Software, and to permit persons to whom the
  9. * Software is furnished to do so, subject to the following conditions:
  10. *
  11. * The above copyright notice and this permission notice shall be included
  12. * in all copies or substantial portions of the Software.
  13. *
  14. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  15. * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  16. * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  17. * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
  18. * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19. * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20. * OTHER DEALINGS IN THE SOFTWARE.
  21. *
  22. * Except as contained in this notice, the name of Maxim Integrated
  23. * Products, Inc. shall not be used except as stated in the Maxim Integrated
  24. * Products, Inc. Branding Policy.
  25. *
  26. * The mere transfer of this software does not imply any licenses
  27. * of trade secrets, proprietary technology, copyrights, patents,
  28. * trademarks, maskwork rights, or any other form of intellectual
  29. * property whatsoever. Maxim Integrated Products, Inc. retains all
  30. * ownership rights.
  31. ********************************************************************************/

  33. /* **** Includes **** */
  34. /* config.h is the required application configuration; RAM layout, stack, chip type etc. */
  35. #include "mxc_config.h"
  36. #include "board.h"

  38. #include
  39. #include
  40. #include
  41. #include
  42. #include
  43. #include

  45. /* FreeRTOS */
  46. #include "FreeRTOS.h"
  47. #include "task.h"
  48. #include "semphr.h"

  50. /* FreeRTOS+ */
  51. #include "FreeRTOS_CLI.h"

  53. /* Maxim CMSIS SDK */
  54. #include "rtc.h"
  55. #include "uart.h"
  56. #include "lp.h"
  57. #include "led.h"
  58. #include "board.h"
  59. #include "pb.h"

  61. /* FreeRTOS+CLI */
  62. void vRegisterCLICommands(void);

  64. /* Mutual exclusion (mutex) semaphores */
  65. SemaphoreHandle_t xGPIOmutex;

  67. /* Task IDs */
  68. TaskHandle_t cmd_task_id;

  70. /* Enables/disables tick-less mode */
  71. unsigned int disable_tickless = 1;

  73. /* **** macros **** */
  74. /* Stringification macros */
  75. #define STRING(x) STRING_(x)
  76. #define STRING_(x) #x

  78. /* Console ISR selection */
  79. #if (CONSOLE_UART==0)
  80. #define UARTx_IRQHandler UART0_IRQHandler
  81. #define UARTx_IRQn UART0_IRQn
  82. #elif (CONSOLE_UART==1)
  83. #define UARTx_IRQHandler UART1_IRQHandler
  84. #define UARTx_IRQn UART1_IRQn
  85. #else
  86. #error "Please update ISR macro for UART CONSOLE_UART"
  87. #endif

  89. extern mxc_uart_regs_t *ConsoleUART; /* Set by board.c */
  90. gpio_cfg_t uart_rx_pin = { PORT_0, PIN_6, GPIO_FUNC_IN, GPIO_PAD_PULL_UP};

  92. /* **** Definitions **** */
  93. volatile int buttonPressed = 0;
  94. gpio_cfg_t dht_in = {PORT_0, PIN_4, GPIO_FUNC_IN, GPIO_PAD_NONE};
  95. #define SECS_PER_HR         (60 * 60)
  96. #define SECS_PER_DAY        (24 * SECS_PER_HR)

  98. #define MSEC_TO_RSSA(x) (0 - ((x * 256) / 1000)) /* Converts a time in milleseconds to the equivalent RSSA register value. */
  99. /* Array sizes */
  100. #define CMD_LINE_BUF_SIZE  80
  101. #define OUTPUT_BUF_SIZE  512



  105. /**
  106. * @brief   vTask0
  107. * @details
  108. */
  109. void vTask0(void *pvParameters)
  110. {

  112.     gpio_cfg_t gpio_out0 = {PORT_0, PIN_9, GPIO_FUNC_OUT, GPIO_PAD_NONE};
  113.         gpio_cfg_t gpio_out1 = {PORT_0, PIN_13, GPIO_FUNC_OUT, GPIO_PAD_NONE};
  114.         /*int count = 0;*/

  116.         /* Setup output pin  FOR led. */

  118.         GPIO_Config(&gpio_out0);


  121.         GPIO_Config(&gpio_out1);

  123.         printf("
  125. ***** GPIO led  ******
  127. ");
  128.         printf(
  129.                         "1. This example outputs the same state onto P0.9 (led) and outputs the same state onto P0.13 (led).
  130. ");

  132.         while (1) {
  133.                 GPIO_OutClr(&gpio_out1);
  134.                 GPIO_OutClr(&gpio_out0);
  135.             TickType_t xLastWakeTime;


  138.             /* Get task start time */
  139.             xLastWakeTime = xTaskGetTickCount();
  140.         GPIO_OutSet(&gpio_out0);
  141.         /* Wait 1 second until next run */
  142.         vTaskDelayUntil(&xLastWakeTime, configTICK_RATE_HZ*10);            // wait for 10 seconds
  143.   GPIO_OutClr(&gpio_out0);
  144.   vTaskDelay( 300 * configTICK_RATE_HZ/1000);
  145. // mxc_delay(MXC_DELAY_MSEC(300));
  146.   GPIO_OutSet(&gpio_out0);
  147.   vTaskDelay( 300 * configTICK_RATE_HZ/1000);
  148.   GPIO_OutClr(&gpio_out0);
  149.   vTaskDelay( 300 * configTICK_RATE_HZ/1000);
  150.   GPIO_OutSet(&gpio_out0);
  151.   vTaskDelay( 300 * configTICK_RATE_HZ/1000);
  152.   GPIO_OutClr(&gpio_out0);
  153.   vTaskDelay( 300 * configTICK_RATE_HZ/1000);
  154.   GPIO_OutSet(&gpio_out0);
  155.   vTaskDelay( 300 * configTICK_RATE_HZ/1000);
  156.                 GPIO_OutSet(&gpio_out1);
  157.             xLastWakeTime = xTaskGetTickCount();
  158.                 GPIO_OutSet(&gpio_out0);
  159.         vTaskDelayUntil(&xLastWakeTime, configTICK_RATE_HZ*2);
  160.                 //mxc_delay(MXC_DELAY_MSEC(2000));
  161.                 GPIO_OutClr(&gpio_out1);
  162.                 GPIO_OutClr(&gpio_out0);
  163.             xLastWakeTime = xTaskGetTickCount();
  164.         GPIO_OutSet(&gpio_out1);
  165.         vTaskDelayUntil(&xLastWakeTime, configTICK_RATE_HZ*10);            // wait for 10 seconds
  166.   GPIO_OutClr(&gpio_out1);
  167.   vTaskDelay( 300 * configTICK_RATE_HZ/1000);
  168.   GPIO_OutSet(&gpio_out1);
  169.   vTaskDelay( 300 * configTICK_RATE_HZ/1000);
  170.   GPIO_OutClr(&gpio_out1);
  171.   vTaskDelay( 300 * configTICK_RATE_HZ/1000);
  172.   GPIO_OutSet(&gpio_out1);
  173.   vTaskDelay( 300 * configTICK_RATE_HZ/1000);
  174.   GPIO_OutClr(&gpio_out1);
  175.   vTaskDelay( 300 * configTICK_RATE_HZ/1000);
  176.   GPIO_OutSet(&gpio_out1);
  177.   vTaskDelay( 300 * configTICK_RATE_HZ/1000);
  178.                 GPIO_OutSet(&gpio_out1);
  179.             xLastWakeTime = xTaskGetTickCount();
  180.                 GPIO_OutSet(&gpio_out0);
  181.         vTaskDelayUntil(&xLastWakeTime, configTICK_RATE_HZ*2);
  182.                 //mxc_delay(MXC_DELAY_MSEC(2000));
  183.                 GPIO_OutClr(&gpio_out1);
  184.                 GPIO_OutClr(&gpio_out0);

  186.         }
  187. }

  189. void printTime(void)
  190. {
  191.     int day, hr, min, sec;
  192.     double subsec;

  194.     subsec = RTC_GetSubSecond() / 256.0;
  195.     sec = RTC_GetSecond();

  197.     day = sec / SECS_PER_DAY;
  198.     sec -= day * SECS_PER_DAY;

  200.     hr = sec / SECS_PER_HR;
  201.     sec -= hr * SECS_PER_HR;

  203.     min = sec /60;
  204.     sec -= min * 60;

  206.     subsec += sec;

  208.     printf("Current Time (dd:hh:mm:ss.subs): %02d:%02d:%02d:%05.2f
  209. ", day, hr, min, subsec);
  210. }
  211. void MicroSeconds(int us) {

  213.     /* Demonstrates the TMR driver delay */
  214.     //    TMR_Delay(MXC_TMR0, USEC(us), NULL); // todo check if this is μsec or msec
  215.     uint32_t i = 0;
  216.     for( i=0; i < us * 4; i++) {
  217.         asm(" nop");
  218.     }
  219. }

  221. /*从DHT11读取一个位，返回值：1/0。
  222. 每一bit数据都以50us的低电平时序开始，高电平的宽度决定了bit数据位的0或1，
  223. 高电平状态在26~28us时，表示数据位为0，高电平状态在70us时，表示数据位为1.
  224. DHT11_DQ_IN是读取对应端口引脚的输入电平，在读之前，该引脚要配置为上拉下拉输入模式
  225. */
  226. char DHT11_Read_Bit(void)
  227. {
  228.         char retry=0;
  229. while(GPIO_InGet(&dht_in)&&retry<100)//读取高电平中，等待变为低电平，/*&&与<的优先级是<高于&&*/
  230. {
  231. retry++;
  232. MicroSeconds(1);//SysTickDelay(1);
  233. }
  234. retry=0;
  235. while(!GPIO_InGet(&dht_in)&&retry<100)//读取低电平中，等待变高电平
  236. {
  237. retry++;
  238. MicroSeconds( 1);//SysTickDelay(1);
  239. }
  240. MicroSeconds( 40);//SysTickDelay(40);//等待40us
  241. if(GPIO_InGet(&dht_in))return 1;
  242. else return 0;
  243. }

  245. char DhtReadByte(void)
  246. {
  247.         char j,dat;
  248.     dat=0;

  250. for(j=0;j<8;j++)
  251. {

  253.     dat<<=1;
  254.    dat|=DHT11_Read_Bit();
  255. }

  257. return(dat);  }


  260. void vTask1(void *pvParameters)
  261. {
  262.    // gpio_cfg_t dht_in = {PORT_0, PIN_4, GPIO_FUNC_IN, GPIO_PAD_NONE};
  263.     gpio_cfg_t dht_out = {PORT_0, PIN_4, GPIO_FUNC_OUT, GPIO_PAD_NONE};
  264.         int count = 0;

  266.         printf("
  268. ***** DHT11  on P0.4 ******
  270. ");
  271.         printf(
  272.                         "1.  An interrupt is set up on P0.12.  when that interrupt occurs.using a push button (S1) to start DHT11
  274. ");
  275.     /* Wait 1 second until next run */
  276.           vTaskDelay(  configTICK_RATE_HZ);
  277.             int i=0;
  278.         char check;    // 校验字节
  279.         char TemHig,TemLow,HumiHig,HumiLow;
  280.             while (1) {
  281.                 if (buttonPressed) {
  282.                     // Show the time elapsed.
  283.                     printTime();
  284.                     printf("buttonPressed    count = %d
  285. ", count++);
  286.                     // Delay for switch debouncing.
  287.                     vTaskDelay(  configTICK_RATE_HZ/10);//TMR_Delay(MXC_TMR0, MSEC(100), &sys_tmr_cfg);
  288.                     printf("configTICK_RATE_HZ = %d
  289. ", configTICK_RATE_HZ);
  290.                     // Re-arm switch detection.
  291.                     i++;
  292.                     buttonPressed = 0;

  294.                     GPIO_Config(&dht_out);
  295.                     GPIO_OutClr(&dht_out);
  296.                           // 主机拉低18ms  DelayMs(18);
  297.                     vTaskDelay( 19* configTICK_RATE_HZ/1000);//TMR_Delay(MXC_TMR0, MSEC(18), &sys_tmr_cfg);
  298.                     vTaskSuspendAll();
  299.                     GPIO_OutSet(&dht_out);
  300.                     MicroSeconds( 20);
  301.                     GPIO_Config(&dht_in);            
  302.                     xTaskResumeAll();
  303.                     vTaskDelay( 10* configTICK_RATE_HZ);//TMR_Delay(MXC_TMR0, MSEC(15000), &sys_tmr_cfg);       //  主机延时15s
  304.                     GPIO_Config(&dht_out);
  305.                     GPIO_OutClr(&dht_out);
  306.                           // 主机拉低18ms  DelayMs(18);
  307.                     vTaskDelay( 19* configTICK_RATE_HZ/1000);//TMR_Delay(MXC_TMR0, MSEC(18), &sys_tmr_cfg);
  308.                     vTaskSuspendAll();
  309.                     GPIO_OutSet(&dht_out);
  310.                     MicroSeconds( 20);
  311.                     GPIO_Config(&dht_in);            
  312.                     while (!GPIO_InGet(&dht_in));   
  313.                     while (GPIO_InGet(&dht_in));   
  314.                     HumiHig = DhtReadByte();
  315.                     HumiLow = DhtReadByte();  
  316.                     TemHig  = DhtReadByte();
  317.                     TemLow  = DhtReadByte();  
  318.                     check   = DhtReadByte();
  319.                     xTaskResumeAll();
  320.                     
  321.                     if(check==HumiHig + HumiLow + TemHig + TemLow)   
  322.                     {printf("HumiHig   = %d. %d
  323. ", HumiHig,HumiLow);
  324.                     printf("TemHig   = %d. %d
  325. ", TemHig,TemLow);
  326.                     printf("check   = %d
  327. ", check);}
  328.                     else{
  329.                             printf(" error check .count = %d
  330. ", count);
  331.                             printTime();
  332.                     }


  335.                 }
  336.                 else{
  337.                     vTaskDelay( 100* configTICK_RATE_HZ/1000);
  338.                 }
  339.             }

  341. }
  342. /**  
  343. * @brief   vTickTockTask
  344. * @details This task writes the current RTOS tick time to the console
  345. */
  346. void vTickTockTask(void *pvParameters)
  347. {
  348.     TickType_t ticks = 0;
  349.     TickType_t xLastWakeTime;

  351.     /* Get task start time */
  352.     xLastWakeTime = xTaskGetTickCount();
  353.   
  354.     while (1) {
  355.         ticks = xTaskGetTickCount();
  356.         printf("Uptime is 0x%08x (%u seconds), tickless-idle is %s
  357. ",
  358.             ticks, ticks / configTICK_RATE_HZ,
  359.             disable_tickless ? "disabled" : "ENABLED");
  360.         vTaskDelayUntil(&xLastWakeTime, (configTICK_RATE_HZ * 60));
  361.     }
  362. }

  364. /**
  365. * @brief   UART0_IRQHandler
  366. * @details This function overrides the weakly-declared interrupt handler
  367. *          in system_max326xx.c and is needed for asynchronous UART
  368. *          calls to work properly
  369. */
  370. void UARTx_IRQHandler(void)
  371. {
  372.     UART_Handler(ConsoleUART);
  373. }

  375. /**
  376. * @brief   vCmdLineTask_cb
  377. * @details Callback on asynchronous reads to wake the waiting command
  378. *          processor task
  379. */
  380. void vCmdLineTask_cb(uart_req_t *req, int error)
  381. {
  382.     BaseType_t xHigherPriorityTaskWoken;

  384.     /* Wake the task */
  385.     xHigherPriorityTaskWoken = pdFALSE;
  386.     vTaskNotifyGiveFromISR(cmd_task_id, &xHigherPriorityTaskWoken);
  387.     portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
  388. }

  390. /**
  391. * @brief   vCmdLineTask
  392. * @details The command line task provides a prompt on the serial
  393. *          interface and takes input from the user to evaluate
  394. *          via the FreeRTOS+CLI parser.
  395. * @note    FreeRTOS+CLI is part of FreeRTOS+ and has
  396. *          different licensing requirements. Please see
  397. *          http://www.freertos.org/FreeRTOS-Plus for more information
  398. */
  399. void vCmdLineTask(void *pvParameters)
  400. {
  401.     unsigned char tmp;
  402.     unsigned int index;     /* Index into buffer */
  403.     unsigned int x;
  404.     char buffer[CMD_LINE_BUF_SIZE];      /* Buffer for input */
  405.     char output[OUTPUT_BUF_SIZE];        /* Buffer for output */
  406.     BaseType_t xMore;
  407.     uart_req_t async_read_req;
  408.   
  409.     memset(buffer, 0, CMD_LINE_BUF_SIZE);
  410.     index = 0;
  411.    
  412.     /* Register available CLI commands */
  413.     vRegisterCLICommands();

  415.     /* Enable UART0 interrupt */
  416.     NVIC_ClearPendingIRQ(UARTx_IRQn);
  417.     NVIC_DisableIRQ(UARTx_IRQn);
  418.     NVIC_SetPriority(UARTx_IRQn, 1);
  419.     NVIC_EnableIRQ(UARTx_IRQn);

  421.     /* Async read will be used to wake process */
  422.     async_read_req.data = &tmp;
  423.     async_read_req.len = 1;
  424.     async_read_req.callback = vCmdLineTask_cb;
  425.   
  426.     printf("
  427. Enter 'help' to view a list of available commands.
  428. ");
  429.     printf("cmd> ");
  430.     fflush(stdout);
  431.         
  432.     while (1) {
  433.         /* Register async read request */
  434.         if (UART_ReadAsync(ConsoleUART, &async_read_req) != E_NO_ERROR) {
  435.             printf("Error registering async request. Command line unavailable.
  436. ");
  437.         vTaskDelay(portMAX_DELAY);
  438.         }
  439.         /* Hang here until ISR wakes us for a character */
  440.         ulTaskNotifyTake(pdTRUE, portMAX_DELAY);
  441.         /* Check that we have a valid character */
  442.         if (async_read_req.num > 0) {
  443.            /* Process character */
  444.             do {
  445.                     if (tmp == 0x08) {
  446.                     /* Backspace */
  447.                         if (index > 0) {
  448.                             index--;
  449.                             printf("x08 x08");
  450.                         }
  451.                         fflush(stdout);
  452.                     } else if (tmp == 0x03) {
  453.                     /* ^C abort */
  454.                         index = 0;
  455.                         printf("^C");
  456.                         printf("
  457. cmd> ");
  458.                         fflush(stdout);
  459.                     } else if ((tmp == '
    ') || (tmp == '
  460. ')) {
  461.                         printf("
  462. ");
  463.                         /* Null terminate for safety */
  464.                         buffer[index] = 0x00;
  465.                         /* Evaluate */
  466.                         do {
  467.                             xMore = FreeRTOS_CLIProcessCommand(buffer, output, OUTPUT_BUF_SIZE);
  468.                             /* If xMore == pdTRUE, then output buffer contains no null termination, so
  469.                              *  we know it is OUTPUT_BUF_SIZE. If pdFALSE, we can use strlen.
  470.                              */
  471.                             for (x = 0; x < (xMore == pdTRUE ? OUTPUT_BUF_SIZE : strlen(output)) ; x++) {
  472.                                 putchar(*(output+x));
  473.                             }
  474.                         } while (xMore != pdFALSE);
  475.                         /* New prompt */
  476.                         index = 0;
  477.                         printf("
  478. cmd> ");
  479.                         fflush(stdout);
  480.                     } else if (index < CMD_LINE_BUF_SIZE) {
  481.                         putchar(tmp);
  482.                         buffer[index++] = tmp;
  483.                         fflush(stdout);
  484.                     } else {
  485.                         /* Throw away data and beep terminal */
  486.                         putchar(0x07);
  487.                         fflush(stdout);
  488.                     }
  489.                          /* If more characters are ready, process them here */
  490.             } while ((UART_NumReadAvail(MXC_UART_GET_UART(CONSOLE_UART)) > 0) &&
  491.                 UART_Read(MXC_UART_GET_UART(CONSOLE_UART), (uint8_t *)&tmp, 1, NULL));
  492.         }
  493.     }
  494. }

  496. #if configUSE_TICKLESS_IDLE
  497. /**
  498. * @brief   freertos_permit_tickless
  499. * @details Determine if any hardware activity should prevent
  500. *          low-power tickless operation.
  501. */
  502. int freertos_permit_tickless(void)
  503. {
  504.   if (disable_tickless == 1) {
  505.     return E_BUSY;
  506.   }

  508.   return UART_PrepForSleep(MXC_UART_GET_UART(CONSOLE_UART));
  509. }

  511. void buttonHandler(void *pb)
  512. {

  514.   buttonPressed = 1;
  515. }
  516. #endif

  518. void RTC_IRQHandler(void)
  519. {
  520.   MXC_RTC->ctrl &= ~(MXC_F_RTC_CTRL_ALSF);
  521. }

  523. /**
  524. * @brief   main()
  525. * @detials This program demonstrates FreeRTOS tasks, mutexes,
  526. *          and the FreeRTOS+CLI extension.
  527. */
  528. int main(void)
  529. {
  530. #if configUSE_TICKLESS_IDLE
  531.     /* The RTC must be enabled for tickless operation */
  532.     sys_cfg_rtc_t sys_cfg;
  533.     sys_cfg.tmr = MXC_TMR0;
  534.     RTC_Init(MXC_RTC, 0, 0, &sys_cfg);
  535.     RTC_EnableRTCE(MXC_RTC);
  536.     NVIC_ClearPendingIRQ(RTC_IRQn);
  537.     NVIC_EnableIRQ(RTC_IRQn);
  538.     LP_EnableRTCAlarmWakeup();
  539. #endif

  541. #if configUSE_TICKLESS_IDLE
  542.     /* Configure wake-up for GPIO pin corresponding to pushbutton */
  543.     LP_EnableGPIOWakeup((gpio_cfg_t *)&pb_pin[0]);
  544.     PB_RegisterCallback(0, buttonHandler);
  545. #endif
  546.   
  547.     /* Print banner (RTOS scheduler not running) */
  548.     printf("
  549. -=- %s FreeRTOS (%s) Demo -=-
  550. ", STRING(TARGET), tskKERNEL_VERSION_NUMBER);
  551. #if configUSE_TICKLESS_IDLE
  552.     printf("Tickless idle is configured. Type 'tickless 1' to enable.
  553. ");
  554. #endif

  556.     /* Create mutexes */
  557.     xGPIOmutex = xSemaphoreCreateMutex();
  558.     if (xGPIOmutex == NULL) {
  559.         printf("xSemaphoreCreateMutex failed to create a mutex.
  560. ");
  561.     } else {
  562.     /* Configure task */
  563.         if ((xTaskCreate(vTask0, (const char *)"Task0",
  564.                          configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY+1, NULL) != pdPASS) ||
  565.                 (xTaskCreate(vTask1, (const char *)"Task1",
  566.                          configMINIMAL_STACK_SIZE+128, NULL, tskIDLE_PRIORITY+1, NULL) != pdPASS) ||
  567.                 (xTaskCreate(vTickTockTask, (const char *)"TickTock",
  568.                          2*configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY+2, NULL) != pdPASS) ||
  569.                 (xTaskCreate(vCmdLineTask, (const char *)"CmdLineTask",
  570.                          configMINIMAL_STACK_SIZE+CMD_LINE_BUF_SIZE+OUTPUT_BUF_SIZE, NULL, tskIDLE_PRIORITY+1, &cmd_task_id) != pdPASS)) {
  571.             printf("xTaskCreate() failed to create a task.
  572. ");
  573.         } else {
  574.             /* Start scheduler */
  575.             printf("Starting scheduler.
  576. ");
  577.             vTaskStartScheduler();
  578.         }
  579.     }
  580.   
  581.     /* This code is only reached if the scheduler failed to start */
  582.     printf("ERROR: FreeRTOS did not start due to above error!
  583. ");
  584.     while (1) {
  585.         __NOP();
  586.     }

  588.   /* Quiet GCC warnings */
  589.   return -1;
  590. }


检测运行成功
无标题.png

com

  2. -=- 32660 FreeRTOS (V8.2.1) Demo -=-
  3. Tickless idle is configured. Type 'tickless 1' to enable.
  4. Starting scheduler.
  5. Uptime is 0x00000000 (0 seconds), tickless-idle is disabled


  8. ***** GPIO led  ******

  10. 1. This example outputs the same state onto P0.9 (led) and outputs the same state onto P0.13 (led).


  13. ***** DHT11  on P0.4 ******

  15. 1.  An interrupt is set up on P0.12.  when that interrupt occurs.using a push button (S1) to start DHT11


  18. Enter 'help' to view a list of available commands.
  19. cmd> ps
  20. Task          State  Priority  Stack    #
  21. ************************************************
  22. CmdLineTask     R       1       449     4
  23. IDLE            R       0       97      5
  24. Task0           B       1       70      1
  25. TickTock        B       2       126     3
  26. Task1           B       1       192     2

  28. cmd> Current Time (dd:hh:mm:ss.subs): 00:00:00:23.33
  29. buttonPressed    count = 0
  30. configTICK_RATE_HZ =
  31. HumiHig   = 28. 0
  32. TemHig   = 16. 9
  33. check   = 53
  34. ps
  35. Task          State  Priority  Stack    #
  36. ************************************************
  37. CmdLineTask     R       1       398     4
  38. IDLE            R       0       97      5
  39. Task0           B       1       70      1
  40. TickTock        B       2       126     3
  41. Task1           B       1       90      2

  43. cmd> Uptime is 0x00003c00 (60 seconds), tickless-idle is disabled
  44. Uptime is 0x00007800 (120 seconds), tickless-idle is disabled
  45. ps
  46. Task          State  Priority  Stack    #
  47. ************************************************
  48. CmdLineTask     R       1       398     4
  49. IDLE            R       0       97      5
  50. Task0           B       1       70      1
  51. TickTock        B       2       100     3
  52. Task1           B       1       90      2

  54. cmd> Current Time (dd:hh:mm:ss.subs): 00:00:02:42.38
  55. buttonPressed    count = 1
  56. configTICK_RATE_HZ =
  57. HumiHig   = 28. 0
  58. TemHig   = 17. 1
  59. check   = 46
  60. Uptime is 0x0000b401 (180 seconds), tickless-idle is disabled
  61. Uptime is 0x0000f000 (240 seconds), tickless-idle is disabled
  62. Current Time (dd:hh:mm:ss.subs): 00:00:04:00.53
  63. buttonPressed    count = 2
  64. configTICK_RATE_HZ =
  65. HumiHig   = 29. 0
  66. TemHig   = 17. 0
  67. check   = 46
  68. Current Time (dd:hh:mm:ss.subs): 00:00:04:26.76
  69. buttonPressed    count = 3
  70. configTICK_RATE_HZ =
  71. HumiHig   = 29. 0
  72. TemHig   = 17. 0
  73. check   = 46
  74. Current Time (dd:hh:mm:ss.subs): 00:00:04:42.96
  75. buttonPressed    count = 4
  76. configTICK_RATE_HZ =
  77. HumiHig   = 47. 0
  78. TemHig   = 17. 5
  79. check   = 69
  80. Uptime is 0x00012c00 (300 seconds), tickless-idle is disabled
  81. Uptime is 0x00016800 (360 seconds), tickless-idle is disabled


` 891599515.jpg

更多回帖

0 0 0

相关帖子

MAX32660 RTOS
发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分