是否可以通过UART从PC向FPGA发送图像文件

嗨，Meganadhan，
每个图像文件只是一堆字节，所以，当然，您可以通过UART发送它们。
为此，您需要访问这些字节并通过串行端口逐个发送。
大多数终端程序允许您这样做。
他们通常有一个名为“发送文件”的选项来执行此任务。
例如，在免费程序“RealTerm”中，您可以在此处获得：
然后，在FPGA上，您可以将UART接收的字节保存在内存中或者您想要用它们做什么。
所有这些字节一起形成JPEG文件。
尽管如此，即使您可以通过UART传输JPEG图像，这可能不是最好的方法。
让我们做一些计算：想象一下你的UART是9600波特（标准串行通信中9600 bps），你正在使用这个速度进行传输，想象你的图像大小是1MB。
如果传输是perfet将需要的时间是：
t_trans = 1 * 1024 * 1024 * 8 [位] / 9600 [位/秒] = 873.81秒= 14.56分钟
因此，也许，如果您想使用图像，更好的解决方案是使用您在该板上的以太网端口。
问候，
伊格纳西奥。



以下为原文

Hi, Meganadhan,
 
every image file is just a bunch of bytes, so, of course, you can send them via UART. For doing this, you need to access these bytes and send them one by one through the serial port.
The majority of the terminal programs allow you to do this. They usually have an option called "send file" for this task. For example, in the free program "RealTerm" you have it here:
 


 
Then, on the FPGA you could save the bytes received by your UART in a memory or whatever you wanted to do with them. All these bytes together will form the JPEG file.
 
Nevertheless, even though you can transmit a JPEG image via UART, this might not be the best way to do it. Let's do some calculations: Imagine that your UART is 9600 bauds (9600 bps in standard serial comunication) and you are using this speed for the transmission, and imagine your image size is 1MB. The time it would take if the transmission was perfet would be:
 

HI ignacio，
感谢您的意见
假设我计划使用带有uart内核的Microblaze处理器作为外设，从uart接收每个字节并用c代码将其写入FIFO。
如果我直接发送jpg（24位RGB）图像，那么收到的每个字节的值是多少？
它是十六进制值还是ascii或二进制值，我进入C代码？
如何将其转换为二进制RGB以将其写入FPGA内的FIFO？
Meganadhan



以下为原文

HI ignacio,
 
thanks for your comments
 

• Suppose i am planning  using a Microblaze processor with uart core as peripheral ,receiving each byte from uart and writing it in to a FIFO in c code.
  
• If i am directly sending a jpg(24 bit RGB) image, what woudl be the value of each byte received ?
  
• Is it a hex vale or ascii or binary value value i am getting inside the C code ?
  
• How can i convert this to binary RGB for writing it to a FIFO inside the FPGA ?
  

Meganadhan

你好，
如果您使用的是MicroBlaze，您将使用下一个函数来接收数据和冒号;
unsigned int XUartLite_Recv（XUartLite * InstancePtr， 
u8 * DataBufferPtr， 
unsigned int NumBytes 
）
arg。
DataBufferPtr是一个指向缓冲区的指针，您可以在其中保存每次接收的数据，这将是一个8位无符号整数，即JPEG文件的一个字节。
这就是你在C代码中收到的值，正如你所说，1个字节。
现在，您接收的字节不是具有颜色信息的字节。
JPEG文件是包含大量信息的压缩文件。
您正在接收文件的字节，但是您必须能够正确读取它们以获取图像信息。
从JPG中提取RGB数据并非易事。
你可能会发现有趣的这个C库及其文档来获取这个：
http://libjpeg.sourceforge.net/
问候，
伊格纳西奥。



以下为原文

Hello,
 
if you are using MicroBlaze, you will use the next function for receiving data:
 
unsigned int XUartLite_Recv ( XUartLite * InstancePtr,                              u8 * DataBufferPtr,                              unsigned int NumBytes                                                    )  
The arg. DataBufferPtr is a pointer to a buffer to where you will save the received data for each time, which will be a 8 bits unsigned integer, that means, a byte of the JPEG file. That is the value that you are receiving in your C code, as you say, 1 byte.
 
