国民技术N32G430开发笔记（15）- IAP升级 树莓派串口发送数据

已于 2023-05-03 16:02:12 修改
阅读量1k 收藏
点赞数
分类专栏： N32G430C8L7 文章标签： 嵌入式硬件 单片机 stm32
于 2023-05-03 15:46:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43932857/article/details/130473586
版权

IAP升级 树莓派串口发送数据

1、树莓派接入usb转串口模块后，会生成/dev/ttyUSB0节点，因为树莓派内核已经编译usb_serial以及各模块的驱动。
我们直接对ttyUSB0节点编程即可。
2、协议同上一节
cmd + data_lenght + data0 + …+ datax + checksum
1、获取版本号 0x01 0x02 0x00 0x00 checksum
2、升级
1、进入升级模式 0x02 0x02 0x00 0x00 checksum
2、升级文件大小 0x03 0x04 0x00 0x00 0x00 0x00 checksum
3、数据包发送 0x04 0x80 0x00 0x00 0x00 0x00 … checksum
4、数据包发送完成 0x05 0x02 0x00 0x00 checksum

checksum采用crc16的检验方法。

3、升级过程：
1、发送升级模式命令。
2、发送文件大小命令
3、循环发送Application.bin的升级包，每包数据head+64个数据+checksum。
4、发送升级完成命令。
4、代码解析如下：
在这里插入图片描述
在build目录执行 cmake …;make 即可编译出uartiap。

CMakeLists.txt

cmake_minimum_required(VERSION 3.18.4)
project (uartIap)

aux_source_directory(. C_SOURCES)
aux_source_directory(./UartIap C_SOURCES_UART)

include_directories(./UartIap)

add_executable(${PROJECT_NAME} ${C_SOURCES} ${C_SOURCES_UART})
target_link_libraries(${PROJECT_NAME} pthread)

n32g430_iap.c

#include <stdio.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>
#include "uart.h"

#define APPLICATION_PATH                "Application.bin"
#define UPGRADE_DATA_PACKAGES_LENGHT    0x40
#define UPGRADE_PACKAGES_LENGHT         0x40 + 0x04

typedef enum{

    MI_FALSE  =   0,
    MI_TRUE   =   1,

}MI_BOOL;

typedef unsigned char   MI_U8;
typedef unsigned short  MI_U16;

MI_U8 get_ver_cmd[6]            = {0x01,0x02,0x00,0x00,0x00,0x00};
MI_U8 update_cmd[6]             = {0x02,0x02,0x00,0x00,0x00,0x00};
MI_U8 file_size_cmd[8]          = {0x03,0x04,0x00,0x00,0x00,0x00,0x00,0x00};
MI_U8 file_package[UPGRADE_PACKAGES_LENGHT]         = {0x04,UPGRADE_DATA_PACKAGES_LENGHT};
MI_U8 update_complete_cmd[6]    = {0x05,0x02,0x00,0x00};
MI_U16 w_num = 0;

static MI_U8 isRunning = 0;
char r_data[256] = {0};
sem_t sem;

static MI_BOOL get_update_file_size(char * file_path,size_t *size)
{
    FILE *file;

    file = fopen(file_path,"rb");

    if (!file)
    {
        perror("get_update_file_size fopen error\n");
        return MI_FALSE;
    }
    fseek(file, 0L, SEEK_END);

    *size = ftell(file);

    fclose(file);
    return MI_TRUE;
}

static MI_U16 CRC16(MI_U8 * buf, MI_U16 len)
{
	MI_U16 i;
	MI_U16 crc = 0xffff;
 
	if (len == 0) {
		len = 1;
	}
	while (len--) {
        
		crc ^= *buf;
		for (i = 0; i<8; i++) 
		{            
			if (crc & 1) {               
				crc >>= 1;        
				crc ^= 0xA001;            
			}      
			else {               
				crc >>= 1;            
			}       
		}     
		buf++;
	}
	return(crc);
}

static MI_BOOL compare(MI_U8 *des,MI_U8 *src,int len)
{
    while (len--)
    {
        if (*des != *src)
        {
            return MI_FALSE;
        }

        des++;
        src++;
    }

    return MI_TRUE;
}

