1949啦网--小小

stm32中电脑设备管理器识别到了ST-Link，但是在keil5中无法识别的解决办法

Thu, 19 Jun 2025 15:10:31 +0800

原来是驱动没装。。，装了驱动就好了

keil5软件所需软件包下载地址

Thu, 19 Jun 2025 14:52:21 +0800

https://www.keil.arm.com/devices/#!%23third-party-download-dialog

编写QT串口上位机接收stm32串口发送的数据

Mon, 16 Jun 2025 16:57:16 +0800

QT串口上位机的代码

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    ui->pushButton->setEnabled(false);
    serial=new QSerialPort(this);
    updateSerialPortMenu();
    connect(ui->pushButton,&QPushButton::clicked,this,[=]()
    {
        if(serial->isOpen())
        {
            ui->pushButton->setText("打开串口");
             ui->label->setText("串口"+currentPortName+"已关闭");
            serial->close();
        }else
        {
           serialControl();
        }

    });
    QAction *refreshAction=new QAction("刷新串口",this);
    menuBar()->addAction(refreshAction);
    connect(refreshAction,&QAction::triggered,this,&MainWindow::refreshSerialPortList);
    connect(serial,&QSerialPort::readyRead,this,&MainWindow::readSerialData);
    connect(serial,SIGNAL(error(QSerialPort::SerialPortError)),this,SLOT(handleSerialError(QSerialPort::SerialPortError)));
}

//如果中途出现串口断开的处理槽函数
void MainWindow::handleSerialError(QSerialPort::SerialPortError error)
{

    if(error==QSerialPort::PermissionError)
    {
        ui->pushButton->setText("打开串口");
        ui->label->setText("串口"+currentPortName+"异常关闭");
        serial->close();
    }
}

void MainWindow::readSerialData()//处理单片机传过来的数据的槽函数
{
    QByteArray data =serial->readAll();
    ui->textEdit->append(QString::fromUtf8(data));

}
//刷新串口端口的槽函数
void MainWindow::refreshSerialPortList()
{
    //清除旧菜单项
    for(QAction*action: protactionGroup->actions())
    {
      ui->menuSerialPorts->removeAction(action);
      protactionGroup->removeAction(action);
      delete action;
    }
    //再重新添加扫描到的串口
    const auto ports=QSerialPortInfo::availablePorts();
    for(const QSerialPortInfo &info:ports )
    {
        QAction *protAction=new QAction(info.portName(),this);
        protAction->setCheckable(true);
        protactionGroup->addAction(protAction);
        ui->menuSerialPorts->addAction(protAction);
    }
    ui->menuSerialPorts->setEnabled(true);
    ui->label->setText("串口菜单已刷新");
    ui->pushButton->setText("打开串口");

}

void MainWindow::serialControl()
{
    if(serial->open(QIODevice::ReadWrite))
    {
        serial->clear(QSerialPort::AllDirections);//清除缓冲区,要不然一开始接收的字符可能是乱码
        ui->pushButton->setEnabled(true);
        ui->pushButton->setText("关闭串口");
        ui->textEdit->clear();
        ui->label->setText("串口"+currentPortName+"已打开");
        serial->setBaudRate(QSerialPort::Baud115200);
        serial->setDataBits(QSerialPort::Data8);
        serial->setParity(QSerialPort::NoParity);
        serial->setStopBits(QSerialPort::OneStop);
        serial->setFlowControl(QSerialPort::NoFlowControl);
    }
    else
    {
         ui->label->setText("串口"+currentPortName+"打开失败");
        //弹窗提示
        QMessageBox::information(this,"串口打开失败","无法打开串口"+currentPortName+".\n请检查是否被其他程序占用或不存在.");
    }

}

//当用户选择了对应的串口端口后进行的处理
void MainWindow::onSerialPorSelected(QAction *action)
{

    QString selectedPort = action->text();
    currentPortName=selectedPort;
    serial->setPortName(selectedPort);
    ui->menuSerialPorts->setEnabled(false);
    if(serial->isOpen())
    {
        serial->close();
    }

    serialControl();

}

void MainWindow::updateSerialPortMenu()
{

    ui->menuSerialPorts->clear();//清除旧的菜单栏
    protactionGroup=new QActionGroup(this);//用于管理互斥选择
    protactionGroup->setExclusive(true);
    foreach(const QSerialPortInfo &info,QSerialPortInfo::availablePorts())
    {
        QAction *protAction=new QAction(info.portName(),this);
        protAction->setCheckable(true);
        protactionGroup->addAction(protAction);
        ui->menuSerialPorts->addAction(protAction);
    }

    //连接槽函数:当用户点击某个串口菜单项时
   // connect(protactionGroup,&QActionGroup::triggered,this,&MainWindow::onSerialPorSelected);//这句话用Lambda表示如下:
    connect(protactionGroup,&QActionGroup::triggered,this,[this](QAction *action)
    {
        QString selectSerial=action->text();
        qDebug()<<"select Serial Port:"<<selectSerial;
        this->onSerialPorSelected(action);

    });

}



MainWindow::~MainWindow()
{
    delete ui;
}

stm32的串口代码(使用定时器定时往串口发送数据)

#include "timer.h"

uint8_t timer_flag = 0;
void Timer_NVIC(void)
{
	NVIC_InitTypeDef NVIC_InitStructure;

	NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure); 
}

void Timer_Config(void)
{
	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
   /* Time Base configuration */
   TIM_TimeBaseStructure.TIM_Prescaler = 7200-1;
   TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
   TIM_TimeBaseStructure.TIM_Period = 10000-1;
   TIM_TimeBaseStructure.TIM_ClockDivision = 0;
   TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);
   Timer_NVIC();
   TIM_ITConfig(TIM2,TIM_IT_Update,ENABLE);
	/* TIM3 counter enable */
	TIM_Cmd(TIM2, ENABLE);
 	
}

void TIM2_IRQHandler()
{
	if(TIM_GetITStatus(TIM2,TIM_IT_Update)==SET)
	{
		timer_flag=1;
		TIM_ClearITPendingBit(TIM2,TIM_IT_Update);
	}
}


#include "usart.h"  
void Usart_Config(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	/* Enable GPIO clock */
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);
	 

   /* Configure USARTy Rx as input floating */
   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
   GPIO_Init(GPIOA, &GPIO_InitStructure);
   
   /* Configure USARTy Tx as alternate function push-pull */
   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
   GPIO_Init(GPIOA, &GPIO_InitStructure);
		
   USART_InitStructure.USART_BaudRate = 115200;
   USART_InitStructure.USART_WordLength = USART_WordLength_8b;
   USART_InitStructure.USART_StopBits = USART_StopBits_1;
   USART_InitStructure.USART_Parity = USART_Parity_No;
   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
   USART_InitStructure.USART_Mode = USART_Mode_Rx |USART_Mode_Tx;
   
   /* Configure USARTy */
   USART_Init(USART1, &USART_InitStructure);
 
   /* Enable USARTz */
   USART_Cmd(USART1, ENABLE);

}

void Usart_send(uint8_t ch)
 {
   /* Place your implementation of fputc here */
   /* e.g. write a character to the USART */
   USART_SendData(USART1, (uint8_t) ch);
 
   /* Loop until the end of transmission */
   while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
   {}
 
 }
 
 void Usart_sendBuff(uint8_t *buf,uint32_t size)
{
	for(uint32_t i=0;i<size;i++)
	{
		Usart_send(buf[i]);
	}
}

 //¶¨Ê±·¢ËÍ
 void Send_Handle()
 {
 	uint8_t xiao[9]="xiaoxiao";
		if(timer_flag==1)
		{
			timer_flag=0;
			Usart_sendBuff(xiao,sizeof(xiao));
		}
 }

stm32使用PWM+DMA控制呼吸灯与PWM+DMA+TIM控制呼吸灯

Sun, 15 Jun 2025 17:32:57 +0800

