Linux应用层使用mmap内存映射控制IO寄存器

已于 2023-11-16 20:01:05 修改
阅读量441 收藏 3
点赞数
文章标签： linux 嵌入式硬件 单片机
于 2023-11-16 19:55:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_68653002/article/details/134319286
版权

1、概述

这段代码中采用了使用mmap函数映射IO寄存器来控制IO的方法，可视为应用层上最快速的IO控制方式之一。

在第三节代码中有ADS8361芯片的时序控制代码，经过多次测试，每次采集所需的时间约为38微秒，共进行了78次IO控制操作，平均每次IO控制操作耗时约为0.5微秒。

2、原理

使用内存映射时条件和初始化：

（1.）内核中释放用到这些IO的设备树节点；

（2.）先手动添加，或在应用层通过程序，将引脚导出（寄存器不对时使用的）；

（3.）使用mmap函数将GPIO寄存器映射到虚拟内存；

（4.）通过寄存器设置GPIO引脚复用，设置GPIO的输入输出等参数；

（5.）或者手动添加，在应用层通过程序，设置GPIO的输入输出等参数；

使用内存映射时的寄存器地址，就和STM32一样。但要注意偏移地址！！！

对指针偏移不理解的宝子们看👇

C语言的指针偏移_c语言指针偏移怎么写_颜一书的博客-CSDN博客

3、代码

#include <sys/mman.h>
#include<stdio.h>          /* 标准输入输出定义 */
#include<stdlib.h>         /* 标准函数库定义 */
#include<unistd.h>         /* Unix 标准函数定义 */
#include<sys/types.h> 
#include<sys/stat.h> 
#include<fcntl.h>          /* 文件控制定义 */
#include<termios.h>        /* PPSIX 终端控制定义 */
#include<string.h>
#include <sys/time.h>
#include <ctype.h>

#include <linux/gpio.h>

/**
    ADC_CLOCK          GPIO0-B5         GRF--H:4~6=0    pinx =L- 13
    ADC_DATA_A0        GPIO0-C5         GRF--H:4~6=0    pinx =H- 5
    ADC_DATA_B         GPIO4-D0         GRF--L:0~2=0    pinx =H- 8
    ADC_BUSY           GPIO0-C7         GRF--H:12~14=0  pinx =H- 7  
    ADC_CONVS          GPIO4-C2         GRF--L:8~10=0   pinx =H- 2
    M0                 GPIO4-D1         GRF--L:4~6=0    pinx =H- 9
    M1                 GPIO4-C7         GRF--H:12~14=0  pinx =H- 7
    A0                 GPIO4-C3         GRF--L:12~14=0  pinx =H- 3
**/

volatile unsigned int *  PMU_GRF_GPIO0;
volatile unsigned int *  PMU_GRF_GPIO4;
volatile unsigned int *  REGGPIO0;
volatile unsigned int *  REGGPIO4;
#define PMU_GRF_GPIO0_BASEADDR    0XFDC20000
#define PMU_GRF_GPIO4_BASEADDR    0XFDC60000
#define GPIO0_REG_BASEADDR        0XFDD60000
#define GPIO4_REG_BASEADDR        0XFE770000

volatile unsigned int *  PMU_GRF_GPIO0;
volatile unsigned int *  PMU_GRF_GPIO4;
volatile unsigned int *  REGGPIO0;
volatile unsigned int *  REGGPIO4;

#define PMU_GRF_GPIO0A_IOMUX_L      0X0000U
#define PMU_GRF_GPIO0A_IOMUX_H      0X0004U
#define PMU_GRF_GPIO0B_IOMUX_L      0X0008U
#define PMU_GRF_GPIO0B_IOMUX_H      0X000CU
#define PMU_GRF_GPIO0C_IOMUX_L      0X0010U
#define PMU_GRF_GPIO0C_IOMUX_H      0X0014U
#define PMU_GRF_GPIO0D_IOMUX_L      0X0018U
#define PMU_GRF_GPIO0D_IOMUX_H      0X001CU

#define PMU_GRF_GPIO4A_IOMUX_L      0X0060U
#define PMU_GRF_GPIO4A_IOMUX_H      0X0064U
#define PMU_GRF_GPIO4B_IOMUX_L      0X0068U
#define PMU_GRF_GPIO4B_IOMUX_H      0X006CU
#define PMU_GRF_GPIO4C_IOMUX_L      0X0070U
#define PMU_GRF_GPIO4C_IOMUX_H      0X0074U
#define PMU_GRF_GPIO4D_IOMUX_L      0X0078U
#define PMU_GRF_GPIO4D_IOMUX_H      0X007CU

