DMA测试代码

最新推荐文章于 2024-07-12 22:49:40 发布
最新推荐文章于 2024-07-12 22:49:40 发布
阅读量106 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_71394945/article/details/134133707
版权 
#pragma once 
#include "DMACtrl.h"
class CLumDataCtrl //父类 通用类
{
public:
	// 构造函数
	CLumDataCtrl(const string & sDMADriverFile, int iType = 1);
	// 析构函数
	~CLumDataCtrl();
	// 初始化
	int iInitilize(int iDataLen);
public:
	// 采集亮度数据
	int iSampleLumData(unsigned char * &lumData, int &iLen);
private:
	// DMA控制
	CDMACtrl *m_pDmaCtrl;
};

#include <unistd.h>
#include "LumDataCtrl.h"
#include "DMAProxyCtrl.h"

// 最大轮询次数
const int cniLoopNum = 3;

// 构造函数
CLumDataCtrl::CLumDataCtrl(const string & sDMADriverFile, int iType)
{
	if (1 == iType)
	{
		m_pDmaCtrl = new CDMAProxyCtrl(sDMADriverFile);
	}
	else
	{
		m_pDmaCtrl = new CDMACtrl(sDMADriverFile);
	}
	return;
}

CLumDataCtrl::~CLumDataCtrl()
{
	if (nullptr != m_pDmaCtrl)
	{
		delete m_pDmaCtrl;
		m_pDmaCtrl = nullptr;
	}
	return;
}

// 初始化
int CLumDataCtrl::iInitilize(int iDataLen)
{
	return m_pDmaCtrl->iInitialize(iDataLen);
}

// 采集亮度数据
int CLumDataCtrl::iSampleLumData(unsigned char * &lumData, int &iLen)
{
	if (0 != m_pDmaCtrl->iStartSample())
	{
		return EXIT_FAILURE;
	}
	int iCounter = 0;
	while (m_pDmaCtrl->iGetSampleFinishedStatus() != 0 && iCounter < cniLoopNum)
	{
		usleep(1);
		iCounter++;
	}

	if (m_pDmaCtrl->iReadDMAData(lumData, iLen) < 0)
	{
		printf("iReadDMAData fail !");
		return EXIT_FAILURE;
	}

	return EXIT_SUCCESS;
}

子类 read方式传输：

#pragma once
#include <string>
using namespace std;
const int cniRowDataSize = 2048;
const int cniRowDescSize = 128;
const int cniOnceSampleRowNum = 64;
const int cniOnceDMADataSize = (cniRowDataSize + cniRowDescSize) * cniOnceSampleRowNum;
class CDMACtrl
{
public:
	// 构造函数
	CDMACtrl(const string & sDriverFile);
	// 析构函数
	virtual ~CDMACtrl();
	// 初始化
	virtual int iInitialize(int iDataLen);
public:
	inline void SetDriverFile(const string &sDriverFile)
	{
		m_sDriverFile = sDriverFile;
		return;
	}
	inline string sGetDriverFile() const
	{
		return m_sDriverFile;
	}
	inline int iGetDriverHandle() const
	{
		return m_iDriverHandle;
	}
	// 开始采集
	virtual int iStartSample();
	// 采集完成标识
	virtual int iGetSampleFinishedStatus();
	// 读取DMA数据
	virtual int iReadDMAData(unsigned char * &rdBuf, int &iLen);
private:
	// 驱动文件句柄
	int m_iDriverHandle;
	// 驱动文件
	string m_sDriverFile;
	// 驱动文件映射内存
	//void * m_pMap;
};

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include "DMACtrl.h"
#define IOCTL_ARG1                    0xFB
#define DMA_START_RD_COMMAND         _IO(IOCTL_ARG1,1)
#define DMA_START_WR_COMMAND         _IO(IOCTL_ARG1,2)
#define DMA_WAIT_WR_FINISH_COMMAND   _IO(IOCTL_ARG1,3)
#define DMA_WAIT_RD_FINISH_COMMAND   _IO(IOCTL_ARG1,4)
const unsigned int cnuiMapAddrSize = 0x22000;

// 构造函数
CDMACtrl::CDMACtrl(const string & sDriverFile)
{
	m_sDriverFile = sDriverFile;
	m_iDriverHandle = -1;
	//m_pMap = MAP_FAILED;
	return;
}
// 析构函数
CDMACtrl::~CDMACtrl()
{
	/*if (MAP_FAILED != m_pMap)
	{
		munmap(m_pMap, cnuiMapAddrSize);
	}*/
	if (-1 != m_iDriverHandle)
	{
		close(m_iDriverHandle);
		m_iDriverHandle = -1;
	}
	return;
}