Now, the bytes that you are receiving are not the bytes with the colour information. A JPEG file is a compressed file with a lot of information. You are receiving the bytes of the file, but then you will have to be able to read them properly to get the image information.
 
Extracting the RGB data from a JPG is not an easy task. You might find interesting this C library and its documentation for getting this:
 

如果图像格式是.bmp怎么样？
我不是在使用micrlaze，它还有可能吗？



以下为原文

how about if the image format is .bmp? and i'm not using microblaze, it is still possible?

halimfutuwijaya写道：
如果图像格式是.bmp怎么样？
我不是在使用micrlaze，它还有可能吗？
嗨！
文件格式不相关。
它是一个图像（任何类型），声音或其他什么并不重要。
重要的是文件中包含的信息字节。
当然，您可以收到不使用MicroBlaze的图像。
您只需要一个UART模块和一些用于控制数据传输的逻辑，例如状态机。
对于UART，您可以自行设计或通过Internet搜索预先设计的UART。
这种串行通信根本不难实现。
问候
伊格纳西奥



以下为原文

halimfutuwijaya wrote:
how about if the image format is .bmp? and i'm not using microblaze, it is still possible?

Hi!
 
The file format is not relevant. It doesn't matter if it is an image (of any kind), a sound or whatever. The important thing are the information bytes contained in the file.
 
Of course you can receive an image not using MicroBlaze. All you need is an UART module and some logic for controlling the data transmission, for instance a state machine. For the UART you can design your own or search over the Internet a pre-designed one. This serial communications are not difficult at all to implement.
 
Regards
Ignacio
 
 

谢谢你以前的帮助
我有另一个问题
如果我使用由每个像素24位组成的rgb图像，我已经制作了一个24位输入的算法。
但
当我在互联网上搜索uart程序时，我得到的所有程序只是缓冲8位并将其发送到主程序，你有什么建议让我解决我的问题吗？，也许我必须创建的任何其他程序？
有uart标准只允许我们每个周期传输8位？
如果我直接将缓冲区24位的uart程序中的代码更改为有可能吗？，我担心它会导致pc和fpga之间无法比拟的标准
最好的祝福
哈利姆



以下为原文

thanks for the help before 
i have another question
if i work with rgb image that consist of 24 bit each pixel, and i already made an algorithm that has  24 bit for input. but
when i  search uart program in internet, all the program that i get  just buffer 8 bit and send it to main program , do you have some advice for me to solve my problem?,maybe any additional program that i have to create?
 
has the uart standard just allow us to transfer 8 bit each cycle ?
 
if i change the code from that uart program for buffer 24 bit directly it is possible?, im afraid that it cause unmatched standard between pc and fpga
 
best regards
halim

嗨哈利姆。
这是最古老的集成UART设备之一：
http://www.intersil.com/content/dam/Intersil/documents/hd-6/hd-6402.pdf
在第2页，您可以找到UART应支持的所有模式的列表。
但是，出于实际原因，8位（= 1字节）是今天的标准。
（虽然PC标准UART不支持更长的字长，但可以使用FPGA进行此类操作。
但由于UART协议的异步行为，存在限制。
对于今天两个设备之间的短连接，时钟应该足够可靠，但是存在一些需要考虑的失去同步的风险）
如果您要处理24位字，则必须以某种方式将它们打包成至少3个字节。
请记住，同步很重要，否则R，G和B的顺序可能不正确。
有许多方法具有不同的优点和缺点。
由您来制定适合您的方案。
有一个很好的综合 
Eilert



以下为原文

Hi Halim.
This is one of the oldest integrated UART devices:
http://www.intersil.com/content/dam/Intersil/documents/hd-6/hd-6402.pdf
 
On pg.2 you find a list of all the modes a UART should support.
 