#define GPIO0_DATA_L                0X0000U
#define GPIO0_DATA_H                0X0004U
#define GPIO0_DIR_L                 0X0008U
#define GPIO0_DIR_H                 0X000CU
#define GPIO0_INT_L                 0X0010U
#define GPIO0_INT_H                 0X0014U
#define GPIO0_EXT_PORT              0X0070U

#define GPIO4_DATA_L                0X0000U
#define GPIO4_DATA_H                0X0004U
#define GPIO4_DIR_L                 0X0008U
#define GPIO4_DIR_H                 0X000CU
#define GPIO4_INT_L                 0X0010U
#define GPIO4_INT_H                 0X0014U
#define GPIO4_EXT_PORT              0X0070U

enum
{
    ADC_CLOCK=0,
    ADC_DATA_A,
    ADC_DATA_B,
    ADC_BUSY,
    ADC_CONVST,
    M0,
    M1,
    A0,
};

struct gpio_t 
{
    unsigned char gpio;
    char number[10];
    char direction[100];
    char gpio_path[100];
    int  fd;
};

struct gpio_t ADC_collect[8]=
{
    {ADC_CLOCK ,"13" ,"out","",0},
    {ADC_DATA_A,"21" ,"in" ,"",0},
    {ADC_DATA_B,"152","in" ,"",0},
    {ADC_BUSY  ,"23" ,"in" ,"",0},
    {ADC_CONVST,"146","out","",0},
    {M0,"153","out","",0},
    {M1,"151","out","",0},   
    {A0,"147","out","",0},
};

/**
  * 函数名称    __raw_writel(unsigned int data, volatile unsigned int *reg)
  * 函数功能    往指定地址写数据
  * 输入参数    unsigned int data ：写入的数据
                volatile unsigned int *reg：要写入数据的地址
  * 函数返回值  无
  */
void __raw_writel(unsigned int data, volatile unsigned int *reg)
{
    *reg=data;
}

/**
  * 函数名称    __raw_readl( volatile unsigned int *reg)
  * 函数功能    从指定地址读数据
  * 输入参数    volatile unsigned int *reg：要读取数据的地址
  * 函数返回值  读取的数据
  */
unsigned int __raw_readl( volatile unsigned int *reg)
{
    unsigned int data=0;
    data=*reg;
    return data;
}

