标签归档:Linux

Linux查看系统配置常用命令

 

系统

# uname -a # 查看内核/操作系统/CPU信息
# head -n 1 /etc/issue # 查看操作系统版本
# cat /proc/cpuinfo # 查看CPU信息
# hostname # 查看计算机名
# lspci -tv # 列出所有PCI设备
# lsusb -tv # 列出所有USB设备
# lsmod # 列出加载的内核模块
# env # 查看环境变量

资源

# free -m # 查看内存使用量和交换区使用量
# df -h # 查看各分区使用情况
# du -sh <目录名> # 查看指定目录的大小
# grep MemTotal /proc/meminfo # 查看内存总量
# grep MemFree /proc/meminfo # 查看空闲内存量
# uptime # 查看系统运行时间、用户数、负载
# cat /proc/loadavg # 查看系统负载

磁盘和分区

# mount | column -t # 查看挂接的分区状态
# fdisk -l # 查看所有分区
# swapon -s # 查看所有交换分区
# hdparm -i /dev/hda # 查看磁盘参数(仅适用于IDE设备)
# dmesg | grep IDE # 查看启动时IDE设备检测状况

网络

# ifconfig # 查看所有网络接口的属性
# iptables -L # 查看防火墙设置
# route -n # 查看路由表
# netstat -lntp # 查看所有监听端口
# netstat -antp # 查看所有已经建立的连接
# netstat -s # 查看网络统计信息

进程

# ps -ef # 查看所有进程
# top # 实时显示进程状态

用户

# w # 查看活动用户
# id <用户名> # 查看指定用户信息
# last # 查看用户登录日志
# cut -d: -f1 /etc/passwd # 查看系统所有用户
# cut -d: -f1 /etc/group # 查看系统所有组
# crontab -l # 查看当前用户的计划任务

服务

# chkconfig –list # 列出所有系统服务
# chkconfig –list | grep on # 列出所有启动的系统服务

程序

# rpm -qa # 查看所有安装的软件包

gdb的几个常用调试指令

本文为《GTK开发平台4.pdf》的gdb调试小节,摘于此处,以备后查。
• list :简记为 l ,其作用就是列出程序的源代码,默认每次显示10行。
• list 行号:将显示当前文件以“行号”为中心的前后10行代码,如:list 12
• list 函数名:将显示“函数名”所在函数的源代码,如:list main
• list :不带参数,将接着上一次 list 命令的,输出下边的内容。
注意:如果运行list 命令得到类似如下的打印,那是因为在编译程序时没有加入 -g 选项: (gdb) list 1 ../sysdeps/i386/elf/start.S: No such file or directory. in ../sysdeps/i386/elf/start.S
• run:简记为 r ,其作用是运行程序,当遇到断点后,程序会在断点处停止运行,等待用户输入下一步的命令。
• set args:设置运行程序时的命令行参数,如:set args 33 55
• show args:显示命令行参数
• continue:简讯为 c ,其作用是继续运行被断点中断的程序。
• break:为程序设置断点。
• break 行号:在当前文件的“行号”处设置断点,如:break 33
• break 函数名:在用户定义的函数“函数名”处设置断点,如:break cb_button
• info breakpoints:显示当前程序的断点设置情况
• disable breakpoints Num:关闭断点“Num”,使其无效,其中“Num”为 info breakpoints 中显示的对应值
• enable breakpoints Num:打开断点“Num”,使其重新生效
• step:简记为 s ,单步跟踪程序,当遇到函数调用时,则进入此函数体(一般只进入用户自定义函数)。
• next:简记为 n,单步跟踪程序,当遇到函数调用时,也不进入此函数体;此命令同 step 的主要区别是,step 遇到用户自定义的函数,将步进到函数中去运行,而 next 则直接调用函数,不会进入到函数体内。
• until:当你厌倦了在一个循环体内单步跟踪时,这个命令可以运行程序直到退出循环体。
• finish:运行程序,直到当前函数完成返回,并打印函数返回时的堆栈地址和返回值及参数值等信息。
• stepi或nexti:单步跟踪一些机器指令。
• print 表达式:简记为 p ,其中“表达式”可以是任何当前正在被测试程序的有效表达式,比如当前正在调试C语言的程序,那么“表达式”可以是任何C语言的有效表达式,包括数字,变量甚至是函数调用。
• print a:将显示整数 a 的值
• print ++a:将把 a 中的值加1,并显示出来
• print name:将显示字符串 name 的值
• print gdb_test(22):将以整数22作为参数调用 gdb_test() 函数
• print gdb_test(a):将以变量 a 作为参数调用 gdb_test() 函

• bt:显示当前程序的函数调用堆栈。
• display 表达式:在单步运行时将非常有用,使用display命令设置一个表达式后,它将在每次单步进行指令后,紧接着输出被设置的表达式及值。如: display a
• watch 表达式:设置一个监视点,一旦被监视的“表达式”的值改变,gdb将强行终止正在被调试的程序。如: watch a
• kill:将强行终止当前正在调试的程序
• help 命令:help 命令将显示“命令”的常用帮助信息
• call 函数(参数):调用“函数”,并传递“参数”,如:call gdb_test(55)
• layout:用于分割窗口,可以一边查看代码,一边测试:
• layout src:显示源代码窗口
• layout asm:显示反汇编窗口
• layout regs:显示源代码/反汇编和CPU寄存器窗口
• layout split:显示源代码和反汇编窗口
•Ctrl + L:刷新窗口

• quit:简记为 q ,退出gdb

 

当然,gdb的功能远不止这些,包括多进程/多线程/信号/远程调试等功能在这里均没有提及,有需要的读者可以参考其它信息。

linux/cygwin下使用gdb三板斧

第一步,先用gdb装载exe程序的调试符

(我用的是cygwin,所以使用’/cygdrive/盘符’来跳转到I盘下的xxx/111目录下)

HYH@HYH-PC ~
$ cd /                                                                        <========到根目录

HYH@HYH-PC /
$ cd /cygdrive/i/SingleValueTrans/111                      <========到exe所在目录

HYH@HYH-PC /cygdrive/i/SingleValueTrans/111
$ gdb valuetrans.exe                                                <========用gdb装载exe程序的调试符
GNU gdb (GDB) 7.3.50.20111026-cvs (cygwin-special)
Copyright (C) 2011 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type “show copying”
and “show warranty” for details.
This GDB was configured as “i686-cygwin”.
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>…
Reading symbols from /cygdrive/i/SingleValueTrans/111/valuetrans.exe…done.
(gdb)

 

第二步,用gdb运行程序
(gdb)
(gdb) r                          <========用gdb装载exe程序
Starting program: /cygdrive/i/SingleValueTrans/111/valuetrans.exe
[New Thread 22604.0x5de0]
[New Thread 22604.0x5e8c]
2012-06-07 18:17:04 Single value translation service is starting …

……

……

 

第三步,gdb已经自动在出问题的代码出停止并推出exe程序

2012-06-07 18:17:46 socket service listening at port ‘502’

Program received signal SIGSEGV, Segmentation fault.
[Switching to Thread 22604.0×6030]
0x004e703d in sockServer::tListen (param=0x20074160) at ..\sockServer.cpp:193

轻松看到看到程序在 sockServer.cpp:193行出问题了

 

 

还有些招数,比如生成core文件,利用core文件调试等,很好很强大,但是上面三板斧已经能直接定位到问题所在了,杀鸡焉用牛刀呢

 

 

Linux socket关闭连接shutdown与close

本文转自:
http://www.cublog.cn/u3/99348/showart_2072194.html

在Linux socket关闭连接的方法有两种分别是shutdown和close,

首先看一下shutdown的定义

#include

int shutdown(int sockfd,int how);

how的方式有三种分别是

SHUT_RD(0):关闭sockfd上的读功能,此选项将不允许sockfd进行读操作。

SHUT_WR(1):关闭sockfd的写功能,此选项将不允许sockfd进行写操作。

SHUT_RDWR(2):关闭sockfd的读写功能。

成功则返回0,错误返回-1,错误码errno:EBADF表示sockfd不是一个有效描述符;ENOTCONN表示sockfd未连接;ENOTSOCK表示sockfd是一个文件描述符而不是socket描述符。

close的定义如下:

#include

int close(int fd);

关闭读写。

成功则返回0,错误返回-1,错误码errno:EBADF表示fd不是一个有效描述符;EINTR表示close函数被信号中断;EIO表示一个IO错误。

下面摘用网上的一段话来说明二者的区别:

close——–关闭本进程的socket id,但链接还是开着的,用这个socket id的其它进程还能用这个链接,能读或写这个socket id
shutdown–则破坏了socket 链接,读的时候可能侦探到EOF结束符,写的时候可能会收到一个SIGPIPE信号,这个信号可能直到socket buffer被填充了才收到,shutdown还有一个关闭方式的参数,0 不能再读,1不能再写,2 读写都不能。

socket 多进程中的shutdown, close使用
当所有的数据操作结束以后,你可以调用close()函数来释放该socket,从而停止在该socket上的任何数据操作:
close(sockfd);

你也可以调用shutdown()函数来关闭该socket。该函数允许你只停止在某个方向上的数据传输,而一个方向上的数据传输继续进行。如你可以关闭某socket的写操作而允许继续在该socket上接受数据,直至读入所有数据。

int shutdown(int sockfd,int how);
Sockfd是需要关闭的socket的描述符。参数 how允许为shutdown操作选择以下几种方式:
SHUT_RD:关闭连接的读端。也就是该套接字不再接受数据,任何当前在套接字接受缓冲区的数据将被丢弃。进程将不能对该套接字发出任何读操作。对TCP套接字该调用之后接受到的任何数据将被确认然后无声的丢弃掉。

SHUT_WR:关闭连接的写端,进程不能在对此套接字发出写操作
SHUT_RDWR:相当于调用shutdown两次:首先是以SHUT_RD,然后以SHUT_WR

使用close中止一个连接,但它只是减少描述符的参考数,并不直接关闭连接,只有当描述符的参考数为0时才关闭连接
shutdown可直接关闭描述符,不考虑描述符的参考数,可选择中止一个方向的连接。

注意:

1>. 如果有多个进程共享一个套接字,close每被调用一次,计数减1,直到计数为0时,也就是所用进程都调用了close,套接字将被释放。

2>. 在多进程中如果一个进程中shutdown(sfd, SHUT_RDWR)后其它的进程将无法进行通信. 如果一个进程close(sfd)将不会影响到其它进程. 得自己理解引用计数的用法了. 有Kernel编程知识的更好理解了.

 

在使用select函数实现服务器socket的并行处理时必须注意,因为select的文件描述符是受系统限制的,不能大于某个值(默认64),如果大于此值,直接导致select对这些fd失效,而且最大fd越大,select函数的效率越低。所以对于处理那些不断断开并重连的访问方式,一定要及时关闭前面不用的fd,而关闭这些fd,不能使用shutdown()函数!因为经测试,用shutdown()函数时并不重置fd累加,所以接受新连接后新分配fd会不断上升,而close()会重置fd计数,避免fd数值不断上升。

                       ——khler

 

