20145211《信息安全系统设计基础》实验二 固件设计

实验目的与要求

（1）了解多线程程序设计的基本原理，学习 pthread 库函数的使用。                                               

（2）了解在 linux 环境下串行程序设计的基本方法。                     

（3）掌握终端的主要属性及设置方法，熟悉终端I /O 函数的使用。学习使用多线程来完成串口的收发处理。 

（4）熟悉linux开发环境,学会基于S3C2410的linux开发环境的配置和使用。使用linux的armv4l-unknown-linux-gcc编译，使用基于NFS方式的下载调试，了解嵌入式开发的基本过程

实验代码解析

（一）线程代码分析

（1）分析

• 这个代码是生产者－消费者问题模型的实现。
• 主程序中分别启动生产者线程和消费者 线程。生产者线程不断顺序地将0到1000的数字写入共享的循环缓冲区，同时消费者线程不断地从共享的循环缓冲区读取数据。
• 生产者首先要获得互斥锁，并且判断写指针+1 后是否等于读指针，如果相等则进入等待状态，等候条件 变量notfull；如果不等则向缓冲区中写一个整数，并且设置条件变量为notempty，最后释放互斥锁。

（2）线程相关函数

• 线程创建函数：

  int pthread_create (pthread_t * thread_id, __const pthread_attr_t * __attr,void *(*__start_routine) (void *),void *__restrict __arg)

• 获得父进程 ID：

  pthread_t pthread_self (void)

• 测试两个线程号是否相同：

  int pthread_equal (pthread_t __thread1, pthread_t __thread2)

• 线程退出：

  void pthread_exit (void *__retval)

• 等待指定的线程结束：

  int pthread_join (pthread_t __th, void **__thread_return)

• 互斥量初始化：

  pthread_mutex_init (pthread_mutex_t *,__const pthread_mutexattr_t *)

• 销毁互斥量：

  int pthread_mutex_destroy (pthread_mutex_t *__mutex)

• 再试一次获得对互斥量的锁定（非阻塞） ：

  int pthread_mutex_trylock (pthread_mutex_t *__mutex)

• 锁定互斥量（阻塞） ：

  int pthread_mutex_lock (pthread_mutex_t *__mutex)

• 解锁互斥量：

  int pthread_mutex_unlock (pthread_mutex_t *__mutex)

• 条件变量初始化：

  int pthread_cond_init (pthread_cond_t *__restrict __cond,__const pthread_condattr_t *__restrict __cond_attr)

• 销毁条件变量 COND：

  int pthread_cond_destroy (pthread_cond_t *__cond)

• 唤醒线程等待条件变量：

  int pthread_cond_signal (pthread_cond_t *__cond)

• 等待条件变量（阻塞） ：

  int pthread_cond_wait (pthread_cond_t *__restrict __cond, pthread_mutex_t *__restrict __mutex)

• 在指定的时间到达前等待条件变量：

  int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,pthread_mutex_t *__restrict __mutex, __const struct timespec *__restrict __abstime)

（3）源代码注释

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "pthread.h"
#define BUFFER_SIZE 16

/* 设置一个整数的圆形缓冲区 */
struct prodcons {
    int buffer[BUFFER_SIZE]; /* 缓冲区数组 */
    pthread_mutex_t lock; /* 互斥锁 */
    int readpos, writepos; /* 读写的位置*/
    pthread_cond_t notempty; /* 缓冲区非空信号 */
    pthread_cond_t notfull; /*缓冲区非满信号 */
};

/*初始化缓冲区：初始化缓存指针信息（信号量）*/
void init(struct prodcons * b)
{
    pthread_mutex_init(&b->lock, NULL);
    pthread_cond_init(&b->notempty, NULL);
    pthread_cond_init(&b->notfull, NULL);
    b->readpos = 0;
    b->writepos = 0;
}