However, out of practical reasons, 8 bit (= 1 Byte)  is the standard today.
(While PC standard UARTs do not support longer word sizes it is possible to do such things with FPGAs.
But there's a limit, due to the asynchronous behavior of the UART protocol.
For short connections between two devices todays clocks should be reliable enough, stil there's some risk to run out of synchronisation that needs to be considered)
 
If you are about to work with 24 bit words you have to pack them somehow into at least 3 bytes.
Keep in mind that synchronisation is important, otherwise R, G and B might be in the wrong order.
There are numerous approaches with different pros and cons.
It's up to you to work out a scheme that works for you.
 
Have a nice synthesis
  Eilert

嗨，哈利姆，
你必须在一行中坚持串行8位。
这意味着您的输出仅为1位深度，并且为8位。
因此，您必须编写以这种方式发送数据的逻辑。
这并不困难，你将学习如何处理串行通信，这很好:)
当然，你可以在你的设备之间实现24位并行传输，但是计算机不会“理解”那个。
您甚至没有标准的方法来插入其中的位。
但是，你必须要注意一些事情：你拥有像素信息的事实并不意味着你有一个图像文件。
如果将此信息发送到计算机，则计算机端必须具有某种软件，这些软件根据您要发送的位信息生成图像文件。
另一种方法是从FPGA发送所有文件头和所有内容，但这可能有点混乱。
这取决于你拥有什么。
我的意思是：如果你有一个4像素的图像，分辨率为2 * 2，你所拥有的信息是：{0x4F，0x03,0x01,0xCA}，这并不意味着
如果你把它写入文件，你会得到一个图像文件。
您必须创建一个propper文件。
在您的情况下，使用BMP，您必须添加一些标题（此处有更多信息）。
问候
伊格纳西奥



以下为原文

Hi, Halim,
 
you have to stick to the serial 8 bits in one line. This means that your output will be just of 1 bit depth, and in pieces of 8 bits. So, you must program the logic for sending the data in this way. It is not going to be difficult and you will learn about how to handle serial communications, which is good :)
 
Of course you could implement a 24 bit parallel transfer between your devices, but a computer will not "understand" that. You don't even have a standard way to insert those bits in it.
 
But, you must be aware of something: the fact that you have the information of the pixels doesn't mean you have an image file. If you send this information to the computer, at the computer side you must have some kind of software that, from the information of the bits you are sending, generates an image file. Another approach will be to send all the file headers and all that stuff from the FPGA, but this can be a bit messy. It depends on what you have.
 
What I mean is: if you have, for instance, an image of 4 pixels, with a resolution of 2*2, and the information that you have is this: {0x4F, 0x03, 0x01, 0xCA}, that doesn't mean that if you write that into a file you will get an image file. You must create a propper file. In your case, with BMP, you must add some headers (more info. here).
 
Regards
Ignacio

halimfutuwijaya写道：
如果我使用由每个像素24位组成的rgb图像，我已经制作了一个24位输入的算法。
但是当我在互联网上搜索uart程序时，我得到的所有程序只是缓冲8位并将其发送到主程序，你有什么建议让我解决我的问题吗？，也许我必须创建的任何其他程序？
您需要做的就是取每个24位字并以三个块发送它。
这真的不难。
有uart标准只允许我们每个周期传输8位？
没有“UART标准”这样的东西。
----------------------------是的，我这样做是为了谋生。



以下为原文

halimfutuwijaya wrote:
if i work with rgb image that consist of 24 bit each pixel, and i already made an algorithm that has  24 bit for input. but when i search uart program in internet, all the program that i get  just buffer 8 bit and send it to main program , do you have some advice for me to solve my problem?,maybe any additional program that i have to create?

All you need to do is to take each 24 bit word and send it in three chunks. It's really not hard at all.

has the uart standard just allow us to transfer 8 bit each cycle ?

There is no such thing as "The UART standard."
----------------------------Yes, I do this for a living.