static void send_get_version_cmd(int fd)
{
    int len = sizeof(get_ver_cmd);
    int crc = CRC16(get_ver_cmd,len-2);
    get_ver_cmd[len-2] = crc & 0x00ff;
    get_ver_cmd[len-1] = ((crc >> 8) & 0x00ff);
    serialWrite(fd,get_ver_cmd,sizeof(get_ver_cmd));
}

static void send_enter_update_cmd(int fd)
{
    int len = sizeof(update_cmd);
    int crc = CRC16(update_cmd,len-2);
    update_cmd[len-2] = crc & 0x00ff;
    update_cmd[len-1] = ((crc >> 8) & 0x00ff);
    serialWrite(fd,update_cmd,sizeof(update_cmd));
}

static MI_BOOL send_update_file_size_cmd(int fd)
{
    int len = sizeof(file_size_cmd);
    size_t file_size = 0;
    get_update_file_size(APPLICATION_PATH,&file_size);

    file_size_cmd[2] = (file_size >> 24 & (0xff));
    file_size_cmd[3] = (file_size >> 16 & (0xff));
    file_size_cmd[4] = (file_size >> 8 & (0xff));
    file_size_cmd[5] = (file_size & (0xff));

    int crc = CRC16(file_size_cmd,len-2);
    file_size_cmd[len-2] = crc & 0x00ff;
    file_size_cmd[len-1] = ((crc >> 8) & 0x00ff);

    serialWrite(fd,file_size_cmd,sizeof(file_size_cmd));
    return MI_TRUE;
}

static MI_BOOL send_file_every_package(int fd)
{
    int len = sizeof(file_package);
    FILE *fp;
    size_t file_size;
    int package_num;
    MI_U8 package_buff[UPGRADE_DATA_PACKAGES_LENGHT] = {0};

    fp = fopen(APPLICATION_PATH,"rb");
    if (!fp)
    {
        perror("fopen error\n");
        return MI_FALSE;
    }
    get_update_file_size(APPLICATION_PATH,&file_size);

    if (file_size % UPGRADE_DATA_PACKAGES_LENGHT == 0 )
    {
        package_num = file_size / UPGRADE_DATA_PACKAGES_LENGHT;
    }
    else
    {
        package_num = (file_size / UPGRADE_DATA_PACKAGES_LENGHT) + 1;
    }

    printf("pageage_num == %d\n",package_num);
    while (!feof(fp)/* condition */)
    {
        /* code */
        int r_len = fread(package_buff,1,UPGRADE_DATA_PACKAGES_LENGHT,fp);
        
        // 最后读出来不满128 ，用0xff补全。
        if (r_len != UPGRADE_DATA_PACKAGES_LENGHT)
        {
            for (int i=r_len;i<UPGRADE_DATA_PACKAGES_LENGHT;i++)
            {
                package_buff[i] = 0xff;
            }
        }

        memcpy(&file_package[2],package_buff,sizeof(package_buff));

        int crc = CRC16(file_package,sizeof(file_package)-2);
        file_package[sizeof(file_package)-2] = crc & 0x00ff;
        file_package[sizeof(file_package)-1] = ((crc >> 8) & 0x00ff);


        usleep(30 * 1000);
        w_num++;

        printf("send package process == [%03d]\n", ((w_num * 100)/package_num));

#if DEBUG
        for(int i=0;i< len;i++)
        {
            printf("0x%02x  ",file_package[i]);
            if ((i+1) % 16 == 0)
                printf("\n");
        }
        printf("\n");

#endif
        memset(r_data,0,sizeof(r_data));
        serialWrite(fd,file_package,len);
        sem_wait(&sem);
#if DEBUG
        // for(int i=0;i< len;i++)
        // {
        //     printf("0x%02x  ",r_data[i]);
        //     if ((i+1) % 16 == 0)
        //         printf("\n");
        // }
        // printf("\n");


        // int status = compare(r_data,file_package,20);
        // if (status)
        // {
        //     printf("send_file_every_package and receive cmd success!\n");
        // }
        // else
        // {
        //     perror("send_file_every_package not equal receive cmd\n");
        // }
       
        //printf("read len == %d  w_num == %d \n",len,w_num);
 #endif        
    }
    
    fclose(fp);
    return MI_TRUE;
}