Linux下串口参数VTIME和VMIN的用法

   VTIME指定了等待的时间,VMIN指定了读取字符的最小数量。

   它们不同组合地取值会得到不同的结果,分别如下:

   1.当VTIME>0,VMIN>0时。read调用将保持阻塞直到读取到第一个字符,读到了第一个字符之后开始计时,此后若时间到了VTIME或者时间未到但已读够了VMIN个字符则会返回;若在时间未到之前又读到了一个字符(但此时读到的总数仍不够VMIN)则计时重新开始。

   2. 当VTIME>0,VMIN=0时。read调用读到数据则立即返回,否则将为每个字符最多等待VTIME时间。

   3. 当VTIME=0,VMIN>0时。read调用一直阻塞,直到读到VMIN个字符后立即返回。

   4. 若在open或fcntl设置了O_NDELALY或O_NONBLOCK标志,read调用不会阻塞而是立即返回,那么VTIME和VMIN就没有意义,效果等同于与把VTIME和VMIN都设为了0。

来自:http://blog.sina.com.cn/s/blog_4d32d0b40100j7d2.html

linux下的虚拟串口程序

今日编写了一个串口通讯程序,但是本机只有一个串口,无法验证程序的正确性,
于是想到在linux下面增加一对虚拟串口,找了半天,没有简便的解决方法,都是涉及驱动
小弟我不懂,只好继续找,最后找到一个用python语言写的一个简易程序,能够实现虚拟串口通讯
下面是源代码:
[code lang=”cpp”]
#! /usr/bin/env python

#coding=utf-8

import pty
import os
import select

def mkpty():
#
master1, slave = pty.openpty()
slaveName1 = os.ttyname(slave)
master2, slave = pty.openpty()
slaveName2 = os.ttyname(slave)
print ‘\nslave device names: ‘, slaveName1, slaveName2
return master1, master2

if __name__ == "__main__":

master1, master2 = mkpty()
while True:
rl, wl, el = select.select([master1,master2], [], [], 1)
for master in rl:
data = os.read(master, 128)
print "read %d data." % len(data)
if master==master1:
os.write(master2, data)
else:
os.write(master1, data)
[/code]

保存为VirtualComTest.py
在命令行中输入 python VirtualComTest.py &
然后会返回虚拟串口的设备地址

 

在终端里运行“python VirtualComTest.py &”,这样就可以生成一个基于pty(伪终端)的虚拟端口对,两个设备名会显示在终端里。然后就可以利用这两个设备名在本机上进行虚拟串口之类的调试~
使用完后用ps查看这个python进程的pid号,然后kill掉即可~

 

原文地址:http://fayaa.com/code/view/8500/

Linux编程Shell基本工作原理

Linux系统提供给用户的最重要的系统程序是Shell命令语言解释程序。它不属于内核部分,而是在核心之外,以用户态方式运行。其基本功能是解释并执行用户打入的各种命令,实现用户与Linux核心的接口。系统初启后,核心为每个终端用户建立一个进程去执行Shell解释程序。它的执行过程基本上按如下步骤:

(1)读取用户由键盘输入的命令行。

(2)分析命令,以命令名作为文件名,并将其它参数改造为系统调用execve( )内部处理所要求的形式。

(3)终端进程调用fork( )建立一个子进程。

(4)终端进程本身用系统调用wait4( )来等待子进程完成(如果是后台命令,则不等待)。当子进程运行时调用execve( ),子进程根据文件名(即命令名)到目录中查找有关文件(这是命令解释程序构成的文件),将它调入内存,执行这个程序(解释这条命令)。

(5)如果命令末尾有&号(后台命令符号),则终端进程不用系统调用wait4( )等待,立即发提示符,让用户输入下一个命令,转⑴。如果命令末尾没有&号,则终端进程要一直等待,当子进程(即运行命令的进程)完成处理后终止,向父进程(终端进程)报告,此时终端进程醒来,在做必要的判别等工作后,终端进程发提示符,让用户输入新的命令,重复上述处理过程。

Shell基本执行过程及父子进程之间的关系如图所示。

基于linux下shell的工作原理

什么是shell
Linux系统的shell作为操作系统的外壳,为用户提供使用操作系统的接口。它是命令语言、命令解释程序及程序设计语言的统称。
shell是用户和Linux内核之间的接口程序,如果把Linux内核想象成一个球体的中心,shell就是围绕内核的外层。当从shell或其他程序向Linux传递命令时,内核会做出相应的反应。
shell是一个命令语言解释器,它拥有自己内建的shell命令集,shell也能被系统中其他应用程序所调用。用户在提示符下输入的命令都由shell先解释然后传给Linux核心。
有一些命令,比如改变工作目录命令cd,是包含在shell内部的。还有一些命令,例如拷贝命令cp和移动命令rm,是存在于文件系统中某个目录下的单独的程序。对用户而言,不必关心一个命令是建立在shell内部还是一个单独的程序。
shell首先检查命令是否是内部命令,若不是再检查是否是一个应用程序(这里的应用程序可以是Linux本身的实用程序,如ls和rm,也可以是购买的商业程序,如xv,或者是自由软件,如emacs)。然后shell在搜索路径里寻找这些应用程序(搜索路径就是一个能找到可执行程序的目录列表)。如果键入的命令不是一个内部命令并且在路径里没有找到这个可执行文件,将会显示一条错误信息。如果能够成功找到命令,该内部命令或应用程序将被分解为系统调用并传给Linux内核。
shell的另一个重要特性是它自身就是一个解释型的程序设计语言,shell程序设计语言支持绝大多数在高级语言中能见到的程序元素,如函数、变量、数组和程序控制结构。shell编程语言简单易学,任何在提示符中能键入的命令都能放到一个可执行的shell程序中。
当普通用户成功登录,系统将执行一个称为shell的程序。正是shell进程提供了命令行提示符。作为默认值(TurboLinux系统默认的shell是BASH),对普通用户用“$”作提示符,对超级用户(root)用“#”作提示符。
一旦出现了shell提示符,就可以键入命令名称及命令所需要的参数。shell将执行这些命令。如果一条命令花费了很长的时间来运行,或者在屏幕上产生了大量的输出,可以从键盘上按ctrl+c发出中断信号来中断它(在正常结束之前,中止它的执行)。
当用户准备结束登录对话进程时,可以键入logout命令、exit命令或文件结束符(EOF)(按ctrl+d实现),结束登录。
我们来实习一下shell是如何工作的。
$ make work
make:***No rule to make target ‘work’. Stop.
$
注释:make是系统中一个命令的名字,后面跟着命令参数。在接收到这个命令后,shell便执行它。本例中,由于输入的命令参数不正确,系统返回信息后停止该命令的执行。
在例子中,shell会寻找名为make的程序,并以work为参数执行它。make是一个经常被用来编译大程序的程序,它以参数作为目标来进行编译。在 “make work”中,make编译的目标是work。因为make找不到以work为名字的目标,它便给出错误信息表示运行失败,用户又回到系统提示符下。
另外,用户键入有关命令行后,如果shell找不到以其中的命令名为名字的程序,就会给出错误信息。例如,如果用户键入:
$ myprog
bash:myprog:command not found
$
可以看到,用户得到了一个没有找到该命令的错误信息。用户敲错命令后,系统一般会给出这样的错误信息。
shell的种类
Linux中的shell有多种类型,其中最常用的几种是Bourne shell(sh)、C shell(csh)和Korn shell(ksh)。三种shell各有优缺点。Bourne shell是UNIX最初使用的shell,并且在每种UNIX上都可以使用。Bourne shell在shell编程方面相当优秀,但在处理与用户的交互方面做得不如其他几种shell。Linux操作系统缺省的shell是Bourne Again shell,它是Bourne shell的扩展,简称Bash,与Bourne shell完全向后兼容,并且在Bourne shell的基础上增加、增强了很多特性。Bash放在/bin/bash中,它有许多特色,可以提供如命令补全、命令编辑和命令历史表等功能,它还包含了很多C shell和Korn shell中的优点,有灵活和强大的编程接口,同时又有很友好的用户界面。
C shell是一种比Bourne shell更适于编程的shell,它的语法与C语言很相似。 Linux为喜欢使用C shell的人提供了Tcsh。Tcsh是C shell的一个扩展版本。Tcsh包括命令行编辑、可编程单词补全、拼写校正、历史命令替换、作业控制和类似C语言的语法,它不仅和Bash shell是提示符兼容,而且还提供比Bash shell更多的提示符参数。
Korn shell集合了C shell和Bourne shell的优点并且和Bourne shell完全兼容。Linux系统提供了pdksh(ksh的扩展),它支持任务控制,可以在命令行上挂起、后台执行、唤醒或终止程序。
Linux并没有冷落其他shell用户,还包括了一些流行的shell如ash、zsh等。每个shell都有它的用途,有些shell是有专利的,有些能从Internet网上或其他来源获得。要决定使用哪个shell,只需读一下各种shell的联机帮助,并试用一下。
用户在登录到Linux时由/etc/passwd文件来决定要使用哪个shell。例如:
# fgrep lisa /etc/passwd
lisa:x:500:500:TurboLinux User:/home/lisa:/bin/bash
shell被列每行的末尾(/bin/bash)。
由于Bash是Linux上缺省的shell,本章主要介绍Bash及其相关知识。
shell命令
命令行c
用户登录到Linux系统时,可以看到一个shell提示符,标识了命令行的开始。用户可以在提示符后面输入任何命令及参数。例如:
$ date
二 11 23 01:34:58 CST 1999
$
用户登录时,实际进入了shell,它遵循一定的语法将输入的命令加以解释并传给系统。命令行中输入的第一个字必须是一个命令的名字,第二个字是命令的选项或参数,命令行中的每个字必须由空格或TAB隔开,格式如下:
$ Command Option Arguments
1. 选项和参数
选项是包括一个或多个字母的代码,它前面有一个减号(减号是必要的,Linux用它来区别选项和参数),选项可用于改变命令执行的动作的类型。例如:
$ ls
motd passwd
$
这是没有选项的ls命令,可列出当前目录中所有文件,只列出各个文件的名字,而不显示其他更多的信息。
$ ls -l
total 2
-rw-r–r– 2 wzh book 22 Apr 20 20:37 motd
-rw-r–r– 2 wzh book 796 Apr 20 20:37 passwd
$
加入-l选项,将会为每个文件列出一行信息,诸如数据大小和数据最后被修改的时间。
大多数命令都被设计为可以接纳参数。参数是在命令行中的选项之后键入的一个或多个单词,例如:
$ ls -l text
-rw-r–r– 2 wzh book 22 Apr 20 20:37 motd
-rw-r–r– 2 wzh book 796 Apr 20 20:37 passwd
$
将显示text目录下的所有文件及其信息。
有些命令,如ls可以带参数,而有一些命令可能需要一些最小数目的参数。例如,cp命令至少需要两个参数,如果参数的数目与命令要求不符,shell将会给出出错信息。例如:
$ cp -i mydata newdata
注意:命令行中选项先于参数输入。
2. 命令行特征
命令行实际上是可以编辑的一个文本缓冲区,在按回车之前,可以对输入的文本进行编辑。比如利用BACKSPACE键可以删除刚键入的字符,可以进行整行删除,还可以插入字符,使得用户在输入命令,尤其是复杂命令时,若出现键入错误,无须重新输入整个命令,只要利用编辑操作,即可改正错误。
利用上箭头可以重新显示刚执行的命令,利用这一功能可以重复执行以前执行过的命令,而无须重新键入该命令。
bash保存着以前键入过的命令的列表,这一列表被称为命令历史表。按动上箭头,便可以在命令行上逐次显示各条命令。同样,按动下箭头可以在命令列表中向下移动,这样可以将以前的各条命令显示在命令行上,用户可以修改并执行这些命令。这一特征将在10.4节中进行详细的论述。
在一个命令行中还可以置入多个命令,用分号将各个命令隔开。例如:
$ ls -F;cp -i mydata newdata
也可以在几个命令行中输入一个命令,用反斜杠将一个命令行持续到下一行。
$ cp –i
mydata
newdata
上面的cp命令是在三行中输入的,开始的两行以反斜杠结束,把三行作为一个命令行。
shell中的特殊字符
shell中除使用普通字符外,还可以使用一些具有特殊含义和功能的特殊字符。在使用它们时应注意其特殊的含义和作用范围。下面分别对这些特殊字符加以介绍。
1. 通配符
通配符用于模式匹配,如文件名匹配、路经名搜索、字符串查找等。常用的通配符有*、?和括在方括号[ ]中的字符序列。用户可以在作为命令参数的文件名中包含这些通配符,构成一个所谓的“模式串”,在执行过程中进行模式匹配。
* 代表任何字符串(长度可以不等),例如:“f*”匹配以f打头的任意字符串。但应注意,文件名前的圆点(.)和路经名中的斜线(/)必须显式匹配。例如“*”不能匹配.file,而“.*”才可以匹配.file。
? 代表任何单个字符。
[] 代表指定的一个字符范围,只要文件名中[]位置处的字符在[]中指定的范围之内,那么这个文件名就与这个模式串匹配。方括号中的字符范围可以由直接给出的字符组成,也可以由表示限定范围的起始字符、终止字符及中间的连字符(-)组成。例如,f [a- d] 与f [abcd]的作用相同。Shell将把与命令行中指定的模式串相匹配的所有文件名都作为命令的参数,形成最终的命令,然后再执行这个命令。
下面我们给出表10-1说明这些通配符的具体含义。
表10-1 通配符含义举例
模式串
意 义
*
当前目录下所有文件的名称。
*Text*
当前目录下所有文件名中包含有Text的文件的名称。
[ab-dm]*
当前目录下所有以a、b、c、d、m开头的文件的名称。
[ab-dm]?
当前目录下所有以a、b、c、d、m开头且后面只跟有一个字符的文件的名称。
/usr/bin/??
目录/usr/bin下所有名称为两个字符的文件的名称。
特别需要注意的是,连字符“-”仅在方括号内有效,表示字符范围,如在方括号外面就成为普通字符了。而*和?只在方括号外面是通配符,若出现在方括号之内,它们也失去通配符的能力,成为普通字符了。例如,模式“- a[*?]abc”中只有一对方括号是通配符,*和?均为普通字符,因此,它匹配的字符串只能是- a*abc和- a?abc。
最后说明一下使用通配符时需要注意的一些问题。由于*、?和[]对于shell来说具有比较特殊的意义,因此在正常的文件名中不应出现这些字符。特别是在目录名中不要出现它们,否则Shell匹配起来可能会无穷的递归下去。另外要注意的一点是:如果目录中没有与指定的模式串相匹配的文件名,那么Shell 将使用此模式串本身作为参数传给有关命令。这可能就是命令中出现特殊字符的原因所在。

  2. 引号
