sp4418实现使用c++内存映射实现GPIO、Timer、PWM访问控制

最新推荐文章于 2022-04-23 13:37:03 发布
最新推荐文章于 2022-04-23 13:37:03 发布
阅读量1.5k 收藏 2
点赞数 2
分类专栏： arm c/c++ 文章标签： 内存映射 sp4418 c++ gpio访问 内存映射实例
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haohaojian/article/details/54846549
版权
c/c++ 同时被 2 个专栏收录
26 篇文章 0 订阅
订阅专栏
arm
5 篇文章 0 订阅
订阅专栏 
说明：本文代码由本人编写，可以作为sp4418c++标准库使用，可以作为应用开发者的参考代码，你也可以通过此代码扩展出更多的外设库。本文如需使用转载请给博主留言告知并说明出处,欢迎各位一起讨论。
缘由：网上没有使用c++实现内存映射，其实c++实现代码清晰易读，使用方便，而且具有很高的复用性和兼容性，可以在多平台的应用。
用法：将如下代码拷贝到板子的linux上然后保存成xxx.cpp然后编译运行即可。其中main函数是本人使用的实例代码，包含了GPIO、Timer、pwm，具体用到哪个注释掉其他代码打开相应的注释即可。
/*
 * 基于NanoPc-T2 Debian系统上的内存映射操作
 * 1、本实例为使用寄存器方式输出GPIO口，一条指令的速度可以达到20ns，
 * Author:http://blog.csdn.net/haohaojian
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>

#ifndef __SP4418_FRIENDLY_
#define __SP4418_FRIENDLY_

#define uint8 unsigned char
#define bool char
#define true 1
#define false 0
#endif

#define uint32  intptr_t

#define MAP_SIZE (getpagesize())

class S5P4418{
public:

	static int dev_fd;
	S5P4418()
	{
		openMM();
	}

	~S5P4418()
	{
		closeMM();
	}
	static void openMM()
	{
		dev_fd = open("/dev/mem", O_RDWR | O_NONBLOCK);
		if (dev_fd < 0)
		{
			printf("open(/dev/mem) failed.");
		}
	}

	static void closeMM()
	{
		if(dev_fd){
			close(dev_fd);
			dev_fd = 0;
		}
	}

	static intptr_t getMapBase(intptr_t baseAddr)
	{
		intptr_t base = (intptr_t)mmap(NULL, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, S5P4418::dev_fd, baseAddr);
	    return base;
	}

	static void deleteMapBase(size_t  base);

	static uint32* Register(size_t mem, uint32 offset);
};

int S5P4418::dev_fd = 0;

 void S5P4418::deleteMapBase(size_t  base)
{
	munmap((intptr_t *)base,(size_t)MAP_SIZE);
}

 uint32* S5P4418::Register(size_t mem, uint32 offset)
{
	if (mem == 0)
		return NULL;
	return  (uint32 *)(mem + offset);
}



/*GPIO */
#define BaseGPIO  0xC001A000

enum{
INPUT = 0, OUTPUT
};

enum {
	PA = 0, PB, PC, PD, PE
};

enum {
	Fun_0 = 0, Fun_1, Fun_2, Fun_3
};

enum {
	PULLDOWN = 0, PULLUP, PULLDEFAULT
};