static MI_BOOL send_update_complete_cmd(int fd)
{
    int len = sizeof(update_complete_cmd);
    int crc = CRC16(update_complete_cmd,len-2);
    update_complete_cmd[len-2] = crc & 0x00ff;
    update_complete_cmd[len-1] = ((crc >> 8) & 0x00ff);
    serialWrite(fd,update_complete_cmd,sizeof(update_complete_cmd));

    return MI_TRUE;
}

void *uart_read_thread(void *arg)
{
    int fd = *((int *)arg);
    size_t  size ;        

    sem_wait(&sem);
    while(isRunning)
    {
        size = serialRead(fd,r_data,256); //阻塞方式去读

    #if DEBUG    
        if (size > 0)
        {
            for(int i=0;i<size;i++)
            {
                printf("0x%02x  ",r_data[i]);
            }
            printf("\n");
        }
    #endif    
        sem_post(&sem);
    }

    printf("uart_read_thread exit\n");
    pthread_exit(0);
}

int main(int argc,char *argv[])
{
    int fd = 0;
    int ret;
    char w_data[] = "hello world\n";
    MI_U16 crc = 0;
    MI_BOOL status;
    pthread_t m_read_thread ;
    size_t update_file_size;

    sem_init(&sem, 0, 0);
    fd = serialOpen("/dev/ttyUSB0",115200);

    if (fd > 0)
    {
        printf("open ttyUSB0 ok\n");
    }
    else
    {
        printf("open ttyUSB0 fail\n");
        return -1;
    }

    ret = pthread_create(&m_read_thread,NULL,uart_read_thread,&fd);
    if (ret)
    {
        perror("pthread_create error\n");
        return -1;
    }
    else
    {
        isRunning = 1;
        sem_post(&sem);
    }

    sleep(1);// 获取一下N32G430C8L7的版本号
    
    memset(r_data,0,sizeof(r_data));
    send_get_version_cmd(fd);
    sem_wait(&sem);

    printf("get version == %s\n",r_data);

    memset(r_data,0,sizeof(r_data));
    send_enter_update_cmd(fd);
    sem_wait(&sem);

    status = compare(r_data,update_cmd,sizeof(update_cmd));
    if (status)
    {
        printf("send_enter_update_cmd and receive cmd success!\n");
    }
    else
    {
        perror("send_enter_update_cmd not equal receive cmd\n");
    }

    get_update_file_size(APPLICATION_PATH,&update_file_size);
    printf("get update file size == %ld\n",update_file_size);

    memset(r_data,0,sizeof(r_data));
    send_update_file_size_cmd(fd);
    sem_wait(&sem);

    status = compare(r_data,file_size_cmd,sizeof(file_size_cmd));
    if (status)
    {
        printf("send_update_file_size_cmd and receive cmd success!\n");
    }
    else
    {
        perror("send_update_file_size_cmd not equal receive cmd\n");
    }

    send_file_every_package(fd);

    memset(r_data,0,sizeof(r_data));
    send_update_complete_cmd(fd);
    sem_wait(&sem);

    pthread_cancel(m_read_thread);
    isRunning = 0;

    pthread_join(m_read_thread,NULL);
    serialClose(fd);
    printf("raspberryPi App exit!\n");
}

uart.c

#include <stdio.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <pthread.h>
#include "uart.h"

static speed_t getBaudRate(int baudRate)
{
    switch(baudRate) {
        case 0: return B0;
        case 50: return B50;
        case 75: return B75;
        case 110: return B110;
        case 134: return B134;
        case 150: return B150;
        case 200: return B200;
        case 300: return B300;
        case 600: return B600;
        case 1200: return B1200;
        case 1800: return B1800;
        case 2400: return B2400;
        case 4800: return B4800;
        case 9600: return B9600;
        case 19200: return B19200;
        case 38400: return B38400;
        case 57600: return B57600;
        case 115200: return B115200;
        case 230400: return B230400;
        case 460800: return B460800;
        case 500000: return B500000;
        case 576000: return B576000;
        case 921600: return B921600;
        case 1000000: return B1000000;
        case 1152000: return B1152000;
        case 1500000: return B1500000;
        case 2000000: return B2000000;
        case 2500000: return B2500000;
        case 3000000: return B3000000;
        case 3500000: return B3500000;
        case 4000000: return B4000000;
        default: return -1;
    }
}

