21ic电子技术开发论坛 › 单片机与嵌入式系统 › 侃单片机论坛 › 用SAM-BA或JLINK跑ATSAM4E16的程序(17)ASF RTC
返回列表 发新帖我要提问

[Atmel] 用SAM-BA或JLINK跑ATSAM4E16的程序(17)ASF RTC

[复制链接]
931|0
 楼主| ddllxxrr 发表于 2015-11-24 21:43 | 显示全部楼层 |阅读模式
sam4e, link, RTC, SAM-BA, TE
本帖最后由 ddllxxrr 于 2015-11-24 21:54 编辑

RTC可选内部或外部32.768kHz晶振驱动。可定时，报警，更新时间/日历,还可以通过RTCOUT0和RTCOUT1输出波形。


以下程序就是同串**互，可以设日期，设时间，设报警时间，设日期报警，清除报警，和产生波形：

程序如下：

复制
  1. #include "asf.h"
    

  2. #include "stdio_serial.h"
    

  3. #include "conf_clock.h"
    

  4. #include "conf_board.h"
    


  5. 

  6. /// [url=home.php?mod=space&uid=1302964]@cond[/url] 0
    

  7. /**INDENT-OFF**/
    

  8. #ifdef __cplusplus
    

  9. extern "C" {
    

  10. #endif
    

  11. /**INDENT-ON**/
    

  12. /// @endcond
    


  13. 

  14. /* Main menu is being displayed. */
    

  15. #define STATE_MENU             0
    

  16. /* Time is being edited. */
    

  17. #define STATE_SET_TIME         1
    

  18. /* Date is being edited. */
    

  19. #define STATE_SET_DATE         2
    

  20. /* Time alarm is being edited. */
    

  21. #define STATE_SET_TIME_ALARM   3
    

  22. /* Date alarm is being edited. */
    

  23. #define STATE_SET_DATE_ALARM   4
    

  24. /* Wave generating is being edited. */
    

  25. #define STATE_WAVEFORM         5
    


  26. 

  27. /* Maximum size of edited string. */
    

  28. #define MAX_EDIT_SIZE          10
    


  29. 

  30. /* Macro for converting char to digit. */
    

  31. #define char_to_digit(c) ((c) - '0')
    


  32. 

  33. #define STRING_EOL    "\r"
    

  34. #define STRING_HEADER "-- RTC Example --\r\n" \
    

  35.                 "-- "BOARD_NAME" --\r\n" \
    

  36.                 "-- Compiled: "__DATE__" "__TIME__" --"STRING_EOL
    


  37. 

  38. /* Current state of application. */
    

  39. static uint32_t gs_ul_state = STATE_MENU;
    


  40. 

  41. /* Edited hour. */
    

  42. static uint32_t gs_ul_new_hour;
    

  43. /* Edited minute. */
    

  44. static uint32_t gs_ul_new_minute;
    

  45. /* Edited second. */
    

  46. static uint32_t gs_ul_new_second;
    


  47. 

  48. /* Edited year. */
    

  49. static uint32_t gs_ul_new_year;
    

  50. /* Edited month. */
    

  51. static uint32_t gs_ul_new_month;
    

  52. /* Edited day. */
    

  53. static uint32_t gs_ul_new_day;
    

  54. /* Edited day-of-the-week. */
    

  55. static uint32_t gs_ul_new_week;
    


  56. 

  57. /* Indicate if alarm has been triggered and not yet cleared */
    

  58. static uint32_t gs_ul_alarm_triggered = 0;
    


  59. 

  60. /* Time string */
    

  61. static uint8_t gs_uc_rtc_time[8 + 1] =
    

  62.                 { '0', '0', ':', '0', '0', ':', '0', '0', '\0' };
    

  63. /* Date string */
    

  64. static uint8_t gs_uc_date[10 + 1] =
    

  65.                 { '0', '0', '/', '0', '0', '/', '0', '0', '0', '0', '\0' };
    

  66. /* Week string */
    

  67. static uint8_t gs_uc_day_names[7][4] =
    

  68.                 { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
    


  69. 

  70. /* Flag for refreshing menu */
    

  71. static uint32_t gs_ul_menu_shown = 0;
    


  72. 

  73. /**
    

  74.  *  Configure UART console.
    

  75.  */
    

  76. static void configure_console(void)
    

  77. {
    

  78.         const usart_serial_options_t uart_serial_options = {
    

  79.                 .baudrate = CONF_UART_BAUDRATE,
    

  80. #ifdef CONF_UART_CHAR_LENGTH
    

  81.                 .charlength = CONF_UART_CHAR_LENGTH,
    

  82. #endif
    

  83.                 .paritytype = CONF_UART_PARITY,
    

  84. #ifdef CONF_UART_STOP_BITS
    

  85.                 .stopbits = CONF_UART_STOP_BITS,
    

  86. #endif
    

  87.         };
    


  88. 

  89.         /* Configure console UART. */
    

  90.         sysclk_enable_peripheral_clock(CONSOLE_UART_ID);
    

  91.         stdio_serial_init(CONF_UART, &uart_serial_options);
    

  92. }
    


  93. 

  94. /**
    

  95.  * \brief Get new time. Successful value is put in gs_ul_new_hour,
    

  96.  * gs_ul_new_minute, gs_ul_new_second.
    

  97.  */
    

  98. static uint32_t get_new_time(void)
    

  99. {
    

  100.         uint8_t uc_key;
    

  101.         uint32_t i = 0;
    


  102. 

  103.         /* Clear setting variable. */
    

  104.         gs_ul_new_hour = 0xFFFFFFFF;
    

  105.         gs_ul_new_minute = 0xFFFFFFFF;
    

  106.         gs_ul_new_second = 0xFFFFFFFF;
    


  107. 

  108.         /* Use gs_uc_rtc_time[] as a format template. */
    

  109.         while (1) {
    


  110. 

  111.                 scanf("%c", (char *)&uc_key);
    


  112. 

  113.                 /* End input */
    

  114.                 if (uc_key == 0x0d || uc_key == 0x0a) {
    

  115.                         puts("\r");
    

  116.                         break;
    

  117.                 }
    


  118. 

  119.                 /* DEL or BACKSPACE */
    

  120.                 if (uc_key == 0x7f || uc_key == 0x08) {
    

  121.                         if (i > 0) {
    

  122.                                 /* End of gs_uc_rtc_time[], then one more back of index */
    

  123.                                 if (!gs_uc_rtc_time[i]) {
    

  124.                                         --i;
    

  125.                                 }
    


  126. 

  127.                                 puts("\b \b");
    

  128.                                 --i;
    


  129. 

  130.                                 /* Delimiter ':' for time is uneditable */
    

  131.                                 if (!((gs_uc_rtc_time[i]) >= '0' && (gs_uc_rtc_time[i]) <= '9')
    

  132.                                                 && i > 0) {
    

  133.                                         puts("\b \b");
    

  134.                                         --i;
    

  135.                                 }
    

  136.                         }
    

  137.                 }
    


  138. 

  139.                 /*
    

  140.                  * End of gs_uc_rtc_time[], no more input except the above DEL/BS,
    

  141.                  * or enter to end.
    

  142.                  */
    

  143.                 if (!gs_uc_rtc_time[i]) {
    

  144.                         continue;
    

  145.                 }
    


  146. 

  147.                 printf("%c", uc_key);
    

  148.                 gs_uc_rtc_time[i++] = uc_key;
    


  149. 

  150.         }
    


  151. 

  152.         if (i == 0) {
    

  153.                 return 0;
    

  154.         }
    


  155. 

  156.         if (i != 0 && gs_uc_rtc_time[i] != '\0') {
    

  157.                 /* Failure input */
    

  158.                 return 1;
    

  159.         }
    


  160. 

  161.         gs_ul_new_hour = char_to_digit(gs_uc_rtc_time[0]) * 10 +
    

  162.                         char_to_digit(gs_uc_rtc_time[1]);
    

  163.         gs_ul_new_minute = char_to_digit(gs_uc_rtc_time[3]) * 10 +
    

  164.                         char_to_digit(gs_uc_rtc_time[4]);
    

  165.         gs_ul_new_second = char_to_digit(gs_uc_rtc_time[6]) * 10 +
    

  166.                         char_to_digit(gs_uc_rtc_time[7]);
    


  167. 

  168.         /* Success input. Verification of data is left to RTC internal Error Checking. */
    

  169.         return 0;
    

  170. }
    


  171. 

  172. /**
    

  173.  * \brief Calculate week from year, month, day.
    

  174.  */
    

  175. static uint32_t calculate_week(uint32_t ul_year, uint32_t ul_month,
    

  176.                 uint32_t ul_day)
    

  177. {
    

  178.         uint32_t ul_week;
    


  179. 

  180.         if (ul_month == 1 || ul_month == 2) {
    

  181.                 ul_month += 12;
    

  182.                 --ul_year;
    

  183.         }
    


  184. 

  185.         ul_week = (ul_day + 2 * ul_month + 3 * (ul_month + 1) / 5 + ul_year +
    

  186.                         ul_year / 4 - ul_year / 100 + ul_year / 400) % 7;
    


  187. 

  188.         ++ul_week;
    


  189. 

  190.         return ul_week;
    

  191. }
    


  192. 

  193. /**
    

  194.  * \brief Get new time. Successful value is put in gs_ul_new_year,
    

  195.  * gs_ul_new_month, gs_ul_new_day, gs_ul_new_week.
    

  196.  */
    

  197. static uint32_t get_new_date(void)
    

  198. {
    

  199.         uint8_t uc_key;
    

  200.         uint32_t i = 0;
    


  201. 

  202.         /* Clear setting variable */
    

  203.         gs_ul_new_year = 0xFFFFFFFF;
    

  204.         gs_ul_new_month = 0xFFFFFFFF;
    

  205.         gs_ul_new_day = 0xFFFFFFFF;
    

  206.         gs_ul_new_week = 0xFFFFFFFF;
    


  207. 

  208.         /* Use gs_uc_rtc_time[] as a format template */
    

  209.         while (1) {
    


  210. 

  211.                 scanf("%c", (char *)&uc_key);
    


  212. 

  213.                 /* End input */
    

  214.                 if (uc_key == 0x0d || uc_key == 0x0a) {
    

  215.                         puts("\r");
    

  216.                         break;
    

  217.                 }
    


  218. 

  219.                 /* DEL or BACKSPACE */
    

  220.                 if (uc_key == 0x7f || uc_key == 0x08) {
    

  221.                         if (i > 0) {
    

  222.                                 /* End of date[], then one more back of index */
    

  223.                                 if (!gs_uc_date[i]) {
    

  224.                                         --i;
    

  225.                                 }
    


  226. 

  227.                                 puts("\b \b");
    

  228.                                 --i;
    


  229. 

  230.                                 /* Delimiter '/' for date is uneditable */
    

  231.                                 if (!((gs_uc_date[i]) >= '0' && (gs_uc_date[i]) <='9')
    

  232.                                                 && i > 0) {
    

  233.                                         puts("\b \b");
    

  234.                                         --i;
    

  235.                                 }
    

  236.                         }
    

  237.                 }
    


  238. 

  239.                 /*
    

  240.                  * End of gs_uc_rtc_time[], no more input except the above DEL/BS,
    

  241.                  * or enter to end.
    

  242.                  */
    

  243.                 if (!gs_uc_date[i]) {
    

  244.                         continue;
    

  245.                 }
    


  246. 

  247.                 printf("%c", uc_key);
    

  248.                 gs_uc_date[i++] = uc_key;
    


  249. 

  250.         }
    


  251. 

  252.         if (i == 0) {
    

  253.                 return 0;
    

  254.         }
    


  255. 

  256.         if (i != 0 && gs_uc_date[i] != '\0' && i != 6) {
    

  257.                 /* Failure input */
    

  258.                 return 1;
    

  259.         }
    


  260. 

  261.         /* MM-DD-YY */
    

  262.         gs_ul_new_month = char_to_digit(gs_uc_date[0]) * 10
    

  263.                         + char_to_digit(gs_uc_date[1]);
    

  264.         gs_ul_new_day = char_to_digit(gs_uc_date[3]) * 10
    

  265.                         + char_to_digit(gs_uc_date[4]);
    

  266.         if (i != 6) {
    

  267.                 /* For 'Set Date' option, get the input new year and new week. */
    

  268.                 gs_ul_new_year = char_to_digit(gs_uc_date[6]) * 1000 +
    

  269.                                 char_to_digit(gs_uc_date[7]) * 100 +
    

  270.                                 char_to_digit(gs_uc_date[8]) * 10 +
    

  271.                                 char_to_digit(gs_uc_date[9]);
    

  272.                 gs_ul_new_week = calculate_week(gs_ul_new_year, gs_ul_new_month,
    

  273.                                 gs_ul_new_day);
    

  274.         }
    


  275. 

  276.         /*
    

  277.          * Success input. Verification of data is left to RTC internal Error
    

  278.          * Checking.
    

  279.          */
    

  280.         return 0;
    

  281. }
    


  282. 


  283. 

  284. /**
    

  285.  * \brief Display the user interface on the terminal.
    

  286.  */
    

  287. static void refresh_display(void)
    

  288. {
    

  289.         uint32_t ul_hour, ul_minute, ul_second;
    

  290.         uint32_t ul_year, ul_month, ul_day, ul_week;
    


  291. 

  292.         if (gs_ul_state != STATE_MENU) {
    

  293.                 /* Not in menu display mode, in set mode. */
    

  294.         } else {
    

  295.                 /* Retrieve date and time */
    

  296.                 rtc_get_time(RTC, &ul_hour, &ul_minute, &ul_second);
    

  297.                 rtc_get_date(RTC, &ul_year, &ul_month, &ul_day, &ul_week);
    


  298. 

  299.                 /* Display */
    

  300.                 if (!gs_ul_menu_shown) {
    

  301.                         puts("\n\rMenu:\n\r"
    

  302.                                         "  t - Set time\n\r"
    

  303.                                         "  d - Set date\n\r"
    

  304.                                         "  i - Set time alarm\n\r"
    

  305.                                         "  m - Set date alarm\r");
    

  306. #if ((SAM3S8) || (SAM3SD8) || (SAM4S) || (SAM4C) || (SAM4CP) || (SAM4CM) || (SAMV71)|| (SAMV70) || (SAME70) || (SAMS70))
    

  307.                         puts("  w - Generate Waveform\r");
    

  308. #endif
    

  309.                         if (gs_ul_alarm_triggered) {
    

  310.                                 puts("  c - Clear alarm notification\r");
    

  311.                         }
    


  312. 

  313.                         printf("\n\r");
    


  314. 

  315.                         gs_ul_menu_shown = 1;
    

  316.                 }
    


  317. 

  318.                 /* Update current date and time */
    

  319.                 puts("\r");
    

  320.                 printf(" [Time/Date: %02u:%02u:%02u, %02u/%02u/%04u %s ][Alarm status:%s]",
    

  321.                         (unsigned int)ul_hour, (unsigned int)ul_minute, (unsigned int)ul_second,
    

  322.                         (unsigned int)ul_month, (unsigned int)ul_day, (unsigned int)ul_year,
    

  323.                         gs_uc_day_names[ul_week-1], gs_ul_alarm_triggered?"Triggered!":"");
    

  324.         }
    

  325. }
    


  326. 

  327. /**
    

  328.  * \brief Interrupt handler for the RTC. Refresh the display.
    

  329.  */
    

  330. void RTC_Handler(void)
    

  331. {
    

  332.         uint32_t ul_status = rtc_get_status(RTC);
    


  333. 

  334.         /* Second increment interrupt */
    

  335.         if ((ul_status & RTC_SR_SEC) == RTC_SR_SEC) {
    

  336.                 /* Disable RTC interrupt */
    

  337.                 rtc_disable_interrupt(RTC, RTC_IDR_SECDIS);
    


  338. 

  339.                 refresh_display();
    


  340. 

  341.                 rtc_clear_status(RTC, RTC_SCCR_SECCLR);
    


  342. 

  343.                 rtc_enable_interrupt(RTC, RTC_IER_SECEN);
    

  344.         } else {
    

  345.                 /* Time or date alarm */
    

  346.                 if ((ul_status & RTC_SR_ALARM) == RTC_SR_ALARM) {
    

  347.                         /* Disable RTC interrupt */
    

  348.                         rtc_disable_interrupt(RTC, RTC_IDR_ALRDIS);
    


  349. 

  350.                         gs_ul_alarm_triggered = 1;
    

  351.                         refresh_display();
    

  352.                         /* Show additional menu item for clear notification */
    

  353.                         gs_ul_menu_shown = 0;
    

  354.                         rtc_clear_status(RTC, RTC_SCCR_ALRCLR);
    

  355.                         rtc_enable_interrupt(RTC, RTC_IER_ALREN);
    

  356.                 }
    

  357.         }
    

  358. }
    


  359. 


  360. 

  361. /**
    

  362.  * \brief Application entry point for RTC example.
    

  363.  *
    

  364.  * \return Unused (ANSI-C compatibility).
    

  365.  */
    

  366. int main(void)
    

  367. {
    

  368.         uint8_t uc_key;
    


  369. 

  370.         /* Initialize the SAM system */
    

  371.         sysclk_init();
    

  372.         board_init();
    


  373. 

  374.         /* Initialize the console uart */
    

  375.         configure_console();
    


  376. 

  377.         /* Output example information */
    

  378.         puts(STRING_HEADER);
    


  379. 

  380.         /* Default RTC configuration, 24-hour mode */
    

  381.         rtc_set_hour_mode(RTC, 0);
    


  382. 

  383.         /* Configure RTC interrupts */
    

  384.         NVIC_DisableIRQ(RTC_IRQn);
    

  385.         NVIC_ClearPendingIRQ(RTC_IRQn);
    

  386.         NVIC_SetPriority(RTC_IRQn, 0);
    

  387.         NVIC_EnableIRQ(RTC_IRQn);
    

  388.         rtc_enable_interrupt(RTC, RTC_IER_SECEN | RTC_IER_ALREN);
    


  389. 

  390.         /* Refresh display once */
    

  391.         refresh_display();
    


  392. 

  393.         /* Handle keypresses */
    

  394.         while (1) {
    


  395. 

  396.                 scanf("%c", (char *)&uc_key);
    


  397. 

  398.                 /* Set time */
    

  399.                 if (uc_key == 't') {
    

  400.                         gs_ul_state = STATE_SET_TIME;
    


  401. 

  402.                         do {
    

  403.                                 puts("\n\r\n\r Set time(hh:mm:ss): ");
    

  404.                         } while (get_new_time());
    


  405. 

  406.                         /* If valid input, none of the variables for time is 0xff. */
    

  407.                         if (gs_ul_new_hour != 0xFFFFFFFF && (gs_uc_rtc_time[2] == ':')
    

  408.                                         && (gs_uc_rtc_time[5] == ':')) {
    

  409.                                 if (rtc_set_time(RTC, gs_ul_new_hour, gs_ul_new_minute,
    

  410.                                                 gs_ul_new_second)) {
    

  411.                                         puts("\n\r Time not set, invalid input!\r");
    

  412.                                 }
    

  413.                         } else {
    

  414.                                 gs_uc_rtc_time[2] = ':';
    

  415.                                 gs_uc_rtc_time[5] = ':';
    

  416.                                 puts("\n\r Time not set, invalid input!\r");
    

  417.                         }
    


  418. 

  419.                         gs_ul_state = STATE_MENU;
    

  420.                         gs_ul_menu_shown = 0;
    

  421.                         refresh_display();
    

  422.                 }
    


  423. 

  424.                 /* Set date */
    

  425.                 if (uc_key == 'd') {
    

  426.                         gs_ul_state = STATE_SET_DATE;
    


  427. 

  428.                         do {
    

  429.                                 puts("\n\r\n\r Set date(mm/dd/yyyy): ");
    

  430.                         } while (get_new_date());
    


  431. 

  432.                         /* If valid input, none of the variables for date is 0xff(ff). */
    

  433.                         if (gs_ul_new_year != 0xFFFFFFFF && (gs_uc_date[2] == '/')
    

  434.                                         && (gs_uc_date[5] == '/')) {
    

  435.                                 if (rtc_set_date(RTC, gs_ul_new_year, gs_ul_new_month,
    

  436.                                                 gs_ul_new_day, gs_ul_new_week)) {
    

  437.                                         puts("\n\r Date not set, invalid input!\r");
    

  438.                                 }
    

  439.                         } else {
    

  440.                                 gs_uc_date[2] = '/';
    

  441.                                 gs_uc_date[5] = '/';
    

  442.                                 puts("\n\r Time not set, invalid input!\r");
    

  443.                         }
    


  444. 

  445.                         /* Only 'mm/dd' is input. */
    

  446.                         if (gs_ul_new_month != 0xFFFFFFFF &&
    

  447.                                                 gs_ul_new_year == 0xFFFFFFFF) {
    

  448.                                 puts("\n\r Not Set for no year field!\r");
    

  449.                         }
    


  450. 

  451.                         gs_ul_state = STATE_MENU;
    

  452.                         gs_ul_menu_shown = 0;
    

  453.                         refresh_display();
    

  454.                 }
    


  455. 

  456.                 /* Set time alarm */
    

  457.                 if (uc_key == 'i') {
    

  458.                         gs_ul_state = STATE_SET_TIME_ALARM;
    


  459. 

  460.                         rtc_clear_date_alarm(RTC);
    


  461. 

  462.                         do {
    

  463.                                 puts("\n\r\n\r Set time alarm(hh:mm:ss): ");
    

  464.                         } while (get_new_time());
    


  465. 

  466.                         if (gs_ul_new_hour != 0xFFFFFFFF && (gs_uc_rtc_time[2] == ':')
    

  467.                                         && (gs_uc_rtc_time[5] == ':')) {
    

  468.                                 if (rtc_set_time_alarm(RTC, 1, gs_ul_new_hour,
    

  469.                                                 1, gs_ul_new_minute, 1, gs_ul_new_second)) {
    

  470.                                         puts("\n\r Time alarm not set, invalid input!\r");
    

  471.                                 } else {
    

  472.                                         printf("\n\r Time alarm is set at %02u:%02u:%02u!",
    

  473.                                                 (unsigned int)gs_ul_new_hour, (unsigned int)gs_ul_new_minute,
    

  474.                                                 (unsigned int)gs_ul_new_second);
    

  475.                                 }
    

  476.                         } else {
    

  477.                                 gs_uc_rtc_time[2] = ':';
    

  478.                                 gs_uc_rtc_time[5] = ':';
    

  479.                                 puts("\n\r Time not set, invalid input!\r");
    

  480.                         }
    

  481.                         gs_ul_state = STATE_MENU;
    

  482.                         gs_ul_menu_shown = 0;
    

  483.                         gs_ul_alarm_triggered = 0;
    

  484.                         refresh_display();
    

  485.                 }
    


  486. 

  487.                 /* Set date alarm */
    

  488.                 if (uc_key == 'm') {
    

  489.                         gs_ul_state = STATE_SET_DATE_ALARM;
    


  490. 

  491.                         rtc_clear_time_alarm(RTC);
    


  492. 

  493.                         do {
    

  494.                                 puts("\n\r\n\r Set date alarm(mm/dd/yyyy): ");
    

  495.                         } while (get_new_date());
    


  496. 

  497.                         if (gs_ul_new_year != 0xFFFFFFFF && (gs_uc_date[2] == '/')
    

  498.                                         && (gs_uc_date[5] == '/')) {
    

  499.                                 if (rtc_set_date_alarm(RTC, 1, gs_ul_new_month, 1,
    

  500.                                                 gs_ul_new_day)) {
    

  501.                                         puts("\n\r Date alarm not set, invalid input!\r");
    

  502.                                 } else {
    

  503.                                         printf("\n\r Date alarm is set on %02u/%02u/%4u!",
    

  504.                                                         (unsigned int)gs_ul_new_month, (unsigned int)gs_ul_new_day,
    

  505.                                                         (unsigned int)gs_ul_new_year);
    

  506.                                 }
    

  507.                         } else {
    

  508.                                 gs_uc_date[2] = '/';
    

  509.                                 gs_uc_date[5] = '/';
    

  510.                                 puts("\n\r Date alarm not set, invalid input!\r");
    

  511.                         }
    

  512.                         gs_ul_state = STATE_MENU;
    

  513.                         gs_ul_menu_shown = 0;
    

  514.                         gs_ul_alarm_triggered = 0;
    

  515.                         refresh_display();
    

  516.                 }
    


  517. 

  518. #if ((SAM3S8) || (SAM3SD8) || (SAM4S) || (SAM4C) || (SAM4CP) || (SAM4CM) || (SAMV71)|| (SAMV70) || (SAME70) || (SAMS70))
    

  519.                 /* Generate Waveform */
    

  520.                 if (uc_key == 'w') {
    

  521.                         gs_ul_state = STATE_WAVEFORM;
    

  522.                         puts("\n\rMenu:\n\r"
    

  523.                                         "  0 - No Waveform\n\r"
    

  524.                                         "  1 - 1 Hz square wave\n\r"
    

  525.                                         "  2 - 32 Hz square wave\n\r"
    

  526.                                         "  3 - 64 Hz square wave\n\r"
    

  527.                                         "  4 - 512 Hz square wave\n\r"
    

  528.                                         "  5 - Toggles when alarm flag rise\n\r"
    

  529.                                         "  6 - Copy of the alarm flag\n\r"
    

  530.                                         "  7 - Duty cycle programmable pulse\n\r"
    

  531.                                         "  8 - Quit\r");
    


  532. 

  533.                         while (1) {
    

  534.                                 scanf("%c", (char *)&uc_key);
    


  535. 

  536.                                 if ((uc_key >= '0') && (uc_key <= '7')) {
    

  537.                                         rtc_set_waveform(RTC, 0, char_to_digit(uc_key));
    

  538.                                 }
    


  539. 

  540.                                 if (uc_key == '8') {
    

  541.                                         gs_ul_state = STATE_MENU;
    

  542.                                         gs_ul_menu_shown = 0;
    

  543.                                         refresh_display();
    

  544.                                         break;
    

  545.                                 }
    

  546.                         }
    

  547.                 }
    

  548. #endif
    

  549.                 /* Clear trigger flag */
    

  550.                 if (uc_key == 'c') {
    

  551.                         gs_ul_alarm_triggered = 0;
    

  552.                         gs_ul_menu_shown = 0;
    

  553.                         refresh_display();
    

  554.                 }
    


  555. 

  556.         }
    


  557. 

  558. }
    


  559. 

  560. /// [url=home.php?mod=space&uid=1302964]@cond[/url] 0
    

  561. /**INDENT-OFF**/
    

  562. #ifdef __cplusplus
    

  563. }
    

  564. #endif
    

  565. /**INDENT-ON**/
    

  566. /// @endcond
    


  567.

运行结果：



本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

相关帖子
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

ddllxxrr
个人签名：http://shop34182318.taobao.com/ http://shop562064536.taobao.com

2404

主题

7001

帖子

68

粉丝
快速回复 在线客服 返回列表 返回顶部