在shell中引号分为三种:单引号,双引号和反引号。
* 单引号 ‘
由单引号括起来的字符都作为普通字符出现。特殊字符用单引号括起来以后,也会失去原有意义,而只作为普通字符解释。例如:
$ string=’$PATH’
$ echo $string
$PATH
$
可见$保持了其本身的含义,作为普通字符出现。
* 双引号 “
由双引号括起来的字符,除$、、’、和”这几个字符仍是特殊字符并保留其特殊功能外,其余字符仍作为普通字符对待。对于$来说,就是用其后指定的变量的值来代替这个变量和$;对于而言,是转义字符,它告诉shell不要对其后面的那个字符进行特殊处理,只当作普通字符即可。可以想见,在双引号中需要在前面加上的只有四个字符$,,’和”本身。而对”号,若其前面没有加,则Shell会将它同前一个”号匹配。
例如,我们假定PATH的值为.:/usr/bin:/bin,输入如下命令:
$ testString=”$PATH”$PATH”
$ echo $TestString
.:/usr/bin:/ bin”$PATH
$
读者可以自己试一下在第二个双引号之前不加会产生什么结果。
* 反引号 `
反引号(`)这个字符所对应的键一般位于键盘的左上角,不要将其同单引号(’)混淆。反引号括起来的字符串被shell解释为命令行,在执行时,shell首先执行该命令行,并以它的标准输出结果取代整个反引号(包括两个反引号)部分。例如:
$ pwd
/home/xyz
$ string=”current directory is `pwd`”
$ echo $string
current directour is /home/xyz
$
shell执行echo命令时,首先执行`pwd`中的命令pwd,并将输出结果/home/xyz取代`pwd`这部分,最后输出替换后的整个结果。
利用反引号的这种功能可以进行命令置换,即把反引号括起来的执行结果赋值给指定变量。例如:
$ today=`date`
$ echo Today is $today
Today is Mon Apr 15 16:20:13 CST 1999
$
反引号还可以嵌套使用。但需注意,嵌套使用时内层的反引号必须用反斜线()将其转义。例如:
$ abc=`echo The number of users is `who| wc-l“
$ echo $abc
The number of users is 5
$
在反引号之间的命令行中也可以使用shell的特殊字符。Shell为得到“中命令的结果,它实际上要去执行“中指定的命令。执行时,命令中的特殊字符,如$,”,?等又将具有特殊含义,并且“所包含的可以是任何一个合法的Shell命令,如:
$ ls
note readme.txt Notice Unix.dir
$ TestString=”`echo $HOME ` ` ls [nN]*`”
$ echo $TestString
/home/yxz note Notice
$
其他情况,读者可自行试之。
1. 注释符
在shell编程中经常要对某些正文行进行注释,以增加程序的可读性。在Shell中以字符“#”开头的正文行表示注释行。
此外还有一些特殊字符如:用于输入/输出重定向与管道的、 >和|;执行后台命令的&;命令执行操作符&&和||及表示命令组的{}将在下面各小节中加以介绍。
标准输入/输出和重定向
1. 标准输入与输出
我们知道,执行一个shell命令行时通常会自动打开三个标准文件,即标准输入文件(stdin),通常对应终端的键盘;标准输出文件(stdout)和标准错误输出文件(stderr),这两个文件都对应终端的屏幕。进程将从标准输入文件中得到输入数据,将正常输出数据输出到标准输出文件,而将错误信息送到标准错误文件中。
我们以cat命令为例,cat命令的功能是从命令行给出的文件中读取数据,并将这些数据直接送到标准输出。若使用如下命令:
$ cat config
将会把文件config的内容依次显示到屏幕上。但是,如果cat的命令行中没有参数,它就会从标准输入中读取数据,并将其送到标准输出。例如:
$ cat
Hello world
Hello world
Bye
Bye
$
用户输入的每一行都立刻被cat命令输出到屏幕上。
另一个例子,命令sort按行读入文件正文(当命令行中没有给出文件名时,表示从标准输入读入),将其排序,并将结果送到标准输出。下面的例子是从标准输入读入一个采购单,并将其排序。
$ sort
bananas
carrots
apples
apples
bananas
carrots
$
这时我们在屏幕上得到了已排序的采购单。
直接使用标准输入/输出文件存在以下问题:
输入数据从终端输入时,用户费了半天劲输入的数据只能用一次。下次再想用这些数据时就得重新输入。而且在终端上输入时,若输入有误修改起来不是很方便。
输出到终端屏幕上的信息只能看不能动。我们无法对此输出作更多处理,如将输出作为另一命令的输入进行进一步的处理等。
为了解决上述问题,Linux系统为输入、输出的传送引入了另外两种机制,即输入/输出重定向和管道。
2. 输入重定向
输入重定向是指把命令(或可执行程序)的标准输入重定向到指定的文件中。也就是说,输入可以不来自键盘,而来自一个指定的文件。所以说,输入重定向主要用于改变一个命令的输入源,特别是改变那些需要大量输入的输入源。
例如,命令wc统计指定文件包含的行数、单词数和字符数。如果仅在命令行上键入:
$ wc
wc将等待用户告诉它统计什么,这时shell就好象死了一样,从键盘键入的所有文本都出现在屏幕上,但并没有什么结果,直至按下<ctrl+d>,wc才将命令结果写在屏幕上。
如果给出一个文件名作为wc命令的参数,如下例所示,wc将返回该文件所包含的行数、单词数和字符数。
$ wc /etc/passwd
20 23 726 /etc/passwd
$
另一种把/etc/passwd文件内容传给wc命令的方法是重定向wc的输入。输入重定向的一般形式为:命令this text forms the content
>of the here document,which
>continues until the end of
>text delimter
>delim
4 17 98
在文件名。例如:
$ ls > directory.out
$ cat directory.out
ch1.doc ch2.doc ch3.doc chimp config mail/ test/
$
将ls命令的输出保存为一个名为directory.out的文件。
注:如果>符号后边的文件已存在,那么这个文件将被重写。
为避免输出重定向中指定文件只能存放当前命令的输出重定向的内容,shell提供了输出重定向的一种追加手段。输出追加重定向与输出重定向的功能非常相似,区别仅在于输出追加重定向的功能是把命令(或可执行程序)的输出结果追加到指定文件的最后,而该文件原有内容不被破坏。
如果要将一条命令的输出结果追加到指定文件的后面,可以使用追加重定向操作符>>。形式为:命令>>文件名。例如:
$ ls *.doc>>directory.out
$ cat directory.out
ch1.doc ch2.doc ch3.doc chimp config mail/ test/
ch1.doc ch2.doc ch3.doc
$
和程序的标准输出重定向一样,程序的错误输出也可以重新定向。使用符号2>(或追加符号2>>)表示对错误输出设备重定向。例如下面的命令:
$ ls /usr/tmp 2> err.file
可在屏幕上看到程序的正常输出结果,但又将程序的任何错误信息送到文件err.file中,以备将来检查用。
还可以使用另一个输出重定向操作符(&>)将标准输出和错误输出同时送到同一文件中。例如:
$ ls /usr/tmp &> output.file
利用重定向将命令组合在一起,可实现系统单个命令不能提供的新功能。例如使用下面的命令序列:
$ ls /usr/bin > /tmp/dir
$ wc –w

服务器开发惯例和对现有开源项目的一些看法

上一篇转发的文章,作者提到了他的另一篇关于连接服务器的文章, 塞外浪子做了评价,我觉得还是比较中肯:

 