static int setParity(int fd,int dataBits,int stopBits,int parity)
{
    struct termios options;
    if (tcgetattr (fd, &options) != 0) {
        printf ("SetupSerial 1");
        return (-1);
    }
    options.c_cflag &= ~CSIZE;
    switch (dataBits) {
        case 7:
            options.c_cflag |= CS7;
            break;
        case 8:
            options.c_cflag |= CS8;
            break;
        default:
            fprintf (stderr, "Unsupported data size\n");
            return (-1);
    }

    switch (parity) {
        case 'n':
        case 'N':
            options.c_cflag &= ~PARENB; /* Clear parity enable */
            options.c_iflag &= ~INPCK;  /* Enable parity checking */
            break;
        case 'o':
        case 'O':
            options.c_cflag |= (PARODD | PARENB);
            options.c_iflag |= INPCK;   /* Disable parity checking */
            break;
        case 'e':
        case 'E':
            options.c_cflag |= PARENB;  /* Enable parity */
            options.c_cflag &= ~PARODD;
            options.c_iflag |= INPCK;   /* Disable parity checking */
            break;
        case 'S':
        case 's':           /*as no parity */
            options.c_cflag &= ~PARENB;
            options.c_cflag &= ~CSTOPB;
            break;
        default:
            fprintf (stderr, "Unsupported parity\n");
            return (-1);
    }
    switch (stopBits) {
        case 1:
            options.c_cflag &= ~CSTOPB;
            break;
        case 2:
            options.c_cflag |= CSTOPB;
            break;
        default:
            fprintf (stderr, "Unsupported stop bits\n");
            return (-1);
    }

    /* Set input parity option */
    if (parity != 'n')
        options.c_iflag |= INPCK;
    tcflush (fd, TCIFLUSH);
    options.c_cc[VTIME] = 0x01;
    options.c_cc[VMIN] =  0xFF; /* Update the options and do it NOW */
    //qd to set raw mode, which is copied from web
    options.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP
                         | INLCR | IGNCR | ICRNL | IXON);
    options.c_oflag &= ~OPOST;
    options.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
    options.c_cflag &= ~(CSIZE | PARENB);
    options.c_cflag |= CS8;

    if (tcsetattr (fd, TCSANOW, &options) != 0) {
        perror ("SetupSerial 3");
        return (-1);
    }

    return 0;
}

int serialOpen(const char *path, int baudRate)
{
    int fd;
    speed_t speed;

    /* Check arguments */
    {
        speed = getBaudRate(baudRate);
        if (speed == -1) {

            printf("get Baud rate error\n");
            return -1;
        }
    }
    {
        fd = open(path, O_RDWR);
        if (fd == -1)
        {
            printf("open serial error =%d\n",fd);
            return -1;
        }
    }
    /* Configure device */
    {
        struct termios cfg;
        if (tcgetattr(fd, &cfg))
        {
            printf("tcgetattr() failed\n");
            close(fd);
            return -1;
        }

        cfmakeraw(&cfg);
        cfsetispeed(&cfg, speed);
        cfsetospeed(&cfg, speed);

        if (tcsetattr(fd, TCSANOW, &cfg))
        {
            printf("tcsetattr() failed\n");
            close(fd);
            return -1;
        }
    }
    setParity(fd,8,1,'N');
    //printf("open Success==%d\n",fd);
    return fd;
}


int serialWrite(int fd,char *writeData,int len)
{
    if (fd > 0){
        write(fd,writeData,len);
    }else{

        printf("[File]=%s[Function]=%s error\n",__FILE__,__FUNCTION__);
        return -1;
    }
    return 0;
}

int serialRead(int fd,char *readData,int len)
{
    size_t size = 0;
    if (fd > 0)
    {
        size = read(fd,readData,len);
    }
    else
    {

        printf("[File]=%s[Function]=%s error\n",__FILE__,__FUNCTION__);
        return -1;
    }
    return size;
}

int serialClose(int fd)
{
    close(fd);
    return 0;
}

uart.h

#ifndef __UART_H__
#define __UART_H__

int serialOpen(const char *path, int baudRate);
int serialWrite(int fd,char *writeData,int len);
int serialRead(int fd,char *readData,int len);
int serialClose(int fd);

#endif

5、视频