// 初始化
int CDMACtrl::iInitialize(int iDataLen)
{
	m_iDriverHandle = open(m_sDriverFile.c_str(), O_RDWR);
	if (m_iDriverHandle < 0)
	{
		return EXIT_FAILURE;
	}
	else
	{
		/*m_pMap = mmap(nullptr, cnuiMapAddrSize, PROT_READ|PROT_WRITE, MAP_SHARED, m_iDriverHandle, 0);
		if (MAP_FAILED == m_pMap)
		{
			ostringstream os;
			os << "failed to mmap [" << m_sDriverFile << "]" << endl;
			CLog::GetInstance()->WriteLog(__FUNCTION__, __LINE__, os.str(), Log_Error);
		}*/
		return EXIT_SUCCESS;
	}
}

// 开始采集
int CDMACtrl::iStartSample()
{
	int iLen = cniOnceDMADataSize * 4;
	return ioctl(m_iDriverHandle, DMA_START_RD_COMMAND, &iLen);
}

// 采集完成标识
int CDMACtrl::iGetSampleFinishedStatus()
{
	int iLen = cniOnceDMADataSize * 4;
	return ioctl(m_iDriverHandle, DMA_WAIT_RD_FINISH_COMMAND, &iLen);
}

// 读取DMA数据
int CDMACtrl::iReadDMAData(unsigned char * &rdBuf, int &iLen)
{
	//iLen = cniOnceDMADataSize;
	rdBuf = new unsigned char[iLen];
	/*if (MAP_FAILED != m_pMap)
	{
		memcpy(rdBuf, m_pMap, cniOnceDMADataSize);
		return iLen;
	}
	else*/
	{
		int len = read(m_iDriverHandle, rdBuf, iLen);
		return len;
	}
}

子类mmap方式传输：

#pragma once
#include <string>
#include "DMACtrl.h"
#include "dma-proxy.h"
using namespace std;
class CDMAProxyCtrl:public CDMACtrl
{
public:
	// 构造函数
	CDMAProxyCtrl(const string & sDriverFile);
	// 析构函数
	~CDMAProxyCtrl();
	// 初始化
	int iInitialize(int iDataLen);
public:
	// 开始采集
	virtual int iStartSample();
	// 采集完成标识
	virtual int iGetSampleFinishedStatus();
	// 读取DMA数据
	virtual int iReadDMAData(unsigned char * &rdBuf, int &iLen);
private:
	// 驱动文件句柄
	channel_buffer *m_pChannelBuffer;
};


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include "DMAProxyCtrl.h"
#include <string>
#include<iostream>
using namespace std;
// 构造函数
CDMAProxyCtrl::CDMAProxyCtrl(const string & sDriverFile)
	:CDMACtrl(sDriverFile)
{
	m_pChannelBuffer = (channel_buffer *)MAP_FAILED;
	return;
}
// 析构函数
CDMAProxyCtrl::~CDMAProxyCtrl()
{
	if (MAP_FAILED != m_pChannelBuffer)
	{
		munmap(m_pChannelBuffer, sizeof(struct channel_buffer));
		m_pChannelBuffer = nullptr;
	}
	return;
}

// 初始化
int CDMAProxyCtrl::iInitialize(int iDataLen)
{
	if (EXIT_FAILURE == CDMACtrl::iInitialize(iDataLen))
	{
		return EXIT_FAILURE;
	}
	m_pChannelBuffer = (struct channel_buffer *)mmap(NULL, sizeof(struct channel_buffer) * RX_BUFFER_COUNT,
		PROT_READ | PROT_WRITE, MAP_SHARED, iGetDriverHandle(), 0);

	m_pChannelBuffer[0].length = iDataLen; //m_pChannelBuffer->length = cniOnceDMADataSize; 
	return EXIT_SUCCESS;
}

// 开始采集
int CDMAProxyCtrl::iStartSample()
{
	int iChannelIndex = 0;
	return ioctl(iGetDriverHandle(), START_XFER, &iChannelIndex);
}

// 采集完成标识
int CDMAProxyCtrl::iGetSampleFinishedStatus()
{
	int iChannelIndex = 0;
	return ioctl(iGetDriverHandle(), FINISH_XFER, &iChannelIndex);
}

