海思306x系列 gc9a01移植

于 2024-09-10 00:33:51 发布
阅读量208 收藏
点赞数 2
文章标签： 其他
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nonsense1973/article/details/141756416
版权

先写gc9a01_driver.c和gc9a01_driver.h

gc9a01_driver.c

#include "gc9a01_driver.h"
#include "spi.h"
#include "gpio.h"
#include "main.h"
#include "debug.h"

#define MAX_TIMEOUT_VAL    5000
#define ORIENTATION        0 
#define COLOR_MODE          0x3A
#define COLOR_MODE__12_BIT  0x03
#define COLOR_MODE__16_BIT  0x05
#define COLOR_MODE__18_BIT  0x06

// SPI 发送命令
void GC9A01_WriteCommand(uint8_t cmd) {
    HAL_GPIO_SetValue(&g_gpio4_4, g_gpio4_4.pins, GPIO_LOW_LEVEL);  // DC = 0 for command
    HAL_SPI_WriteBlocking(&g_spi1, &cmd, sizeof(cmd), MAX_TIMEOUT_VAL);
}

// SPI 发送数据
void GC9A01_WriteData(uint8_t data) {
    HAL_GPIO_SetValue(&g_gpio4_4, g_gpio4_4.pins, GPIO_HIGH_LEVEL);  // DC = 1 for data
    HAL_SPI_WriteBlocking(&g_spi1, &data, sizeof(data), MAX_TIMEOUT_VAL);
}

// 复位 GC9A01
void GC9A01_Reset(void) {
    HAL_GPIO_SetValue(&g_gpio4_5, g_gpio4_5.pins, GPIO_LOW_LEVEL);  // RST = 0 for RESET
    BASE_FUNC_DELAY_MS(100);
    HAL_GPIO_SetValue(&g_gpio4_5, g_gpio4_5.pins, GPIO_HIGH_LEVEL);  // RST = 1   
    BASE_FUNC_DELAY_MS(120);
}

// 设置显示窗口
void GC9A01_SetAddressWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) {
    GC9A01_WriteCommand(0x2A); // 列地址设置
    GC9A01_WriteData(x0 >> 8);
    GC9A01_WriteData(x0 & 0xFF);
    GC9A01_WriteData(x1 >> 8);
    GC9A01_WriteData(x1 & 0xFF);

    GC9A01_WriteCommand(0x2B); // 行地址设置
    GC9A01_WriteData(y0 >> 8);
    GC9A01_WriteData(y0 & 0xFF);
    GC9A01_WriteData(y1 >> 8);
    GC9A01_WriteData(y1 & 0xFF);

    GC9A01_WriteCommand(0x2C); // 准备写入内存
}

void GC9A01_FillScreen(uint16_t color) {
    // 设置整个屏幕的绘图窗口
    GC9A01_SetAddressWindow(0, 0, 239, 239);  // 对于 240x240 的 GC9A01 显示屏，坐标从 0 开始

    // 发送要填充的颜色数据
    for (uint32_t i = 0; i < 240 * 240; i++) {
        GC9A01_WriteData(color >> 8);    // 发送颜色的高 8 位
        GC9A01_WriteData(color & 0xFF);  // 发送颜色的低 8 位
    }
}

// 画一个像素
void GC9A01_DrawPixel(uint16_t x, uint16_t y, uint16_t color) {
    GC9A01_SetAddressWindow(x, y, x, y);
    GC9A01_WriteData(color >> 8);
    GC9A01_WriteData(color & 0xFF);
}

// void gc9a01_flush_cb(lv_disp_drv_t *disp_drv, const lv_area_t *area, lv_color_t *color_p) {
//     int32_t x, y;

//     // 设置要刷新的区域
//     GC9A01_SetAddressWindow(area->x1, area->y1, area->x2, area->y2);

//     // 写入像素数据到 GC9A01
//     for (y = area->y1; y <= area->y2; y++) {
//         for (x = area->x1; x <= area->x2; x++) {
//             uint16_t color = color_p->full;  // 获取 RGB565 格式的颜色数据
//             GC9A01_WriteData(color >> 8);    // 发送颜色的高 8 位
//             GC9A01_WriteData(color & 0xFF);  // 发送颜色的低 8 位
//             color_p++;  // 指向下一个像素数据
//         }
//     }

//     // 刷新完成后通知 LVGL
//     lv_disp_flush_ready(disp_drv);
// }

void gc9a01_flush_cb(lv_disp_drv_t *disp_drv, const lv_area_t *area, lv_color_t *color_p) {
    uint32_t width = area->x2 - area->x1 + 1;
    uint32_t height = area->y2 - area->y1 + 1;
    uint32_t size = width * height;

    // Set the address window
    GC9A01_WriteCommand(0x2A);  // Column Address Set
    uint8_t data[4];
    data[0] = (area->x1 >> 8) & 0xFF;
    data[1] = area->x1 & 0xFF;
    data[2] = (area->x2 >> 8) & 0xFF;
    data[3] = area->x2 & 0xFF;
    GC9A01_WriteData(data);
    
    GC9A01_WriteCommand(0x2B);  // Page Address Set
    data[0] = (area->y1 >> 8) & 0xFF;
    data[1] = area->y1 & 0xFF;
    data[2] = (area->y2 >> 8) & 0xFF;
    data[3] = area->y2 & 0xFF;
    GC9A01_WriteData(data);
    
    GC9A01_WriteCommand(0x2C);  // Memory Write
    
    // Write pixel data
    for (uint32_t i = 0; i < size; i++) {
        uint16_t color = color_p[i].full;
        data[0] = color >> 8;
        data[1] = color & 0xFF;
        GC9A01_WriteData(data);
    }

    lv_disp_flush_ready(disp_drv);
}