感谢您的信息
所以，你能给我一些建议，以3个块发送24位吗？
我可以先使用移位寄存器来接收算法之前的块吗？
问候
哈利姆



以下为原文

thanks for the information
 
so ,can you give me some advice to send 24 bit in 3 chunks? can i use shift register first for receive that chunks before my algorithm?
 
 
 
 
 
 
 
 
 
regards 
halim

嗨imginagcio
你能告诉我你之前提到的一些软件吗？
问候
哈利姆



以下为原文

hi imginagcio
 
can you tell me about some software that you mention before?
 
 
 
 
 
 
 
 
 
 
regards
halim

halimfutuwijaya写道：
嗨imginagcio
你能告诉我你之前提到的一些软件吗？
当然！
我打算用原始像素信息为接收和文件创建编写一个软件。
我将在C＃中给你一个例子：
要接收串行数据，您必须使用类似的东西（取自Microsoft Developer Network）：
使用系统;
使用System.IO.Ports;
class PortDataReceived
{ 
public static void Main（） 
{ 
SerialPort mySerialPort = new SerialPort（“COM1”）; 
mySerialPort.BaudRate = 9600; 
mySerialPort.Parity = Parity.None; 
mySerialPort.StopBits = StopBits.One; 
mySerialPort.DataBits = 8; 
mySerialPort.Handshake = Handshake.None; 
mySerialPort.DataReceived + = new SerialDataReceivedEventHandler（DataReceivedHandler）; 
mySerialPort.Open（）; 
Console.WriteLine（“按任意键继续...”）; 
Console.WriteLine（）; 
Console.ReadKey（）; 
mySerialPort.Close（）; 
} 
private static void DataReceivedHandler（ 
对象发送者 
SerialDataReceivedEventArgs e） 
{ 
SerialPort sp =（SerialPort）sender; 
string indata = sp.ReadExisting（）; 
Console.WriteLine（“Data Received：”）; 
Console.Write（INDATA）; 
}
}
然后，您必须将信息块放在一起以创建像素，获取字节数组，并保存到文件中。
它会是这样的：
使用System.Drawing.Image;
System.IO.MemoryStream
//你必须有这样的数组：
byte []像素;
//你把它们放入内存流：
var pixelsMs = MemoryStream（pixels）;
//你创建一个图像：
System.Drawing.Image receivedImage = Image.FromStream（pixelsMs）;
//你保存它
image.Save（“在这里你把路径”）
问候
伊格纳西奥



以下为原文

halimfutuwijaya wrote:
hi imginagcio
 
can you tell me about some software that you mention before?
 

 
Sure! I meant to program a piece of software for the reception and the file creation from the raw pixels information. I will give you an example in C#:
 
For receiving the serial data, you must use something like this (taken from Microsoft Developer Network):
 
using System;using System.IO.Ports;class PortDataReceived{    public static void Main()    {        SerialPort mySerialPort = new SerialPort("COM1");        mySerialPort.BaudRate = 9600;        mySerialPort.Parity = Parity.None;        mySerialPort.StopBits = StopBits.One;        mySerialPort.DataBits = 8;        mySerialPort.Handshake = Handshake.None;        mySerialPort.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);        mySerialPort.Open();        Console.WriteLine("Press any key to continue...");        Console.WriteLine();        Console.ReadKey();        mySerialPort.Close();    }    private static void DataReceivedHandler(                        object sender,                        SerialDataReceivedEventArgs e)    {        SerialPort sp = (SerialPort)sender;        string indata = sp.ReadExisting();        Console.WriteLine("Data Received:");        Console.Write(indata);    }} 
Then you must put the chunks of information together to create the pixels, to get an array of bytes, and save into a file. It would be something like this:
 
using System.Drawing.Image;System.IO.MemoryStream//You must have somethin like this array:byte [] pixels;//You put them into a Memory Stream:var pixelsMs = MemoryStream(pixels);//You create an image:System.Drawing.Image receivedImage= Image.FromStream(pixelsMs);//You save itimage.Save("here you put the path") 
Regards
Ignacio