/* 向缓冲区中写入一个整数*/
void put(struct prodcons * b, int data)
{
    pthread_mutex_lock(&b->lock);//获取互斥锁

    /*等待缓冲区非满*/
    while ((b->writepos + 1) % BUFFER_SIZE == b->readpos) //如果读写位置相同
    {
        printf("wait for not full
");
        pthread_cond_wait(&b->notfull, &b->lock);//等待状态变量 b->notfull，不满则跳出阻塞
    }

    /*写数据并且指针前移*/
    b->buffer[b->writepos] = data;//写入数据
    b->writepos++;
    if (b->writepos >= BUFFER_SIZE) b->writepos = 0;

    /*设置缓冲区非空信号*/
    pthread_cond_signal(&b->notempty);//设置状态变量
    pthread_mutex_unlock(&b->lock);//释放互斥锁
}

/*从缓冲区中读出一个整数 */
int get(struct prodcons * b)
{
    int data;
    pthread_mutex_lock(&b->lock);//获取互斥锁

    /* 等待缓冲区非空*/
    while (b->writepos == b->readpos)//如果读写位置相同 
    {
        printf("wait for not empty
");
        pthread_cond_wait(&b->notempty, &b->lock);//等待状态变量 b->notempty，不空则跳出阻塞。否则无数据可读。
    }

    /* 读数据并且指针前移 */
    data = b->buffer[b->readpos];//读取数据
    b->readpos++;
    if (b->readpos >= BUFFER_SIZE) b->readpos = 0;

    /* 设置缓冲区非满信号*/
    pthread_cond_signal(&b->notfull);//设置状态变量
    pthread_mutex_unlock(&b->lock);//释放互斥锁
    return data;
}

#define OVER (-1)
struct prodcons buffer;

/*实现一个生产者程序：生产者线程不断顺序地将0到1000的数字写入共享的循环缓冲区，当生产-1时，程序终止。*/
void * producer(void * data)
{
    int n;
    for (n = 0; n < 1000; n++) {
        printf(" put-->%d
", n);
        put(&buffer, n);
    }
    put(&buffer, OVER);
    printf("producer stopped!
");
    return NULL;
}

/*消费掉缓存中生产出来的数据：消费者线程不断地从共享的循环缓冲区读取数据，当消费-1时，程序终止*/
void * consumer(void * data)
{
    int d;
    while (1) 
    {
        d = get(&buffer);
        if (d == OVER ) break;
        printf(" %d-->get
", d);
    }
    printf("consumer stopped!
");
    return NULL;
}

int main(void)
{
    pthread_t th_a, th_b;
    void * retval;
    init(&buffer);
    //创建生产者线程
    pthread_create(&th_a, NULL, producer, 0);
    //创建消费者线程
    pthread_create(&th_b, NULL, consumer, 0);
    /* 等待生产者和消费者结束 */
    pthread_join(th_a, &retval);
    pthread_join(th_b, &retval);
    return 0;
}

（二）串行口代码分析

• 头文件

  #include <stdio.h> /*标准输入输出定义*/
  #include <stdlib.h> /*标准函数库定义*/
  #include <unistd.h> /*linux 标准函数定义*/
  #include <sys/types.h>
  #include <sys/stat.h>
  #include <fcntl.h> /*文件控制定义*/
  #include <termios.h> /*PPSIX 终端控制定义*/
  #include <errno.h> /*错误号定义*/
  #include <pthread.h>  /*线程库定义*/

• 打开串口是通过标准的文件打开函数来实现的

  int fd;
  fd = open( "/dev/ttyS0", O_RDWR); /*以读写方式打开串口*/
  if (-1 == fd)/* 不能打开串口一*/
  { 
      perror(" 提示错误！");
  }

• 串口设置

  最基本的设置串口包括波特率设置，效验位和停止位设置。串口的设置主要是设置struct termios结构体的各成员值。
  
  - 波特率设置：
      struct termios Opt;
      tcgetattr(fd, &Opt);
      cfsetispeed(&Opt,B19200); /*设置为 19200Bps*/
      cfsetospeed(&Opt,B19200);
      tcsetattr(fd,TCANOW,&Opt);
  
  - 校验位和停止位的设置：
      无效验 8 位
      Option.c_cflag &= ~PARENB;Option.c_cflag &= ~CSTOPB;Option.c_cflag &= ~CSIZE;Option.c_cflag |= ~CS8;
      奇效验(Odd) 7 位
      Option.c_cflag |= ~PARENB;Option.c_cflag &= ~PARODD;Option.c_cflag &= ~CSTOPB;Option.c_cflag &= ~CSIZE;Option.c_cflag |= ~CS7;
      偶效验(Even) 7 位
      Option.c_cflag &= ~PARENB;Option.c_cflag |= ~PARODD;Option.c_cflag &= ~CSTOPB;Option.c_cflag &= ~CSIZE;Option.c_cflag |= ~CS7;
      Space 效验 7 位
      Option.c_cflag &= ~PARENB;Option.c_cflag &= ~CSTOPB;Option.c_cflag &= &~CSIZE;Option.c_cflag |= CS8;
  
  - 设置停止位：
      1 位：options.c_cflag &= ~CSTOPB;
      2 位:options.c_cflag |= CSTOPB;
  
  注：如果不是开发终端，只是串口传输数据，而不需要串口来处理，那么使用原始模式(Raw Mode) 方式来通讯，设置方式如下：
      options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); /*Input*/
      options.c_oflag &= ~OPOST; /*Output*/

• 读写、关闭串口

  设置好串口之后，读写串口就很容易了，把串口当作文件读写就可以了。
  
  - 发送数据：
      char buffer[1024];
      int Length＝1024;
      int nByte;
      nByte = write(fd, buffer ,Length)
  
  - 读取串口数据：
  使用文件操作read函数读取，如果设置为原始模式(Raw Mode)传输数据，那么read函数返回的字符数是实际串口收到的字符数。可以使用操作文件的函数来实现异步读取，如 fcntl，或者select等来操作。
      char buff[1024];
      int Len＝1024;
      int readByte = read(fd, buff, Len);
  
  - 关闭串口就是关闭文件。
      close(fd);

实验过程       

（一）开发环境的配置

1、连接arm开发板

将arm开发板电源线接好，保持开发板开关处于闭合状态。再分别将串口线、并口线和网线与pc机连接好。

2、建立超级终端

运行windows XP系统下“开始”、“所有程序”、“附件”、“通讯”、“超级终端”。

 

 

新建一个通信终端，取名为arm。在属性对话框中，将波特率设为115200，数据位设为8，无奇偶校验，停止位为1，无数据流控制。另存为在桌面。

 

                 

3、启动实验平台

打开超级终端，打开arm机电源开关。等待一分钟，arm机的信息会显示在超级终端的窗口中。

 

 

继续等待，直至出现所示界面。输入ifconfig命令，记录下arm机的ip为：192.168.0.121

 

4、修改xp系统与redhat虚拟机的ip，使得它们均与arm机的ip在同一网段。在pc机中的xp系统中，设置步骤如图7-9，redhat虚拟机中设置步骤如图10-14。本次实验中将pc机的ip设为192.168.0.55，redhat虚拟机ip为192.168.0.234。

 

  

 

 

修改完IP，重启一下虚拟机，IP才能启作用。重启后在命令行中使用ifconfig确认修改正确

5、安装arm编译器。

在pc机中“开始”、“运行”，输入虚拟机的ip。\192.168.0.234，输入用户名bc，密码123456然后确定

就可以访问虚拟机的文件了。然后把所需文件解压缩拷贝到共享文件夹bc中。

进入虚拟机，在命令行中输入./install.sh，安装脚本程序将会自动建立目录，配置编译环境。

 

6、配置环境变量

在虚拟机中使用vi修改/root/.bash_profile文件中的PATH变量为PATH=$PATH:$HOME/bin:/opt/host/armv4l/bin/ （因为该文件为隐藏系统文件，所以使用ls命令不可见），存盘后执行：source/root/.bash_profile，则以后armv4l-unknown-linux-gcc 会自动搜索到，可以在终端上输入。

 

保存退出后，重启虚拟机或者在虚拟机shell中输入下面的命令。

（二）验证实验代码

1.将实验代码拷贝到共享文件夹中。

2、在虚拟机中编译代码。

对于多线程相关的代码，编译时需要加-lpthread的库

4、下载调试

在超级终端中运行可执行文件pthread，可得实验结果如图29所示。

 

运行可执行文件term。

注意：如果在执行./term 时出现下面的错误

/dev/ttyS0: No such file or directory

可以通过方法建立一个连接来解决。

在 Linux 下串口文件位于/dev 下，一般在老版本的内核中串口一为/dev/ttyS0 ，串口二为 /dev/ttyS1， 在我们的开发板中串口设备位于/dev/tts/下，因为开发板中没有ttyS0这个设备，所以我们要建立一个连接。

首先在超级终端中进入/dev文件夹中。

输入命令“ln –sf /dev/tts/0 /dev/ttyS0” 注意空格与字母l、数字0。