使用PWM+DMA+TIM控制呼吸灯,此种办法DMA搬运速度与另外定时器触发周期有关
使用PWM+DMA控制呼吸灯,此种办法DMA搬运速度与PWM周期有关
如下:
此是PWM+DMA
void Pwm_Config(void)
{
   GPIO_InitTypeDef GPIO_InitStructure;
   TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
   TIM_OCInitTypeDef  TIM_OCInitStructure;
	/* TIM3 clock enable */
   RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
   /* GPIOA and GPIOB clock enable */
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA 
                          |RCC_APB2Periph_AFIO, ENABLE);
	
   GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_6;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_Init(GPIOA, &GPIO_InitStructure);
	GPIO_ResetBits(GPIOA, GPIO_Pin_6);
	
	TIM_TimeBaseStructure.TIM_Period = 500-1;//200hz
	TIM_TimeBaseStructure.TIM_Prescaler = 720-1;//72000000/72=1Mhz
	TIM_TimeBaseStructure.TIM_ClockDivision = 0;
	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
	TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
	

	/* Channel 3 Configuration in PWM mode */
	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
	TIM_OCInitStructure.TIM_Pulse = pwm_buff[0];
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;
	TIM_OC1Init(TIM3, &TIM_OCInitStructure);

	/* TIM3 Update DMA Request enable */
	TIM_DMACmd(TIM3, TIM_DMA_CC1, ENABLE);
    TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Enable);

    TIM_ARRPreloadConfig(TIM3, ENABLE);

	/* TIM3 counter enable */
	TIM_Cmd(TIM3, ENABLE);

}
Dma_Config()
{
    DMA_InitTypeDef dma_InitStruct;
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
/* DMA1 Channel5 Config */
DMA_DeInit(DMA1_Channel6);
    dma_InitStruct.DMA_PeripheralBaseAddr = (uint32_t)&TIM3->CCR1;//当内存传内存时可看作数据的源
    dma_InitStruct.DMA_MemoryBaseAddr = (uint32_t)pwm_buff;
    dma_InitStruct.DMA_DIR = DMA_DIR_PeripheralDST;
    dma_InitStruct.DMA_BufferSize = PWM_SIZE; //传输数目
    dma_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //外设地址增量模式
    dma_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
    dma_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
    dma_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
    dma_InitStruct.DMA_Mode = DMA_Mode_Circular;
    dma_InitStruct.DMA_M2M = DMA_M2M_Disable;
    dma_InitStruct.DMA_Priority = DMA_Priority_High;
    DMA_Init(DMA1_Channel6,&dma_InitStruct);

    DMA_Cmd(DMA1_Channel6, ENABLE);

}

使用PWM+DMA+TIM控制呼吸灯,此种办法DMA搬运速度与另外定时器触发周期有关
#include "pwm.h"
#include "math.h"


extern volatile uint16_t new_pwm;
uint16_t pwm_buff[PWM_SIZE]={0};

void Led_PwmBuff()
{
	int i=0;
	for( i=0;i<(PWM_SIZE/2);i++)
	{
		pwm_buff[i]=i;
	}
	for(;i<PWM_SIZE;i++)
	{
		pwm_buff[i]=PWM_SIZE-i;
	}	
}
void Pwm_Config(void)
{
   GPIO_InitTypeDef GPIO_InitStructure;
   TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
   TIM_OCInitTypeDef  TIM_OCInitStructure;
	/* TIM3 clock enable */
   RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
   /* GPIOA and GPIOB clock enable */
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA 
                          |RCC_APB2Periph_AFIO, ENABLE);
	
   GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_6;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_Init(GPIOA, &GPIO_InitStructure);
   GPIO_ResetBits(GPIOA, GPIO_Pin_6);
	
	TIM_TimeBaseStructure.TIM_Period = 500-1;//2khz
	TIM_TimeBaseStructure.TIM_Prescaler = 72-1;//72000000/72=1Mhz
	TIM_TimeBaseStructure.TIM_ClockDivision = 0;
	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
	TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
	

	/* Channel 3 Configuration in PWM mode */
	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
	TIM_OCInitStructure.TIM_Pulse = pwm_buff[0];
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_Low;
	TIM_OC1Init(TIM3, &TIM_OCInitStructure);


    TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Enable);

    TIM_ARRPreloadConfig(TIM3, ENABLE);

	/* TIM3 counter enable */
	TIM_Cmd(TIM3, ENABLE);

}

void Time_init()//为了控制dma搬运
{
	TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
	TIM_OCInitTypeDef  TIM_OCInitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	/* TIM2 clock enable */
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);

	TIM_TimeBaseStructure.TIM_Period = 500-1;//200hz
	TIM_TimeBaseStructure.TIM_Prescaler = 720-1;//72000000/72=1Mhz
	TIM_TimeBaseStructure.TIM_ClockDivision = 0;
	TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
	TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);


	NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure); 
	TIM_DMACmd(TIM2, TIM_DMA_Update, ENABLE);
	TIM_ITConfig(TIM2,TIM_IT_Update,ENABLE);
	/* TIM3 counter enable */
	TIM_Cmd(TIM2, ENABLE);
	
}

void TIM2_IRQHandler()
{
	if(TIM_GetITStatus(TIM2,TIM_IT_Update)==SET)
	{
		TIM3->CCR1=new_pwm;
		TIM_ClearITPendingBit(TIM2,TIM_IT_Update);
	}
}

void Dma_Config()
{
    DMA_InitTypeDef dma_InitStruct;
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
	 /* DMA1 Channel5 Config */
	DMA_DeInit(DMA1_Channel2);
    dma_InitStruct.DMA_PeripheralBaseAddr = (uint32_t)&new_pwm;
    dma_InitStruct.DMA_MemoryBaseAddr = (uint32_t)pwm_buff;
    dma_InitStruct.DMA_DIR = DMA_DIR_PeripheralDST;
    dma_InitStruct.DMA_BufferSize = PWM_SIZE; 
    dma_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable; 
    dma_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
    dma_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
    dma_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
    dma_InitStruct.DMA_Mode = DMA_Mode_Circular;
    dma_InitStruct.DMA_M2M = DMA_M2M_Disable;
    dma_InitStruct.DMA_Priority = DMA_Priority_High;
    DMA_Init(DMA1_Channel2,&dma_InitStruct);

    DMA_Cmd(DMA1_Channel2, ENABLE);
	
}

串口+DMA非中断接收不定长数据

Thu, 12 Jun 2025 12:07:08 +0800

1.DMA重要知识点

单次模式时：当传输计数器减到0就停止了；还想再次启动，得先失能装载计数器的值再使能
循环模式：当减到0时会重新加载

2.STM32使用串口工具高波特率发送多数据的时候,使用DMA能减少MCU的负担,并进行快速搬运数据,此代码是非中断接收不定长数据的.

#include "usart.h"
void Usart_Config(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	/* Enable GPIO clock */
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);
	 

   /* Configure USARTy Rx as input floating */
   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
   GPIO_Init(GPIOA, &GPIO_InitStructure);
   
   /* Configure USARTy Tx as alternate function push-pull */
   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
   GPIO_Init(GPIOA, &GPIO_InitStructure);
		
   USART_InitStructure.USART_BaudRate = 115200;
   USART_InitStructure.USART_WordLength = USART_WordLength_8b;
   USART_InitStructure.USART_StopBits = USART_StopBits_1;
   USART_InitStructure.USART_Parity = USART_Parity_No;
   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
   USART_InitStructure.USART_Mode = USART_Mode_Rx |USART_Mode_Tx;
   
   /* Configure USARTy */
   USART_Init(USART1, &USART_InitStructure);
 
   /* Enable USARTy DMA TX request */
   USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);
   /* Enable USARTz */
   USART_Cmd(USART1, ENABLE);

}

void Usart_send(uint8_t ch)
 {
   /* Place your implementation of fputc here */
   /* e.g. write a character to the USART */
   USART_SendData(USART1, (uint8_t) ch);
 
   /* Loop until the end of transmission */
   while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
   {}
 
 }
 
 void Usart_sendBuff(uint8_t *buf,uint32_t size)
{
	for(uint32_t i=0;i<size;i++)
	{
		Usart_send(buf[i]);
	}
}

#include "dma.h"
#include "string.h"
//M to M
/*定义数组作为DMA传输数据源
*使用const关键字修饰,使其定义为常量类型,表示数据存储在内部的FLASH中
*/
const uint32_t DMA_S_Const_Buffer[BufferSIze]={
    0x12345678,0x12345679,0x1234567A,
    0x1234567B,0x1234567C,0x1234567D,0x1234567E};

//定义DMA传输目标存储器,存储在内部的SRAM中
uint32_t DMA_D_Buffer[BufferSIze];
uint8_t DMA_D_Buffer_RX[BufferSIze];
void Dma_Config()
{
    DMA_InitTypeDef dma_InitStruct;
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
    dma_InitStruct.DMA_PeripheralBaseAddr = (uint32_t)&USART1->DR;//当内存传内存时可看作数据的源
    dma_InitStruct.DMA_MemoryBaseAddr = (uint32_t)DMA_D_Buffer_RX;
    dma_InitStruct.DMA_DIR = DMA_DIR_PeripheralSRC;
    dma_InitStruct.DMA_BufferSize = BufferSIze; //传输数目
    dma_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable; //外设地址增量模式
    dma_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
    dma_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    dma_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    dma_InitStruct.DMA_Mode = DMA_Mode_Normal;
    dma_InitStruct.DMA_M2M = DMA_M2M_Disable;
    dma_InitStruct.DMA_Priority = DMA_Priority_High ;
    DMA_Init(DMA1_Channel5,&dma_InitStruct);

    DMA_Cmd(DMA1_Channel5, ENABLE);
	
}


