金艳霞
通信2班
201203110210
实验五 Linux交叉编译平台
一、实验目的
1.掌握一些基本的linux读写操作 2.利用vcc编译c程序
3.通过nfs挂载到实验箱中，利用交叉编译执行文件
二．实验设备
1.Arm9试验箱 2.Pc机
3.Linux系统服务器
三．实验过程及实验结果 1.连接电脑箱
2.设置交叉编译环境 启动putty.exe 登陆192.168.1.116
3.添加软件包至实验目录： ① [shiyan@localhost ~]$ cd /home/shiyan ② [shiyan@localhost ~]$ tar –zxvf arm-linux-gcc-3.4.4-glib-2.3.5-static.tar.gz tar -zxvf arm-linux-gcc-3.4.4-glib-2.3.5-static.tar.gz ③ [shiyan@localhost201203110210] $export PATH=$PATH:/home/shiyan/201203110210/opt/crotool/arm-linux/gcc-3.4.4-glib-2.3.5/arm-linux/bin ④ [shiyan@localhost 201203110210]$ set OSTYPE=linux-gnu PATH=/usr/lib/qt-3.3/bin:/usr/kerberos/bin:/usr/local/bin:/bin:/usr/bin:/home/shiyan/bin:/home/shiyan/opt/crotool/arm-linux/gcc-3.4.4-glibc-2.3.5/arm-linux/bin:/home/shiyan/opt/crotool/arm-linux/gcc-3.4.4-glibc-2.3.5/arm-linux/bin:/home/shiyan/opt/crotool/arm-linux/gcc-3.4.4-glibc-2.3.5/arm-linux/bin 可以看出路径已添加 ⑤ [shiyan@localhost 201203110210]$ arm-linux-g再按tab arm-linux-g++
arm-linux-gcc
arm-linux-gcc-3.4.4 arm-linux-gccbug
arm-linux-gcov ⑥ [shiyan@localhost 201203110210]$ arm-linux-gcc arm-linux-gcc: no input files 此时出错，无此文件 3.测试程序 ① 创建hello.c [shiyan@localhost ~]$ vi hello.c #include int main() { printf(\"jin123\"); return 0; }
：wq ② 查看是否生成文件
[shiyan@matrix 201203110210]$ ls arm-linux-gcc-3.4.4-glib-2.3.5-static.tar.gz hello.c 已经生成 ③ 打开hello.c [shiyan@localhost ~]$ ./hello.c -bash:/hello cannot execute binary file 表示无法在服务器上执行 ④ 交叉编译hello.c [shiyan@localhost ~]$ arm-linux-gcc -o hello hello.c ⑤ 将文件拷贝到nfs下
[shiyan@localhost ~]$ cp hello /home/shiyan/nfs ⑥ 挂载服务器到板子上
/ $ mount –tnfs -o nolock 192.168.1.116:/home/shiyan/nfs/mnt/nfs / $cdmnt/nfs ⑦ 打开hello文件 / $./hello
结果输出: Jin 123
四．实验总结
上述实验可以得出，交叉编译的二进制可以在板子上运行，却不能在服务器上运行，很好的认清了交叉编译的意义和功能。
实验六Armboot下载运行及tcp实验
一．实验目的
1.掌握armboot的编译 2.掌握tftp工具的使用 3.掌握armboot下载运行
4.掌握windows的 tcp客户端的建立及通信过程 5.掌握tcp的基本原理
二．实验设备
1.Arm9试验箱 2.Pc机
3.Linux系统服务器
三．实验过程及实验结果 1) Armboot
① 编译armboot-1.1.0 cd /home/shiyan/arm-linux-2.6/armboot-1.1.0 [shiyan@matrix armboot-1.1.0]$ make
② 产生的armboot.bin拷贝到tftp的目录服务下
[shiyan@matrixarmboot-1.1.0]$ cparmboot.bin /home/shiyan/arm-linux-2.6/armboot-1.1.0/tftpboot/armboot ③ 打开arm9开发板，在五秒内按ESC，检查网络环境
CPE>printenv bootdelay=3 baudrate=38400 ethaddr=00:40:25:00:00:01 netmask=255.255.255.0 sererip=192.168.1.65 ipaddr=192.168.1.111 serverip=192.168.1.30
Environment size: 139/131068 bytes ④ 将armboot的网络环境改为tftp服务的网络地址
setenv serverip 192.168.1.220 CPE>saveenv Un-Protected 1 sectors Erasing sector 6 ...ok.0x800e0000
o Flash...done.Protected 1 sectors
⑤ 将armboot.bin文件通过tftp传输到内存0x2000000H中
CPE>tftp 0x2000000 armboot.bin ARP broadcast 1 ARP broadcast 2
⑥ 运行
go 0x2000000
⑦ 检查网络环境
CPE> printenv bootdelay=3 baudrate=38400 ethaddr=00:40:25:00:00:01 netmask=255.255.255.0 sererip=192.168.1.65 ipaddr=192.168.1.111 serverip=192.168.1.220
通过serverip的改变可看出armboot下载的正确性。
实验七 Mount挂载实验
一．实验目的 1.掌握一些基本的linux读写操作（touch指令） 2.掌握Usb挂载方法 3.掌握配置nfs的方法
二．实验设备
1.2.3.4.Arm9试验箱 Pc机
Linux系统服务器 U盘
三．实验过程及实验结果 A.文件夹挂载 1.服务器
[shiyan@matrix ~]$/etc/rc.d/init.d/nfs start 2.板子挂载
/ $ ifconfig eth0 192.168.1.98 / $ mount -t nfs -o nolock 192.168.1.220:/home/shiyan/nfs/mnt/nfs /$ df Filesystem
1k-blocks
Used Available Use% Mounted on /dev/mtdblock1
1024
544
480 53% /mnt/mtd 192.168.1.220:/home/shiyan/nfs 515455456 59590720 429681056 12% /mnt/nfs B.Usb 挂载
① 将u盘插入arm9开发板，并启动 ② 查看盘符信息
/ $ fdisk -l
③ 创建一个/mnt/usb文件夹
/ $ mkdir /mnt/usb ④ 把sda1盘符mount到/mnt/usb文件上
/ $ mount /dev/sda1 /mnt/usb/ / $ cd /mnt/usb /mnt/usb $ ls
⑤ 创建文件，并输入字符串
/mnt/usb $ vi jin.txt
hello!
⑥ 解挂载
/mnt/usb $ unmount /mnt/usb/ /bin/sh: unmount: not found ⑦ 将u盘拔出，插入电脑，观察该文件
结果正确
实验八RTC时钟驱动实验
一．实验目的
1.了解RTC工作原理 2.掌握RTC时钟驱动编程
二．实验内容
1.编写RTC驱动程序
2.通过insmod加载驱动程序 3.编写代码修改RTC内部时间
三．实验设备
1.PC机
2.Arm9实验箱客户端 3.Linux操作系统服务端
四．实验过程及结果
1.实验代码
#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define DRIVER_VERSION
\"0.01\" /* Register map */ /* rtc section */ // control and status registers #define REG_CS1 0x00
#define TEST1
(1
// 0-normal mode, must be set to logic 0 during normal operations; 1-EXT_CLK test mode #define STOP
(1
// 0-RTC source clock runs; 1-the RTC clock is stopped (CLKOUT at 32.768KHz is still available) #define TESTC
(1
// 0-power-on reset (POR) override facility is disable; set to logic 0 for normal operation; 1-POR override may be enable #define REG_CS2 0x01 #define TI_TP
(1
// 0-\\int is active when TF is active (subject to the status of TIE) #define AF
(1
(1
(1
(1
// Time and date registers #define REG_SC 0x02
// vl_seconds (0-59) #define REG_MN 0x03
// minutes (0-59) #define REG_HR 0x04
// hours (0-23) #define REG_DT 0x05
// days (1-31) #define REG_DW 0x06
// weekdays (0-6) #define REG_MO 0x07
// century_months (1-12) #define REG_YR 0x08
// years (0-99)
// Alarm registers #define REG_MA 0x09
// minute_alarm #define AE_M
(1
// hour_alarm #define AE_H
(1
// day_alarm #define AE_D
(1
// weekday_alarm #define AE_W
(1
(1
// timer_control #define TE
(1
// timer #define RTC_SECTION_LEN
7
/* i2c configuration */ #define I2C_ADDR
0xa2 ///////////////////////////////////////////////////////////// #define DEFAULT_I2C_CLOCKDIV
180//for APB 108MHz staticunsignedlong rtc_status; staticvolatileunsignedlong rtc_irq_data; staticunsignedlong rtc_freq = 1; /*FTRTC010 supports only 1Hz clock*/ staticstruct fasync_struct *rtc_async_queue; static DECLARE_WAIT_QUEUE_HEAD(rtc_wait); extern spinlock_t rtc_lock; MODULE_AUTHOR(\"GM Corp.\"); MODULE_LICENSE(\"GM License\"); externint GM_i2c_xfer(struct i2c_msg *msgs, int num, int clockdiv); /* block read */ staticint i2c_read_regs(u8 reg, u8 buf[], unsigned len) { struct i2c_msg msgs[1]; //////////////
buf[0] = reg;
msgs[0].addr = I2C_ADDR>>1;
msgs[0].flags = 0;
msgs[0].len = 1;
msgs[0].buf = buf;
if (GM_i2c_xfer(msgs, 1, DEFAULT_I2C_CLOCKDIV) != 1) return -1; //////////////
msgs[0].addr = I2C_ADDR>>1;
msgs[0].flags = 1;
msgs[0].len = len+1;
msgs[0].buf = buf;
if (GM_i2c_xfer(msgs, 1, DEFAULT_I2C_CLOCKDIV) != 1) return -1; return 0; } /* block write */ staticint i2c_set_regs(u8 reg, u8 const buf[], unsigned len) {
u8 i2c_buf[10]; struct i2c_msg msgs[1];
i2c_buf[0] = reg;
memcpy(&i2c_buf[1], &buf[0], len);
msgs[0].addr = I2C_ADDR>>1;
msgs[0].flags = 0;
msgs[0].len = len+1;
msgs[0].buf = i2c_buf;
if (GM_i2c_xfer(msgs, 1, DEFAULT_I2C_CLOCKDIV) != 1) return -1; return 0; } staticint set_time(struct rtc_time const *tm) { int sr;
u8 regs[RTC_SECTION_LEN] = { 0, };
printk(\"stop RTC\\n\");
regs[0] = STOP;
regs[1] = 0x00;
// disable interrupt and clear all flags
sr = i2c_set_regs(REG_CS1, regs, 2); if (sr
// write control and status registers
printk(\"%s: stop RTC failed\\n\", __func__); return sr;
}
printk(\"set_time Date(y/m/d):%d/%d/%d Time(h/m/s):%d/%d/%d\\n\",tm->tm_year,tm->tm_mon,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec);
regs[REG_SC-REG_SC] = BIN2BCD(tm->tm_sec);
regs[REG_MN-REG_SC] = BIN2BCD(tm->tm_min);
regs[REG_HR-REG_SC] = BIN2BCD(tm->tm_hour);
regs[REG_DT-REG_SC] = BIN2BCD(tm->tm_mday);
regs[REG_MO-REG_SC] = BIN2BCD(tm->tm_mon);
regs[REG_YR-REG_SC] = BIN2BCD(tm->tm_year-100);
regs[REG_DW-REG_SC] = BIN2BCD(tm->tm_wday & 7); /* write RTC registers */
sr = i2c_set_regs(REG_SC, regs, RTC_SECTION_LEN); if (sr
printk(\"%s: writing RTC section failed\\n\", __func__); return sr;
}
printk(\"start RTC\\n\");
regs[0] = 0x00;
sr = i2c_set_regs(REG_CS1, regs, 1); if (sr
// write control and status registers
printk(\"%s: start RTC failed\\n\", __func__); return sr;
}
return 0;
} staticvoid read_time (struct rtc_time *tm) { int sr;
u8 regs[RTC_SECTION_LEN] = { 0, };
sr = i2c_read_regs(REG_SC, regs, RTC_SECTION_LEN); if (sr
printk(\"%s: reading RTC section failed\\n\", __func__); return;
}
tm->tm_sec = BCD2BIN(regs[REG_SC-REG_SC]&0x7f);
tm->tm_min = BCD2BIN(regs[REG_MN-REG_SC]&0x7f);
tm->tm_hour = BCD2BIN(regs[REG_HR-REG_SC]&0x3f);
tm->tm_mday = BCD2BIN(regs[REG_DT-REG_SC]&0x3f);
tm->tm_wday = BCD2BIN(regs[REG_DW-REG_SC]&0x07);
tm->tm_mon = BCD2BIN(regs[REG_MO-REG_SC]&0x1f); /* rtc starts at 1 */
tm->tm_year = BCD2BIN(regs[REG_YR-REG_SC])+100;
printk(\"read_time Date(YY/MM/DD):%d/%d/%d Time(hh/mm/):%d/%d/%d\\n\",tm->tm_year,tm->tm_mon,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec); } staticunsigned AIE_stat=0; /*ijsung: arch-indep function*/ staticint rtc_open(struct inode *inode, struct file *file) { if (test_and_set_bit (1, &rtc_status)) return -EBUSY;
rtc_irq_data = 0; return 0; } staticint rtc_release(struct inode *inode, struct file *file) { unsignedchar buf[7];
rtc_status = 0; return 0; } staticint rtc_fasync (int fd, struct file *filp, int on) { return fasync_helper (fd, filp, on, &rtc_async_queue); } staticunsignedint rtc_poll(struct file *file, poll_table *wait) {
poll_wait (file, &rtc_wait, wait); return (rtc_irq_data) ? 0 : POLLIN | POLLRDNORM; } static loff_t rtc_llseek(struct file *file, loff_t offset, int origin) { return -ESPIPE; } ize_t rtc_read(struct file *file, char *buf, size_t count, loff_t *ppos) {
DECLARE_WAITQUEUE(wait, current); unsignedlong data;
ize_t retval; if (count
add_wait_queue(&rtc_wait, &wait);
set_current_state(TASK_INTERRUPTIBLE); for (;;) {
spin_lock_irq (&rtc_lock);
data = rtc_irq_data; if (data != 0) {
rtc_irq_data = 0; break;
}
spin_unlock_irq (&rtc_lock); if (file->f_flags & O_NONBLOCK) {
retval = -EAGAIN; goto out;
} if (signal_pending(current)) {
retval = -ERESTARTSYS; goto out;
}
schedule();
}
spin_unlock_irq (&rtc_lock);
data -= 0x100; /* the first IRQ wasn\'t actually mied */
retval = put_user(data, (unsignedlong *)buf); if (!retval)
retval = sizeof(unsignedlong); out:
set_current_state(TASK_RUNNING);
remove_wait_queue(&rtc_wait, &wait); return retval; } staticint rtc_ioctl(struct inode *inode, struct file *file, unsignedint cmd, unsignedlong arg) { struct rtc_time tm, tm2; unsignedchar buf[7]; switch (cmd) { case RTC_AIE_OFF:
printk(\"Not Support\\n\"); return 0; case RTC_AIE_ON:
printk(\"Not Support\\n\"); return 0; case RTC_ALM_READ:
printk(\"Not Support\\n\"); return 0; case RTC_ALM_SET:
printk(\"Not Support\\n\"); return 0; case RTC_RD_TIME:
read_time(&tm); break;
case RTC_SET_TIME:
{ unsigned usertime; unsignedchar buf[7]; if (!capable(CAP_SYS_TIME)) return -EACCES; if (copy_from_user (&tm, (struct rtc_time*)arg, sizeof (tm))) return -EFAULT;
set_time(&tm);
} return 0; case RTC_IRQP_READ: return put_user(rtc_freq, (unsignedlong *)arg); case RTC_IRQP_SET: if (arg != 1) return -EINVAL; return 0; case RTC_EPOCH_READ: return put_user (1970, (unsignedlong *)arg); default: return -EINVAL;
} return copy_to_user ((void *)arg, &tm, sizeof (tm)) ? -EFAULT : 0; } staticstruct file_operations rtc_fops = {
owner:
THIS_MODULE,
llseek:
rtc_llseek,
read:
rtc_read,
poll:
rtc_poll,
ioctl:
rtc_ioctl,
open:
rtc_open,
release: rtc_release,
fasync:
rtc_fasync, }; staticstruct miscdevice ftrtc010rtc_miscdev = {
RTC_MINOR,
\"rtc\", &rtc_fops }; staticint rtc_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data) { // unsigned alarm_time; unsignedchar buf[7];
char *p = page; int len; struct rtc_time tm;
read_time(&tm); //printk(\"RTC ...%d\\n\",xtime.tv_sec);
p += sprintf(p, \"rtc_time\\t: %02d:%02d:%02d\\n\"
\"rtc_date\\t: %04d-%02d-%02d\\n\"
\"rtc_epoch\\t: %04d\\n\",
tm.tm_hour + 1, tm.tm_min, tm.tm_sec,
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, 2000); // read_alarm(&tm); // p += sprintf(p, \"alrm_time\\t: %2dth day of week day\\n\" //
\"alrm_date\\t: N/A for Platform\\n\", //
tm.tm_wday);
p += sprintf(p, \"alrm_time\\t: Not Support\\n\"
\"alrm_date\\t: Not Support\\n\");
p += sprintf(p, \"alarm_IRQ\\t: %s\\n\", AIE_stat ? \"yes\" : \"no\" );
len = (poff; if (len
len = 0;
*eof = (len
*start = page + off; return len; } staticint __init rtc_init(void) {
misc_register (&ftrtc010rtc_miscdev);
create_proc_read_entry (\"driver/rtc\", 0, 0, rtc_read_proc, NULL);
printk(\"PCF8563 Real Time Clock driver\\n\"); return 0; } staticvoid __exit rtc_exit(void) {
remove_proc_entry (\"driver/rtc\", NULL);
misc_deregister (&ftrtc010rtc_miscdev); } module_init(rtc_init); module_exit(rtc_exit);
2.挂载usb / $ ifconfig eth0 192.168.1.99 / $ mount -t nfs -o nolock 192.168.1.220:/home/shiyan/nfs /mnt/nfs / $ fdisk –l / $ mkdir /mnt/usb / $ mount /dev/sda1 /mnt/usb/ / $ cd /mnt/usb
3.找到u盘中的pcf8563.ko /mnt/usb $ ls
4.加载pcf8563.ko /mnt/usb $ insmod pcf8563.ko
5.更改日期并写入
6.重启检验日期
与当前时间相符
实验九视频采集RTP发送及远程视频监控实验
一．实验目的 1.理解视频传输原理
2.掌握在IP网络中实现视频传输的方法 3.理解远程控制原理
4.掌握在windows下TCP客户端建立及通信过程
二．实验内容
1.搭建点对点视频传输模式 2.开启视频采集
3.开启Windows下tcp客户端，完成控制命令
三．实验设备
1.硬件：基于双核处理器架构的网络音视频传输教学实验系统；
对接线； 串口连接线； 网线；
集线器（HUB），PC机；
2.软件：H.264流媒体软件
设备端视频采集程序 设备端视频传输程序 串口操作软件
四．实验步骤及结果 A.视频采集
1.连接好实验箱，打开串口通信端，远程mount到home/nfs文件夹 / $ mount -t nfs -o nolock 192.168.1.116:/home/shiyan/nfs /mnt/nfs 2.挂载服务器下nfs与板子的/mnt/nfs，进入/mnt/nfs文件夹 / $ cd /mnt/nfs 3.输入ls命令，目录下文件 /mnt/nfs $ ls 123321
clientxxww
readme
tcpserver StartLog0
ffgpio.ko
server
tcpserver19 a
gpio_test
serverfxf
tcpserver_arm_11 bo
hello
serverxw
tcpserver_hdt client
nfs1
tcpclient
tcpserver_zn client_arm
ok
tcpclient19
tcpsever client_arm_17
program_20_1.c
tcpclient_29
tw2835_menu client_arm_st20
program_20_2.c
tcpclient_arm_11 xianshi client_dalan
programyk
tcpclient_hdt
yk clientxw
programyq
tcpclient_zn
yq 4.运行tw2835_menu进行视频采集 /mnt/nfs $ ./tw2835_menu&
5.进入挂载目录并查看文件 /mnt/nfs $ cd nfs1 /mnt/nfs/nfs1 $ ls dev_app.app
hello
vedio.confTCPS1
dev_app3
ffgpio.ko
tw2835_menu dev_app
gpio_test
tw2835_pic 6.运行dev_app到板子IP192.168.1.9 /mnt/nfs/nfs1 $ ./dev_app 192.168.1.9 7.开启H.264流媒体播放器进行视频接受 a) 用解码器解码，并允许注册.bat
b) 打开H.264流媒体播放器，点击开启视频接收
B.远程视频监控
1.重复以上实验1~4步
2.进入已挂载目录/mnt/nfs/nfs1，看到多个程序 /mnt/nfs $ cd nfs1 /mnt/nfs/nfs1 $ ls StartLog0
dev_app.app
hello
vedio.conf TCPS1
dev_app3
image.info
www boot.sh
ffgpio.ko
tw2835_menu 3.运行TCPS1 /mnt/nfs/nfs1 $ ./ TCPS1 4.程序进入等待状态，等待TCP连接到来
5.开启H.264流媒体播放器，点击“开始视频接收”，屏幕变黑
6.点击“控制功能”，输入设备端ip地址192.168.1.68，点击连接
7.设备端出现下列字样，表示连接成功
Servergetconnectionfrom192.168.1.68 8.点击“开启视频监控”，获得视频数据
实验十一Tcp网络编程
一、实验目的
1.了解网络编程原理 2.了解套接字的使用
二、实验原理
嵌入式Linux的网络通信程序是基于套接字模式的。Socket实际是网络传输层供给应用层的接口。常见的Socket有三种类型。 1.流式Sockct 流式套接字提供可靠的，面向连接的通信流，它使用TCP协议，从而保证了数据传输的正确性和顺序性。Socket编程采用客户/服务器模式。因此编程分为服务器端和客户端。服务器端：首先建立Socket，返回该Socket的描述符；配置Socket的端口和IP地址；建立监听函数，检测是否有客户端向服务器端发送请求，若有则接收该请求，将其放到接收队列中；从接收队列中接收一个请求；并向客户端发送确认连接信息。客户端：建立一个Socket，返回该Socket的描述符，配置Socket端口和IP地址；向服务器发送连接请求，并接收服务器发回的确认连接信息。双方通信结束后，关闭其Socket。2.数据报Socket，数据通过相互独立的报文进行传输，数据报套接字定义了一种无连接的服务，是无序的，并且不保证是可靠的，无差错的。它使用数据报协议UDP。 3.原始Socket 使用Socket编程时可以开发客户机和服务器端应用程序，它们可以在本地网络上进行通信，也可以通过Internet在全球范围内进行通信。编写并运行Socket的客户端和服务器端程序，双方通过套接字建立了服务连接请求，并且通过一些方法提高Socket的性能。
三、实验步骤
编写服务器端源程序和客户端源程序
1.代码：
program_20_1.c #include #include #include #include #include #include #include #include #include #include #include #include
int main(int argc, char *argv[]) {
int sockfd,new_fd;
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;
int portnumber;
const char hello[]=\"Hello and Bye\\n\"; // for setsockopt() SO_REUSEADDR, below
int yes = 1; int addrlen;
if(argc!=2)
{
fprintf(stderr,\"Usage:%s portnumber\\a\\n\",argv[0]);
exit(1);
}
if((portnumber=atoi(argv[1]))
{
fprintf(stderr,\"Usage:%s portnumber\\a\\n\",argv[0]);
exit(1);
}
/* 服务器端开始建立socket描述符 */
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
fprintf(stderr,\"Socket error:%s\\n\\a\",strerror(errno));
exit(1);
}
printf(\"Server-socket() is OK...\\n\");
// \"addre already in use\" error meage
if( setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes,sizeof(int))== -1 )
{
perror(\"Server-setsockopt() error lol!\");
exit(1);
}
printf(\"Server-setsockopt() is OK...\\n\");
/* 服务器端填充 sockaddr结构 */
bzero(&server_addr,sizeof(struct sockaddr_in));
server_addr.sin_family=AF_INET;
server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
server_addr.sin_port=htons(portnumber);
memset(&(server_addr.sin_zero), \'\\0\', 8);
/* 捆绑sockfd描述符 */
if(bind(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr))==-1)
{
fprintf(stderr,\"Bind error:%s\\n\\a\",strerror(errno));
exit(1);
}
printf(\"Server-bind() is OK...\\n\");
/* 监听sockfd描述符 */
if(listen(sockfd,5)==-1)
{
fprintf(stderr,\"Listen error:%s\\n\\a\",strerror(errno));
exit(1);
}
printf(\"Server-listen() is OK...\\n\");
while(1)
{
/* 服务器阻塞,直到客户程序建立连接 */
addrlen = sizeof(client_addr);
if((new_fd=accept(sockfd,(struct sockaddr *)(&client_addr),&addrlen))==-1)
{
printf(\"Accept error:%s\\n\\a\",strerror(errno));
exit(1);
}else{
printf(\"Server-accept() is OK...\\n\"); }
printf(\"New connection from %s on socket %d\\n\", inet_ntoa(client_addr.sin_addr), new_fd);
if(write(new_fd,hello,strlen(hello))==-1)
{
printf(\"Write Error:%s\\n\",strerror(errno));
exit(1);
}else{ printf(\"Write something to the client, then close it.\\n\");
} close(new_fd);
}
close(sockfd);
exit(0); } program_20_2.c
/TCPClient示例/ #include #include #include #include #include #include #include #include
int main(int argc, char *argv[]) {
int sockfd;
char buffer[1024];
struct sockaddr_in server_addr; struct hostent *host; int portnumber,nbytes; if(argc!=3) {
fprintf(stderr,\"Usage:%s hostname portnumber\\a\\n\",argv[0]);
exit(1); }
if((host=gethostbyname(argv[1]))==NULL) {
herror (\"Get host name error\\n\");
exit(1); }
if((portnumber=atoi(argv[2]))
fprintf(stderr,\"Usage:%s hostname portnumber\\a\\n\",argv[0]);
exit(1); }
/* 客户程序开始建立 sockfd描述符 */
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1) {
fprintf(stderr,\"Socket Error:%s\\a\\n\",strerror(errno));
exit(1); }
/* 客户程序填充服务端的资料 */ bzero(&server_addr,sizeof(server_addr)); server_addr.sin_family=AF_INET;
server_addr.sin_port=htons(portnumber);
server_addr.sin_addr=*((struct in_addr *)host->h_addr); /* 客户程序发起连接请求 */
if(connect(sockfd,(struct sockaddr *)(&server_addr),\\
sizeof(struct sockaddr))==-1) {
fprintf(stderr,\"Connect Error:%s\\a\\n\",strerror(errno));
exit(1); }
/* 连接成功了 */
if((nbytes=read(sockfd,buffer,1024))==-1) {
fprintf(stderr,\"Read Error:%s\\n\",strerror(errno));
exit(1); }
buffer[nbytes]=\'\\0\';
printf(\"I have received:%s\\n\",buffer); /* 结束通讯 */ close(sockfd); exit(0); } 2.步骤
① 交叉编译服务端程序
[shiyan@matrix ~]$ cd /home/shiyan [shiyan@localhost ~]$ gcc -o clientjin program_20_1.c [shiyan@localhost ~]$ arm-linux-gcc -o serverjin program_20_2.c [shiyan@localhost ~]$ cp /home/shiyan/serverjin /home/shiyan/nfs
② 执行
[shiyan@localhost ~]$ ./clientjin 3456
③ 打开实验箱，并挂载 / $ ifconfig eth0 192.168.1.55 up / $ ping 192.168.1.116 / $ mount -t nfs -o nolock 192.168.1.116:/home/shiyan/nfs /mnt/nfs / $ cd mnt/nfs /mnt/nfs $ ls
④ 执行客户端程序
/mnt/nfs $ ./serverjin 192.168.1.116 3456
接受到数据，实验成功
实验十二 WEB服务器程序
一． 实验目的
1.掌握httpd工具制作web服务器的基本流程 2.掌握实验设备的连接和调试
二． 实验内容
1.运行实验箱
2.通过路由器将实验箱和pc机连接
3.在pc机上运行浏览器，看是否运行网页服务器
三．实验设备
1.Pc机
2.嵌入式实验箱 3.Pc机操作系统
四．实验步骤
1.连接好实验箱，挂载nfs文件
/ $ ifconfig eth0 192.168.1.55 / $ ping 192.168.1.116 / $ mount -t nfs -o nolock 192.168.1.116:/home/shiyan/nfs /mnt/nfs 3.进入nfs1/www文件夹查看可执行文件thttpd / $ cd mnt/nfs/nfs1 /mnt/nfs /nfs1 $ ls /mnt/nfs /nfs1/www $ ls
4.运行web服务器
/mnt/nfs /nfs1/www $ ./thttpd –c ./thttpd.conf /mnt/nfs /nfs1/www $ cd thttpd/ /mnt/nfs /nfs1/www/thttpd $ ls
5.查看网络文件
/mnt/nfs /nfs1/www/thttpd $ cd html /mnt/nfs /nfs1/www/thttpd/html $ ls /mnt/nfs /nfs1/www/thttpd/html $ cat index.html
6.打开浏览器输入192.168.1.55 ，进入web页面