void GC9A01_init(void) {
    GC9A01_Reset();
    
    /* Initial Sequence */ 
    
    GC9A01_WriteCommand(0xEF);
    
    GC9A01_WriteCommand(0xEB);
    GC9A01_WriteData(0x14);
    
    GC9A01_WriteCommand(0xFE);
    GC9A01_WriteCommand(0xEF);
    
    GC9A01_WriteCommand(0xEB);
    GC9A01_WriteData(0x14);
    
    GC9A01_WriteCommand(0x84);
    GC9A01_WriteData(0x40);
    
    GC9A01_WriteCommand(0x85);
    GC9A01_WriteData(0xFF);
    
    GC9A01_WriteCommand(0x86);
    GC9A01_WriteData(0xFF);
    
    GC9A01_WriteCommand(0x87);
    GC9A01_WriteData(0xFF);
    
    GC9A01_WriteCommand(0x88);
    GC9A01_WriteData(0x0A);
    
    GC9A01_WriteCommand(0x89);
    GC9A01_WriteData(0x21);
    
    GC9A01_WriteCommand(0x8A);
    GC9A01_WriteData(0x00);
    
    GC9A01_WriteCommand(0x8B);
    GC9A01_WriteData(0x80);
    
    GC9A01_WriteCommand(0x8C);
    GC9A01_WriteData(0x01);
    
    GC9A01_WriteCommand(0x8D);
    GC9A01_WriteData(0x01);
    
    GC9A01_WriteCommand(0x8E);
    GC9A01_WriteData(0xFF);
    
    GC9A01_WriteCommand(0x8F);
    GC9A01_WriteData(0xFF);
    
    
    GC9A01_WriteCommand(0xB6);
    GC9A01_WriteData(0x00);
    GC9A01_WriteData(0x00);
    
    GC9A01_WriteCommand(0x36);
    
#if ORIENTATION == 0
    GC9A01_WriteData(0x18);
#elif ORIENTATION == 1
    GC9A01_WriteData(0x28);
#elif ORIENTATION == 2
    GC9A01_WriteData(0x48);
#else
    GC9A01_WriteData(0x88);
#endif
    
    GC9A01_WriteCommand(COLOR_MODE);
    GC9A01_WriteData(COLOR_MODE__16_BIT);
    
    GC9A01_WriteCommand(0x90);
    GC9A01_WriteData(0x08);
    GC9A01_WriteData(0x08);
    GC9A01_WriteData(0x08);
    GC9A01_WriteData(0x08);
    
    GC9A01_WriteCommand(0xBD);
    GC9A01_WriteData(0x06);
    
    GC9A01_WriteCommand(0xBC);
    GC9A01_WriteData(0x00);
    
    GC9A01_WriteCommand(0xFF);
    GC9A01_WriteData(0x60);
    GC9A01_WriteData(0x01);
    GC9A01_WriteData(0x04);
    
    GC9A01_WriteCommand(0xC3);
    GC9A01_WriteData(0x13);
    GC9A01_WriteCommand(0xC4);
    GC9A01_WriteData(0x13);
    
    GC9A01_WriteCommand(0xC9);
    GC9A01_WriteData(0x22);
    
    GC9A01_WriteCommand(0xBE);
    GC9A01_WriteData(0x11);
    
    GC9A01_WriteCommand(0xE1);
    GC9A01_WriteData(0x10);
    GC9A01_WriteData(0x0E);
    
    GC9A01_WriteCommand(0xDF);
    GC9A01_WriteData(0x21);
    GC9A01_WriteData(0x0c);
    GC9A01_WriteData(0x02);
    
    GC9A01_WriteCommand(0xF0);
    GC9A01_WriteData(0x45);
    GC9A01_WriteData(0x09);
    GC9A01_WriteData(0x08);
    GC9A01_WriteData(0x08);
    GC9A01_WriteData(0x26);
    GC9A01_WriteData(0x2A);
    
    GC9A01_WriteCommand(0xF1);
    GC9A01_WriteData(0x43);
    GC9A01_WriteData(0x70);
    GC9A01_WriteData(0x72);
    GC9A01_WriteData(0x36);
    GC9A01_WriteData(0x37);
    GC9A01_WriteData(0x6F);
    
    GC9A01_WriteCommand(0xF2);
    GC9A01_WriteData(0x45);
    GC9A01_WriteData(0x09);
    GC9A01_WriteData(0x08);
    GC9A01_WriteData(0x08);
    GC9A01_WriteData(0x26);
    GC9A01_WriteData(0x2A);
    
    GC9A01_WriteCommand(0xF3);
    GC9A01_WriteData(0x43);
    GC9A01_WriteData(0x70);
    GC9A01_WriteData(0x72);
    GC9A01_WriteData(0x36);
    GC9A01_WriteData(0x37);
    GC9A01_WriteData(0x6F);
    
    GC9A01_WriteCommand(0xED);
    GC9A01_WriteData(0x1B);
    GC9A01_WriteData(0x0B);
    
    GC9A01_WriteCommand(0xAE);
    GC9A01_WriteData(0x77);
    
    GC9A01_WriteCommand(0xCD);
    GC9A01_WriteData(0x63);
    
    GC9A01_WriteCommand(0x70);
    GC9A01_WriteData(0x07);
    GC9A01_WriteData(0x07);
    GC9A01_WriteData(0x04);
    GC9A01_WriteData(0x0E);
    GC9A01_WriteData(0x0F);
    GC9A01_WriteData(0x09);
    GC9A01_WriteData(0x07);
    GC9A01_WriteData(0x08);
    GC9A01_WriteData(0x03);
    
    GC9A01_WriteCommand(0xE8);
    GC9A01_WriteData(0x34);
    
    GC9A01_WriteCommand(0x62);
    GC9A01_WriteData(0x18);
    GC9A01_WriteData(0x0D);
    GC9A01_WriteData(0x71);
    GC9A01_WriteData(0xED);
    GC9A01_WriteData(0x70);
    GC9A01_WriteData(0x70);
    GC9A01_WriteData(0x18);
    GC9A01_WriteData(0x0F);
    GC9A01_WriteData(0x71);
    GC9A01_WriteData(0xEF);
    GC9A01_WriteData(0x70);
    GC9A01_WriteData(0x70);
    
    GC9A01_WriteCommand(0x63);
    GC9A01_WriteData(0x18);
    GC9A01_WriteData(0x11);
    GC9A01_WriteData(0x71);
    GC9A01_WriteData(0xF1);
    GC9A01_WriteData(0x70);
    GC9A01_WriteData(0x70);
    GC9A01_WriteData(0x18);
    GC9A01_WriteData(0x13);
    GC9A01_WriteData(0x71);
    GC9A01_WriteData(0xF3);
    GC9A01_WriteData(0x70);
    GC9A01_WriteData(0x70);
    
    GC9A01_WriteCommand(0x64);
    GC9A01_WriteData(0x28);
    GC9A01_WriteData(0x29);
    GC9A01_WriteData(0xF1);
    GC9A01_WriteData(0x01);
    GC9A01_WriteData(0xF1);
    GC9A01_WriteData(0x00);
    GC9A01_WriteData(0x07);
    
    GC9A01_WriteCommand(0x66);
    GC9A01_WriteData(0x3C);
    GC9A01_WriteData(0x00);
    GC9A01_WriteData(0xCD);
    GC9A01_WriteData(0x67);
    GC9A01_WriteData(0x45);
    GC9A01_WriteData(0x45);
    GC9A01_WriteData(0x10);
    GC9A01_WriteData(0x00);
    GC9A01_WriteData(0x00);
    GC9A01_WriteData(0x00);
    
    GC9A01_WriteCommand(0x67);
    GC9A01_WriteData(0x00);
    GC9A01_WriteData(0x3C);
    GC9A01_WriteData(0x00);
    GC9A01_WriteData(0x00);
    GC9A01_WriteData(0x00);
    GC9A01_WriteData(0x01);
    GC9A01_WriteData(0x54);
    GC9A01_WriteData(0x10);
    GC9A01_WriteData(0x32);
    GC9A01_WriteData(0x98);
    
    GC9A01_WriteCommand(0x74);
    GC9A01_WriteData(0x10);
    GC9A01_WriteData(0x85);
    GC9A01_WriteData(0x80);
    GC9A01_WriteData(0x00);
    GC9A01_WriteData(0x00);
    GC9A01_WriteData(0x4E);
    GC9A01_WriteData(0x00);
    
    GC9A01_WriteCommand(0x98);
    GC9A01_WriteData(0x3e);
    GC9A01_WriteData(0x07);
    
    GC9A01_WriteCommand(0x35);
    GC9A01_WriteCommand(0x21);
    
    GC9A01_WriteCommand(0x11);
    BASE_FUNC_DELAY_MS(120);
    GC9A01_WriteCommand(0x29);
    BASE_FUNC_DELAY_MS(20);
    
}