class PORT
{
public:
	PORT(uint8 PORTx)
	{
		intptr_t BaseADDR = 0;
		intptr_t Reg = 0;

		BaseADDR = BaseGPIO + (0x1000 * (uint32)(PORTx));
		this->hMem = S5P4418::getMapBase(BaseADDR);

		//Reg = (BaseADDR & 0x00000FFF);
		Reg = 0;
		OUT = S5P4418::Register(hMem, Reg+0x0000);
		OUTENB = S5P4418::Register(this->hMem, Reg+0x0004);
		DETMODE[0] = S5P4418::Register(this->hMem, Reg+0x0008);
		DETMODE[1] = S5P4418::Register(this->hMem, Reg+0x000C);
		INTENB = S5P4418::Register(this->hMem, Reg+0x0010);
		DET = S5P4418::Register(this->hMem, Reg+0x0014);
		PAD = S5P4418::Register(this->hMem, Reg+0x0018);
		ALTFN[0] = S5P4418::Register(this->hMem, Reg+0x0020);
		ALTFN[1] = S5P4418::Register(this->hMem, Reg+0x0024);
		DETMODEEX = S5P4418::Register(this->hMem, Reg+0x0028);
		DETENB = S5P4418::Register(this->hMem, Reg+0x003C);
		SLEW = S5P4418::Register(this->hMem, Reg+0x0040);
		SLEWDEF = S5P4418::Register(this->hMem, Reg+0x0044);
		DRV[0] = S5P4418::Register(this->hMem, Reg+0x0050);
		DRV[1] = S5P4418::Register(this->hMem, Reg+0x0048);
		DRVDEF[0] = S5P4418::Register(this->hMem, Reg+0x0054);
		DRVDEF[1] = S5P4418::Register(this->hMem, Reg+0x004C);
		PULLSEL = S5P4418::Register(this->hMem, Reg+0x0058);
		PULLDEF = S5P4418::Register(this->hMem, Reg+0x005C);
		PULLENB = S5P4418::Register(this->hMem, Reg+0x0060);
		PULLENBDEF = S5P4418::Register(this->hMem, Reg+0x0064);
	}
	~PORT(){
		if(hMem)
		S5P4418::deleteMapBase(hMem);
	}

	intptr_t hMem;

	uint32 *OUT;//输出口
	uint32 * OUTENB;//输出使能，共32位
	uint32 * DETMODE[2];
	uint32 * INTENB;
	uint32 * DET;
	uint32 * PAD;
	uint32 * ALTFN[2];
	uint32 * DETMODEEX;
	uint32 * DETENB;
	uint32 * SLEW;
	uint32 * SLEWDEF;
	uint32 * DRV[2];
	uint32 * DRVDEF[2];
	uint32 * PULLSEL;
	uint32 * PULLDEF;
	uint32 * PULLENB;
	uint32 * PULLENBDEF;

	void SetData(uint32 Data);
	uint32 GetData();
};

void PORT::SetData(uint32 Data)
{
	*OUT = Data;
}

uint32 PORT::GetData()
{
	return *OUT;
}

class GPIO{
public:
	PORT * Port;
	uint8 Pin;
	uint32 Bit;

	void SetFun(uint8 FUNx);
	void SetDir(uint8 IO );
	void SetDrv();
	void SetPull(uint8 Pull );
	void SetSlew(bool Slew ) ;
	bool GetSlew();
	void SetData(bool Data );
	bool GetData();
	void Flip();
	/*
	 * PORTx:对应A，B，C，D，E
	 * PINx:对应0-31*/
	GPIO(uint8 PORTx ,uint8 PINx)
	{
		Pin = 0;
		Bit = 0;
		Port = new PORT(PORTx );
		this->Pin = PINx;
		this->Bit = (0x1 << PINx);

		*this->Port->SLEWDEF &= ~this->Bit;
	}
	~GPIO(){
		delete Port;
	}
};

void GPIO::SetFun(uint8 FUNx) {
	switch (Pin) {
	case 0:
    case 1:
	case 2:
	case 3:
	case 4:
	case 5:
	case 6:
	case 7:
	case 8:
	case 9:
    case 10:
	case 11:
	case 12:
	case 13:
	case 14:
	case 15:
		*Port->ALTFN[0] &= ~(0x3 << (Pin * 2));
		*Port->ALTFN[0] |= (uint32)(FUNx << (Pin * 2));
		break;
	default:
		*Port->ALTFN[1] &= ~(0x3 << ((Pin - 16) * 2));
		*Port->ALTFN[1] |= (uint32)(FUNx << ((Pin - 16) * 2));
		break;
	}
}

 void GPIO::SetDir(uint8 IO ) {
	switch (IO) {
	case INPUT:
		*Port->OUTENB &= ~Bit;
		break;
	case OUTPUT:
		*Port->OUTENB |= Bit;
		break;
	}
}

void GPIO::SetDrv() {

}