uint16_t Get_Revbuf(uint8_t *buf,uint32_t size)
{
	uint16_t count=0,len=0;
	memset(buf,0,size);
	if(DMA1_Channel5->CNDTR < BufferSIze)
	{
		count = DMA1_Channel5->CNDTR ;
		delay_ms(30);
		if(count==DMA1_Channel5->CNDTR)
		{
			len = BufferSIze-count;
			for(int i=0;i<len;i++)
			{
				buf[i]=DMA_D_Buffer_RX[i];
			}
			return len;
		}
	}
	
	return 0;
}

esp32_C3使用VsCode编辑时引入一些头文件报红色波浪线的解决办法

Sat, 29 Mar 2025 22:07:30 +0800

这个问题在使用VsCode时报红色波浪线,虽然说使用命令行编译也是没出错,但是出于强迫症得把红色波浪线去掉,所以下面是解决办法:

1.若是

#include <stdio.h>

报红色波浪线,说明\.vscode\c_cpp_properties.json这个文件没有配置正确,需加入此行

"compilerPath": "${config:idf.toolsPath}\\tools\\riscv32-esp-elf\\esp-13.2.0_20240530\\riscv32-esp-elf\\bin\\riscv32-esp-elf-gcc.exe",

a>如果你使用的芯片是esp32/S3则需使用Xtense而不是riscv32

b>如果你没有这个文件,则ctrl+shift+p,输入ESP-IDF:Add vscode configuration folder,点击其即可.

2.若是freertos的头文件报波浪线

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

也是在这个文件下添加

"compileCommands": "${workspaceFolder}/build/compile_Commands.json",

3.还有一个就是这两句有先后顺序,#include "freertos/FreeRTOS.h"这句得在#include "freertos/task.h"前面,要不然编译的时候出错.

can控制器 uds诊断完整代码（c写的keil项目）遵循iso sae J1939标准（stm32 N32 系列MCU可用）

Sat, 19 Oct 2024 15:25:25 +0800

可以帮忙调试，QQ：778292363

Single Frame（SF）- 单帧；First Frame (FF)-第一帧；Consecutive Frame (CF)-连续帧；Flow Control (FC)-流控帧；N_PDU type-网络层协议控制单元类型；N_PCI-网络层协议控制信息；SF_DL-单帧数据长度；FF_DL-首帧数据长度；SN-连续帧序列号；FS-流控状态；BS-块大小；STmin-连续帧最小时间间隔。

‌‌UDS（Unified Diagnostic Services，统一诊断服务）是一种用于汽车行业的标准化诊断协议，基于‌CAN总线进行通信。UDS服务是诊断服务的规范化标准，规定了读取DTC（故障码）的指令、读诊断数据流的指令等。它允许维修人员使用诊断设备通过CAN总线与汽车电子控制单元（‌ECU）进行通信，执行各种诊断任务，如读取故障码、控制ECU的功能、以及更新ECU的软件等。‌

整个项目完整代码已经在前装车载设备上使用：

/***************************************************************************//**
    \author        
    \mail         
    \version       0.03 - CANoe Test Passed
    \date          2024-09-24
    \description   uds network code, base on ISO 15765
*******************************************************************************/
#include "network_layer_private.h"
#include "network_layer.h"
#include "uds_api.h"
/*******************************************************************************
    Type Definition
*******************************************************************************/

/*******************************************************************************
    Global Varaibles
*******************************************************************************/
static network_layer_st nwl_st = NWL_IDLE;

static bool_t g_wait_cf = FALSE;
static bool_t g_wait_fc = FALSE;

static uint32_t nt_timer[TIMER_CNT] = {0};

static uint8_t g_rfc_stmin = 0;    /* received flowcontrol SeparationTime */
static uint8_t g_rfc_bs = 0;       /* received flowcontrol block size */

static uint8_t g_xcf_bc = 0;       /* transmit consecutive frame block counter */
static uint8_t g_xcf_sn = 0;       /* transmit consecutive frame SequenceNumber */
static uint8_t g_rcf_bc = 0;       /* received frame block counter */
static uint8_t g_rcf_sn = 0;       /* received consecutive frame SequenceNumber */

/* transmit buffer */
static uint8_t remain_buf[UDS_FF_DL_MAX];
static uint16_t remain_len = 0;
static uint16_t remain_pos = 0;

/* recieve buffer */
static uint8_t recv_buf[UDS_FF_DL_MAX];
static uint16_t recv_len = 0;
static uint16_t recv_fdl = 0;  /* frame data len */


//OS_EVENT *UdsMutex;

/*******************************************************************************
    Function  declaration
*******************************************************************************/
static void
send_flowcontrol (uint8_t flow_st);

//static indication_func uds_indication = NULL;
//static confirm_func uds_confirm = NULL;

static nt_usdata_t N_USData = {NULL, NULL, NULL};
/*******************************************************************************
    Function  Definition - common
*******************************************************************************/

/**
 * nt_timer_start - start network timer
 *
 * void :
 *
 * returns:
 *     void
 */
static void
nt_timer_start (uint8_t num)
{
	if (num >= TIMER_CNT) return;

	if (num == TIMER_N_CR)
        nt_timer[TIMER_N_CR] = TIMEOUT_N_CR;
	if (num == TIMER_N_BS)
	    nt_timer[TIMER_N_BS] = TIMEOUT_N_BS;
    if (num == TIMER_STmin)
        nt_timer[TIMER_STmin] = g_rfc_stmin;
}

static void
nt_timer_start_wv (uint8_t num, uint32_t value)
{
	if (num >= TIMER_CNT) return;

	if (num == TIMER_N_CR)
        nt_timer[TIMER_N_CR] = value;
	if (num == TIMER_N_BS)
	    nt_timer[TIMER_N_BS] = value;
    if (num == TIMER_STmin)
        nt_timer[TIMER_STmin] = value;
}

static void
nt_timer_stop (uint8_t num)
{
	if (num >= TIMER_CNT) return;

    nt_timer[num] = 0;
}

/**
 * nt_timer_run - run a network timer, should be invoked per 1ms
 *
 * void :
 *
 * returns:
 *     0 - timer is not running, 1 - timer is running, -1 - a timeout occur
 */
static int
nt_timer_run (uint8_t num)
{
	if (num >= TIMER_CNT) return 0;

    if (nt_timer[num] == 0)
	{
        return 0;
	}
	else if (nt_timer[num] == 1)
	{
		nt_timer[num] = 0;
	    return -1;
	}
	else
	{
	    /* if (nt_timer[num] > 1) */
		nt_timer[num]--;
	    return 1;
	}

}

/**
 * nt_timer_chk - check a network timer and stop it
 *
 * num :
 *
 * returns:
 *     0 - timer is not running, 1 - timer is running,
 */
static int
nt_timer_chk (uint8_t num)
{
	if (num >= TIMER_CNT) return 0;

	if (nt_timer[num] > 0)
    {
        nt_timer[num] = 0; /* stop timer */
	    return 1;
    }
	else
    {
        nt_timer[num] = 0; /* stop timer */
		return 0;
    }
}


/**
 * clear_network - clear network status
 *
 * void :
 *
 * returns:
 *     void
 */
static void
clear_network (void)
{
    uint8_t num;
    nwl_st = NWL_IDLE;
    g_wait_cf = FALSE;
    g_wait_fc = FALSE;
    g_xcf_bc = 0;
    g_xcf_sn = 0;
    g_rcf_bc = 0;
    g_rcf_sn = 0;

    for (num = 0; num < TIMER_CNT; num++)
        nt_timer_stop (num);
}

/*******************************************************************************
    Function  Definition - recieve
*******************************************************************************/
/**
 * recv_singleframe - recieved a single frame from CAN
 *
 * @frame_buf : uds can frame data buffer
 * @frame_dlc : uds can frame length
 *
 * returns:
 *     void
 */
static void
recv_singleframe (uint8_t frame_buf[], uint8_t frame_dlc)
{
    uint16_t i, uds_dlc;
//	uint8_t service_id;

    uds_dlc = NT_GET_SF_DL (frame_buf[0]);

//    service_id = frame_buf[1];

    /************************************/

#ifdef UDS_CAN_ID_STD
    if (uds_dlc > 7 || uds_dlc == 0)
        return;
#else
    if (uds_dlc > 6 || uds_dlc == 0)
        return;
#endif

    recv_fdl = uds_dlc;
    for (i = 0; i < frame_dlc - 1; i++)
        recv_buf[i] = frame_buf[1+i];
    recv_len = frame_dlc - 1;

    N_USData.indication (recv_buf, recv_fdl, N_OK);
}
/**
 * recv_firstframe - recieved a firt frame from CAN
 *
 * service : L_Data.indication (FF)
 * @frame_buf : uds can frame data buffer
 * @frame_dlc : uds can frame length
 *
 * returns:
 *     0 - recv a right frame, other - err 
 */