// 读取DMA数据
int CDMAProxyCtrl::iReadDMAData(unsigned char * &rdBuf, int &iLen)
{
	//iLen = cniOnceDMADataSize;
	rdBuf = new unsigned char[iLen];
	if (MAP_FAILED != m_pChannelBuffer)
	{
		//string *p = new string[iLen];
		//p = 9;
		//memcpy((void*)m_pChannelBuffer->buffer, p, sizeof(unsigned int));

		memcpy(rdBuf, (void*)m_pChannelBuffer->buffer, iLen);
		//memcpy(rdBuf, (void*)m_pChannelBuffer->buffer, cniOnceDMADataSize);
		return iLen;
	}
	else
	{
		printf("transport by read");
		return read(iGetDriverHandle(), rdBuf, iLen);
	}
}

主程序测试最佳带宽main：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include<iostream>
#include <iomanip>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <string>
#include "LumDataCtrl.h"
#include <time.h>
#include <fstream>

#include<sys/stat.h>
#include<sys/types.h>



using namespace std;
#define EXIT_SUCCESS 0
#define EXIT_FAILURE 1

#define BASE_ADDR 0x40000000
#define PAGE_SIZE ((size_t) getpagesize()) // 分配地址大小
#define PAGE_MASK ((uint32_t)(long)~(PAGE_SIZE-1)) // 分配地址掩码
#define DEV_MEM_SIZE (PAGE_SIZE*2)
#define DEV_MEM_MASK ((uint32_t)(long)~(DEV_MEM_SIZE-1)) // 分配地址掩码
#define WR_DMARDLEN_OFFSET 60 // 写DMA读长度寄存器偏移值 
#define CAPTURE_OFFSET 24
const int cniScanRowLowerLimit = 0;
const int cniScanRowUpperLimit = 1023;


int main(int argv, char ** args)
{
	if (argv < 2)
	{
		cout << "Please Enter DMAType(0 or 1)" << endl;
		return EXIT_FAILURE;
	}
	int iDMAType = 1;
	if ("0" == string(args[1]) || "1" == string(args[1]))
	{
		iDMAType = stoi(args[1]);
	}

	ofstream ofs;
	ofs.open("DMA_test_bind.txt", ios::out);

	unsigned char *m_bsRawLumData = nullptr;
	int m_iDataLen;// 原始亮度数据长度
	int cniRawLumRowDataSize = 2176*64;

	const string cnsDMADriverName = "/dev/axiDmaPoxy";
	CLumDataCtrl lumDataCtrl(cnsDMADriverName, iDMAType);

	//int iLen = cniOnceDMADataSize;
	int rowNum = 128; //初始row  开始的行数
	int DMAiLen = 2176 * rowNum;  //一次传输数据的大小
	unsigned char *bsData = nullptr;
	double ibandwidth = 0; //带宽 MB/S
	double ibandwidth_next = 0;

	while (1)        //外循环  退出循环条件是带宽发生下降或者大于了驱动的内存大小       
	{
	//********************************
		if (EXIT_FAILURE == lumDataCtrl.iInitilize(DMAiLen))
		{
			cout << "failed to initialize LumDataCtrl" << endl;
			return EXIT_FAILURE;
		}

		int fd = -1;
		volatile void *addr = NULL;
		volatile void * virt_addr = NULL;
		//打开文件
		fd = open("/dev/mem", O_RDWR | O_SYNC);
		if (-1 == fd)
		{
			printf("error:failed to open file[/dev/mem]\n");
			return 1;
		}

		//映射到内存
		addr = mmap(NULL, DEV_MEM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, BASE_ADDR);
		if (MAP_FAILED == addr)
		{
			close(fd);
			printf("failed to mmap phy-addr to virtual-addr\n");
			return 1;
		}
		virt_addr = (volatile void *)((uint32_t)addr & DEV_MEM_MASK);
		printf("PhyAddr:%x mamped to VirtAddr:%x, reg0:%x\n", BASE_ADDR, (uint32_t)virt_addr, *(volatile uint32_t *)(virt_addr));

		

		// 停止扫描
		unsigned int uiParam = (4 << 28) | (cniScanRowLowerLimit << 16) | cniScanRowUpperLimit;
		memcpy(((char*)virt_addr + CAPTURE_OFFSET), (void*)&uiParam, sizeof(unsigned int));  // 写方式一

		// 设置函数
		unsigned int uiLineNum = rowNum | (0x5a5a << 16);
		memcpy(((char*)virt_addr + WR_DMARDLEN_OFFSET), (void*)&uiLineNum, sizeof(unsigned int));  // 写方式一
		//(unsigned int *)(virt_addr+WR_DMARDLEN_OFFSET) = uiLineNum; // 写方式二

		//开始扫描
		uiParam = (5 << 28) | (cniScanRowLowerLimit << 16) | cniScanRowUpperLimit;
		memcpy(((char*)virt_addr + CAPTURE_OFFSET), (void*)&uiParam, sizeof(unsigned int));  // 写方式一

		  //断开映射
		munmap((void *)addr, BASE_ADDR);

		//关闭文件
		close(fd); 
		//********************************
		int i = 0;
		time_t tStartTime = time(NULL);
		int iInterval = 0;
		while (1)      //内循环， 退出循环条件达到十分钟                 
		{
			if (EXIT_FAILURE == lumDataCtrl.iSampleLumData(bsData, DMAiLen))
			{
				cout << "failed to sample lumData" << endl;
				return EXIT_FAILURE;
			}
			i++;                //记录次数
			if (nullptr != bsData)  //清空数据缓存
			{
				delete bsData;
				bsData = nullptr;
			}
			if ((iInterval = time(NULL) - tStartTime)> 10)      //更新时间     计算时间间隔
			{
				ofs << " 600s end! /n" << endl;
				break;
			}
		}
		ofs << " times = " << i << endl;             //记录结束次数*/
		long long Mbit = 1048576;
		long long j = i;
		long long size_MB = Mbit * 10;
		long long size_DMA = j * DMAiLen;
		long long ibandwidth = size_DMA / size_MB; //记录性能带宽
		
		if (ibandwidth < ibandwidth_next)   //判断这次计算的带宽和上次的带宽MB/S
		{
			ofs << " bind = " << ibandwidth << endl;
			ofs << " best_bind = " << ibandwidth_next << endl; //带宽开始下降，停止运行获取最优带宽, 最优带宽
			ofs << " row = " << rowNum << endl;
			ofs << " DMAiLen = " << DMAiLen << endl;
		//	break;
		}
		else
		{
			ofs << " bind = " << ibandwidth << endl; //当前带宽
			ofs << " row = " << rowNum << endl;
			ofs << " DMAiLen = " << DMAiLen << endl;
		}
		ibandwidth_next = ibandwidth;        //保存这次记录的带宽*/

	     // 一次循环后长度加倍 呈现2的指数上升
		rowNum = rowNum + 16; // 行数加倍*/
		DMAiLen = 2176 * rowNum;
	}
	ofs.close();
	return 0;
}