先保证通讯模块的稳定性和性能,然后再往下构架。。。毕竟是一劳永逸的事情。
关于服务器开发,必须要做到网络与逻辑分开。逻辑处理线程池可以根据各自需求整合到网络引擎中,或者整合到逻辑中。
我一般写服务器都是跨平台的,window下面用iocp,linux下用epoll,或者poll+多线程。
   线程池部分直接整合到网络引擎中。
   逻辑部分采用插件模式,即插即用,关于逻辑中的共享数据我将单独保存。

以上模型我就写了一次,用了3年,当然随着网络技术不断发展我会不断支持各自新的网络技术。
关于ACE或者各种开源引擎,我觉得好比是一件漂亮的衣服,但是要用的话很难控制甚至达不到开发者的初衷,发生问题的时候你只能等待新版本的更新了,这方面我以前可是吃尽了苦头。

小弟愚见!祝愿风云游戏作品越来越好,也希望有一天我写的游戏能够尽快稳定。

 

 

Linux下如何提高发现bug并排除问题的效率

1、编写代码时一定要非常非常的细心!
这是最最重要的一点,因为一些理所当然的假设往往埋伏了超级多的bug。减少bug的数量,就要从编码开始,认真写每一个字符,非常清楚每写一行代码都在执行什么动作、执行流程是否清晰明了;
2、仔细阅读代码和流程,做到“代码在脑袋里正确执行”!
如果做不到这一步,说明你对执行的代码不够了解,自然容易出问题,出了问题也不容易找出问题;
3、屏蔽可疑代码段
排除法是最有效的定位问题代码位置的办法,虽然常见,却不见得人人重视或第一时间采纳;
4、插旗法
在可疑的地方将变量值打印出来,或者打印一些提示性的语句,然后运行程序,仔细观察输出,以判别执行流程是否正确、变量赋值是否正确
5、gdb core文件定位问题
排在第5不是因为它不重要,而是因为排除bug需要有效的方式方法。gdb是神器,linux编程离不开它。你可以通过‘|’打印代码、break 下断点、run执行程序、bt查看调用堆栈,功能强大到无以复加的地步,就看你怎么用了;

Linux出3.0RC1版本了

2011年5月30日凌晨,也就是昨天早上,Linus在 linux-foundation.org上发布了这则消息。

这绝对是个爆炸式的新闻,毕竟Linux稳稳当当的用2.6.x发布了这么多经典版本,今天却一跃跨进3.0的门槛。这个版本跨越太大了,不是Linux版本管理的一贯作风。

用Linus的话说,此版本没有任何重大的更新,也没有任何重大的原因需要升至3.0,只是不想再数到40了……

Linus的原文:

http://permalink.gmane.org/gmane.linux.kernel/1147415

Linux 3.0-rc1

Linus Torvalds <torvalds <at> linux-foundation.org>
2011-05-30 01:30:32 GMT
Yay! Let the bikeshed painting discussions about version numbering
begin (or at least re-start).

I decided to just bite the bullet, and call the next version 3.0. It
will get released close enough to the 20-year mark, which is excuse
enough for me, although honestly, the real reason is just that I can
no longe rcomfortably count as high as 40.

The whole renumbering was discussed at last years Kernel Summit, and
there was a plan to take it up this year too. But let's face it -
what's the point of being in charge if you can't pick the bike shed
color without holding a referendum on it? So I'm just going all
alpha-male, and just renumbering it. You'll like it.

Now, my alpha-maleness sadly does not actually extend to all the
scripts and Makefile rules, so the kernel is fighting back, and is
calling itself 3.0.0-rc1. We'll have the usual 6-7 weeks to wrestle it
into submission, and get scripts etc cleaned up, and the final release
should be just "3.0". The -stable team can use the third number for
their versioning.

So what are the big changes?

NOTHING. Absolutely nothing. Sure, we have the usual two thirds driver
changes, and a lot of random fixes, but the point is that 3.0 is
*just* about renumbering, we are very much *not* doing a KDE-4 or a
Gnome-3 here. No breakage, no special scary new features, nothing at
all like that. We've been doing time-based releases for many years
now, this is in no way about features. If you want an excuse for the
renumbering, you really should look at the time-based one ("20 years")
instead.

So no ABI changes, no API changes, no magical new features - just
steady plodding progress. In addition to the driver changes (and the
bulk really is driver updates), we've had some nice VFS cleanups,
various VM fixes, some nice initial ARM consolidation (yay!) and in
general this is supposed to be a fairly normal release cycle. The
merge window was a few days shorter than usual, but if that ends up
meaning a smaller release and a nice stable 3.0 release, that is all
good. There's absolutely no reason to aim for the traditional ".0"
problems that so many projects have.

In fact, I think that in addition to the shorter merge window, I'm
also considering make this one of my "Linus is being a difficult
^&^hole" releases, where I really want to be pretty strict about what
I pull during the stabilization window. Part of that is that I'm going
to be traveling next week with a slow atom laptop, so you had better
convince me I *really* want to pull from you, because that thing
really is not the most impressive piece of hardware ever built. It
does the "git" workflow quite well, but let's just say that compiling
the kernel is not quite the user experience I've gotten used to.

So be nice to me, and send me only really important fixes. And let's
make sure we really make the next release not just an all new shiny
number, but a good kernel too.

Ok?

Go forth and test,

                            Linus

linux 下 crond 后台执行脚本的权限问题

这几天发现服务器又不自动备份日志了。。。

我通过在crond服务中添加定时执行备份脚本实现自动备份的,crontab文件:
/etc/crontab文件:

SHELL=/bin/bash
PATH=/sbin:/bin:/usr/sbin:/usr/bin
MAILTO=root
HOME=/

# run-parts
01 * * * * root run-parts /etc/cron.hourly
02 4 * * * root run-parts /etc/cron.daily
22 4 * * 0 root run-parts /etc/cron.weekly
42 4 1 * * root run-parts /etc/cron.monthly
59 11 * * * root /root/mysql_backup.sh
0 0 * * * root /usr/sbin/twslogbaker.sh

今天SSH以root登录,直接到/usr/sbin下执行twslogbaker.sh,居然说权限不够:

[root@localhost sbin]# twslogbaker.sh
-bash: /usr/sbin/twslogbaker.sh: 权限不够
[root@localhost sbin]# ls -l | grep tws
-rw-r--r-- 1 root root 834 03-16 16:00 twslogbaker.sh

什么时候失去执行权限了呢?唯一的可能性就是机器重启,权限丢失了。

再把权限加上:

[root@localhost sbin]# chmod 777 twslogbaker.sh
[root@localhost sbin]# ls -l | grep twslogbaker.sh
-rwxrwxrwx 1 root root 834 03-16 16:00 twslogbaker.sh
[root@localhost sbin]#

手动执行一下:

[root@localhost sbin]# twslogbaker.sh
---> Log path: '/usr/local/twslog'
---> Starting bak 'tws.log' to '2011-04-01.log' ...
---> file 'tws.log' not exist!
---> restart 'syslog' service
关闭内核日志记录器: [确定]
关闭系统日志记录器: [确定]
启动系统日志记录器: [确定]
启动内核日志记录器: [确定]
---> Done!
[root@localhost sbin]#

OK了。
如果判断正确,那么如何再开机时就使得cond后台服务具有执行twslogbaker.sh 的权限呢?

用Source Insight打开linux内核源代码

 

     作为一个开放源代码的操作系统,Linux附带的源代码库使得广大爱好者有了一个广泛学习、深入钻研的机会,特别是Linux内核的组织极为复杂,同时,又不能像windows平台的程序一样,可以使用集成开发环境通过察看变量和函数,甚至设置断点、单步运行、调试等手段来弄清楚整个程序的组织结构,使得Linux内核源代码的阅读变得尤为困难。

安装Source Insight并启动程序,可以进入图1界面。在工具条上有几个值得注意的地方,如图所示,图中内凹左边的是工程按钮,用于显示工程窗口的情况;右边的那个按钮按下去将会显示一个窗口,里边提供光标所在的函数体内对其他函数的调用图,通过点击该窗体里那些函数就可以进入该函数所在的地方。

图1 Source Insight界面图

由于Source Insight实质上是一个支持多种开发语言(java,c ,c++等等)的编辑器,只不过由于其查找、定位、彩色显示等功能的强大,而被我们当成源代码阅读工具使用。所以,为了有效的阅读源程序,首先必须选择功能菜单上的 “Project”选项的子菜单“New Project”新建一个项目,项目名称可以自由选定,当然也可以选择删除(Remove)一个项目。当删除一个项目的时候,并不删除原有的源代码文件,只是将该软件生成的那些工程辅助文件删除。设定之后,将会弹出一个对话框如图2,接受默认选择,如果,硬盘空间足够,可以将第一个复选框选上,该选项将会需要与源代码大致同等的空间来建立一个本地数据库以加快查找的速度。

图2 工程设置

点击“OK”按钮,接受选择后,将会有一个新的对话框弹出,在这个对话框里,可以选择将要阅读的文件加入工程,一种方式是通过在File Name中输入要阅读源代码文件的名称,点击“Add”按钮将其加入,也可以通过其中“Add All”和“Add Tree”两个按钮可以将选中目录的所有文件加入到工程中,其中“Add All”选项会提示加入顶层文件和递归加入所有文件两种方式,而“Add Tree”相当于“Add All”选项的递归加入所有文件,可以根据需要使用,就我来说,更喜欢“Add Tree”一些。由于该程序采用了部分打开文件的方式,没有用到的文件不会打开,所以,加入数千个文件也不用担心加入的文件超出程序的所能容忍的最大值,我就是采用“Add Tree”的方式将Linux2.4内核的四千五百九十一个文件加入的。

图3 添加文件

加入文件后,点击一个文件,可以出现使用界面,如图4所示,其中,右边的那个窗口(Linux Project,即工程窗口)缺省按照字母顺序列出当前工程中所有的文件。

图4 工作窗口

点击一个文件就可以打开该文件,显示如图5所示,进入到右边的那个窗口分别可以以文件列表的方式,列出所有的文件,每个窗体下边有一排按钮,左边的窗口(21142.c)从左至右分别为:按字母顺序排列所有标记、按照文件中行数顺序排列标记、按照类型排列标记、浏览本地文件标记、标记窗口属性。右边的窗口(Linux Project)从左至右分别为:按字母顺序文件列表、显示文件夹、按照文件类型归类文件、全部文件的所有标记列表、按照标记类型归类标记、跳转到定义处、显示标记信息、浏览工程标记、查找函数调用、工程属性,其中全部文件的所有标记列表选项可能要一段时间抽取标记,同步到数据库去,如果开始选择了建立标记数据库,将会在今后节省同步时间,最有用的莫过于浏览标记信息和查找函数调用,前者可以通过“Jump”按钮在不同的地方查找同样的标志,还可以通过“Reference”按钮结合后者进行全局的标记查找。

