第九节，ZYNQ的双核启动

最新推荐文章于 2024-07-31 18:41:10 发布
最新推荐文章于 2024-07-31 18:41:10 发布
阅读量4.1k 收藏 46
点赞数 5
分类专栏： zynq学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/youbin2013/article/details/89342330
版权

ZYNQ的双核启动

1 双核运行原理

ZYNQ是一种主从关系的AMP架构，通过松散耦合共享资源，允许两个处理器同时运行自己的操作系统或者裸机应用程序，在各自运行自己的程序或者系统的时候，可以通过共享内存进行双核之间的交互。双核启动中，cpu0完成系统的初始化，控制cpu1的启动，与cpu1通信，读写共享内存；与cpu1进行通信，读写共享内存。

共享资源防止冲突：

1，DDR的内存使用，CPU0使用内存地址为0x00100000-0x001fffff，CPU1的使用地址应该避开这段地址，使用地址设为0x00200000-0x003fffff；

2，CPU1不使用L2内存，仅仅CPU0使用；

3，CPU1从核心在PL的中断路由到PPI控制器，通过使用PPI将中断路由到核心，而CPU0通过ICD路由到核心；

4，当CPU0访问共享内存的时候，CPU1不访问，同理，CPU1访问共享内存的时候，CPU0不访问；

双核运行的过程：

ZYNQ是一个可扩展平台，就是有FPGA作为外设的A9双核处理器，它的启动流程与FPGA完全不同，而与传统的ARM处理器类似，ZYNQ的启动配置需要多个处理步骤，通常情况，需要包含以下3个阶段：

  1. 阶段0：在芯片上电运行后，处理器自动开始stage0-boot，就是片内的BOORROM中的代码，上电复位或者热复位后，处理器执行不可修改的代码；
  2. 阶段1：BOORROM初始化CPU和一些外设后，读取下一个阶段所需的程序代码FSBL（first stage boot loader），它是可以由用户修改控制的代码；
  3. 阶段2：这是用户基于BSP（板级支持包），也可以是操作系统的启动引导程序，这个阶段完全是在用户的控制下实现的；

系统上电启动后，第0阶段启动代码判断启动模式，将第一阶段启动代码FSBL下载到DDR中并且执行。FSBL会配置硬件比特流文件，加载CPU0可执行文件和CPU1可执行文件到DDR对应的链接地址，在这一阶段，所有代码在CPU0中执行，在执行CPU0程序的时候，把CPU1上将要执行的应用程序执行地址写入到OCM的0xFFFFFFF0地址，然后执行       SEV汇编指令，激活CPU1，CPU1激活后，将会到OCM的0xFFFFFFF0地址读取其数值，其数值就是CPU1执行可执行程序的地址，CPU1将从该地址执行。

2 双核运行的配置

2.1 建立工程的区别：

核0建立工程和以前一样，但是核1建立工程与以前不同，需要单独建立一个板级支持包bsp。建立CPU1的板级支持包步骤：

  1. 在SDK主界面主菜单下，选择File->New->Board Support Package；
  2. 出现“New Board Support Package Project”对话框，如图1所示；

图1 新建cpu1板级支持包

  1. 点击finish建立好支持包后，出现“Board Support Package Settings”对话框，在界面左侧窗口中，展开Overview，在展开项中，找到并展开drivers，找到ps_cortexa9_1，并选择它；
  2. 在右侧的Configuration for OS界面中，找到名字为extra_compiler_flags一行，将其对应的Value一列的值改为-g –DUSE_AMP_ = 1，如图2所示；

图2 板级开发包的属性设置

建立好板级开发包后，建立cpu1的sdk工程，该工程的配置与和0也有不同，就是在新建工程对话框的参数配置要与核0不同，其核心选择核心1，板级支持包选择刚刚建立的cpu1的板级支持包（proccessor：ps7_cortexa9_1；Borad Support Package：app_cpu1_bsp），建立好双核的应用工程和板级开发包后，进行软件的设计。

2.2 软件设计：

1，cpu0的软件，在fsbl启动cpu0程序后，其程序需要增加启动cpu1的流程代码；

2，cpu0和cpu1的软件需要有一片共享内存，该内存不能被cache化；

3，通过共享内存的分时访问，设计两个cpu的程序流程；

增加启动cpu1的代码如下：

#define sev()  __asm__("sev")

#define CPU1STARTADDR  0xFFFFFFF0

