精华内容
下载资源
问答
  • 多核dsp核间通信例程
  • 干货分享:DSP多核IPC通信案例开发案例,欢迎大家下载学习!
  • IPC通信采用socket方式

    2019-04-17 18:03:43
    Socket套接字,分为流式套接字TCP,客户端通过new Socket()发起请求,服务端通过new ServerSocket().accept()接收。
  • Android跨进程IPC通信的常用例子,AIDL,Messenger,Binder
  • 2. IPC进程通信:支持本地进程间通信,支持任意类型数据(文件传输除外),模式有push和pull两种。 具体使用方法,请看示例! 给单位做考勤系统,找了一些通信框架,都不理想,索性就自己动手,类库最开始是去年年初...
  • FreeRTOS IPC通信方式

    2021-07-29 17:26:44
    FreeRTOS IPC通信方式

    FreeRTOS IPC通信方式

    展开全文
  • Socket通常翻译为套接字,它是为了方便让两台机器能互相通信的一套技术,该套技术封装好了繁琐的TCP/IP协议,向外提供出简单的API简化了通信实现的过程,其可以实现不同层面,不同应用,跨进程跨网络的通信。...

    LocalSocket是什么?
    在弄清LocalSocket是什么之前,有必要先了解下Socket是什么。Socket通常翻译为套接字,它是为了方便让两台机器能互相通信的一套技术,该套技术封装好了繁琐的TCP/IP协议,向外提供出简单的API简化了通信实现的过程,其可以实现不同层面,不同应用,跨进程跨网络的通信。依据Socket提供的数据传输特性可分为如下几个大类:

    • Stream socket: 提供双向、有序、可靠、非重复的数据通信。大致可以认为它封装的TCP通信协议。
    • Datagram socket: 提供双向数据通信,数据不一定按顺序到达。大致可以认为它封装的是UDP通信协议。
    • Sequential socket: 提供双向、有序、可靠数据通信,数据包有最大限制,并且必须把这个包完整的接受才能进行读取。
    • Raw socket: 提供相对TCP/UDP而言较下层的通信协议访问,如果使用非TCP/UDP的通信协议可以使用该类型的socket。

    socket通信过程如下图
    在这里插入图片描述Android系统可以通过命令

    adb shell netstat -apn
    

    在这里插入图片描述LocalSocket通信实例
    一般两个不同的应用之间如果要相互通信,首先想到的解决方案都是利用AIDL,这里我们用LocalSocket来实现。通过该例子来实践下LocalSocket
    一、服务端实现
    1、服务端代码如下所示

    public class ServerActivity extends AppCompatActivity {
    
        private LocalServerSocket mServerSocket = null;
        private LocalSocket mSocket = null;
        private TextView mShowMsg = null;
        private InputStream mInputStream = null;
        private static final String SOCKET_NAME = "com.wq.serverdemo.testsocket";
        private static final String TAG = "wq892373445-Socket";
    
        private final Handler mHandler = new Handler() {
            public void handleMessage(android.os.Message msg) {
                String dispMesg = (String) msg.obj;
                mShowMsg.setText(dispMesg);
            };
        };
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_server);
            Button button = (Button) findViewById(R.id.replay_btn);
            mShowMsg = (TextView) findViewById(R.id.display_msg);
            createServerSocket();// 创建LocalServerSocket
            new Thread(new Runnable() {
                @Override
                public void run() {
                    acceptMsg();//必须要在子线程里接收消息
                }
            }).start();
        }
    
        private void createServerSocket() {
            if (mServerSocket == null) {
                try {
                    /**注意这里new出LocalServerSocket的同时,系统层已经同步做了bind和listen。
                     * 我们看看new的过程:
                     * public LocalServerSocket(String name) throws IOException {
                     *       impl = new LocalSocketImpl();
                     *       impl.create(LocalSocket.SOCKET_STREAM);
                     *       localAddress = new LocalSocketAddress(name);
                     *       impl.bind(localAddress);
                     *       impl.listen(LISTEN_BACKLOG);
                     * }
                     */
                    mServerSocket = new LocalServerSocket(SOCKET_NAME);
                } catch (IOException ex) {
                    throw new RuntimeException(
                            "Error binding to local socket " + ex);
                }
            }
        }
    
        private void acceptMsg() {
            try {
                mSocket = mServerSocket.accept();//accept是个阻塞方法,这就是必须要在子线程接收消息的原因。
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            while (true) {
                try {
                    byte[] buffer = new byte[1024];
                    mInputStream = mSocket.getInputStream();
                    int count = mInputStream.read(buffer);
                    String key = new String(Arrays.copyOfRange(buffer, 0, count));
                    Log.e(TAG, "ServerActivity mSocketOutStream==" + key);
                    if ("stop".equals(key)) {
                        closeSocketResource();
                        break;
                    }
                    Message msg = mHandler.obtainMessage();
                    msg.obj = key;
                    msg.sendToTarget();
                } catch (IOException e) {
                    Log.e(TAG, "exception==" + e.fillInStackTrace().getMessage());
                    e.printStackTrace();
                }
            }
        }
    
        private void closeSocketResource() {
            closeSlient(mInputStream);
            closeSlient(mSocket);
            try {
                if (mServerSocket != null) {
                    mServerSocket.close();
                    mServerSocket = null;
                }
            } catch (IOException ex) {
                Log.e(TAG, "Failed closing ServerSocket" + ex.fillInStackTrace());
            }
        }
    
        private void closeSlient(Closeable closeable){
            try {
                if (closeable != null) {
                    closeable.close();
                    closeable = null;
                }
            } catch (IOException ex) {
                Log.e(TAG, "Failed closing : " + closeable);
            }
        }
    }
    

    2、布局文件

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        tools:context=".ServerActivity">
    
       <Button
           android:id="@+id/replay_btn"
           android:text="这是服务端"
           android:layout_width="wrap_content"
           android:layout_height="wrap_content"/>
        <TextView
            android:id="@+id/display_msg"
            android:textColor="#f0f0f0"
            android:layout_width="match_parent"
            android:layout_height="60dp"/>
    
    </LinearLayout>
    

    3、验证服务端是否就绪,输入如下命令

    adb shell netstat -apn|grep testsocket
    

    输出结果:
    在这里插入图片描述则表明服务端已经就绪,等待客户端socket接入发送消息了
    二、客户端的实现
    1、客户端代码

    public class ClientActivity extends AppCompatActivity implements View.OnClickListener {
    
        private LocalSocket mSocket;
        private OutputStream mOut;
        private EditText mEditText = null;
        private static final String SOCKET_NAME = "com.wq.serverdemo.testsocket";//这里必须要跟TestLocalSocketServer中定义的一样
        private static final String TAG = "wq892373445-Socket";
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_client);
            connect();
            mEditText = (EditText) findViewById(R.id.input_msg);
            findViewById(R.id.replay_btn).setOnClickListener(this);
            findViewById(R.id.stop_btn).setOnClickListener(this);
        }
    
        private boolean connect() {
            if (mSocket != null) {
                return true;
            }
            try {
                mSocket = new LocalSocket();//创建LocalSocket,模拟客户端
                LocalSocketAddress address = new LocalSocketAddress(SOCKET_NAME,
                        LocalSocketAddress.Namespace.ABSTRACT);
                mSocket.connect(address);//连接TestLocalSocketServer
            } catch (IOException ex) {
                return false;
            }
            return true;
        }
    
        private boolean writeCommand(String cmdString) {
            final byte[] cmd = cmdString.getBytes();
            final int len = cmd.length;
            try {
                mOut = mSocket.getOutputStream();
                mOut.write(cmd, 0, len);
                Log.e(TAG, "ClientActivity write " + new String(cmd));
            } catch (IOException ex) {
                Log.e(TAG, "ClientActivity write error:" + ex.fillInStackTrace());
                return false;
            }
            return true;
        }
    
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.replay_btn:
                    writeCommand(mEditText.getText().toString());
                    break;
                case R.id.stop_btn:
                    writeCommand("stop");
                    break;
                default:
                    break;
            }
    
        }
    }
    

    2、布局文件

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        tools:context=".ClientActivity">
    
        <Button
            android:id="@+id/replay_btn"
            android:text="回复"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"/>
        <EditText
            android:id="@+id/input_msg"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"/>
        <Button
            android:id="@+id/stop_btn"
            android:text="关闭Socket"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"/>
        <TextView
            android:id="@+id/display_msg"
            android:textColor="#f0f0f0"
            android:layout_width="match_parent"
            android:layout_height="60dp"/>
    
    </LinearLayout>
    

    3、验证服务端是否就绪,输入如下命令

    adb shell netstat -apn|grep testsocket
    

    输出结果:
    在这里插入图片描述则表明客户端已经连接上了服务端,可以给服务端发送消息了
    三、最后在客户端发送消息给服务端效果如下所示
    在这里插入图片描述

    展开全文
  • 电子应用程序的简化IPC通信 与,此模块的最大好处是,它使您可以在同一呼叫中发送消息并获得响应。 这通常需要多个IPC订阅。 您可以在主过程和渲染器过程中直接使用此模块。 安装 $ npm install electron-better-...
  • 主要介绍了Android使用Service实现IPC通信的2种方式,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Linux IPC通信方式

    2017-05-26 14:59:34
    Linux进程间通信(IPC)有几种方式,下面将将简单的简述一下: 一。管道(pipe) 管道是Linux支持的最初IPC方式,管道可分为无名管道,有名管道等。 (一)无名管道,它具有几个特点: 1) 管道是半双工的,只能支持...

    Linux进程间通信(IPC)有几种方式,下面将将简单的简述一下:

      一。管道(pipe)

      管道是Linux支持的最初IPC方式,管道可分为无名管道,有名管道等。

      (一)无名管道,它具有几个特点:

      1) 管道是半双工的,只能支持数据的单向流动;两进程间需要通信时需要建立起两个管道;

      2) 无名管道使用pipe()函数创建,只能用于父子进程或者兄弟进程之间;

      3) 管道对于通信的两端进程而言,实质上是一种独立的文件,只存在于内存中;

      4) 数据的读写操作:一个进程向管道中写数据,所写的数据添加在管道缓冲区的尾部;另一个进程在管道中缓冲区的头部读数据。

      (二)有名管道

      有名管道也是半双工的,不过它允许没有亲缘关系的进程间进行通信。具体点说就是,有名管道提供了一个路径名与之进行关联,以FIFO(先进先出)的形式存在于文件系统中。这样即使是不相干的进程也可以通过FIFO相互通信,只要他们能访问已经提供的路径。

      值得注意的是,只有在管道有读端时,往管道中写数据才有意义。否则,向管道写数据的进程会接收到内核发出来的SIGPIPE信号;应用程序可以自定义该信号处理函数,或者直接忽略该信号。

      二。信号量(semophore)

      信号量是一种计数器,可以控制进程间多个线程或者多个进程对资源的同步访问,它常实现为一种锁机制。实质上,信号量是一个被保护的变量,并且只能通过初始化和两个标准的原子操作(P/V)来访问。(P,V操作也常称为wait(s),signal(s))

      三。信号(Signal)

      信号是Unix系统中使用的最古老的进程间通信的方法之一。操作系统通过信号来通知某一进程发生了某一种预定好的事件;接收到信号的进程可以选择不同的方式处理该信号,一是可以采用默认处理机制—进程中断或退出,一是忽略该信号,还有就是自定义该信号的处理函数,执行相应的动作。

      内核为进程生产信号,来响应不同的事件,这些事件就是信号源。信号源可以是:异常,其他进程,终端的中断(Ctrl-C,Ctrl+\等),作业的控制(前台,后台进程的管理等),分配额问题(cpu超时或文件过大等),内核通知(例如I/O就绪等),报警(计时器)。

      四。消息队列(Message Queue)

      消息队列就是消息的一个链表,它允许一个或者多个进程向它写消息,一个或多个进程向它读消息。Linux维护了一个消息队列向量表:msgque,来表示系统中所有的消息队列。

      消息队列克服了信号传递信息少,管道只能支持无格式字节流和缓冲区受限的缺点。

      五。共享内存(shared memory)

      共享内存映射为一段可以被其他进程访问的内存。该共享内存由一个进程所创建,然后其他进程可以挂载到该共享内存中。共享内存是最快的IPC机制,但由于linux本身不能实现对其同步控制,需要用户程序进行并发访问控制,因此它一般结合了其他通信机制实现了进程间的通信,例如信号量。

      五。套接字(socket)

      socket也是一种进程间的通信机制,不过它与其他通信方式主要的区别是:它可以实现不同主机间的进程通信。一个套接口可以看做是进程间通信的端点(endpoint),每个套接口的名字是唯一的;其他进程可以访问,连接和进行数据通信。

    展开全文
  • electron-better-ipc:简化Electron程序之间的IPC通信
  • 2837xD之IPC通信(共享内存)

    千次阅读 2020-06-22 17:08:26
    IPC通信(共享内存)IPC通信基本原理程序部分一、CPU1程序注释二、CPU1主程序部分三、CPU2主程序部分致谢 IPC通信基本原理 IPC通信是TI公司的一种双核通信方式,主要有:1.共享内存(Message RAM) 2.共享寄存器...

    IPC通信基本原理

    • IPC通信是TI公司的一种双核通信方式,主要有:1.共享内存(Message RAM) 2.共享寄存器(Message register) 3.IPC lite 等等。本次分析的是TI公司的例程(基于2837xD)。

    程序部分

    一、CPU1程序注释

    • 例程目标:
    // //###########################################################################
    FILE:   RAM_management_cpu01.c
    TITLE:  RAM management Example for F2837xD.
    
    //This example shows how to assign shared RAM for use by both the CPU02 
    //and CPU01 core.   //使用CPU1与CPU2进行通信
    //Shared RAM regions are defined in  both the CPU02 and CPU01 linker files.
    // In this example GS0 and GS14 are assigned to/owned by CPU02. The remaining 
    // shared RAM regions are owned by CPU01.
    //! In this example:
    //! 
    //! A pattern is written to c1_r_w_array and then IPC flag is sent to notify 
    //! CPU02 that data is ready to be read. CPU02 then reads the data from
    //! c2_r_array and writes a modified pattern to c2_r_w_array. Once CPU02 acknowledges
    //! the IPC flag to , CPU01 reads the data from c1_r_array and compares with expected
    //! result.
    //! 
    //! A Timed ISR is also serviced in both CPUs. The ISRs are copied into the shared 
    //! RAM region owned by the respective CPUs. Each ISR toggles a GPIO. Watch GPIO31
    //! and GPIO34 on oscilloscope. If using the control card watch LED1 and LED2 blink
    //! at different rates.
    //!  - c1_r_w_array[] is mapped to shared RAM GS1
    //!  - c1_r_array[]   is mapped to shared RAM GS0
    //!  - c2_r_array[]   is mapped to shared RAM GS1
    //!  - c2_r_w_array[] is mapped to shared RAM GS0
    //!  - cpu_timer0_isr in CPU02 is copied to shared RAM GS14 , toggles GPIO31
    //!  - cpu_timer0_isr in CPU01 is copied to shared RAM GS15 , toggles GPIO34
    //!
    //! \b  Watch \b Variables
    //!
    //!  - error Indicates that the data written is not correctly received by the other CPU.
    //
    //###########################################################################
    // $TI Release: F2837xD Support Library v190 $
    // $Release Date: Mon Feb  1 16:51:57 CST 2016 $
    // $Copyright: Copyright (C) 2013-2016 Texas Instruments Incorporated -
    //             http://www.ti.com/ ALL RIGHTS RESERVED $
    //###########################################################################;
    

    以上文档说明指出

    • 1.Share RAM 区域需要在CPU1和CPU2的ilnk文件进行定义。
      2.本例中定义GS0和GS14属于CPU2,剩下的空间属于CPU1
      3.数据将被CPU1写入c1_r_w_array数组,然后通过IPC_flag通知CPU2。
      4.CPU2从c2_r_array读取数据,然后将修改后的数据写入c2_r_w_array,然后通过IPC_flag通知CPU1。

    二、CPU1主程序部分

    #include "F28x_Project.h"
    #include "F2837xD_Ipc_drivers.h"
    
    // Data exchange arrays  32*256=2^12
    uint16_t c1_r_array[256];  
    uint16_t c1_r_w_array[256]; 
    #pragma DATA_SECTION(c1_r_array,"SHARERAMGS0"); // 分配到GS0(CPU2)
    #pragma DATA_SECTION(c1_r_w_array,"SHARERAMGS1");// 分配到GS1(CPU1)
    
    // Global variables 
    uint16_t error;
    uint16_t multiplier;
    
    // External variables declared by linker.
    extern uint16_t isrfuncLoadStart;
    extern uint16_t isrfuncLoadEnd;
    extern uint16_t isrfuncRunStart;
    extern uint16_t isrfuncLoadSize;
    
    // Prototype statements for functions found within this file.
    __interrupt void cpu_timer0_isr(void);
    #pragma CODE_SECTION(cpu_timer0_isr,"isrfunc") //中断程序放置到GS14
    
    // Functions to read and write data
    void Shared_Ram_dataRead_c1(void);
    void Shared_Ram_dataWrite_c1(void);
    
    void main(void)
    {
      //1.初始化程序
      InitSysCtrl(); 
    
    #ifdef _STANDALONE
    #ifdef _FLASH
      //  Send boot command to allow the CPU02 application to begin execution
      IPCBootCPU2(C1C2_BROM_BOOTMODE_BOOT_FROM_FLASH);
    #else
      //  Send boot command to allow the CPU02 application to begin execution
      IPCBootCPU2(C1C2_BROM_BOOTMODE_BOOT_FROM_RAM);
    #endif
    #endif  //引导CPU2启动
    
    // 2.初始化GPIO:
      InitGpio();  // Skipped for this example
    
    // 3.关中断
      DINT;
    
    // 初始化PIE
     InitPieCtrl();
    
    // 清除中断
     IER = 0x0000;
     IFR = 0x0000;
    
    // 初始化PIE向量表
     InitPieVectTable();
     
    // GPIO31属于CPU2
      GPIO_SetupPinMux(31,GPIO_MUX_CPU2,0);
      GPIO_SetupPinOptions(31, GPIO_OUTPUT,0);
      
    // GPIO34属于CPU1
      GPIO_SetupPinMux(34,GPIO_MUX_CPU1,0);
      GPIO_SetupPinOptions(34, GPIO_OUTPUT,0);    
    
    // 将GS0和GS14控制权给CPU2
      while( !(MemCfgRegs.GSxMSEL.bit.MSEL_GS0 &
      		 MemCfgRegs.GSxMSEL.bit.MSEL_GS14))
      {
      	EALLOW;
      	MemCfgRegs.GSxMSEL.bit.MSEL_GS0 = 1;//0:CPU1 is master for this memory
      										//1:CPU2 is master for this memory
      	MemCfgRegs.GSxMSEL.bit.MSEL_GS14 = 1;
      	EDIS;
      }
    
    //  将中断函数拷贝进入GS14 RAM空间
      memcpy(&isrfuncRunStart, &isrfuncLoadStart, (uint32_t)&isrfuncLoadSize);
    
    //指定中断函数
      EALLOW;  // This is needed to write to EALLOW protected registers
      PieVectTable.TIMER0_INT = &cpu_timer0_isr;
      EDIS;    // This is needed to disable write to EALLOW protected registers
      
    ///初始化定时器
     InitCpuTimers();   // For this example, only initialize the Cpu Timers    
     
    //设置定时器2s
     ConfigCpuTimer(&CpuTimer0, 200, 2000000); 
    
    //启动定时器
     CpuTimer0Regs.TCR.all = 0x4000; // Use write-only instruction to set TSS bit = 0
     
    // 开始中断
     IER |= M_INT1;   
     
    // 开PIE
     PieCtrlRegs.PIEIER1.bit.INTx7 = 1;   
     
    // Enable global Interrupts and higher priority real-time debug events:
     EINT;   // 开全局中断
     ERTM;   // 开启实时中断  
      // Main Code
      error = 0;
      multiplier = 0;
      Shared_Ram_dataWrite_c1();  //给c1_r_w_array数组中写入数据内容为[0]:multiplier,[1]-[255]=1-255
      IPCLtoRFlagSet(IPC_FLAG10); /挂起中断信号FLAG10
      
      while(1)
      {          
          // 如果没有挂起中断标志(代表CPU2已经操作完毕,ACK了FLAG10)
          if(IPCLtoRFlagBusy(IPC_FLAG10) == 0)
          {
              Shared_Ram_dataRead_c1();  //读取c1_r_array中的数据
              
              if(multiplier++ > 255)
              {
                  multiplier = 0;
              }                                   //multipliter++,单只能在0-255中间循环
          
              //给c1_r_w_array数组中写入数据内容为[0]:multiplier,[1]-[255]=1-255
              Shared_Ram_dataWrite_c1();
              IPCLtoRFlagSet(IPC_FLAG10);
          }
      }
    }
    
    __interrupt void cpu_timer0_isr(void)
    {
     EALLOW;
     CpuTimer0.InterruptCount++;  //记录进入中断次数
     GpioDataRegs.GPBTOGGLE.bit.GPIO34 = 1;  //GPIO34翻转
     EDIS;
     PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;   //清除中断标志
    }
    
    void Shared_Ram_dataWrite_c1(void)  //写入c1_r_w_array中数据
    {
      uint16_t index;
    
      // Use first location to write a multiplier.
      c1_r_w_array[0] = multiplier;  //0
      
      for(index = 1; index < 256; index++)
      {
          c1_r_w_array[index] = index;
          //the following code will attempt to write to a shared RAM
          //assigned to cpu2 and as a result will cause an error.
          //c1_r_array[index] = 1000 + index;
      }
    }
    
    //读取CPU2处理后的数据并进行校验是否进行了乘法
    void Shared_Ram_dataRead_c1(void)
    {
      uint16_t index;
    
      if(c1_r_array[0] == multiplier)
      {
         for(index = 1; index < 256; index++)
         {
             if(c1_r_array[index] != multiplier*c1_r_w_array[index])
             {
                 error = 1;        
             }
         }
      }
      else
      {
          error = 1;
      }
    }
    

    三、CPU2主程序部分

    #include "F28x_Project.h"     
    #include "F2837xD_Ipc_drivers.h"
    
    uint16_t c2_r_w_array[256];  
    uint16_t c2_r_array[256];     
    #pragma DATA_SECTION(c2_r_array,"SHARERAMGS1"); //分配给GS1(CPU1)
    #pragma DATA_SECTION(c2_r_w_array,"SHARERAMGS0"); //分配给GS0(CPU2)
    
    // External variables declared by linker.
    extern uint16_t isrfuncLoadStart;
    extern uint16_t isrfuncLoadEnd;
    extern uint16_t isrfuncRunStart;
    extern uint16_t isrfuncLoadSize;
    
    // Prototype statements for functions found within this file.
    __interrupt void cpu_timer0_isr(void);
    #pragma CODE_SECTION(cpu_timer0_isr,"isrfunc")
    
    void Shared_Ram_dataWrite_c2(void);// function to write data from shared RAM owned by c2
    
    void main(void)
    {
    
    //   InitSysCtrl();
    
    
    // InitGpio();  // Skipped for this example
    
    
     DINT;
    
    
     InitPieCtrl();
    
    
     IER = 0x0000;
     IFR = 0x0000;
    
    
     InitPieVectTable();
    
    // CPU1未分配RAM就一直等待
     while(!( MemCfgRegs.GSxMSEL.bit.MSEL_GS0 &
      	    MemCfgRegs.GSxMSEL.bit.MSEL_GS14 ) )
     {
    
    
     }
    //  将中断拷贝进入RAM
      memcpy(&isrfuncRunStart, &isrfuncLoadStart, (uint32_t)&isrfuncLoadSize);
    
     EALLOW;  // This is needed to write to EALLOW protected registers
     PieVectTable.TIMER0_INT = &cpu_timer0_isr;
     EDIS;    // This is needed to disable write to EALLOW protected registers
    
    
     InitCpuTimers();   // For this example, only initialize the Cpu Timers
    
    //定时器设置为1s
     ConfigCpuTimer(&CpuTimer0, 200, 1000000);
    
    // 启动定时器
     CpuTimer0Regs.TCR.all = 0x4000; // Use write-only instruction to set TSS bit = 0
    
    // Step 5. User specific code, enable interrupts:
    
    // Enable CPU int1 which is connected to CPU-Timer 0
     IER |= M_INT1;
    
    // Enable TINT0 in the PIE: Group 1 interrupt 7
     PieCtrlRegs.PIEIER1.bit.INTx7 = 1;
    
    // Enable global Interrupts and higher priority real-time debug events:
     EINT;   // Enable Global interrupt INTM
     ERTM;   // Enable Global realtime interrupt DBGM
     
     while(1)
     {
     //如果CPU1挂起了中断线FLAG10
          if(IPCRtoLFlagBusy(IPC_FLAG10) == 1)
          {       
              //Read c2_r_array and modify c2_r_w_array  
              Shared_Ram_dataWrite_c2();     //处理CPU1传送来的信息
           
              IPCRtoLFlagAcknowledge (IPC_FLAG10);            //应答
           }            
     }
    }
    
    // function definitions
    __interrupt void cpu_timer0_isr(void)  //每1s进入一次中断程序
    {
     EALLOW;
     CpuTimer0.InterruptCount++;
     GpioDataRegs.GPATOGGLE.bit.GPIO31 = 1; //灯光闪烁一次
     EDIS;
     PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
    }
    
    // Read data from c2_r_array written by CPU01 and 
    // modify and write into c2_r_w_array
    // c2_r_array[0] is used to hold the multiplier value.
    void Shared_Ram_dataWrite_c2(void)
    {
      uint16_t index;
      uint16_t multiplier;
      
      multiplier = c2_r_array[0];
      c2_r_w_array[0] = multiplier;
      
      for(index = 1; index < 256; index ++)
      {
          c2_r_w_array[index] = multiplier*c2_r_array[index];
      }
    }
    

    致谢

    本博客仅供记录学习过程和分享学习心得使用,感谢提供源码的公司。

    第一次开博客了,想记录一下学习的过程。坐标武汉小硕一名,目前在学习dsp。现在想的是做出双核程序,CPU1跑算法,CPU2通过IPC交互信息后跑通信。

    展开全文
  • Electron使用指南——IPC 通信

    千次阅读 2020-08-28 14:15:05
    IPC 通信 1、index.html <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <meta http-equiv="Content-Security-Policy" content="script-src 'self' 'unsafe-inline'"> ...
  • Android Binder IPC通信机制对比

    千次阅读 2018-08-31 10:56:08
    Linux已经拥有管道,system V IPC,socket等IPC手段,却还要倚赖Binder来实现进程间通信,说明Binder具有无可比拟的优势。深入了解Binder并将之与传统IPC做对比有助于我们深入领会进程间通信的实现和性能优化。本文...
  • AIDL:Android Interface Definition Language,即Android接口定义语言,用于生成Android不同进程间进行进程通信(IPC)的代码,一般情况下一个进程是无法访问另一个进程的内存的。如果某些情况下仍然需要跨进程访问内存...
  • IPC 通信内核实现

    千次阅读 2018-05-16 16:29:15
    IPC 通信内核实现1:架构图2:主要实现代码struct task_struct { ..... /* namespaces */ struct nsproxy *nsproxy;}struct nsproxy { atom...
  • zmq 之 ipc 通信

    千次阅读 2020-01-02 22:22:20
    在写zeromq 的程序的时候,我们需要设定的...如下图所示,我才用的是pub-xsub-xpub-sub 的模式,其中sub1 和 xpub 在相同的文件夹下,其能够通过正常ipc 进行通信,但是,sub2 不与xpub 在同一个文件夹下的情况的时...
  • IPC通信机制

    2018-05-02 13:56:17
    通信方式 名字 详解 管道 pipe fifo 管道详细 信号 signal 信号详细 消息队列 massage queue 消息队列详细 共享内存 shared memory 共享内存详细 信号量 普通文件 file 套接字 socket
  • IPC通信的几种方式

    千次阅读 2019-03-03 22:42:39
    为什么要进行进程间的通讯(IPC (Inter-process communication)) 数据传输:一个进程需要将它的数据发送给另一个进程,发送的数据量在一个字节到几M字节之间 共享数据:多个进程想要操作共享数据,一个进程对共享...
  • 参考 https://www.jianshu.com/p/71480c680a65 https://blog.csdn.net/ljd2038/article/details/50767223
  • LPC实现IPC通信.rar

    2021-03-09 11:04:23
    LPC相关函数简介、LPC实现IPC通信文档及代码
  • Linux C/C++:IPC通信

    千次阅读 2019-05-15 15:20:51
    进程间通信IPC,Inter-Process Communication),指至少两个进程或线程间传送数据或信号的一些技术或方法。进程是计算机系统分配资源的最小单位(严格说来是线程)。每个进程都有自己的一部分独立的系统资源,彼此是...
  • 此应用程序创建的了解IPC通信和纸盒的一个示例程序。 目前,我们已经确认了在macOS和Windows 10上的操作。 有关该程序的文章 我使用此应用程序作为示例编写了以下文章。 电子的IPC通信简介(自v12.0.0起)-过渡到更...
  • android IPC通信(下)-AIDL

    万次阅读 2015-12-17 17:30:23
    android IPC通信(上)-sharedUserId&&Messenger  android IPC通信(中)-ContentProvider&&Socket  这篇我们将会着重介绍AIDL的使用方式和原理,要介绍AIDL先要简单介绍一下 Binder,而且 Messenger,...
  • linux下的IPC通信机制

    2017-08-07 16:52:27
    linux下进程间通信的几种主要手段简介: 管道(Pipe)及有名管道(named pipe):管道可用于具有亲缘关系进程间的通信,有名管道克服了管道没有名字的限制,因此,除具有管道所具有的功能外,它还允许无亲缘关系...
  • C6678多核间的IPC通信180615

    千次阅读 2018-06-15 21:27:04
    今天一天看了关于多核通信的内容,放假回来后自己搭建一个多核之间的主辅的拓扑结构通信~,就不先帖图了,等先搭出来。
  • IPC通信方式之LocalSocket

    千次阅读 2017-07-05 15:58:33
    LocalSocket作为一种IPC手段,在Android系统中也有使用,本文通过示例加深对LocalSocket的理解跟运用。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 90,079
精华内容 36,031
关键字:

ipc通信