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

实验内容、步骤：

• 学习 02_pthread 03_tty中的代码。

• Linux使用:先打开桌面 vmware，然后打开C：/redhat 9虚拟机原始文件/redhat.vmx 用户名/密码： root:123456
  vmware 与Winxp 切换：ctrl + alt

• 完成 2410经典实验指导20110331.pdf中实验2,3

• 按照指导书步骤配置pc、虚拟机、实验箱环境，可以ping通

• 实验结果如下：
  

实验理解：

• 实验过程的理解，实验指导书中知识点的理解。

1. 多线程的概念？为什么要提出多线程？

   在一个程序中，这些独立运行的程序片断叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理”。利用多线程，提高应用程序响应；使多CPU 系统更加有效；改善程序结构。

2. 实验中控制两个进程顺利进行的关键是什么？

   生产者首先要获得互斥锁，并且判断写指针+1 后是否等于读指针，如果相等则进入等待状态，等候条件变量notfull；如果不等则向缓冲区中写一个整数，并且设置条件变量为notempty，最后释放互斥锁。消费者线程与生产者线程类似，所以控制进程的关键为互斥锁。

实验遇到的问题：

1. 一开始我们的arm总是无连接，后来更换了实验箱

2. 出现错误，可能是命令输错了，后来用tab键补全命令，解决问题。
   

线程相关函数

线程创建函数：

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)

源代码注释

#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\n");
        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\n");
        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", n);
        put(&buffer, n);
    }
    put(&buffer, OVER);
    printf("producer stopped!\n");
    return NULL;
}

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