gc9a01_driver.h

#ifndef GC9A01_DRIVER_H
#define GC9A01_DRIVER_H

#include <stdint.h>  // 标准整数类型定义
#include "spi.h"     // 包含 SPI 接口头文件
#include "gpio.h"    // 包含 GPIO 接口头文件
// #include "lvgl.h"

// GC9A01屏幕长宽定义
#define GC9A01_WIDTH 240     // GC9A01显示屏的宽度为240像素
#define GC9A01_HEIGHT 240    // GC9A01显示屏的高度为240像素

// 基本颜色定义
#define GC9A01A_BLACK 0x0000       ///<   0,   0,   0
#define GC9A01A_NAVY 0x000F        ///<   0,   0, 123
#define GC9A01A_DARKGREEN 0x03E0   ///<   0, 125,   0
#define GC9A01A_DARKCYAN 0x03EF    ///<   0, 125, 123
#define GC9A01A_MAROON 0x7800      ///< 123,   0,   0
#define GC9A01A_PURPLE 0x780F      ///< 123,   0, 123
#define GC9A01A_OLIVE 0x7BE0       ///< 123, 125,   0
#define GC9A01A_LIGHTGREY 0xC618   ///< 198, 195, 198
#define GC9A01A_DARKGREY 0x7BEF    ///< 123, 125, 123
#define GC9A01A_BLUE 0x001F        ///<   0,   0, 255
#define GC9A01A_GREEN 0x07E0       ///<   0, 255,   0
#define GC9A01A_CYAN 0x07FF        ///<   0, 255, 255
#define GC9A01A_RED 0xF800         ///< 255,   0,   0
#define GC9A01A_MAGENTA 0xF81F     ///< 255,   0, 255
#define GC9A01A_YELLOW 0xFFE0      ///< 255, 255,   0
#define GC9A01A_WHITE 0xFFFF       ///< 255, 255, 255
#define GC9A01A_ORANGE 0xFD20      ///< 255, 165,   0
#define GC9A01A_GREENYELLOW 0xAFE5 ///< 173, 255,  41
#define GC9A01A_PINK 0xFC18        ///< 255, 130, 198

