fifo原理以及两种模式
fifo读写
fifo读写
FIFO，全称为First In First Out，即先进先出，是一种常见的数据结构。
在计算机领域中，FIFO通常指的是一种管道（pipe）的实现方式，也称为命名管道（named pipe），用于进程间通信。
在FIFO中，数据的读取和写入都是按照先进先出的原则进行的。
当一个进程向FIFO中写入数据时，数据会被存储在FIFO的尾部，而当另一个进程从FIFO中读取数据时，数据会从FIFO的头部开始读取。
FIFO的读写操作可以分为阻塞和非阻塞两种方式。
在阻塞模式下，当FIFO中没有数据可读时，读取进程会被阻塞，直到有数据可读为止；当FIFO已满时，写入进程会被阻塞，直到有空间可写为止。
在非阻塞模式下，读取进程和写入进程不会被阻塞，而是会立即返回一个错误码。
FIFO的实现方式可以基于内存或磁盘。
在基于内存的实现方式中，FIFO的数据存储在内核缓冲区中，因此读写速度较快；而在基于磁盘的实现方式中，FIFO 的数据存储在磁盘文件中，因此读写速度较慢。
FIFO的应用场景非常广泛，例如在Linux系统中，FIFO常用于进程间通信、日志记录等方面。
在多线程编程中，FIFO也可以用于线程间通信，实现线程安全的数据传输。
总之，FIFO作为一种先进先出的数据结构，在计算机领域中有着广泛的应用，其读写操作的实现方式和应用场景也非常丰富。
fifo算法和lru算法
fifo算法和lru算法FIFO算法和LRU算法是计算机领域中两种常用的置换算法，它们被广泛应用于操作系统和缓存管理中。
本文将详细介绍FIFO算法和LRU算法的原理、应用场景以及优缺点，并比较它们在不同场景下的性能表现。
一、FIFO算法FIFO算法（First-In-First-Out）是一种简单直观的置换算法，它根据页面调入内存的先后顺序，选择最早进入内存的页面进行置换。
具体而言，当系统需要为新的页面腾出空间时，FIFO算法会选择最早进入内存的页面进行替换，以此保证内存空间的有效利用。
FIFO算法的工作原理如下：1. 系统维护一个页面队列，用于记录页面进入内存的顺序。
2. 当新的页面需要调入内存时，系统将其加入页面队列的末尾。
3. 当页面置换发生时，FIFO算法选择队列中最早进入内存的页面进行替换，即选择队列中的第一个页面。
FIFO算法的优点是简单且易于实现，适用于实时应用场景和对页面访问顺序没有严格要求的场景。
然而，FIFO算法也存在一些缺点。
首先，它无法利用页面的访问频率信息进行优化，导致可能会把频繁被访问的页面置换出去。
其次，FIFO算法对于长时间保留在内存中的页面和短时间仅被访问一次的页面一视同仁，无法根据页面的使用模式进行智能调整。
二、LRU算法LRU算法（Least Recently Used）是一种基于页面访问模式的置换算法，它根据页面最近被访问的时间顺序，选择最长时间未被访问的页面进行置换。
具体而言，当系统需要为新的页面腾出空间时，LRU算法会选择最长时间未被访问的页面进行替换，以此提高缓存命中率。
LRU算法的工作原理如下：1. 系统维护一个页面访问历史链表，用于记录页面的访问顺序。
2. 当页面被访问时，系统将其移动到链表的末尾。
3. 当页面置换发生时，LRU算法选择链表中最早进入的页面进行替换，即选择链表中的第一个页面。
LRU算法的优点是能够较好地适应页面访问模式，并做出相应调整。
Lecture 15 FIFO设计介绍
同步FIFO的操作
¾ FIFO 的初始化只进行一次，FIFO的读进程 、写进程、Count的计数进程相互之间并行 。 如何将上述进程（算法）转化为相应的硬件 实现？
同步FIFO设计
• 根据FIFO的大小N，决定Count、Wptr、 Rptr的位宽⎡log2N⎤; • 设置寄存器分别保存Count、Wptr、Rptr的 值； • 同步FIFO必须有异步Reset； • 当FIFO复位时，Count＝0，Wptr＝0， Rptr＝0； • FIFO正常操作时，受时钟控制。
• 满标志：FIFO已满或将要满时由FIFO的状态电路送 出的一个信号，以阻止FIFO的写操作继续向FIFO中 写数据而造成溢出（overflow）。 • 空标志：FIFO已空或将要空时由FIFO的状态电路送 出的一个信号，以阻止FIFO的读操作继续从FIFO中 读出数据而造成无效数据的读出（underflow）。 • 读指针：指向下一个读出地址。读完后自动加1。 • 写指针：指向下一个要写入的地址的，写完自动加 1。
Oldest goods leave first
最老的货最先离 开
• FIFO与普通存储器的区 别是没有外部读写地址 线，这样使用起来非常简 单。 • 只能顺序写入数据，顺 序的读出数据，其数据地 址由内部读写指针自动加 1完成。 FIFO基本结构 • 不能像普通存储器那样 可以由地址线决定读取或 写入某个指定的地址。
parameter L = ⎡log2N⎤ ; reg [Size-1] RData; reg WEn, REn; reg [L-1:0] Count; reg [L-1:0] Wptr; reg [L-1:0] Rptr; always @(posedge clk or negedge Reset) if (~Reset) //初始化 begin Count <= 0; Wptr <= 0; Rptr <= 0; end else begin // FIFO 写操作 if ( (Wreq ==1’b1) && (Count < N)) begin FIFO[Wptr] <= WData; Wptr <= (Wptr +1) % N; WEn <= 1’b1; end else WEn <= 1’b0;
fifo算法c语言
fifo算法c语言FIFO算法C语言实现FIFO（First In First Out）算法是一种简单的页面置换算法，也称为先进先出算法。
该算法的核心思想是将最先进入内存的页面最先淘汰，即将页表中最早调入内存的页面移出内存。
本文将介绍如何使用C语言实现FIFO算法。
一、FIFO算法原理1.1 页面置换在操作系统中，为了提高程序运行效率，会将程序需要用到的数据和指令从硬盘上加载到内存中。
但是内存有限，无法容纳所有程序需要用到的数据和指令。
当内存不足时，就需要进行页面置换。
页面置换就是将当前正在使用但又不常用的页面从内存中移出，并将新的页面调入内存。
在进行页面置换时，需要选择一个合适的页面置换算法。
1.2 FIFO算法FIFO算法是一种简单而常用的页面置换算法。
它以队列为基础，将最早进入队列的页面作为被淘汰的对象。
具体来说，在FIFO算法中，操作系统会维护一个队列来记录当前正在使用的所有页面。
当需要进行页面置换时，操作系统会选择队头元素对应的页面进行淘汰，并将新调入内存中的页面插入队尾。
二、FIFO算法C语言实现2.1 算法流程FIFO算法的实现流程如下：1. 初始化页面队列，将所有页面按照调入内存的时间顺序依次插入队列；2. 当需要进行页面置换时，将队头元素对应的页面移出内存，并将新调入内存中的页面插入队尾；3. 重复执行步骤2。
2.2 代码实现下面是使用C语言实现FIFO算法的示例代码：```c#include <stdio.h>#include <stdlib.h>#define MAX_PAGE_NUM 100 // 最大页面数#define MAX_MEM_SIZE 10 // 最大内存容量int page_queue[MAX_PAGE_NUM]; // 页面队列int mem[MAX_MEM_SIZE]; // 内存int queue_head = 0; // 队头指针int queue_tail = -1; // 队尾指针// 初始化页面队列void init_page_queue(int page_num) {for (int i = 0; i < page_num; i++) {page_queue[i] = i % MAX_MEM_SIZE;}}// 页面置换函数void page_replace(int new_page) {int old_page = page_queue[queue_head]; // 获取被淘汰的页面mem[old_page] = new_page; // 将新页面调入内存中queue_tail = (queue_tail + 1) % MAX_PAGE_NUM; // 更新队尾指针queue_head = (queue_head + 1) % MAX_PAGE_NUM; // 更新队头指针}int main() {int page_num = 20; // 页面数int miss_count = 0; // 缺页次数init_page_queue(page_num);for (int i = 0; i < page_num; i++) {int page = page_queue[i];if (mem[page] == 0) { // 页面不在内存中miss_count++;page_replace(page);}}printf("缺页次数：%d\n", miss_count);return 0;}```2.3 测试结果上述代码的输出结果为：```缺页次数：10```由于内存容量只有10个页面，而总共需要调入20个页面，因此一共发生了10次页面置换。
fifo通信原理
fifo通信原理标题：FIFO通信原理引言：FIFO通信（First In, First Out）是一种基于队列的通信机制，它遵循先进先出的原则，确保数据按照发送的顺序被接收。
本文将详细介绍FIFO通信原理。
一、FIFO通信的概念FIFO通信是一种在计算机系统中常见的通信方式，它模拟了现实世界中的排队现象，即先来的任务先执行，后来的任务后执行。
在FIFO通信中，数据按照发送的顺序进入队列，接收方按照相同的顺序取出数据进行处理。
二、FIFO通信的实现原理1. 队列数据结构FIFO通信的核心是队列数据结构。
队列是一种线性数据结构，有两个端点，分别称为队头和队尾。
数据从队尾进入队列，从队头出队。
队列可以用数组或链表实现。
2. 发送方工作原理发送方将数据按照先后顺序写入队列的队尾。
当有新的数据到达时，会被追加到队列中，此时队列的长度会增加。
发送方可以通过检查队列的长度来判断队列是否已满，如果队列已满，则需要等待，直到有空闲位置。
3. 接收方工作原理接收方从队头读取数据，并进行处理。
当接收方读取了队头的数据后，队列中的数据会向前移动一位，队列的长度减少。
接收方可以通过检查队列的长度来判断队列是否为空，如果队列为空，则需要等待，直到有新的数据到达。
三、FIFO通信的优点1. 顺序性：FIFO通信确保数据按照发送的顺序被接收，保证了数据的顺序性，避免了数据错乱或丢失的问题。
2. 公平性：FIFO通信遵循先进先出的原则，保证了任务的公平性，每个任务都有机会被及时执行。
3. 简单高效：FIFO通信的实现相对简单，不需要复杂的同步机制，能够高效地完成任务。
四、FIFO通信的应用场景1. 进程间通信：在操作系统中，多个进程之间需要进行数据的传递和共享，FIFO通信可以很好地实现进程间的通信。
2. 网络通信：在网络通信中，FIFO通信可以用于实现数据包的发送和接收，保证数据的顺序性。
3. 队列调度：在任务调度中，FIFO通信可以用于实现任务的排队和执行，保证任务按照顺序被执行。
FIFO原理讲解
异 步 FIFO 结 构（第一部分）作者：Vijay A.Nebhrajani翻译：Adam Luo2006年7月设计一个FIFO是ASIC设计者遇到的最普遍的问题之一。
本文着重介绍怎样设计FIFO——这是一个看似简单却很复杂的任务。
一开始，要注意，FIFO通常用于时钟域的过渡，是双时钟设计。
换句话说，设计工程要处理（work off）两个时钟，因此在大多数情况下，FIFO工作于独立的两个时钟之间。
然而，我们不从这样的结构开始介绍—我们将从工作在单时钟的一个FIFO特例开始。
虽然工作在同一时钟的FIFO在实际应用中很少用到，但它为更多的复杂设计搭建一个平台，这是非常有用的。
然后再从特例推广到更为普通的FIFO，该系列文章包括以下内容：1．单时钟结构2．双时钟结构——双钟结构13．双时钟结构——双钟结构24．双时钟结构——双钟结构35．脉冲模式FIFO单时钟FIFO特例FIFO有很多种结构，包括波浪型（ripple）FIFO，移位寄存器型以及其他一些我们并不关心的结构类型。
我们将集中讨论包含RAM存储器的结构类型。
其结构如图1所示。
通过分析，我们看到图中有一个具有独立的读端口和独立的写端口的RAM 存储器。
这样选择是为了分析方便。
如果是一个单端口的存储器，还应包含一个仲裁器保证同一时刻只能进行一项操作（读或写），我们选择双口RAM（无需真正的双口RAM，因为我们只是希望有一个简单的相互独立的读写端口）是因为这些实例非常接近实际情况。
读、写端口拥有又两个计数器产生的宽度为log2(array_size)的互相独立的读、写地址。
数据宽度是一个非常重要的参数将在在稍后的结构选择时予以介绍，而现在我们不必过分的关心它。
为了一致，我们称这些计数器为“读指针”（read pointer）和“写指针”（write pointer）。
写指针指向下一个将要写入的位置，读指针指向下一个将要读取的位置。
每次写操作使写指针加1，读操作使读指针加1。
概述fifo,opt,lru算法
概述fifo,opt,lru算法一、算法简介FIFO（FirstInFirstOut，先进先出）、OPT（OptimalPageReplacement）和LRU（LeastRecentlyUsed）算法是三种常见的页面替换算法，用于计算机中的虚拟内存管理。
这些算法在处理内存中数据块的替换时，需要考虑内存的容量、程序的需求以及数据的历史访问情况等因素。
二、算法原理1.FIFO算法：此算法将页面按照进入的顺序依次存放在内存中。
当有新的页面需要被加载时，如果内存中没有该页面，就需要从磁盘上加载。
当所有的页面都按照进入的顺序被加载完毕后，再按照同样的顺序将页面从内存中逐出，以腾出空间存放新的页面。
这种算法简单易行，但过于依赖页面的进入顺序，如果页面进入的顺序不合理，可能会导致频繁的页面替换。
2.OPT算法：此算法在每次需要加载新页面时，会根据一些准则（如最大错误率、最小错误率、最坏情况等）选择一个最优的页面进行替换。
相比于FIFO算法，OPT算法能更好地适应不同的页面访问情况，从而减少页面的替换频率。
然而，由于需要考虑到各种复杂的因素，OPT算法的实现难度相对较高。
3.LRU算法：此算法将最近最少使用的页面替换出内存，以腾出空间存放新的页面。
当有新的页面需要被加载时，如果内存中没有该页面，就需要从磁盘上加载。
而在加载完成后，会将该页面标记为最近最少使用的状态。
这种算法能够有效地提高内存的使用效率，减少页面的替换次数。
三、应用场景这三种算法在许多实际应用场景中都有应用，如操作系统中的虚拟内存管理、缓存系统等。
不同的应用场景可能需要不同的算法来满足特定的需求，如对于需要频繁访问的页面，可能更适合使用LRU算法；而对于访问模式较为固定的场景，可能更适合使用OPT算法。
四、总结FIFO、OPT和LRU算法是虚拟内存管理中常用的页面替换算法，它们各自具有不同的原理和应用场景。
在实际应用中，需要根据具体的需求和场景选择合适的算法，以实现最优的内存管理效果。
简述 fifo 使用场景和使用方法
FIFO使用场景和使用方法介绍FIFO（First In, First Out）是一种有序列表的数据结构，其中首先进入的元素会被最先取出，类似于队列的工作原理。
FIFO常用于多线程或多进程的应用程序中，用于实现线程间或进程间的数据共享和通信。
FIFO的使用场景FIFO的使用场景很广泛，特别是在并发编程和多线程环境中，下面列举了一些常见的使用场景：1. 生产者-消费者模型生产者-消费者模型是一种常见的并发编程模式，其中生产者线程将数据放入FIFO 队列，而消费者线程则从队列中取出数据进行处理。
这种模型可以实现数据的生产与消费之间的解耦，提高程序的健壮性和效率。
2. 进程间通信在多进程的应用程序中，不同进程之间需要进行数据的传输和共享。
FIFO可以作为进程间通信的一种方式，一个进程将数据写入FIFO队列，而另一个进程则通过读取队列获取数据。
这种方式可以实现进程间的数据交换和共享，避免了复杂的进程间通信机制。
3. 网络编程在网络编程中，FIFO可以用于实现数据的传输和协调。
例如，多个客户端连接到服务器并发送数据，服务器通过FIFO队列接收并处理这些数据，从而实现了多个客户端与服务器之间的数据交互。
4. 缓存FIFO可以作为缓存的一种实现方式，适用于需要按照特定顺序处理数据的场景。
例如，在图像处理中，可以使用FIFO队列存储待处理的图像数据，然后逐个取出进行处理，确保按照先进先出的顺序处理图像。
FIFO的使用方法1. 创建FIFO队列首先，需要创建一个FIFO队列，可以使用系统调用函数（如mkfifo）创建一个命名管道，或者使用编程语言提供的FIFO类或库函数创建一个内存中的FIFO队列。
2. 向FIFO队列写入数据使用write系统调用函数（或编程语言提供的写入方法），将数据写入FIFO队列。
写入的数据会按照写入的顺序被存储在队列中，等待被读取和处理。
3. 从FIFO队列读取数据使用read系统调用函数（或编程语言提供的读取方法），从FIFO队列中读取数据。
fifo通信原理
fifo通信原理FIFO（先进先出）通信是一种常见的数据传输方式，特别在计算机系统中广泛应用。
它是指数据按照先进先出的原则进行传输和处理。
在FIFO通信中，数据进入一个队列，然后按照进入顺序一个一个被处理。
FIFO通信原理基于队列的操作。
队列是一种线性数据结构，具有先进先出（First-In-First-Out，FIFO）的特性。
它可以通过两个指针来标识队列的头和尾，数据从队列的尾部进入，从队列的头部离开。
当一个元素进入队列时，它被添加到队列的尾部；当一个元素离开队列时，它是从队列的头部被移除。
在计算机系统中，FIFO通常用于连接不同的模块或进程之间的数据传输。
这种通信方式可以保证数据按照发送顺序到达接收端，避免数据乱序问题。
下面是FIFO通信的一般原理：1.发送端将数据写入到FIFO缓冲区中:-发送端将数据写入一个特定的FIFO缓冲区。
-如果缓冲区已满，发送端将被阻塞等待，直到有空闲位置。
2.接收端从FIFO缓冲区中读取数据:-接收端从FIFO缓冲区的头部读取数据。
-如果缓冲区为空，接收端将被阻塞等待，直到有数据可读取。
3.数据的传输和处理:-接收端从FIFO缓冲区读取的数据可以被进一步处理，比如存储到内存或者传递给其他模块。
-发送端可以继续写入更多的数据到FIFO缓冲区。
FIFO通信的原理可以按照以下步骤进行具体实现：1.创建一个FIFO缓冲区，用于存储数据。
在操作系统中，FIFO可以通过使用管道或者消息队列来实现。
2. 发送端将数据写入FIFO缓冲区。
这可以通过调用系统API函数，如write(或者send(来完成。
如果缓冲区已满，发送端将被阻塞等待，直到有空闲位置。
3. 接收端从FIFO缓冲区读取数据。
这可以通过调用系统API函数，如read(或者recv(来完成。
如果缓冲区为空，接收端将被阻塞等待，直到有数据可读取。
4.接收端可以对读取到的数据进行进一步处理，如存储到内存或者传递给其他模块。
FIFO(先进先出算法)
FIFO（先进先出算法）先进先出算法（First In, First Out，简称FIFO）是一种常见的调度算法，也是操作系统和计算机网络中广泛应用的一种策略。
该算法使用队列的数据结构来管理和调度任务，按照任务的到达顺序进行处理，最先到达的任务先被处理，后到达的任务则等待在队列中。
在操作系统中，FIFO算法常用于内存管理和磁盘调度。
在内存管理中，操作系统根据进程的到达时间将其放入内存中的任务队列。
而在磁盘调度中，操作系统按照文件请求的到达顺序来访问硬盘。
这样可以保证任务按照顺序进行处理，不会出现任务被跳过或产生乱序的情况。
FIFO算法的原理非常简单，每个任务到达时加入队列的尾部，任务执行时从队列的头部取出。
这样可以确保先到达的任务先被执行，队列中的任务按照FIFO的顺序依次进行处理。
例如，有三个任务A、B、C按照顺序到达队列，从头部开始取出任务进行处理，则A、B、C依次被处理，保证了任务执行的顺序性。
FIFO算法的优点是实现简单，性能稳定。
由于只需要维护一个任务队列，不需要根据任务的优先级或其他因素进行排序和调度，所以实现相对较简单。
同时，由于保证了任务的先后顺序，不会出现任务等待时间过长或任务被忽略的情况，因此性能相对稳定。
然而，FIFO算法也存在一些不足之处。
首先，FIFO算法对任务的响应时间和完成时间没有考虑或优化，导致任务的等待时间可能很长。
如果队列中有一个优先级较低但是任务大小较大的任务排在前面，后面的优先级较高但是任务大小较小的任务将长时间等待。
其次，FIFO算法不适用于长任务和短任务相互混合的场景，可能导致响应时间变长，影响系统的实时性和用户体验。
为了解决FIFO算法的一些不足，人们在实际应用中通常会对其进行一些改进。
例如，引入优先级调度算法，给不同的任务设置优先级，按照优先级高低进行任务调度。
另外，也可以通过时间片轮转算法，将任务划分为多个时间片，在每个时间片内循环进行任务调度，以提高任务的响应速度。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
关于 ALTERA 提供的 FIFO 核使用原理（转）加入收藏2010-12-18 16:01转发分享 人人网 开心网 新浪微博 搜狐博客 百度收藏 谷歌收藏 qq 书签 豆瓣 淘江湖 Facebook Twitter Digg Yahoo!BookmarksALTERA 提供了 LPM_FIFO 参数宏模块，可以在代码中例化使用。
FIFO 有两种工作模式：（1）SCFIFO，（2）DCFIFO 其中 SCFIFO 指读写用一个时钟进行同步，可以支持同时读写的功能。
其中 DCFIFO 指读写使用不同的时钟进行同步，这在设计多时钟系统中相当有用，可用于 不同时钟同步信号之间的同步调整。
首先看看 DCFIFO 模式下的几个比较重要的信号： [A]在写端，主要有以下几个信号： (1) data[n-1:0]：写入数据信号总线； (2) wrreq：写入请求信号，高有效 (2) wrclk：写入同步时钟； (3) wrfull, wrempty：用于指示写端 FIFO 为空或者满的状态； (4) wrusedw[log2(SIZE_FIFO)-1:0] ：写入的数据个数，按写入个数递增； 上述信号都与写入时钟 srclk 同步； [B]在读端，主要有以下几个信号： (1) q[n-1:0]：读取数据信号总线； (2) rdreq：读取请求/确认信号，高有效 (2) rdclk：读取同步时钟；(3) rdfull, rdempty：用于指示读端 FIFO 为空或者满的状态； (4) rdusedw[log2(SIZE_FIFO)-1:0] ：读取的数据个数，按读取顺序递减； FIFO 主要有两种工作模式： (1) Legacy mode(Legacy synchronous FIFO mode ) (2) Show-ahead mode(Show-ahead synchronous FIFO mode) 其中： 在 Legacy mode， 读端的 rdreq 信号作为读取 FIFO 的请求信号(REQ)， 读取数据在 rdreq 置位后的第二个时钟周期有效。
在 Show-ahead mode，读端的 rdreq 信号作为读取 FIFO 的确认信号(ACK)，读取数据 在 rdreq 置位后立即有效，不要额外的读取周期。
下面分别给出 Legacy mode 和 Show-ahead mode 的读写时序： [A] Legacy mode[B] Show-ahead mode由上述时序可以看出两种模式的区别。
值得注意的是： 读端在读取数据的时候，必须等待写端数据准备好，即 rdempty 为低之后开始读取数据， 为高期间表明 FIFO 状态为空，写端写入数据未有效。
相应的在写端如果 wrfull 为高，则表明 FIFO 状态以满，不能再写入数据，此时写入的数 据无效。
下面给出一个 FIFO 操作的具体实例：完成将 10MHz 同步输入的总线同步缓冲到 72MHz+6MHz 的同步组合输出。
// ---------------------------------------------------------------------------------// Copyright (c) 2007 by College of Communication Engineering,Chongqing University. // ---------------------------------------------------------------------------------// Project: // // ---------------------------------------------------------------------------------// File Name:CNGI_PLCP2TxPHY_SyncProc.v // Module: // // Top Module: // // ---------------------------------------------------------------------------------// // Major Functions: // // ---------------------------------------------------------------------------------// // Revision History : // ---------------------------------------------------------------------------------// // Ver :| Author V1.0 :| ZHANG-xuying :| Mod. Date :| Changes Made: :| 01/08/07 :| Initial :| E-mailRevision :| zh_xuying@ // ---------------------------------------------------------------------------------`define PLME_RESET_IND (4'b1001) `define CCA_RESET_IND (4'b1010) `define TxSTARTreq_IND (4'b1011) `define TxMPDU_IND (4'b1100) module CNGI_PLCP2TxPHY_SyncProc( reset, //poewer on reset PLCP2TxPHY_clk, PLCP2TxPHY_ind, PLCP2TxPHY_msg, // clk, //Tx PHY Local(此处不区分原语和 MPDU 直接采用数据的基带时钟读取) clk_ena, // LENGTH, syncPLCP2TxPHY_ind,syncPLCP2TxPHY_msg ); // input wire reset; input wire PLCP2TxPHY_clk; input wire [3:0] PLCP2TxPHY_ind; input wire [7:0] PLCP2TxPHY_msg; // input wire clk,clk_ena; input wire [11:0] LENGTH; // output wire [3:0] syncPLCP2TxPHY_ind; output wire [7:0] syncPLCP2TxPHY_msg; //Generate wrreq reg fifo_wrreq; reg [11:0] fifo_wrdata; always @(posedge PLCP2TxPHY_clk or posedge reset)begin if(reset) fifo_wrreq<=1'b0; else fifo_wrreq<=PLCP2TxPHY_ind[3]; end // always @(posedge PLCP2TxPHY_clk or posedge reset)begin if(reset) fifo_wrdata<=12'd0; else fifo_wrdata<={PLCP2TxPHY_ind,PLCP2TxPHY_msg}; end // reg [3:0] BUS_IND_TYPE; always @(posedge PLCP2TxPHY_clk or posedge reset)begin if(reset) BUS_IND_TYPE<=4'h0; else begin case(PLCP2TxPHY_ind) `PLME_RESET_IND: BUS_IND_TYPE<=`PLME_RESET_IND; `CCA_RESET_IND: BUS_IND_TYPE<=`CCA_RESET_IND; `TxSTARTreq_IND: BUS_IND_TYPE<=`TxSTARTreq_IND; `TxMPDU_IND: BUS_IND_TYPE<=`TxMPDU_IND; default: endcase end end // wire fifo_rdempty; reg fifo_rdack; BUS_IND_TYPE<=BUS_IND_TYPE;reg [2:0] cnt_a,cnt_b; reg [2:0] cnt_c; reg [11:0] cnt_d; always @(posedge clk or posedge reset)begin if(reset)begin cnt_a<=3'd0; cnt_b<=3'd0; cnt_c<=3'd0; cnt_d<=12'd0; fifo_rdack<=1'b0; end else if(clk_ena)begin if(BUS_IND_TYPE==`PLME_RESET_IND || BUS_IND_TYPE==`CCA_RESET_IND) begin if(!fifo_rdempty)begin if(cnt_a==0)begin fifo_rdack<=1'b1; cnt_a<=cnt_a+1; end else if(cnt_a==1)begin fifo_rdack<=1'b0; cnt_a<=cnt_a; end end end else if(BUS_IND_TYPE==`TxSTARTreq_IND)begin if(!fifo_rdempty)begin if(cnt_b<=5)begin fifo_rdack<=1'b1; cnt_b<=cnt_b+1; end else if(cnt_b==6)begin fifo_rdack<=1'b0; cnt_b<=cnt_b; end end end else if(BUS_IND_TYPE==`TxMPDU_IND)begin if(!fifo_rdempty)begin if(cnt_c>=7)begin if(cnt_d fifo_rdack<=1'b1;cnt_d<=cnt_d+1; cnt_c<=3'd0; end else if(cnt_d==LENGTH)begin fifo_rdack<=1'b0; cnt_d<=cnt_d; cnt_c<=cnt_c; end end else cnt_c<=cnt_c+1; end end end else fifo_rdack<=1'b0; end wire [11:0] fifo_Q; PLCP2TxPHY_FIFO u1( .aclr(reset), .data(fifo_wrdata), .rdclk(clk), .rdreq(fifo_rdack), .wrclk(PLCP2TxPHY_clk), .wrreq(fifo_wrreq), .q(fifo_Q), .rdempty(fifo_rdempty) ); // assign syncPLCP2TxPHY_ind=fifo_Q[11:8]; assign syncPLCP2TxPHY_msg=fifo_Q[7:0]; endmodule。