Reference功能是Source Insight的特色之一,它可以在速度极快的在整个工程中找到所有的标记,并且在该行程序的前边加上红色箭头的小按钮链接上。图6是一个Reference搜索后的结果,它可以有两种模式,一种集中显示结果,图6显示的就是这种模式,在这种模式下,可以通过前边的红色箭头小按钮进入另外一种模式,该标记的具体的所在处,也可以通过标记的具体所在处点击红色箭头小按钮进入警种模式,还可以通过工具条上的两个红色小箭头直接在第二种模式下前后移动,察看相应信息。它的这个强大的功能使得阅读Linux源程序有如神助。但是要注意的是,当进行了第二次“Reference”时,它会提示你将结果集附加在第一个结果集的后边还是取代第一个结果集。如果选择前者,不能对结果集根据前后两次搜索结果进行分类,然后在其子类里进行移动,只能在整个结果集里移动;如果,选择后者,结果集将会被替换为第二次搜索的结果,略微有些不方便。

图6 Reference的搜索结果

当然,Source Insight 还提供了一些其他常见的便利。比如:右键菜单几乎包含了程序的所有功能,可以在编辑窗口为程序加上行号,还可以统计整个工程的程序行数,当然还有功能强大却用不上自动完成功能,似乎连它的30天试用期也是别有用心――可以迫使你尽可能快速的阅读源程序,其他一些技巧大家可以在使用过程中慢慢摸索。怎么样?爱好读源代码的朋友,不妨马上去下载一个,去开始我们的Linux内核探险之旅吧

本文转自:http://siamecat.spaces.live.com/blog/cns!EB2B82CF1C58E073!123.entry

感谢作者!

花了1680RMB拿下DevKit8000

今天终于拿到TI OMAP3530的开发板了,天漠的DevKit8000,花了1680人民币。

下一步,先熟悉熟悉Linux定制方面的知识。有了板子,也终于可以边看边实践了!

然后嘛,想做的东西就太多了,什么视觉系统啊、行走机构啊、蓝牙通讯啦……,每项都是重大课题,里面一点点东西都是好多公司花好多money在搞的东西,个人搞这个,有时候真觉得不现实。

但是,人不都得有点追求是不是?有追求,还得有点实现追求的实际行动是不是?搞就搞了,想这么多干嘛   :)~~~~~~~~~

 

 

Beanstalk Protocol

= Beanstalk Protocol =
Protocol
——–
The beanstalk protocol runs over TCP using ASCII encoding. Clients connect,
send commands and data, wait for responses, and close the connection. For each
connection, the server processes commands serially in the order in which they
were received and sends responses in the same order. All integers in the
protocol are formatted in decimal and (unless otherwise indicated)
nonnegative.
Names, in this protocol, are ASCII strings. They may contain letters (A-Z and
a-z), numerals (0-9), hyphen (“-“), plus (“+”), slash (“/”), semicolon (“;”),
dot (“.”), dollar-sign (“$”), underscore (“_”), and parentheses (“(” and “)”),
but they may not begin with a hyphen. They are terminated by white space
(either a space char or end of line). Each name must be at least one character
long.
The protocol contains two kinds of data: text lines and unstructured chunks of
data. Text lines are used for client commands and server responses. Chunks are
used to transfer job bodies and stats information. Each job body is an opaque
sequence of bytes. The server never inspects or modifies a job body and always
sends it back in its original form. It is up to the clients to agree on a
meaningful interpretation of job bodies.
The client may issue the “quit” command, or simply close the TCP connection
when it no longer has use for the server. However, beanstalkd performs very
well with a large number of open connections, so it is usually better for the
client to keep its connection open and reuse it as much as possible. This also
avoids the overhead of establishing new TCP connections.
If a client violates the protocol (such as by sending a request that is not
well-formed or a command that does not exist) or if the server has an error,
the server will reply with one of the following error messages:
 – “OUT_OF_MEMORY\r\n” The server cannot allocate enough memory for the job.
   The client should try again later.
 – “INTERNAL_ERROR\r\n” This indicates a bug in the server. It should never
   happen. If it does happen, please report it at
   http://groups.google.com/group/beanstalk-talk.
 – “BAD_FORMAT\r\n” The client sent a command line that was not well-formed.
   This can happen if the line does not end with \r\n, if non-numeric
   characters occur where an integer is expected, if the wrong number of
   arguments are present, or if the command line is mal-formed in any other
   way.
 – “UNKNOWN_COMMAND\r\n” The client sent a command that the server does not
   know.
These error responses will not be listed in this document for individual
commands in the following sections, but they are implicitly included in the
description of all commands. Clients should be prepared to receive an error
response after any command.
As a last resort, if the server has a serious error that prevents it from
continuing service to the current client, the server will close the
connection.
Job Lifecycle
————-
A job in beanstalk gets created by a client with the “put” command. During its
life it can be in one of four states: “ready”, “reserved”, “delayed”, or
“buried”. After the put command, a job typically starts out ready. It waits in
the ready queue until a worker comes along and runs the “reserve” command. If
this job is next in the queue, it will be reserved for the worker. The worker
will execute the job; when it is finished the worker will send a “delete”
command to delete the job.
Here is a picture of the typical job lifecycle:
   put            reserve               delete
  —–> [READY] ———> [RESERVED] ——–> *poof*
Here is a picture with more possibilities:
   put with delay               release with delay
  —————-> [DELAYED] <————.
                        |                   |
                        | (time passes)     |
                        |                   |
   put                  v     reserve       |       delete
  —————–> [READY] ———> [RESERVED] ——–> *poof*
                       ^  ^                |  |
                       |   \  release      |  |
                       |    `————-‘   |
                       |                      |
                       | kick                 |
                       |                      |
                       |       bury           |
                    [BURIED] <—————‘
                       |
                       |  delete
                        `——–> *poof*
The system has one or more tubes. Each tube consists of a ready queue and a
delay queue. Each job spends its entire life in one tube. Consumers can show
interest in tubes by sending the “watch” command; they can show disinterest by
sending the “ignore” command. This set of interesting tubes is said to be a
consumer’s “watch list”. When a client reserves a job, it may come from any of
the tubes in its watch list.
When a client connects, its watch list is initially just the tube named
“default”. If it submits jobs without having sent a “use” command, they will
live in the tube named “default”.
Tubes are created on demand whenever they are referenced. If a tube is empty
(that is, it contains no ready, delayed, or buried jobs) and no client refers
to it, it will be deleted.
Producer Commands
—————–
The “put” command is for any process that wants to insert a job into the queue.
It comprises a command line followed by the job body:
put <pri> <delay> <ttr> <bytes>\r\n
<data>\r\n
It inserts a job into the client’s currently used tube (see the “use” command
below).
 – <pri> is an integer < 2**32. Jobs with smaller priority values will be
   scheduled before jobs with larger priorities. The most urgent priority is 0;
   the least urgent priority is 4,294,967,295.
 – <delay> is an integer number of seconds to wait before putting the job in
   the ready queue. The job will be in the “delayed” state during this time.
 – <ttr> — time to run — is an integer number of seconds to allow a worker
   to run this job. This time is counted from the moment a worker reserves
   this job. If the worker does not delete, release, or bury the job within
   <ttr> seconds, the job will time out and the server will release the job.
   The minimum ttr is 1. If the client sends 0, the server will silently
   increase the ttr to 1.
 – <bytes> is an integer indicating the size of the job body, not including the
   trailing “\r\n”. This value must be less than max-job-size (default: 2**16).
 – <data> is the job body — a sequence of bytes of length <bytes> from the
   previous line.
After sending the command line and body, the client waits for a reply, which
may be:
 – “INSERTED <id>\r\n” to indicate success.
   – <id> is the integer id of the new job
 – “BURIED <id>\r\n” if the server ran out of memory trying to grow the
   priority queue data structure.
   – <id> is the integer id of the new job
 – “EXPECTED_CRLF\r\n” The job body must be followed by a CR-LF pair, that is,
   “\r\n”. These two bytes are not counted in the job size given by the client
   in the put command line.
 – “JOB_TOO_BIG\r\n” The client has requested to put a job with a body larger
   than max-job-size bytes.
 – “DRAINING\r\n” This means that the server has been put into “drain mode”
   and is no longer accepting new jobs. The client should try another server
   or disconnect and try again later.
The “use” command is for producers. Subsequent put commands will put jobs into
the tube specified by this command. If no use command has been issued, jobs
will be put into the tube named “default”.
use <tube>\r\n
 – <tube> is a name at most 200 bytes. It specifies the tube to use. If the
   tube does not exist, it will be created.
The only reply is:
USING <tube>\r\n
 – <tube> is the name of the tube now being used.
Worker Commands
—————
A process that wants to consume jobs from the queue uses “reserve”, “delete”,
“release”, and “bury”. The first worker command, “reserve”, looks like this:
reserve\r\n
Alternatively, you can specify a timeout as follows:
reserve-with-timeout <seconds>\r\n
This will return a newly-reserved job. If no job is available to be reserved,
beanstalkd will wait to send a response until one becomes available. Once a
job is reserved for the client, the client has limited time to run (TTR) the
job before the job times out. When the job times out, the server will put the
job back into the ready queue. Both the TTR and the actual time left can be
found in response to the stats-job command.
A timeout value of 0 will cause the server to immediately return either a
response or TIMED_OUT.  A positive value of timeout will limit the amount of
time the client will block on the reserve request until a job becomes
available.
During the TTR of a reserved job, the last second is kept by the server as a
safety margin, during which the client will not be made to wait for another
job. If the client issues a reserve command during the safety margin, or if
the safety margin arrives while the client is waiting on a reserve command,
the server will respond with:
DEADLINE_SOON\r\n
This gives the client a chance to delete or release its reserved job before
the server automatically releases it.
TIMED_OUT\r\n
If a non-negative timeout was specified and the timeout exceeded before a job
became available, the server will respond with TIMED_OUT.
Otherwise, the only other response to this command is a successful reservation
in the form of a text line followed by the job body:
RESERVED <id> <bytes>\r\n
<data>\r\n
 – <id> is the job id — an integer unique to this job in this instance of
   beanstalkd.
 – <bytes> is an integer indicating the size of the job body, not including
   the trailing “\r\n”.
 – <data> is the job body — a sequence of bytes of length <bytes> from the
   previous line. This is a verbatim copy of the bytes that were originally
   sent to the server in the put command for this job.
The delete command removes a job from the server entirely. It is normally used
by the client when the job has successfully run to completion. A client can
delete jobs that it has reserved, ready jobs, and jobs that are buried. The
delete command looks like this:
delete <id>\r\n
 – <id> is the job id to delete.
The client then waits for one line of response, which may be:
 – “DELETED\r\n” to indicate success.
 – “NOT_FOUND\r\n” if the job does not exist or is not either reserved by the
   client, ready, or buried. This could happen if the job timed out before the
   client sent the delete command.
The release command puts a reserved job back into the ready queue (and marks
its state as “ready”) to be run by any client. It is normally used when the job
fails because of a transitory error. It looks like this:
release <id> <pri> <delay>\r\n
 – <id> is the job id to release.
 – <pri> is a new priority to assign to the job.
 – <delay> is an integer number of seconds to wait before putting the job in
   the ready queue. The job will be in the “delayed” state during this time.
The client expects one line of response, which may be:
 – “RELEASED\r\n” to indicate success.
 – “BURIED\r\n” if the server ran out of memory trying to grow the priority
   queue data structure.
 – “NOT_FOUND\r\n” if the job does not exist or is not reserved by the client.