/**
函數名：    ADC_GPIO_Init
函數功能：  初始化ADC模塊引脚的GPIO
輸入：      无
輸出：      无
**/
void ADC_GPIO_Init(void)
{
    unsigned int temp=0U;
    /*引脚用途模式*/
    /*ADC_CLOCK*/
    temp=__raw_readl(PMU_GRF_GPIO0+PMU_GRF_GPIO0B_IOMUX_H);
    temp = temp | 0xffff0000;
    __raw_writel(temp,PMU_GRF_GPIO0+PMU_GRF_GPIO0B_IOMUX_H);
    temp = temp & (~(0x0000000FU<<4U));
    __raw_writel(temp,PMU_GRF_GPIO0+PMU_GRF_GPIO0B_IOMUX_H);

    /*ADC_DATA_A0*/
    temp=__raw_readl(PMU_GRF_GPIO0+PMU_GRF_GPIO0C_IOMUX_H);
    temp = temp | 0xffff0000;
    __raw_writel(temp,PMU_GRF_GPIO0+PMU_GRF_GPIO0C_IOMUX_H);
    temp = temp & (~(0x0000000fU<<4U));
    __raw_writel(temp,PMU_GRF_GPIO0+PMU_GRF_GPIO0C_IOMUX_H);

    /*ADC_DATA_B*/
    temp=__raw_readl(PMU_GRF_GPIO4+PMU_GRF_GPIO4D_IOMUX_L);
    temp = temp | 0xffff0000;
    __raw_writel(temp,PMU_GRF_GPIO4+PMU_GRF_GPIO4D_IOMUX_L);
    temp = temp & (~(0x0000000fU<<0U));
    __raw_writel(temp,PMU_GRF_GPIO4+PMU_GRF_GPIO4D_IOMUX_L);

    /*ADC_BUSY*/
    temp=__raw_readl(PMU_GRF_GPIO0+PMU_GRF_GPIO0C_IOMUX_H);
    temp = temp | 0xffff0000;
    __raw_writel(temp,PMU_GRF_GPIO0+PMU_GRF_GPIO0C_IOMUX_H);
    temp = temp & (~(0x0000000fU<<12));
    __raw_writel(temp,PMU_GRF_GPIO0+PMU_GRF_GPIO0C_IOMUX_H);

    /*ADC_CONVS*/
    temp=__raw_readl(PMU_GRF_GPIO4+PMU_GRF_GPIO4C_IOMUX_L);
    temp = temp | 0xffff0000;
    __raw_writel(temp,PMU_GRF_GPIO4+PMU_GRF_GPIO4C_IOMUX_L);
    temp = temp & (~(0x0000000fU<<8));
    __raw_writel(temp,PMU_GRF_GPIO4+PMU_GRF_GPIO4C_IOMUX_L);

    /*M0*/
    temp=__raw_readl(PMU_GRF_GPIO4+PMU_GRF_GPIO4D_IOMUX_L);
    temp = temp | 0xffff0000;
    __raw_writel(temp,PMU_GRF_GPIO4+PMU_GRF_GPIO4D_IOMUX_L);
    temp = temp & (~(0x0000000fU<<4U));
    __raw_writel(temp,PMU_GRF_GPIO4+PMU_GRF_GPIO4D_IOMUX_L);

    /*M1*/
    temp=__raw_readl(PMU_GRF_GPIO4+PMU_GRF_GPIO4C_IOMUX_H);
    temp = temp | 0xffff0000;
    __raw_writel(temp,PMU_GRF_GPIO4+PMU_GRF_GPIO4C_IOMUX_H);
    temp = temp & (~(0x0000000fU<<12U));
    __raw_writel(temp,PMU_GRF_GPIO4+PMU_GRF_GPIO4C_IOMUX_H);

    /*A0*/
    temp=__raw_readl(PMU_GRF_GPIO4+PMU_GRF_GPIO4C_IOMUX_L);
    temp = temp | 0xffff0000;
    __raw_writel(temp,PMU_GRF_GPIO4+PMU_GRF_GPIO4C_IOMUX_L);
    temp = temp & (~(0x0000000fU<<2U));
    __raw_writel(temp,PMU_GRF_GPIO4+PMU_GRF_GPIO4C_IOMUX_L);


    /*引脚输入输出模式  可省略与下面重复*/
    /*ADC_CLOCK  OUT*/
    temp=__raw_readl(REGGPIO0+GPIO0_DIR_L);
    temp = temp | 0xffff0000;
    __raw_writel(temp,REGGPIO0+GPIO0_DIR_L);
    temp = temp | ((0x00000001U<<13U));
    __raw_writel(temp,REGGPIO0+GPIO0_DIR_L);

    /*ADC_DATA_A0  INT*/
    temp=__raw_readl(REGGPIO0+GPIO0_DIR_H);
    temp = temp | 0xffff0000; 
    __raw_writel(temp,REGGPIO0+GPIO0_DIR_H);
    temp = temp & (~(0x00000001U<<5U));
    __raw_writel(temp,REGGPIO0+GPIO0_DIR_H);

    /*ADC_DATA_B INT*/
    temp=__raw_readl(REGGPIO4+GPIO4_DIR_H);
    temp = temp | 0xffff0000; 
    __raw_writel(temp,REGGPIO4+GPIO4_DIR_H);
    temp = temp & (~(0x00000001U<<8U));
    __raw_writel(temp,REGGPIO4+GPIO4_DIR_H);

    /*ADC_BUSY INT*/
    temp=__raw_readl(REGGPIO0+GPIO0_DIR_H);
    temp = temp | 0xffff0000; 
    __raw_writel(temp,REGGPIO0+GPIO0_DIR_H);
    temp = temp & (~(0x00000001U<<7U));
    __raw_writel(temp,REGGPIO0+GPIO0_DIR_H);

    /*ADC_CONVS OUT*/
    temp=__raw_readl(REGGPIO0+GPIO0_DIR_H);
    temp = temp | 0xffff0000; 
    __raw_writel(temp,REGGPIO0+GPIO0_DIR_H);
    temp = temp | ((0x00000001U<<4U));
    __raw_writel(temp,REGGPIO0+GPIO0_DIR_H);

    /*M0 OUT */
    temp=__raw_readl(REGGPIO4+GPIO4_DIR_H);
    temp = temp | 0xffff0000; 
    __raw_writel(temp,REGGPIO4+GPIO4_DIR_H);
    temp = temp | ((0x00000001U<<9U));
    __raw_writel(temp,REGGPIO4+GPIO4_DIR_H);

    /*M1 OUT*/
    temp=__raw_readl(REGGPIO4+GPIO4_DIR_H);
    temp = temp | 0xffff0000;
    __raw_writel(temp,REGGPIO4+GPIO4_DIR_H);
    temp = temp | ((0x00000001U<<7U));
    __raw_writel(temp,REGGPIO4+GPIO4_DIR_H);

    /*A0 OUT*/
    temp=__raw_readl(REGGPIO0+GPIO0_DIR_H);
    temp = temp | 0xffff0000; 
    __raw_writel(temp,REGGPIO4+GPIO4_DIR_H);
    temp = temp | ((0x00000001U<<14U));
    __raw_writel(temp,REGGPIO0+GPIO0_DIR_H);

    /*DISABLE INT*/
    /*ADC_CLOCK */
    temp=__raw_readl(REGGPIO0+GPIO0_INT_L);
    temp = temp | 0xffff0000;
    temp = temp & (~(0x00000001U<<13U));
    __raw_writel(temp,REGGPIO0+GPIO0_INT_L);

    /*ADC_DATA_A0 */
    temp=__raw_readl(REGGPIO0+GPIO0_INT_H);
    temp = temp | 0xffff0000;
    temp = temp & (~(0x00000001U<<5U));
    __raw_writel(temp,REGGPIO0+GPIO0_INT_H);

    /*ADC_DATA_B*/
    temp=__raw_readl(REGGPIO4+GPIO4_INT_H);
    temp = temp | 0xffff0000;
    temp = temp & (~(0x00000001U<<8U));
    __raw_writel(temp,REGGPIO4+GPIO4_INT_H);

    /*ADC_BUSY */
    temp=__raw_readl(REGGPIO0+GPIO0_INT_H);
    temp = temp | 0xffff0000;
    temp = temp & (~(0x00000001U<<7U));
    __raw_writel(temp,REGGPIO0+GPIO0_INT_H);

    /*ADC_CONVS */
    temp=__raw_readl(REGGPIO0+GPIO0_INT_H);
    temp = temp | 0xffff0000;
    temp = temp & (~(0x00000001U<<4U));
    __raw_writel(temp,REGGPIO0+GPIO0_INT_H);

    /*M0  */
    temp=__raw_readl(REGGPIO4+GPIO4_INT_H);
    temp = temp | 0xffff0000;
    temp = temp & (~(0x00000001U<<9U));
    __raw_writel(temp,REGGPIO4+GPIO4_INT_H);

    /*M1 */
    temp=__raw_readl(REGGPIO4+GPIO4_INT_H);
    temp = temp | 0xffff0000;
    temp = temp & (~(0x00000001U<<7U));
    __raw_writel(temp,REGGPIO4+GPIO4_INT_H);

    /*A0 */
    temp=__raw_readl(REGGPIO0+GPIO0_INT_H);
    temp = temp | 0xffff0000;
    temp = temp & (~(0x00000001U<<14U));
    __raw_writel(temp,REGGPIO0+GPIO0_INT_H);
}

