欢迎来到皮皮网官网

【licmanager源码】【redis网络源码分析】【抖音直连源码】U校源码

时间:2024-12-23 08:56:06 来源:探花头像源码

1.写出下面题目的校源码程序代码(C++) 并且输入输出都截个 谢谢~
2.代码是什么意思?
3.如何获得优先级在Linux环境编程中?
4.Zynq GTX全网最细讲解,aurora 8b/10b协议,校源码OV5640板对板视频传输,校源码提供2套工程源码和技术支持

U校源码

写出下面题目的校源码程序代码(C++) 并且输入输出都截个 谢谢~

       //记的以前学校时写过,好像是校源码POJ的题目。源代码还在电脑上留着,校源码licmanager源码仅供参考

       #include <iostream>

       #include <cmath>

       using namespace std;

       const int MAXN = ;

       const int MAXM = ;

       const int MAXP = ;

       const int MAXT = 6;

       struct Tpoint {

        int x,校源码 y;

       };

       Tpoint u[MAXN],v[MAXN],w[MAXN],p[MAXN];

       int step[4][2] = { { 0,1}, { 0,-1}, { 1,0}, { -1,0}};

       int mark[MAXM][MAXM], map[MAXP][MAXP], board[MAXT][MAXT];

       int num, cnt, ver, size;

       bool cover[MAXM][MAXM];

       char line[MAXM][MAXM];

       //判断B集合中的连通性

       inline int connect(int x, int y)

       {

        int front = 0, rear = 1;

        w[rear].x = x; w[rear].y = y; board[x][y] = 0;

        while(front < rear) {

        front ++;

        for(int i = 0; i < 4; i ++) {

        int tx = w[front].x + step[i][0];

        int ty = w[front].y + step[i][1];

        if(tx >= 0 && tx < size && ty >= 0 && ty < size && board[tx][ty]) {

        board[tx][ty] = 0;

        rear++;

        w[rear].x = tx;

        w[rear].y = ty;

        }

        }

        }

        return rear;

       }

       //通过平移判断两个集合是否刚好构成N*N的图形

       inline bool match(int minx2, int miny2, int maxx2, int maxy2, int maxx1, int maxy1)

       {

        for(int i = maxx2 - size + 1; i < minx2 + size - maxx1; i ++) {

        for(int j = maxy2 - size + 1; j < miny2 + size - maxy1; j ++) {

        bool flag = true;

        for(int k = 0; k < num; k ++) {

        if(map[v[k].x+i][v[k].y+j]) {

        flag = false;

        break;

        }

        }

        if(flag) return true; //集合A和集合B刚好能组成size*size的正方形,返回true;

        }

        }

        return false;

       }

       inline bool ok(int minx2,校源码 int miny2, int maxx2, int maxy2) //参数传递集合A的边界

       {

        int i, j, minx1, miny1, maxx1, maxy1;

        minx1 = miny1 = ; maxx1 = maxy1 = 0;

        for(i = 0; i < ver; i ++) {

        if(! cover[p[i].x][p[i].y]) { //标记集合B的边界

        if(minx1 > p[i].x) minx1 = p[i].x;

        if(miny1 > p[i].y) miny1 = p[i].y;

        if(maxx1 < p[i].x) maxx1 = p[i].x;

        if(maxy1 < p[i].y) maxy1 = p[i].y;

        }

        }

        num = 0;

        memset(map, 0, sizeof(map));

        for(i = 0; i < ver; i ++) {

        if(! cover[p[i].x][p[i].y]) {

        if((p[i].x - minx1 >= size) || (p[i].y - miny1 >= size))

        return false;

        //集合B的边界超过size*size,返回false

        v[num].x = p[i].x - minx1; //将集合B往左上角移

        v[num].y = p[i].y - miny1;

        num ++;

        }else {

        map[p[i].x - minx2 + 5][p[i].y - miny2 + 5]=1; //将集合A往右下角移

        }

        }

        memset(board,校源码 0, sizeof(board));

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

        board[v[i].x][v[i].y] = 1;

        if(connect(v[0].x,v[0].y)<num) return false; //集合B不连通返回false

        maxx2 = maxx2 - minx2 + 5; maxy2 = maxy2 - miny2 + 5;

        minx2 = miny2 = 5;

        maxx1 = maxx1 - minx1; maxy1 = maxy1 - miny1;

        minx1 = miny1 = 0;

        for(i = 0; i < 4; i ++) { //4次旋转

        if(match(minx2, miny2, maxx2, maxy2, maxx1, maxy1))

        //集合A与B刚好能够组成size*size的正方形,返回true

        return true;

        minx1 = miny1 = INT_MAX; maxx1 = maxy1 = INT_MIN;

        for(j = 0; j < num; j ++) {

        int temp = v[j].y;

        v[j].y = size - v[j].x - 1;

        v[j].x = temp;

        if(minx1 > v[j].x) minx1 = v[j].x;

        if(miny1 > v[j].y) miny1 = v[j].y;

        if(maxx1 < v[j].x) maxx1 = v[j].x;

        if(maxy1 < v[j].y) maxy1 = v[j].y;

        }

        for(j = 0; j < num; j ++) {

        v[j].x -= minx1; v[j].y -= miny1; //将集合B往左上角移

        }

        maxx1 -= minx1;maxy1 -= miny1;

        }

        return false;

       }

       inline bool dfs(int minx,校源码 int miny, int maxx, int maxy, int m, int k)

       {

        if(k > m) return false;

        if(dfs(minx, miny, maxx, maxy, m, k + 1)) return true; //k点不属于集合A

        if(abs(u[k].x - minx) >= size || abs(u[k].y - miny) >= size ||

        abs(u[k].x - maxx) >= size || abs(u[k].y - maxy) >= size)

        //若集合A超过边界size,则返回false

        return false;

        int i,校源码 tx, ty;

        for(i = 0; i < 4; i ++) {

        tx = u[k].x + step[i][0];

        ty = u[k].y + step[i][1];

        if(line[tx][ty] == '*' && ! mark[tx][ty]) { //可扩展点进行标记

        m ++;

        u[m].x = tx;

        u[m].y = ty;

        mark[tx][ty] = k;

        }

        }

        cover[u[k].x][u[k].y] = true;

        if(ok(__min(minx, u[k].x), __min(miny, u[k].y), __max(maxx, u[k].x), __max(maxy, u[k].y)))

        //若刚好能组成size*size的正方形,则返回true

        return true;

        if(dfs(__min(minx,校源码 u[k].x), __min(miny, u[k].y), __max(maxx, u[k].x), __max(maxy,u[k].y), m, k + 1))//继续搜索集合A,若成功返回true

        return true;

        cover[u[k].x][u[k].y] = false;

        for(i = 0; i < 4; i ++) {

        tx = u[k].x + step[i][0];

        ty = u[k].y + step[i][1];

        if(mark[tx][ty] == k) mark[tx][ty] = 0; //消除标记

        }

        return false;

       }

       int main()

       {

        cnt = 0;

        while(gets(line[cnt++])); //读入数据

        ver = 0;

        for(int i = 0; i < cnt; i ++)

        for(int j = 0; line[i][j]; j ++)

        if(line[i][j] == '*') {

        p[ver].x = i; p[ver].y = j; ver ++;

        }

        size = (int)sqrt((double)ver); //正方形的校源码边长为size

        memset(cover, false, sizeof(cover));

        memset(mark, 0, sizeof(mark));

        u[1].x = p[0].x; u[1].y = p[0].y;

        mark[u[1].x][u[1].y] = -1;

        dfs(u[1].x, u[1].y, u[1].x, u[1].y, 1, 1); //搜索集合A的可能情况

        for(i = 0; i < cnt; i ++) {

        for(int j = 0; line[i][j]; j ++) {

        if(line[i][j]=='*') {

        if(cover[i][j]) printf("A");

        else printf("B");

        }else printf(".");

        }

        printf("\n");

        }

        return(0);

       }