// 函数原型声明
void GC9A01_init(void);
void GC9A01_Reset(void);
void GC9A01_WriteCommand(uint8_t cmd);
void GC9A01_WriteData(uint8_t data);
void GC9A01_SetAddressWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1);
void GC9A01_FillScreen(uint16_t color);
void GC9A01_DrawPixel(uint16_t x, uint16_t y, uint16_t color);
void gc9a01_flush_cb(lv_disp_drv_t *disp_drv, const lv_area_t *area, lv_color_t *color_p);

#endif // GC9A01_H

把这两个文件写在middleware

再写一个lcd_sample.c和lcd_sample.h

lcd_sample.c如下

#include "debug.h"
#include "gpio.h"
#include "main.h"
#include "gc9a01_driver.h"
// #include "lvgl.h"

void Lcd_Sample(void)
{
    SystemInit();
    GC9A01_init();
    DBG_PRINTF("init_success! \r\n");

    // GC9A01_DrawPixel(150, 150, GC9A01A_RED);
    // GC9A01_DrawPixel(160, 160, GC9A01A_YELLOW);
    GC9A01_FillScreen(GC9A01A_RED);
}

lcd_sample.h如下

#ifndef LCD_SAMPLE_H
#define LCD_SAMPLE_H

void Lcd_Sample(void);

#endif

main.c如下

/**
  * @copyright Copyright (c) 2022, HiSilicon (Shanghai) Technologies Co., Ltd. All rights reserved.
  * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
  * following conditions are met:
  * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
  * disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
  * following disclaimer in the documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
  * products derived from this software without specific prior written permission.
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * @file      main.c
  * @author    MCU Driver Team
  * @brief     Main program body.
  */

#include "typedefs.h"
#include "feature.h"
#include "main.h"
/* USER CODE BEGIN 0 */
/* USER CODE 区域内代码不会被覆盖，区域外会被生成的默认代码覆盖（其余USER CODE 区域同理） */
/* 建议用户放置头文件 */
#include "gc9a01_driver.h"
#include "lcd_sample.h"
/* USER CODE END 0 */
UART_Handle g_uart0;
SPI_Handle g_spi1;
/* USER CODE BEGIN 1 */
/* 建议用户定义全局变量、结构体、宏定义或函数声明等 */
// GPIO_Handle g_gpio3_0;
GPIO_Handle g_gpio4_4;
GPIO_Handle g_gpio4_5;
/* USER CODE END 1 */

int main(void)
{
    /* USER CODE BEGIN 2 */
    /* 建议用户放置初始化代码或启动代码等 */

    /* USER CODE END 2 */
    // GPIO_KeySample();
    /* USER CODE BEGIN 3 */
    /* 建议用户放置初始配置代码 */
    Lcd_Sample();
    /* USER CODE END 3 */
    while (1) {
        /* USER CODE BEGIN 4 */
        /* 建议用户放置周期性执行代码 */
        /* USER CODE END 4 */
    }
    /* USER CODE BEGIN 5 */
    /* 建议用户放置代码流程 */
    /* USER CODE END 5 */
    return BASE_STATUS_OK;
}

/* USER CODE BEGIN 6 */
/* 建议用户放置自定义函数 */
/* USER CODE END 6 */

main.h如下

/**
  * @copyright Copyright (c) 2022, HiSilicon (Shanghai) Technologies Co., Ltd. All rights reserved.
  * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
  * following conditions are met:
  * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
  * disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
  * following disclaimer in the documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
  * products derived from this software without specific prior written permission.
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * @file      main.h
  * @author    MCU Driver Team
  * @brief     This file contains driver init functions.
  */

/* Define to prevent recursive inclusion ------------------------------------- */
#ifndef McuMagicTag_SYSTEM_INIT_H
#define McuMagicTag_SYSTEM_INIT_H

#include "uart.h"
#include "uart_ex.h"
#include "spi.h"
#include "spi_ex.h"
#include "gpio.h"
#include "crg.h"
#include "iocmg.h"
#include "lvgl.h"

#define    IO_SPEED_FAST     0x00U
#define    IO_SPEED_SLOW     0x01U

#define    IO_DRV_LEVEL4     0x00U
#define    IO_DRV_LEVEL3     0x01U
#define    IO_DRV_LEVEL2     0x02U
#define    IO_DRV_LEVEL1     0x03U

#define    XTAL_DRV_LEVEL4   0x03U
#define    XTAL_DRV_LEVEL3   0x02U
#define    XTAL_DRV_LEVEL2   0x01U
#define    XTAL_DRV_LEVEL1   0x00U

extern UART_Handle g_uart0;
extern SPI_Handle g_spi1;

extern GPIO_Handle g_gpio4_4;
extern GPIO_Handle g_gpio4_5;

BASE_StatusType CRG_Config(CRG_CoreClkSelect *coreClkSelect);
void SystemInit(void);