The bury command puts a job into the “buried” state. Buried jobs are put into a
FIFO linked list and will not be touched by the server again until a client
kicks them with the “kick” command.
The bury command looks like this:
bury <id> <pri>\r\n
 – <id> is the job id to release.
 – <pri> is a new priority to assign to the job.
There are two possible responses:
 – “BURIED\r\n” to indicate success.
 – “NOT_FOUND\r\n” if the job does not exist or is not reserved by the client.
The “touch” command allows a worker to request more time to work on a job.
This is useful for jobs that potentially take a long time, but you still want
the benefits of a TTR pulling a job away from an unresponsive worker.  A worker
may periodically tell the server that it’s still alive and processing a job
(e.g. it may do this on DEADLINE_SOON).
The touch command looks like this:
touch <id>\r\n
 – <id> is the ID of a job reserved by the current connection.
There are two possible responses:
 – “TOUCHED\r\n” to indicate success.
 – “NOT_FOUND\r\n” if the job does not exist or is not reserved by the client.
The “watch” command adds the named tube to the watch list for the current
connection. A reserve command will take a job from any of the tubes in the
watch list. For each new connection, the watch list initially consists of one
tube, named “default”.
watch <tube>\r\n
 – <tube> is a name at most 200 bytes. It specifies a tube to add to the watch
   list. If the tube doesn’t exist, it will be created.
The reply is:
WATCHING <count>\r\n
 – <count> is the integer number of tubes currently in the watch list.
The “ignore” command is for consumers. It removes the named tube from the
watch list for the current connection.
ignore <tube>\r\n
The reply is one of:
 – “WATCHING <count>\r\n” to indicate success.
   – <count> is the integer number of tubes currently in the watch list.
 – “NOT_IGNORED\r\n” if the client attempts to ignore the only tube in its
   watch list.
Other Commands
————–
The peek commands let the client inspect a job in the system. There are four
variations. All but the first operate only on the currently used tube.
 – “peek <id>\r\n” – return job <id>.
 – “peek-ready\r\n” – return the next ready job.
 – “peek-delayed\r\n” – return the delayed job with the shortest delay left.
 – “peek-buried\r\n” – return the next job in the list of buried jobs.
There are two possible responses, either a single line:
 – “NOT_FOUND\r\n” if the requested job doesn’t exist or there are no jobs in
   the requested state.
Or a line followed by a chunk of data, if the command was successful:
FOUND <id> <bytes>\r\n
<data>\r\n
 – <id> is the job id.
 – <bytes> is an integer indicating the size of the job body, not including
   the trailing “\r\n”.
 – <data> is the job body — a sequence of bytes of length <bytes> from the
   previous line.
The kick command applies only to the currently used tube. It moves jobs into
the ready queue. If there are any buried jobs, it will only kick buried jobs.
Otherwise it will kick delayed jobs. It looks like:
kick <bound>\r\n
 – <bound> is an integer upper bound on the number of jobs to kick. The server
   will kick no more than <bound> jobs.
The response is of the form:
KICKED <count>\r\n
 – <count> is an integer indicating the number of jobs actually kicked.
The stats-job command gives statistical information about the specified job if
it exists. Its form is:
stats-job <id>\r\n
 – <id> is a job id.
The response is one of:
 – “NOT_FOUND\r\n” if the job does not exist.
 – “OK <bytes>\r\n<data>\r\n”
   – <bytes> is the size of the following data section in bytes.
   – <data> is a sequence of bytes of length <bytes> from the previous line. It
     is a YAML file with statistical information represented a dictionary.
The stats-job data is a YAML file representing a single dictionary of strings
to scalars. It contains these keys:
 – “id” is the job id
 – “tube” is the name of the tube that contains this job
 – “state” is “ready” or “delayed” or “reserved” or “buried”
 – “pri” is the priority value set by the put, release, or bury commands.
 – “age” is the time in seconds since the put command that created this job.
 – “time-left” is the number of seconds left until the server puts this job
   into the ready queue. This number is only meaningful if the job is
   reserved or delayed. If the job is reserved and this amount of time
   elapses before its state changes, it is considered to have timed out.
 – “reserves” is the number of times this job has been reserved.
 – “timeouts” is the number of times this job has timed out during a
   reservation.
 – “releases” is the number of times a client has released this job from a
   reservation.
 – “buries” is the number of times this job has been buried.
 – “kicks” is the number of times this job has been kicked.
The stats-tube command gives statistical information about the specified tube
if it exists. Its form is:
stats-tube <tube>\r\n
 – <tube> is a name at most 200 bytes. Stats will be returned for this tube.
The response is one of:
 – “NOT_FOUND\r\n” if the tube does not exist.
 – “OK <bytes>\r\n<data>\r\n”
   – <bytes> is the size of the following data section in bytes.
   – <data> is a sequence of bytes of length <bytes> from the previous line. It
     is a YAML file with statistical information represented a dictionary.
The stats-tube data is a YAML file representing a single dictionary of strings
to scalars. It contains these keys:
 – “name” is the tube’s name.
 – “current-jobs-urgent” is the number of ready jobs with priority < 1024 in
   this tube.
 – “current-jobs-ready” is the number of jobs in the ready queue in this tube.
 – “current-jobs-reserved” is the number of jobs reserved by all clients in
   this tube.
 – “current-jobs-delayed” is the number of delayed jobs in this tube.
 – “current-jobs-buried” is the number of buried jobs in this tube.
 – “total-jobs” is the cumulative count of jobs created in this tube.
 – “current-waiting” is the number of open connections that have issued a
   reserve command while watching this tube but not yet received a response.
 – “pause” is the number of seconds the tube has been paused for.
 – “cmd-pause-tube” is the cumulative number of pause-tube commands for this
   tube.
 – “pause-time-left” is the number of seconds until the tube is un-paused.
The stats command gives statistical information about the system as a whole.
Its form is:
stats\r\n
The server will respond:
OK <bytes>\r\n
<data>\r\n
 – <bytes> is the size of the following data section in bytes.
 – <data> is a sequence of bytes of length <bytes> from the previous line. It
   is a YAML file with statistical information represented a dictionary.
The stats data for the system is a YAML file representing a single dictionary
of strings to scalars. It contains these keys:
 – “current-jobs-urgent” is the number of ready jobs with priority < 1024.
 – “current-jobs-ready” is the number of jobs in the ready queue.
 – “current-jobs-reserved” is the number of jobs reserved by all clients.
 – “current-jobs-delayed” is the number of delayed jobs.
 – “current-jobs-buried” is the number of buried jobs.
 – “cmd-put” is the cumulative number of put commands.
 – “cmd-peek” is the cumulative number of peek commands.
 – “cmd-peek-ready” is the cumulative number of peek-ready commands.
 – “cmd-peek-delayed” is the cumulative number of peek-delayed commands.
 – “cmd-peek-buried” is the cumulative number of peek-buried commands.
 – “cmd-reserve” is the cumulative number of reserve commands.
 – “cmd-use” is the cumulative number of use commands.
 – “cmd-watch” is the cumulative number of watch commands.
 – “cmd-ignore” is the cumulative number of ignore commands.
 – “cmd-delete” is the cumulative number of delete commands.
 – “cmd-release” is the cumulative number of release commands.
 – “cmd-bury” is the cumulative number of bury commands.
 – “cmd-kick” is the cumulative number of kick commands.
 – “cmd-stats” is the cumulative number of stats commands.
 – “cmd-stats-job” is the cumulative number of stats-job commands.
 – “cmd-stats-tube” is the cumulative number of stats-tube commands.
 – “cmd-list-tubes” is the cumulative number of list-tubes commands.
 – “cmd-list-tube-used” is the cumulative number of list-tube-used commands.
 – “cmd-list-tubes-watched” is the cumulative number of list-tubes-watched
   commands.
 – “cmd-pause-tube” is the cumulative number of pause-tube commands
 – “job-timeouts” is the cumulative count of times a job has timed out.
 – “total-jobs” is the cumulative count of jobs created.
 – “max-job-size” is the maximum number of bytes in a job.
 – “current-tubes” is the number of currently-existing tubes.
 – “current-connections” is the number of currently open connections.
 – “current-producers” is the number of open connections that have each
   issued at least one put command.
 – “current-workers” is the number of open connections that have each issued
   at least one reserve command.
 – “current-waiting” is the number of open connections that have issued a
   reserve command but not yet received a response.
 – “total-connections” is the cumulative count of connections.
 – “pid” is the process id of the server.
 – “version” is the version string of the server.
 – “rusage-utime” is the accumulated user CPU time of this process in seconds
   and microseconds.
 – “rusage-stime” is the accumulated system CPU time of this process in
   seconds and microseconds.
 – “uptime” is the number of seconds since this server started running.
 – “binlog-oldest-index” is the index of the oldest binlog file needed to
   store the current jobs
 – “binlog-current-index” is the index of the current binlog file being
   written to. If binlog is not active this value will be 0
 – “binlog-max-size” is the maximum size in bytes a binlog file is allowed
   to get before a new binlog file is opened
The list-tubes command returns a list of all existing tubes. Its form is:
list-tubes\r\n
The response is:
OK <bytes>\r\n
<data>\r\n
 – <bytes> is the size of the following data section in bytes.
 – <data> is a sequence of bytes of length <bytes> from the previous line. It
   is a YAML file containing all tube names as a list of strings.
The list-tube-used command returns the tube currently being used by the
client. Its form is:
list-tube-used\r\n
The response is:
USING <tube>\r\n
 – <tube> is the name of the tube being used.
The list-tubes-watched command returns a list tubes currently being watched by
the client. Its form is:
list-tubes-watched\r\n
The response is:
OK <bytes>\r\n
<data>\r\n
 – <bytes> is the size of the following data section in bytes.
 – <data> is a sequence of bytes of length <bytes> from the previous line. It
   is a YAML file containing watched tube names as a list of strings.
The quit command simply closes the connection. Its form is:
quit\r\n
The pause-tube command can delay any new job being reserved for a given time. Its form is:
pause-tube <tube-name> <delay>\r\n
 – <tube> is the tube to pause
 – <delay> is an integer number of seconds to wait before reserving any more
   jobs from the queue
There are two possible responses:
 – “PAUSED\r\n” to indicate success.
 – “NOT_FOUND\r\n” if the tube does not exist.

苹果i系列产品的操作系统:iOS

iOS是由蘋果公司為 iPhone 開發的操作系統。它主要是給 iPhone、iPod touch、iPad 以及 Apple TV 使用。就像其基於的 Mac OS X 操作系統一樣,它也是以 Darwin 為基礎的。原本這個系統名為 iPhone OS,直到 2010 年 6 月 7 日 WWDC 大會上宣布改名為 iOS。 iOS的系統架構分為四個層次:核心操作系統層(the Core OS layer),核心服務層(the Core Services layer),媒體層(the Media layer),可輕觸層(the Cocoa Touch layer)。系統操作佔用大概240MB的記憶體空間。

2011年2月2日,苹果已经发布了其 iOS4.3 beta3 预览版。