代码是什么意思?

       代码就是程序员用开发工具所支持的语言写出来的源文件,是校源码一组由字符、符号或信号码元以离散形式表示信息的校源码明确的规则体系。代码设计的原则包括唯一确定性、标准化和通用性、可扩充性与稳定性、便于识别与记忆、力求短小与格式统一以及容易修改等。

       在现代程序语言中,redis网络源码分析源代码可以是以书籍或者磁带的形式出现,但最为常用的格式是文本文件,这种典型格式的目的是为了编译出计算机程序。

       

扩展资料:

       开放源代码

       您购买或下载的大多数软件只提供已编译的可运行版本。“已编译”意味着开发人员创建的实际程序代码(称为源代码)已经由一个称为编译器的特殊程序进行过处理,该程序将源代码转换为计算机可以理解的格式。

       修改大多数应用程序的已编译版本都是极其困难的,人们几乎不可能知道开发人员究竟是如何创建程序的各个部分的。

       开放源代码软件恰恰相反。源代码随已编译的版本一起提供,而且事实上鼓励人们修改或定制。支持开放源代码概念的软件开发人员相信,通过允许感兴趣的人修改源代码,应用程序将会更加完善,并且在很长时间内不会出现错误。

       百度百科-代码

如何获得优先级在Linux环境编程中?

       ä»€ä¹ˆæ˜¯å®žæ—¶ç³»ç»Ÿï¼ŒPOSIX .b作了这样的定义:指系统能够在限定的响应时间内提供所需水平的服务。而一个由Donald Gillies提出的更加为大家接受的定义是:一个实时系统是指计算的正确性不仅取决于程序的逻辑正确性,也取决于结果产生的时间,如果系统的时间约束条件得不到满足,将会发生系统出错。

        实时系统根据其对于实时性要求的不同,可以分为软实时和硬实时两种类型。硬实时系统指系统要有确保的最坏情况下的服务时间,即对于事件的响应时间的截止期限是无论如何都必须得到满足。比如航天中的宇宙飞船的控制等就是现实中这样的系统。其他的所有有实时特性的系统都可以称之为软实时系统。如果明确地来说,软实时系统就是那些从统计的角度来说,一个任务(在下面的论述中,我们将对任务和进程不作区分)能够得到有确保的处理时间,到达系统的事件也能够在截止期限到来之前得到处理,但违反截止期限并不会带来致命的错误,像实时多媒体系统就是一种软实时系统。

        一个计算机系统为了提供对于实时性的支持,它的操作系统必须对于CPU和其他资源进行有效的调度和管理。在多任务实时系统中,资源的调度和管理更加复杂。本文下面将先从分类的角度对各种实时任务调度算法进行讨论,然后研究普通的 Linux操作系统的进程调度以及各种实时Linux系统为了支持实时特性对普通Linux系统所做的改进。最后分析了将Linux操作系统应用于实时领域中时所出现的一些问题,并总结了各种实时Linux是如何解决这些问题的。

        1. 实时CPU调度算法分类

        各种实时操作系统的实时调度算法可以分为如下三种类别[Wang][Gopalan]:基于优先级的调度算法(Priority-driven scheduling-PD)、基于CPU使用比例的共享式的调度算法(Share-driven scheduling-SD)、以及基于时间的进程调度算法(Time-driven scheduling-TD),下面对这三种调度算法逐一进行介绍。

        1.1. 基于优先级的调度算法

        基于优先级的调度算法给每个进程分配一个优先级,在每次进程调度时,调度器总是调度那个具有最高优先级的任务来执行。根据不同的优先级分配方法,基于优先级的调度算法可以分为如下两种类型[Krishna][Wang]:

        静态优先级调度算法:

        这种调度算法给那些系统中得到运行的所有进程都静态地分配一个优先级。静态优先级的分配可以根据应用的属性来进行,比如任务的周期,用户优先级,或者其它的预先确定的策略。RM(Rate-Monotonic)调度算法是一种典型的静态优先级调度算法,它根据任务的执行周期的长短来决定调度优先级,那些具有小的执行周期的任务具有较高的优先级。

        动态优先级调度算法:

        这种调度算法根据任务的资源需求来动态地分配任务的优先级,其目的就是在资源分配和调度时有更大的灵活性。非实时系统中就有很多这种调度算法,比如短作业优先的调度算法。在实时调度算法中, EDF算法是使用最多的一种动态优先级调度算法,该算法给就绪队列中的各个任务根据它们的截止期限(Deadline)来分配优先级,具有最近的截止期限的任务具有最高的优先级。

        1.2. 基于比例共享调度算法

        虽然基于优先级的调度算法简单而有效,但这种调度算法提供的是一种硬实时的调度,在很多情况下并不适合使用这种调度算法:比如象实时多媒体会议系统这样的软实时应用。对于这种软实时应用,使用一种比例共享式的资源调度算法(SD算法)更为适合。

        比例共享调度算法指基于CPU使用比例的共享式的调度算法,其基本思想就是按照一定的权重(比例)对一组需要调度的任务进行调度,让它们的执行时间与它们的权重完全成正比。

        我们可以通过两种方法来实现比例共享调度算法[Nieh]:第一种方法是调节各个就绪进程出现在调度队列队首的频率,并调度队首的进程执行;第二种做法就是逐次调度就绪队列中的各个进程投入运行,但根据分配的权重调节分配个每个进程的运行时间片。

        比例共享调度算法可以分为以下几个类别:轮转法、公平共享、公平队列、彩票调度法(Lottery)等。

        比例共享调度算法的一个问题就是它没有定义任何优先级的概念;所有的任务都根据它们申请的比例共享CPU资源,当系统处于过载状态时,所有的任务的执行都会按比例地变慢。所以为了保证系统中实时进程能够获得一定的CPU处理时间,一般采用一种动态调节进程权重的方法。

        1.3. 基于时间的进程调度算法

        对于那些具有稳定、已知输入的简单系统,可以使用时间驱动(Time-driven:TD)的调度算法,它能够为数据处理提供很好的预测性。这种调度算法本质上是一种设计时就确定下来的离线的静态调度方法。在系统的设计阶段,在明确系统中所有的处理情况下,对于各个任务的开始、切换、以及结束时间等就事先做出明确的安排和设计。这种调度算法适合于那些很小的嵌入式系统、自控系统、传感器等应用环境。

        这种调度算法的优点是任务的执行有很好的可预测性,但最大的缺点是缺乏灵活性,并且会出现有任务需要被执行而CPU却保持空闲的情况。

        2. 通用Linux系统中的CPU调度

        通用Linux系统支持实时和非实时两种进程,实时进程相对于普通进程具有绝对的优先级。对应地,实时进程采用SCHED_FIFO或者SCHED_RR调度策略,普通的进程采用SCHED_OTHER调度策略。

        在调度算法的实现上,Linux中的每个任务有四个与调度相关的参数,它们是rt_priority、policy、priority(nice)、counter。调度程序根据这四个参数进行进程调度。

        在SCHED_OTHER 调度策略中,调度器总是选择那个priority+counter值最大的进程来调度执行。从逻辑上分析,SCHED_OTHER调度策略存在着调度周期(epoch),在每一个调度周期中,一个进程的priority和counter值的大小影响了当前时刻应该调度哪一个进程来执行,其中 priority是一个固定不变的值,在进程创建时就已经确定,它代表了该进程的优先级,也代表这该进程在每一个调度周期中能够得到的时间片的多少; counter是一个动态变化的值,它反映了一个进程在当前的调度周期中还剩下的时间片。在每一个调度周期的开始,priority的值被赋给 counter,然后每次该进程被调度执行时,counter值都减少。当counter值为零时,该进程用完自己在本调度周期中的时间片,不再参与本调度周期的进程调度。当所有进程的时间片都用完时,一个调度周期结束,然后周而复始。另外可以看出Linux系统中的调度周期不是静态的,它是一个动态变化的量,比如处于可运行状态的进程的多少和它们priority值都可以影响一个epoch的长短。值得注意的一点是,在2.4以上的内核中, priority被nice所取代,但二者作用类似。

        可见SCHED_OTHER调度策略本质上是一种比例共享的调度策略,它的这种设计方法能够保证进程调度时的公平性--一个低优先级的进程在每一个epoch中也会得到自己应得的那些CPU执行时间,另外它也提供了不同进程的优先级区分,具有高priority值的进程能够获得更多的执行时间。

        对于实时进程来说,它们使用的是基于实时优先级rt_priority的优先级调度策略,但根据不同的调度策略,同一实时优先级的进程之间的调度方法有所不同:

        SCHED_FIFO:不同的进程根据静态优先级进行排队,然后在同一优先级的队列中,谁先准备好运行就先调度谁,并且正在运行的进程不会被终止直到以下情况发生:1.被有更高优先级的进程所强占CPU;2.自己因为资源请求而阻塞;3.自己主动放弃CPU(调用sched_yield);

        SCHED_RR:这种调度策略跟上面的SCHED_FIFO一模一样,除了它给每个进程分配一个时间片,时间片到了正在执行的进程就放弃执行;时间片的长度可以通过sched_rr_get_interval调用得到;

        由于Linux系统本身是一个面向桌面的系统,所以将它应用于实时应用中时存在如下的一些问题:

        Linux系统中的调度单位为ms,所以它不能够提供精确的定时;

        当一个进程调用系统调用进入内核态运行时,它是不可被抢占的;

        Linux内核实现中使用了大量的封中断操作会造成中断的丢失;

        由于使用虚拟内存技术,当发生页出错时,需要从硬盘中读取交换数据,但硬盘读写由于存储位置的随机性会导致随机的读写时间,这在某些情况下会影响一些实时任务的截止期限;

        虽然Linux进程调度也支持实时优先级,但缺乏有效的实时任务的调度机制和调度算法;它的网络子系统的协议处理和其它设备的中断处理都没有与它对应的进程的调度关联起来,并且它们自身也没有明确的调度机制;

        3. 各种实时Linux系统

        3.1. RT-Linux和RTAI

        RT -Linux是新墨西哥科技大学(New Mexico Institute of Technology)的研究成果[RTLinuxWeb][Barabanov]。它的基本思想是,为了在Linux系统中提供对于硬实时的支持,它实现了一个微内核的小的实时操作系统(我们也称之为RT-Linux的实时子系统),而将普通Linux系统作为一个该操作系统中的一个低优先级的任务来运行。另外普通Linux系统中的任务可以通过FIFO和实时任务进行通信。RT-Linux的框架如图 1所示:

       å›¾ 1 RT-Linux结构

       RT -Linux的关键技术是通过软件来模拟硬件的中断控制器。当Linux系统要封锁CPU的中断时时,RT-Linux中的实时子系统会截取到这个请求,把它记录下来,而实际上并不真正封锁硬件中断,这样就避免了由于封中断所造成的系统在一段时间没有响应的情况,从而提高了实时性。当有硬件中断到来时, RT-Linux截取该中断,并判断是否有实时子系统中的中断例程来处理还是传递给普通的Linux内核进行处理。另外,普通Linux系统中的最小定时精度由系统中的实时时钟的频率决定,一般Linux系统将该时钟设置为每秒来个时钟中断,所以Linux系统中一般的定时精度为 ms,即时钟周期是ms,而RT-Linux通过将系统的实时时钟设置为单次触发状态,可以提供十几个微秒级的调度粒度。

        RT-Linux实时子系统中的任务调度可以采用RM、EDF等优先级驱动的算法,也可以采用其他调度算法。

        RT -Linux对于那些在重负荷下工作的专有系统来说,确实是一个不错的选择,但他仅仅提供了对于CPU资源的调度;并且实时系统和普通Linux系统关系不是十分密切,这样的话,开发人员不能充分利用Linux系统中已经实现的功能,如协议栈等。所以RT-Linux适合与工业控制等实时任务功能简单,并且有硬实时要求的环境中,但如果要应用与多媒体处理中还需要做大量的工作。

        意大利的RTAI( Real-Time Application Interface )源于RT-Linux,它在设计思想上和RT-Linux完全相同。它当初设计目的是为了解决RT-Linux难于在不同Linux版本之间难于移植的问题,为此,RTAI在 Linux 上定义了一个实时硬件抽象层,实时任务通过这个抽象层提供的接口和Linux系统进行交互,这样在给Linux内核中增加实时支持时可以尽可能少地修改 Linux的内核源代码。

        3.2. Kurt-Linux

        Kurt -Linux由Kansas大学开发,它可以提供微秒级的实时精度[KurtWeb] [Srinivasan]。不同于RT-Linux单独实现一个实时内核的做法,Kurt -Linux是在通用Linux系统的基础上实现的,它也是第一个可以使用普通Linux系统调用的基于Linux的实时系统。

        Kurt-Linux将系统分为三种状态:正常态、实时态和混合态,在正常态时它采用普通的Linux的调度策略,在实时态只运行实时任务,在混合态实时和非实时任务都可以执行;实时态可以用于对于实时性要求比较严格的情况。

        为了提高Linux系统的实时特性,必须提高系统所支持的时钟精度。但如果仅仅简单地提高时钟频率,会引起调度负载的增加,从而严重降低系统的性能。为了解决这个矛盾, Kurt-Linux采用UTIME所使用的提高Linux系统中的时钟精度的方法[UTIMEWeb]:它将时钟芯片设置为单次触发状态(One shot mode),即每次给时钟芯片设置一个超时时间,然后到该超时事件发生时在时钟中断处理程序中再次根据需要给时钟芯片设置一个超时时间。它的基本思想是一个精确的定时意味着我们需要时钟中断在我们需要的一个比较精确的时间发生,但并非一定需要系统时钟频率达到此精度。它利用CPU的时钟计数器TSC (Time Stamp Counter)来提供精度可达CPU主频的时间精度。

        对于实时任务的调度,Kurt-Linux采用基于时间(TD)的静态的实时CPU调度算法。实时任务在设计阶段就需要明确地说明它们实时事件要发生的时间。这种调度算法对于那些循环执行的任务能够取得较好的调度效果。

        Kurt -Linux相对于RT-Linux的一个优点就是可以使用Linux系统自身的系统调用,它本来被设计用于提供对硬实时的支持,但由于它在实现上只是简单的将Linux调度器用一个简单的时间驱动的调度器所取代,所以它的实时进程的调度很容易受到其它非实时任务的影响,从而在有的情况下会发生实时任务的截止期限不能满足的情况,所以也被称作严格实时系统(Firm Real-time)。目前基于Kurt-Linux的应用有:ARTS(ATM Reference Traffic System)、多媒体播放软件等。另外Kurt-Linux所采用的这种方法需要频繁地对时钟芯片进行编程设置。

        3.3. RED-Linux

        RED -Linux是加州大学Irvine分校开发的实时Linux系统[REDWeb][ Wang],它将对实时调度的支持和Linux很好地实现在同一个操作系统内核中。它同时支持三种类型的调度算法,即:Time-Driven、 Priority-Dirven、Share-Driven。

        为了提高系统的调度粒度,RED-Linux从RT-Linux那儿借鉴了软件模拟中断管理器的机制,并且提高了时钟中断频率。当有硬件中断到来时,RED-Linux的中断模拟程序仅仅是简单地将到来的中断放到一个队列中进行排队,并不执行真正的中断处理程序。

        另外为了解决Linux进程在内核态不能被抢占的问题, RED-Linux在Linux内核的很多函数中插入了抢占点原语,使得进程在内核态时,也可以在一定程度上被抢占。通过这种方法提高了内核的实时特性。

        RED-Linux的设计目标就是提供一个可以支持各种调度算法的通用的调度框架,该系统给每个任务增加了如下几项属性,并将它们作为进程调度的依据:

        Priority:作业的优先级;

        Start-Time:作业的开始时间;

        Finish-Time:作业的结束时间;

        Budget:作业在运行期间所要使用的资源的多少;

        通过调整这些属性的取值及调度程序按照什么样的优先顺序来使用这些属性值,几乎可以实现所有的调度算法。这样的话,可以将三种不同的调度算法无缝、统一地结合到了一起。

       å¦å¤–,团IDC网上有许多产品团购,便宜有口碑