#define CPU1STARTMEM   0x10000000

void StartCpu1(void)

{

   Xil_Out32(CPU1STARTADDR,CPU1STARTMEM);

   dmb();

   sev();

}

禁用共享内存的代码：

#define COMM_VAL   (*(volatile unsigned long *)(0xffff0000))

    Xil_SetTlbAttributes(0xffff0000,0x14de2);

3 双核源码与测试

3.1 利用共享内存做通讯的例子：

Cpu0代码：

#include "stdio.h"

#include "xil_io.h"

#include "xil_mmu.h"

#include "xil_exception.h"

#include "xpseudo_asm.h"

#include "sleep.h"

 

#define COMM_VAL   (*(volatile unsigned long *)(0xffff0000))

#define sev()  __asm__("sev")

#define CPU1STARTADDR  0xFFFFFFF0

#define CPU1STARTMEM   0x10000000

void StartCpu1(void)

{

    Xil_Out32(CPU1STARTADDR,CPU1STARTMEM);

    dmb();

    sev();

}

int main(void)

{

    Xil_SetTlbAttributes(0xffff0000,0x14de2);

    StartCpu1();

    COMM_VAL = 0;

    while(1)

    {

        print("CPU0:hello world CPU0\r\n");

        sleep(2);

        COMM_VAL = 1;

        while(COMM_VAL == 1);

    }

    return 0;

}

Cpu1代码：

#include "stdio.h"

#include "xil_io.h"

#include "xil_mmu.h"

#include "xil_exception.h"

#include "xpseudo_asm.h"

#include "xparameters.h"

#include "sleep.h"

#define COMM_VAL   (*(volatile unsigned long *)(0xffff0000))

int main(void)

{

    Xil_SetTlbAttributes(0xffff0000,0x14de2);

    while(1)

    {

        while(COMM_VAL == 0);

        print("CPU1:hello world CPU1\r\n");

        sleep(2);

        COMM_VAL = 0;

    }

    return 0;

}

测试结果：

将上述程序生成boot.bin文件，然后下载到flash，启动后通过串口助手可以收到cpu0与cpu1的打印信息，每间隔两秒打印一次，如图3所示。

图3 程序测试

3.2 利用软件中断做通讯的例子：

该例子中，cpu0和cpu1都注册两个软件中断，将1号软件中断注册给cpu1，表示cpu0发送中断给cpu1，将2号软件中断注册给cpu0，表示cpu1发送中断给cpu0；然后在程序运行时，cpu0触发1号软件中断，此时cpu1正在运行主程序被该中断中断，进入中断服务函数，其处理完中断后触发2号软件中断，此时该中断会中断cpu0，进入中断服务函数，cpu0处理完中断后回到主函数，再触发1号软件中断，往复运行。

Cpu0代码：

/*

 * app_cpu0.c

 *

 *  Created on: 2019年3月27日

 *      Author: dz

 */

#include "xil_cache.h"

#include "xparameters.h"

#include "xil_mmu.h"

#include "xil_misc_psreset_api.h"

#include "xil_exception.h"

#include "xscugic.h"

#include "xuartps.h"

#include "stdio.h"

#include "sleep.h"

 

volatile u8 software_intr_received = 0;

#define CORE0_TO_CORE1_INTR_ID   0x01

#define CORE1_TO_CORE0_INTR_ID   0x02

void sys_intr_init(void);

void Setup_Intr_Exception(XScuGic * IntcInstancePtr);

void Scu_Intr_Init(XScuGic* IntancePtr,int Scu_Int_ID);

void Init_Software_Intr(XScuGic *GicInstancePtr, Xil_InterruptHandler IntrHanedler, u16 SoftwareIntrId, u8 CpuId);

void Gen_Software_Intr(XScuGic *GicInstancePtr, u16 SoftwareIntrId, u32 CpuId);

void Cpu0_Intr_Hanedler(void *Callback);

void Cpu1_Intr_Hanedler(void *Callback);

XScuGic ScuGic;

 

void delay(unsigned int count)

{

    int i = 0;

    for(i = 0;i < count;i++)

        ;

}

int main(void)

