AI 助理
备案控制台
开发者社区 龙蜥操作系统 文章 正文

zynq操作系统： Linux驱动开发Gpio中断篇

2023-01-16 1194
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Linux内核中有一套GPIO框架，管理和控制芯片上的GPIO管教，包括配置输入输出，配置电平高低（输出）和获取电平高低（输入），中断管理。只需要通过读取/sys/class/gpio/gpioN/value的值来获取中断。当然也不是简单的read，而是通过epoll、poll、select等这些IO复用函数来控制，对于epoll或者poll，需要监听的事件是EPOLLPRI或POLLPRI，而不是EPOLLIN或POLLIN，对于select，需要将文件描述符放在exceptfds中，而且文件描述符被触发时需要通过调用read读取数据，还要通过lseek将文件流指针置回文件开头。

简介

 Linux内核中有一套GPIO框架，管理和控制芯片上的GPIO管教，包括配置输入输出，配置电平高低（输出）和获取电平高低（输入），中断管理。只需要通过读取/sys/class/gpio/gpioN/value的值来获取中断。当然也不是简单的read，而是通过epoll、poll、select等这些IO复用函数来控制，对于epoll或者poll，需要监听的事件是EPOLLPRI或POLLPRI，而不是EPOLLIN或POLLIN，对于select，需要将文件描述符放在exceptfds中，而且文件描述符被触发时需要通过调用read读取数据，还要通过lseek将文件流指针置回文件开头。

（另，网上说实际测试，使用epoll或者poll时监听事件（POLLIN | POLLET）也是可以的。）

命令行的使用

进入 /sys/class/gpio目录

假如你想操作EMIO这个引脚，那么根据计算，比如内核启动会生成gpio906这个目录，emio的第一个就相当于906+54＝960也就是gpio960会是我们用来判断的gpio引脚

执行命令：

echo 960 > export //暴露接口
cd gpio960
echo out > direction //设置方向
echo 1 > value //设置输出电平值 0低 1高

写代码就可以通过配置来暴露了

测试代码

下面给出整个bram通过gpio中断来实现数据读写的驱动以及测试demo：（好像还是有点简陋）