static int
recv_firstframe (uint8_t frame_buf[], uint8_t frame_dlc)
{
    uint16_t i;
//    uint8_t service_id;
    uint16_t uds_dlc;

    uds_dlc = ((uint16_t)(frame_buf[0]&0x0f)) << 8;
    uds_dlc |= frame_buf[1];

//    service_id = frame_buf[2];

    /************************************/

#ifdef UDS_CAN_ID_STD
    if (uds_dlc < 8)
        return -1;
#else
    if (uds_dlc < 7)
        return -1;
#endif
    /**
     * if FF_DL is greater than the available receiver buffer size
     * abort the message reception and send
     * an FC N_PDU with Overflow.
     */
    if (uds_dlc >= UDS_FF_DL_MAX) {
        send_flowcontrol (FS_OVFLW);
        return -2;
    }

    recv_fdl = uds_dlc;
    for (i = 0; i < frame_dlc - 2; i++)
        recv_buf[i] = frame_buf[2+i];
    recv_len = frame_dlc - 2;

    /**
     * after received first frame,
     * send flowcontrol frame and wait consecutive frame,
     */
    send_flowcontrol (FS_CTS);
    g_rcf_bc = 0;
    g_wait_cf = TRUE;
    nt_timer_start(TIMER_N_CR);
    /* claer the consecutive frane0 sn */
    g_rcf_sn = 0;

    N_USData.ffindication (uds_dlc);

    return 1;
}

/**
 * recv_consecutiveframe - recieved a consecutive frame from CAN
 *
 * service: L_Data.indication (CF)
 * @frame_buf : uds can frame data buffer
 * @frame_dlc : uds can frame length
 *
 * returns:
 *     0 - recv end, 1 - recv continue, other - err
 */
static int
recv_consecutiveframe (uint8_t frame_buf[], uint8_t frame_dlc)
{
    uint8_t cf_sn;
	uint16_t i;
    cf_sn = NT_GET_CF_SN (frame_buf[0]);

    /* if N_Cr timeout, Abort message transmission and issue N_TIMEOUT_Cr */
    if(nt_timer_chk (TIMER_N_CR) <= 0) return -1;

    g_rcf_sn++;
    if (g_rcf_sn > 0x0f)
        g_rcf_sn = 0;
    if (g_rcf_sn != cf_sn) {
        N_USData.indication (recv_buf, recv_len, N_WRONG_SN);
        return -2;
    }

    for(i = 0; i < UDS_CF_DL_COM; i++)
    {
        recv_buf[recv_len+i] = frame_buf[1+i]; 
    }
    recv_len += UDS_CF_DL_COM;

    if (recv_len >= recv_fdl)
    {
        g_wait_cf = FALSE;
        N_USData.indication (recv_buf, recv_fdl, N_OK);
        return 0;
    }
    else
    {
        if (NT_XMIT_FC_BS > 0)
        {
            g_rcf_bc++;
            if (g_rcf_bc >= NT_XMIT_FC_BS)
            {
                /**
                 * after NT_XMIT_FC_BS consecutive frames,
                 * send flowcontrol frame and wait consecutive frame,
                 */
                send_flowcontrol (FS_CTS);
                g_rcf_bc = 0;
            }
        }
     
        g_wait_cf = TRUE;
        nt_timer_start(TIMER_N_CR);
        return 1;
    }
}

/**
 * recv_flowcontrolframe - process uds flowc control frame
 *
 * service: L_Data.indication (FC)
 * @frame_buf : uds can frame data buffer
 * @frame_dlc : uds can frame length
 *
 * returns:
 *     0 - recv CTS, 1 - recv WT, other - err
 */
static int
recv_flowcontrolframe (uint8_t frame_buf[], uint8_t frame_dlc)
{
    uint8_t fc_fs;

    fc_fs = NT_GET_FC_FS (frame_buf[0]);

    /**
     * if N_Bs timeout, 
     * Abort message transmission and issue N_TIMEOUT_Bs,
     * if not timeout, stop the timer.
     */
    if(nt_timer_chk (TIMER_N_BS) <= 0) return -1;

    /**
    * Got from CANoe Test:
    * After the First frame is received the Tester sends a functional
    * adressed Flow control. ECU must abort sending of the response
    */
    //if (g_tatype == N_TATYPE_FUNCTIONAL) return -1;

    g_wait_fc = FALSE;
    if (fc_fs >= FS_RESERVED) {
        N_USData.confirm (N_INVALID_FS);
        return -2;
    }

    if (fc_fs == FS_OVFLW) {
        N_USData.confirm (N_BUFFER_OVFLW);
        return -3;
    }

    if (fc_fs == FS_WT) {
        g_wait_fc = TRUE;
        nt_timer_start (TIMER_N_BS);
        return 1;
    }

    /** 
     * get the fc block size and stmin
     */
    g_rfc_bs = frame_buf[1];
	if (frame_buf[2] <= 0x7f)
	    g_rfc_stmin = frame_buf[2]+1;
	else
	    g_rfc_stmin = 0x7f; /* 127 ms */

    /* start to transmit consecutive frame */
    g_xcf_bc = 0;
    nt_timer_start_wv (TIMER_STmin, 1);

    return 0;
}

/*******************************************************************************
    Function  Definition - send
*******************************************************************************/

/**
 * send_flowcontrol - send flowcontrol frame
 *
 * service: L_Data.confirm (FC)
 * @flow_st : flow status
 *
 * returns:
 *     void
 */
static void
send_flowcontrol (uint8_t flow_st)
{
    uint8_t send_buf[UDS_VALID_FRAME_LEN] = {0};
		memset(send_buf, 0xcc, UDS_VALID_FRAME_LEN);
    send_buf[0] = NT_SET_PCI_TYPE_FC (flow_st);
    send_buf[1] = NT_XMIT_FC_BS;
    send_buf[2] = NT_XMIT_FC_STMIN;
    ZTai_UDS_Send (send_buf, UDS_VALID_FRAME_LEN);

}

/**
 * send_singleframe - send a single frame msg
 *
 * @msg_buf : uds msg data buffer
 * @msg_dlc : uds msg length
 *
 * returns:
 *     void
 */
static void
send_singleframe (uint8_t msg_buf[], uint16_t msg_dlc)
{
	uint16_t i;
    uint8_t send_buf[UDS_VALID_FRAME_LEN] = {0};
		memset(send_buf, 0xcc, UDS_VALID_FRAME_LEN);

	if (msg_dlc == 0 || msg_dlc > UDS_SF_DL_MAX) return;

    send_buf[0] = NT_SET_PCI_TYPE_SF ((uint8_t)msg_dlc);
	for (i = 0; i < msg_dlc; i++)
        send_buf[1+i] = msg_buf[i];

    ZTai_UDS_Send (send_buf, UDS_VALID_FRAME_LEN);

}


/**
 * send_firstframe - send a first frame data
 *
 * service : L_Data.confirm (FF)
 * @msg_buf : uds msg data buffer
 * @msg_dlc : uds msg length
 *
 * returns:
 *     int
 */
static int
send_firstframe (uint8_t msg_buf[], uint16_t msg_dlc)
{
	uint16_t i;
    uint8_t send_buf[UDS_VALID_FRAME_LEN] = {0};
		memset(send_buf, 0xcc, UDS_VALID_FRAME_LEN);

	if (msg_dlc < UDS_FF_DL_MIN || msg_dlc > UDS_FF_DL_MAX) return 0;

    send_buf[0] = NT_SET_PCI_TYPE_FF ((uint8_t)(msg_dlc >> 8));
	send_buf[1] = (uint8_t)(msg_dlc & 0x00ff);
	for (i = 0; i < UDS_VALID_FRAME_LEN-2; i++)
        send_buf[2+i] = msg_buf[i];

    ZTai_UDS_Send (send_buf, UDS_VALID_FRAME_LEN);

    /**
     * start N_Bs and wait for a fc.
     */
    g_wait_fc = TRUE;
    nt_timer_start (TIMER_N_BS);
    
	return UDS_VALID_FRAME_LEN-2;
}


/**
 * send_consecutiveframe - send consecutive frame data
 *
 * service : L_Data.confirm (CF)
 * @msg_buf : uds msg data buffer
 * @msg_dlc : uds msg length
 *
 * returns:
 *     int
 */
static int
send_consecutiveframe (uint8_t msg_buf[], uint16_t msg_dlc, uint8_t frame_sn)
{
	uint16_t i;
    uint8_t send_buf[UDS_VALID_FRAME_LEN] = {0};
		memset(send_buf, 0xcc, UDS_VALID_FRAME_LEN);

    send_buf[0] = NT_SET_PCI_TYPE_CF (frame_sn);
	for (i = 0; i < msg_dlc && i < UDS_CF_DL_COM; i++)
        send_buf[1+i] = msg_buf[i];
	for (; i < UDS_CF_DL_COM; i++)
        send_buf[1+i] = 0;

    ZTai_UDS_Send (send_buf, UDS_VALID_FRAME_LEN);

    if (msg_dlc > UDS_CF_DL_COM)
	    return UDS_CF_DL_COM;
	else
	    return msg_dlc;
}
/**
 * send_multipleframe - send a multiple frame msg
 *
 * @msg_buf : uds msg data buffer
 * @msg_dlc : uds msg length
 *
 * returns:
 *     void
 */