/* USER CODE BEGIN 0 */
/* USER CODE 区域内代码不会被覆盖，区域外会被生成的默认代码覆盖（其余USER CODE 区域同理） */
/* USER CODE END 0 */

#endif /* McuMagicTag_SYSTEM_INIT_H */

system_init.c如下

/**
  * @copyright Copyright (c) 2022, HiSilicon (Shanghai) Technologies Co., Ltd. All rights reserved.
  * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
  * following conditions are met:
  * 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
  * disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
  * following disclaimer in the documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
  * products derived from this software without specific prior written permission.
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  * @file      system_init.c
  * @author    MCU Driver Team
  * @brief     This file contains driver init functions.
  */

#include "main.h"
#include "ioconfig.h"
#include "iocmg_ip.h"

#define UART0_BAND_RATE 115200

#define SPI1_FREQ_SCR 2
#define SPI1_FREQ_CPSDVSR 2

BASE_StatusType CRG_Config(CRG_CoreClkSelect *coreClkSelect)
{
    CRG_Handle crg;
    crg.baseAddress     = CRG;
    crg.pllRefClkSelect = CRG_PLL_REF_CLK_SELECT_HOSC;
    crg.pllPreDiv       = CRG_PLL_PREDIV_5;
    crg.pllFbDiv        = 20; /* PLL Multiplier 20 */
    crg.pllPostDiv      = CRG_PLL_POSTDIV_5;
    crg.coreClkSelect   = CRG_CORE_CLK_SELECT_PLL;
    crg.handleEx.pllPostDiv2   = CRG_PLL_POSTDIV2_3;
    crg.handleEx.clk1MSelect   = CRG_1M_CLK_SELECT_HOSC;
    crg.handleEx.clk1MDiv = (25 - 1); /* The 1 MHz freq is equal to the input clock frequency / (clk_1m_div + 1). 25 is the div of the clk_1m in CLOCK. */

    if (HAL_CRG_Init(&crg) != BASE_STATUS_OK) {
        return BASE_STATUS_ERROR;
    }
    *coreClkSelect = crg.coreClkSelect;
    return BASE_STATUS_OK;
}

static void GPIO_Init(void)
{
    HAL_CRG_IpEnableSet(GPIO4_BASE, IP_CLK_ENABLE);
    g_gpio4_4.baseAddress = GPIO4;
    g_gpio4_4.pins = GPIO_PIN_4;
    HAL_GPIO_Init(&g_gpio4_4);
    HAL_GPIO_SetDirection(&g_gpio4_4, g_gpio4_4.pins, GPIO_OUTPUT_MODE);
    HAL_GPIO_SetValue(&g_gpio4_4, g_gpio4_4.pins, GPIO_LOW_LEVEL);
    HAL_GPIO_SetIrqType(&g_gpio4_4, g_gpio4_4.pins, GPIO_INT_TYPE_NONE);

    HAL_CRG_IpEnableSet(GPIO4_BASE, IP_CLK_ENABLE);
    g_gpio4_5.baseAddress = GPIO4;
    g_gpio4_5.pins = GPIO_PIN_5;
    HAL_GPIO_Init(&g_gpio4_5);
    HAL_GPIO_SetDirection(&g_gpio4_5, g_gpio4_5.pins, GPIO_OUTPUT_MODE);
    HAL_GPIO_SetValue(&g_gpio4_5, g_gpio4_5.pins, GPIO_LOW_LEVEL);
    HAL_GPIO_SetIrqType(&g_gpio4_5, g_gpio4_5.pins, GPIO_INT_TYPE_NONE);

    return;
}

static void SPI1_Init(void)
{
    HAL_CRG_IpEnableSet(SPI1_BASE, IP_CLK_ENABLE);  /* SPI1 clock enable. */
    g_spi1.baseAddress = SPI1;

    g_spi1.mode = HAL_SPI_MASTER;
    g_spi1.csMode = SPI_CHIP_SELECT_MODE_INTERNAL;
    g_spi1.xFerMode = HAL_XFER_MODE_BLOCKING;
    g_spi1.clkPolarity = HAL_SPI_CLKPOL_0;
    g_spi1.clkPhase =  HAL_SPI_CLKPHA_0;
    g_spi1.endian = HAL_SPI_BIG_ENDIAN;
    g_spi1.frameFormat = HAL_SPI_MODE_MOTOROLA;
    g_spi1.dataWidth = SPI_DATA_WIDTH_8BIT;
    g_spi1.freqScr = SPI1_FREQ_SCR;
    g_spi1.freqCpsdvsr = SPI1_FREQ_CPSDVSR;
    g_spi1.waitEn = BASE_CFG_DISABLE;
    g_spi1.waitVal = 127; /* 127 is microwire wait time */
    g_spi1.rxBuff = NULL;
    g_spi1.txBuff = NULL;
    g_spi1.transferSize = 0;
    g_spi1.txCount = 0;
    g_spi1.rxCount = 0;
    g_spi1.state = HAL_SPI_STATE_RESET;
    g_spi1.rxIntSize =  SPI_RX_INTERRUPT_SIZE_1;
    g_spi1.txIntSize =  SPI_TX_INTERRUPT_SIZE_1;
    g_spi1.rxDMABurstSize =  SPI_RX_DMA_BURST_SIZE_1;
    g_spi1.txDMABurstSize =  SPI_TX_DMA_BURST_SIZE_1;
    HAL_SPI_Init(&g_spi1);
    HAL_SPI_ChipSelectChannelSet(&g_spi1, SPI_CHIP_SELECT_CHANNEL_0);
}