/**
函數名：    set_ADC_CLOCK
函數功能：  设置ADC_CLOCK的输出值
輸入：      status： 输出的状态；0--低；1--高
輸出：      无
**/
void set_ADC_CLOCK(unsigned char status)
{
    unsigned int temp=0U;
    temp=__raw_readl(REGGPIO0+GPIO0_DATA_L);
    // temp = temp | ((0x00000001U<<(13U+16U))); 
    temp = temp | (0xffff0000U); 
    if(status==0U)
    {
        // temp = temp & (~(0x00000001U<<13U));
        temp = temp & (0xffffdfffU);
    }
    else
    {
        // temp = temp | (0x00000001U<<13U);    
        temp = temp | (0x00002000U); 
    }
    __raw_writel(temp,REGGPIO0+GPIO0_DATA_L);
}

/**
函數名：    set_ADC_CONVS
函數功能：  设置ADC_CONVS的输出值
輸入：      status： 输出的状态；0--低；1--高
輸出：      无
**/
void set_ADC_CONVS(unsigned char status)
{
    unsigned int temp=0U;
    temp=__raw_readl(REGGPIO4+GPIO4_DATA_H);
    temp = temp | ((0x00000001U<<(2U+16U))); 
    if(status==0U)
    {
        // temp = temp & (~(0x00000001U<<2U));
        temp = temp & (0xfffffffbU);
    }
    else
    {
        // temp = temp | (0x00000001U<<2U);
        temp = temp | (0x00000004U);

    }
    __raw_writel(temp,REGGPIO4+GPIO4_DATA_H);
}