static void
send_multipleframe (uint8_t msg_buf[], uint16_t msg_dlc)
{
	uint16_t i;
	uint8_t send_len;

	if (msg_dlc < UDS_FF_DL_MIN || msg_dlc > UDS_FF_DL_MAX) return;

    for (i = 0; i < msg_dlc; i++)
	    remain_buf[i] = msg_buf[i];

    g_xcf_sn = 0;
    send_len = send_firstframe (msg_buf, msg_dlc);

    remain_pos = send_len;
	remain_len = msg_dlc - send_len;
}
/*******************************************************************************
    Function  Definition - external API
*******************************************************************************/

/**
 * network_main - network main task, should be schedule every one ms
 *
 * @void
 *
 * returns:
 *     void
 */
extern void
network_main (void)
{
    uint8_t send_len;
//    uint8_t err;
    if (nt_timer_run (TIMER_N_CR) < 0)
    {
        clear_network ();
	    N_USData.indication (recv_buf, recv_len, N_TIMEOUT_Cr);
    }
    if (nt_timer_run (TIMER_N_BS) < 0)
    {
        clear_network ();
        N_USData.confirm (N_TIMEOUT_Bs);
    }

	if (nt_timer_run (TIMER_STmin) < 0)
	{
        g_xcf_sn++;
		if (g_xcf_sn > 0x0f)
		    g_xcf_sn = 0;
 //       OSMutexPend(UdsMutex,0,&err);
		send_len = send_consecutiveframe (&remain_buf[remain_pos], remain_len, g_xcf_sn);
		remain_pos += send_len;
		remain_len -= send_len;

        if (remain_len > 0)
        {
            if (g_rfc_bs > 0)
            {
                g_xcf_bc++;
                if (g_xcf_bc < g_rfc_bs)
                {
                    nt_timer_start (TIMER_STmin);
                }
                else
                {
                    /**
                     * start N_Bs and wait for a fc.
                     */
                    g_wait_fc = TRUE;
                    nt_timer_start (TIMER_N_BS);
                }
            }
            else
            {
                nt_timer_start (TIMER_STmin);
            }
        }
        else
        {
            clear_network ();
        }
 //       OSMutexPost(UdsMutex);
	}
}
/**
 * network_recv_frame - recieved uds network can frame
 *
 * @func_addr : 0 - physical addr, 1 - functional addr
 * @frame_buf : uds can frame data buffer
 * @frame_dlc : uds can frame length
 *
 * returns:
 *     void
 */
extern void
network_recv_frame (uint8_t func_addr, uint8_t frame_buf[], uint8_t frame_dlc)
{
//    uint8_t err;
    uint8_t pci_type; /* protocol control information type */


    /**
     * The reception of a CAN frame with a DLC value
     * smaller than expected shall be ignored by the 
     * network layer without any further action
     */
    if(frame_dlc != UDS_VALID_FRAME_LEN) return;

    if (func_addr == 0)
        g_tatype = N_TATYPE_PHYSICAL;
    else
        g_tatype = N_TATYPE_FUNCTIONAL;

 //   OSMutexPend(UdsMutex,0,&err);
    pci_type = NT_GET_PCI_TYPE (frame_buf[0]);
    switch(pci_type)
    {
        case PCI_SF:
            if (nwl_st == NWL_RECV || nwl_st == NWL_IDLE)
            {
                clear_network ();
                if (nwl_st == NWL_RECV)
                    N_USData.indication (recv_buf, recv_len, N_UNEXP_PDU);
                recv_singleframe (frame_buf, frame_dlc);
            }
            break;
        case PCI_FF:
            if (nwl_st == NWL_RECV || nwl_st == NWL_IDLE)
            {
                clear_network ();
                if (nwl_st == NWL_RECV)
                    N_USData.indication (recv_buf, recv_len, N_UNEXP_PDU);

                if (recv_firstframe (frame_buf, frame_dlc) > 0)
                    nwl_st = NWL_RECV;
                else
                    nwl_st = NWL_IDLE;
            }
            break;
        case PCI_CF:
            if (nwl_st == NWL_RECV && g_wait_cf == TRUE)
            {
                if (recv_consecutiveframe (frame_buf, frame_dlc) <= 0)
                {
                    clear_network ();
                    nwl_st = NWL_IDLE;
                }
            }
            break;
        case PCI_FC:
            if (nwl_st == NWL_XMIT && g_wait_fc == TRUE)
                if (recv_flowcontrolframe (frame_buf, frame_dlc) < 0)
                {
                    clear_network ();
                    nwl_st = NWL_IDLE;
                }
            break;
        default:
            break;
    }
//    OSMutexPost(UdsMutex);
}

/**
 * network_send_udsmsg - send a uds msg by can
 *
 * @msg_buf : uds msg data buffer
 * @msg_dlc : uds msg length
 *
 * returns:
 *     void
 */
extern void
network_send_udsmsg (uint8_t msg_buf[], uint16_t msg_dlc)
{

	if (msg_dlc == 0 || msg_dlc > UDS_FF_DL_MAX) return;

	if (msg_dlc <= UDS_SF_DL_MAX)
    {
	    send_singleframe (msg_buf, msg_dlc);
    }
	else
    {
        nwl_st = NWL_XMIT;
	    send_multipleframe (msg_buf, msg_dlc);
    }
}

/**
 * network_reg_usdata - reg usdata Function
 *
 * @usdata : uds msg data Function struct
 *
 * returns:
 *     0 - ok, other - err
 */
extern int
network_reg_usdata (nt_usdata_t usdata)
{
//    uint8_t err;
    if (usdata.ffindication == NULL || usdata.indication == NULL || usdata.confirm == NULL) return -1;

    N_USData = usdata;

 //   UdsMutex = OSMutexCreate(5, &err);
    return 0;
}
/****************EOF****************/

can控制器 Bootloader刷新流程，及其完整代码c写的（stm32 N32 系列MCU可用）

Mon, 23 Sep 2024 16:40:30 +0800

可以帮忙调试，QQ：778292363

Bootloader是在ECU上电初始化时运行的一段代码，它通过can线接收来自上位机的命令，将数据写进ECU的指定Flash区段中。本文件主要约束控制器(以下简称ECU)的Bootloader数据刷写流程。该项目中BT刷新流程采用UDS统一诊断服务来实现。

该项目需要将ECU待刷写的区域划分成逻辑块，并对每个块进行编号，每个块的大小和起始地址一经确定，后续不允许修改，需要供应商根据功能类别进行准确定位。本项目对ECU的块的个数有限制要求，根据待刷写程序的类别，要求擦除程序、引导程序、应用程序、应用数据各自只能有1个逻辑块。如果同种类型有多个块，请与陕汽刷写工程师联系确定最终状态。

待刷写的ECU内部不需要内置擦除程序，擦除程序的块号编号为0，每次刷写时都需要从数据管理平台上下载；引导程序的块编号为1，应用程序的块编号为2，应用数据的块编号为3。

块的使用体现34服务和31服务上，在34服务中表示即将传输的程序的块编号，31服务中表示需要对某个块进行编程完整性和兼容性检查。BT中使用的34服务的数据格式定义和UDS国际标准定义完全不一样，详细的定义见服务描述。

ECU供应商提供给OEM生产线或者售后服务处的应用程序与应用数据文件使用.bin格式。需要ECU供应商反馈bin文件的基本信息，

整个项目完整代码已经在前装车载设备上使用：

#include "main.h"
#include "bt_define.h"


uint8_t flash_driver_arr[FLASH_DRIVER_LENGTH] __attribute__((at(0x20007000))) = {0};

typedef void (*pFunction)(void);
pFunction Jump_To_Application;
uint32_t JumpAddress;

void Jump_To_App(uint32_t address)
{
    /* Judge whether the top of stack address is legal or not */
    if (((*(__IO uint32_t*)address) & 0x2FFE0000) == 0x20000000)
    {
				/* 屏蔽所有中断，防止在跳转过程中，中断干扰出现异常 */
				__disable_irq();
        /* Jump to user application */
        JumpAddress = *(__IO uint32_t*) (address + 4);
        Jump_To_Application = (pFunction) JumpAddress;
			
        /* Initialize user application's Stack Pointer */
        __set_MSP(*(__IO uint32_t*) address);
        Jump_To_Application();
    }
}

//#include "n32g43x_crc.h"