Zynq GTX全网最细讲解,aurora 8b/b协议,OV板对板视频传输,提供2套工程源码和技术支持

       没玩过GT资源都不好意思说自己玩儿过FPGA,这是抖音直连源码CSDN某大佬说过的一句话,鄙人深信不疑。

       GT资源是Xilinx系列FPGA的重要卖点,也是做高速接口的基础,不管是PCIE、SATA、MAC等,都需要用到GT资源来做数据高速串化和解串处理,Xilinx不同的FPGA系列拥有不同的GT资源类型,低端的A7由GTP,K7有GTX,V7有GTH,更高端的U+系列还有GTY等,他们的速度越来越高,应用场景也越来越高端。

       本文使用Xilinx的Zynq FPGA的GTX资源做板对板的视频传输实验,视频源有两种,分别对应开发者手里有没有摄像头的情况,一种是使用廉价的OV摄像头模组;如果你得手里没有摄像头,或者你得开发板没有摄像头接口,则可使用代码内部生成的源码开发者动态彩条模拟摄像头视频;视频源的选择通过代码顶层的`define宏定义进行,默认使用ov作为视频源,调用GTX IP核,用verilog编写视频数据的编解码模块和数据对齐模块,使用2块开发板硬件上的2个SFP光口实现数据的收发;本博客提供2套vivado工程源码,2套工程的不同点在于一套是GTX发送,另一套是GTX接收;本博客详细描述了FPGA GTX 视频传输的设计方案,工程代码可综合编译上板调试,可直接项目移植,适用于在校学生、研究生项目开发,也适用于在职工程师做学习提升,可应用于医疗、军工等行业的高速接口或图像处理领域;

       提供完整的、跑通的工程源码和技术支持;

       工程源码和技术支持的获取方式放在了文章末尾,请耐心看到最后。

       免责声明:本工程及其源码即有自己写的一部分,也有网络公开渠道获取的一部分(包括CSDN、Xilinx官网、Altera官网等等),若大佬们觉得有所冒犯,教育知识付费源码请私信批评教育;基于此,本工程及其源码仅限于读者或粉丝个人学习和研究,禁止用于商业用途,若由于读者或粉丝自身原因用于商业用途所导致的法律问题,与本博客及博主无关,请谨慎使用。

       我这里已有的 GT 高速接口解决方案:我的主页有FPGA GT 高速接口专栏,该专栏有 GTP 、 GTX 、 GTH 、 GTY 等GT 资源的视频传输例程和PCIE传输例程,其中 GTP基于A7系列FPGA开发板搭建,GTX基于K7或者ZYNQ系列FPGA开发板搭建,GTH基于KU或者V7系列FPGA开发板搭建,GTY基于KU+系列FPGA开发板搭建。

       GTX 全网最细解读:关于GTX介绍最详细的肯定是Xilinx官方的《ug_7Series_Transceivers》,我们以此来解读;我用到的开发板FPGA型号为Xilinx Kintex7 xc7ktffg-2;带有8路GTX资源,其中2路连接到了2个SFP光口,每通道的收发速度为 Mb/s 到 . Gb/s 之间。GTX收发器支持不同的串行传输接口或协议,比如 PCIE 1.1/2.0 接口、万兆网 XUAI 接口、OC-、串行 RapidIO 接口、 SATA(Serial ATA) 接口、数字分量串行接口(SDI)等等;GTX 基本结构:Xilinx 以 Quad 来对串行高速收发器进行分组,四个串行高速收发器和一个 COMMOM(QPLL)组成一个 Quad,每一个串行高速收发器称为一个 Channel(通道)。GTX 的具体内部逻辑框图:GTX 的发送和接收处理流程:首先用户逻辑数据经过 8B/B 编码后,进入一个发送缓存区(Phase Adjust FIFO),最后经过高速 Serdes 进行并串转换(PISO)。GTX 的参考时钟:GTX 模块有两个差分参考时钟输入管脚(MGTREFCLK0P/N 和 MGTREFCLK1P/N),作为 GTX 模块的参考时钟源,用户可以自行选择。

       GTX 发送接口:用户只需要关心发送接口的时钟和数据即可,GTX例化模块的这部分接口如下:在代码中我已为你们重新绑定并做到了模块的顶层,代码部分如下。GTX 接收接口:用户只需要关心接收接口的时钟和数据即可,GTX例化模块的这部分接口如下:在代码中我已为你们重新绑定并做到了模块的顶层,代码部分如下。

       GTX IP核调用和使用:有别于网上其他博主的教程,我个人喜欢用如下图的共享逻辑:这样选择的好处有两个,一是方便DRP变速,二是便于IP核的修改,修改完IP核后直接编译即可。

       设计思路框架:本博客提供2套vivado工程源码,2组工程的不同点在于一套是GTX发送,另一套是GTX接收。第1套vivado工程源码:GTX作为发送端,Zynq开发板1采集视频,然后数据组包,通过GTX做8b/b编码后,通过板载的SFP光口的TX端发送出去。视频源有两种,分别对应开发者手里有没有摄像头的情况,一种是使用廉价的OV摄像头模组;如果你得手里没有摄像头,或者你得开发板没有摄像头接口,则可使用代码内部生成的动态彩条模拟摄像头视频;默认使用ov作为视频源。第2套vivado工程源码:Zynq开发板2的SFP RX端口接收数据,经过GTX做8b/b解码、数据对齐、数据解包的操作后就得到了有效的视频数据,再用我常用的FDMA方案做视频缓存,最后输出HDMI视频显示。

       视频源选择:视频源有两种,分别对应开发者手里有没有摄像头的情况,如果你的手里有摄像头,或者你的开发板有摄像头接口,则使用摄像头作为视频输入源,我这里用到的是廉价的OV摄像头模组;如果你得手里没有摄像头,或者你得开发板没有摄像头接口,则可使用代码内部生成的动态彩条模拟摄像头视频,动态彩条是移动的画面,完全可以模拟视频;默认使用ov作为视频源;视频源的选择通过代码顶层的`define COLOR_IN 宏定义进行。

       视频源配置及采集:OV摄像头需要i2c配置才能使用,需要将DVP接口的视频数据采集为RGB或者RGB格式的视频数据。选择逻辑如下:当(注释) define COLOR_IN时,输入源视频是动态彩条;当(不注释) define COLOR_IN时,输入源视频是ov摄像头。

       视频数据组包:由于视频需要在GTX中通过aurora 8b/b协议收发,所以数据必须进行组包,以适应aurora 8b/b协议标准。视频数据组包模块代码位置如下:首先,我们将bit的视频存入FIFO中,存满一行时就从FIFO读出送入GTX发送;在此之前,需要对一帧视频进行编号,也叫作指令,GTX组包时根据固定的指令进行数据发送,GTX解包时根据固定的指令恢复视频的场同步信号和视频有效信号。

       GTX aurora 8b/b:这个就是调用GTX做aurora 8b/b协议的数据编解码。数据对齐:由于GT资源的aurora 8b/b数据收发天然有着数据错位的情况,所以需要对接受到的解码数据进行数据对齐处理。视频数据解包:数据解包是数据组包的逆过程。图像缓存:我用到了Zynq开发板,用FDMA取代VDMA具有以下优势:不需要将输入视频转为AXI4-Stream流;节约资源,开发难度低;不需要SDK配置,不要要会嵌入式C,纯FPGA开发者的福音;看得到的源码,不存在黑箱操作问题。

       视频输出:视频从FDMA读出后,经过VGA时序模块和HDMI发送模块后输出显示器。

       第1套vivado工程详解:开发板FPGA型号:Xilinx--Zynq--xc7zffg-2;开发环境:Vivado.1;输入:ov摄像头或者动态彩条,分辨率x@Hz;输出:开发板1的SFP光口的TX接口;应用:GTX板对板视频传输;工程Block Design如下:工程代码架构如下:综合编译完成后的FPGA资源消耗和功耗预估如下。

       第2套vivado工程详解:开发板FPGA型号:Xilinx--Zynq--xc7zffg-2;开发环境:Vivado.1;输入:开发板2的SFP光口的RX接口;输出:开发板2的HDMI输出接口,分辨率为X@Hz;应用:GTX板对板视频传输;工程Block Design如下:工程代码架构如下:综合编译完成后的FPGA资源消耗和功耗预估如下。

       上板调试验证光纤连接:两块板子的光纤接法如下。静态演示:下面以第1组vivado工程的两块板子为例展示输出效果。当GTX运行4G线速率时输出如下。

       福利:工程代码的获取:代码太大,无法邮箱发送,以某度网盘链接方式发送,资料获取方式:私。网盘资料如下:

copyright © 2016 powered by 皮皮网   sitemap