void GPIO::SetPull(uint8 Pull ) {
	switch (Pull) {
	case PULLDOWN:
		*Port->PULLENB &= ~Bit;
		*Port->PULLDEF |= Bit;
		break;
	case PULLUP:
		*Port->PULLENB |= Bit;
		*Port->PULLDEF |= Bit;
		break;
	case PULLDEFAULT:
		*Port->PULLENB &= ~Bit;
		break;
	}
}

void GPIO::SetSlew(bool Slew ) {

	*Port->SLEWDEF |= Bit;
	switch (Slew) {
	case true:
		*Port->SLEW &= ~Bit;
		break;
	case false:
		*Port->SLEW |= Bit;
		break;
	default:
		break;
	}
}

bool GPIO::GetSlew() {
	return ((*Port->SLEWDEF & Bit) == Bit) && ((*Port->SLEW & Bit) == 0);
}

void GPIO::SetData(bool Data ) {
	switch (Data) {
	case true:
		*Port->OUT |= Bit;
		break;
	case false:
		*Port->OUT &= ~Bit;
		break;
	}
}

bool GPIO::GetData(){
	return (*Port->OUT & Bit) == Bit;
}

void GPIO::Flip() {;
	*Port->OUT ^= Bit;
}
/* GPIO END   */

/*定时器*/
long BaseTIMER = 0xC0017000;
enum{
	TIMER_0 = 0, TIMER_1, TIMER_2, TIMER_3, TIMER_4
};

class TIMER {
public:
	TIMER(uint8 TIMERx ,bool FunPWM );
	~TIMER(){
		if(hMem)S5P4418::deleteMapBase(hMem);
		if(gpio)delete gpio;
	}
	uint8 timerX;
	uint32 hMem;
	GPIO	*gpio;

	uint32 * TCFG[2];
	uint32 * TCON;
	uint32 * TCNTB;
	uint32 * TCMPB;
	uint32 * TCNTO;
	uint32 * TINT;

	void Start();
	void Stop();
	void SetAutoReload(bool AutoReload);
	void SetDivider(uint8 Divider);
	void SetPrescale(uint8 Prescale);
	void SetDuration(uint32 Duration);
	void SetCompare(uint32 Compare );
	uint32 GetCount();
	uint32 getTest();
    uint32 getCount(uint8 timerX);
};

TIMER::TIMER(uint8 TIMERx ,bool FunPWM ){
	timerX = TIMERx;
	gpio = NULL;
	if(FunPWM)
	BaseTIMER = 0xC0018000;
	hMem = S5P4418::getMapBase(BaseTIMER);
	TCFG[0] = 	S5P4418::Register(hMem, 0x00);
	TCFG[1] = 	S5P4418::Register(hMem, 0x04);
	TCON = 		S5P4418::Register(hMem, 0x08);

	switch (TIMERx)
	{
	case TIMER_0:
	case TIMER_1:
	case TIMER_2:
	case TIMER_3:
		TCNTB = S5P4418::Register(hMem, 0x0C + (uint32)(TIMERx * 0x0C));
		TCMPB = S5P4418::Register(hMem, 0x10 + (uint32)(TIMERx * 0x0C));
		TCNTO = S5P4418::Register(hMem, 0x14 + (uint32)(TIMERx * 0x0C));
		break;
	case TIMER_4:
		TCNTB = S5P4418::Register(hMem, 0x3C);
		TCNTO = S5P4418::Register(hMem, 0x40);
		break;
	}
	printf("timerX:%d\n",timerX);
	printf("offset is:%x\n",0x14 + (uint32)(TIMERx * 0x0C));

	TINT = S5P4418::Register(hMem, 0x44);

	if (FunPWM) {
		switch (TIMERx) {
			case TIMER_2:
				gpio = new GPIO(PC, 14);
				gpio->SetFun(Fun_2);
				gpio->SetDir(OUTPUT);
//					printf("gpio->Port->hMem:%X\n",gpio->Port->hMem);
				*TCON &= ~(0x1 << 13);
				*TCON |= (0x1 << 14);
				break;
		}
	}
}
uint32 TIMER::getCount(uint8 timerX)
{
    uint32 * addr = NULL;
    addr = S5P4418::Register(hMem, 0x14 + (uint32)(timerX * 0x0C));
    return *addr;
}