驱动c文件 gpioapp.c
#include <stdio.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <poll.h>
#include "gpioapp.h"
#define XPAR_BRAM_0_BASEADDR 0x40000000
#define XPAR_BRAM_1_BASEADDR 0x42000000
#define XPAR_BRAM_2_BASEADDR 0x44000000
#define XPAR_BRAM_3_BASEADDR 0x46000000
#define XPAR_BRAM_4_BASEADDR 0x48000000
#define XPAR_BRAM_5_BASEADDR 0x4A000000
#define XPAR_BRAM_6_BASEADDR 0x4C000000
#define XPAR_BRAM_7_BASEADDR 0x4E000000
#define XPAR_BRAM_8_BASEADDR 0x50000000
#define DATA_LEN    1024
volatile unsigned int *map_base0;
volatile unsigned int *map_base1;
volatile unsigned int *map_base2;
volatile unsigned int *map_base3;
volatile unsigned int *map_base4;
volatile unsigned int *map_base5;
volatile unsigned int *map_base6;
volatile unsigned int *map_base7;
volatile unsigned int *map_base8;
int gpio_fd;
int gpio_fd1;
int gpio_fd2;
int gpio_fd3;
int gpio_fd4;
int gpio_fd5;
int gpio_fd6;
int gpio_fd7;
static int gpio_export(int pin);
static int gpio_unexport(int pin);
static int gpio_direction(int pin, int dir);
static int gpio_write(int pin, int value);
static int gpio_read(int pin);
static int gpio_edge(int pin, int edge);
void XBram_Out32(unsigned int * Addr, unsigned int Value)
{
  volatile unsigned int *LocalAddr = (volatile unsigned int *)Addr;
  *LocalAddr = Value;
}
 unsigned int * XBram_In32(unsigned int * Addr)
{
  return *(volatile unsigned int *) Addr;
}
static int gpio_export(int pin)  
{  
    char buffer[64];  
    int len;  
    int fd;  
    fd = open("/sys/class/gpio/export", O_WRONLY);  
    if (fd < 0) 
    {  
        MSG("Failed to open export for writing!\n");  
        return(-1);  
    }  
    len = snprintf(buffer, sizeof(buffer), "%d", pin);  
    printf("%s,%d,%d\n",buffer,sizeof(buffer),len);
    if (write(fd, buffer, len) < 0) 
    {  
        MSG("Failed to export gpio!");  
        return -1;  
    }  
    close(fd);  
    return 0;  
}  
static int gpio_unexport(int pin)  
{  
    char buffer[64];  
    int len;  
    int fd;  
    fd = open("/sys/class/gpio/unexport", O_WRONLY);  
    if (fd < 0) 
    {  
        MSG("Failed to open unexport for writing!\n");  
        return -1;  
    }  
    len = snprintf(buffer, sizeof(buffer), "%d", pin);  
    if (write(fd, buffer, len) < 0) 
    {  
        MSG("Failed to unexport gpio!");  
        return -1;  
    }  
    close(fd);  
    return 0;  
} 
//dir: 0输入, 1输出
static int gpio_direction(int pin, int dir)  
{  
    static const char dir_str[] = "in\0out";  
    char path[64];  
    int fd;  
    snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d/direction", pin);  
    fd = open(path, O_WRONLY);  
    if (fd < 0) 
    {  
        MSG("Failed to open gpio direction for writing!\n");  
        return -1;  
    }  
    if (write(fd, &dir_str[dir == 0 ? 0 : 3], dir == 0 ? 2 : 3) < 0) 
    {  
        MSG("Failed to set direction!\n");  
        return -1;  
    }  
    close(fd);  
    return 0;  
}  
//value: 0-->LOW, 1-->HIGH
static int gpio_write(int pin, int value)  
{  
    static const char values_str[] = "01";  
    char path[64];  
    int fd;  
    snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d/value", pin);  
    fd = open(path, O_WRONLY);  
    if (fd < 0) 
    {  
        MSG("Failed to open gpio value for writing!\n");  
        return -1;  
    }  
    if (write(fd, &values_str[value == 0 ? 0 : 1], 1) < 0) 
    {  
        MSG("Failed to write value!\n");  
        return -1;  
    }  
    close(fd);  
    return 0;  
}
static int gpio_read(int pin)  
{  
    char path[64];  
    char value_str[3];  
    int fd;  
    snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d/value", pin);  
    fd = open(path, O_RDONLY);  
    if (fd < 0) 
    {  
        MSG("Failed to open gpio value for reading!\n");  
        return -1;  
    }  
    if (read(fd, value_str, 3) < 0)
    {  
        MSG("Failed to read value!\n");  
        return -1;  
    }  
    close(fd);  
    return (atoi(value_str));
}  
// none表示引脚为输入，不是中断引脚
// rising表示引脚为中断输入，上升沿触发
// falling表示引脚为中断输入，下降沿触发
// both表示引脚为中断输入，边沿触发
// 0-->none, 1-->rising, 2-->falling, 3-->both
static int gpio_edge(int pin, int edge)
{
const char dir_str[] = "none\0rising\0falling\0both"; 
char ptr;
char path[64];  
    int fd; 
switch(edge)
{
    case 0:
        ptr = 0;
        break;
    case 1:
        ptr = 5;
        break;
    case 2:
        ptr = 12;
        break;
    case 3:
        ptr = 20;
        break;
    default:
        ptr = 0;
} 
    snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d/edge", pin);  
    fd = open(path, O_WRONLY);  
    if (fd < 0) 
    {  
        MSG("Failed to open gpio edge for writing!\n");  
        return -1;  
    }  
    if (write(fd, &dir_str[ptr], strlen(&dir_str[ptr])) < 0) 
    {  
        MSG("Failed to set edge!\n");  
        return -1;  
    }  
    close(fd);  
    return 0;  
}
int GpioInit()
{
    gpio_unexport(958);
    gpio_unexport(959);
    gpio_unexport(960);
    gpio_unexport(961);
    gpio_unexport(962);
    gpio_unexport(963);
    gpio_unexport(964);
    gpio_unexport(965);
    /*********************rx handle**************/ 
    gpio_export(958);
    gpio_direction(958, 0);//
    gpio_edge(958,1);
    gpio_fd = open("/sys/class/gpio/gpio958/value",O_RDONLY);
    if(gpio_fd < 0)
    {
        MSG("Failed to open value!\n");  
        return -1;  
    }
    else
    printf("success open958\r\n");
    gpio_export(959);
    gpio_direction(959, 0);//
    gpio_edge(959,1);
    gpio_fd1 = open("/sys/class/gpio/gpio959/value",O_RDONLY);
    if(gpio_fd1 < 0)
    {
        MSG("Failed to open value1!\n");  
        return -1;  
    }
    else
    printf("success open959\r\n");
    gpio_export(960);
    gpio_direction(960, 0);//
    gpio_edge(960,1);
    gpio_fd2 = open("/sys/class/gpio/gpio960/value",O_RDONLY);
    if(gpio_fd2 < 0)
    {
        MSG("Failed to open value2!\n");  
        return -1;  
    }
    else
    printf("success open960\r\n");
    gpio_export(961);
    gpio_direction(961, 0);//
    gpio_edge(961,1);
    gpio_fd3 = open("/sys/class/gpio/gpio961/value",O_RDONLY);
    if(gpio_fd3 < 0)
    {
        MSG("Failed to open value3!\n");  
        return -1;  
    }
    else
    printf("success open961\r\n");
    gpio_export(962);
    gpio_direction(962, 0);//
    gpio_edge(962,1);
    gpio_fd4 = open("/sys/class/gpio/gpio962/value",O_RDONLY);
    if(gpio_fd4 < 0)
    {
        MSG("Failed to open value4!\n");  
        return -1;  
    }
    else
    printf("success open962\r\n");
    gpio_export(963);
    gpio_direction(963, 0);//
    gpio_edge(963,1);
    gpio_fd5 = open("/sys/class/gpio/gpio963/value",O_RDONLY);
    if(gpio_fd5 < 0)
    {
        MSG("Failed to open value5!\n");  
        return -1;  
    }
    else
    printf("success open963\r\n");
    gpio_export(964);
    gpio_direction(964, 0);//
    gpio_edge(964,1);
    gpio_fd6 = open("/sys/class/gpio/gpio964/value",O_RDONLY);
    if(gpio_fd6 < 0)
    {
        MSG("Failed to open value6!\n");  
        return -1;  
    }
    else
    printf("success open964\r\n");
    gpio_export(965);
    gpio_direction(965, 0);//
    gpio_edge(965,1);
    gpio_fd7 = open("/sys/class/gpio/gpio965/value",O_RDONLY);
    if(gpio_fd7 < 0)
    {
        MSG("Failed to open value7!\n");  
        return -1;  
    }
    else
    printf("success open965\r\n");
}
int BramInit()
{
/********************BRAMinit****************************************************/
    GpioInit();
    int fd = open("/dev/mem", O_RDWR | O_SYNC);
    if (fd < 0) {
        printf("can not open /dev/mem \n");
        return (-1);
    }   
    printf("/dev/mem is open \n");
    /*
    mmap（阿巴阿巴阿巴）
    第二个参数表示内存映射的大小、
    第三个参数是一个 flag标志， PROT_READ | PROT_WRITE 的组合表示映射的内存空间是可读可写的、
    第四个参数MAP_SHARED、
    第五个参数表示文件描述符 fd。
     mmap 函数的返回值就等于映射之后得到的实际地址
    */
    map_base0 = mmap(NULL, BRAM_MAX_SIZE * 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, XPAR_BRAM_0_BASEADDR);
    map_base1 = mmap(NULL, BRAM_MAX_SIZE * 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, XPAR_BRAM_1_BASEADDR);
    map_base2 = mmap(NULL, BRAM_MAX_SIZE * 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, XPAR_BRAM_2_BASEADDR);
    map_base3 = mmap(NULL, BRAM_MAX_SIZE * 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, XPAR_BRAM_3_BASEADDR);
    map_base4 = mmap(NULL, BRAM_MAX_SIZE * 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, XPAR_BRAM_4_BASEADDR);
    map_base5 = mmap(NULL, BRAM_MAX_SIZE * 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, XPAR_BRAM_5_BASEADDR);
    map_base6 = mmap(NULL, BRAM_MAX_SIZE * 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, XPAR_BRAM_6_BASEADDR);
    map_base7 = mmap(NULL, BRAM_MAX_SIZE * 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, XPAR_BRAM_7_BASEADDR);
    map_base8 = mmap(NULL, BRAM_MAX_SIZE * 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, XPAR_BRAM_8_BASEADDR);
    if (map_base0 == 0 || map_base1 == 0|| map_base2 == 0|| map_base3 == 0|| map_base4 == 0||
                          map_base5 == 0|| map_base6 == 0|| map_base7 == 0|| map_base8 == 0 ) { 
        printf("NULL pointer\n");
    }   
    else {
        printf("mmap successful\n");
    }   
     close(fd);
     return 0;
}
 int BramExit()
{
  munmap(map_base0, DATA_LEN);
  munmap(map_base1, DATA_LEN);
  munmap(map_base2, DATA_LEN);
  munmap(map_base3, DATA_LEN);
  munmap(map_base4, DATA_LEN);
  munmap(map_base5, DATA_LEN);
  munmap(map_base6, DATA_LEN);
  munmap(map_base7, DATA_LEN);
}
/*******************************************************
 * 
 * 
 * 
 * 
 * 
 * *****************************************************/
 int SendBram0(unsigned char *sbuffer,unsigned int length)
{
    int m,n;
    int Status;
    int i;
    unsigned int addr;
    unsigned int content;
  unsigned char *bufferrptr;
    bufferrptr = (unsigned char *)map_base2;
    if(sbuffer == NULL)
    {
        return -1;
    }
    m = length/BRAM_MAX_SIZE;
    n = length%BRAM_MAX_SIZE;
    for(i = 0;i < m;i++)
    {
        memcpy(bufferrptr,&sbuffer[i*BRAM_MAX_SIZE],BRAM_MAX_SIZE);
        XBram_Out32(map_base0+1,BRAM_MAX_SIZE);
        XBram_Out32(map_base0+2,0x1);
        usleep(15);
        XBram_Out32(map_base0+2,0);//清除发送中断,实际地址加8
    }
    memcpy(bufferrptr,&sbuffer[m*BRAM_MAX_SIZE],n);
    XBram_Out32(map_base0+1,n);
    XBram_Out32(map_base0+2,0x1);
    usleep(15);
    XBram_Out32(map_base0+2,0);//清除发送中断,实际地址加8
    return 0;
}
int SendBram1(unsigned char *sbuffer,unsigned int length)
{
    int m,n;
    int Status;
    int i;
    unsigned int addr;
    unsigned int content;
  unsigned char *bufferrptr;
    bufferrptr = (unsigned char *)map_base3;
    if(sbuffer == NULL)
    {
        return -1;
    }
    m = length/BRAM_MAX_SIZE;
    n = length%BRAM_MAX_SIZE;
    for(i = 0;i < m;i++)
    {
        memcpy(bufferrptr,&sbuffer[i*BRAM_MAX_SIZE],BRAM_MAX_SIZE);
        XBram_Out32(map_base0+5,BRAM_MAX_SIZE);
        XBram_Out32(map_base0+6,0x1);
        usleep(15);
        XBram_Out32(map_base0+6,0);//清除发送中断,实际地址加24
    }
    memcpy(bufferrptr,&sbuffer[m*BRAM_MAX_SIZE],n);
    XBram_Out32(map_base0+5,n);
    XBram_Out32(map_base0+6,0x1);
    usleep(15);
    XBram_Out32(map_base0+6,0);//清除发送中断,实际地址加24
    return 0;
}
int SendBram2(unsigned char *sbuffer,unsigned int length)
{
    int m,n;
    int Status;
    int i;
    unsigned int addr;
    unsigned int content;
  unsigned char *bufferrptr;
    bufferrptr = (unsigned char *)map_base5;
    if(sbuffer == NULL)
    {
        return -1;
    }
    m = length/BRAM_MAX_SIZE;
    n = length%BRAM_MAX_SIZE;
    for(i = 0;i < m;i++)
    {
        memcpy(bufferrptr,&sbuffer[i*BRAM_MAX_SIZE],BRAM_MAX_SIZE);
        XBram_Out32(map_base0+9,BRAM_MAX_SIZE);
        XBram_Out32(map_base0+10,0x1);
        usleep(15);
        XBram_Out32(map_base0+10,0);//清除发送中断,实际地址加40
    }
    memcpy(bufferrptr,&sbuffer[m*BRAM_MAX_SIZE],n);
    XBram_Out32(map_base0+9,n);
    XBram_Out32(map_base0+10,0x1);
    usleep(15);
    XBram_Out32(map_base0+10,0);//清除发送中断,实际地址加40
    return 0;
}
int SendBram3(unsigned char *sbuffer,unsigned int length)
{
    int m,n;
    int Status;
    int i;
    unsigned int addr;
    unsigned int content;
  unsigned char *bufferrptr;
    bufferrptr = (unsigned char *)map_base7;
    if(sbuffer == NULL)
    {
        return -1;
    }
    m = length/BRAM_MAX_SIZE;
    n = length%BRAM_MAX_SIZE;
    for(i = 0;i < m;i++)
    {
        memcpy(bufferrptr,&sbuffer[i*BRAM_MAX_SIZE],BRAM_MAX_SIZE);
        XBram_Out32(map_base0+13,BRAM_MAX_SIZE);
        XBram_Out32(map_base0+14,0x1);
        usleep(15);
        XBram_Out32(map_base0+14,0);
    }
    memcpy(bufferrptr,&sbuffer[m*BRAM_MAX_SIZE],n);
    XBram_Out32(map_base0+13,n);
    XBram_Out32(map_base0+14,0x1);
    usleep(30);
    XBram_Out32(map_base0+14,0);
    return 0;
}
 int ReadBram0(unsigned char *rbuffer)
{
    int i;
    int Length;
    int Status;
    unsigned int addr;
    unsigned int content;
    Length = XBram_In32(map_base0+2);
    memcpy(rbuffer,(unsigned char*)map_base1,Length);
    XBram_Out32(map_base0,0x1);
    XBram_Out32(map_base0,0);//清除接收中断
    // XBram_Out32(map_base0+2,0);//清除发送中断,实际地址加8
    return Length;
}
int ReadBram1(unsigned char *rbuffer)
{
    int i;
    int Length;
    int Status;
    unsigned int addr;
    unsigned int content;
    Length = XBram_In32(map_base0+2+1);
    memcpy(rbuffer,(unsigned char*)map_base4,Length);
    XBram_Out32(map_base0+4,0x1);
    XBram_Out32(map_base0+4,0);//清除接收中断
    // XBram_Out32(map_base0+2+4,0);//清除发送中断,实际地址加8
    return Length;
}
int ReadBram2(unsigned char *rbuffer)
{
    int i;
    int Length;
    int Status;
    unsigned int addr;
    unsigned int content;
    Length = XBram_In32(map_base0+2+1+1);
    memcpy(rbuffer,(unsigned char*)map_base6,Length);
    XBram_Out32(map_base0+4+4,0x1);
    XBram_Out32(map_base0+4+4,0);//清除接收中断
    // XBram_Out32(map_base0+2+4+4,0);//清除发送中断,实际地址加8
    return Length;
}
int ReadBram3(unsigned char *rbuffer)
{
    int i;
    int Length;
    int Status;
    unsigned int addr;
    unsigned int content;
    Length = XBram_In32(map_base0+2+1+1+1);
    if(Length == 0)
    {
        XBram_Out32(map_base0+4+4+4,0x1);
        XBram_Out32(map_base0+4+4+4,0);//清除接收中断
      return 0;
    }
    memcpy(rbuffer,(unsigned char*)map_base8,Length);
    XBram_Out32(map_base0+4+4+4,0x1);
    XBram_Out32(map_base0+4+4+4,0);//清除接收中断
    // XBram_Out32(map_base0+2+4+4+4,0);//清除发送中断,实际地址加8
    return Length;
}
驱动头文件gpioapp.h
#include <stdio.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#define MSG(args...) printf(args) 
#define BRAM_MAX_SIZE    2048
#define DATA_LEN    1024
int GpioInit();
int BramInit();
int BramExit();
int SendBram0(unsigned char *sbuffer,unsigned int length);
int ReadBram0(unsigned char *rbuffer);
int SendBram1(unsigned char *sbuffer,unsigned int length);
int ReadBram1(unsigned char *rbuffer);
int SendBram2(unsigned char *sbuffer,unsigned int length);
int ReadBram2(unsigned char *rbuffer);
int SendBram3(unsigned char *sbuffer,unsigned int length);
int ReadBram3(unsigned char *rbuffer);
测试demo
#include <stdio.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <poll.h>
#include <pthread.h>
#include "gpioapp.h"
extern gpio_fd;
extern gpio_fd2;
extern gpio_fd4;
extern gpio_fd6;
static unsigned char rbuffer[BRAM_MAX_SIZE] = {0};
static unsigned char tbuffer[BRAM_MAX_SIZE] = {0};
// void *rapidio_taks_rec(void *arg)
// {
//     int ret = 0,i;
//     unsigned int rec_len = 0;
//     struct pollfd fds[1];
//     char buff[10];
//     static cnt = 0;
//     fds[0].fd = gpio_fd;
//     fds[0].events  = POLLPRI;
//     ret = read(gpio_fd,buff,10);
//     if( ret == -1 )
//         MSG("read\n");
//     while(1)
//     {
//       ret = poll(fds,1,-1);
//       if( ret == -1 )
//           MSG("poll\n");
//       if( fds[0].revents & POLLPRI)
//       {
//         ret = lseek(gpio_fd,0,SEEK_SET);
//         if( ret == -1 )
//             MSG("lseek\n");
//         ret = read(gpio_fd,buff,10);
//         if( ret == -1 )
//             MSG("read\n");
//         memset(rbuffer,0,BRAM_MAX_SIZE);
//         rec_len = ReadBram0(rbuffer);
//         cnt ++;
//         printf("\nrec_len = 0x%x,cnt = %d\n",rec_len,cnt);
//         printf("bram0 rx\n");
//          if(cnt == 3)
//          {
//              for(i = 0;i<256;i++)
//              {
//                  if(i%16 == 0)
//                  {
//                      printf("\n");
//                  }         
//                  printf("0x%02x ",rbuffer[i]);
//              }
//              printf("\n");
//          }
//          if(rec_len != BRAM_MAX_SIZE)
//          {
//              for(i = 0;i<rec_len;i++)
//              {
//                  if(i%16 == 0)
//                  {
//                      printf("\n");
//                  }   
//                  printf("0x%02x ",rbuffer[i]);
//              }
//              printf("\n");
//          }
//  SendBram0(rbuffer,rec_len);
//       }
//     else
//     printf("poll nothing--------------------------\n");
//    }
//    pthread_exit(0);
// }
// void *rapidio_taks_rec1(void *arg)
// {
//     int ret = 0,i;
//     unsigned int rec_len = 0;
//     struct pollfd fds[1];
//     char buff[10];
//     static cnt = 0;
//     fds[0].fd = gpio_fd2;
//     fds[0].events  = POLLPRI;
//     ret = read(gpio_fd2,buff,10);
//     if( ret == -1 )
//         MSG("read\n");
//     while(1)
//     {
//       ret = poll(fds,1,-1);
//       if( ret == -1 )
//           MSG("poll\n");
//       if( fds[0].revents & POLLPRI)
//       {
//         ret = lseek(gpio_fd2,0,SEEK_SET);
//         if( ret == -1 )
//             MSG("lseek\n");
//         ret = read(gpio_fd2,buff,10);
//         if( ret == -1 )
//             MSG("read\n");
//         memset(rbuffer,0,256);
//         rec_len = ReadBram1(rbuffer);
//         cnt ++;
//         printf("\nrec_len = 0x%x,cnt = %d\n",rec_len,cnt);
//         printf("bram1 rx\n");
//          for(i = 0;i<rec_len;i++)
//          {
//              if(i%16 == 0)
//              {
//                  printf("\n");
//              }
//              printf("0x%02x ",rbuffer[i]);
//          }
//          printf("\n");
//  SendBram1(rbuffer,rec_len);
//       }
//     else
//     printf("poll nothing--------------------------\n");
//    }
//    pthread_exit(0);
// }
// void *rapidio_taks_rec2(void *arg)
// {
//     int ret = 0,i;
//     unsigned int rec_len = 0;
//     struct pollfd fds[1];
//     char buff[10];
//     static cnt = 0;
//     fds[0].fd = gpio_fd4;
//     fds[0].events  = POLLPRI;
//     ret = read(gpio_fd4,buff,10);
//     if( ret == -1 )
//         MSG("read\n");
//     while(1)
//     {
//       ret = poll(fds,1,-1);
//       if( ret == -1 )
//           MSG("poll\n");
//       if( fds[0].revents & POLLPRI)
//       {
//         ret = lseek(gpio_fd4,0,SEEK_SET);
//         if( ret == -1 )
//             MSG("lseek\n");
//         ret = read(gpio_fd4,buff,10);
//         if( ret == -1 )
//             MSG("read\n");
//         memset(rbuffer,0,256);
//         rec_len = ReadBram2(rbuffer);
//         cnt ++;
//         printf("\nrec_len = 0x%x,cnt = %d\n",rec_len,cnt);
//         printf("bram2 rx\n");
//          for(i = 0;i<rec_len;i++)
//          {
//              if(i%16 == 0)
//              {
//                  printf("\n");
//              }
//              printf("0x%02x ",rbuffer[i]);
//          }
//          printf("\n");
//  SendBram2(rbuffer,rec_len);
//       }
//     else
//     printf("poll nothing--------------------------\n");
//    }
//    pthread_exit(0);
// }
void *rapidio_taks_rec3(void *arg)
{
    int ret = 0,i;
    unsigned int rec_len = 0;
    struct pollfd fds[1];
    char buff[10];
    static cnt = 0;
    unsigned int err_num = 0;
    unsigned int cou = 0;
    fds[0].fd = gpio_fd6;
    fds[0].events  = POLLPRI;
    ret = read(gpio_fd6,buff,10);
    if( ret == -1 )
        MSG("read\n");
    while(1)
    {
      ret = poll(fds,1,-1);
      if( ret == -1 )
          MSG("poll\n");
      if( fds[0].revents & POLLPRI)
      {
        ret = lseek(gpio_fd6,0,SEEK_SET);
        if( ret == -1 )
            MSG("lseek\n");
        ret = read(gpio_fd6,buff,10);
        if( ret == -1 )
            MSG("read\n");
        memset(rbuffer,0,2048);
        rec_len = ReadBram3(rbuffer);
        cnt ++;
        if(rec_len == 0)
     {
      printf("gkhy_debug : recv len error \n");
      continue;
     }
        if(rec_len > 1500)
     {
      printf("gkhy_debug : recv len error1500 \n");
      continue;
     }
        for(i=0;i<rec_len;i++)
  {
  if(rbuffer[i] != tbuffer[i])
  {
    // printf("khy_debug :tbuffer[%d] : 0x%x, rbuffer[%d] : 0x%x\n",i,tbuffer[i],i,rbuffer[i]);
    err_num++;
  }
  }   
        if(err_num != 0)
        {
            printf("gkhy_debug:err_num = %d\n",err_num);
            err_num = 0;
        }
  //if(cnt%50 == 0)
  //{
   //printf("\nrec_len = 0x%x,cnt = %d\n",rec_len,cnt);
  //}
        //printf("\nrec_len = 0x%x,cnt = %d\n",rec_len,cnt);
        // printf("bram3 rx\n");
        // for(i = 0;i<(rec_len);i++)
        // {
        //     if(i%16 == 0)
        //     {
        //         printf("\n");
        //     }
        //    printf("0x%02x ",rbuffer[i]);//注意大小端转换
        // }
        // printf("\n");
        // SendBram3(rbuffer,rec_len); 
      }
    else
    printf("poll nothing--------------------------\n");
   }
   pthread_exit(0);
}
// void *rapidio_taks_send(void *arg)
// {
//     int i;
//     unsigned char sbuffer[256] = {0};
//     for(i = 0;i < 256;i++)
//     {
//         sbuffer[i]=i+1;
//     }
//     while(1)
//     {
//         sleep(10);
//         //SendBram0(sbuffer,0x500); 
//     }
//    pthread_exit(0);
// }
// void *rapidio_taks_send1(void *arg)
// {
//     int i;
//     unsigned char sbuffer[256] = {0};
//     for(i = 0;i < 256;i++)
//     {
//         sbuffer[i]=i+1;
//     }
//     while(1)
//     {
//         sleep(10);
//         //SendBram1(sbuffer,0x100); 
//     }
//    pthread_exit(0);
// }
// void *rapidio_taks_send2(void *arg)
// {
//     int i;
//     unsigned char sbuffer[256] = {0};
//     for(i = 0;i < 256;i++)
//     {
//         sbuffer[i]=i+2;
//     }
//     while(1)
//     {
//         sleep(10);
//         //SendBram2(sbuffer,0x200); 
//     }
//    pthread_exit(0);
// }
void *rapidio_taks_send3(void *arg)
{
    while(1)
    {
        usleep(20000);
        SendBram3(tbuffer,375); 
    }
   pthread_exit(0);
}
int main(int argc, char **argv)
{
    int error;
    int ret;
    int i;
    pthread_t rapidio_sid;
    pthread_t rapidio_rid;
    pthread_t rapidio_sid1;
    pthread_t rapidio_rid1;
    pthread_t rapidio_sid2;
    pthread_t rapidio_rid2;
    pthread_t rapidio_sid3;
    pthread_t rapidio_rid3;
    printf("enter app --------\n");
    BramInit();
    for(i = 0;i < 1500;i++)
    {
        tbuffer[i]=i;
    }
    // error=pthread_create(&rapidio_rid, NULL, &rapidio_taks_rec,NULL);
    // if(error != 0)
    // {
    //     printf("pthreadrx_create fail\n");
    //     return -1;
    // }
    // error=pthread_create(&rapidio_sid, NULL, &rapidio_taks_send,NULL);
    // if(error != 0)
    // {
    //     printf("pthreadtx_create fail\n");
    //     return -1;
    // }
    // error=pthread_create(&rapidio_rid1, NULL, &rapidio_taks_rec1,NULL);
    // if(error != 0)
    // {
    //     printf("pthreadrx1_create fail\n");
    //     return -1;
    // }
    // error=pthread_create(&rapidio_sid1, NULL, &rapidio_taks_send1,NULL);
    // if(error != 0)
    // {
    //     printf("pthreadtx1_create fail\n");
    //     return -1;
    // }
    // error=pthread_create(&rapidio_rid2, NULL, &rapidio_taks_rec2,NULL);
    // if(error != 0)
    // {
    //     printf("pthreadrx2_create fail\n");
    //     return -1;
    // }
    // error=pthread_create(&rapidio_sid2, NULL, &rapidio_taks_send2,NULL);
    // if(error != 0)
    // {
    //     printf("pthreadtx2_create fail\n");
    //     return -1;
    // }
    error=pthread_create(&rapidio_rid3, NULL, &rapidio_taks_rec3,NULL);
    if(error != 0)
    {
        printf("pthreadrx3_create fail\n");
        return -1;
    }
    error=pthread_create(&rapidio_sid3, NULL, &rapidio_taks_send3,NULL);
    if(error != 0)
    {
        printf("pthreadtx3_create fail\n");
        return -1;
    }
    // pthread_detach(rapidio_rid);
    // pthread_detach(rapidio_sid);
    // pthread_detach(rapidio_rid1);
    // pthread_detach(rapidio_sid1);
    // pthread_detach(rapidio_rid2);
    // pthread_detach(rapidio_sid2);
    pthread_detach(rapidio_rid3);
    pthread_detach(rapidio_sid3);
    while(1)
    {
        sleep(10);
    }
    //BramExit();
    return 0;
}