屏幕录制2023-05-03 15.39.07

6、代码路径 ： https://gitee.com/xiaoguo-tec_0/raspberrypi

夏侯城临
关注
专栏目录
N32G430学习笔记18-基于串口的IAP程序升级
Car12
10-05 855
N32F430C8L6 ROM 地址范围ROM 地址范围: 0x800 0000~0x800 FFFF 合计64K,扇区大小 2048Byte = 2kfalsh 空间分配设置。
国民技术N32G430开发笔记（16）- IAP升级 整合多个bin文件为一个升级包
weixin_43932857的博客
05-04 775
3、我们新建一个（16+8+20）*1024个字节的数组，将Bootloader.bin从0开始填到数组中，将Settings.bin从0x4000处填充到数组中，将Application.bin 从0x6000填充到数组中，最后写入文件中，即可得到我们想要的all.bin。Bootloader.bin. 起始地址0x8000000。Application.bin 起始地址0x8006000。7、根目录下make后回在output下生成all.bin文件。
国民技术N32G430开发笔记（3）- 串口1的使用
weixin_43932857的博客
04-27 676
4、printf重映射，因为gcc环境，重写_write函数。根据芯片手册，PA9 PA10可用作uasrt1。1、usart1用作printf的打印使用。5、使用printf就可以收到打印了。3、main.c调用。
国民技术N32G430开发笔记（4）- - 串口2中断+IDLE接收不定长数据
weixin_43932857的博客
04-27 1392
1、根据手册可查PA6 PA7可复用usart2功能。我们将电脑端发送过来的数据 返还回电脑。2、复用功能配置如图。
国民技术N32G430开发笔记（14）-IAP升级 usart2接收数据
weixin_43932857的博客
05-03 1349
5、重启后，mcu进入bootloader后，读取update_flag，如果为1，将download区域数据拷贝到App区域，然后跳转到App执行，完成App区域的升级。3、数据包发送 0x04 0x80 0x00 0x00 0x00 0x00 …2、升级文件大小 0x03 0x04 0x00 0x00 0x00 0x00 checksum。1、进入升级模式 0x02 0x02 0x00 0x00 checksum。
国民技术N32G430开发笔记（12）- IAP升级 Settings区域数据初始化
weixin_43932857的博客
04-28 850
这里我们将setting区域的数据提前初始化，通过c语言的文件流的操作方法，创建一个setting.bin文件，然后将setting区域存储的结构体初始化后写入setting.bin文件，然后通过pyocd烧录到0x08004000地址即可。1、假如，有两个产品，A产品跟B产品，硬件都一样，要求一个软件里的board_name为N32G430C8L7_STB_A，另一个软件里的board_name为N32G430C8L7_STB_B。4、setting_init.c文件。6、根目录执行make后，
国民技术N32G430C8L7串口IAP 升级代码
10-06
《国民技术N32G430C8L7串口IAP升级代码详解》 在嵌入式系统开发中，固件更新是一项至关重要的任务，它允许开发者远程修复错误、添加新功能或优化现有软件。国民技术的N32G430C8L7是一款基于ARM Cortex-M4内核的高...
21.国民技术N32G45X例程之-U盘模式IAP升级固件.rar
12-23
21.国民技术N32G45X例程之-U盘模式IAP升级固件，利用模拟U盘升级固件，只占用了24K的FLASH完成。已经在具体项目中使用，成熟可靠，值得注意，需要配合20.国民技术N32G45X例程之-C-Free5合成BIN文件使用。这个代码为...
国民技术N32G031使用YMODEM协议实现IAP
11-17
4、在进行RS485通信时必须要注意USART_FLAG_TXC标志位的检查，这是一串数据最后一个字节发送完成的标志，只有它置1才表示数据全部发送完成，光检测标志位USART_FLAG_TXDE还不够，这里一定要注意，否则会发生莫名其妙...
N32G430实现串口IAP升级【支持N32G4系列单片机_标准库驱动】.zip
07-17
总的来说，N32G430单片机的串口IAP升级技术结合标准库驱动，不仅提升了开发效率，还保证了设备在运行过程中能够进行无缝的固件升级，这对于实时系统和远程设备维护具有显著优势。在实际应用中，开发者应当重视IAP...
NZ3801-AB 国民技术-驱动示例代码 V1.1.rar
12-27
NZ3801-AB 国民技术-驱动示例代码 是一款身份读取芯片的代码 比如门禁卡读卡器 身份证 银行卡识别等等。
国民技术主控芯片开发资料
11-08
国民技术中控芯片的资料，方便大家对其进行开发
国民技术N32G430开发笔记（19）- IAP 升级 I2C1 从机收发数据
weixin_43932857的博客
05-06 918
1、之前讲过usart2收发数据进行IAP升级，上节i2c1设置为从机后，可跟Android版卡通讯，那么融合之前的代码，我们这一节用i2c收发数据进行IAP升级。跟usart不用的是数据包数据长度为0x80,串口之前受限于usb转串口驱动，长度为0x40。4、N32版卡都在handle_i2c_message函数中处理，发送升级模式指令 —>>> 发送升级文件大小—>>>>5、其他 写flash以及跳转跟串口升级一样。分包发送数据—>>>数据包发送完成指令。
国民技术N32G430开发笔记（10）- IAP升级 Application 的制作
weixin_43932857的博客
04-28 1179
程序的执行地址变成了之前flash设定的0x08006000处，1、App程序跟Bootloader程序最大的区别就是，直接输入 make gdapp也是可以烧录的。所以修改Application工程的ld文件。烧录是起始地址也要改为x0x08006000。origin 改成 0x08006000。length 改成0x5000。
国民技术N32G430开发笔记（11）- IAP升级 Settings区域数据读写
weixin_43932857的博客
04-28 191
1、Settings区域可以储存我们的一些数据，我们定义成结构体形式，然后按照结构体的形式写进falsh，使用时读取即可。比如我们定义了一个system_info的结构体，我们要获取是否升级的这个flag值，2、新增setting.c setting.h文件。我们调用下看看效果，是不是我们想要的。我们写入一个2，看打印读取的是否为2.
国民技术N32G430开发笔记（9）- IAP升级 Bootloader的制作
weixin_43932857的博客
04-28 2006
之前的教程都是基于Application程序开发，所以跳转到Application后，会看到定时器6每100ms去开关LED1，1、上节提到Flash的分区，0x8000000-0x8004000为Boot分区，我们的bootloader就烧录到此分区。代码路径：https://gitee.com/xiaoguo-tec_0/n32iap。Bootloader很简单，新建一个普通的工程，也不用初始化外部设备，开机后，直接跳转到。当然App的分区程序也要提前烧录进去，App分区所在的地址即可，
N32G430C8开发笔记二-UART驱动开发
最新发布
sscb0521的博客
01-24 666
E:\tfs\data\smartsafe\N32G430\Nations.N32G430_Library.1.0.0\projects\n32g430_EVAL\examples\USART\Interrupt开发uart1和uart3驱动。Uart1_tx引脚使用PA9，重映射使用AF5，Uart1_rx引脚使用PA10，重映射使用AF5，Uart3_tx引脚使用PB10，重映射使用AF10，Uart3_Rx引脚使用PB11，重映射使用AF10。配置IO的复用功能为UART。4、uart中断响应函数。
cmake:基于MDK(Keil)的Nationstech.N32G45x平台交叉编译工具链定义
10km的专栏
02-06 2168
Keil MDK是非常常用的单片机开发集成环境，Keil公司2005年由ARM公司收购，现在是ARM主要的嵌入系统开发平台(ARM的另一个开发环境ds-5早在九年前就停止更新了)。 Keil虽然是个集成开发环境，但Keil本身其实是由μVision IDE和arm编译器构成。cmake虽然目前不支持生成μVision的工程文件，但cmake完全可以使用MDK中提供的arm编译器来实现独立于μVision的交叉编译(说到底μVision只是一个为开发者提供易用的GUI界面,真正干活的还是编译器)。 cmake
N32G430学习笔记9-串口dma方式收发数据+printf的代码版本
Car12
10-01 1574
串口dma方式收发数据+printf的代码版本
国民技术N32G45X flash
08-12
国民技术N32G45X芯片中的flash是一种非易失性存储器，用于存储程序和数据。根据引用，该芯片支持通过U盘模式进行固件升级。引用提供了一些关于固件的地址信息，例如bootloader的大小约为15K，隐藏文件预留4K，合成的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值