void TIMER::Start() {
	switch (timerX) {
		case 0:
			*TCON |= 0x1;
			break;
		case 1:
		case 2:
		case 3:
		case 4:
			*TCON |= (0x1 << (timerX * 4 + 4));
			break;
	}
}

void TIMER::Stop() {
	switch (timerX) {
		case 0:
			*TCON &= ~0x1;break;
		case 1:
		case 2:
		case 3:
		case 4:
			*TCON &= ~(0x1 << (timerX * 4 + 4));break;
	}
}

void TIMER::SetAutoReload(bool AutoReload) {
	if (AutoReload)
	{
		switch (timerX) {
			case 0: *TCON |= (0x1 << 3);break;
			case 1: *TCON |= (0x1 << 11);break;
			case 2: *TCON |= (0x1 << 15);break;
			case 3: *TCON |= (0x1 << 19);break;
			case 4: *TCON |= (0x1 << 22);break;
		}
	} else
	{
		switch (timerX) {
			case 0: *TCON &= ~(0x1 << 3);break;
			case 1: *TCON &= ~(0x1 << 11);break;
			case 2: *TCON &= ~(0x1 << 15);break;
			case 3: *TCON &= ~(0x1 << 19);break;
			case 4: *TCON &= ~(0x1 << 22);break;
		}
	}
}

void TIMER::SetDivider(uint8 Divider) {
	*TCFG[1] &= ~(0xF << (timerX * 4));
	*TCFG[1] |= (uint32(Divider & 0x7) << (timerX * 4));
}

void TIMER::SetPrescale(uint8 Prescale) {
	switch (timerX) {
		case 0:
		case 1:
			*TCFG[0] &= ~0xFF;
			*TCFG[0] |= uint32(Prescale);
			break;
		case 2:
		case 3:
		case 4:
			*TCFG[0] &= ~(0xFF << 8);
			*TCFG[0] |= uint32(Prescale << 8);
			break;
	}
}

void TIMER::SetDuration(uint32 Duration) {
	*TCNTB = Duration;
}

void TIMER::SetCompare(uint32 Compare ) {
	*TCMPB = Compare;
}

uint32 TIMER::GetCount() {
	return *TCNTO;
}

uint32 TIMER::getTest()
{
	return *TCNTO;
}

/* 毫秒级 延时 */
void Sleep(int ms)
{
    struct timeval delay;
    delay.tv_sec = 0;
    delay.tv_usec = ms * 1000; // 20 ms
    select(0, NULL, NULL, NULL, &delay);
}