/**
函數名：    set_ADC_M0
函數功能：  设置ADC_M0的输出值
輸入：      status： 输出的状态；0--低；1--高
輸出：      无
**/
void set_ADC_M0(unsigned char status)
{
    unsigned int temp=0U;
    temp=__raw_readl(REGGPIO4+GPIO4_DATA_H);
    temp = temp | ((0x00000001U<<(9U+16U))); 
    if(status==0U)
    {
        // temp = temp & (~(0x00000001U<<9U));
        temp = temp & (0xfffffdffU);
    }
    else
    {
        // temp = temp | (0x00000001U<<9U);
        temp = temp | (0x00000200U);

    }
    __raw_writel(temp,REGGPIO4+GPIO4_DATA_H);
}

/**
函數名：    set_ADC_M1
函數功能：  设置ADC_M1的输出值
輸入：      status： 输出的状态；0--低；1--高
輸出：      无
**/
void set_ADC_M1(unsigned char status)
{
    unsigned int temp=0U;
    temp=__raw_readl(REGGPIO4+GPIO4_DATA_H);
    temp = temp | ((0x00000001U<<(7U+16U))); 
    if(status==0U)
    {
        // temp = temp & (~(0x00000001U<<7U));
        temp = temp & (0xffffff7fU);
    }
    else
    {
        // temp = temp | (0x00000001U<<7U);
        temp = temp | (0x00000080U);
    }
    __raw_writel(temp,REGGPIO4+GPIO4_DATA_H);
}

/**
函數名：    set_ADC_A0
函數功能：  设置ADC_A0的输出值
輸入：      status： 输出的状态；0--低；1--高
輸出：      无
**/
void set_ADC_A0(unsigned char status)
{
    unsigned int temp=0U;
    temp=__raw_readl(REGGPIO4+GPIO4_DATA_H);
    temp |=  0xffff0000U;
    if(status==0U)
    {
        // temp = temp & (~(0x00000001U<<3U));
        temp = temp & (0xfffffff7U);
    }
    else
    {
        // temp = temp | (0x00000001U<<3U);    
        temp = temp | (0x00000008U); 
    }
    __raw_writel(temp,REGGPIO4+GPIO4_DATA_H);
}

/**
函數名：    get_ADC_DATA_A0
函數功能：  获取ADC的A0引脚的值
輸入：      无 
輸出：      获取的状态；0--低；1--高
**/
unsigned char get_ADC_DATA_A0(void)
{
    unsigned int temp=0U;
    temp=__raw_readl(REGGPIO0+GPIO0_EXT_PORT);
    return ((temp>>21U) & 0x00000001U);
}

/**
函數名：    get_ADC_DATA_B0
函數功能：  获取ADC的B0引脚的值
輸入：      无 
輸出：      获取的状态；0--低；1--高
**/
unsigned char get_ADC_DATA_B0(void)
{
    unsigned int temp=0U;
    temp=__raw_readl(REGGPIO4+GPIO4_EXT_PORT);
    return ((temp>>24U) & 0x00000001U);
}

/**
函數名：    get_ADC_BUSY
函數功能：  获取ADC的BUSY引脚的值
輸入：      无 
輸出：      获取的状态；0--低；1--高
**/
unsigned char get_ADC_BUSY(void)
{
    unsigned int temp=0U;
    temp=__raw_readl(REGGPIO0+GPIO0_EXT_PORT);
    return ((temp>>23U) & 0x00000001U);
}

/**
  * 函数名称    void ADC_init(void)
  * 函数功能    ads8361 adc采集模块引脚初始化
  * 输入参数    way:采集几路adc
  * 函数返回值  无
  */