谢谢ignacio
我会试着写信
但是为了将图像发送到fpga，我可以使用realterm吗？
实际上我正在进行图像加密项目，尺寸像素是1600X1600，它非常大，但如果通过UART传输它需要很长时间，这是可以的，因为我只想确保我的算法是真的。
我对uart rx代码有些麻烦。
我想用代表来自pc的传输位的随机位来模拟它，但很难同步uart rx和随机位程序之间的时序，这里的代码
--------------------------------------------------
--------------------------------
随机位
--------------------------------------------------
--------------------------------
图书馆IEEE;
使用IEEE.STD_LOGIC_1164.ALL;
实体随机是 
通用（ 
g_CLKS_PER_BIT：整数：= 87  - 需要正确设置 - > 10 MHZ / 115200（波特率） 
）; 
端口（clk：在STD_LOGIC;
输出：输出STD_LOGIC）;
结束随机;
架构随机行为是
信号计数器：整数：= 0; 
开始
过程（clk）
开始 
如果rising_edge（clk）那么
计数器
--------------------------------------------------
-------------------- UART RX
- 文件从http://www.nandland.com下载
--------------------------------------------------
--------------------
- 此文件包含UART接收器。
这个接收器能够
- 接收8位串行数据，一个起始位，一个停止位，
- 没有奇偶校验位。
当收到完成后，o_rx_dv将会是
- 驱动高电平一个时钟周期。
-
- 设置Generic g_CLKS_PER_BIT如下：
-  g_CLKS_PER_BIT =（i_clk的频率）/（UART的频率）
- 示例：10 MHz时钟，115200波特UART
- （10000000）/（115200）= 87
-
图书馆;
使用ieee.std_logic_1164.ALL;
使用ieee.numeric_std.all;
实体收到的是 
通用（ 
g_CLKS_PER_BIT：整数：= 87  - 需要正确设置 - > 10 MHZ / 115200（波特率） 
）; 
港口 （ 
i_clk：在std_logic中; 
i_rx_serial：在std_logic中; 
o_rx_dv：out std_logic; 
o_rx_byte：out std_logic_vector（7 downto 0） 
）;
收到;
接收的架构rtl是 
类型t_SM_MAIN是（s_IDLE，s_RX_START_BIT，s_RX_DATA_BITS， 
s_RX_STOP_BIT，s_CLEANUP）; 
signal r_SM_MAIN：t_SM_MAIN：= s_IDLE; 
signal r_RX_DATA_R：std_logic：='0'; 
信号r_RX_DATA＆amp;冒号;
std_logic：='0';  
signal r_CLK_COUNT：整数范围0到g_CLKS_PER_BIT-1：= 0; 
signal r_BIT_INDEX：整数范围0到7：= 0;
- 总共8位 
信号r_RX_BYTE：std_logic_vector（7 downto 0）：=（其他=>'0'）; 
signal r_RX_DV：std_logic：='0'; 
开始 
- 目的：双重注册传入数据。 
- 这允许它用于UART RX时钟域。 
- （它消除了由转移引起的问题） 
p_SAMPLE：进程（i_clk） 
开始 
如果rising_edge（i_clk）那么 
r_RX_DATA_R 
r_RX_DV 
如果r_CLK_COUNT =（g_CLKS_PER_BIT-1）/ 2则 
如果r_RX_DATA ='0'那么 
r_CLK_COUNT 
如果是r_CLK_COUNT 
- 等待g_CLKS_PER_BIT-1个时钟周期，停止位完成 
如果是r_CLK_COUNT 
r_SM_MAIN 
r_SM_MAIN
--------------------------------------------------
--------------------------------
最佳
--------------------------------------------------
--------------------------------
图书馆IEEE;
使用IEEE.STD_LOGIC_1164.ALL;
实体顶部是
port（cl_k：在std_logic中
）;
最后;
建筑行为顶部是
--------------------------------------------------
-----------------------
- 组件随机
--------------------------------------------------
-----------------------
组件随机是 
通用（ 
g_CLKS_PER_BIT：整数：= 87  - 需要正确设置 - > 10 MHZ / 115200（波特率） 
）; 
端口（clk：在STD_LOGIC;
输出：输出STD_LOGIC
）;
最终组件;
--------------------------------------------------
-----------------------
--component uart rx
--------------------------------------------------
-----------------------
组件接收是 
通用（ 
g_CLKS_PER_BIT：整数：= 87  - 需要正确设置 - > 10 MHZ / 115200（波特率） 
）; 
港口 （ 
i_clk：在std_logic中; 
i_rx_serial：在std_logic中; 
o_rx_dv：out std_logic; 
o_rx_byte：out std_logic_vector（7 downto 0） 
）;
最终组件;
--------------------------------------------------
-----------------------
- 信号
--------------------------------------------------
-----------------------
信号mlebu：std_logic;
信号enabl：std_logic;
信号metu：std_logic_vector（7 downto 0）;
开始
a：随机端口映射（输出=> mlebu，
CLK => cl_k
）;
b：接收端口映射（i_clk => cl_k，
i_rx_serial => mlebu，
o_rx_dv => ENABL，
o_rx_byte => METU
）;
结束行为;
问候
哈利姆