主程序验证正确性main：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include<iostream>
#include <iomanip>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <string>
#include "LumDataCtrl.h"
#include <time.h>
#include <fstream>

#include<sys/types.h>
#include<sys/stat.h>

using namespace std;
#define EXIT_SUCCESS 0
#define EXIT_FAILURE 1

#define BASE_ADDR 0x40000000
#define PAGE_SIZE ((size_t) getpagesize()) // 分配地址大小
#define PAGE_MASK ((uint32_t)(long)~(PAGE_SIZE-1)) // 分配地址掩码
#define DEV_MEM_SIZE (PAGE_SIZE*2)
#define DEV_MEM_MASK ((uint32_t)(long)~(DEV_MEM_SIZE-1)) // 分配地址掩码
#define WR_DMARDLEN_OFFSET 60 // 写DMA读长度寄存器偏移值 
#define CAPTURE_OFFSET 24
const int cniScanRowLowerLimit = 0;
const int cniScanRowUpperLimit = 1023;


int main(int argv, char ** args)
{
	if (argv < 2)
	{
		cout << "Please Enter DMAType(0 or 1)" << endl;
		return EXIT_FAILURE;
	}
	int iDMAType = 1;
	if ("0" == string(args[1]) || "1" == string(args[1]))
	{
		iDMAType = stoi(args[1]);
	}

	ofstream ofs;
	ofs.open("DMA_test_bind.txt", ios::out);

	int fd = -1;
	volatile void *addr = NULL;
	volatile void * virt_addr = NULL;
	unsigned char *bsData = nullptr;
	int rowNum = 1024; //初始row
	int iDMALen = 2176 * rowNum;

	const string cnsDMADriverName = "/dev/axiDmaPoxy";
	CLumDataCtrl lumDataCtrl(cnsDMADriverName, iDMAType);
	if (EXIT_FAILURE == lumDataCtrl.iInitilize(iDMALen))
	{
		cout << "failed to initialize LumDataCtrl" << endl;
		return EXIT_FAILURE;
	}
	
	

	//打开文件
	fd = open("/dev/mem", O_RDWR | O_SYNC);
		if (-1 == fd)
		{
			printf("error:failed to open file[/dev/mem]\n");
			return 1;
		}

		//映射到内存
		addr = mmap(NULL, DEV_MEM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, BASE_ADDR);
		if (MAP_FAILED == addr)
		{
			close(fd);
			printf("failed to mmap phy-addr to virtual-addr\n");
			return 1;
		}
		virt_addr = (volatile void *)((uint32_t)addr & DEV_MEM_MASK);
		printf("PhyAddr:%x mamped to VirtAddr:%x, reg0:%x\n", BASE_ADDR, (uint32_t)virt_addr, *(volatile uint32_t *)(virt_addr));

		

		// 停止扫描
		unsigned int uiParam = (4 << 28) | (cniScanRowLowerLimit << 16) | cniScanRowUpperLimit;
		memcpy(((char*)virt_addr + CAPTURE_OFFSET), (void*)&uiParam, sizeof(unsigned int));  // 写方式一

		// 设置函数
		unsigned int uiLineNum = rowNum | (0x5a5a << 16);
		memcpy(((char*)virt_addr + WR_DMARDLEN_OFFSET), (void*)&uiLineNum, sizeof(unsigned int));  // 写方式一
		//(unsigned int *)(virt_addr+WR_DMARDLEN_OFFSET) = uiLineNum; // 写方式二

		//开始扫描
		uiParam = (5 << 28) | (cniScanRowLowerLimit << 16) | cniScanRowUpperLimit;
		memcpy(((char*)virt_addr + CAPTURE_OFFSET), (void*)&uiParam, sizeof(unsigned int));  // 写方式一

		  //断开映射
		munmap((void *)addr, BASE_ADDR);

		//关闭文件
		close(fd); 
		unsigned int data_dma = 0;
		unsigned int data_dma2 = 0;
		while(1)
		{
			if (EXIT_FAILURE == lumDataCtrl.iSampleLumData(bsData, iDMALen))
			{
				cout << "failed to sample lumData" << endl;
				return EXIT_FAILURE;
			}
			data_dma = *(unsigned int*)(bsData+24);
			if ((data_dma-data_dma2) != rowNum)
			{
				cout << "failed to DMAData transform, preIndex:" << hex << setw(8) << setfill('0') << data_dma2;
				cout << ", CurIndex:" << hex << setw(8) << setfill('0') << data_dma << endl;
				
			}
			if (nullptr != bsData)  //清空数据缓存
			{
				delete bsData;
				bsData = nullptr;
			}
			data_dma2 = data_dma;
		}

	/*cout << " DMA data:" << endl;
	for (int i = 0; i < DMAiLen; i++)
	{
		if (i != 0 && 0 == i % 16)
		{
			cout << endl;
		}
		cout << hex << setw(2) << setfill('0') << (int)bsData[i];
		
	}*/
	ofs.close();
	return 0;
}