void ADC_init(unsigned char way)
{
    int fd;
    unsigned int time_cnt=0;
    unsigned int temp=0;


    /* 打开 /dev/mem 设备*/
    fd = open("/dev/mem", O_RDWR | O_SYNC);
    if (fd == -1) 
    {
        return ;
    }
    /* 映射 GPIO 寄存器到内存*/
    PMU_GRF_GPIO0 = (volatile unsigned int *)mmap(NULL, 0X1000, PROT_READ | PROT_WRITE, MAP_SHARED, fd, PMU_GRF_GPIO0_BASEADDR);
    if (PMU_GRF_GPIO0 == MAP_FAILED) 
    {
        close(fd);
        return ;
    }
    PMU_GRF_GPIO4 = (volatile unsigned int *)mmap(NULL, 0X1000, PROT_READ | PROT_WRITE, MAP_SHARED, fd, PMU_GRF_GPIO4_BASEADDR);
    if (PMU_GRF_GPIO4 == MAP_FAILED) 
    {
        close(fd);
        return ;
    }
    REGGPIO0 = (volatile unsigned int *)mmap(NULL,  0X1000, PROT_READ | PROT_WRITE, MAP_SHARED, fd, GPIO0_REG_BASEADDR);
    if (REGGPIO0 == MAP_FAILED) 
    {
        close(fd);
        return ;
    }
    REGGPIO4 = (volatile unsigned int *)mmap(NULL,  0X1000, PROT_READ | PROT_WRITE, MAP_SHARED, fd, GPIO4_REG_BASEADDR);
    if (REGGPIO4 == MAP_FAILED) 
    {
        close(fd);
        return ;
    }
    ADC_GPIO_Init();

    gpio_init(ADC_collect,ADC_CLOCK);
    gpio_init(ADC_collect,ADC_DATA_A);
    gpio_init(ADC_collect,ADC_DATA_B);
    gpio_init(ADC_collect,ADC_BUSY);
    gpio_init(ADC_collect,M0);
    gpio_init(ADC_collect,M1);
    gpio_init(ADC_collect,A0);
    gpio_init(ADC_collect,ADC_CONVST);

    set_ADC_CLOCK(0);
    set_ADC_CONVS(0);

    if(way==2U)
    {
        set_ADC_M0(0);
        set_ADC_M1(0);
    }
    else
    {
        set_ADC_M0(1);
        set_ADC_M1(0);
    }
}

/**
  * 函数名称    void ADC_collection2(void)
  * 函数功能    ADC采集功能，2路ADC采集功能(将采集到的4路ADC电压值放在voltage_A1,voltage_B1;)
  * 输入参数    无
  * 函数返回值  无
  */
void ADC_collection2(void)
{
    unsigned short data[2]={0U,0U};
    unsigned char i,j;

    set_ADC_CLOCK(1);
    set_ADC_A0(0);
    set_ADC_CONVS(1);
    // delay_ns(1);
    set_ADC_CLOCK(0);
    // delay_ns(1);

    set_ADC_CLOCK(1);
    // delay_ns(1);
    set_ADC_CLOCK(0);
    // delay_ns(1);
    set_ADC_CLOCK(1);
    // delay_ns(1);
    set_ADC_CLOCK(0);
    // delay_ns(1);

    for(i=0U;i<16U;i++)
    {
        data[0] <<= 1;
        data[1] <<= 1;
        set_ADC_CLOCK(1);
        // delay_ns(1);
        set_ADC_CLOCK(0);
        if(get_ADC_DATA_A0()==1)
        {
            data[0]++;
        }
        if(get_ADC_DATA_B0()==1)
        {
            data[1]++;
        }
        // delay_ns(1);
    }

    set_ADC_CLOCK(1);
    // delay_ns(1);
    set_ADC_CLOCK(0);
    // delay_ns(1);
    set_ADC_CLOCK(1);
    // delay_ns(1);
    set_ADC_CLOCK(0);
    // delay_ns(1);

    while(get_ADC_BUSY()==1)
    {
        ;
    }
    set_ADC_CONVS(0);

    voltage_A1=jisuan(data[0]);//需要优化
    voltage_B1=jisuan(data[1]);//需要优化

    return;
}

4、总结

这种操作方法目前是接触到驱动开发的操作IO最快的方法了。欢迎大佬留言指导！！！

还有，并不是所有寄存器都可以操作的，在内核上配置的SPI节点，在应用层可以正常使用的，但对其进行寄存器操作，发现不可控。对于这点宝子们先用下面的指令试试寄存器可以控制不，省的写了半天代码，最后是配置问题导致不能用，那可是要命的。

最后，补充一下操作指令：

/* 应用层操作IO */
cd /sys/class/gpio                                          查看gpio设置，文件，配置
echo 149 > export           	                            将相应的gpio引脚从内核层导入到用户层
echo "in" > direction   echo "out" > direction          	设置gpio的输入/输出方向
cat value           	                                    获取或者控制gpio的状态
echo 1 > value  echo 0 > value         	                    设置输出高电平/输出低电平

/* 直接通过寄存器操作IO */
io -4 -r 寄存器地址                                         通过指令读取寄存器（例：io -4 -r  0xfdd60000）
io -4 -w 寄存器地址 数据                                    通过指令设置寄存器（例：io -4 -w 0xfdd60000 0x11111111）