以下为原文

thanks ignacio
 
i will try it letter
 
but for sending an image to fpga, can i use realterm?  actually i'm doing image encryption project and the size pixel is 1600X1600, it's very big , but it's ok if it will take a long time for transfer it via UART because i just want to make sure that my alghorithm was true.
 
 and i have some trouble with the uart rx code. i would like to simulate it with random bit that represent transfer bit from pc, but it's hard to sychronise the timing between uart rx and the random bit program , here the code
 
----------------------------------------------------------------------------------RANDOM BIT----------------------------------------------------------------------------------library IEEE;use IEEE.STD_LOGIC_1164.ALL;entity random is generic (    g_CLKS_PER_BIT : integer := 87    -- Needs to be set correctly-->  10 MHZ/115200(baud rate)    );    Port (  clk :in  STD_LOGIC; output : out  STD_LOGIC);end random;architecture Behavioral of random issignal counter: integer:=0; beginprocess (clk)begin if rising_edge(clk) thencounter <= counter+1;if counter= (g_CLKS_PER_BIT-1) thenoutput <= '1';elsif counter=55 thenoutput <= '0';elsif counter=65thenoutput <= '0';elsif counter=75 thenoutput <= '0';elsif counter=85 thenoutput <= '1';elsif counter=95 thenoutput <= '0';elsif counter=105 thenoutput <= '0';elsif counter=115 thenoutput <= '0';--elsif counter =1 thencounter <= 0;end if;end if;end process;end Behavioral; 
----------------------------------------------------------------------UART RX-- File Downloaded from http://www.nandland.com------------------------------------------------------------------------ This file contains the UART Receiver.  This receiver is able to-- receive 8 bits of serial data, one start bit, one stop bit,-- and no parity bit.  When receive is complete o_rx_dv will be-- driven high for one clock cycle.-- -- Set Generic g_CLKS_PER_BIT as follows:-- g_CLKS_PER_BIT = (Frequency of i_clk)/(Frequency of UART)-- Example: 10 MHz Clock, 115200 baud UART-- (10000000)/(115200) = 87--library ieee;use ieee.std_logic_1164.ALL;use ieee.numeric_std.all;entity receive is  generic (    g_CLKS_PER_BIT : integer := 87    -- Needs to be set correctly-->  10 MHZ/115200(baud rate)    );  port (    i_clk       : in  std_logic;    i_rx_serial : in  std_logic;    o_rx_dv     : out std_logic;    o_rx_byte   : out std_logic_vector(7 downto 0)    );end receive;architecture rtl of receive is  type t_SM_MAIN is (s_IDLE, s_RX_START_BIT, s_RX_DATA_BITS,                     s_RX_STOP_BIT, s_CLEANUP);  signal r_SM_MAIN : t_SM_MAIN := s_IDLE;  signal r_RX_DATA_R : std_logic := '0';  signal r_RX_DATA   : std_logic := '0';    signal r_CLK_COUNT : integer range 0 to g_CLKS_PER_BIT-1 := 0;  signal r_BIT_INDEX : integer range 0 to 7 := 0;  -- 8 Bits Total  signal r_RX_BYTE   : std_logic_vector(7 downto 0):= (others => '0');  signal r_RX_DV     : std_logic := '0';  begin  -- Purpose: Double-register the incoming data.  -- This allows it to be used in the UART RX Clock Domain.  -- (It removes problems caused by metastabiliy)  p_SAMPLE : process (i_clk)  begin    if rising_edge(i_clk) then      r_RX_DATA_R <= i_rx_serial;      r_RX_DATA   <= r_RX_DATA_R;    end if;  end process p_SAMPLE;    -- Purpose: Control RX state machine  p_UART_RX : process (i_clk)  begin    if rising_edge(i_clk) then              case r_SM_MAIN is        when s_IDLE =>          r_RX_DV     <= '0';          r_CLK_COUNT <= 0;          r_BIT_INDEX <= 0;          if r_RX_DATA = '0' then       -- Start bit detected            r_SM_MAIN <= s_RX_START_BIT;          else            r_SM_MAIN <= s_IDLE;          end if;                  -- Check middle of start bit to make sure it's still low        when s_RX_START_BIT =>          if r_CLK_COUNT = (g_CLKS_PER_BIT-1)/2 then            if r_RX_DATA = '0' then              r_CLK_COUNT <= 0;  -- reset counter since we found the middle              r_SM_MAIN   <= s_RX_DATA_BITS;            else              r_SM_MAIN   <= s_IDLE;            end if;          else            r_CLK_COUNT <= r_CLK_COUNT + 1;            r_SM_MAIN   <= s_RX_START_BIT;          end if;                  -- Wait g_CLKS_PER_BIT-1 clock cycles to sample serial data        when s_RX_DATA_BITS =>          if r_CLK_COUNT < g_CLKS_PER_BIT-1 then            r_CLK_COUNT <= r_CLK_COUNT + 1;            r_SM_MAIN   <= s_RX_DATA_BITS;          else            r_CLK_COUNT            <= 0;            r_RX_BYTE(r_BIT_INDEX) <= r_RX_DATA;                        -- Check if we have sent out all bits            if r_BIT_INDEX < 7 then              r_BIT_INDEX <= r_BIT_INDEX + 1;              r_SM_MAIN   <= s_RX_DATA_BITS;            else              r_BIT_INDEX <= 0;              r_SM_MAIN   <= s_RX_STOP_BIT;            end if;          end if;        -- Receive Stop bit.  Stop bit = 1        when s_RX_STOP_BIT =>          -- Wait g_CLKS_PER_BIT-1 clock cycles for Stop bit to finish          if r_CLK_COUNT < g_CLKS_PER_BIT-1 then            r_CLK_COUNT <= r_CLK_COUNT + 1;            r_SM_MAIN   <= s_RX_STOP_BIT;          else            r_RX_DV     <= '1';            r_CLK_COUNT <= 0;            r_SM_MAIN   <= s_CLEANUP;          end if;                          -- Stay here 1 clock        when s_CLEANUP =>          r_SM_MAIN <= s_IDLE;          r_RX_DV   <= '0';                    when others =>          r_SM_MAIN <= s_IDLE;      end case;    end if;  end process p_UART_RX;  o_rx_dv   <= r_RX_DV;  o_rx_byte <= r_RX_BYTE;  end rtl; 
----------------------------------------------------------------------------------TOP----------------------------------------------------------------------------------library IEEE;use IEEE.STD_LOGIC_1164.ALL;entity top isport(cl_k: in std_logic  );end top;architecture Behavioral of top is---------------------------------------------------------------------------component random-------------------------------------------------------------------------component random is generic (    g_CLKS_PER_BIT : integer := 87    -- Needs to be set correctly-->  10 MHZ/115200(baud rate)    );    Port ( clk :in  STD_LOGIC;  output : out  STD_LOGIC  );end component;---------------------------------------------------------------------------component uart rx-------------------------------------------------------------------------component receive is  generic (    g_CLKS_PER_BIT : integer := 87    -- Needs to be set correctly-->  10 MHZ/115200(baud rate)    );  port (    i_clk       : in  std_logic;    i_rx_serial : in  std_logic;    o_rx_dv     : out std_logic;    o_rx_byte   : out std_logic_vector(7 downto 0)    );end component;---------------------------------------------------------------------------signal-------------------------------------------------------------------------signal mlebu:std_logic;signal enabl:std_logic;signal metu:std_logic_vector (7 downto 0);begina:random port map( output=>mlebu, clk=>cl_k);b:receive port map( i_clk=>cl_k,  i_rx_serial=>mlebu,  o_rx_dv=>enabl,  o_rx_byte=>metu);end Behavioral; 
 
