ARM技术论坛
直播中

卢松涛

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

【星空派GD32F303开发板试用体验】控温（2）测试ADC

本帖最后由 lustao 于 2021-10-31 14:52 编辑

接上稿，
在之前基础上加入ADC程序（温度传感器和内部参考电压 VREFINT ）
  1. /*
  2. * Copyright (c) 2006-2018, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date           Author       Notes
  8. * 2006-03-23     Bernard      the first version
  9. * 2010-11-10     Bernard      add cleanup callback function in thread exit.
  10. * 2012-12-29     Bernard      fix compiling warning.
  11. * 2013-12-21     Grissiom     let rt_thread_idle_excute loop until there is no
  12. *                             dead thread.
  13. * 2016-08-09     ArdaFu       add method to get the handler of the idle thread.
  14. * 2018-02-07     Bernard      lock scheduler to protect tid->cleanup.
  15. * 2018-07-14     armink       add idle hook list
  16. * 2018-11-22     Jesven       add per cpu idle task
  17. *                             combine the code of primary and secondary cpu
  18. */

  20. #include
  21. #include

  23. #ifdef RT_USING_MODULE
  24. #include
  25. #endif

  27. #if defined (RT_USING_HOOK)
  28. #ifndef RT_USING_IDLE_HOOK
  29. #define RT_USING_IDLE_HOOK
  30. #endif
  31. #endif

  33. #ifndef IDLE_THREAD_STACK_SIZE
  34. #if defined (RT_USING_IDLE_HOOK) || defined(RT_USING_HEAP)
  35. #define IDLE_THREAD_STACK_SIZE  256
  36. #else
  37. #define IDLE_THREAD_STACK_SIZE  128
  38. #endif
  39. #endif

  41. #ifdef RT_USING_SMP
  42. #define _CPUS_NR                RT_CPUS_NR
  43. #else
  44. #define _CPUS_NR                1
  45. #endif

  47. extern rt_list_t rt_thread_defunct;

  49. static struct rt_thread idle[_CPUS_NR];
  50. ALIGN(RT_ALIGN_SIZE)
  51. static rt_uint8_t rt_thread_stack[_CPUS_NR][IDLE_THREAD_STACK_SIZE];

  53. #ifdef RT_USING_IDLE_HOOK
  54. #ifndef RT_IDLE_HOOK_LIST_SIZE
  55. #define RT_IDLE_HOOK_LIST_SIZE  4
  56. #endif

  58. static void (*idle_hook_list[RT_IDLE_HOOK_LIST_SIZE])(void);

  60. /**
  61. * @ingroup Hook
  62. * This function sets a hook function to idle thread loop. When the system performs
  63. * idle loop, this hook function should be invoked.
  64. *
  65. * [url=home.php?mod=space&uid=3142012]@param[/url] hook the specified hook function
  66. *
  67. * [url=home.php?mod=space&uid=1141835]@Return[/url] RT_EOK: set OK
  68. *         -RT_EFULL: hook list is full
  69. *
  70. * [url=home.php?mod=space&uid=1902110]@NOTE[/url] the hook function must be simple and never be blocked or suspend.
  71. */
  72. rt_err_t rt_thread_idle_sethook(void (*hook)(void))
  73. {
  74.     rt_size_t i;
  75.     rt_base_t level;
  76.     rt_err_t ret = -RT_EFULL;

  78.     /* disable interrupt */
  79.     level = rt_hw_interrupt_disable();

  81.     for (i = 0; i < RT_IDLE_HOOK_LIST_SIZE; i++)
  82.     {
  83.         if (idle_hook_list[i] == RT_NULL)
  84.         {
  85.             idle_hook_list[i] = hook;
  86.             ret = RT_EOK;
  87.             break;
  88.         }
  89.     }
  90.     /* enable interrupt */
  91.     rt_hw_interrupt_enable(level);

  93.     return ret;
  94. }

  96. /**
  97. * delete the idle hook on hook list
  98. *
  99. * @param hook the specified hook function
  100. *
  101. * @return RT_EOK: delete OK
  102. *         -RT_ENOSYS: hook was not found
  103. */
  104. rt_err_t rt_thread_idle_delhook(void (*hook)(void))
  105. {
  106.     rt_size_t i;
  107.     rt_base_t level;
  108.     rt_err_t ret = -RT_ENOSYS;

  110.     /* disable interrupt */
  111.     level = rt_hw_interrupt_disable();

  113.     for (i = 0; i < RT_IDLE_HOOK_LIST_SIZE; i++)
  114.     {
  115.         if (idle_hook_list[i] == hook)
  116.         {
  117.             idle_hook_list[i] = RT_NULL;
  118.             ret = RT_EOK;
  119.             break;
  120.         }
  121.     }
  122.     /* enable interrupt */
  123.     rt_hw_interrupt_enable(level);

  125.     return ret;
  126. }

  128. #endif

  130. /* Return whether there is defunctional thread to be deleted. */
  131. rt_inline int _has_defunct_thread(void)
  132. {
  133.     /* The rt_list_isempty has prototype of "int rt_list_isempty(const rt_list_t *l)".
  134.      * So the compiler has a good reason that the rt_thread_defunct list does
  135.      * not change within rt_thread_idle_excute thus optimize the "while" loop
  136.      * into a "if".
  137.      *
  138.      * So add the volatile qualifier here. */
  139.     const volatile rt_list_t *l = (const volatile rt_list_t *)&rt_thread_defunct;

  141.     return l->next != l;
  142. }

  144. /**
  145. * @ingroup Thread
  146. *
  147. * This function will perform system background job when system idle.
  148. */
  149. void rt_thread_idle_excute(void)
  150. {
  151.     /* Loop until there is no dead thread. So one call to rt_thread_idle_excute
  152.      * will do all the cleanups. */
  153.     while (_has_defunct_thread())
  154.     {
  155.         rt_base_t lock;
  156.         rt_thread_t thread;
  157. #ifdef RT_USING_MODULE
  158.         struct rt_dlmodule *module = RT_NULL;
  159. #endif
  160.         RT_DEBUG_NOT_IN_INTERRUPT;

  162.         /* disable interrupt */
  163.         lock = rt_hw_interrupt_disable();

  165.         /* re-check whether list is empty */
  166.         if (_has_defunct_thread())
  167.         {
  168.             /* get defunct thread */
  169.             thread = rt_list_entry(rt_thread_defunct.next,
  170.                                    struct rt_thread,
  171.                                    tlist);
  172. #ifdef RT_USING_MODULE
  173.             module = (struct rt_dlmodule*)thread->module_id;
  174.             if (module)
  175.             {
  176.                 dlmodule_destroy(module);
  177.             }
  178. #endif
  179.             /* remove defunct thread */
  180.             rt_list_remove(&(thread->tlist));

  182.             /* lock scheduler to prevent scheduling in cleanup function. */
  183.             rt_enter_critical();

  185.             /* invoke thread cleanup */
  186.             if (thread->cleanup != RT_NULL)
  187.                 thread->cleanup(thread);

  189. #ifdef RT_USING_SIGNALS
  190.             rt_thread_free_sig(thread);
  191. #endif

  193.             /* if it's a system object, not delete it */
  194.             if (rt_object_is_systemobject((rt_object_t)thread) == RT_TRUE)
  195.             {
  196.                 /* detach this object */
  197.                 rt_object_detach((rt_object_t)thread);
  198.                 /* unlock scheduler */
  199.                 rt_exit_critical();

  201.                 /* enable interrupt */
  202.                 rt_hw_interrupt_enable(lock);

  204.                 return;
  205.             }

  207.             /* unlock scheduler */
  208.             rt_exit_critical();
  209.         }
  210.         else
  211.         {
  212.             /* enable interrupt */
  213.             rt_hw_interrupt_enable(lock);

  215.             /* may the defunct thread list is removed by others, just return */
  216.             return;
  217.         }

  219.         /* enable interrupt */
  220.         rt_hw_interrupt_enable(lock);

  222. #ifdef RT_USING_HEAP
  223.         /* release thread's stack */
  224.         RT_KERNEL_FREE(thread->stack_addr);
  225.         /* delete thread object */
  226.         rt_object_delete((rt_object_t)thread);
  227. #endif
  228.     }
  229. }

  231. extern void rt_system_power_manager(void);
  232. static void rt_thread_idle_entry(void *parameter)
  233. {
  234. #ifdef RT_USING_SMP
  235.     if (rt_hw_cpu_id() != 0)
  236.     {
  237.         while (1)
  238.         {
  239.             rt_hw_secondary_cpu_idle_exec();
  240.         }
  241.     }
  242. #endif

  244.     while (1)
  245.     {
  246. #ifdef RT_USING_IDLE_HOOK
  247.         rt_size_t i;

  249.         for (i = 0; i < RT_IDLE_HOOK_LIST_SIZE; i++)
  250.         {
  251.             if (idle_hook_list[i] != RT_NULL)
  252.             {
  253.                 idle_hook_list[i]();
  254.             }
  255.         }
  256. #endif

  258.         rt_thread_idle_excute();
  259. #ifdef RT_USING_PM        
  260.         rt_system_power_manager();
  261. #endif
  262.     }
  263. }

  265. /**
  266. * @ingroup SystemInit
  267. *
  268. * This function will initialize idle thread, then start it.
  269. *
  270. * @note this function must be invoked when system init.
  271. */
  272. void rt_thread_idle_init(void)
  273. {
  274.     rt_ubase_t i;
  275.     char tidle_name[RT_NAME_MAX];

  277.     for (i = 0; i < _CPUS_NR; i++)
  278.     {
  279.         rt_sprintf(tidle_name, "tidle%d", i);
  280.         rt_thread_init(&idle[i],
  281.                 tidle_name,
  282.                 rt_thread_idle_entry,
  283.                 RT_NULL,
  284.                 &rt_thread_stack[i][0],
  285.                 sizeof(rt_thread_stack[i]),
  286.                 RT_THREAD_PRIORITY_MAX - 1,
  287.                 32);
  288. #ifdef RT_USING_SMP
  289.         rt_thread_control(&idle[i], RT_THREAD_CTRL_BIND_CPU, (void*)i);
  290. #endif
  291.         /* startup */
  292.         rt_thread_startup(&idle[i]);
  293.     }
  294. }

  296. /**
  297. * @ingroup Thread
  298. *
  299. * This function will get the handler of the idle thread.
  300. *
  301. */
  302. rt_thread_t rt_thread_idle_gethandler(void)
  303. {
  304. #ifdef RT_USING_SMP
  305.     register int id = rt_hw_cpu_id();
  306. #else
  307.     register int id = 0;
  308. #endif

  310.     return (rt_thread_t)(&idle[id]);
  311. }
