stm32f407通过HAL完成I2C读写hym8563的代码中，HAL_I2C_Mem_Write函数的返回值为1，怎么改

HAL_I2C_Mem_Write函数的返回值为1表示发送成功，如果你需要修改返回值，可以通过以下两种方式实现：

1. 修改HAL库源码：在HAL_I2C_Mem_Write函数的定义处，将返回值修改为你期望的值。但是这种方式需要你重新编译HAL库，不建议使用。

2. 在调用HAL_I2C_Mem_Write函数时，手动修改返回值：在调用HAL_I2C_Mem_Write函数的语句后面添加一行代码，将返回值修改为你期望的值。例如：

if(HAL_I2C_Mem_Write(&hi2c1, devAddr, memAddr, memAddrSize, data, dataSize, 1000) == HAL_OK) {
  // 发送成功
} else {
  // 发送失败
  HAL_Delay(10);
  HAL_I2C_DeInit(&hi2c1);
  HAL_I2C_Init(&hi2c1);
  // 修改返回值为0
  __HAL_LOCK(&hi2c1);
  hi2c1.State = HAL_I2C_STATE_READY;
  __HAL_UNLOCK(&hi2c1);
}

在上面的代码中，如果HAL_I2C_Mem_Write函数返回值为HAL_OK，则表示发送成功；否则，将返回值修改为0，并重新初始化I2C总线。

相关问题

stm32f407 通过HAL，完成I2C读写hym8563，pb6为scl，pb7为sda，的完成代码

以下是stm32f407通过HAL完成I2C读写hym8563的代码示例：

#include "main.h"
#include "stm32f4xx_hal.h"

I2C_HandleTypeDef hi2c1;

void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_I2C1_Init(void);

int main(void)
{
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_I2C1_Init();

  uint8_t data[7];
  uint8_t address = 0x51;
  uint8_t reg = 0x00;

  //写入数据
  HAL_I2C_Mem_Write(&hi2c1, address, reg, 1, data, 7, 1000);

  //读取数据
  HAL_I2C_Mem_Read(&hi2c1, address, reg, 1, data, 7, 1000);

  while (1)
  {
  }
}

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

  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 8;
  RCC_OscInitStruct.PLL.PLLN = 168;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  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_DIV4;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
  {
    Error_Handler();
  }
}

static void MX_I2C1_Init(void)
{
  hi2c1.Instance = I2C1;
  hi2c1.Init.ClockSpeed = 100000;
  hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
  hi2c1.Init.OwnAddress1 = 0;
  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  hi2c1.Init.OwnAddress2 = 0;
  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  if (HAL_I2C_Init(&hi2c1) != HAL_OK)
  {
    Error_Handler();
  }
}

static void MX_GPIO_Init(void)
{
  __HAL_RCC_GPIOB_CLK_ENABLE();
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  GPIO_InitStruct.Pin = GPIO_PIN_6 | GPIO_PIN_7;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF4_I2C1;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
}

以上代码将 I2C1 初始化为100kHz的速率，并使用GPIOB的PB6和PB7引脚作为I2C总线的SCL和SDA引脚。在主函数中，先写入数据到地址为0x51、寄存器为0x00的设备中，然后读取相同的数据。可以根据实际需要修改设备地址、寄存器地址和读取/写入的字节数。

用rt_thread，hal库，用stm32f407vet6完成i2c读写时钟芯片HYM8563的完整代码，PB6为scl，pb7为sda

以下是使用 RT-Thread 和 HAL 库，通过 I2C 总线读写时钟芯片 HYM8563 的完整代码，PB6 为 SCL，PB7 为 SDA：

#include <rtthread.h>
#include <rtdevice.h>
#include "stm32f4xx_hal.h"
#include "hym8563.h"

#define I2C_BUS_NAME    "i2c1"      // I2C 总线名称
#define I2C_SLAVE_ADDR  0xD0        // 时钟芯片 HYM8563 的地址

static struct rt_i2c_bus_device *i2c_bus = RT_NULL;