IO控制代码

normal_mode
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>   //define O_WRONLY and O_RDONLY
void initGpio(int n)
{
    FILE * fp =fdopen("/sys/class/gpio/export","w");
    if (fp == NULL)
        perror("export open filed");
    else
        fprintf(fp,"%d",n);
    fclose(fp);
}   //create gpio file
void setGpioDirection(int n,char *direction)
{
    char path[100] = {0};
    sprintf(path,"/sys/class/gpio/gpio%d/direction",n);
    FILE * fp =fdopen(path,"w");
    if (fp == NULL)
        perror("direction open filed");
    else
        fprintf(fp,"%s",direction);
    fclose(fp);
}   //set gpio "in" or "out"
int getGpioValue(int n)
{
    char path[64];
    char value_str[3];
    int fd;
    snprintf(path, sizeof(path), "/sys/class/gpio/gpio%d/value", n);
    fd = open(path, O_RDONLY);
    if (fd < 0) {
        perror("Failed to open gpio value for reading!");
        return -1;
    }
    if (read(fd, value_str, 3) < 0) {
        perror("Failed to read value!");
        return -1;
    }
    close(fd);
    return (atoi(value_str));
}   //get gpio(n)'s value
int main()
{
    initGpio(970);
    setGpioDirection(970,"in");
    while(1)
    {
        printf("%d\n",getGpioValue(18));<span style="white-space:pre">  </span>//每隔1s输出一次gpio18的值
        sleep(1);
    }
    return 0;
}
system_mode
void set_gpio64_low(void)  
{     
    system("echo 970> /sys/class/gpio/export");  
    system("echo out > /sys/class/gpio/gpio970/direction");  
    system("echo 0 > /sys/class/gpio/gpio970/value");  
}
文章标签：
龙蜥操作系统
Linux
芯片
关键词：
Linux操作系统
操作系统linux
操作系统开发
Linux GPIO
Linux开发
相关实践学习
CentOS 7迁移Anolis OS 7
龙蜥操作系统Anolis OS的体验。Anolis OS 7生态上和依赖管理上保持跟CentOS 7.x兼容，一键式迁移脚本centos2anolis.py。本文为您介绍如何通过AOMS迁移工具实现CentOS 7.x到Anolis OS 7的迁移。
快跑bug来啦
目录
相关文章
萝卜带泥
|
9天前
|
缓存 资源调度 安全
深入探索Linux操作系统的心脏——内核配置与优化####
本文作为一篇技术性深度解析文章，旨在引领读者踏上一场揭秘Linux内核配置与优化的奇妙之旅。不同于传统的摘要概述，本文将以实战为导向，直接跳入核心内容，探讨如何通过精细调整内核参数来提升系统性能、增强安全性及实现资源高效利用。从基础概念到高级技巧，逐步揭示那些隐藏在命令行背后的强大功能，为系统管理员和高级用户打开一扇通往极致性能与定制化体验的大门。 --- ###
萝卜带泥
32 9
游客5fdji2pvmf8888
|
7天前
|
人工智能 Android开发 数据安全/隐私保护
移动应用与系统：探索开发趋势与操作系统的协同进化####
当今时代，移动应用不再仅仅是简单的软件工具，它们已成为扩展智能手机及平板等设备功能的关键。本文旨在深入分析当前移动应用的开发趋势，探讨移动操作系统的最新进展及其对应用开发的影响，并阐述两者如何相互促进、协同进化，共同推动移动互联网技术向前发展。 ####
游客5fdji2pvmf8888
19 5
Echo_Wish
|
9天前
|
缓存 运维 网络协议
深入Linux内核架构：操作系统的核心奥秘
深入Linux内核架构：操作系统的核心奥秘
Echo_Wish
27 2
游客5fdji2pvmf8888
|
12天前
|
人工智能 物联网 Android开发
移动应用与系统：探索开发趋势与操作系统的协同进化####
本文深入探讨了移动应用开发的当前趋势，以及这些趋势如何与移动操作系统的发展相互影响、协同进化。通过分析最新的技术动态、市场数据及用户行为变化，本文旨在为开发者提供关于未来移动应用开发方向的洞察，并讨论操作系统层面的创新如何促进或制约应用的发展。 ####
游客5fdji2pvmf8888
26 4
Skyund
|
13天前
|
缓存 网络协议 Linux
Linux操作系统内核
Linux操作系统内核 1、进程管理： 进程调度 进程创建与销毁 进程间通信 2、内存管理： 内存分配与回收 虚拟内存管理 缓存管理 3、驱动管理： 设备驱动程序接口 硬件抽象层 中断处理 4、文件和网络管理： 文件系统管理 网络协议栈 网络安全及防火墙管理
Skyund
35 4
萝卜带泥
|
12天前
|
安全 网络协议 Linux
Linux操作系统的内核升级与优化策略####
【10月更文挑战第29天】 本文深入探讨了Linux操作系统内核升级的重要性，并详细阐述了一系列优化策略，旨在帮助系统管理员和高级用户提升系统的稳定性、安全性和性能。通过实际案例分析，我们展示了如何安全有效地进行内核升级，以及如何利用调优技术充分发挥Linux系统的潜力。 ####
萝卜带泥
32 1
萝卜带泥
|
15天前
|
安全 物联网 Android开发
移动应用与系统：探索开发趋势与操作系统的演进####
【10月更文挑战第29天】 本文深入探讨了移动应用开发的最新趋势与挑战，并分析了主流移动操作系统（如Android、iOS）的发展动态。通过对比不同系统的技术特点和市场表现，揭示了移动应用生态系统的复杂性及其对开发者的影响。此外，还讨论了跨平台开发工具的兴起如何改变应用开发流程，以及这些变化对未来移动计算领域的潜在影响。 ####
萝卜带泥
30 4
ShaFaChuang-36210
|
15天前
|
物联网 Linux 云计算
Linux操作系统的演变与未来趋势####
【10月更文挑战第29天】 本文深入探讨了Linux操作系统从诞生至今的发展历程，分析了其在服务器、桌面及嵌入式系统领域的应用现状，并展望了云计算、物联网时代下Linux的未来趋势。通过回顾历史、剖析现状、预测未来，本文旨在为读者提供一个全面而深入的视角，以理解Linux在当今技术生态中的重要地位及其发展潜力。 ####
ShaFaChuang-36210
29 1
叫个什么名字
|
20天前
|
边缘计算 人工智能 运维
Linux操作系统：开源力量的崛起与影响###
一场技术革命的回顾 回溯至1991年，当Linus Torvalds宣布Linux操作系统的诞生时，世界或许并未意识到这一举措将如何深刻地改变技术领域的面貌。本文旨在探讨Linux操作系统的发展历程、核心特性、以及它如何引领了一场开源运动，重塑了软件行业的生态。从最初的个人爱好项目成长为全球最广泛采用的服务器操作系统之一，Linux的故事是技术创新与社区精神共同推动下的辉煌篇章。 ###
叫个什么名字
50 4
龙蜥社区（OpenAnolis）
|
19天前
|
人工智能 安全 Linux
阿里云服务器操作系统 Alibaba Cloud Linux 全新升级，核心场景性能提升超 20%
Alinux产品家族，助力云+AI 时代多样使用场景。
龙蜥社区（OpenAnolis）
92 1