Build started: Project: project
*** Using Compiler 'V5.06 update 6 (build 750)', folder: 'g:Keil_v5ARMARMCCBin'
Build target 'rt-thread_gd32f30x'
compiling main.c...
applicationsmain.c(559): warning:  #177-D: variable "mind_a0_on1"  was declared but never referenced
    uint16_t  mind_a0_on, mind_a0_on1;
applicationsmain.c: 1 warning, 0 errors
linking...
Program Size: Code=106640 RO-data=11448 RW-data=1016 ZI-data=5672  
After Build - User command #1: fromelf --bin .buildrtthread-gd32f30x.axf --output rtthread.bin
".buildrtthread-gd32f30x.axf" - 0 Error(s), 1 Warning(s).
Build Time Elapsed:  00:00:02
Load "C:\rt-thread\bsp\gd32303e-eval\build\rtthread-gd32f30x.axf"
Dll Verison 1.06  Build date: 2019-06-23
Emulaor: MM32-LINK, SN: 0023557, Hardware: A, Firmware: 1.23
Manufacturer: MindMotion, Date: 2020-01-08
Appliaction: MM32-LINK, Version: 1.51
Connect Mode SWD, Speed Auto
Out put voltage 3.34V, current 0.00mA, target voltage 3.34V
Found SWD-DP with ID 0x410FC241
TPIU fitted.
ETM fitted.
Found Cortex-M4 , Little endian
FPUnit: 6 code (BP) slots and 2 literal slots
Data Watchpoint: 4
Erase Done.
Programming Done.
Verify OK.
Flash Load finished at 11:49:50