团子椰汁
关注
使用mmap读写开发板寄存器地址
SYLAS_LINUX的博客
10-22 1546
准备数据： 需要访问的寄存器的物理地址，访问的内存大小。 #include #include #include #include #include #define I2C_BASE 0x1E78A000 #define MAP_SIZE 0x1000 #if 0 #define MAP_SIZE 4096UL #define MAP_MASK (MAP_SIZE-1
mmap函数用法及示例程序
冰淇淋色的天空
01-19 2763
该函数主要有三个用途： 1.将一个普通文件映射到内存中，通常在需要对文件进行频繁读写时使用，这样用内存读写取代I/O读写，以获得较高的性能； 2.将特殊文件进行匿名内存映射，可以为关联进程提供共享内存空间； 3.为无关联的进程提供共享内存空间，一般也是将一个普通文件映射到内存中。   头文件: 　　#include 　　#include 原型: void *mmap(void
mmap学习笔记
zyc262503的专栏
08-21 520
<br />最近遇到个问题，需要写个测试程序，从用户态读取DM365里寄存器的数据。有两个方案：<br />1.自己写个驱动，提供个ioctl的接口，提供读取寄存器数据的功能<br />2.通过mmap（），读取寄存器内容<br />方案一太过麻烦，本身需要的只是个小的测试程序，实现驱动工作量太大了，所以采用方案2.<br />关于mmap的内容网上已经有很多了，这里进行下大概的介绍：<br /> <br />头文件:<br />　　<unistd.h><br />　　<sys/mman.h><br />　
使用mmap函数查看内存/寄存器
08-07
使用mmap函数查看内存/寄存器 因为开发板没有装gdb,所以用这个来代替查看物理内存/寄存器等. 注意mmap是基于页对齐映射的.所以地址必须是4k的倍数.
MSPOC linux下mmap操作gpio
hanhailong0525的博客
08-09 1028
mmap函数可以把物理地址映射到用户空间，对映射到用户空间的地址读写即可完成相应物理空间的读写操作。在mspoc，zynq中pl侧经常会在axi总线线上挂载许多自定义的ip，用此函数可以省去内核驱动得开发直接操作自定义ip的寄存器。当然也可对片内外设用同样的方式操作，下面就使用mmap实现MIO（GPIO）的操作。...
在Linux用户层使用MMAP对寄存器进行读写
我不姓周，不唱朋友
03-23 3779
0. 前言 最近需要在嵌入式系统上调试驱动程序，需要在用户态下频繁读取ARM的寄存器的值。 为了方便测试，发现可以在用户态下，通过mmap函数将设备节点/dev/mem进行映射，实现在用户态下将物理地址映射到虚拟地址，并通过对虚拟地址的修改来实现寄存器的修改。 1. 原理 1.1 /dev/mem设备节点 简单一点说，/dev/mem是Linux系统下的物理内存的全镜像，可通过该节点实现对物理内存的访问。 一般用于在嵌入式中以用户态形式直接访问寄存器/物理IO设备等。 通常用法是open这个设备节点文件，然
linux下使用mmap控制GPIO
chenben的专栏
03-18 2613
linux下使用mmap控制GPIO 原文地址：  http://mikenoodle.blog.163.com/blog/static/1133352200861274159875/   如果没有/dev/mem,则执行 mknod /dev/mem c 1 1 编译下面的代码   #include #include #include
mmap操作arm寄存器
zailushangha的专栏
02-25 1545
#include   #include   #include   #include  #include  #include  #define GPIO_CTL_BASE 0x56000000  #define rGPBCON 0x10  #define rGPBDAT 0x14  #define rGPBUP 0x18 #define rGPGCON 0x60 #de
Linux系统 mmap 存储映射
tugouxp的专栏
04-23 1802
括号中表示预期行为，括号外部的表示在LINUX系统中的实际行为，比如组合SHARED/EXEC的读行为，对于一个可执行的共享地址来说，没有给与PROT_READ属性，预期当然不可读，但是由于CPU执行上面的代码，必须要进行读操作，而实际的硬件架构和及并没有区分执行读和其它方式的读，所以，实际上对于这样的内存，仍然是可读的。从上图中可以看到，这段匿名区域（可能是MMAP区域，现在的MALLOC都用MMAP实现）地址是向下增长的，像栈一样，就像前面提到的第二种情况，这是在哪里控制的呢？
Linux内存管理-详解mmap原理
Linux高级开发的博客
02-12 547
1. 一句话概括mmap mmap的作用，在应用这一层，是让你把文件的某一段，当作内存一样来访问。将文件映射到物理内存，将进程虚拟空间映射到那块内存。 这样，进程不仅能像访问内存一样读写文件，多个进程映射同一文件，还能保证虚拟空间映射到同一块物理内存，达到内存共享的作用。 2.虚拟内存？虚拟空间？ 其实是一个概念，前一篇对于这个词没有确切的定义，现在定义一下： 虚拟空间就是进程看到的所有地址组成的空间，虚拟空间是某个进程对分配给它的所有物理地址（已经分配的和将会分配的）的重新映射。 而虚拟...
Linux在应用层读写寄存器的方法及实现实例
09-15
主要介绍了Linux在应用层读写寄存器的方法及实现实例的相关资料,需要的朋友可以参考下
应用层读写ARM底层寄存器
01-10
为了方便在应用层调试底层寄存器，将该文件放进内核源码任意目录下，修改对应Makefile编译进内核之后就可以在应用层对ARM底层寄存器进行读写。使用方法在源码内有标注
RK3399平台开发系列讲解（内核调试篇）2.12、ioremap及mmap映射物理地址操作寄存器
内核笔记
02-26 2721
Linux 内核中操作寄存器 Linux 应用层操作寄存器 实验
驱动开发系列07 - 内存映射和DMA
最新发布
GPU全栈博主-程序哥
07-20 647
本文深入探讨 Linux 内存管理子系统，重点介绍对设备驱动程序编写者有用的技术。许多类型的驱动程序编程都需要对虚拟内存子系统的工作原理有一定的了解；当我们编写一些更复杂、对性能要求更高的驱动时，本文所涉及的内容就会派上用场。虚拟内存子系统也是 Linux 核心内核中非常有趣的一部分，因此值得一看。本文内容分为三节：第一节涉及 mmap 系统调用的实现，该调用允许将设备内存直接映射到用户进程的地址空间。将设备内存直接映射到用户进程的地址空间。
Linux 操作系统原理 — 内存管理 — 虚拟地址空间
烟云的计算
02-25 1747
相应的，Linux 和 CPU 软硬件结合提供了 2 级保护机制，只有 Kernel Space 的代码可以使用 Ring0 的 CPU 指令，而 User Space 的代码只可以使用 Ring3 的 CPU 指令。在 Kernel 中用于对虚拟地址进行寻址的数据结构称为 Kernel Page Table（内核页表），包括：页表目录、页表、页表项、属性标记等组成部分，可以将每个页表项（Page Table Entry）标记为只读、可写、只执行等，以控制内存的访问权限和缓存行为。
Linux在应用层读写寄存器
qq_40629752的博客
09-24 1418
先说结论：在应用层可以通过操作/dev/mem设备文件，以及mmap函数，将寄存器的地址映射到用户空间，然后直接在应用层对寄存器进行操作。 1、dev/mem 设备文件 该设备文件是物理内存的全映像，通过分析dev/mem设备驱动可以知道，通过这个设备文件可以映射整个处理器的地址空间，而不单单是内存。这里的地址空间指的是处理器总线上的全部可寻址空间。除了内存，还有外设IO空间。也就是说通过/dev/mem可以映射0-0xFFFFFFFF的全部物理地址（这个物理地址是真是有效的，处理器访问这个物理地址
嵌入式Linux 使用MMAP映射GPIO
Zengzhiwei的博客
04-22 770
嵌入式Linux 使用MMAP映射GPIO #include <stdio.h> #include <fcntl.h> #include <sys/mman.h> #include <unistd.h> #include <stdint.h> #include <errno.h> #define GPIO_LED_BASE_ADDR 0x01c20800 #define MAP_SIZE 4096UL #define MA
mmap操作荔枝派gpio v3s Linux
03-12 548
1.预备知识 https://baike.baidu.com/item/mmap/1322217?fr=aladdin 大家直接看百度百科，比较清楚了。 2.代码 gpio.c #include "gpio.h" unsigned int fd; PIO_Map *PIO = NULL; unsigned int *gpio_map; unsigned int a...
龙芯应用层mmap映射寄存器地址
大猫的博客
08-14 1459
龙芯应用层mmap映射寄存器 以操作龙芯派为例，龙芯派2代 GPIO39为峰鸣器控制引脚 linux系统下通过info命令查看mmap使用： info mmap #include <stdio.h> #include <stdlib.h> #include <time.h> #include <unistd.h> #include <fcntl.h> #include <unistd.h> #include <sys/m
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值