int main(void)
{
		Systick_MS_Config(); //Setup SysTick Timer for 1 msec interrupts
		tim6_7_init();
		can0_init();

		earse_flash_4_page();
		
		uds_init();

		if(flash_read(REQ_PROGRAM_UPDATE_FLAG_ADDR) == 0x1)
		{
						
				//如果ECU在正确的条件下收到“$10 $02”指令，ECU将重编程请求标志状态位设为有效，并执行ECU重启。
				flash_write(REQ_PROGRAM_UPDATE_FLAG_ADDR, 0x0);
			
				m_SecurityLevel = UDS_SA_NON;
				uds_session = (uds_session_t)UDS_SESSION_PROG;
				uds_timer_start (UDS_TIMER_S3server);

		}
		else
		{
				sys_delay_ms(15);
				if(is_force_update == 0x1)
				{
						is_force_update = 0x0;
					
						m_SecurityLevel = UDS_SA_NON;
						uds_session = (uds_session_t)UDS_SESSION_PROG;
						uds_timer_start (UDS_TIMER_S3server);
				}
				else
				{
					
						RCC_EnableAHBPeriphClk(RCC_AHB_PERIPH_CRC, ENABLE);
						__IO uint32_t CRCValue   = 0;
						/* Compute the 32bit CRC of "DataBuffer" */
						CRC32_ResetCrc();
						CRCValue = CRC32_CalcBufCrc((uint32_t*)FLASH_APP1_ADDR, FLASH_APP1_CRC_LENGTH/0x4);
						CRC32_ResetCrc();
						if(CRCValue == (*(__IO uint32_t*)(FLASH_APP1_CRC_ADRR)) && 0x2 == (*(__IO uint32_t*)(FLASH_APP1_LOGIC_BLOCK_ADRR)))
						{
								flash_write(FLASH_APP1_VALID_ADRR, 0x1);
							
								CRC32_ResetCrc();
								CRCValue = CRC32_CalcBufCrc((uint32_t*)(FLASH_APP1_ADDR+0xC800), FLASH_APP1_CRC_LENGTH/0x4);
								CRC32_ResetCrc();
								if(CRCValue != (*(__IO uint32_t*)(FLASH_APP1_CRC_ADRR+0xC800)))
								{
										bt_flash_erase(FLASH_APP2_ADDR, FLASH_APP2_LENGTH);
										bt_flash_write(FLASH_APP2_ADDR, (u8 *)FLASH_APP1_ADDR, FLASH_APP2_LENGTH);
								}
						}
						else
						{
								flash_write(FLASH_APP1_VALID_ADRR, 0x0);
								bt_flash_erase(FLASH_APP1_ADDR, FLASH_APP1_LENGTH);
								bt_flash_write(FLASH_APP1_ADDR, (u8 *)FLASH_APP2_ADDR, FLASH_APP1_LENGTH);
								/* Compute the 32bit CRC of "DataBuffer" */
								CRC32_ResetCrc();
								CRCValue = CRC32_CalcBufCrc((uint32_t*)FLASH_APP1_ADDR, FLASH_APP1_CRC_LENGTH/0x4);
								CRC32_ResetCrc();
								if(CRCValue == (*(__IO uint32_t*)(FLASH_APP1_CRC_ADRR)) && 0x2 == (*(__IO uint32_t*)(FLASH_APP1_LOGIC_BLOCK_ADRR)))
								{
										flash_write(FLASH_APP1_VALID_ADRR, 0x1);
								}
								else
								{
										flash_write(FLASH_APP1_VALID_ADRR, 0x0);
								}
						}
						
						if(flash_read(FLASH_APP1_VALID_ADRR) == 0x1)
						{
								if(((*(vu32*)(FLASH_APP1_ADDR+4))&0xFF000000)==0x08000000)
								{
										Jump_To_App(FLASH_APP1_ADDR);				//跳转到APP起始地址，期间不能被其他中断打断，否则会跳转失败
								}
						}

				}
		}

		while(1)
		{
			
//				u8 send_buf[8] = {0x0};
//				can_send_mess(0x222, send_buf, 8);
				sys_delay_ms(1);

		}
}

xs5013模拟视频编码，bt1120转ahd tvi cvi格式，调试资料和教程

Mon, 02 Sep 2024 14:03:40 +0800

可以帮忙调试，QQ：778292363

XS5013 芯片是一款应用于专业安防摄像机的图像信号处理芯片，主要应用在模拟摄像机产品，高度集成外围器件，简化产品设计。内置高性能 ISP 处理器，最高支持 5M ，标清模拟输出支持 960H ，高清模拟输出支持多标准协议，支持 720P/1080P/4M/5M ，其中 HDCVI 高清编码在 TX 模式下可支持到 720P/1080P/4M/5M/4K 。内嵌 CPU 处理器，可以实现灵活的软件应用。

XS5013 是面向中低端模拟摄像机产品的一款SOC 芯片。XS5013 既可以作为ISP+TX 单芯片解决方案，也可以只当做TX 模块进行模拟视频编码。

此文章主要讲解TX 模块进行模拟视频编码，bt1120转ahd tvi cvi格式。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <ctype.h>
#include <fcntl.h>
#include <unistd.h>

#include <termios.h> //set baud rate

#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <errno.h>
#include <sys/stat.h>

/* cvi 720P60 pattern
xs5013 "mem w 0x11003400 0x0"
xs5013 "mem w 0x11000060 0x0011"
xs5013 "mem w 0x11000060 0x1003"
xs5013 "mem w 0x11001010 0x0"
xs5013 "mem w 0x11001010 0xffffffff"
xs5013 "mem w 0x11048080 0x03"
xs5013 "mem w 0x11008188 0xff"
xs5013 "mem w 0x11008188 0x0"
xs5013 "mem w 0x1104805c 0x1"
xs5013 "mem w 0x11003400 0x1"
*/

#define TTY_NAME "/dev/ttyS3"
#define BAUDRATE B115200

#define XS_SUCCESS 0
#define XS_FAIL 1

//
#define PKG_HEAD 0x02
#define PKG_TAIL 0x03

#define IMG_ADDRESS (0x00010000)
#define XS_ADDRESS_LEN (4)
#define XS_COUNT_LEN (4)
#define XS_PERDATA_LEN (4)

// command
#define BM_CMD_NOTIFY 36
#define BM_CMD_DEBUG 20
#define BM_CMD_DLOAD 24
#define BM_CMD_WRITE 25
#define BM_CMD_READ 26
#define BM_CMD_RUN 27
#define BM_CMD_EXIT 101
#define BM_CMD_SHAKE 85
#define BM_CMD_ACK 170
#define BM_CMD_OK 5
#define BM_CMD_ERR 10
#define MB_CMD_MINIBOOT 117
#define MB_CMD_ERASE 69

enum {
    STX = 0,
    CMD,
    CHKSUM,
    ETX,
    HEADLEN,
    extDATA = HEADLEN
};

typedef struct {
    char stx;
    char cmd;
    char chksum;
    char etx;
}NoDataCmd;

static NoDataCmd NoDataCmdPkg = {
    .stx = PKG_HEAD,
    .cmd = 0,
    .chksum = 0,
    .etx = PKG_TAIL
};

// hexdump -v -e '4/1 "0x%02x, " "\n"' miniboot_reload_xs5013_ahd.img > ahdData
static const char ahdData[] = {
#include "ahdData"
};

// hexdump -v -e '4/1 "0x%02x, " "\n"' miniboot_reload_xs5013_cvi.img > cviData
static const char cviData[] = {
#include "cviData"
};

// hexdump -v -e '4/1 "0x%02x, " "\n"' miniboot_reload_xs5013_tvi.img > tviData
static const char tviData[] = {
#include "tviData"
};

// hexdump -v -e '4/1 "0x%02x, " "\n"' pattern.img > patternData
static const char patternData[] = {
#include "patternData"
};


static inline int bytes2int(char *buf)
{
    return buf[3] |(buf[2]<<24) | (buf[1]<<16) | (buf[0]);
}

static inline void int2bytes(int i, char *buf)
{
    buf[0] = (i>>24)&0xff;
    buf[1] = (i>>16)&0xff;
    buf[2] = (i>>8)&0xff;
    buf[3] = i&0xff;
}

int setOpt(int fd) {
    struct termios newtio, oldtio;

    if (tcgetattr(fd, &oldtio) != 0) {
        perror("SetupSerial");
        return -1;
    }

    bzero(&newtio, sizeof(newtio));

    newtio.c_lflag &= ~ECHO;
    cfsetispeed(&newtio, BAUDRATE);
    cfsetospeed(&newtio, BAUDRATE);

#if 1
    newtio.c_cflag |= CLOCAL | CREAD;
    newtio.c_cflag &= ~CSIZE;
    newtio.c_cflag |= CS8;
    newtio.c_cflag &= ~PARENB;

    newtio.c_cflag &= ~CSTOPB;

    newtio.c_cc[VTIME] = 0;
    newtio.c_cc[VMIN] = 0;
    tcflush(fd, TCIFLUSH);
#endif

    if ((tcsetattr(fd, TCSANOW, &newtio)) != 0) {
        perror("com set error");
        return -1;
    }

    return 0;
}