regards
halim
 
 

你好halim，
我很抱歉这个巨大的延迟。
我忘了回答......现在我发现你找到了一个解决方案，但万一它可以帮助更多的人......
但是为了将图像发送到fpga，我可以使用realterm吗？
实际上我正在进行图像加密项目，尺寸像素是1600X1600，它非常大，但如果通过UART传输它需要很长时间，这是可以的，因为我只想确保我的算法是真的。
您可以通过串口，RealTerm或其他程序发送任何您想要的内容。
它有多大并不重要。
但是你必须考虑到接收器必须具有存储信息的位置，并且通信必须处于接收器可以处理它的速度而不会使其输入缓冲区饱和（如果存在）。如果发送者是
对于接收器而言太快，除非实现流量控制，否则将丢失数据。
我对uart rx代码有些麻烦。
我想用代表来自pc的传输位的随机位来模拟它，但很难同步uart rx和随机位程序之间的时序
既然你只是想模拟它，那么在我看来，创建一个之后不会实现的组件是不值得的。
我只是创建一个带有随机数的数组，然后我会在测试工作台文件中同步地从数组中提取这些数字，这是你的被测单元。
库ieee.math.real中有一些函数可以生成一个随机数。
这适用于模拟。
你可以在每个时钟周期生成一个从0到1的数字，然后根据它是否大于0.5设置为'1'，或者如果没有设置'0'。
这将与您的模拟时钟同步。
问候，
伊格纳西奥