龙蜥操作系统

热门文章

最新文章

  • 1
    zabbix 3.2 编译安装
  • 2
    查看linux操作系统版本：Ubuntu？Centos？还是其他？
  • 3
    Win11彻底卸载WSL2系统（去除导航窗格Linux图标）
  • 4
    Linux环境下Docker的卸载
  • 5
    Linux进程查看与控制：掌握ps、top、kill等关键命令
  • 6
    linux添加环境变量4种方法
  • 7
    M1 macos docker获取x86 x64 amd 等指定架构版本linux ubuntu mysql 容器并启动容器
  • 8
    如何在实际开发中深入使用 yalantinglibs 编译期反射库
  • 9
    Virtualbox上安装Linux系统(CentOS7)（图文超详细）
  • 10
    从Ubuntu-base构建ubuntu rootfs系统(以x86_64和arm为例)
  • 1
    Coolbpf 最新特性系列解读：eNetSTL 网络功能加速库在龙蜥社区开源
    16
  • 2
    手把手教学攻略：如何在Anolis OS上部署OpenVINO深度学习模型？
    13
  • 3
    “双龙”联合！助力辽宁沈抚示范区打造安全可靠的政务云平台 | 龙蜥案例
    14
  • 4
    高性能网络SIG月度动态： 推进SMC支持基于eBPF透明替换和内存水位限制等多项功能支持
    8
  • 5
    开源生态发展合作倡议
    15
  • 6
    Cloud Kernel SIG 月度动态：发布ANCK 5.10-017.3小版本，引入SMC、TDX等多项特性
    14
  • 7
    高性能存储SIG月度动态：重构和优化fuse，推动containerd社区支持erofs
    11
  • 8
    C语言如何使用结构体和指针来操作动态分配的内存
    27
  • 9
    精选直播：软件供应链安全、大语言模型、TDX等技术实践分享 | 龙蜥大讲堂
    13
  • 10
    开放原子校源行（天津大学站） 即将启幕，龙蜥技术专家分享开源技术与实践
    14

    • 相关课程

    更多
  • Linux MySQL服务器搭建与应用
  • Linux服务器运维基本操作
  • 计算机基础与Linux入门
  • Linux企业运维实战 - 入门及常用命令
  • Linux Shell 编程入门与实战
  • Linux网络进阶 - TCP/IP协议及OSI七层模型

    • 相关电子书

    更多
  • Alibaba Cloud Linux 3 发布
  • ECS系统指南之Linux系统诊断
  • ECS运维指南 之 Linux系统诊断

    • 相关实验场景

    更多
  • Linux指令入门-文件与权限
  • Linux系统的文本处理
  • Linux指令入门-系统管理
  • 使用计算巢企业应用，一键获取专属的Linux服务器管理软件
  • Alibaba Cloud Linux操作系统的安装及使用
  • Alibaba Cloud Linux操作系统Shell程序

    • 推荐镜像

    更多
  • mxlinux-iso
  • archlinuxarm
  • archlinuxcn
    • 下一篇
    阿里云OSS设置跨域访问