精华内容
下载资源
问答
  • 基于嵌入式NiosⅡ软核的串口直接读写寄存器方式编程,讨论了NiosⅡ软棱的串口直接读写寄存器方式的编程方法,并给出了参考源代码。它与C语言的标准输入/输出语句相比,可极大地缩短程序执行时间,并使得CPU同时...
  • stm32 直接读写寄存器代码风格总结

    千次阅读 2015-05-06 11:59:16
    简单的总结了一下stm32 寄存器读写代码风格,以备后用: 根据memory mapping 直接写寄存器代码风格: #define GPIOA_BASE1 (uint32_t)0x40010800 ...转换为指针之后,直接读写: *GPIOA_CRH=0x000004B0; /

    简单的总结了一下stm32 寄存器读写代码风格,以备后用:

    根据memory mapping 直接写寄存器代码风格:


    #define GPIOA_BASE1 (uint32_t)0x40010800
    #define GPIOA_CRH ((uint32_t*)(GPIOA_BASE1+0x04))


    转换为指针之后,直接读写:

    *GPIOA_CRH=0x000004B0; //A端口 //复用推挽输出 


    结构体指针解决连续多个寄存器读写设置:



    #define Usart1_BASE	 0x40013800
    typedef struct
    {
    	__IO uint32_t SR;
    	__IO uint32_t DR;
    	__IO uint32_t BRR;
    	__IO uint32_t CR1;
    	__IO uint32_t CR2;
    	__IO uint32_t CR3;
    	__IO uint32_t GTPR;
    }Usart1_typedef;
    #define Usart1 ((Usart1_typedef*)Usart1_BASE)  

    Usart1->CR1=0x0000000C;

    展开全文
  • 在Altera公司推出的软件SoPC中加载NiosⅡ软核和相应的外围接口以及与定义相应的自定义指令,然后对设计进行综合,下载到FPGA中就可以方便地实现一个具有高速DSP功能的嵌入式处理器。
  • 硬件工程师将硬件设计好时需要简单的测试程序来看看CPU是否可以正确地读取新硬件系统...然而有时只是为了做简单的硬件寄存器读写动作,就开发驱动程序实在是划算,为了克服这尴尬的情况,Linux的devmem命令油然而生。

    在这里插入图片描述
    =>返回专栏总目录<=

    平台 内核版本 安卓版本
    RK3399 Linux4.4 Android7.1

    硬件工程师将硬件设计好时需要简单的测试程序来看看CPU是否可以正确地读取新硬件系统,在正规的linux操作方式下,必须要有硬件的驱动程序才能完成这个需求。然而有时只是为了做简单的硬件寄存器读写动作,就开发驱动程序实在是不划算,为了克服这尴尬的情况,Linuxdevmem命令油然而生。


    devmem配置宏

    展开全文
  • Linux下读写寄存器

    千次阅读 2017-02-15 17:00:00
    arm裸机下读写寄存器很容易,各个寄存器和内存的地址是单一地址空间,他们是用相同的指令进行读写操作的.而在linux下就要复杂很多,因为linux支持多个体系架构的CPU。比如arm和x86就一样,具体的差别我暂时也说上来...

    arm裸机下读写寄存器很容易,各个寄存器和内存的地址是单一地址空间,他们是用相同的指令进行读写操作的.而在linux下就要复杂很多,因为linux支持多个体系架构的CPU。比如arm和x86就不一样,具体的差别我暂时也说不上来,这个涉及到CPU体系的设计。目前我只关心:linux为了支持多个硬件体系,在IO访问上做了自己的接口。可以通过IO内存和IO端口这两种方式进行IO访问。在LED的例子上给出这两种方式的具体实现:

    1.利用IO Port的方式:

    #include <linux/module.h>
    #include <linux/moduleparam.h>
    #include <linux/init.h>

    #include <linux/kernel.h> /* printk() */
    #include <linux/slab.h>  /* kmalloc() */
    #include <linux/fs.h>  /* everything... */
    #include <linux/errno.h> /* error codes */
    #include <linux/types.h> /* size_t */
    #include <linux/proc_fs.h>
    #include <linux/fcntl.h> /* O_ACCMODE */
    #include <linux/seq_file.h>
    #include <linux/cdev.h>
    #include <linux/ioport.h>

    #include <mach/regs-gpio.h>
    #include <asm/system.h>  /* cli(), *_flags */
    #include <asm/uaccess.h> /* copy_*_user */
    #include <asm/io.h>

    #define LED_NUM   4

    struct led_dev
    {
     struct cdev dev;
     unsigned port;
     unsigned long offset;
    };

    struct led_dev led[4];
    dev_t dev = 0;
    static struct resource *led_resource;


    int led_open(struct inode *inode, struct file *filp)
    {
     struct led_dev *led; /* device information */

     led = container_of(inode->i_cdev, struct led_dev, dev);
     filp->private_data = led; /* for other methods */

     return 0;          /* success */
    }

    int led_release(struct inode *inode, struct file *filp)
    {
     return 0;
    }

    ssize_t led_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
    {
     return 0;
    }

    ssize_t led_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
    {
     char data;
     struct led_dev *led;
     u32 value;
     printk(KERN_INFO "debug by baikal: led dev write\n");
     
     led = (struct led_dev *)filp->private_data;
     copy_from_user(&data,buf,count);
     if(data == '0')
     { 
      printk(KERN_INFO "debug by baikal: led off\n"); 
      value = inl((unsigned)(S3C2410_GPBDAT));
      outl(value | 1<<led->offset,(unsigned)(S3C2410_GPBDAT)); 
      //value = ioread32(led->base);
      //iowrite32( value | 1<<led->offset, led->base);  
     }
     else
     {
      printk(KERN_INFO "debug by baikal: led on\n");
      value = inl((unsigned)(S3C2410_GPBDAT));
      outl(value & ~(1<<led->offset),(unsigned)(S3C2410_GPBDAT)); 
      //value = ioread32(led->base);
      //iowrite32( value & ~(1<<led->offset), led->base);
     }
    }

    struct file_operations led_fops = {
     .owner =    THIS_MODULE,
     .read =    led_read,
     .write =    led_write,
     //.ioctl =    led_ioctl,
     .open =    led_open,
     .release =  led_release,
    };

    static int led_init(void)

     int result, i;
     


     result = alloc_chrdev_region(&dev, 0, LED_NUM,"LED");
     if (result < 0) {
      printk(KERN_WARNING "LED: can't get major %d\n", MAJOR(dev));
      return result;
     }
     led_resource = request_region(0x56000014,0x4,"led");
     if(led_resource == NULL)
     {
      printk(KERN_ERR " Unable to register LED I/O addresses\n");
      return -1;
     }
     for(i = 0; i < LED_NUM; i++)
     {
      cdev_init( &led[i].dev, &led_fops);
      //led[i].port = ioport_map(0x56000014,0x4);
      //led[i].base = ioremap(0x56000014,0x4);
      led[i].offset = i + 5;  //leds  GPB5\6\7\8
      led[i].dev.owner = THIS_MODULE;
      led[i].dev.ops = &led_fops;
      result = cdev_add(&led[i].dev,MKDEV(MAJOR(dev),i),1);
      if(result < 0)
      {
       printk(KERN_ERR "LED: can't add led%d\n",i);
       return result;
      }
     }

     return 0;
    }

    static void led_exit(void)
    {
     int i;
     release_region(0x56000014,0x4);
     for( i = 0; i < LED_NUM; i++)
     {
      //iounmap(led[i].base);

      cdev_del(&led[i].dev); 
     }
     unregister_chrdev_region(dev, LED_NUM);

    }


    module_init(led_init);
    module_exit(led_exit);

    MODULE_AUTHOR("Baikal");
    MODULE_LICENSE("GPL");
    MODULE_DESCRIPTION("Simple LED Driver");

    2.利用IO Mem的方式:

    #include <linux/module.h>
    #include <linux/moduleparam.h>
    #include <linux/init.h>

    #include <linux/kernel.h> /* printk() */
    #include <linux/slab.h>  /* kmalloc() */
    #include <linux/fs.h>  /* everything... */
    #include <linux/errno.h> /* error codes */
    #include <linux/types.h> /* size_t */
    #include <linux/proc_fs.h>
    #include <linux/fcntl.h> /* O_ACCMODE */
    #include <linux/seq_file.h>
    #include <linux/cdev.h>
    #include <linux/ioport.h>

    #include <asm/system.h>  /* cli(), *_flags */
    #include <asm/uaccess.h> /* copy_*_user */
    #include <asm/io.h>

    #define LED_NUM   4

    struct led_dev
    {
     struct cdev dev;
     void __iomem *base;
     unsigned long offset;
    };

    struct led_dev led[4];
    dev_t dev = 0;


    int led_open(struct inode *inode, struct file *filp)
    {
     struct led_dev *led; /* device information */

     led = container_of(inode->i_cdev, struct led_dev, dev);
     filp->private_data = led; /* for other methods */

     return 0;          /* success */
    }

    int led_release(struct inode *inode, struct file *filp)
    {
     return 0;
    }

    ssize_t led_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
    {
     return 0;
    }

    ssize_t led_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)
    {
     char data;
     struct led_dev *led;
     u32 value;
     printk(KERN_INFO "debug by baikal: led dev write\n");
     
     led = (struct led_dev *)filp->private_data;
     copy_from_user(&data,buf,count);
     if(data == '0')
     { 
      printk(KERN_INFO "debug by baikal: led off\n");  
      value = ioread32(led->base);
      iowrite32( value | 1<<led->offset, led->base);  
     }
     else
     {
      printk(KERN_INFO "debug by baikal: led on\n");
      value = ioread32(led->base);
      iowrite32( value & ~(1<<led->offset), led->base);
     }
    }

    struct file_operations led_fops = {
     .owner =    THIS_MODULE,
     .read =    led_read,
     .write =    led_write,
     //.ioctl =    led_ioctl,
     .open =    led_open,
     .release =  led_release,
    };

    static int led_init(void)

     int result, i;
     


     result = alloc_chrdev_region(&dev, 0, LED_NUM,"LED");
     if (result < 0) {
      printk(KERN_WARNING "LED: can't get major %d\n", MAJOR(dev));
      return result;
     }
     
     for(i = 0; i < LED_NUM; i++)
     {
      cdev_init( &led[i].dev, &led_fops);
      request_mem_region(0x56000014,0x4,"led");
      led[i].base = ioremap(0x56000014,0x4);
      led[i].offset = i + 5;  //leds  GPB5\6\7\8
      led[i].dev.owner = THIS_MODULE;
      led[i].dev.ops = &led_fops;
      result = cdev_add(&led[i].dev,MKDEV(MAJOR(dev),i),1);
      if(result < 0)
      {
       printk(KERN_ERR "LED: can't add led%d\n",i);
       return result;
      }
     }

     return 0;
    }

    static void led_exit(void)
    {
     int i;  
     release_mem_region(0x56000014,0x4);
     for( i = 0; i < LED_NUM; i++)
     {
      iounmap(led[i].base);

      cdev_del(&led[i].dev); 
     }
     unregister_chrdev_region(dev, LED_NUM);

    }


    module_init(led_init);
    module_exit(led_exit);

    MODULE_AUTHOR("Baikal");
    MODULE_LICENSE("GPL");
    MODULE_DESCRIPTION("Simple LED Driver");

    目前,对于具体体系上的linux在移植过程中如何实现这两种方式的方法还不清楚,现在只是会用。等以后有机会了再慢慢理清楚。

    展开全文
  • 主要介绍了Linux在应用层读写寄存器的方法及实现实例的相关资料,需要的朋友可以参考下
  • C# ModBus Tcp 直接读写PLC寄存器

    千次阅读 2020-05-25 14:45:06
    C# ModBus Tcp读写数据 直接操做PLC寄存器 MODBUS通用数据帧: 代码下载地址: 具体modbus协议见pdf文档这里就说了(下载包里有) https://download.csdn.net/download/weixin_42288222/12457342 1.这边使用裸Tcp...

    C# ModBus Tcp 直接读写PLC寄存器

    MODBUS通用数据帧:
    在这里插入图片描述在这里插入图片描述测试用modbus服务器下载地址:
    https://download.csdn.net/download/weixin_42288222/12457317
    测试修改寄存器的值为1
    代码下载地址:

    具体modbus协议见pdf文档这里就不说了(下载包里有)
    在这里插入图片描述
    https://download.csdn.net/download/weixin_42288222/12457342

    1.这边使用裸Tcp/ip协议 通过socket发送modbus的通讯报文地址数据等,操作plc寄存器(没有使用别人写好的类库)。

    界面如下:
    界面
    2.TCP部分程序如下: 内联代码片

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Net;
    using System.Net.Sockets;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    using System.Windows.Forms;
    
    namespace ModbusTcp
    {
        class TCP
        {
            public delegate void ChangeFormList(bool change);
            public event ChangeFormList ChangeList;
            public delegate void TcpStutas(bool change);
            public event TcpStutas ReturnFromPLC;
            readonly object obj = new object();
            public string STR;//接收到的消息
            public string SendMsg;
            /// <summary>
            /// 连接状态:true 连接中 false 连接中断
            /// </summary>
            public bool isConnected;
            Socket socketSend;
            public bool Connect(string ip, int port)
            {
                try
                {
                    socketSend = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    IPAddress IP = IPAddress.Parse(ip);
                    IPEndPoint point = new IPEndPoint(IP, port); ;
                    socketSend.Connect(point);
                    isConnected = true;
                    return true;
                }
                catch (Exception)
                {
                    MessageBox.Show("请填写正确的IP地址和端口号!");
                    return false;
                }
            }
            /// <summary>
            /// 接收服务端返回的消息
            /// </summary>
            void Received()
            {
                try
                {
                    //1M的缓存区
                    byte[] data = new byte[1024];
                    //实际接收到的有效字节数
                    int len = socketSend.Receive(data);// 将接受到的数据存入到输入buffer中
                    if (len == 0)
                    {
                        isConnected = false;
                    }
                    int length = data[5];//读取数据长度  
                    Byte[] datashow = new byte[length + 6];//定义所要显示的接收的数据的长度  
                    for (int i = 0; i <= length + 5; i++)//将要显示的数据存放到数组datashow中  
                        datashow[i] = data[i];
                    string stringdata = BitConverter.ToString(datashow);//把数组转换成16进制字符串  
                    if (data[7] == 0x01) { STR = stringdata; };
                    if (data[7] == 0x02) { STR = stringdata; };
                    if (data[7] == 0x03) { STR = stringdata; };//功能码为3
                    if (data[7] == 0x05) { STR = stringdata; };
                    if (data[7] == 0x06) { STR = stringdata; };//功能码为6
                    if (data[7] == 0x0F) { STR = stringdata; };
                    if (data[7] == 0x10) { STR = stringdata; };
                    ChangeList(true);
                }
                catch (Exception ex)
                {
                    MessageBox.Show("接收数据出现异常!" + ex.Message, "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
    
            }
            /// <summary>
            /// 向服务器发送消息
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            public void Send(byte[] msg)
            {
                lock (obj)
                {
                    try
                    {
                        socketSend.Send(msg);
                        for (int i = 0; i < msg.Length; i++)
                        {
                            SendMsg += msg[i];
                        }
                        ReturnFromPLC(true);
                        Thread.Sleep(10);
                        Received();
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(" 发送数据出现异常!" + ex.Message, "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
    
            }
            /// <summary>
            /// 16转10进制
            /// </summary>
            /// <param name="msg"></param>
            /// <returns></returns>
            public int GetDex(string msg)
            {
                int res = Convert.ToInt32(msg, 16);
                return res;
            }
        }
    }
    
    

    3.主界面部分: 内联代码片

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows.Forms;
    
    namespace ModbusTcp
    {
        public partial class Form1 : Form
        {
            public Form1()
            {
                InitializeComponent();
            }
            /*具体详见modbus协议中文版.pdf
             功能码说明(括号内为对应的16进制):
             01(01):byte访问 读线圈
             02(02):byte访问 读输入离散量
             05(05):byte访问 写单个线圈
             15(0F):byte访问 写多个线圈
             03(03):16位byte访问 读多个寄存器
             04(04):16位byte访问 读输入寄存器
             06(06):16位byte访问 写单个寄存器
             16(10):16位byte访问 写多个寄存器
             23(17):16位byte访问 读/写多个寄存器
             22(16):16位byte访问 屏蔽写寄存器
             20(14):文件记录访问 读文件记录
             21(15):文件记录访问 写文件记录
             43(2B):封装接口     读设备识别码
             */
            private void button1_Click(object sender, EventArgs e)
            {
                //连接Tcp服务器
                tcp.Connect(textBox1.Text, 502);
            }
            TCP tcp = new TCP();
            private void Form1_Load(object sender, EventArgs e)
            {
                tcp.ChangeList += new TCP.ChangeFormList(f_ChangeList);//tcp通讯显示发送
                tcp.ReturnFromPLC += new TCP.TcpStutas(f_TcpAtutas);//tcp通讯显示返回
            }
    
            private void f_TcpAtutas(bool change)
            {
                Invoke(new Action(() =>{
                    richTextBox1.Text += tcp.STR + "***" + DateTime.Now.ToString("yyyy/mm/dd HH:mm:ss") + "\r\n";
                } ));
            }
    
            private void f_ChangeList(bool change)
            {
                Invoke(new Action(() => {
                    richTextBox2.Text += tcp.STR + "***" + DateTime.Now.ToString("yyyy/mm/dd HH:mm:ss") + "\r\n";
                }));
            }
    
            /// <summary>
            /// 数据格式:0-6位:报文头;7位:功能码;8-9位:起始地址;10-11位:寄存器位数(读)/写入数据(写)
            /// </summary>
            byte[] data = new byte[] { 0x00, 0x01, 0x00, 0x00, 0x00, 0x06, 0x01, 0x06, 0x00, 0x00, 0x00, 0x01 };
            private void button2_Click(object sender, EventArgs e)
            {
                try
                {
                    data[7] = GetHex(textBox2.Text);
                    data[11] = GetHex(textBox3.Text);
                    data[9] = GetHex(textBox4.Text);
                    tcp.Send(data);
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.ToString());
                }
                
            }
            /// <summary>
            /// 10转16
            /// </summary>
            /// <param name="msg"></param>
            /// <returns></returns>
            private byte GetHex(string msg)
            {
                byte hex = Convert.ToByte(msg);
                return hex;
            }
    
            private void timer1_Tick(object sender, EventArgs e)
            {
                if (tcp.isConnected)
                {
                    button1.Enabled = false;
                    textBox1.Enabled = false;
                }
                else
                {
                    button1.Enabled = true;
                    textBox1.Enabled = true;
                }
            }
        }
    }
    
    
    展开全文
  • 文章目录IIC读写寄存器时序图中断方式的实现流程中断方式的实现代码(主) IIC读写寄存器时序图 中断方式的实现流程 中断方式的实现代码(主) //直接读:发完器件从地址后直接读取数据 //直接写:发完器件从地址...
  • 基于IAR开发STM8的FALSH读写直接操作寄存器方式。
  • JTAG MASTER GUI 可直接读写FPGA寄存器

    千次阅读 2017-07-19 16:23:19
    福利!  之前有写过一篇关于JTAG...即使对tcl一点都了解,也可以通过该界面方便的进行FPGA寄存器的调试。 由于CSDN博客太方便上传附件,这里直接贴源码。大家把代码保存后,另存为mem_test.tcl文件即可。 使
  • 读写寄存器调试技巧

    2011-12-03 11:50:40
    1.将所有的片选(ORn和BRn)都打印出来 2.接外设直接对映射后的地址访问
  • ARM平台WINCE系统的寄存器直接读写工具,适用于驱动调试,减少调试工作量
  • Linux在应用层读写寄存器的方法

    千次阅读 2017-12-12 17:41:59
    在某些情况下,需要移植的代码是直接访问寄存器的,当移植到linux时,可利用mmap创建一个适配层,减少开发工作量。 通过操作/dev/mem设备文件,以及mmap函数,将寄存器的地址映射到用户空间,直接在应用层对寄存器...
  • 通用代码编译后可读写phy寄存器
  • OP-TEE TA:读写寄存器数据

    千次阅读 2016-04-27 15:49:54
    最近想为OP-TEE的Trusted OS开发一个触摸屏驱动,在查询代码的时候发现直接调用TA修改TZPC寄存器的值是可行的,原因是user TA的运行采用了沙盒机制,所以无法直接访问寄存器所映射的物理地址。所以在查看了相关...
  • 1. Linux在应用层读写寄存器的方法 转自: https://blog.csdn.net/liukang325/article/details/26601811 可以通过操作/dev/mem设备文件,以及mmap函数,将寄存器的地址映射到用户空间,直接在应用层对寄存器进行...
  • linux mdio 读写phy 寄存器工具
  • 分为控制寄存器和数据寄存器:分别占4个字节。 //*************** 此处引出led灯的物理地址查找方法: 如LED灯 --->板子原理图(底板原理图--->到核心板原理图) --->找到对应器件I/O口 --->查找芯片
  • ![图片说明](https://img-ask.csdn.net/upload/201511/21/1448080631_801603.png)图上的意思是C不能直接操作吗?还是说操作起来和汇编一样
  • 以下内容源于朱有鹏《物联网大讲堂》课程的学习整理,如有侵权,请告知删除。 1、前面访问寄存器的方式 通过定义指向寄存器的指针,然后解引用来对寄存器...2、内核提供的寄存器读写接口 这些接口具有移植性,在Io
  • 可以通过操作/dev/mem设备文件,以及mmap函数,将寄存器的地址映射到用户空间,直接在应用层对寄存器进行操作,示例如下: [cpp] view plaincopy #include #include #include #include #include...
  • STM8S_SPI_读写SI4432的寄存器函数样例, 用c语言直接操作寄存器, 不用库函数,如果写的不好请大家多多指教;平台基于stm8s105s6,控制无线SI4432。
  • 使用python将计算机与汇川H3...直接上代码吧,封装好的功能,可以直接使用: import time import modbus_tk import modbus_tk.defines as cst import modbus_tk.modbus_tcp as modbus_tcp def connect_plc(host): ma
  • 寄存器映射与直接操作寄存器

    千次阅读 多人点赞 2017-06-02 23:08:26
    存储器本身具有地址信息,它的地址是由芯片厂商或用户分配,给物理存储器分配逻辑地址的过程就称为存储器映射,通过这些逻辑地址就可以访问到相应的存储器的物理存储单元。如果给存储器再分配一个地址就叫存储器...
  • 一般来说IIC器件的内部寄存器地址都是8位的,这样在进行读写操作时,发送完器件地址之后直接发送一个字节的寄存器地址,然后即可以进行读写。但是有的器件内部寄存器是按照16位地址编排的,例如一些EEPROM器件,由于...
  • 驱动中读写硬件寄存器的方式

    千次阅读 2014-06-15 00:09:01
    1.驱动中读写硬件寄存器的方式 比如想控制某寄存器。先查找datasheet中该寄存器的物理地址。 然后调用ioremap()函数。该函数返回一个虚拟地址。内核空间 可以直接访问它。 比如我们要访问s3c2410平台上的I2S...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 70,269
精华内容 28,107
关键字:

不能直接读写的寄存器是