更详细的信息,请到Wiki上浏览:http://zh.wikipedia.org/zh/IOS

Linux下如何清空socket的接收缓冲区的数据

最近碰到一个问题,对于阻塞模式的socket通讯,如果要实现设备的命令控制,那么进入命令流前,缓冲区不能存有上次通讯没有取回的信息,否则一旦命令发出,然后读取缓冲区,很显然会读到上一次的剩余数据。做法当然很简单,就是先清除接收区的缓冲数据,可是如何清除?

网上有很多这样的问题,但都没什么规范的解决办法,有的甚至为了达到清空的目的,建议先close一下socket,这个太大手笔了,为了解决一个小问题而大动干戈,根本不是个合理的解决办法。

还有就是用recv读取,但是由于不知道缓存里有多少数据,如果是阻塞模式,到最后必然等到超时才知道数据已经读取完毕,这是个问题。

另一个是用fgetc,通过返回判断是否是feof:

[code lang=”C”]
whlie (1) {
a=fgetc(f);
if (feof(f)) break;
//…
b=fgetc(f);
if (feof(f)) break;
//…
}[/code]

当然,我不知道读取完毕后最后一次调用fgetc会不会堵塞,需要测试。

在非阻塞模式下,我们用recv就可以轻松搞定了,但是阻塞模式下,由于我们不知道缓冲区有多少数据,不能直接调用recv尝试清除。

使用一个小小的技巧,利用select函数,我们可以轻松搞定这个问题:

select函数用于监视一个文件描述符集合,如果集合中的描述符没有变化,则一直阻塞在这里,直到超时时间到达;在超时时间内,一旦某个描述符触发了你所关心的事件,select立即返回,通过检索文件描述符集合处理相应事件;select函数出错则返回小于零的值,如果有事件触发,则返回触发事件的描述符个数;如果超时,返回0,即没有数据可读。

重点在于:我们可以用select的超时特性,将超时时间设置为0,通过检测select的返回值,就可以判断缓冲是否被清空。通过这个技巧,使一个阻塞的socket成了‘非阻塞’socket。

现在就可以得出解决方案了:使用select函数来监视要清空的socket描述符,并把超时时间设置为0,每次读取一个字节然后丢弃(或者按照业务需要进行处理,随你便了),一旦select返回0,说明缓冲区没数据了(“超时”了)。

[code lang=”C”]
struct timeval tmOut;
tmOut.tv_sec = 0;
tmOut.tv_usec = 0;
fd_set fds;
FD_ZEROS(&amp;fds);
FD_SET(skt, &amp;fds);

int nRet;
char tmp[2];
memset(tmp, 0, sizeof(tmp));

while(1)
{
nRet= select(FD_SETSIZE, &amp;fds, NULL, NULL, &amp;tmOut);
if(nRet== 0) break;
recv(skt, tmp, 1,0);
}
[/code]

 这种方式的好处是,不再需要用recv、recvfrom等阻塞函数直接去读取,而是使用select,利用其超时特性检测缓冲区是否为空来判断是否有数据,有数据时才调用recv进行清除。

有人说同样可以用recv和socket的超时设置去清空啊,这个没错,但是你需要直接对socket描述符设置超时时间,而为了清空数据而直接修改socket描述符的属性,可能会影响到其他地方的使用,造成系统奇奇怪怪的问题,所以,不推荐使用。



看上TI 的 OMAP3530 开发板了

看上这块板子了:EVM3530-B3-1880-LUNC0

理由嘛:

1、CPU是TI的,TI OMAP3530 多核处理器,600MHz 的ARM Cortex-A8内核;430MHz TMS320C64x+ DSP POWERVR SG™2D/3D图形加速处理引擎。如果DSP资料开放,可以考虑移植OpenCV,利用DSP能力实现图像识别

2、一个10M/100M网卡、1个RS232、2个UART、4个USB2.0 Host、1个USB2.0 OTG

3、音频输入输出口、VGA口、视频输入输出口

4、SD卡槽

参数如下:
产品型号 技术参数 价格(RMB)
EVM3530-B3-1880-LUNC0 处理器:TI OMAP3530
内存:256M内存 + 256M Flash,
网络:采用LAN9221,10/100Mbps
USB接口:4个Host + 1个OTG
串口:1个RS232 + 2个串口插针
显示接口:标准DVI
1380

 

问题是1380大洋,还不带显示屏,如果加个4.3寸显示屏380,可就到1760了,nnd,喉贵!

选配表:

 
产品型号 技术参数 价格(RMB)
EVM3530-B3-1880-LUNC0 处理器:TI OMAP3530
内存:256M内存 + 256M Flash,
网络:采用LAN9221,10/100Mbps
USB接口:4个Host + 1个OTG
串口:1个RS232 + 2个串口插针
显示接口:标准DVI
1380
SOM-3530-B2-1880-C 1、处理器:TI OMAP3530
2、内存:256M内存 + 256M Flash
3、电源管理:高性能电源管理模块,支持USB
4、B2B接口:4x 0.5mm 60Pin B2B
600
SBC3530-A2-1880-LUAC0 处理器:TI OMAP3530
内存:256M内存 + 256M Flash,
网络:采用LAN9221,10/100Mbps
USB接口:4个Host + 1个OTG
串口:1个RS232 + 2个串口插针
显示接口:标准VGA
视频输入:四路模拟视频输入 + 1路数字摄像头
1580
DEV3530-128M 处理器:TI OMAP3530 ,内存:128M内存 + 128M Flash ,DVI视频接口:支持多种高分辨率,音频接口:2.1声道,网络:10/100Mbps 采用LAN9221,USB接口:1个OTG,串口:1个RS232 ,SD卡槽:最高支持32G容量 798
支持OMAP3530开发板的4.3寸群创液晶屏模块   380
支持OMAP3530开发板的7寸群创液晶屏模块   480
WIFI   250
 Camera   300
XDS100V2 仿真器   368
omap3530启动SD Card   55
适用于DEV3530系列   40

 

另两款:

DevKit8000评估套件+4.3触摸屏 OMAP3530开发板 256M

这个带了个4.3的屏幕,CPU与上一款一样,区别呢?

地址:http://item.taobao.com/item.htm?id=3781993929

报价¥1690,

256MB DevKit8000评估套件 配4.3寸屏 OMAP3530开发板

更上一款一样啊,报价多了9块钱 :)

地址:http://item.taobao.com/item.htm?id=3920551293

DevKit8000系列的参数及配置如下:

T1系列 主板型号 税前价 税后价 说明
OMAP3530 DevKit8000标准配置 888 1,050 单板+SD+电源+串口线
DevKit8000完全配置1 1,599 1,870 4.3”触摸屏及全部配件
DevKit8000完全配置2 1,799 2,100 7”触摸屏及全部配件
DevKit8000(2G)标准配置 988 1,160 单板+SD+电源+串口线
DevKit8000(2G)完全配置1 1,699 2,000 4.3”触摸屏及全部配件
DevKit8000(2G)完全配置2 1,899 2,220 7”触摸屏及全部配件
Mini8100 540 630 SBC8100核心板
SBC8100单板机 2,800 3,280 配512M SD卡、串口线、网线、5V/2A电源、USB转接线(Mini-B to A)、S-Video线。
SBC8100套件1 3,150 3,690 单板机配4.3寸触摸屏。
SBC8100套件2 3,300 3,860 单板机配7寸触摸屏。
Mini8100(2G) 640 750 SBC8100核心板
SBC8100(2G)单板机 2,900 3,400 配512M SD卡、串口线、网线、5V/2A电源、USB转接线(Mini-B to A)、S-Video线。
SBC8100(2G)套件1 3,250 3,800 单板机配4.3寸触摸屏。
SBC8100(2G)套件2 3,400 3,980 单板机配7寸触摸屏。
VSS3530(1G) 1299 1520 配12V/1.25A电源、串口线、串口转接板

 

配套模块型号 税前价 税后价 说明
CAM8000-A 250 290 模拟摄像头输入模块,配套DevKit8000和SBC8100
CAM8000-U 500 585 USB数字摄像头输入模块,配套DevKit8000和SBC8100
VGA8000-A 250 290 LCD转VGA输出模块,配套DevKit8000和SBC8100
模拟摄像头 250 290 提供配套电源,不带支架和连接线。
WF8000-U 250 290 USB WiFi模块,配套DevKit8000
GPRS8000-S 400 470 串口GPRS模块,配套DevKit8000
GPS8000-S 300 350 串口GPS模块,配套DevKit8000
CDMA8000-U 450 525 USB 3G模块,配套DevKit8000和SBC8100

 

仿真器 TDS560 Plus仿真器 4,800 4,800 适用于TI 公司C2000、C5000、C6000芯片及OMAP、DaVinci、ARM7、ARM9 
XDS100v2 380 445 支持多种处理器:TMS320C28x、TMS320C54x、TMS320C55x、TMS320C64x+、TMS320C674x、ARM 9、 ARM Cortex R4、ARM Cortex A8 

 

DevKit8000评估套件

 

– 基于TI OMAP3530处理器,板载256MByte DDR SDRAM、256MByte NAND Flash
– 支持DVI-D、VGA、TFT-LCD三种显示输出,可输出高清信号
– 支持摄像头输入、USB WiFi、GPS定位、GPRS通讯、CDMA
– 支持XDS100v2仿真器和TDS560 Puls仿真器调试
– 外扩USB OTG,串口,网口,摄像头,音频,SD/MMC,键盘等接口
– 支持WinCE 6.0及Linux2.6.28系统,完全兼容beagleboard
   

    DevKit8000评估主板为开发者使用TI OMAP35x系列处理器提供了完善的软件开发环境,支持linux-2.6.28操作系统及WinCE6.0操作系统,并包含完善的底层驱动程序,方便用户快速评估OMAP35x系列处理器、设计系统驱动及其定制应用软件,并提供有成熟的操作系统Google Android及Angstrom(GPE)的发布版本,方便用户快速体验OMAP35x处理器的强大的数据运算处理能力,也可降低产品开发周期,实现面向消费电子、医疗仪器、多媒体处理、视频监控、工业控制等领域的产品快速上市。
    DevKit8000评估套件是一个功能丰富的开发平台,为嵌入式设计人员提供快捷简单的实践方式来评估OMAP3530处理器。该套件提供了一个完整的实验评估平台,包括一个4.3″LCD屏、SD卡、电源及各种接口转接线(串口转接线,USB OTG转接线,S-Video转接线,HDMI转DVI-D转接线)等。该套件使设计者能够基于DevKit8000的板载系统快速开发出基于OMAP3530芯片的相关产品。

 
硬件特性
CPU单元: 

  • OMAP3530应用处理器(Pin to Pin兼容OMAP3503,OMAP3515,OMAP3525处理器)
  • 600-MHz ARM Cortex-A8 Core
  • 430MHz TMS320C64x+ DSP Core
  • 128MByte DDR SDRAM (可选配256MB DDR SDRAM)
  • 128MByte NAND Flash (可选配256MB NAND Flash)
  • 6层板