int main(int argc, char **argv)
{
	S5P4418 * s5p4418 = new(S5P4418);
/*gpio例子，点亮/关闭Led
	GPIO * gpio = new GPIO(PB,12);
	gpio->SetFun(Fun_2);
	gpio->SetDir(OUTPUT);
	gpio->Flip();
	delete gpio;
*/

/*pwm例子*/
	int k = 0;
    int max = 0;
	TIMER * PWM2 = new TIMER(TIMER_2, true);
	
	PWM2->Stop();
	printf("TCON Value:%X\n",PWM2->TCON);
	printf("TCON:%X\n",*PWM2->TCON);
	PWM2->SetAutoReload(true);
	PWM2->SetDivider(3);
	PWM2->SetPrescale(0xFF);
	PWM2->SetDuration(0xffffff);
	PWM2->SetCompare(0xfffff);
	PWM2->Start();
	printf("6*PWM2->TCON:%X\n",*PWM2->TCON);
	printf("GetCount:%d\n",PWM2->GetCount());
	printf("GetCount:%d\n",PWM2->GetCount());


/*内存映射pwm遍历例子
    while(k < 5)
    {
    	for(int i = 0; i < 4; i ++)
		{
			printf("%dtimer count is:%d\n",i,PWM2->getCount(i));
		}
    	printf("\n");
    	Sleep(200);
    	k++;
    }
*/
	PWM2->Stop();
	delete PWM2;

	delete s5p4418;
    return 0;
}
智能高科
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
讯为4418 led驱动以模块加载方式的驱动程序
09-20
驱动程序为模块加载方式，前提是要通过make menuconfig去掉led选项 在讯为4418开发板上加载模块，并测试通过，开发板系统为android 5.1
BeagleBone Black板第七课：GPIO编程控制
力力梦工场
08-03 9441
BBB板第七课：GPIO编程控制         在一上课我们通过IO函数做了简单的GPIO端口输出高低电平输出，实现对一个LED指示灯的点亮和关闭控制，本节将通过完整的C++程序，实现第四课Shell脚本的全部功能，实现两个LED指示灯的交替闪亮。 直接通过进入功能程序     1、实现echo 44 > export 打开端口功能     上一课简单测试中，通过手工在BBB板终端模式下
讯为4418GPIO口调用过程
09-05
通过调试的方式从led驱动分级找到最终操作寄存器函数，对硬件开发人员查找函数操作GPIO口的源头有很大帮助。
STM32 GPIO/USART/timer 控制（寄存器版）
thaiqi的专栏
08-23 177
参见 http://www.zhishi-zhishi.net/working/stm32_timer.html
RPi-WinWireUm:用户模式直接访问 RaspberryPi 的内存映射外设，以使用 WinWireKm.sys 驱动程序通过 DMA 实现高性能 GPIO 和 PWM
07-19
综上所述，"RPi-WinWireUm"项目为Windows 10环境下的Raspberry Pi开发提供了一个高效、安全的解决方案，通过用户模式访问内存映射外设，结合DMA技术，实现了GPIO和PWM的高性能控制。对于想要在Windows系统上进行...
使用Qt开发界面程序控制GPIO
02-24
前言Qt是一个1991年由奇趣科技开发的跨平台C++图形用户界面应用程序开发框架。它既可以开发GUI程序，也可用于开发非GUI程序，比如控制台工具和服务器。Qt是面向对象的框架，使用特殊的代码生成扩展（称为元对象...
GPIO_C语言实现设备GPIO读写操作_GpioRead_GPIO读写_gpio读写_
09-29
本篇文章将详细探讨如何使用C语言实现对GPIO的读写操作，以及涉及的底层寄存器原理。 首先，理解GPIO的工作原理至关重要。GPIO接口由一组可以配置为输入或输出的物理引脚组成。当配置为输出时，我们可以设置引脚的...
用C语言代码实现GPIO通信协议
05-04
总的来说，用C语言实现GPIO通信协议需要对底层硬件有深入理解，包括其寄存器映射和操作机制。同时，也需要掌握基本的嵌入式编程和系统级编程技术。通过这种方式，我们可以创建自定义的通信协议，满足特定应用场景的...
S5P4418_Users Manual_Ver.0.10.pdf
03-01
三星，4418,4核心，图像处理的CPU。可以做相机的CPU。调试isp等。非常不错的一款sensor。
单片机与DSP中的ARM核心板，三星S5P4418ARM Cortex-A9架构
10-15
产品简介 　　G4418开发平台采用邮票孔的核心板＋底板方式设计，核心板可扩展性强，多达 184 PIN 管脚，运行速度高达 1.4GHz。PCB 采用 8 层沉金工艺设计，具有最佳的电气特性和抗干扰特性，工作稳定可靠。核心板板载了 PMU，带库仑计的充电管理，可以广泛应用于 MID，POS，PDA，PND，智能家居，手机，车机，学习机，游戏机以及其他各种工控领域。 　　S5P4418 采用 28nm 制作工艺，内置高性能 4 核 A9 ARM 架构，相比 Exynos4412， 在多媒体性能上，它几乎支持全格式视频解码，在 LCD 控制器上，芯片板载 LVDS 和 RGB 双路显示控制接
【转】Android应用程序:(jni方式)控制LED/GPIO
梦江月
02-12 2960
GPIO的英文全称General-Purpose Input /Output Ports,中文意思是通用I/O端口。 在嵌入式系统中，经常需要控制许多结构简单的外部设备或者电路，这些设备有的需要通过CPU控制，有的需要CPU提供输入信号搜索。并且，许多设备或电路只要求有开/关两种状体就够了，比如LED的亮与灭。对这些设备的控制，使用传统的串口或者并口就显得比较复杂，所以，在嵌入式微处理器上通常提
使用 RPI.GPIO 模块的脉宽调制（PWM）功能
zandaoguang的博客
08-21 1610
脉宽调制(PWM)是指用微处理器的数字输出来对模拟电路进行控制，是一种对模拟信号电平进行数字编码的方法。在树莓派上，可以通过对GPIO的编程来实现PWM。创建一个 PWM 实例：p = GPIO.PWM(channel, frequency)启用 PWM：p.start(dc) # dc 代表占空比（范围：0.0 <= dc >= 100.0） 更改频率：p.ChangeFrequency(fr
NanoPi M2 gpio驱动编写
hktkfly6的专栏
09-10 1933
作为一个新手第一个程序应该是hello world，第一个驱动肯定就是流水灯了哈，但是啊前两天虚拟机爆炸了。重装了一个64位的ubuntu，耽误了两天，今天下午刚装完开始写驱动，找资料又找了好久，各种心酸。觉得今天再不发帖子太对不起论坛和友善之臂的抬爱了，所以这一篇完成度有点低。      比起来啊，看s5p4418的datesheet简直虐心，英文小白，一句一句度娘翻译的。今天刚写完驱动吧，还
S5P4418裸机开发（三）：运行裸机程序：IROM里面的程序是芯片厂家写死了的，用户改不了
二进制模----细微行动改变影响世界
04-23 339
参考：①.S5P4418启动镜像分析①.NanoPi2-S5P4418启动流程分析②.S5P4418裸机编程的实现（替换2ndboot）③.【NanoPi2试用体验】-6 S5PV4418的启动过程分析-（结合原理图&datasheet)④.【NanoPi2试用体验】-7 在 pi2上用裸机程序点亮LED的原理详细分析与实验 学习了大牛们的操作，自己再整理一下； 系统内存分布： 内部ROM(IROM，20KB，地址0x34000000)的介绍： 上电后，CPU从IROM的0地址的读取指
使用linux内核hrtimer高精度定时器实现GPIO口模拟PWM,【原创】
07-01 575
关键词：Android linux hrtimer 蜂鸣器 等待队列 信号量 字符设备 平台信息:内核：linux3.4.39系统：android/android5.1平台：S5P4418 作者：庄泽彬(欢迎转载，请注明作者) 邮箱：2760715357@qq.com 程序描述：本文控制的设备是无源蜂鸣器，由于无源蜂鸣器是需要产生一定的频率的PWM才能够控制蜂鸣器，不像有...
NanoPC-T4|GPIO驱动
OneSea的专栏
05-01 654
本文主要介绍NanoPC-T4的GPIO驱动。
arm-linux smart4418使用gpio
a20132848的博客
06-23 837
研究了一段时间的gpio，arm上的gpio不像树莓派上可以直接用wiringPi的库直接使用。这个gpio需要配置内核或者直接写入寄存器的方式进行操控。下面就以两种方法使用gpio，简单介绍寄存器，详细的记录一下配置内核的方法。 1. 寄存器 寄存方式得需要用户手册才能使用。主要是查询各个gpio的地址，其中包括控制寄存器的地址和数据寄存器的地址。 其主要流程为下： 1. 写入16位数...
NanoPi PWM驱动（Nanopi-S2）
北京-大白的博客
04-29 983
pwm相关手册说明 These timers can be used to generate internal interrupts to the ARM subsystem. In addition, Timers 0, 1, 2, and 3include a PWM function (Pulse Width Modulation) which can drive an exte...
K60微控制器内存映射与GPIO寄存器详解
"内存映射与寄存器定义在嵌入式系统中是至关重要的概念，尤其是在微控制器（如K60）的使用中。内存映射是指将硬件外设的地址空间分配到CPU的地址空间的过程，使得软件可以通过内存访问方式来操作这些外设。在K60微...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值