static void UART0_Init(void)
{
    HAL_CRG_IpEnableSet(UART0_BASE, IP_CLK_ENABLE);  /* UART0 clock enable. */
    g_uart0.baseAddress = UART0;

    g_uart0.baudRate = UART0_BAND_RATE;
    g_uart0.dataLength = UART_DATALENGTH_8BIT;
    g_uart0.stopBits = UART_STOPBITS_ONE;
    g_uart0.parity = UART_PARITY_NONE;
    g_uart0.txMode = UART_MODE_BLOCKING;
    g_uart0.rxMode = UART_MODE_BLOCKING;
    g_uart0.fifoMode = BASE_CFG_ENABLE;
    g_uart0.fifoTxThr = UART_FIFODEPTH_SIZE8;
    g_uart0.fifoRxThr = UART_FIFODEPTH_SIZE8;
    g_uart0.hwFlowCtr = BASE_CFG_DISABLE;
    g_uart0.handleEx.overSampleMultiple = UART_OVERSAMPLING_16X;
    g_uart0.handleEx.msbFirst = BASE_CFG_DISABLE;
    HAL_UART_Init(&g_uart0); 
}

static void IOConfig(void)
{
    HAL_IOCMG_SetPinAltFuncMode(GPIO4_4_AS_GPIO4_4);  /* Check function selection */
    HAL_IOCMG_SetPinPullMode(GPIO4_4_AS_GPIO4_4, PULL_NONE);  /* Pull-up and pull-down */
    HAL_IOCMG_SetPinSchmidtMode(GPIO4_4_AS_GPIO4_4, SCHMIDT_DISABLE);  /* Schmitt input on/off */
    HAL_IOCMG_SetPinLevelShiftRate(GPIO4_4_AS_GPIO4_4, LEVEL_SHIFT_RATE_SLOW);  /* Output drive capability */
    HAL_IOCMG_SetPinDriveRate(GPIO4_4_AS_GPIO4_4, DRIVER_RATE_2);  /* Output signal edge fast/slow */

    HAL_IOCMG_SetPinAltFuncMode(GPIO4_5_AS_GPIO4_5);  /* Check function selection */
    HAL_IOCMG_SetPinPullMode(GPIO4_5_AS_GPIO4_5, PULL_NONE);  /* Pull-up and pull-down */
    HAL_IOCMG_SetPinSchmidtMode(GPIO4_5_AS_GPIO4_5, SCHMIDT_DISABLE);  /* Schmitt input on/off */
    HAL_IOCMG_SetPinLevelShiftRate(GPIO4_5_AS_GPIO4_5, LEVEL_SHIFT_RATE_SLOW);  /* Output drive capability */
    HAL_IOCMG_SetPinDriveRate(GPIO4_5_AS_GPIO4_5, DRIVER_RATE_2);  /* Output signal edge fast/slow */

    HAL_IOCMG_SetPinAltFuncMode(GPIO0_3_AS_UART0_TXD);  /* Check function selection */
    HAL_IOCMG_SetPinPullMode(GPIO0_3_AS_UART0_TXD, PULL_NONE);  /* Pull-up and pull-down */
    HAL_IOCMG_SetPinSchmidtMode(GPIO0_3_AS_UART0_TXD, SCHMIDT_DISABLE);  /* Schmitt input on/off */
    HAL_IOCMG_SetPinLevelShiftRate(GPIO0_3_AS_UART0_TXD, LEVEL_SHIFT_RATE_SLOW);  /* Output drive capability */
    HAL_IOCMG_SetPinDriveRate(GPIO0_3_AS_UART0_TXD, DRIVER_RATE_2);  /* Output signal edge fast/slow */

    HAL_IOCMG_SetPinAltFuncMode(GPIO0_4_AS_UART0_RXD);  /* Check function selection */
    HAL_IOCMG_SetPinPullMode(GPIO0_4_AS_UART0_RXD, PULL_NONE);  /* Pull-up and pull-down */
    HAL_IOCMG_SetPinSchmidtMode(GPIO0_4_AS_UART0_RXD, SCHMIDT_DISABLE);  /* Schmitt input on/off */
    HAL_IOCMG_SetPinLevelShiftRate(GPIO0_4_AS_UART0_RXD, LEVEL_SHIFT_RATE_SLOW);  /* Output drive capability */
    HAL_IOCMG_SetPinDriveRate(GPIO0_4_AS_UART0_RXD, DRIVER_RATE_2);  /* Output signal edge fast/slow */

    HAL_IOCMG_SetPinAltFuncMode(GPIO4_6_AS_SPI1_CLK);  /* Check function selection */
    HAL_IOCMG_SetPinPullMode(GPIO4_6_AS_SPI1_CLK, PULL_NONE);  /* Pull-up and pull-down */
    HAL_IOCMG_SetPinSchmidtMode(GPIO4_6_AS_SPI1_CLK, SCHMIDT_DISABLE);  /* Schmitt input on/off */
    HAL_IOCMG_SetPinLevelShiftRate(GPIO4_6_AS_SPI1_CLK, LEVEL_SHIFT_RATE_SLOW);  /* Output drive capability */
    HAL_IOCMG_SetPinDriveRate(GPIO4_6_AS_SPI1_CLK, DRIVER_RATE_2);  /* Output signal edge fast/slow */

    HAL_IOCMG_SetPinAltFuncMode(GPIO1_3_AS_SPI1_TXD);  /* Check function selection */
    HAL_IOCMG_SetPinPullMode(GPIO1_3_AS_SPI1_TXD, PULL_NONE);  /* Pull-up and pull-down */
    HAL_IOCMG_SetPinSchmidtMode(GPIO1_3_AS_SPI1_TXD, SCHMIDT_DISABLE);  /* Schmitt input on/off */
    HAL_IOCMG_SetPinLevelShiftRate(GPIO1_3_AS_SPI1_TXD, LEVEL_SHIFT_RATE_SLOW);  /* Output drive capability */
    HAL_IOCMG_SetPinDriveRate(GPIO1_3_AS_SPI1_TXD, DRIVER_RATE_2);  /* Output signal edge fast/slow */

    HAL_IOCMG_SetPinAltFuncMode(GPIO3_0_AS_SPI1_CSN1);  /* Check function selection */
    HAL_IOCMG_SetPinPullMode(GPIO3_0_AS_SPI1_CSN1, PULL_NONE);  /* Pull-up and pull-down */
    HAL_IOCMG_SetPinSchmidtMode(GPIO3_0_AS_SPI1_CSN1, SCHMIDT_DISABLE);  /* Schmitt input on/off */
    HAL_IOCMG_SetPinLevelShiftRate(GPIO3_0_AS_SPI1_CSN1, LEVEL_SHIFT_RATE_SLOW);  /* Output drive capability */
    HAL_IOCMG_SetPinDriveRate(GPIO3_0_AS_SPI1_CSN1, DRIVER_RATE_2);  /* Output signal edge fast/slow */

    HAL_IOCMG_SetPinAltFuncMode(GPIO1_4_AS_SPI1_RXD);  /* Check function selection */
    HAL_IOCMG_SetPinPullMode(GPIO1_4_AS_SPI1_RXD, PULL_NONE);  /* Pull-up and pull-down */
    HAL_IOCMG_SetPinSchmidtMode(GPIO1_4_AS_SPI1_RXD, SCHMIDT_DISABLE);  /* Schmitt input on/off */
    HAL_IOCMG_SetPinLevelShiftRate(GPIO1_4_AS_SPI1_RXD, LEVEL_SHIFT_RATE_SLOW);  /* Output drive capability */
    HAL_IOCMG_SetPinDriveRate(GPIO1_4_AS_SPI1_RXD, DRIVER_RATE_2);  /* Output signal edge fast/slow */

}