{

    sys_intr_init();

    xil_printf("cpu0 start!\r\n");

    while(1)

    {

 

        if(XPAR_CPU_ID == 0)

            Gen_Software_Intr(&ScuGic, CORE0_TO_CORE1_INTR_ID, XSCUGIC_SPI_CPU1_MASK);

//          Gen_Software_Intr(&ScuGic, CORE0_TO_CORE1_INTR_ID, XSCUGIC_SPI_CPU0_MASK);

        else

            Gen_Software_Intr(&ScuGic, CORE1_TO_CORE0_INTR_ID, XSCUGIC_SPI_CPU0_MASK);

        delay(200000000);

        if(1 == software_intr_received)

        {

            xil_printf("cpu0_main\r\n");

            software_intr_received = 0;

        }

    }

    return 0;

}

 

 

void sys_intr_init(void)

{

    Scu_Intr_Init(&ScuGic,XPAR_SCUGIC_SINGLE_DEVICE_ID);

//  if(XPAR_CPU_ID == 0)

        Init_Software_Intr(&ScuGic, Cpu0_Intr_Hanedler, CORE0_TO_CORE1_INTR_ID, 0);

//  else

        Init_Software_Intr(&ScuGic, Cpu1_Intr_Hanedler, CORE1_TO_CORE0_INTR_ID, 1);

    Setup_Intr_Exception(&ScuGic);

}

 

void Setup_Intr_Exception(XScuGic * IntcInstancePtr)

{

    //connect hardware interrupt

    Xil_ExceptionInit();

Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,(Xil_ExceptionHandler)XScuGic_InterruptHandler,(void *)IntcInstancePtr);

    //enable hardware interrupt

    Xil_ExceptionEnable();

}

 

void Scu_Intr_Init(XScuGic* IntancePtr,int Scu_Int_ID)

{

    XScuGic_Config *ScuConfigPtr;

    //find device

    ScuConfigPtr = XScuGic_LookupConfig(Scu_Int_ID);

    //config scuint

    XScuGic_CfgInitialize(IntancePtr, ScuConfigPtr,ScuConfigPtr->CpuBaseAddress);

}

 

void Cpu0_Intr_Hanedler(void *Callback)

{

    xil_printf("receive interrupt from core1!\r\n");

    software_intr_received = 1;

}

 

void Cpu1_Intr_Hanedler(void *Callback)

{

    xil_printf("receive interrupt from core0!\r\n");

    software_intr_received = 1;

}

 

void Init_Software_Intr(XScuGic *GicInstancePtr, Xil_InterruptHandler IntrHanedler, u16 SoftwareIntrId, u8 CpuId)

{

    int Status;

//  XScuGic_SetPriorityTriggerType(GicInstancePtr, SoftwareIntrId, 0xB0, 0x2);

    XScuGic_SetPriorityTriggerType(GicInstancePtr, SoftwareIntrId, 0xd0, 0x3);

    Status = XScuGic_Connect(GicInstancePtr, SoftwareIntrId,

                 (Xil_InterruptHandler)IntrHanedler, NULL);

    if (Status != XST_SUCCESS) {

        xil_printf("core%d: interrupt %d set fail!\r\n", XPAR_CPU_ID, SoftwareIntrId);

        return;

    }

    XScuGic_InterruptMaptoCpu(GicInstancePtr, CpuId, SoftwareIntrId); //map the the Software interrupt to target CPU

    XScuGic_Enable(GicInstancePtr, SoftwareIntrId);//enable the interrupt for the Software interrupt at GIC

 }

 

void Gen_Software_Intr(XScuGic *GicInstancePtr, u16 SoftwareIntrId, u32 CpuId)

{

    int Status;

    Status = XScuGic_SoftwareIntr(GicInstancePtr, SoftwareIntrId, CpuId);

    if (Status != XST_SUCCESS) {

        xil_printf("core%d: interrupt %d gen fail!\r\n", XPAR_CPU_ID, SoftwareIntrId);

        return;

    }

}

 

Cpu1代码：

/*

 * app_cpu0.c

 *

 *  Created on: 2019年3月27日

 *      Author: dz

 */

#include "xil_cache.h"

#include "xparameters.h"

#include "xil_mmu.h"

#include "xil_misc_psreset_api.h"

#include "xil_exception.h"

#include "xscugic.h"

#include "xuartps.h"

#include "stdio.h"

#include "sleep.h"

 

volatile u8 software_intr_received = 0;

#define CORE0_TO_CORE1_INTR_ID   0x01

#define CORE1_TO_CORE0_INTR_ID   0x02

void sys_intr_init(void);

void Setup_Intr_Exception(XScuGic * IntcInstancePtr);

