KEIL5中for打不出来显示format BCD

在KEIL5集成开发环境中，如果使用for循环无法正常输出BCD码（二进制补码十进制），这可能是由于编程语言设置、数据类型处理或者代码格式的问题。通常，你可以按照以下步骤检查：

1. **数据类型**：确保你在处理字符数组或字符串时，用于存储BCD值的是正确的类型，例如`char`，因为BCD码通常是四个二进制位表示一位十进制数。

2. **格式化输出**：查看是否使用了特定函数或格式说明符来将BCD转换成可打印的字符形式。比如在C/C++中，可以使用ASCII编码对应的方式来组合BCD数字，如`('0'+ '0') * 4`代表00。

char bcd[4] = {'0', '0', '0', '0'};
bcd[0] = ('0' + (num / 1000) % 10); // 千位
bcd[1] = ('0' + (num / 100) % 10);   // 百位
bcd[2] = ('0' + (num / 10) % 10);     // 十位
bcd[3] = ('0' + num % 10);           // 个位
printf("%s", bcd);

3. **循环控制**：确保for循环遍历的是BCD数组的正确位置，并在每次迭代中更新对应的BCD字符。

如果以上步骤都正确，但仍然无法显示，可能是IDE配置问题或者代码有其他未察觉的错误。试着添加一些调试信息，观察每个阶段的数据变化，以便找出问题所在。

相关问题

keil rtc绘制时钟

要在 Keil 中使用 RTC 绘制时钟，需要先配置 RTC 模块并连接到相应的外部时钟源。然后可以使用 Keil 的图形库来绘制时钟的外观。

以下是一个简单的示例代码，可以在 Keil 中使用 STM32F4 开发板绘制时钟：

#include "stm32f4xx.h"
#include "GLCD.h"
#include <stdio.h>

#define RTC_CLOCK_SOURCE_LSI

#ifdef RTC_CLOCK_SOURCE_LSI
#define RTC_ASYNCH_PREDIV    0x7F
#define RTC_SYNCH_PREDIV     0x0138
#endif

void RTC_Config(void)
{
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
    PWR_BackupAccessCmd(ENABLE);
    RCC_BackupResetCmd(ENABLE);
    RCC_BackupResetCmd(DISABLE);

    RCC_LSEConfig(RCC_LSE_ON);
    while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET);

    RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
    RCC_RTCCLKCmd(ENABLE);

    RTC_InitTypeDef RTC_InitStructure;
    RTC_InitStructure.RTC_AsynchPrediv = RTC_ASYNCH_PREDIV;
    RTC_InitStructure.RTC_SynchPrediv = RTC_SYNCH_PREDIV;
    RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
    RTC_InitStructure.RTC_AutomaticWakeUp = RTC_AutomaticWakeUp_Disable;
    RTC_InitStructure.RTC_DateStruct.RTC_Date = 1;
    RTC_InitStructure.RTC_DateStruct.RTC_Month = RTC_Month_January;
    RTC_InitStructure.RTC_DateStruct.RTC_WeekDay = RTC_Weekday_Monday;
    RTC_InitStructure.RTC_DateStruct.RTC_Year = 0;
    RTC_Init(&RTC_InitStructure);
    RTC_WriteProtectionCmd(DISABLE);
}

void RTC_SetTime(uint32_t Time)
{
    RTC_TimeTypeDef RTC_TimeStruct;
    RTC_TimeStruct.RTC_H12 = RTC_H12_AM;
    RTC_TimeStruct.RTC_Hours = (Time / 3600) % 24;
    RTC_TimeStruct.RTC_Minutes = (Time / 60) % 60;
    RTC_TimeStruct.RTC_Seconds = Time % 60;
    RTC_SetTime(RTC_Format_BCD, &RTC_TimeStruct);
}

void RTC_GetTime(uint32_t *Time)
{
    RTC_TimeTypeDef RTC_TimeStruct;
    RTC_GetTime(RTC_Format_BCD, &RTC_TimeStruct);
    *Time = RTC_TimeStruct.RTC_Hours * 3600 + RTC_TimeStruct.RTC_Minutes * 60 + RTC_TimeStruct.RTC_Seconds;
}

void DrawClock(uint32_t Time)
{
    GLCD_Clear(White);
    GLCD_Circle(120, 120, 100, Black, NO_FILL);
    GLCD_Line(120, 120, 120 + 80 * sin(Time * 2 * 3.1415926 / 3600), 120 - 80 * cos(Time * 2 * 3.1415926 / 3600), Black);
    GLCD_Line(120, 120, 120 + 60 * sin(Time * 2 * 3.1415926 / 60), 120 - 60 * cos(Time * 2 * 3.1415926 / 60), Black);
    GLCD_Line(120, 120, 120 + 40 * sin(Time * 2 * 3.1415926 / 60), 120 - 40 * cos(Time * 2 * 3.1415926 / 60), Black);
    GLCD_Line(120, 120, 120 + 20 * sin(Time * 2 * 3.1415926 / 60), 120 - 20 * cos(Time * 2 * 3.1415926 / 60), Black);
}