/* 初始化 I2C 总线 */
static int i2c_bus_init(void)
{
    struct rt_i2c_bus_device *i2c_bus;

    /* 获取 I2C 总线设备 */
    i2c_bus = rt_i2c_bus_device_find(I2C_BUS_NAME);
    if (i2c_bus == RT_NULL)
    {
        rt_kprintf("I2C bus %s not found!\n", I2C_BUS_NAME);
        return -1;
    }

    /* 打开 I2C 总线 */
    if (rt_i2c_bus_device_open(i2c_bus) != RT_EOK)
    {
        rt_kprintf("Open I2C bus %s failed!\n", I2C_BUS_NAME);
        return -1;
    }

    return 0;
}

/* 读取时钟芯片 HYM8563 的时间 */
int hym8563_read_time(struct hym8563_time *t)
{
    rt_uint8_t buf[7];
    rt_size_t size;

    /* 发送读取命令 */
    if (rt_i2c_master_send(i2c_bus, I2C_SLAVE_ADDR, &t->sec_addr, 1) != 1)
    {
        rt_kprintf("Send read command failed!\n");
        return -1;
    }

    /* 读取数据 */
    size = rt_i2c_master_recv(i2c_bus, I2C_SLAVE_ADDR, buf, sizeof(buf));
    if (size != sizeof(buf))
    {
        rt_kprintf("Read data failed!\n");
        return -1;
    }

    /* 解析数据 */
    t->sec = BCD2BIN(buf[0] & 0x7F);
    t->min = BCD2BIN(buf[1] & 0x7F);
    t->hour = BCD2BIN(buf[2] & 0x3F);
    t->day = BCD2BIN(buf[3] & 0x3F);
    t->week = BCD2BIN(buf[4] & 0x07);
    t->month = BCD2BIN(buf[5] & 0x1F);
    t->year = BCD2BIN(buf[6]) + 2000;

    return 0;
}

/* 设置时钟芯片 HYM8563 的时间 */
int hym8563_set_time(const struct hym8563_time *t)
{
    rt_uint8_t buf[8];

    /* 构造写入数据 */
    buf[0] = t->sec_addr;
    buf[1] = BIN2BCD(t->sec);
    buf[2] = BIN2BCD(t->min);
    buf[3] = BIN2BCD(t->hour);
    buf[4] = BIN2BCD(t->day);
    buf[5] = BIN2BCD(t->week);
    buf[6] = BIN2BCD(t->month);
    buf[7] = BIN2BCD(t->year - 2000);

    /* 发送写入命令和数据 */
    if (rt_i2c_master_send(i2c_bus, I2C_SLAVE_ADDR, buf, sizeof(buf)) != sizeof(buf))
    {
        rt_kprintf("Write data failed!\n");
        return -1;
    }

    return 0;
}

/* HYM8563 时钟芯片测试 */
int hym8563_test(void)
{
    struct hym8563_time t;

    /* 初始化 I2C 总线 */
    if (i2c_bus_init() != 0)
    {
        return -1;
    }

    /* 读取时间 */
    if (hym8563_read_time(&t) != 0)
    {
        return -1;
    }

    /* 输出时间 */
    rt_kprintf("%04d-%02d-%02d %02d:%02d:%02d, week %d\n",
               t.year, t.month, t.day, t.hour, t.min, t.sec, t.week);

    /* 修改时间 */
    t.year = 2022;
    t.month = 8;
    t.day = 1;
    t.hour = 12;
    t.min = 0;
    t.sec = 0;
    t.week = 7;
    if (hym8563_set_time(&t) != 0)
    {
        return -1;
    }

    return 0;
}

在以上代码中，我们使用了 `hym8563.h` 头文件，其中包含了一些常量和宏定义，用于解析 HYM8563 的时间数据。`hym8563.c` 文件的内容如下：

#include "hym8563.h"

/* BCD 转二进制 */
rt_uint8_t BCD2BIN(rt_uint8_t val)
{
    return (val & 0x0F) + ((val >> 4) * 10);
}

/* 二进制转 BCD */
rt_uint8_t BIN2BCD(rt_uint8_t val)
{
    return ((val / 10) << 4) + (val % 10);
}

在以上代码中，我们定义了两个函数，用于将 BCD 码转换为二进制和将二进制转换为 BCD 码。这两个函数在解析 HYM8563 的时间数据时会用到。

需要注意的是，以上代码仅供参考，具体的实现方式可能与你的硬件和软件环境有关。你需要根据自己的实际情况进行修改和调整。