以下为原文

Hello halim,
 
I apollogize for this huge delay. I forgot to answer... Now I gess that you found a solution, but just in case it helps more people...
 
but for sending an image to fpga, can i use realterm?  actually i'm doing image encryption project and the size pixel is 1600X1600, it's very big , but it's ok if it will take a long time for transfer it via UART because i just want to make sure that my alghorithm was true.
 
You can send via serial, with RealTerm or other programs, whatever you want. It does not matter how big it is. But you have to take into account that the receiver must have to have where to store the information and that the communication must be at a speed in which the receiver can handle it without saturating it's input buffer (if this exists). If the sender is too quick for the receiver, you will loose data unless you implement a flow control.
 
 and i have some trouble with the uart rx code. i would like to simulate it with random bit that represent transfer bit from pc, but it's hard to sychronise the timing between uart rx and the random bit program
 
Since you just want to simulate it, in my oppinion it is not worth it to create a component that it's not going to be implemented afterwards. I would just create an array with the random numbers and then I would extract such numbers out of the array syncrhonously in the test bench file where is your unit under test.
 
There are functions in the library ieee.math.real that allow you to generate a random number. This is fine for simulation. You could just generate a number from 0 to 1 in each clock cycle and then, according to if it's greater than 0.5 set '1', or if not set '0'. This would be synchronous to your simulation clock.
 
Regards,
 
Ignacio