int main(void)
{
    GLCD_Init();
    GLCD_Clear(White);

    RTC_Config();
    uint32_t Time;
    RTC_GetTime(&Time);

    while (1)
    {
        RTC_GetTime(&Time);
        DrawClock(Time);
    }
}

这段代码使用 RTC 模块获取当前时间，并使用图形库在屏幕上绘制时钟外观。你可以根据需要进行修改和优化。

stm32实时显示时间

要在STM32上实时显示时间，可以使用内置的定时器和RTC模块。以下是一些基本步骤：

1. 配置RTC模块：使用CubeMX等工具配置RTC模块，并设置时间格式和时钟源等参数。

2. 配置定时器：使用CubeMX等工具配置一个定时器，定时器周期设置为1秒。

3. 在定时器中断中更新时间：在定时器中断服务程序中，读取RTC模块中的时间，将其转换为字符串格式，并显示在LCD等显示器上。

4. 更新时间：使用RTC模块提供的时间更新功能，可以保证时间的准确性。

下面是一个简单的示例代码：

#include "stm32f1xx_hal.h"
#include "stdio.h"

RTC_HandleTypeDef hrtc;
TIM_HandleTypeDef htim2;
UART_HandleTypeDef huart1;

char time_string[9];

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_RTC_Init(void);
static void MX_TIM2_Init(void);

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  if (htim->Instance == TIM2)
  {
    RTC_TimeTypeDef sTime = {0};

    HAL_RTC_GetTime(&hrtc, &sTime, RTC_FORMAT_BIN);

    sprintf(time_string, "%02d:%02d:%02d", sTime.Hours, sTime.Minutes, sTime.Seconds);

    HAL_UART_Transmit(&huart1, (uint8_t *)time_string, strlen(time_string), 100);
  }
}

int main(void)
{
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  MX_RTC_Init();
  MX_TIM2_Init();

  HAL_TIM_Base_Start_IT(&htim2);

  while (1)
  {
    HAL_RTC_AlarmIRQHandler(&hrtc);
  }
}

void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK |
                                RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

static void MX_RTC_Init(void)
{
  RTC_TimeTypeDef sTime = {0};
  RTC_DateTypeDef sDate = {0};
  RTC_AlarmTypeDef sAlarm = {0};

  hrtc.Instance = RTC;
  hrtc.Init.AsynchPrediv = 127;
  hrtc.Init.SynchPrediv = 255;
  hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
  hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
  hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
  if (HAL_RTC_Init(&hrtc) != HAL_OK)
  {
    Error_Handler();
  }

  sTime.Hours = 0x12;
  sTime.Minutes = 0x0;
  sTime.Seconds = 0x0;
  sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
  sTime.StoreOperation = RTC_STOREOPERATION_RESET;
  if (HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BCD) != HAL_OK)
  {
    Error_Handler();
  }

  sDate.WeekDay = RTC_WEEKDAY_MONDAY;
  sDate.Month = RTC_MONTH_JANUARY;
  sDate.Date = 0x1;
  sDate.Year = 0x0;
  if (HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BCD) != HAL_OK)
  {
    Error_Handler();
  }

  sAlarm.AlarmTime.Hours = 0x0;
  sAlarm.AlarmTime.Minutes = 0x0;
  sAlarm.AlarmTime.Seconds = 0x0;
  sAlarm.AlarmTime.SubSeconds = 0x0;
  sAlarm.AlarmTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
  sAlarm.AlarmTime.StoreOperation = RTC_STOREOPERATION_RESET;
  sAlarm.AlarmMask = RTC_ALARMMASK_NONE;
  sAlarm.AlarmSubSecondMask = RTC_ALARMSUBSECONDMASK_NONE;
  sAlarm.AlarmDateWeekDaySel = RTC_ALARMDATEWEEKDAYSEL_DATE;
  sAlarm.AlarmDateWeekDay = 0x1;
  sAlarm.Alarm = RTC_ALARM_A;
  if (HAL_RTC_SetAlarm(&hrtc, &sAlarm, RTC_FORMAT_BCD) != HAL_OK)
  {
    Error_Handler();
  }
}

static void MX_TIM2_Init(void)
{
  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 7200 - 1;
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim2.Init.Period = 10000 - 1;
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  {
    Error_Handler();
  }

  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }

  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
}

static void MX_USART1_UART_Init(void)
{
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
}

static void MX_GPIO_Init(void)
{
  __HAL_RCC_GPIOC_CLK_ENABLE();

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  GPIO_InitStruct.Pin = GPIO_PIN_13;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
}

void Error_Handler(void)
{
  while (1)
  {
  }
}

#ifdef USE_FULL_ASSERT
void assert_failed(uint8_t *file, uint32_t line)
{
}
#endif

在这个例子中，我们使用了STM32F103C8T6开发板和Keil uVision5开发环境，将时间字符串通过串口输出。可以根据具体需求，将时间显示在LCD等显示器上。