void SystemInit(void)
{
    IOConfig();
    UART0_Init();
    SPI1_Init();
    GPIO_Init();

    /* USER CODE BEGIN system_init */
    /* USER CODE END system_init */
}

芯片配置如下

连线根据原理图找相应位置即可

nonsense1973
关注
海思OSD开发系列(一) SDL_TTF框架移植
一只海星的主页
06-10 3725
参考 海思平台freetype、SDL、SDL_TTL的编译 交叉编译freetype 交叉编译SDL 安装配置及环境变量的设置 背景 需求 在海思osd显示，就是在region叠方块，我们常用的需求就是叠加 时间戳、通道名称、log等，做的好一点的可以实现二维码扫描方块显示、天气信息等等； 需求里就两类信息，一种字符、一种图片，最后的实现其实都一样，通通转成位图bmp叠上去就ok; 今天我们要做的就是搞字体； 字体 点阵式字体 安防领域，传统使用点阵式字体，顾名思义就是打点成像，跟老式的针式打印
Hi3861_海思官方_第三方软件移植指南1
08-04
【Hi3861_海思官方_第三方软件移植指南1】是海思技术有限公司为开发者提供的一份详细文档，旨在指导用户将第三方软件移植到Hi3861V100和Hi3861LV100平台上的SDK环境中。这份指南包含了移植过程中的操作步骤、常见...
QT5.9移植到海思HI3520设备上运行
Biao
06-16 6400
前言： 在海思HI3520DV300上调试QT5.9.0有一小段时间了，这里将遇到的比较典型的问题做一个记录，以备后续查询，也可给同行一个参考。本人只使用过QT5.9.0这一个版本，如有描述错误欢迎指出。 说明： QT版本：qt-everywhere-opensource-src-5.9.0 qt-creator版本：qt-creator-opensource-l...........................
3、海思3518ev300 RTL8189FS移植
未定的博客
01-29 1152
首先我们解压RTL8189fs的sdk压缩包，打开Makefile。修改其中的交叉编译工具、linux内核路径、指定对应的wifi芯片以及选择对应的平台。 1、先将CONFIG_RTL8188F选择为y 2、选中CONFIG_PLATFORM_HISILICON为y，就是设置海思开发平台 3、跳到底部的CONFIG_PLANTFORM_HISILICON选项，修改交叉编译工具链，指定自己的linux路径。MOUDULE_NAME是make后生成的ko的名字，可以自己定义。 接着我们.
海思Rtmp之Nginx和ffmpeg的移植。
gf8956的博客
05-24 3548
公司需要用海思推流rtmp，首先需要在海思中移植服务器，nginx服务器是比较常用的服务器之一。 （1）nginx编译 ./configure --prefix=/opt/app/nginx \ --with-zlib=/home/gf/交叉编译nginx/nginx交叉编译/zlib-1.2.8 \ --with-cc=arm-hisiv300-linux-gcc \ --user...
海思Hi3559A编译x264
阿Sir问道
12-26 1520
1、交叉编译工具 aarch64-himix100-linux-gcc 2、下载x264源码  # git clone git://git.videolan.org/x264.git 3、编译  配置选项  ./configure --enable-pthread --enable-static --disable-shared --host=arm-linux --disable-as...
mp4v2移植海思Hi3559AV100平台
阿Sir问道
01-17 1242
1、下载MP4v2源码          https://launchpad.net/ubuntu/artful/+source/mp4v2 2、配置编译工具          sudo CC=aarch64-himix100-linux-gcc CXX=aarch64-himix100-linux-g++ ./configure --host=arm-linux --prefix=/opt...
海思算法移植
weixin_41012399的博客
09-28 2127
背景：pytorch训练了一个yolov5模型，在服务器上使用。现打算移植到海思3559上。 尝试方法：yolov5pytorch训练------转onnx模型-----转caffe模型-----如意工具量化-----板端测试。 环境配置： pytorch转onnx用的： onnx转caffe环境： yolov5-caffe模型测试：https://github.com/Wulingtian/yolov5_caffe 板端yolov5后处理代码： ...
移植ffmpeg至海思平台
chenwr2018的博客
09-25 4227
一、xvid、x264、ffmpeg源码下载 链接：https://pan.baidu.com/s/13phSFrLqkGrKDGF3_a2cSA 提取码：ls2s 二、交叉编译 1. xvid tar zxvf xvidcore-1.3.3.tar.gz cd xvidcore/build/generic ./configure --prefix=/home/workspace/arm_sof...
海思Hi3559A平台移植 opencv4.0.0
阿Sir问道
12-26 4248
1、交叉编译工具 aarch64-himix100-linux-gcc 2、下载opencv-4.0.0源码  # git clone https://github.com/opencv/opencv.git 3、编译 源码 cmake编译：               进去到opencv-4.0.0目录下，创建build文件夹，根据需要配置编译选项如下：               ...
live555海思平台移植.zip_rtsp live555 海思_rtsp 海思_关于live555的_平台移植_海思3516
07-15
本文将详细讨论如何在海思3516平台上移植和使用live555，以实现实时视频流的转发。 首先，我们需要了解RTSP（Real-Time Streaming Protocol）。RTSP是一种应用层协议，用于控制多媒体数据的传输，它允许客户端通过...
海思移植 LVGL v8.x 及NXP GUI-Guider代码移植
最新发布
08-01
海思移植 LVGL V8.x 及NXP GUI-Guider代码移植，也可移植SquareLine代码， 适用Linx系统， Framebuffer设备
海思3519移植问题总结.docx
01-28
海思3519移植问题总结 本文档总结了海思3519移植过程中可能遇到的问题和解决方法。海思3519是一个高性能的嵌入式处理器，广泛应用于智能家电、自动驾驶、机器人等领域。然而，在移植海思3519时，可能会遇到各种问题...
QT属性动画--设置样式属性(其他属性)
lizequan的博客
03-02 6228
这里写自定义目录标题故事背景遇到的问题解决过程最终方法感悟 故事背景   最近在制作一个按钮切换的动画特效中接触了属性动画这部分内容，并由此产生了一些思考。 遇到的问题 解决过程 最终方法 感悟 ...
Volatile的其他特性
我想月薪过万的博客
03-03 4567
2.1 volatile总体概览 在上一节中，我们已经研究完了volatile可以实现并发下共享变量的可见性，volatile除了保证可见性外，volatile还具备如下一些突出的特性： volatile的原子性问题：volatile不能保证原子性操作 禁止指令重排序：volatile可以防止指令重排序操作 2.2 volatile不保证原子性 2.3 代码测试 package Ls; /** * 目标：研究Volatile的原子性操作 * <p> * 基本观点：V.
【安卓基础】Android直接通过路径来操作其他应用的私有目录，可以吗？
m0_48179608的博客
03-02 7862
在上篇文章[【安卓基础】一文搞懂Android历代版本文件访问权限变化](https://blog.csdn.net/m0_48179608/article/details/122838494)我们对同一个应用的的文件访问权限做了比较。 那么不同应用之间文件访问又有什么限制呢？我们准备分二到三篇文件来阐述。 这篇文章，主要来看下不同系统版本下，我们直接通过路径来访问其它应用的**内部存储、外部存储私有目录**，看看能不能访问以及不同系统版本的区别。
Silane-PEG-NHS，SIL-PEG-NHS，可以用来修饰蛋白质、多肽以及其他活性基团，NHS-PEG-Silane
qq_39152602的博客
03-03 4142
英文名称：Silane-PEG-NHS 中文名称：硅烷-聚乙二醇-活性酯 分子量：1k，2k，3.4k，5k，10k，20k（可按需定制） 质量控制：95%+ 存储条件：-20°C，避光，避湿 用 途：仅供科研实验使用，不用于诊治 外观: 固体或粘性液体，取决于分子量 注意事项：取用一定要干燥，避免频繁的溶解和冻干 溶解性：溶于大部分有机溶剂，如：DCM、DMF、DMSO、THF等等。在水中有很好的溶解性 取用：现配现用，将包装从冰箱中取出，置于干燥器中缓慢升至室温，打开瓶盖，取用。取用.
[Golang]力扣Leetcode—中级算法—其他—两整数之和（位运算）
皮埃尔的博客
03-03 3379
[Golang]力扣Leetcode—中级算法—其他—两整数之和（位运算）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值