下后运行
com口

the temperature data is 26 degrees Celsius

the reference voltage data is 1.197V



the temperature data is 26 degrees Celsius

the reference voltage data is 1.199V



the temperature data is 26 degrees Celsius

the reference voltage data is 1.200V



the temperature data is 26 degrees Celsius

the reference voltage data is 1.198V



the temperature data is 26 degrees Celsius

the reference voltage data is 1.198V



the temperature data is 26 degrees Celsius

the reference voltage data is 1.199V



the temperature data is 26 degrees Celsius

the reference voltage data is 1.198V



the temperature data is 26 degrees Celsius

the reference voltage data is 1.198V



the temperature data is 26 degrees Celsius

the reference voltage data is 1.198V



Button2 Dowm_!a=11 the temperature data is 26 degrees Celsius

the reference voltage data is 1.200V



Button3 _Dowm!b=11 the temperature data is 26 degrees Celsius

the reference voltage data is 1.200V



Button4 _Dowm! the temperature data is 26 degrees Celsius

the reference voltage data is 1.197V



the temperature data is 26 degrees Celsius

the reference voltage data is 1.196V



the temperature data is 26 degrees Celsius

the reference voltage data is 1.198V


键盘显示及内部两路测试正常。








加入（PC3）模拟输入程序
  1. /*
  2. * File      : main.c
  3. * This file is part of RT-Thread RTOS
  4. * COPYRIGHT (C) 2009, RT-Thread Development Team
  5. *
  6. * The license and distribution terms for this file may be
  7. * found in the file LICENSE in this distribution or at
  8. * http://www.rt-thread.org/license/LICENSE
  9. *想用星空派gd32F303开发板资源  （P  F 7）输出（19），（PC3）模拟输入（29），板（P  F0~3）LED，板（PA 0 、PC13 、 P  F 5 、 P  F 4）button，来通过光耦中间继电器控制加热设备。
  10. * Change Logs:
  11. * Date           Author       Notes
  12. * 2021-10-29                                  first implementation
  13. */
  14. #include
  15. #include
  16. #include "stdio.h"
  17. #include
  18. #include
  19. #include "gd32f303e_eval.h"
  20. //#include "systick.h"
  21. #include "button.h"


  24. //adc
  25. float temperature;
  26. float vref_value;

  28. void rcu_config(void);
  29. void adc_config(void);
  30. void adc_init(void);

  32. /*!
  33.     brief      main function
  34.     param[in]  none
  35.     param[out] none
  36.     retval     none
  37. */
  38. //adc

  40.         uint8_t pin_count = 0;
  41.         volatile long  bootCount = 0;  //DF-A进行 1分，1.5分，10分状态。
  42. volatile uint8_t mind_n_As1;      //
  43. unsigned long startProducing, endProducing;
  44. volatile float  mind_n_key1, mind_n_all, mind_n_oninall;
  45. // 函数声明
  46. void DF_B(void*);
  47. void DF_onoff(uint16_t  mind_n_on, uint16_t  mind_n_off, uint8_t  mind_n_key);
  48. void DF_A(void*);
  49. static   rt_thread_t tid_dfa,tid_dfb;
  50.                         
  51. void  key_init (void)//（PA 0 、PC13 、 P  F 5 、 P  F 4）
  52. {
  53.         
  54.     /* 使能 GPIOC 时钟源 */
  55.     rcu_periph_clock_enable(RCU_GPIOA);
  56.     rcu_periph_clock_enable(RCU_GPIOC);        
  57.     rcu_periph_clock_enable(RCU_GPIOF);        

  59.     /* 配置按键为 浮空输入 */
  60.     gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_0);        //34
  61.     gpio_init(GPIOC, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_13);        //7
  62.     gpio_init(GPIOF, GPIO_MODE_IN_FLOATING , GPIO_OSPEED_50MHZ,GPIO_PIN_4|GPIO_PIN_5);        //14，15
  63.         
  64. }

  66. void  key_exit_mode_init (void)
  67. {
  68.         //复用功能时钟源
  69.         rcu_periph_clock_enable(RCU_AF);
  70.         
  71.         /* 配置中断优先级 */
  72.         nvic_irq_enable(EXTI10_15_IRQn, 2U, 0U);

  74.         /* 把对应的引脚连接到 exit外部中断  */
  75.         gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOC, GPIO_PIN_SOURCE_13);

  77.         /* 配置外部中断13 */
  78.         exti_init(EXTI_13, EXTI_INTERRUPT, EXTI_TRIG_FALLING);
  79.         exti_interrupt_flag_clear(EXTI_13);
  80. }


  83. uint8_t key_state_get(void)
  84. {
  85.     return gpio_input_bit_get(GPIOC, GPIO_PIN_13);
  86. }


  89. void  led_init (void)
  90. {
  91.                 /* 使能对应得时钟源 */
  92.     rcu_periph_clock_enable(RCU_GPIOF);
  93.     /* 配置引脚 */
  94.     gpio_init(GPIOF, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ,GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);//10~13
  95. }



  99. void led_on(int lednum)
  100. {
  101.         switch(lednum)
  102.         {
  103.                 case 0:
  104.                     gpio_bit_set(GPIOF,GPIO_PIN_0);
  105.                         break;
  106.                         
  107.                 case 1:
  108.                     gpio_bit_set(GPIOF,GPIO_PIN_1);
  109.                         break;
  110.                         
  111.                 case 2:
  112.                     gpio_bit_set(GPIOF,GPIO_PIN_2);
  113.                         break;

  115.                 case 3:
  116.                     gpio_bit_set(GPIOF,GPIO_PIN_3);
  117.                         break;
  118.         }
  119. }


  122. void led_off(int lednum)
  123. {
  124.         switch(lednum)
  125.     {
  126.                 case 0:
  127.                     gpio_bit_reset(GPIOF,GPIO_PIN_0);
  128.                         break;
  129.                         
  130.                 case 1:
  131.                     gpio_bit_reset(GPIOF,GPIO_PIN_1);
  132.                         break;
  133.                         
  134.                 case 2:
  135.                     gpio_bit_reset(GPIOF,GPIO_PIN_2);
  136.                         break;

  138.                 case 3:
  139.                     gpio_bit_reset(GPIOF,GPIO_PIN_3);
  140.                         break;
  141.         }
  142. }



  146. uint8_t Button_2 ,Button_3 ,Button_4 ;
  147.     Button_t Button2;
  148.     Button_t Button3;
  149.     Button_t Button4;
  150. uint8_t a,b,c;
  151. uint8_t a_v,b_v,c_v;
  152. uint8_t Button2_Dowm_v=0,Button2_Dowm_rgbv;
  153. //返回句柄
  154. uint8_t pin_r ,pin_g, pin_b , pin_4 , pinout_19;






  161. //GPIO模拟PWM的实体
  162. void pwm_entry(void* p){
  163. uint8_t count;
  164. while(1)    {
  165.     //设定脉宽200ms
  166.     count++;
  167.     count %=10;
  168. rt_thread_mdelay(1);
  169. //模拟pwm比较
  170. //红色的pwm输出
  171. if (a_v==5) {
  172. if( count>=a){
  173.     rt_pin_write(pin_r, PIN_LOW);
  174. }
  175. else {
  176.     rt_pin_write(pin_r,PIN_HIGH);
  177. }
  178. } else {
  179.      rt_pin_write(pin_r,PIN_HIGH);
  180. }

  182. //绿色的PWM输出
  183. if (b_v==5) {
  184.   if(count>=b)
  185. {
  186.     rt_pin_write(pin_g, PIN_LOW);
  187. }
  188. else {
  189.     rt_pin_write(pin_g,PIN_HIGH);
  190. }
  191. } else {
  192.         rt_pin_write(pin_g,PIN_HIGH);
  193. }

  195. //蓝色的pwm输出
  196. if (c_v==5) {
  197.   if(count>=c)
  198. {
  199.     rt_pin_write(pin_b, PIN_LOW);
  200. }
  201. else {
  202.     rt_pin_write(pin_b,PIN_HIGH);
  203. }
  204. } else {
  205.         rt_pin_write(pin_b,PIN_HIGH);
  206. }
  207. }
  208. }

  210. void test_button(void* p)
  211. {

  213.     uint8_t pin_count = 0;
  214. while (1){

  216.   Button_Process();

  218.   rt_thread_mdelay(10);
  219.           pin_count++;
  220.   if ((pin_count%500)==19) {

  222. }
  223. }
  224. }


  227. void pwm_init(){
  228.     rt_thread_t tid1;
  229. //      rt_err_t ret= RT_EOK ;

  231.     /* 设置PIN脚模式为输出 */
  232.     rt_pin_mode(pin_r, PIN_MODE_OUTPUT);
  233.     rt_pin_mode(pin_g, PIN_MODE_OUTPUT);
  234.     rt_pin_mode(pin_b, PIN_MODE_OUTPUT);
  235.     rt_pin_write(pin_r, PIN_HIGH);
  236.     rt_pin_write(pin_g, PIN_HIGH);
  237.     rt_pin_write(pin_b,PIN_HIGH);
  238. //       rt_thread_t rt_thread_create( "pwm_rgb",//const char* name
  239. //            pwm_entry,//void (*entry)(void* parameter)
  240. //            RT_NULL,//void* parameter
  241. //                               512 ,//rt_uint32_t stack_size
  242. //                               3 ,//rt_uint8_t priority
  243. //                               2 );//rt_uint32_t tick
  244.     tid1 = rt_thread_create( "pwm_rgb", pwm_entry, RT_NULL,  512 ,
  245.                                3 ,
  246.                                2 );
  247.     /* 如果获得线程控制块，启动这个线程 */
  248.     if (tid1 != RT_NULL)
  249.         rt_thread_startup(tid1);
  250.                
  251.     //    _button_hw_init               
  252.     tid1 = rt_thread_create( "button_hw", test_button, RT_NULL,  1024 ,5 , 2 );
  253.     /* 如果获得线程控制块，启动这个线程 */
  254.     if (tid1 != RT_NULL)
  255.         rt_thread_startup(tid1);

  257.     //    _DF_A_hw_init
  258. //      tid_dfa = rt_thread_create( "DF_A", DF_A, RT_NULL,  1024 ,6 , 2 );
  259.     /* 如果获得线程控制块，启动这个线程 */
  260. //  if (tid_dfa != RT_NULL)
  261. //  rt_thread_startup(tid1);
  262. //    xTaskCreate(
  263. //                        DF_A,       /* Task function. */
  264. //                        "DF_A",     /* String with name of task. */
  265. //                        20000,             /* Stack size in words. */
  266. //                        NULL,              /* Parameter passed as input of the task */
  267. //                        2,                 /* Priority of the task. */
  268. //                        NULL);
  269. }



  273. //    Button
  274. uint8_t Read_Button2_Level(void)
  275. {
  276.   return rt_pin_read(Button_2);
  277. }

  279. uint8_t Read_Button3_Level(void)
  280. {
  281.     return rt_pin_read(Button_3);
  282. }


  285. uint8_t Read_Button4_Level(void)
  286. {
  287.     return rt_pin_read(Button_4);
  288. }


  291. void Btn2_Dowm_CallBack(void *btn)
  292. {
  293.   rt_kprintf("Button2 Dowm_!");
  294.   Button2_Dowm_v=1;
  295.   a++;
  296.   rt_kprintf("a=%d",a);
  297.   if (a>10) {a_v=5;
  298.       a=0;
  299. }else {a_v=5;

  301. }
  302. }

  304. void Btn2_Double_CallBack(void *btn)
  305. {
  306.   rt_kprintf("Button2 _Double_!");
  307. }

  309. void Btn2_Long_CallBack(void *btn)
  310. {
  311.   rt_kprintf("Button2_Long_!");

  313. //  Button_Delete(&Button2);
  314. //  rt_kprintf("删除Button2");
  315. //  Search_Button();
  316. }


  319. void Btn3_Dowm_CallBack(void *btn)
  320. {
  321.   rt_kprintf("Button3 _Dowm!");
  322.   b++;
  323.   rt_kprintf("b=%d",b);
  324.   if (b>10) {b_v=5;
  325.       b=0;
  326. }else {b_v=5;

  328. }
  329. }

  331. void Btn3_Double_CallBack(void *btn)
  332. {
  333.   rt_kprintf("Button3_Double_!");
  334. }

  336. void Btn3_Long_CallBack(void *btn)
  337. {
  338.   rt_kprintf("Button3 _Long_!");

  340. //  Button_Delete(&Button2);
  341. //  rt_kprintf("删除Button3");
  342. //  Search_Button();
  343. }

  345. void Btn4_Dowm_CallBack(void *btn)
  346. {
  347.   rt_kprintf("Button4 _Dowm!");
  348.   c++;if (c>10) {
  349.       c=0;
  350. }
  351. }

  353. void Btn4_Double_CallBack(void *btn)
  354. {
  355.   rt_kprintf("Button4 _Double_!");
  356. }

  358. void Btn4_Long_CallBack(void *btn)
  359. {
  360.   rt_kprintf("Button4 long_Dowm !");

  362. //  Button_Delete(&Button2);
  363. //  rt_kprintf("删除Button4");
  364. //  Search_Button();
  365. }


  368. uint16_t   adc_val_1;
  369. int main(void)
  370. {
  371. #define KEY_ON   0     //
  372.     //    Button
  373.     Button_2    = 34;//get_pin(34)//    22
  374.     Button_3    = 7;//get_pin(7);    21
  375.     Button_4    = 15;//get_pin(15);    2
  376.     rt_pin_mode(Button_2 , PIN_MODE_INPUT_PULLUP);
  377.     rt_pin_mode(Button_3 , PIN_MODE_INPUT_PULLUP);
  378.     rt_pin_mode(Button_4 , PIN_MODE_INPUT_PULLUP);

  380.     Button_Create("Button3",
  381.                 &Button3,
  382.                 Read_Button3_Level,
  383.                 KEY_ON);
  384.     Button_Attach(&Button3,BUTTON_DOWM,Btn3_Dowm_CallBack);                       //单击
  385.     Button_Attach(&Button3,BUTTON_DOUBLE,Btn3_Double_CallBack);                   //双击
  386. //    Button_Attach(&Button3,BUTTON_CONTINUOS,Btn3_Continuos_CallBack);             //连按
  387. //    Button_Attach(&Button3,BUTTON_CONTINUOS_FREE,Btn3_ContinuosFree_CallBack);    //连按释放
  388.     Button_Attach(&Button3,BUTTON_LONG,Btn3_Long_CallBack);                       //长按


  391.     Button_Create("Button2",
  392.                 &Button2,
  393.                 Read_Button2_Level,
  394.                 KEY_ON);
  395.     Button_Attach(&Button2,BUTTON_DOWM,Btn2_Dowm_CallBack);                     //单击
  396.     Button_Attach(&Button2,BUTTON_DOUBLE,Btn2_Double_CallBack);                 //双击
  397. //    Button_Attach(&Button2,BUTTON_CONTINUOS,Btn2_Continuos_CallBack);           //连按
  398. //    Button_Attach(&Button2,BUTTON_CONTINUOS_FREE,Btn2_ContinuosFree_CallBack);  //连按释放
  399.     Button_Attach(&Button2,BUTTON_LONG,Btn2_Long_CallBack);                     //长按



  403.     Button_Create("Button4",
  404.                 &Button4,
  405.                 Read_Button4_Level,
  406.                 KEY_ON);
  407.     Button_Attach(&Button4,BUTTON_DOWM,Btn4_Dowm_CallBack);                     //单击
  408.     Button_Attach(&Button4,BUTTON_DOUBLE,Btn4_Double_CallBack);                 //双击
  409. //    Button_Attach(&Button4,BUTTON_CONTINUOS,Btn4_Continuos_CallBack);           //连按
  410. //    Button_Attach(&Button4,BUTTON_CONTINUOS_FREE,Btn4_ContinuosFree_CallBack);  //连按释放
  411.     Button_Attach(&Button4,BUTTON_LONG,Btn4_Long_CallBack);                     //长按

  413.     Get_Button_Event(&Button4);
  414.     Get_Button_Event(&Button3);
  415.     Get_Button_Event(&Button2);





  421.      pin_r = 10;//rt_pin_get(10);
  422.      pin_g = 11;//rt_pin_get(11);
  423.      pin_b = 12;//rt_pin_get(12);
  424.                 pin_4= 13;//rt_pin_get(13);
  425.                 pinout_19= 19;//out_rt_pin_get(19);
  426.     rt_pin_mode(pin_r, PIN_MODE_OUTPUT);
  427.     rt_pin_mode(pin_g, PIN_MODE_OUTPUT);
  428.     rt_pin_mode(pin_b, PIN_MODE_OUTPUT);
  429.     rt_pin_mode(pin_4, PIN_MODE_OUTPUT);        
  430.     rt_pin_mode(pinout_19, PIN_MODE_OUTPUT);                        
  431.     rt_kprintf("Hello, worldn");
  432.     a=10;b=10;c=10;//pin_rgb不亮
  433.     a_v=5;b_v=5;c_v=5;//pin_rgb允许
  434. //    _irrx_hw_init();
  435.     pwm_init();
  436.     mind_n_key1 = 0;

  438. //    uint8_t pin_count = 0;
  439. //    while (1)
  440. //    {
  441. //
  442. //        rt_pin_write(pin_r, pin_count&0x1);
  443. //        rt_pin_write(pin_g,( pin_count>>1)&0x1);
  444. //        rt_pin_write(pin_b, ( pin_count>>2)&0x1);
  445. //        rt_thread_mdelay(50);
  446. //        rt_pin_write(pin_r, 0x1);
  447. //        rt_pin_write(pin_g, 0x1);
  448. //        rt_pin_write(pin_b,0x1);
  449. //        rt_thread_mdelay(500);
  450. //        pin_count++;
  451. //    }
  452. //adc
  453.     /* system clocks configuration */
  454.     rcu_config();
  455.     /* configure systick */
  456.     //systick_config();  
  457.     /* ADC configuration */
  458.     adc_config();
  459.     /* USART configuration */
  460.     //gd_eval_com_init(EVAL_COM1);
  461. //adc

  463. //adc
  464.         /* ADC software trigger enable */
  465.         adc_software_trigger_enable(ADC0, ADC_INSERTED_CHANNEL);
  466.         /* delay a time in milliseconds */
  467.         rt_thread_mdelay(2000);
  468.       
  469.         /* value convert  */
  470.         temperature = (1.43 - ADC_IDATA0(ADC0)*3.3/4096) * 1000 / 4.3 + 25;
  471.         vref_value = (ADC_IDATA1(ADC0) * 3.3 / 4096);
  472.       
  473.         /* value print */
  474.         printf(" the temperature data is %2.0f degrees Celsiusrn", temperature);
  475.         printf(" the reference voltage data is %5.3fV rn", vref_value);
  476.         printf(" rn");
  477.                                 //*!      disable the temperature sensor and Vrefint channel
  478.                                 adc_tempsensor_vrefint_disable();
  479.                                 adc_init();//pc3
  480. //adc

  482.     while (1){

  484.                                 /* ADC software trigger enable */
  485.         adc_software_trigger_enable(ADC0, ADC_INSERTED_CHANNEL);
  486.         /* delay a time in milliseconds */
  487.         rt_thread_mdelay(2000);
  488.       
  489.         /* value convert  */
  490.         adc_val_1 = ADC_IDATA0(ADC0); //pc3   IN13
  491. //        adc_val_2 = ADC_IDATA1(ADC0);//PC5   IN15
  492.       
  493.         /* value print */
  494.         printf(" adc val 1 is 0x%xrn", adc_val_1);
  495. //        printf(" adc val 2 is 0x%xrn", adc_val_2);
  496.         printf(" rn");

  498.                         
  499.       rt_thread_mdelay(500);




  504.     if(bootCount==0x0a55aa00){

  506.              bootCount=0x0a55aa01; //启动DeepSleep
  507. //     endProducing= clock_cpu_millisecond();
  508.         }
  509.     if(bootCount==0x0a55aa01){
  510.                               rt_thread_mdelay(90000);
  511. //             if(clock_cpu_millisecond() - endProducing > 90000){
  512. //          xTaskCreate(
  513. //                        DF_A,
  514. //                        "DF_A",     /* String with name of task. */
  515. //                        20000,             /* Stack size in words. */
  516. //                        NULL,              /* Parameter passed as input of the task */
  517. //                        2,                 /* Priority of the task. */
  518. //                        NULL);
  519.           tid_dfa = rt_thread_create( "DF_A", DF_A, RT_NULL,  1024 ,6 , 2 );
  520.           /* 如果获得线程控制块，启动这个线程 */
  521.           if (tid_dfa != RT_NULL)
  522.               rt_thread_startup(tid_dfa);
  523.           //    _DF_A_hw_init

  525. //         }

  527.           }
  528.       if(mind_n_key1==2) {
  529. //          digitalWrite(OUT_PWM, LOW);
  530.     rt_pin_write(pinout_19,PIN_LOW);
  531.       }
  532.           if(bootCount==1) {
  533.              rt_thread_mdelay(6); //delay(6);
  534.                   bootCount=0;
  535.        if (mind_n_key1==0) {

  537. //    xTaskCreate(
  538. //                        DF_A,
  539. //                        "DF_A",     /* String with name of task. */
  540. //                        20000,             /* Stack size in words. */
  541. //                        NULL,              /* Parameter passed as input of the task */
  542. //                        2,                 /* Priority of the task. */
  543. //                        NULL);
  544.            tid_dfa = rt_thread_create( "DF_A", DF_A, RT_NULL,  1024 ,6 , 2 );
  545.            /* 如果获得线程控制块，启动这个线程 */
  546.            if (tid_dfa != RT_NULL)
  547.                rt_thread_startup(tid_dfa);
  548.            //    _DF_A_hw_init

  550.     }
  551.       if (mind_n_key1==1) {


  554. //    xTaskCreate(
  555. //                        DF_B,
  556. //                        "DF_B",     /* String with name of task. */
  557. //                        10000,             /* Stack size in words. */
  558. //                        NULL,              /* Parameter passed as input of the task */
  559. //                        2,                 /* Priority of the task. */
  560. //                        NULL);
  561.           tid_dfb = rt_thread_create( "DF_B", DF_B, RT_NULL,  1024 ,6 , 2 );
  562.           /* 如果获得线程控制块，启动这个线程 */
  563.           if (tid_dfb!= RT_NULL)
  564.               rt_thread_startup(tid_dfb);
  565.           //    _DF_A_hw_init

  567.     }


  570.       }

  572.     }

  574. }


  577. // 自定义函数

  579. void DF_B(void * parameter) {
  580.   uint16_t  mind_a0_on, mind_a0_on1;
  581. //       Serial.print("Created task DF_b: Executing on core ");
  582. //   Serial.println(xPortGetCoreID());
  583.   while (mind_n_key1==1)  {
  584.     mind_a0_on=0;
  585.      for(b=0;b<8;b++){//检测双击 循环10次200ms

  587. //      startProducing = ESP.getCycleCount();//开始时间
  588. //           mind_a0_on1=analogRead(IN_0);
  589. //           mind_a0_on+=mind_a0_on1;
  590. //          endProducing = ESP.getCycleCount();//结束时间
  591.         //      Serial.print("mind_a0_on input A0 time all时间(CycleCount): ");
  592. //              Serial.println(( endProducing - startProducing));//写入耗费时间(CycleCount)
  593.         //      Serial.printf("DF_b(analogRead(IN_0))%d： %d   %d  n",b,mind_a0_on1,mind_a0_on);//
  594.   //      Serial.println("");
  595.      }

  597.     DF_onoff(mind_a0_on>>5, 1023, 1);



  601.   }


  604.    bootCount = 1;
  605.     //      Serial.println("删除DF_b");
  606. //    vTaskDelete( NULL );  //任务的删除
  607.     //      rt_thread_delete();//任务的删除
  608. }

  610. void DF_onoff(uint16_t  mind_n_on, uint16_t  mind_n_off, uint8_t  mind_n_key) {
  611.   //      Serial.printf("DF_onoff Cycle Count  mind_n_on:%d, uint16_t  mind_n_off:%d, uint8_t  mind_n_key:%dn",mind_n_on,mind_n_off, mind_n_key);//

  613.   while ((mind_n_off>0)) {
  614.     while ((mind_n_on>0)) {
  615.       //      digitalWrite(OUT_PWM, HIGH);
  616.       //      delay(6);
  617.       mind_n_off -= 1;
  618.       mind_n_on -= 1;
  619.       if (!(mind_n_key==mind_n_key1)) {

  621.         mind_n_off = 0;
  622.         mind_n_on = 0;
  623.    bootCount = 1;
  624.     }
  625.     }
  626.     if ((mind_n_off>0)) {
  627.       //      digitalWrite(OUT_PWM, LOW);
  628.       //      delay(6);
  629.       mind_n_off -= 1;
  630.       if (!(mind_n_key==mind_n_key1)) {

  632.         mind_n_off = 0;
  633.         mind_n_on = 0;
  634.    bootCount = 1;
  635.     }
  636.     }

  638.   }
  639. }
  640. void DF_A(void * parameter) {



  644.       //      Serial.print("Created task DF_A: Executing on core ");
  645.     //      Serial.println(xPortGetCoreID());
  646. //      startProducing = millis();//开始时间

  648. if(bootCount==0x0a55aa01){
  649.    bootCount = 0;
  650. uint8_t   mind_n_Asn = 80;


  653.         //      Serial.print("DF_A to 50% start Producing time 时间(ms): ");
  654.         //      Serial.println(( millis() - startProducing));//写入耗费时间(ms)
  655.   while (!(mind_n_Asn==0)) {
  656.     DF_onoff(490, 1023, 0);
  657.      if (mind_n_key1==0) {
  658.       mind_n_Asn -= 1;
  659.     }
  660.     else {
  661.    bootCount = 1;
  662.       mind_n_Asn = 0;
  663.     }

  665.   }
  666. }
  667. else{
  668.   mind_n_As1 = 10;
  669.   while (mind_n_As1>0) {
  670.     DF_onoff(1023, 1023, 0);


  673.     if (mind_n_key1==0) {

  675.       mind_n_As1 -= 1;

  677.     }
  678.     else {

  680.       mind_n_As1 = 0;
  681.    bootCount = 1;
  682.     }
  683. }
  684.      if (mind_n_key1==0) {
  685.         //      Serial.print("DF_A 启动1分 时间(ms): ");
  686.         //      Serial.println(( millis() - startProducing));//写入耗费时间(ms)
  687.        //      Serial.print("启动1.5分连续 :");
  688.        bootCount=0x0a55aa00; //启动DeepSleep

  690.     //      Serial.println(bootCount);
  691.   //      delay(1);
  692.     //      Serial.println("删除DF_A");
  693.     //      vTaskDelete( NULL );  //任务的删除

  695.      }

  697.   }

  699.     //      endProducing = millis();//结束时间
  700.         //      Serial.print("Producing time all时间(ms): ");
  701.         //      Serial.println(( endProducing - startProducing));//写入耗费时间(ms)
  702.   if (mind_n_key1==0) {
  703.     mind_n_key1 = 2;
  704.   }

  706.     //      Serial.println("删除DF_A");
  707.     //      vTaskDelete( NULL );  //任务的删除

  709. }



  713. /*!
  714.     brief      configure the different system clocks
  715.     param[in]  none
  716.     param[out] none
  717.     retval     none
  718. */
  719. void rcu_config(void)
  720. {
  721.     /* enable ADC clock */
  722.     rcu_periph_clock_enable(RCU_ADC0);
  723.     /* config ADC clock */
  724.     rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV6);
  725. }

  727. /*!
  728.     brief      configure the ADC peripheral
  729.     param[in]  none
  730.     param[out] none
  731.     retval     none
  732. */
  733. void adc_config(void)
  734. {
  735.     /* ADC SCAN function enable */
  736.     adc_special_function_config(ADC0,ADC_SCAN_MODE,ENABLE);  
  737.     /* ADC trigger config */
  738.     adc_external_trigger_source_config(ADC0, ADC_INSERTED_CHANNEL, ADC0_1_2_EXTTRIG_INSERTED_NONE);
  739.     /* ADC data alignment config */
  740.     adc_data_alignment_config(ADC0,ADC_DATAALIGN_RIGHT);
  741.     /* ADC mode config */
  742.     adc_mode_config(ADC_MODE_FREE);  
  743.     /* ADC channel length config */
  744.     adc_channel_length_config(ADC0,ADC_INSERTED_CHANNEL,2);

  746.     /* ADC temperature sensor channel config */
  747.     adc_inserted_channel_config(ADC0, 0, ADC_CHANNEL_16, ADC_SAMPLETIME_239POINT5);
  748.     /* ADC internal reference voltage channel config */
  749.     adc_inserted_channel_config(ADC0, 1, ADC_CHANNEL_17, ADC_SAMPLETIME_239POINT5);

  751.     /* ADC external trigger enable */
  752.     adc_external_trigger_config(ADC0,ADC_INSERTED_CHANNEL,ENABLE);

  754.     /* ADC temperature and Vrefint enable */
  755.     adc_tempsensor_vrefint_enable();

  757.    
  758.     /* enable ADC interface */
  759.     adc_enable(ADC0);
  760.     rt_thread_mdelay(1);   
  761.     /* ADC calibration and reset calibration */
  762.     adc_calibration_enable(ADC0);
  763. }

  765. // 事件回调函数

  767. //宏: [RT_USING_CPUTIME]
  768. //使能此选项时，BSP 应提供 rt_clock_cputime_ops 为 CPU 时间，通过
  769. //const static struct rt_clock_cputime_ops _ops = {...};
  770. //clock_cpu_setops(&_ops);
  771. //
  772. //然后开发者能够使用高精度的时钟计数:
  773. //
  774. //ts1 = clock_cpu_gettime();
  775. //ts2 = clock_cpu_gettime();
  776. //
  777. ///* and get the ms of delta tick with API: */
  778. //ms_tick = clock_cpu_millisecond(t2 - t1);
  779. //us_tick = clock_cpu_microsecond(t2 - t1);

  781. void adc_init(void)
  782. {
  783.         //adc 引脚初始化
  784.         
  785.         /* 使能 GPIOC clock */
  786.     rcu_periph_clock_enable(RCU_GPIOC);
  787.         
  788.     /* 设置PC3  引脚为模拟输入 */  
  789.     gpio_init(GPIOC, GPIO_MODE_AIN, GPIO_OSPEED_MAX, GPIO_PIN_3 );
  790. //adc 引脚初始化
  791.         
  792.         /* 使能ADC0 时钟源 */
  793.     rcu_periph_clock_enable(RCU_ADC0);
  794.     /* 配置预分频 */
  795.     rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV6);

  797.         
  798.         /* ADC 扫描模式打开 */
  799.         adc_special_function_config(ADC0,ADC_SCAN_MODE,ENABLE);  
  800.         /* ADC 触发方式配置 不需要外部触发 */
  801.         adc_external_trigger_source_config(ADC0, ADC_INSERTED_CHANNEL, ADC0_1_2_EXTTRIG_INSERTED_NONE);
  802.         /* 数据右对齐 */
  803.         adc_data_alignment_config(ADC0,ADC_DATAALIGN_RIGHT);
  804.         /* ADC 模式配置，所有ADC独立工作 */
  805.         adc_mode_config(ADC_MODE_FREE);  
  806.         /* ADC 转换通道大小配置，2个通道 */
  807.         adc_channel_length_config(ADC0,ADC_INSERTED_CHANNEL,1);

  809.         /* ADC 通道配置 */
  810.         adc_inserted_channel_config(ADC0, 0, ADC_CHANNEL_13, ADC_SAMPLETIME_239POINT5);
  811.         /* ADC 通道配置 */
  812.         //adc_inserted_channel_config(ADC0, 1, ADC_CHANNEL_15, ADC_SAMPLETIME_239POINT5);

  814.         /* ADC 插入组使能 */
  815.         adc_external_trigger_config(ADC0,ADC_INSERTED_CHANNEL,ENABLE);
  816.         
  817.         /* 使能ADC */
  818.         adc_enable(ADC0);
  819.     rt_thread_mdelay(1);//        delay_1ms(1);         
  820.         /* ADC 校准 */
  821.         adc_calibration_enable(ADC0);
  822. }