逻辑框图：

对应地址：

Tiga840
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
DMA基本原理及其实验代码编写
weixin_55991188的博客
07-28 5762
STM32单片机，DMA，DMA代码编写
串口DMA 收发测试(部分代码)
保持每天的清醒
03-29 116
【代码】串口DMA 收发测试(部分代码)
DMA简单的测试代码
u011392772的专栏
07-19 2605
MSP430F2616的DMA传输，根据触发方式的不同有多种模式，最简单的是Single Transfer，即：设置好源地址与目标地址，以及需要传输的byte/word数，全部传输完成之后DMAEN自动清零，而传输一个byte/word都需要触发一次。 MSP430的DMA源地址和目标地址可以为byte或者word类型，且可以设置递增、递减或者不变，通过寄存器进行相应的设置即可，但它们不是这
DMA驱动的demo
weixin_45930312的博客
03-15 325
【代码】DMA驱动的demo。
CDMA编码
Aden的专栏
11-14 9530
1、实验题目：CDMA编码 2、实验内容： （1） 随机生成5个互不正交的8位码片M1、M2、M3、M4、M5。 （2） 分别求出与M1、M2、M3、M4、M5所有正交的8位码片。 3、实验报告内容： （1） CDMA信道复用原理。 （2） 随机生成的的5个互不正交的码片M1、M2、M3、M4、M5。 （3） 获取与某个码片正交的全部码片的算法。 （4） 记录与M1正交的码片数量及
EDMA.rar_dma 测试代码_edma
09-22
这篇文档将详细介绍EDMA测试代码以及其在DMA中的独特应用。 一、EDMA基本原理 EDMA与普通的DMA相比，其核心优势在于事件触发。传统的DMA在传输数据时，通常由CPU发起请求并控制整个过程，而EDMA则可以独立于CPU，...
DMA.rar_dma_dma 测试代码_stm32103 ad dma
09-14
在"DMA.rar"压缩包中，我们找到了用于测试STM32103 DMA功能的代码。这个代码很适合初学者学习，因为它展示了如何配置DMA控制器、设置传输参数、启动传输以及处理传输完成的中断。通过运行此代码，你可以观察到DMA...
s3c44b0 dma测试源程序.rar_44b0 dma_dma_dma 测试代码_s3c44b0 dma
09-24
总结来说，S3C44B0的DMA测试源代码为我们提供了一个实用的参考，通过它我们可以学习如何在SDT环境下配置和控制DMA进行高效的数据传输。在实际项目中，根据具体的硬件接口和应用需求，灵活运用这些知识可以极大地优化...
基于ZedBoard的AXI DMA测试代码
04-16
笔者自己在ZedBoard上实现的AXI DMA的测试程序。
Xilinx中DMA相关驱动代码
12-25
本主题将深入探讨Xilinx中的几种DMA引擎，包括VDMA、CDMA和ADMA，并结合其驱动代码进行解析。 1. VDMA (Video DMA)：视频DMA主要用于高清视频流处理，提供高效的数据传输能力，以满足实时视频应用的需求。VDMA支持...
函数模板与类模板
程序员_小兵
07-12 1282
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
qq_43671872的博客
07-08 867
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
基于Big-Bang-Big-Crunch(BBBC)算法的目标函数最小值计算matlab仿真
熟悉python,matlab,C,C++,JAVA等
07-12 275
BBBC算法的核心思想模拟了宇宙从大爆炸（Big Bang）开始，经历扩张，再到可能的大收缩（Big Crunch）的过程，以此类比于在解空间中从初始分散的解集出发，通过一系列搜索过程逐步集中并接近最优解的过程。：一个简化的聚集方法可以是xi′′​=xbest​+β⋅(xi′​−xbest​)，其中xbest​是最优解，β是一个小于1的收缩因子，控制收缩速度。：每个解xi​依据一定的规则在解空间中移动，这个移动可以是随机的，也可以基于某种策略，比如基于目标函数梯度的方向或者利用当前解与其他解的相对位置。
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 115
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 286
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
算法刷题笔记 KMP字符串（C++实现，并给出了求next数组的独家简单理解方式）
hanmo22357的博客
07-12 475
一道经典且较难的算法题，给出了C++代码实现，以及自己对next数组求解的独家简单的理解方式。
代码随想录算法训练营第33天
m0_62262158的博客
07-10 130
【代码】代码随想录算法训练营第33天。
力扣215 数组中第k大的数
东篱君的博客
07-10 267
算法：由于数组最大范围是10000，存在负数。申请一个20000的数组，将原数组的数作为新数组下标（+10000因为存在负数），然后从后往前减，求出第K大的数。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。本题主要考察各种排序算法，要求时间O（n），严格意义上说只有计数排序满足条件。给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。
【LeetCode】：62：不同路径
最新发布
2401_83821949的博客
07-12 68
【代码】【LeetCode】：62：不同路径。
Keil5dma代码
05-10
Keil5是一款嵌入式开发软件，可以用来编写和调试嵌入式系统的程序。DMA（Direct Memory Access，直接内存访问）是一种数据传输方式，可以在不占用CPU时间的情况下进行数据传输。 Keil5 DMA代码通常是指在Keil5软件中使用DMA进行数据传输的代码。在编写Keil5 DMA代码时，通常需要使用相关的寄存器、DMA控制器等硬件资源，同时也需要了解DMA的工作原理和使用方法。 具体来说，Keil5 DMA代码通常需要完成以下几个步骤： 1. 配置DMA控制器，包括设置DMA通道、数据传输方向、传输数据长度等参数； 2. 配置源地址和目的地址； 3. 启动DMA传输； 4. 等待DMA传输完成或者检测DMA传输状态； 5. 处理DMA传输完成后的事件或者错误。 如果您有具体的Keil5 DMA代码问题或者需求，可以提出来让我更好地为您解答。以下是一些相关问题：

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值