int readbytes(int fd, char *rcv_buf, int Len)
{
    int ret=0, pos, time=0;
    fd_set rfds;
    struct timeval tv;

    pos = 0;
    while (pos < Len && time <3*Len) {
        FD_ZERO(&rfds);
        FD_SET(fd, &rfds);
        tv.tv_sec = 0;  //set the rcv wait time
        tv.tv_usec = 100*1000;  //100000us = 0.1s

        ret = select(fd + 1, &rfds, NULL, NULL, &tv);

        time ++;

        if (ret == -1){
            perror("select()");
            continue;
        }
        else if (ret) {
            ret = read(fd, rcv_buf+pos, 1);
            //printf("[hardy] ret:%d 0x%02x\n", ret, *(rcv_buf + pos));
            pos++;
        } else {
            //printf("[hardy]: timeout\n");
            continue;
        }
    }

    return pos;
}

int readPckHead(int fd, char *rcv_buf)
{
    int ret, trytimes=3;

    memset(rcv_buf, 0, HEADLEN);
    while (trytimes > 0) {
        trytimes--;
        if (PKG_HEAD != rcv_buf[STX]) {
            ret = readbytes(fd, rcv_buf, 1);
            if (ret < 0) continue;
        }

        if (PKG_HEAD == rcv_buf[STX]) {
            // read package head
            ret = readbytes(fd, &rcv_buf[CMD], HEADLEN-1);
            if (ret < 0) continue;
            if (PKG_TAIL == rcv_buf[ETX]) {
                break;
            }
        }
    }

    //printf("recv package head [0x%02x%02x%02x%02x]\n", rcv_buf[STX], rcv_buf[CMD], rcv_buf[CHKSUM], rcv_buf[ETX]);

    return (PKG_HEAD != rcv_buf[STX] || PKG_TAIL != rcv_buf[ETX]);
}

int sendDataTty(int fd, char *send_buf, int Len)
{
    ssize_t ret;

    ret = write(fd, send_buf, Len);
    if (ret == -1) {
        printf("write device error\n");
        return XS_FAIL;
    }

    return XS_SUCCESS;
}

static inline int sendNoDataCmd(int fd, char cmd)
{
    NoDataCmdPkg.cmd = cmd;
    sendDataTty(fd, (char*)&NoDataCmdPkg, sizeof(NoDataCmdPkg));

    printf("send [0x%02x%02x%02x%02x]\n", NoDataCmdPkg.stx, NoDataCmdPkg.cmd, NoDataCmdPkg.chksum, NoDataCmdPkg.etx);
}

int exeCmdDLoad(int fd, const char *mode)
{
    #define DATA_NUM (0x200)
    char snd_buf[HEADLEN+XS_ADDRESS_LEN+XS_COUNT_LEN+DATA_NUM*XS_PERDATA_LEN] =
        {PKG_HEAD, BM_CMD_DLOAD, 0, PKG_TAIL};

    int sentlen = 0; //
    int sendlen = 0; // data lenght will be sent
    const char* imgData = NULL;
    int datasize = 0;;
    int i, tryTimes, allDataLen;
    char rcv_buf[HEADLEN] = {0};

    if (0 == strcmp(mode, "cvi")) {
        imgData = cviData;
        datasize = sizeof(cviData);
    } else if (0 == strcmp(mode, "tvi")) {
        imgData = tviData;
        datasize = sizeof(tviData);
    } else if (0 == strcmp(mode, "ahd")) {
        imgData = ahdData;
        datasize = sizeof(ahdData);
    } else {
        imgData = patternData;
        datasize = sizeof(patternData);
    }

    while (sentlen < datasize) {
        if (DATA_NUM*XS_PERDATA_LEN < (datasize-sentlen)) {
            sendlen = DATA_NUM*XS_PERDATA_LEN;
        } else {
            sendlen = datasize-sentlen;
        }
        //printf("will send len:0x%x\n", sendlen);

        // address
        int2bytes(IMG_ADDRESS+sentlen, snd_buf+HEADLEN);
        // count
        int2bytes(sendlen/XS_PERDATA_LEN, snd_buf+HEADLEN+XS_ADDRESS_LEN);
        // data
        memcpy(snd_buf+HEADLEN+XS_ADDRESS_LEN+XS_COUNT_LEN,
            imgData+sentlen, sendlen);

        // chksum
        allDataLen = HEADLEN+XS_ADDRESS_LEN+XS_COUNT_LEN+sendlen;
        snd_buf[CHKSUM] = 0;
        for (i=HEADLEN; i<allDataLen; i++) {
            snd_buf[CHKSUM] += snd_buf[i];
            //printf("chksum:0x%02x data:0x%02x\n", snd_buf[CHKSUM], snd_buf[i]);
        }

        //printf("send [0x%02x%02x%02x%02x 0x%02x%02x%02x%02x 0x%02x%02x%02x%02x 0x%02x%02x%02x%02x\n",
//        printf("send [0x%02x%02x%02x%02x 0x%02x%02x%02x%02x 0x%02x%02x%02x%02x\n",
  //          snd_buf[0], snd_buf[1], snd_buf[2], snd_buf[3], // head
    //        snd_buf[4], snd_buf[5], snd_buf[6], snd_buf[7], // address
      //      snd_buf[8], snd_buf[9], snd_buf[10], snd_buf[11]); // count
            //snd_buf[12], snd_buf[13], snd_buf[14], snd_buf[15]); // data

        tryTimes = 3;
        while (tryTimes > 0) {
            if (XS_SUCCESS == sendDataTty(fd, snd_buf, allDataLen)) break;
            tryTimes--;
        }
        if (0 == tryTimes) assert(0);

        tryTimes = 5;
        while (XS_SUCCESS == readPckHead(fd, rcv_buf) ) {
            if (BM_CMD_OK == rcv_buf[CMD]) {
                sentlen += sendlen;
                break;
            } else if (BM_CMD_ERR == rcv_buf[CMD]) {
                printf("send img error!");
                break;
            } else {
                tryTimes--;
            }
        }
    }

    return 0;
}

static int sendRunCmd(int fd)
{
    char snd_buf[HEADLEN+XS_ADDRESS_LEN] = {PKG_HEAD, BM_CMD_RUN, 0, PKG_TAIL};
    int i, tryTimes, allDataLen;
    char rcv_buf[HEADLEN] = {0};

    // address
    int2bytes(IMG_ADDRESS, snd_buf+HEADLEN);

    // chksum
    allDataLen = HEADLEN+XS_ADDRESS_LEN;
    snd_buf[CHKSUM] = 0;
    for (i=HEADLEN; i<allDataLen; i++) {
        snd_buf[CHKSUM] += snd_buf[i];
        //printf("chksum:0x%02x data:0x%02x\n", snd_buf[CHKSUM], snd_buf[i]);
    }

    printf("send [0x%02x%02x%02x%02x 0x%02x%02x%02x%02x]\n",
        snd_buf[0], snd_buf[1], snd_buf[2], snd_buf[3], // head
        snd_buf[4], snd_buf[5], snd_buf[6], snd_buf[7]); // address

    tryTimes = 3;
    while (tryTimes > 0) {
        if (XS_SUCCESS == sendDataTty(fd, snd_buf, allDataLen)) break;
        tryTimes--;
    }
    if (0 == tryTimes) assert(0);

    tryTimes = 5;
    while (XS_SUCCESS == readPckHead(fd, rcv_buf) ) {
        if (BM_CMD_OK == rcv_buf[CMD]) {
            break;
        } else if (BM_CMD_ERR == rcv_buf[CMD]) {
            XS_FAIL;
        } else {
            tryTimes--;
            break;
        }
    }

    return XS_SUCCESS;
}

int initXs5013(int fd, const char *mode)
{
    int ret;
    char rcv_buf[HEADLEN];

    while (1) {
        if (XS_SUCCESS == readPckHead(fd, rcv_buf) ) {
    printf("recv package head [0x%02x%02x%02x%02x]\n", rcv_buf[STX], rcv_buf[CMD], rcv_buf[CHKSUM], rcv_buf[ETX]);
            if (BM_CMD_NOTIFY != rcv_buf[CMD]) {
                printf("incorrect command %d\n", rcv_buf[CMD]);
            } else {
                sendNoDataCmd(fd, BM_CMD_DEBUG);
                usleep(100*1000);
                exeCmdDLoad(fd, mode);
                sendRunCmd(fd);
                //printf("xs5013 is ready\n");
                break;
            }
        } else {
            return -1;
        }
    }

    return 0;
}