void Scu_Intr_Init(XScuGic* IntancePtr,int Scu_Int_ID);

void Init_Software_Intr(XScuGic *GicInstancePtr, Xil_InterruptHandler IntrHanedler, u16 SoftwareIntrId, u8 CpuId);

void Gen_Software_Intr(XScuGic *GicInstancePtr, u16 SoftwareIntrId, u32 CpuId);

void Cpu0_Intr_Hanedler(void *Callback);

void Cpu1_Intr_Hanedler(void *Callback);

XScuGic ScuGic;

 

void delay(unsigned int count)

{

    int i = 0;

    for(i = 0;i < count;i++)

        ;

}

 

int main(void)

{

    sys_intr_init();

//  Gen_Software_Intr(&ScuGic, CORE1_TO_CORE0_INTR_ID, XSCUGIC_SPI_CPU1_MASK);

    xil_printf("cpu1 start!\r\n");

    while(1)

    {

        if(1 == software_intr_received)

        {

            software_intr_received = 0;

 

            if(XPAR_CPU_ID == 0)

                Gen_Software_Intr(&ScuGic, CORE0_TO_CORE1_INTR_ID, XSCUGIC_SPI_CPU1_MASK);

//              Gen_Software_Intr(&ScuGic, CORE0_TO_CORE1_INTR_ID, XSCUGIC_SPI_CPU0_MASK);

            else

                Gen_Software_Intr(&ScuGic, CORE1_TO_CORE0_INTR_ID, XSCUGIC_SPI_CPU0_MASK);

            delay(200000000);

            xil_printf("cpu1_main\r\n");

        }

    }

    return 0;

}

 

void sys_intr_init(void)

{

    Scu_Intr_Init(&ScuGic,XPAR_SCUGIC_SINGLE_DEVICE_ID);

//  if(XPAR_CPU_ID == 0)

        Init_Software_Intr(&ScuGic, Cpu0_Intr_Hanedler, CORE0_TO_CORE1_INTR_ID, 0);

//  else

        Init_Software_Intr(&ScuGic, Cpu1_Intr_Hanedler, CORE1_TO_CORE0_INTR_ID, 1);

    Setup_Intr_Exception(&ScuGic);

}

 

void Setup_Intr_Exception(XScuGic * IntcInstancePtr)

{

    //connect hardware interrupt

    Xil_ExceptionInit();

Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,(Xil_ExceptionHandler)XScuGic_InterruptHandler,(void *)IntcInstancePtr);

    //enable hardware interrupt

    Xil_ExceptionEnable();

}

 

void Scu_Intr_Init(XScuGic* IntancePtr,int Scu_Int_ID)

{

    XScuGic_Config *ScuConfigPtr;

    //find device

    ScuConfigPtr = XScuGic_LookupConfig(Scu_Int_ID);

    //config scuint

    XScuGic_CfgInitialize(IntancePtr, ScuConfigPtr,ScuConfigPtr->CpuBaseAddress);

}

 

void Cpu0_Intr_Hanedler(void *Callback)

{

    xil_printf("receive interrupt from core1!\r\n");

    software_intr_received = 1;

}

 

void Cpu1_Intr_Hanedler(void *Callback)

{

    xil_printf("receive interrupt from core0!\r\n");

    software_intr_received = 1;

}

 

void Init_Software_Intr(XScuGic *GicInstancePtr, Xil_InterruptHandler IntrHanedler, u16 SoftwareIntrId, u8 CpuId)

{

    int Status;

    XScuGic_SetPriorityTriggerType(GicInstancePtr, SoftwareIntrId, 0xB0, 0x2);

//  XScuGic_SetPriorityTriggerType(GicInstancePtr, SoftwareIntrId, 0xd0, 0x3);

    Status = XScuGic_Connect(GicInstancePtr, SoftwareIntrId,

                 (Xil_InterruptHandler)IntrHanedler, NULL);

    if (Status != XST_SUCCESS) {

        xil_printf("core%d: interrupt %d set fail!\r\n", XPAR_CPU_ID, SoftwareIntrId);

        return;

    }

    XScuGic_InterruptMaptoCpu(GicInstancePtr, CpuId, SoftwareIntrId); //map the the Software interrupt to target CPU

    XScuGic_Enable(GicInstancePtr, SoftwareIntrId);//enable the interrupt for the Software interrupt at GIC

 }

 

 

