第一篇：FPGA中同步FIFO的使用小结
FPGA中同步FIFO的使用小结
FPGA中的FIFO，分为同步FIFO，异步FIFO和双向FIFO。同步FIFO一般用于数据的缓存，异步FIFO一般用于跨时钟域的同步上。在这里只讨论同步FIFO的使用。
由于课题中要用FPGA做图像处理，生成3*3的模板。首先我们来分析图像数据的传输方式，线阵CCD1209D为2048个有效像元，经AD采样，每行有2048个图像数据，以串行数据流的形式来传输的，一个时钟周期传输一个像素数据。图像在交由算法模块处理之前要将得到的串行数据变成并行数据，3*3模板就是一个串并转换模块，串行数据经过此模块后变为并行输出。在图像处理算法中的实现过程若选用3*3模板，该滑动窗在某一个时刻读取图像的某个像素和其相邻像素，经过相关的处理后，用处理结果取代模板中间位置的像素值并传送到下一个模块。之后，每校正完一个像素，模板将不断右移或换行，直到将一幅灰度图像的数据阵列中的所有像素全部处理完。为了使窗中的3行3列共9个像素能够在一个时刻同时输出，便于之后的图像处理算法模块进行流水线处理，在3*3模板的硬件设计中，将采用两个FIFO存储器linebuffer1和linebuffer2。其中FIFO地址宽度为图像宽度，这样每个FIFO正好可以存储一行图像数据。模板生成模块的设计框图如下图所示：
这里我们要用到FPGA中的同步FIFO去做linebuffer。选用Verilog HDL语言。
下面介绍使用Quartus II 9.0中的宏模块生成FIFO的过程： 第一步，选megafunctions-> lmp_fifo –> storage->
然后点OK，接着，选Verilog语言，点下一步
注意：在这里设置，FIFO的数据位，FIFO的深度以及同步时钟。
接着下一步，在此处可选择设置如果你前面选择了同步FIFO，那么这一步你需要设置FIFO的握手信号与状态信号有full(满），empty（空）,almostfull（几乎满）,almostempty（几乎空）,Asynchronous clear（异步清零），如果你选择了异步FIFO，那么在读与写两边就要单独设置，读写两边均有 full, empty, usedwide(使用深度）3个信号。
接着点下一步：
一个是FIFO的输出的两种形式，一种是传统的同步方式，即你在有readreq='1'的一个周期后才能读取数取，另一种为show ahead，即为你在readreq='0'时，数据口就一直有一个数据，在读取数据时不用等待一个周期。第二个设置就是综合出FIFO是用一般逻辑单元，还是使用专用的M4K块（当然这需要在该器件有M4K块才可以）。
接着，一直下一步，直到完成，就生成如下所示的一个同步FIFO。
这样的话，主要问题就是读写使能的产生，很关键！！
图中的L_VA是CCD的行数据标志，为读使能； 写使能是这样的assign rdreq = L_VA &&(usedw>2047);
注意：尽量不要使FIFO满，那样很难控制FIFO读写，容易丢数据，如果FPGA存储器允许，FIFO使用4096字节的深度。
最后，希望大家多多实验，不断摸索，不断前进~~~
第二篇：LabVIEW FPGA编程小结
LabVIEW FPGA编程小结
NI PXI-7813R为FPGA卡，板卡上引出4个端口，每个端口有40路引脚，共160路DIO，使用LabVIEW FPGA模块进行编程控制。当FPGA程序复杂度变大或是使用的DIO端口数增多时，可能面临的主要问题包括FPGA空间不够用以及实际循环时间过长等。之前编写的 FPGA程序示意图如下，采集循环与输出循环独立，均采用控件形式与RT程序通讯，两块板卡均使用了近120路DIO口。基于7813R板卡编程实践及涉及到的几个瓶颈问题，简要做了一下总结：
1)使用FIFO还是使用控件？
FPGA与RT通讯时，常用的方法是使用读写FIFO或是使用输入输出控件。这两者的特点是：
a)两者在速度上无明显差别。这是建立在不使用For循环的基础上的，但实际中FIFO通常都要配合For循环来使用，For循环相当于串行操作，当同类端口较多时，使用for将导致循环时间变长，故运行速度上FIFO并没有多少优势。b)FIFO使用合理时不丢数，而控件不能保证。
通过配置FPGA与RT中读写FIFO的超时以及FIFO大小，读写方式等手段，通常可保证FIFO传递数据不丢数（可能要经过多次尝试）；而使用控件则可能会有丢数的情况。当不严格要求每次while循环都不丢数时，可考虑使用控件，例如对DO输出的配置，用户可能很久才会去配置一次，而且配置后不会要求马上生效，稍微晚几个循环周期(us级)再使配置生效也不会有很大影响，这种时候使用读取控件值是合理的。c)FIFO可使用的数据类型有限，而控件几乎无限制。
就7813R而言，FIFO只能传递指定的几种类型的数据，而使用控件时，可使用包括簇数组在内的自定义控件。
所以，还是根据实际需要来选择吧，虽然这句话跟没说一样~ 2)用不用For循环？
端口较多时，很容易就遇到连续几个都是要求采集脉宽的，而另外连续几个要求采集电平即可。这时候很自然想到使用For循环对多个端口一起进行操作，例如下图：
如上面所说，使用FOR循环相当于使端口操作（上图中所说的操作是指将采集到的布尔转成U32数值）变为串行；另外，要使用For，通常就得配合数组操作，例如上图中创建数组等，这样就更加导致循环时间变长。当发现循环时间不满足使用要求时，这种处理方法可能就不能使用了，每一路单独处理就省掉了创建数组及For，节省了循环时间，但这样又使重复代码变多，工作量加大。
3)怎么使用子VI？
输出脉冲时，脉冲的产生可以封装成一个子VI，供多路端口进行使用；采集脉宽时，脉宽采集可以封装成一个子VI供多路端口进行调用。然而，默认情况下，子VI的执行是串行的（因为并没有设置VI属性为“可重入执行”），子VI在同一时间内只能被一路端口所占用，可能导致的结果是循环时间变长，精度降低。如果设置子VI为可重入执行，又可能导致FPGA空间占用率过高，编译无法通过。我想到的一种折中的办法是：使用几个程序框图一样的子VI（功能完全一样，将子VI多另存为几个所生成）来代替原先一个子VI，替换之后，相当于减少了串行运行的子VI数量，循环用时减少明显。下图中使用6个子VI A，如果用2个B与2个C替换其中的4个A，循环时间可能减少为原来的1/3。
While循环方式1：子VI A子VI A子VI A子VI A子VI A子VI AWhile循环方式2：子VI A子VI A子VI B子VI B子VI C子VI C
4)精打细算
这一点可能只会在FPGA空间不够用时才会被重视，下图是逻辑片不够用时导致的FPGA编译失败错误：
因此，当资源有限时，尽量使用能满足使用要求的最小长度的数据类型来实现，能使用U16满足要求的坚决不用U32！另一方面，暂时还没有发现数据类型变长时对FPGA循环运行时间产生明显影响。
5)循环延时考虑
脉冲输出及采集均需要根据实际循环时间来计算，若参与运算的值不是实际的循环时间，输出或采集的结果自然不会准确。例如可配置脉冲或电平输出的端口，若输出电平，其算法简单，所需时间较少，而配置为脉冲输出时，算法复杂。配置为单路脉冲输出可能不会有明显的影响循环时间，但当多路脉冲一起输出时，可能影响到循环时间增加1~2us甚至更长。故实际配置循环时间时，需按照可能的最复杂算法进行运行测试，并依此来设置循环时间，以保证循环时间的确定性已经算法运算的正确性。
总而言之，设计时还是应该根据实际需要，综合考虑数据完整性、FPGA板卡资源大小、循环时间等因素，已达到满意效果。
第三篇：Linux进程通信：命名管道FIFO小结（范文模版）
Linux下进程之间通信可以用命名管道FIFO完成。命名管道是一种特殊类型的文件，因为Linux中所有事物都是文件，它在文件系统中以文件名的形式存在。
在程序中，我们可以使用两个不同的函数调用来建立管道：
#include
#include
int mkfifo(const char *filename, mode_t mode);
int mknode(const char *filename, mode_t mode | S_IFIFO,(dev_t)0);
下面先来创建一个管道：
view plaincopy to clipboardprint? #include
#include
#include
#include
int main()
{
int res = mkfifo(“/tmp/my_fifo”, 0777);
if(res == 0)
{
printf(“FIFO createdn”);
}
exit(EXIT_SUCCESS);
}
#include
int main(){
int res = mkfifo(“/tmp/my_fifo”, 0777);
if(res == 0)
{
printf(“FIFO createdn”);
}
exit(EXIT_SUCCESS);}
编译这个程序：
gcc –o fifo1.c fifo
运行这个程序：
$./fifo1
用ls命令查看所创建的管道
$ ls-lF /tmp/my_fifo
prwxr-xr-x 1 root root 0 05-08 20:10 /tmp/my_fifo|
注意：ls命令的输出结果中的第一个字符为p，表示这是一个管道。最后的|符号是由ls命令的-F选项添加的，它也表示是这是一个管道。
虽然，我们所设置的文件创建模式为“0777”，但它被用户掩码（umask）设置（022）给改变了，这与普通文件创建是一样的，所以文件的最终模式为755。
打开FIFO一个主要的限制是，程序不能是O_RDWR模式打开FIFO文件进行读写操作，这样做的后果未明确定义。这个限制是有道理的，因为我们使用FIFO只是为了单身传递数据，所以没有必要使用O_RDWR模式。如果一个管道以读/写方式打开FIFO，进程就会从这个管道读回它自己的输出。如果确实需要在程序之间双向传递数据，最好使用一对FIFO，一个方向使用一个。
当一个Linux进程被阻塞时，它并不消耗CPU资源，这种进程的同步方式对CPU而言是非常有效率的。
有关Linux下命名管道FIFO的读写规则可以参见之前所写的一篇文章：Linux命名管道FIFO的读写规则。
一、实验：使用FIFO实现进程间通信
两个独立的程序：
1.生产者程序，它在需要时创建管道，然后尽可能快地向管道中写入数据。
2.消费者程序，它从FIFO中读取数据并丢弃它们。
生产者程序fifo2.c：
view plaincopy to clipboardprint? #include
#include
#include
#include
#include
#include
#include
#define FIFO_NAME “/tmp/Linux/my_fifo”
#define BUFFER_SIZE PIPE_BUF
#define TEN_MEG(1024 * 1024 * 10)
int main()
{
int pipe_fd;
int res;
int open_mode = O_WRONLY;
int bytes = 0;
char buffer[BUFFER_SIZE + 1];
if(access(FIFO_NAME, F_OK)==-1)
{
res = mkfifo(FIFO_NAME, 0777);
if(res!= 0)
{
fprintf(stderr, “Could not create fifo %sn”, FIFO_NAME);
exit(EXIT_FAILURE);
}
}
printf(“Process %d opening FIFO O_WRONLYn”, getpid());
pipe_fd = open(FIFO_NAME, open_mode);
printf(“Process %d result %dn”, getpid(), pipe_fd);
if(pipe_fd!=-1)
{
while(bytes < TEN_MEG)
{
res = write(pipe_fd, buffer, BUFFER_SIZE);
if(res ==-1)
{
fprintf(stderr, “Write error on pipen”);
exit(EXIT_FAILURE);
}
bytes += res;
}
close(pipe_fd);
}
else
{
exit(EXIT_FAILURE);
}
printf(“Process %d finishn”, getpid());
exit(EXIT_SUCCESS);
}
#include
#define FIFO_NAME “/tmp/Linux/my_fifo” #define BUFFER_SIZE PIPE_BUF #define TEN_MEG(1024 * 1024 * 10)
int main(){
int pipe_fd;
int res;
int open_mode = O_WRONLY;
int bytes = 0;
char buffer[BUFFER_SIZE + 1];
if(access(FIFO_NAME, F_OK)==-1)
{
res = mkfifo(FIFO_NAME, 0777);
if(res!= 0)
{
fprintf(stderr, “Could not create fifo %sn”, FIFO_NAME);
exit(EXIT_FAILURE);
}
}
printf(“Process %d opening FIFO O_WRONLYn”, getpid());
pipe_fd = open(FIFO_NAME, open_mode);
printf(“Process %d result %dn”, getpid(), pipe_fd);
if(pipe_fd!=-1)
{
while(bytes < TEN_MEG)
{
res = write(pipe_fd, buffer, BUFFER_SIZE);
if(res ==-1)
{
fprintf(stderr, “Write error on pipen”);
exit(EXIT_FAILURE);
}
bytes += res;
}
close(pipe_fd);
}
else
{
exit(EXIT_FAILURE);
}
printf(“Process %d finishn”, getpid());
exit(EXIT_SUCCESS);}
消费者程序fifo3.c：
view plaincopy to clipboardprint? #include
#include
#include
#include
#include
#include
#include
#define FIFO_NAME “/tmp/Linux/my_fifo”
#define BUFFER_SIZE PIPE_BUF
int main()
{
int pipe_fd;
int res;
int open_mode = O_RDONLY;
char buffer[BUFFER_SIZE + 1];
int bytes = 0;
memset(buffer, ' ', sizeof(buffer));
printf(“Process %d opeining FIFO O_RDONLYn”, getpid());
pipe_fd = open(FIFO_NAME, open_mode);
printf(“Process %d result %dn”, getpid(), pipe_fd);
if(pipe_fd!=-1)
{
do{
res = read(pipe_fd, buffer, BUFFER_SIZE);
bytes += res;
}while(res > 0);
close(pipe_fd);
}
else
{
exit(EXIT_FAILURE);
}
printf(“Process %d finished, %d bytes readn”, getpid(), bytes);
exit(EXIT_SUCCESS);
}
#include
#define FIFO_NAME “/tmp/Linux/my_fifo” #define BUFFER_SIZE PIPE_BUF
int main(){
int pipe_fd;
int res;
int open_mode = O_RDONLY;
char buffer[BUFFER_SIZE + 1];
int bytes = 0;
memset(buffer, ' ', sizeof(buffer));
printf(“Process %d opeining FIFO O_RDONLYn”, getpid());
pipe_fd = open(FIFO_NAME, open_mode);
printf(“Process %d result %dn”, getpid(), pipe_fd);
if(pipe_fd!=-1)
{
do{
res = read(pipe_fd, buffer, BUFFER_SIZE);
bytes += res;
}while(res > 0);
close(pipe_fd);
}
else
{
exit(EXIT_FAILURE);
}
printf(“Process %d finished, %d bytes readn”, getpid(), bytes);
exit(EXIT_SUCCESS);}
编译这两个程序：
gcc –o fifo2 fifo2.c
gcc –o fifo3 fifo3.c
运行这两个程序：
[root@localhost chaper12]#./fifo2 &
à后台执行，写数据
[2] 23121
Process 23121 opening FIFO O_WRONLY
[root@localhost chaper12]# time./fifo3à读数据
Process 24155 opeining FIFO O_RDONLY
Process 23121 result 3
Process 24155 result 3
Process 23121 finish
Process 24155 finished, 10485760 bytes read
[2]-Done
./fifo2
real 0m0.214s
user 0m0.000s
sys 0m0.179s
以上两个程序均是使用阻塞模式FIFO。Linux会安排好这两个进程之间的调试，使它们在可以运行的时候运行，在不能运行的时候阻塞。因此，写进程将在管道满时阻塞，读进程将在管道空时阻塞。
虚拟机上，time命令显示，读进程只运行了0.2秒的时间，却读取了10M字节的数据。这说明管道在程序之间传递数据是非常有效的。
二、实验：使用FIFO的客户/服务器应用程序
利用FIFO实现一个客户/服务器的应用程序，服务器进程接受请求，对它们进程处理，最后把结果数据返回给发送请求的客户方。
首先建立一个头文件client.h，它定义了客户和服务器程序都要用到的数据结构，并包含了必要的头文件。
view plaincopy to clipboardprint? #include
#include
#include
#include
#include
#include
#include
#define SERVER_FIFO_NAME “/tmp/Linux/chaper12/server_fifo”
#define CLIENT_FIFO_NAME “/tmp/Linux/chaper12/client_%d_fifo”
#define BUFFER_SIZE PIPE_BUF
#define MESSAGE_SIZE 20
#define NAME_SIZE 256
typedef struct message
{
pid_t client_pid;
char data[MESSAGE_SIZE + 1];
}message;
#include
#define BUFFER_SIZE PIPE_BUF #define MESSAGE_SIZE 20 #define NAME_SIZE 256
typedef struct message {
pid_t client_pid;
char data[MESSAGE_SIZE + 1];}message;
接下来是服务器程序server.c，在这一部分，是以只读阻塞模式打开服务器管道，用于接收客户发送过来的数据，这些数据采用message结构体封装。
view plaincopy to clipboardprint? #include “client.h”
int main()
{
int server_fifo_fd;
int client_fifo_fd;
int res;
char client_fifo_name[NAME_SIZE];
message msg;
char *p;
if(mkfifo(SERVER_FIFO_NAME, 0777)==-1)
{
fprintf(stderr, “Sorry, create server fifo failure!n”);
exit(EXIT_FAILURE);
}
server_fifo_fd = open(SERVER_FIFO_NAME, O_RDONLY);
if(server_fifo_fd ==-1)
{
fprintf(stderr, “Sorry, server fifo open failure!n”);
exit(EXIT_FAILURE);
}
sleep(5);
while(res = read(server_fifo_fd, &msg, sizeof(msg))> 0)
{
p = msg.data;
while(*p)
{
*p = toupper(*p);
++p;
}
sprintf(client_fifo_name, CLIENT_FIFO_NAME, msg.client_pid);
client_fifo_fd = open(client_fifo_name, O_WRONLY);
if(client_fifo_fd ==-1)
{
fprintf(stderr, “Sorry, client fifo open failure!n”);
exit(EXIT_FAILURE);
}
write(client_fifo_fd, &msg, sizeof(msg));
close(client_fifo_fd);
}
close(server_fifo_fd);
unlink(SERVER_FIFO_NAME);
exit(EXIT_SUCCESS);
}
#include “client.h”
int main(){
int server_fifo_fd;
int client_fifo_fd;
int res;
char client_fifo_name[NAME_SIZE];
message msg;
char *p;
if(mkfifo(SERVER_FIFO_NAME, 0777)==-1)
{
fprintf(stderr, “Sorry, create server fifo failure!n”);
exit(EXIT_FAILURE);
}
server_fifo_fd = open(SERVER_FIFO_NAME, O_RDONLY);
if(server_fifo_fd ==-1)
{
fprintf(stderr, “Sorry, server fifo open failure!n”);
exit(EXIT_FAILURE);
}
sleep(5);
while(res = read(server_fifo_fd, &msg, sizeof(msg))> 0)
{
p = msg.data;
while(*p)
{
*p = toupper(*p);
++p;
}
sprintf(client_fifo_name, CLIENT_FIFO_NAME, msg.client_pid);
client_fifo_fd = open(client_fifo_name, O_WRONLY);
if(client_fifo_fd ==-1)
{
fprintf(stderr, “Sorry, client fifo open failure!n”);
exit(EXIT_FAILURE);
}
write(client_fifo_fd, &msg, sizeof(msg));
close(client_fifo_fd);
}
close(server_fifo_fd);
unlink(SERVER_FIFO_NAME);
exit(EXIT_SUCCESS);}
客户端程序client.c，这个程序用于向服务器发送消息，并接收来自服务器的回复。
view plaincopy to clipboardprint? #include “client.h”
int main()
{
int server_fifo_fd;
int client_fifo_fd;
int res;
char client_fifo_name[NAME_SIZE];
message msg;
msg.client_pid = getpid();
sprintf(client_fifo_name, CLIENT_FIFO_NAME, msg.client_pid);
if(mkfifo(client_fifo_name, 0777)==-1)
{
fprintf(stderr, “Sorry, create client fifo failure!n”);
exit(EXIT_FAILURE);
}
server_fifo_fd = open(SERVER_FIFO_NAME, O_WRONLY);
if(server_fifo_fd ==-1)
{
fprintf(stderr, “Sorry, open server fifo failure!n”);
exit(EXIT_FAILURE);
}
sprintf(msg.data, “Hello from %d”, msg.client_pid);
printf(“%d sent %s ”, msg.client_pid, msg.data);
write(server_fifo_fd, &msg, sizeof(msg));
client_fifo_fd = open(client_fifo_name, O_RDONLY);
if(client_fifo_fd ==-1)
{
fprintf(stderr, “Sorry, client fifo open failure!n”);
exit(EXIT_FAILURE);
}
res = read(client_fifo_fd, &msg, sizeof(msg));
if(res > 0)
{
printf(“received:%sn”, msg.data);
}
close(client_fifo_fd);
close(server_fifo_fd);
unlink(client_fifo_name);
exit(EXIT_SUCCESS);
}
#include “client.h”
int main(){
int server_fifo_fd;
int client_fifo_fd;
int res;
char client_fifo_name[NAME_SIZE];
message msg;
msg.client_pid = getpid();
sprintf(client_fifo_name, CLIENT_FIFO_NAME, msg.client_pid);
if(mkfifo(client_fifo_name, 0777)==-1)
{
fprintf(stderr, “Sorry, create client fifo failure!n”);
exit(EXIT_FAILURE);
}
server_fifo_fd = open(SERVER_FIFO_NAME, O_WRONLY);
if(server_fifo_fd ==-1)
{
fprintf(stderr, “Sorry, open server fifo failure!n”);
exit(EXIT_FAILURE);
}
sprintf(msg.data, “Hello from %d”, msg.client_pid);
printf(“%d sent %s ”, msg.client_pid, msg.data);
write(server_fifo_fd, &msg, sizeof(msg));
client_fifo_fd = open(client_fifo_name, O_RDONLY);
if(client_fifo_fd ==-1)
{
fprintf(stderr, “Sorry, client fifo open failure!n”);
exit(EXIT_FAILURE);
}
res = read(client_fifo_fd, &msg, sizeof(msg));
if(res > 0)
{
printf(“received:%sn”, msg.data);
}
close(client_fifo_fd);
close(server_fifo_fd);
unlink(client_fifo_name);
exit(EXIT_SUCCESS);}
编译程序：
gcc –o server server.c
gcc –o client client.c
测试这个程序，我们需要一个服务器进程和多个客户进程。为了让多个客户进程在同一时间启动，我们使用了shell命令：
[root@localhost chaper12]#./server &
[26] 5171
[root@localhost chaper12]# for i in 1 2 3 4 5;do./client & done
[27] 5172
[28] 5173
[29] 5174
[30] 5175 [31] 5176
[root@localhost chaper12]# 5172 sent Hello from 5172 received:HELLO FROM 5172
5173 sent Hello from 5173 received:HELLO FROM 5173
5174 sent Hello from 5174 received:HELLO FROM 5174
5175 sent Hello from 5175 received:HELLO FROM 5175
5176 sent Hello from 5176 received:HELLO FROM 5176
分析这个例子，服务器以只读模式创建它的FIFO并阻塞，直到第一个客户以写方式打开同一现个FIFO来建立连接为止。此时，服务器进程解除阻塞并执行sleep语句，这使得来自客户的数据排除等候。在实际应用程序中，应该把sleep语句删除，这里面只是为了演示当有多个客户请求同时到达时，程序的正确操作方法。
与此同时，在客户端打开服务器FIFO后，它创建自己唯一的一个命名管道以读取服务器返回的数据。完成这些工作后，客户发送数据给服务器（如果管道满或服务器仍处于休眠就阻塞），并阻塞于对自己FIFO的read调用上，等待服务器响应。
接收到来自客户的数据后，服务器处于它，然后以写的方式打开客户管道并将处理后的数据返回，这将解除客户端的阻塞状态，客户程序就可以从自己的管道里面读取服务器返回的数据了。
整个处理过程不断重复，直到最后一个客户关闭服务器管道为止，这将使服务器的read调用失败（返回0），因为已经没有进程以写方式打开服务器管道了。如果这是一个真正的服务器进程的话，它还需要继续等待其他客户的请求，我们就需要对它进行修改，有两种方法：
（1）对它自己的服务器管道打开一个文件描述符，这样read调用将阻塞而不是返回0。
（2）当read调用返回0时，关闭并重新打开服务器管道，使服务器进程阻塞在open调用处以等待客户的到来，就像它最初启动时那样。
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/MONKEY_D_MENG/archive/2010/06/06/5651430.aspx
第四篇：语文课中班班通使用小结
语文课中“班班通”使用小结
班班通安装一个多学期了，从一开始的好奇，到使用，摸索了很长时间，终于有些眉目了，现做一小结。
一，语文第一课时中的运用，讲读课文的第一课时一般是读课文，学生字，划分段落。运用“畅言”软件，会更有效率。1，打开电子书架，运用其朗读功能，点“课题”“播放”不用翻页，会把整篇课文读完，不用找朗读音频了，而且在具体学某一自然段时，也可以播放一个自然段。2，学习生字时，对易混淆的字，也可以化难为易，步骤如下：以“藕”为例，手写“藕”，用鼠标一圈，点“中文“，就出现“笔顺”“结构”轻轻一点，就可以看到现写哪笔后写哪笔了。3.标自然段，对低年级较有效，直接在电子书本中标序号，一目了然。
二，巧妙“找一找”，以往让学生找一找时，由学生在书本中圈划，用不同符号划出来，汇报时得用PPT把所有内容打出来，费事费劲，现在有了畅言电子书本了，直接用“笔”在屏幕上划即可。以第九册13课《钓鱼的启示》为例，我让学生找一找“父亲”和“我”说的话，先由学生思考，汇报时学生说一句，我在“电子书本”中划一句，直观形象，省时省力。
三，整合FLASH课件资源。LASH课件中有很多有用的东西，如动画等，可以用畅言中的插入视频功能，直接播放，如11课《新型玻璃》，我在卡片中插入了一个FLASH课件，分别播放“夹丝网防盗玻璃”如何被击碎，又如何藕断丝连的。“变色玻璃”如何改变颜色深浅的。“吸热玻璃”是如何冬暖夏凉的。“吃音玻璃”是如何使噪音变小的。这样就可以轻松整合FLASH课件资源了。
四，插入视频，音频，能兼容各种格式，以往在PPT中插入超级链接时，有很多格式插入不起来，有了畅言就很方便了，FLV形式的也不用转码，直接播放。比如：13课《钓鱼的启示》中我插入了一首《好孩子要诚实》，设为AVI格式，清晰，音质好，直接在一张“片中”中点“播放即可。方便操作。类似如“配乐朗诵“等，点音频播放按钮即可。
五，巧用“截图”功能，有的课文中的插图功能是很有用的资源，没关系，用畅言截图功能吧，打开书架，点截图，出现一个矩形框，可以调整大小，调整好后点“生成卡片“一幅插图就取下来了。比如《秋思》中的图截取下来后，让学生看图练习说话，张籍在送信人即将离开时，他怎样又把信拿回来拆开，他们都说了些什么？有了这幅截图，学生看着”卡片“畅所欲言。
六，运用搜索功能，随心所欲，有了“班班通”,每个班级都连上互联网，不仅可以下载现有的畅言课件，还可以直接下载图片视频。如：22课《狼牙山五壮士》上完后我直接到百度里搜《狼牙山五壮士》电影，重点观看其中”跳崖“部分，不用制作课件，现下现看。
七，运用“黑板“功能，这个功能初学者常用，即在”卡片“”电子书架“中点”黑板“，就出现一块可调整大小的矩形框，能用不同颜色的笔书写。比如：书写生字词，词语的含义，交互性极强。
八，“白板“的批注功能。除了”畅言“软件，班班通还有一款功能强大的软件，即hiteboad，电子白板软件，我们用惯了PPT课件，却是很僵化的，有了电子白板，就可以用笔直接在PPT课件中批注了。比如：《梅花魂》一课，第二件事，”我 脏了墨梅图，外祖父骂了母亲“出示PPT课件，把第三自然段的主要部分出示出来，然后让学生找一找，从哪些地方可以看出外祖父对墨梅图的珍爱，学生汇报一个，我用”智能笔“圈一个词，很快圈出”分外爱惜“”唯独“”顿时拉下脸“”轻轻刮去“”慢慢抹净“等词语，在PPT课件上批注，师生互动性更强，学生也很新奇。
以上只是笔者初略，肤浅的探索，相信随着时间的推移，班班通一定会“忽如一夜春风来，千树万树梨花开“到那时看，我们将迎来教育的新的春天。
第五篇：FPGA学习及设计中的注意事项
FPGA学习及设计中的注意事项1.基础问题FPGA的基础就是数字电路和HDL语言，想学好FPGA的人，建议床头都有一本数字电路的书，不管是哪个版本的，这个是基础，多了解也有助于形成硬件设计的思想。在语言方面，建议初学者学习Verilog语言，VHDL语言语法规范严格，调试起来很慢，Verilog语言容易上手，而且，一般大型企业都是用Verilog语言。
2.EDA工具问题
熟悉几个常用的就可以的，开发环境QuartusII，或ISE 就可以了，这两个基本是相通的，会了哪一个，另外的那个也就很Easy了。功能仿真建议使用Modelsim，如果你是做芯片的，就可以学学别的仿真工具，做FPGA的，Modelsim就足够了。综合工具一般用Synplify，初学先不用太关心这个，用Quartus综合就OK了。
3.硬件设计思想问题
对于初学者，特别是从软件转过来的，设计的程序既费资源又速度慢，而且很有可能综合不了，这就要求我们熟悉一些固定模块的写法，可综合的模块很多书上都有，语言介绍上都有，不要想当然的用软件的思想去写硬件。详细资料：edu118.com
4.学习习惯问题
FPGA学习要多练习，多仿真，signaltapII是很好的工具，可以看到每个信号的真实值，建议初学者一定要自己多动手，光看书是没用的。关于英文文档问题，如果要学会Quartus II的所有功能，只要看它的handbook就可以了，很详细，对于IT行业的人，大部分知识来源都是英文文档，一定要耐心看，会从中收获很多的。
5.算法问题
做FPGA的工程师，最后一般都是专攻算法了，这些基础知识都是顺手捏来的，如果你没有做好搞理论的准备，学FPGA始终只能停留在初级阶段上。对于初学者，数字信号处理是基础，应该好好理解，往更深的方向，不用什么都学，根据你以后从事的方向，比如
说通信、图像处理，雷达、声纳、导航定位等。深圳专业FPGA技术实训江老师QQ1469217515
FPGA设计的注意事项
不管你是一名逻辑设计师、硬件工程师或系统工程师，甚或拥有所有这些头衔，只要你在任何一种高速和多协议的复杂系统中使用了FPGA，你就很可能需要努力解决好器件配置、电源管理、IP集成、信号完整性和其他的一些关键设计问题。不过，你不必独自面对这些挑战，因为在当前业内领先的FPGA公司里工作的应用工程师每天都会面对这些问题，而且他们已经提出了一些将令你的设计工作变得更轻松的设计指导原则和解决方案。
点击咨询 