通讯接口: 

  • 1个S-VIDEO接口
  • 1个音频输入接口
  • 1个双声道音频输出接口
  • 1个10/100M以太网(芯片:DM9000,RJ45接口)
  • 1个高速USB2.0 OTG接口(芯片:TPS65930),速度达480Mbps
  • 1个高速USB2.0 Host接口
  • 2个串口(1个3线RS232电平串口,1个5线TTL电平串口)
  • 1个SD/MMC接口
  • 1个6*6键盘接口
  • 1个14针标准JTAG接口
  • 1个CAMERA接口(可外接CCD和CMOS的摄像头)
  • 4个按键(1个启动引导按键,1个复位按键及2个用户按键)
  • 扩展接口(包含McSPI,McBSP,I2C,HDQ及SD/MMC接口)

显示单元: 

  • 1个HDMI接口(芯片:TFP410),可输出分辨率1280×720,码率30fps的DVI-D高清信号
  • S-Video视频输出接口
  • 24bit真彩色LCD接口(含4线触摸屏接口,分辨率可支持2048*2048)

电气参数:

  • 工作温度:-40 ~ 85℃(芯片支持)
  • 环境湿度:20% ~ 90% ,非冷凝
  • 机械尺寸:110 mm * 95 mm
  • 电气指标:+5V电源供电,电流150mA
软件特性
Linux系统特性:

  • Linux版本:Linux2.6.28
  • 编译器版本:gcc version 4.2.1 (CodeSourcery Sourcery G++ Lite 2007q3-51)
  • 启动方式:支持网络、SD卡或NAND Flash中启动引导Linux系统
  • 更新方式:支持网络或SD卡更新映像
  • 文件系统格式:Ramdisk文件系统、UBI文件系统
  • 文件系统支持:ROM/CRAM/EXT2/EXT3/FAT/NFS/JFFS2/UBIFS
  • 设备管理支持:udev设备管理
  • 驱动支持:Serial、RTC、NAND、DVI、LCD、 触摸屏、SD卡、USB、键盘、音频、网络、LED、CAMERA、WiFi、GPS、GPRS、CDMA

 

Wince系统特性:

  • Wince版本:Wince6.0
  • 启动方式:网络、SD卡或NAND Flash中启动引导Wince系统
  • 更新方式:网络或SD卡更新映像
  • 文件系统:支持HIVE注册表支持及ROM文件系统(可读写)
  • 支持微软的远程调试工具对目标板的文件、注册表、进程及线程的管理
  • 系统特性:支持.NET Compact Framework 3.5及KITL内核调试
  • 电源管理:背光管理、电池管理、休眠\唤醒功能
  • 驱动支持:DVI、LCD、SD卡、键盘、音频、网络、NLED、USB、RTC、Watchdog、WiFi、GPS、GPRS、CDMA

Demo演示:

  • Angstrom系统:嵌入式操作系统,支持音频播放,网络浏览,图形编辑及文档处理
  • Android系统:Google开发的基于Linux平台的开源手机操作系统
  • DVSDK软件包:支持MPEG4,MPEG2,H264,mp3,aac音/视频格式DSP硬解码及2D/3D特效

源码及工具:

  • 提供u-boot 1.3.3源码及linux2.6.28内核源码(包含驱动源码)
  • 提供gcc交叉编译工具
  • 提供Wince6.0 BSP源码包(包含驱动源码)及SDK安装包

 

订购信息

产品编号 T6010074
产品名称 DevKit8000评估套件
标准配件  1) Devkit8000评估版 *1
 2) SD卡(512MByte) *1
 3) 交叉串口线 *1
 4) 5V、2A电源适配器 *1
 5) CD光盘(包含用户手册、PDF原理图、外设驱动、源代码等)*1
完全配件  1) 4.3寸 LCD屏,分辨率(480*272)LCD8000-43T  *1
 2) SD卡(512MByte) *1
 3) 交叉串口线 *1
 4) 触摸笔 *1
 5) Mini USB A线转USB A型母头 *1
 6) Mini USB B线转USB A型公头 *1
 7) USB HUB(包括HUN电源、连接线) *1
 8) 网线 *1
 9) HMDI转DVI-D转接线 *1
 10) S-Video线 *1
 11) 5V、2A电源适配器 *1
 12) 光盘(包含用户手册、PDF原理图、外设驱动、源代码等) *1
可选配件  1)10.4寸LCD屏(LCD8000-104T,分辨率为800*600)(30套起订)一般不出货,
 2)7寸LCD屏(LCD8000-70T,分辨率为800*480),
 3)XDS100v2 仿真器(XDS100v2 仿真器
 4)560仿真器(TDS560 Plus仿真器
 5)VGA液晶显示(VGA8000,分辨率 1024*768)
 6)模拟摄像头模块(CAM8000-A,分辨率为720*576(PAL制式))
 7)数字摄像头模块(CAM8000-U
 8)USB WiFi模块(WF8000-U
 9)GPRS无线通讯模块(GPRS8000-S
 10)GPS定位系统模块(GPS8000-S
 11)CDMA8000-U 3G模块(CDMA8000-U
 
备注   CAM8000-A 摄像头模块现只支持Linux

ubuntu 文件权限命令详解使用格式和方法

作者: deepfuture    发表时间:2010-02-17     最后修改:2010-02-17  

原文地址:http://www.javaeye.com/topic/595628

=================================================

在 Ubuntu Linux 中用源码文件安装软件时经常都会用到chmod命令来更改文件的权限使其在安装时有执行的权限。由于 Ubuntu Linux 默认不能用root账户来登录所以在用chmod命令来更改文件的权限时往往需要结合sudo命令来使用,如果你对sudo命令还不太了解,请先看看本站的《sudo命令详解》

chmod

Linux/Ubuntu 系统中文件调用的权限分为三级:文件拥有者(u)、群组(g)、其他(o)。用chmod就可以更改文件的权限。chmod是一个相当灵活的命令,对同一个文件的权限的修改可以用多种风格的命令格式来实现。

◆方式一:

语法格式:

chmod [-vR] mode 文件名

参数说明:

mode 权限设置字串,格式为[ugoa] [+-=] [rwx]

u 表示文件的拥有者

g 表示与此文件拥有者属于一个组群的人

o 表示其他人

a 表示包含以上三者即文件拥有者(u)、群组(g)、其他(o)

+ 表示增加权限

– 表示取消权限

= 表示唯一设置权限

r 表示有读取的权限

w 表示有写入的权限

x 表示有执行的权限

-v 显示权限改变的详细资料

-R 表示对当前目录下的所有文件和子目录进行相同的权限更改

例:

我们要将当前目录下ownlinux这个文件的权限修为所有用户拥有该文件的读取、写入、执行的权限。在这里就需要结合sudo命令来使用,如果你对sudo命令还不太了解,请先看看本站的《sudo命令详解》

ownlinux@server:/var/www$ sudo chmod a+rwx ownlinux[sudo] password for ownlinux: (此时输入你的密码)

或者使用

ownlinux@server:/var/www$ sudo chmod ugo+rwx ownlinux[sudo] password for ownlinux: (此时输入你的密码)

命令不一样,但执行后的效果是一样的。

◆方式二:

语法格式:

chmod [-vR] [No] 文件名

参数说明:

No 三位代表相应权限的数字

-v 显示权限改变的详细资料

-R 表示对当前目录下的所有文件和子目录进行相同的权限更改

可能这种方式对于初学者来说有一定的难度,但这种方法学会后在更改文件权限就变得非常的简单。相信通过我的介绍大家会掌握种方法的:)

首先了解一下读取(r)、写入(w)、执行(x)相应的数字编号,如下图所示

如果你记住了上图所示的数字和对应的权限就往下边看

刚才已经说过了,[No]参数 是三位代表相应权限的数字。从左向右,第一位数学代表文件拥有者(u)的权限、群组(g)的权限、其他(o)的权限。每一个数字就对应该级用户拥有的权限即为rwx相应的数字之和。这样说可能大家不是很明白,我画了一张表帮助大家了解

如上图可以看出来如果是所有用户拥有该文件的读取、写入、执行的权限就是拥有者(u)的权限(4+2+1=7)群组(g)的权限(4+2+1=7)其他(o)的权限(4+2+1=7即为777。注意:如果没有读取的权限则”r”相应的数字编号就为”0″,写入(w)、执行(x)同理。

例:

就用刚才方式一的例子,我们要将当前目录下ownlinux这个文件的权限修为所有用户拥有该文件的读取(r)、写入(w)、执行(x)的权限。回顾一下方式一的命令格式。

ownlinux@server:/var/www$ sudo chmod a+rwx ownlinux[sudo] password for ownlinux: (此时输入你的密码)

方式二的命令

ownlinux@server:/var/www$ sudo chmod 777 ownlinux[sudo] password for ownlinux: (此时输入你的密码)

可以看出使用方式二的命令格式简洁明了

如果要让当前目录下ownlinux这个文件的权限修为该文件的拥有者(u)有该文件的读取(r)、写入(w)、执行(x)的权限,群组(g)和其他(o)的用户只有读取(r)和执行(x)的权限,运行以下命令:

ownlinux@server:/var/www$ sudo chmod 755 ownlinux[sudo] password for ownlinux: (此时输入你的密码)

相信通过我的介绍大家都已经对chmod这个命令有一定的了解了吧。我觉得方式二的命令风格一但了解了就很容易掌握,而且方式二的命令风格简单明了。

感谢来自Ownlinux.cn:Linux/Ubuntu chmod命令详解使用格式和方法的稿件

以上为改变用户

改变群组的命令是

超级用户

格式

   chgrp [选项] 组 文件
   或
   chgrp [选项]  --reference=参考文件 文件
   将每个<文件>的所属组设定为<组>。

参数

   -c, --changes :像 --verbose,但只在有更改时才显示结果。
   --dereference:会影响符号链接所指示的对象,而非符号链接本身。
   -h, --no-dereference:会影响符号链接本身,而非符号链接所指示的目的地(当系统支持更改符号链接的所有者,此选项才有效)。
   -f, --silent, --quiet:去除大部分的错误信息。
   --reference=参考文件:使用<参考文件>的所属组,而非指定的<组>。
   -R, --recursive:递归处理所有的文件及子目录。
   -v, --verbose:处理任何文件都会显示信息。

应用说明

该命令改变指定指定文件所属的用户组。其中group可以是用户组ID,也可以是/etc/group文件中用户组的组名。<br />文件名是以空格分开的要改变属组的文件列表,支持通配符。如果用户不是该文件的属主或超级用户,则不能改变该文件的组。

应用实例

   改变/opt/local /book/及其子目录下的所有文件的属组为book,命令如下:
   $ chgrp - R book /opt/local /book

最后是改变文件用户

 (2) chown
功能:改变文件拥有者
格式:chown [参数]<用户名><文件名>
参数:-R:递归改变目录的拥有者
-f:不显示拥有者的详细信息
实例:1)# chown user f1
2)# chown -R user1 /d1
(3)umask
功能:设置权限掩码(决定新建文件的权限)
格式:umask 权限值(超级用户默认为022,普通用户默认为002)
实例:# umask 044
计算公式:目录:777-umask

声明:JavaEye文章版权属于作者,受法律保护。没有作者书面许可不得转载。