int main(int argc, char** argv) {
    char *format = NULL;
    int fd = 0;
    char buf[100] = {0};
    int tryTimes;
    char c;

    if (argc < 2) {
        printf("    no parameter -- read serial\n");
        printf("    para1: command\n");
        printf("    ahd/cvi/tvi/pattern -- download img\n");
        printf("    720p25 -- switch video format\n");
        printf("    720p30 -- switch video format\n");
        printf("    720p50 -- switch video format\n");
        printf("    720p60 -- switch video format\n");
        printf("    1080p25 -- switch video format\n");
        printf("    1080p30 -- switch video format\n");
        printf("    1080p50 -- switch video format, only for cvi\n");
        printf("    1080p60 -- switch video format, only for cvi\n");
        printf("    720pal -- switch video format, 720x576-50\n");
        printf("    720n -- switch video format, 720x480-60\n\n");
        printf("    ex: xs5013 ahd\n\n");
        return 0;
    }

    fd = open(TTY_NAME, O_RDWR | O_NOCTTY | O_NDELAY);
    if (-1 == fd) {
        perror("Can't Open Serial Port");
        return (-1);
    }

    setOpt(fd);

    if (argc >= 2 ) {
        if (0 == strcmp("ahd", argv[1])
            ||0 == strcmp("cvi", argv[1])
            || 0 == strcmp("tvi", argv[1])
            || 0 == strcmp("pattern", argv[1]) ) {
            int ret = initXs5013(fd, argv[1]);

            if (argc == 2) {
                if (0 != ret) return -1;
            } else {
                printf("init %s\n", argv[2]);
                sprintf(buf, "%s\r", argv[2]);
                sendDataTty(fd, buf, strlen(buf));
                printf("init %s end\n", argv[2]);
            }
        } else {
            printf("switch %s\n", argv[1]);

            sprintf(buf, "%s\r", argv[1]);
            sendDataTty(fd, buf, strlen(buf));
        }
    }

    tryTimes = 1024;
    while (tryTimes--) {
        if (1 == readbytes(fd, &c, 1)) {
            if (isprint(c) || iscntrl(c)) {
                putchar(c);
            } else {
                printf("0x%02x\n", c);
            }
        } else {
            break;
        }
        if ('#' == c || '$' == c) {
            putchar('\n');
            break;
        }
    }
    close (fd);

    return 0;
}

版本包说明：

1.版本名称：miniboot_reload_xs5013.tgz，linux环境下解压后使用。

2.版本包的组成

release

|-miniboot_reload_xs5013_ahd.img

|-miniboot_reload_xs5013_cvi.img

|-miniboot_reload_xs5013_tvi.img

3.每个镜像文件包含的分辨率以及启动命令如下：（分辨率描述说明：宽x高-帧率）

1）ahd （对应的镜像：miniboot_reload_xs5013_ahd.img）

1.分辨率：1280x720-25 串口启动命令：720p25

2.分辨率：1280x720-30 串口启动命令：720p30

3.分辨率：1280x720-50 串口启动命令：720p50 （未验证）

4.分辨率：1280x720-60 串口启动命令：720p60

5.分辨率：1920x1080-25 串口启动命令：1080p25

6.分辨率：1920x1080-30 串口启动命令：1080p30

2）cvi （对应的镜像：miniboot_reload_xs5013_cvi.img）

1.分辨率：1280x720-25 串口启动命令：720p25

2.分辨率：1280x720-30 串口启动命令：720p30

3.分辨率：1280x720-50 串口启动命令：720p50

4.分辨率：1280x720-60 串口启动命令：720p60

5.分辨率：1920x1080-25 串口启动命令：1080p25

6.分辨率：1920x1080-30 串口启动命令：1080p30

7.分辨率：1920x1080-50 串口启动命令：1080p50 （未验证）

8.分辨率：1920x1080-60 串口启动命令：1080p60 （未验证）

3）tvi （对应的镜像：miniboot_reload_xs5013_tvi.img）

1.分辨率：1280x720-25 串口启动命令：720p25

2.分辨率：1280x720-30 串口启动命令：720p30

3.分辨率：1280x720-50 串口启动命令：720p50

4.分辨率：1280x720-60 串口启动命令：720p60

5.分辨率：1920x1080-25 串口启动命令：1080p25

6.分辨率：1920x1080-30 串口启动命令：1080p30

4）cvbs （该模式没有单独的镜像文件，在ahd/cvi/tvi三个镜像中均存在）

1.分辨率：720x576-50 串口启动命令：720pal

2.分辨率：720x480-60 串口启动命令：720n

5）系统复位（该模式没有单独的镜像文件，在ahd/cvi/tvi三个镜像中均存在）

1.分辨率：支持所有分辨率串口启动命令：reset

烧写说明

1.烧写工具包：XS_CHIP_TOOLS_V1.4.8.rar，解压后使用。

2.使用说明，该工具适用于通过串口直接给xs5013进行烧写程序，如果是通过主控芯片来控制xs5013进行程序的烧写，需要客户按照《串口协议.pdf》中的介绍，自己开发主控的烧写程序。

//1920*1080@60(16:9)

rgb_timing0: timing0 {

clock-frequency = <148500000>; // 148.5MHz

hactive = <1920>;

vactive = <1080>;

hback-porch = <148>;

hfront-porch = <88>;

vback-porch = <36>;

vfront-porch = <4>;

hsync-len = <44>;

vsync-len = <5>;

hsync-active = <0>;

vsync-active = <0>;

de-active = <0>;

pixelclk-active = <0>;

};

//1920*1080@25(16:9)

rgb_timing0: timing1 {

clock-frequency = <74250000>; // 74.25MHz

hactive = <1920>;

vactive = <1080>;

hback-porch = <148>;

hfront-porch = <528>;

vback-porch = <36>;

vfront-porch = <4>;

hsync-len = <44>;

vsync-len = <5>;

hsync-active = <0>;

vsync-active = <0>;

de-active = <0>;

pixelclk-active = <0>;

};

//1920*1080@30(16:9)

rgb_timing0: timing2 {

clock-frequency = <74250000>; // 74.25MHz

hactive = <1920>;

vactive = <1080>;

hback-porch = <148>;

hfront-porch = <88>;

vback-porch = <36>;

vfront-porch = <4>;

hsync-len = <44>;

vsync-len = <5>;

hsync-active = <0>;

vsync-active = <0>;

de-active = <0>;

pixelclk-active = <0>;

};

//1280*720@60(16:9)

rgb_timing0: timing3 {

clock-frequency = <74250000>; // 74.25MHz

hactive = <1280>;

vactive = <720>;

hback-porch = <220>;

hfront-porch = <110>;

vback-porch = <20>;

vfront-porch = <5>;

hsync-len = <40>;

vsync-len = <5>;

hsync-active = <0>;

vsync-active = <0>;

de-active = <0>;

pixelclk-active = <0>;

};

//1280*720@50(16:9)

rgb_timing0: timing4 {

clock-frequency = <74250000>; // 74.25MHz

hactive = <1280>;

vactive = <720>;

hback-porch = <220>;

hfront-porch = <440>;

vback-porch = <20>;

vfront-porch = <5>;

hsync-len = <40>;

vsync-len = <5>;

hsync-active = <0>;

vsync-active = <0>;

de-active = <0>;

pixelclk-active = <0>;

};

//1280*720@30(16:9)

rgb_timing0: timing5 {

clock-frequency = <74250000>; // 74.25MHz

hactive = <1280>;

vactive = <720>;

hback-porch = <220>;

hfront-porch = <1760>;

vback-porch = <20>;

vfront-porch = <5>;

hsync-len = <40>;

vsync-len = <5>;

hsync-active = <0>;

vsync-active = <0>;

de-active = <0>;

pixelclk-active = <0>;

};

//1280*720@25(16:9)

rgb_timing0: timing6 {

clock-frequency = <74250000>; // 74.25MHz

hactive = <1280>;

vactive = <720>;

hback-porch = <220>;

hfront-porch = <2420>;

vback-porch = <20>;

vfront-porch = <5>;

hsync-len = <40>;

vsync-len = <5>;

hsync-active = <0>;

vsync-active = <0>;

de-active = <0>;

pixelclk-active = <0>;

};

//CVBS 720*480@60(4:3)

rgb_timing0: timing7 {

clock-frequency = <27000000>; // 27MHz

hactive = <720>;

vactive = <480>;

hback-porch = <60>;

hfront-porch = <16>;

vback-porch = <30>;

vfront-porch = <9>;

hsync-len = <62>;

vsync-len = <6>;

hsync-active = <0>;

vsync-active = <0>;

de-active = <0>;

pixelclk-active = <0>;

};

//CVBS 720*576@50(4:3)

rgb_timing0: timing8 {

clock-frequency = <27000000>; // 27MHz

hactive = <720>;

vactive = <576>;

hback-porch = <68>;

hfront-porch = <12>;

vback-porch = <39>;

vfront-porch = <5>;

hsync-len = <64>;

vsync-len = <5>;

hsync-active = <0>;

vsync-active = <0>;

de-active = <0>;

pixelclk-active = <0>;

};

Altium Designer软件破解版

Sun, 05 May 2024 14:39:55 +0800