Build started: Project: project
*** Using Compiler 'V5.06 update 6 (build 750)', folder: 'g:Keil_v5ARMARMCCBin'
Build target 'rt-thread_gd32f30x'
compiling main.c...
applicationsmain.c(580): warning:  #177-D: variable "mind_a0_on1"  was declared but never referenced
    uint16_t  mind_a0_on, mind_a0_on1;
applicationsmain.c: 1 warning, 0 errors
linking...
Program Size: Code=107128 RO-data=11488 RW-data=1020 ZI-data=5676  
After Build - User command #1: fromelf --bin .buildrtthread-gd32f30x.axf --output rtthread.bin
".buildrtthread-gd32f30x.axf" - 0 Error(s), 1 Warning(s).
Build Time Elapsed:  00:00:07
Load "C:\rt-thread\bsp\gd32303e-eval\build\rtthread-gd32f30x.axf"
Dll Verison 1.06  Build date: 2019-06-23
Emulaor: 32-LINK, SN: 0023557, Hardware: A, Firmware: 1.23
Manufacturer: , Date: 2020-01-08
Appliaction: 32-LINK, Version: 1.51
Connect Mode SWD, Speed Auto
Out put voltage 3.34V, current 0.00mA, target voltage 3.34V
Found SWD-DP with ID 0x410FC241
TPIU fitted.
ETM fitted.
Found Cortex-M4 , Little endian
FPUnit: 6 code (BP) slots and 2 literal slots
Data Watchpoint: 4
Erase Done.
Programming Done.
Verify OK.
Flash Load finished at 14:36:30


com口
未标题-1 拷贝.jpg

更多回帖

0 0 0

相关帖子

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