void Gen_Software_Intr(XScuGic *GicInstancePtr, u16 SoftwareIntrId, u32 CpuId)

{

    int Status;

    Status = XScuGic_SoftwareIntr(GicInstancePtr, SoftwareIntrId, CpuId);

    if (Status != XST_SUCCESS) {

        xil_printf("core%d: interrupt %d gen fail!\r\n", XPAR_CPU_ID, SoftwareIntrId);

        return;

    }

}

 

将上述程序生成boot.bin文件，然后下载到flash，启动后通过串口助手可以收到cpu0与cpu1的打印信息，每间隔两秒打印一次，如图4所示。

图4 测试结果

 

youbin2013
关注
专栏目录
ZYNQ双核AMP官方例程（双核分别跑Linux+裸机实现核间通信）
04-25
总的来说，"ZYNQ双核AMP官方例程"提供了一个学习和实践核间通信的理想平台，对于想要深入理解ZYNQ SoC和嵌入式系统设计的开发者来说，这是一个宝贵的资源。通过这个项目，你可以掌握如何有效地利用双核架构，优化...
vivado SDK 双核运行
weixin_45045906的博客
12-03 1067
vivado SDK 双核运行
zynq双核AMP实验之cpu1唤醒代码
weixin_42628470的博客
07-07 1694
一·多核CPU的运行模式     从软件的角度看，多核处理器的运行模式有 AMP（非对称多处理）、SMP（对称多处理）和 BMP（受约束多处理）三种运行模式。     AMP 运行模式指多个内核相对独立的运行不同的任务，每个内核相互隔离，可以运行不同的操作系统（OS）或裸机应用程序。     SMP 运行模式指多个处理器运行一个操作系统，这个操作系统同等的管理多个内核，如 PC 电脑。     BMP 运行模式与 SMP 类似，但开发者可以指定将某个任务仅在某个指定内核上执行。      二.唤醒CPU1
ZYNQ系列---I2C控制器使用教程
最新发布
qq_52538756的博客
07-31 1298
I2C是FPGA入门总线之一，相信大家已经编写过无数遍了，本篇文章将讲述ZYNQ系列---I2C控制器使用方法。I2C控制器使用起来简单方便，底层驱动已经很完善了，我们只需要了解对应的函数就可以完成I2C的读写，是不是又学会一个偷懒的技巧，最后强调一下，I2C的设备ID和ZYNQ的DDR配置不要搞错。
ZYNQ PS端的Cache问题
NoNoUnknow的博客
11-13 1582
CacheFlush把Cache里的数据清空，将Cache内容推到DDR中；而Cache Invalidate表示当场宣布Cache内容无效，需要从DDR中重新加载数据，即把数据从DDR中拉到Cache中。可以禁用掉0x1F00 0000区域的Cache，以上是让CPU将直接访问DDR内存，读写都是直接的。这样显然会降低CPU性能，但简化了数据传输操作，属于极端的方法。这个操作在双核读取同一片区域来通信的操作中常用。以上是相对柔和的方法，使用。
【正点原子FPGA连载】第十三章双核AMP实验-领航者 ZYNQ 之嵌入式开发指南
kunkliu的博客
07-01 2013
第十三章双核AMP实验 在前面的例程中，实现的都是基于单核CPU的实验，在很多应用场景中，往往只需要使用其中的一个CPU即可实现相应的功能。然而对于复杂的设计，如多任务处理、并行控制等，单个CPU将难以胜任。ZYNQ 7000 SOC芯片内部集成了两个独立的Cortex-A9内核处理器，即两个CPU，可以很好的应对各种复杂的设计。本章我们来学习下基于双核AMP的实验。 本章包括以下几个部分： 1313.1简介 13.2实验任务 13.3硬件设计 13.4软件设计 13.5下载验证 13.1简介 多核处理器从
中断：PL硬中断，基地址，优先级。
NoNoUnknow的博客
10-14 786
1.编写RTL文件，设置中断的触发条件和频率，将其封装成IP；2.配置BD，为上述IP提供CLK和RST，注意敏感列表；3.配置BD内中断，分配中断号：PL终端号可选：#61 至 #68 和 #84 至 #914.启动Vitis，在C文件中绑定CPUID，并使能硬中断的中断号，连接，配置优先级和灵敏度类型。
ZYNQ双核处理器独立运行AMP
mxh3600的博客
02-24 2985
ZYNQ双核处理器独立运行AMP
ZYNQ程序固化基本流程
06-30
Zynq-7000是一款高度集成的系统级芯片，由Xilinx公司生产，集成了ARM Cortex-A9双核处理器和可编程逻辑(FPGA)。以下是对这个过程的详细解释： **第一阶段：BOOT ROM** 1. **启动选择**：当AX7010或AX7020开发板上...
Zynq7000 嵌入式系统软硬协同设计第9章
11-19
在本章“Zynq7000 嵌入式系统软硬协同设计第9章”中，我们将深入探讨基于Xilinx Zynq-7000系列SoC（System on Chip）的嵌入式系统开发。Zynq7000是一个高度集成的器件，集成了双核ARM Cortex-A9处理器和可编程逻辑...
zynq无DDR设计参考
10-07
2. "zynq双核AMP在QSPI中XIP加载运行.xps"：AMP（Asymmetric Multiprocessing）指的是两个CPU核心执行不同的任务，可能需要单独的启动流程。这个文件可能描述了如何在QSPI Flash中实现双核AMP系统的XIP加载和运行。 ...
ZYNQ有两个CPU？（三）——SGI异步通信
weixin_39598029的博客
11-21 712
** ZYNQ有两个CPU？（三）——SGI异步通信 ** 本文转载自：https://zhuanlan.zhihu.com/p/30653352 前面两篇文章中我分享了ZYNQ上在Standalone环境下搭建AMP和用OCM共享内存传递数据的方法。而到目前为止实现的功能是在两个CPU上跑了多线程，线程之间可以通过共享内存进行同步通信，而我们知道同步通信需要耗费大量的CPU时间，为了节约CPU时间必须要采用异步通信的方式也就是中断方式。这篇文章的SGI测试方案是这样的：由CPU0绑定软件中断0的中断服务函
【ZYNQ 开发】AMP双arm核交互 - 环境搭建（1）
Gatsby2023的博客
01-22 1890
从软件的角度来看，多核处理器的运行模式有三种：多个核心相对独立的运行不同的任务，每个核心可能运行不同的操作系统或裸机程序，但是有一个主要核心，用来控制整个系统以及其它从核心的运行。SMP（对称多进程） ：一个操作系统同等的管理各个内核，例如 PC 机与 SMP 类似，但开发者可以指定将某个任务仅在某个指定内核上执行。
ZYNQ的程序固化~AMP跑双核
NoNoUnknow的博客
10-09 866
确定启动方式后，BootROM 从相应的启动设备(SD Card/QSPI Flash)加 载 First Stage Bootloader (FSBL)或 用 户 代 码 到 On Chip Memory(OCM)的 RAM 上，并且将执行权交付给 FSBL，这个被拷贝到片上 RAM 执行的程序就来自用户自设计的BOOT.bin。标头搜索将继续，直到找到有效的标头或搜索整个范围。这里，BootROM 配置 PS 来访问引导设备，读取引导标头，验证标头，然后通常将 FSBL/用户代码复制到 OCM 内存。
ZYNQ基础----双核硬中断（PL to PS）
black_pigeon博客
07-02 4447
PL端中断   在上一篇博客中介绍了软中断，软中断可以用于ZYNQ的两个CPU之间进行中断，一次来进行两个CPU之间的通信，在ZYNQ的架构中，PL端也能够向PS端提供中断，PL端向PS端的中断一共有16个。   可以看到PL端的中断，通过SPI连接到GIC上,在双核模式下使用PL端的中断时，需要对中断进行绑定。 搭建硬件系统   为了快速上手，对双核AMP模式下的硬中断使用， ...
Xilinx zynq系列pcie xdma通信（二）：下位机PS端
kunkliu的博客
09-28 2806
在上一篇博文中介绍了PL端的设置，本文继续介绍PS端的设置。PS端仅用于验证上位机读写DDR3是否正确，因此相对比较简单。 一、新建SDK项目 在生成好bit文件之后先Export Hardware 启动SDK 打开SDK后界面如图，可以看到自动生成了一个platform_0的文件夹，这个文件夹里的内容就是之前文章中zynq的一些配置内容。当工程目录发生更改后，SDK又会再自动...
【ZYNQ入门】第三篇、双核AMP运行模式程序开发
大屁桃的博客
01-03 3116
介绍了ZYNQAMP模式的搭建方法以及生成BOOT.bin文件的办法
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值