在驱动程序中初始化入口函数中，向内核注册一个设备后，往往要注册一个类

例如
static int __init mydriver_init(void) //驱动程序的初始化
{  
   ……
    MYDRIVER_Major = register_chrdev(0, DEVICE_NAME, &mydriver_fops); //向内核注册一个设备,返回值为注册的主设备号
    if (MYDRIVER_Major < 0)
    {
        printk(DEVICE_NAME " can't register major number\n");
        return MYDRIVER_Major;
    }
    ……
    mydriver_class = class_create(THIS_MODULE, DEVICE_NAME); //注册一个类，使mdev可以在"/dev/"目录下 面建立设备节点
    ……
    //创建一个设备节点，节点名为DEVICE_NAME
    device_create(mydriver_class, NULL, MKDEV(MYDRIVER_Major, 0), NULL, DEVICE_NAME);
    ……
}
从linux内核2.6的某个版本之后，devfs不复存在，udev成为devfs的 替代。相比devfs，udev有很多优势，在此就不罗嗦了，提醒一点，udev是应用层的东东，不要试图在内核的配置选项里找到它;加入对udev的支 持很简单，以作者所写的一个字符设备驱动为例，在驱动初始化的代码里调用class_create为该设备创建一个class，再为每个设备调用 class_device_create创建对应的设备。大致用法如下：
struct class *myclass = class_create(THIS_MODULE, “my_device_driver”);
class_device_create(myclass, NULL, MKDEV(major_num, 0), NULL, “my_device”);

device_create()  replaces  class_device_create()  in 2.6.21
这样的module被加载时，udev daemon就会自动在/dev下创建my_device设备文件。

Linux字符驱动中动态分配设备号与动态生成设备节点
http://www.cnblogs.com/zhuyp1015/archive/2012/05/22/2514008.html

class_create(),class_device_create()或device_create()自动创建设备文件结点
http://yuxu9710108.blog.163.com/blog/static/237515342011612104030470/

Linux高级字符设备驱动
http://www.linuxidc.com/Linux/2012-05/60469.htm

LabVIEW做成安装程序。

●●片上外设API

函数：

除中断处理函数

void vHwDeviceIntCallback (

uint32 u32DeviceId,

uint32 u32ItemBitmap);

之外，其他所有的函数命名方式为：

返回类型+AHI_+设备+功能

变量、常量：

中断有关的枚举类型：u32DeviceId、u32ItemBitmap

---------------------------------------------------------------

●●BOS API

函数：

命名方式为：

返回类型+Bos+功能

变量、常量：

---------------------------------------------------------------

●●ZDP API

有三类函数：

设备发现、服务发现、绑定

命名方式为：

zdp+功能

返回数据类型如何确定？？

常量、变量：

ZDP STATUS：

ZDP Cluster ID：

---------------------------------------------------------------

●●AF API

有两类函数：

AF数据实体函数（AFDE）、AF管理实体函数（AFME）

AF数据实体函数（AFDE）

命名方式为：

afde+功能

仅一个函数：afdeDataRequest

AF数据管理函数（AFME）

命名方式为：

afme+功能

变量、常量：(在文件af.h中)

（AFME）：KVP、MSG

AF_Transaction_s 、AF_Msg_Transaction_s 、AF_Kvp_Transaction_s 等

（AFME）：Node、Power、Simple；Complex、User

AF_NodeDescriptor_s、AF_PowerDescriptor_s、AF_SimpleDescriptor_s；

AF_ComplexDescriptor_s、AF_UserDescriptor_s、

---------------------------------------------------------------

●●ZigBee应用API

有三类函数：应用初始化函数、应用到协议栈函数、协议栈到应用

应用初始化函数：冷启动、热启动函数

命名：AppColdStart 、AppWarmStart

应用到协议栈函数：多以JZS_开头

命名方式为：

JZS_+返回类型+功能

开始学习Jennic公司的JN５１３９　芯片（内置ZigBee)

上一篇文章中已经介绍了实现最简单的串口接收程序的编写，这篇将对程序内容进行分析。

1.首先应说明操作串口的流程。

步骤一：设置串口参数，如：波特率，数据位，奇偶校验，停止位，数据流控制等。

步骤二：选择串口，如windows下的串口1为“com1”，Linux下为“ttyS0”等。

步骤三：读或写串口。

步骤四：关闭串口。

（我们上一个程序没有写串口和关闭串口的功能，打开串口也是在构造函数里完成的，因为那只是为了用最简单的方法完成串口程序的编写。在以后的文章里我们将会对它进行修改和完善。）

2.下面我们将按照上面的操作串口的流程，讲解第一个程序的编写。

第一，我们在写程序之前，应该浏览一下那6个文件，大概看一下它们里面都是什么内容，各个文件各个类之间有什么联系。在win_qextserialport.cpp文件中，我们看它的最后一个构造函数，会发现，串口可以在这里进行初始化。

Win_QextSerialPort::Win_QextSerialPort(const QString & name, const PortSettings& settings, QextSerialBase::QueryMode mode) {

Win_Handle=INVALID_HANDLE_VALUE;

setPortName(name);

setBaudRate(settings.BaudRate);

setDataBits(settings.DataBits);

setStopBits(settings.StopBits);

setParity(settings.Parity);

setFlowControl(settings.FlowControl);

setTimeout(settings.Timeout_Millisec);

setQueryMode(mode);

init();

}

它共有三个参数，其中第一个参数const QString & name，应该是串口的名字，是QString类型，我们可以用串口1即“com1”，不用过多说明。下面我们主要研究第二个和第三个参数。

第二，我们查看第二个参数的位置。

在Qt Creator的菜单中选择Edit->Find/Replace->All projects，如下图。

在弹出的对话框中输入要查找的内容PortSettings，如下图。

点击Search后，便能在下面显示出整个工程中所有PortSettings的位置。如下图。

我们点击第一条，可以看到在qextserialbase.h文件中有一个struct PortSettings，如下图。

我们双击这一条，进入相应的文件。如下图。

struct PortSettings

{

BaudRateType BaudRate;

DataBitsType DataBits;

ParityType Parity;

StopBitsType StopBits;

FlowType FlowControl;

long Timeout_Millisec;

};

可以看到在这个结构体里定义了串口初始化的各个参数，而对于BaudRateType等类型的定义，我们在这个结构体的上面可以看到，它们是多个枚举变量。如下图。


这时我们便应该明白了，这个结构体便是实现串口参数设置的。

第三，定义串口参数。

BaudRateType BaudRate;

波特率设置，我们设置为9600，即程序中用BAUD9600；

DataBitsType DataBits;

数据位设置，我们设置为8位数据位，即DATA_8；

ParityType Parity;

奇偶校验设置，我们设置为无校验，即PAR_NONE；

StopBitsType StopBits;

停止位设置，我们设置为1位停止位，即STOP_1；

FlowType FlowControl;

数据流控制设置，我们设置为无数据流控制，即FLOW_OFF；

long Timeout_Millisec;

延时设置，我们设置为延时500ms，即500；

这样便写出了程序中的那句：

struct PortSettings myComSetting = {BAUD9600,DATA_8,PAR_NONE,STOP_1,FLOW_OFF,500};

我们定义了一个结构体变量myComSetting，并对其进行了初始化。

第四，设置第三个参数。

我们先按上面的方法找到它的定义位置，在qextserialbase.h中，如下图。

可以看到查询模式也是枚举变量，有两个选项，我们选择第二个EventDriven，事件驱动。

到这里，我们就可以定义Win_QextSerialPort类的变量了，就是那句：

myCom = new Win_QextSerialPort("com1",myComSetting,QextSerialBase::EventDriven);

它完成了串口的选择和串口的初始化。

第五，写打开串口函数和读串口函数。

查看win_qextserialport.h文件，我们会发现Win_QextSerialPort类继承自QextSerialBase类。

查看qextserialbase.h文件，我们会发现QextSerialBase类继承自QIODevice 类。

我们在Qt的帮助中查看QIODevice 类，如下图。

其部分内容如下图。可以看到其中有enum OpenModeFlag { NotOpen, ReadOnly, WriteOnly, ReadWrite, ..., Unbuffered }，virtual bool open ( OpenMode mode )，QByteArray readAll ()等内容。

而下面的信号函数中有void readyRead ()；它可以查看串口是否有新的数据传来。

所以，我们可以用这个类里的这些函数操作串口。

如程序中的语句：

myCom ->open(QIODevice::ReadWrite);

//我们调用了其中的open函数，用ReadWrite可读写的方式进行打开串口；

connect(myCom,SIGNAL(readyRead()),this,SLOT(readMyCom()));

//我们关联信号readyRead()，和自己写的槽函数readMyCom()，当串口有数据传来时进行读串口操作。

void MainWindow::readMyCom() //自己写的读串口函数

{

QByteArray temp = myCom->readAll();

//我们调用readAll()函数，读取串口中所有数据，在上面可以看到其返回值是QByteArray类型。

ui->textBrowser->insertPlainText(temp);

//调用insertPlainText()函数，是窗口上的文本浏览器中连续输出数据，而不是每次写数据前都清除以前的

//数据，可以在Qt的帮助里查看这个函数的说明

}

这样我们便写完了所有的语句，最后只需要在mainwindow.h文件中加入相应的头文件，对象声明，函数声明即可。

      这里需要说明的是我们一定要学会查看文件和使用帮助文档，将我们不懂得知识一点一点搞明白。

      在下一篇中我们将会加入“打开串口”，“关闭串口”，“发送数据”三个按钮，将整个程序进行完善。

首先说明我们的编程环境是windows xp下，在Qt Creator中进行，如果在Linux下或直接用源码编写，程序稍有不同，请自己改动。

http://hi.baidu.com/yafeilinux/blog/item/8cf8f89539311a14d31b70a2.html

       在Qt中并没有特定的串口控制类，现在大部分人使用的是第三方写的qextserialport类，我们这里也是使用的该类。我们可以去

http://sourceforge.net/projects/qextserialport/files/

进行下载，也可以去下载论坛上的

http://www.qtcn.org/bbs/read.php?tid=22847

下载到的文件为：qextserialport-1.2win-alpha.zip

其内容如下图：

我们在windows下只需要使用其中的6个文件：

qextserialbase.cpp和qextserialbase.h，qextserialport.cpp和qextserialport.h，win_qextserialport.cpp和win_qextserialport.h

如果在Linux下只需将win_qextserialport.cpp和win_qextserialport.h 换为 posix_qextserialport.cpp和posix_qextserialport.h即可。

下面我们将讲述详细编程过程，这里我们先给出完整的程序，然后再进行逐句分析。

1.打开Qt Creator，新建Qt4 Gui Application，工程名设置为mycom，其他使用默认选项。

（注意：建立的工程路径不能有中文。）

2.将上面所说的6个文件复制到工程文件夹下，如下图。

3.在工程中添加这6个文件。

在Qt Creator中左侧的文件列表上，鼠标右击工程文件夹，在弹出的菜单中选择Add Existing Files，添加已存在的文件。如下图：

选择工程文件夹里的那6个文件，进行添加。如下图。

添加好后文件列表如下图所示：

4.点击mainwindow.ui，在窗口上加入一个Text Browser，用来显示信息。如下图。

5.在mainwindow.h的相应位置添加头文件#include "win_qextserialport.h"，添加对象声明Win_QextSerialPort *myCom;，添加槽函数声明void readMyCom();，添加完后，如下图。

6.在mainwindow.cpp的类的构造函数中添加如下语句。

MainWindow::MainWindow(QWidget *parent)

: QMainWindow(parent), ui(new Ui::MainWindow)

{

ui->setupUi(this);

struct PortSettings myComSetting = {BAUD9600,DATA_8,PAR_NONE,STOP_1,FLOW_OFF,500};

//定义一个结构体，用来存放串口各个参数

myCom = new Win_QextSerialPort("com1",myComSetting,QextSerialBase::EventDriven);

//定义串口对象，并传递参数，在构造函数里对其进行初始化

myCom ->open(QIODevice::ReadWrite);

//以可读写方式打开串口

connect(myCom,SIGNAL(readyRead()),this,SLOT(readMyCom()));

//信号和槽函数关联，当串口缓冲区有数据时，进行读串口操作

}

在下面添加readMyCom()函数的定义，添加如下代码。

void MainWindow::readMyCom()     //读串口函数

添加完代码后如下图。

此时如果运行程序，已经能实现读取串口数据的功能了。我们将单片机采集的温度信息由串口传给计算机，效果如下图。

这样最简单的串口通信程序就完成了。可以看到它只需要加入几行代码即可，非常简单。

在下一篇中我们将详细分析添加的每一条语句。

Linux串口编程简介(转至http://hi.baidu.com/adane/blog/item/b3bac3fd4c922440d7887d6f.html)

1  AVICap窗口类简介

2  AVICap窗口类的主要函数、宏简介

3  几个重要结构

4  视频捕捉举例

关键词 VFW 视频采集 VC

作者（原创）逄格民 2007-11-06

刚刚做了一个利用VFW(Video For Windows)的视频采集程序，就想写出来，给需要的人分享一下。程序并不复杂，
关键是在没人指导的情况下，学习是比较痛苦和漫长的过程，我经历了这个过程，如果大家想避免走弯路，直接看我
下面的解释就好了。由于我仅仅作出了结果，对很多东西的理解也许并不完全正确或者是完全错误，愿请指教。

提前说一句，我的程序是在Visual C++6.0平台下写的。

下面我慢慢说，你也慢慢听。

1 什么是VFW

VFW 是微软的一个软件包，至少可以用来开发视频采集程序，当然还有别的用处，但不是我想关心的。VFW提供了
基于消息的接口，而这些接口，也可以利用它本省定义的宏来实现。

2 怎么使用VFW

写之前提示一句，可以参照MSDN看下面的内容，一定会更好。

(1)创建一个基于对话框的程序，工程名称Grasp

因为要用VFW,所以要包含头文件

可在GraspDlg.h中加入 #include<Vfw.h>，然后Project

->Settings,在link标签页的Object/library modules :里面加入

Vfw32.lib

(2)在CGraspDlg类中添加一个窗口句柄

HWND m_hVideo;

(3)利用capCreateCaptureWindow函数创建窗口，并且得到返回的窗口句柄。

m_hVideo=::capCreateCaptureWindow("Me",WS_CHILD | WS_VISIBLE,
0,0,500,500,m_hWnd,0);

上面这个函数写在BOOL CGraspDlg::OnInitDialog()中。参数m_hWnd是你的工程中

对话框的句柄，窗口类中都有这个成员变量，而对话框的类是窗口类的子类，记得？

capSetCallbackOnFrame(m_hVideo, FrameCallbackProc);

上面第二个参数是回调函数的地址，名字可以自己来定义，但是回调函数必须有如下参数和返回值。

LRESULT CALLBACK FrameCallbackProc(HWND hWnd, LPVIDEOHDR lpVHdr);
人家规定的，咱们也没办法，就照着写就好啦。

解释一下，什么是回调函数呢，它有什么用处？

回调函数，就是你自己写的函数，符合规定的参数和返回值类型，符合规定的调用约定，比如上面这个函数
就是回调函数，参数和返回值类型都是规定好的，调用约定为CALLBACK，CALLBACK其实是一个宏
#define CALLBACK __stdcall
满足一定条件时，此函数可以被系统自动调用，在回调函数当中，你可以写自己的代码完成一定功能。
比如在这里，用capSetCallbackOnFrame(m_hVideo, FrameCallbackProc)注册后，当每得到一桢数据后，系统就
调用函数FrameCallbackProc。
(5)因为注册了回调函数，所以，当然要自己写出这个函数了。在GraspDlg.cpp中，且在
BOOL CGraspDlg::OnInitDialog()函数之前写下面代码：

LRESULT CALLBACK FrameCallbackProc(HWND hWnd, LPVIDEOHDR lpVHdr)
{
if (!ghVideo)
return FALSE;

return (LRESULT) TRUE ;
}
目前为止，该回调函数还没有什么作用，一会儿我们再来编写函数当中的代码，现在我就写的话，你也不见得看懂，
不是么。一会儿写的话，你就可以轻松明白了。
注意在这个函数中的ghVideo 了么？其实就和上面的m_hVideo一样,可是这里是全局函数，m_hVideo是对话框类的成员变量，
我写m_hVideo编译器是不认识的，对吧，所以，我又在GraspDlg.cpp当中定义了一个全局变量
HWND ghVideo;
并且，在m_hVideo=::capCreateCaptureWindow("Me",WS_CHILD | WS_VISIBLE,
0,0,500,500,m_hWnd,0);
之后加上一句ghVideo=m_hVideo; 这样就可以用ghVideo了。
(6)在BOOL CGraspDlg::OnInitDialog()中继续添加如下代码：
char szDeviceName[80];
char szDeviceVersion[80];
int wIndex;

for (wIndex = 0; wIndex < 10; wIndex++)
{
if (capGetDriverDescription (wIndex, szDeviceName,
sizeof (szDeviceName), szDeviceVersion,
sizeof (szDeviceVersion)) )
{
if(capDriverConnect(m_hVideo,wIndex))
{

}
}

}
上面代码中，capGetDriverDescription是列举所有可用视频的驱动程序，如果列举成功，用capDriverConnect进行连接。
其实，我的机器上就装了一个摄像头，所以，只有当wIndex=0的时候，列举成功，并且连接也成功。这段代码好像很奇怪，因为
列举成功之后，不论是否连接上，都没有做任何事情。其实可以用下面代码代替：

char szDeviceName[80];
char szDeviceVersion[80];

//Get Driver description
//and the code can also be deleted as you want.
capGetDriverDescription (0 szDeviceName,
sizeof (szDeviceName), szDeviceVersion,
sizeof (szDeviceVersion));
//connect window to driver
capDriverConnect(m_hVideo,0);
(7)到这里，再加下面两句话你就会有成就感了,在BOOL CGraspDlg::OnInitDialog()中继续添加如下代码：
capPreviewRate(m_hVideo, 40); // 设置Preview模式的显示速率
capPreview(m_hVideo, TRUE); //启动Preview模式
如果到此为止，已经完成了视频采集的全过程，你运行一下，就可以看到摄像头拍摄的画面了，显示在你的对话框上。
但是，我的目的还没有达到，我其实想在每一桢显示之前，能处理一下这一桢的数据，那么，去哪里找这桢数据存
放的位置呢？
(8)为了完成我的目标，我把步骤(7)中的两句代码先注释掉。在对话框上加一个按钮，并在对单击做出响应的响应函数
中写下面代码：
capGrabFrame(m_hVideo);
这是一个宏，将鼠标移动到这段代码上，右键单击，选择Go To Definition of capGrabFrame,你会看到
#define capGrabFrame(hwnd) ((BOOL)AVICapSM(hwnd, WM_CAP_GRAB_FRAME, (WPARAM)0, (LPARAM)0L))
而继续察看AVICapSM宏你会看到其实是在调用SendMessage函数呢，对吧，其实就是在发送消息。至于消息谁处理了，我们就不去
关心了，我们关心的是，发送消息后，系统会调用我们刚才注册的回调函数
LRESULT CALLBACK FrameCallbackProc(HWND hWnd, LPVIDEOHDR lpVHdr) ;
(9)好了，如果你单击按钮，capGrabFrame(m_hVideo)就发送消息了，然后，我们就进入回调函数了，这太好了。
看到回调函数传递的两个参数了么？我们更关心第二个参数，这个就是单击按钮我们捕捉到的一桢数据的入口啊！
LPVIDEOHDR 是结构体VIDEOHDR的指针，而在MSDN中察看结构体VIDEOHDR，我们就可以找到桢数据的存贮位置指针了。

VIDEOHDR定义如下：
typedef struct videohdr_tag {
LPBYTE lpData;
DWORD dwBufferLength;
DWORD dwBytesUsed;
DWORD dwTimeCaptured;
DWORD dwUser;
DWORD dwFlags;
DWORD_PTR dwReserved[4];
} VIDEOHDR, NEAR *PVIDEOHDR, FAR * LPVIDEOHDR;
看到结构体中第一个参数了么？这个就是我们想要的桢数据的指针！后面参数，包括缓冲区长度等。
(10)终于得到了缓冲区的数据，可是，又一个问题出现了，缓冲区中的数据到底具体是啥含义啊？
这桢图像多大啊？size 是多少乘多少的啊？就是我们想要的像素信息么？
好的，我先告诉你，缓冲区中全部是像素信息，我们照着我的步骤这样做，其实是默认了一些参数，包括图像的
长度，宽度，色彩数，等等，那么，这个默认的值是多少呢？
(11)用一下capGetVideoFormat宏吧，你会得到想要的东西。
在BOOL CGraspDlg::OnInitDialog()中继续添加如下代码：
BITMAPINFO bmpInfo;
capGetVideoFormat(m_hVideo,&bmpInfo,sizeof(BITMAPINFO));
BITMAPINFO结构体内容自己看MSDN.定义如下

typedef struct tagBITMAPINFO {
BITMAPINFOHEADER bmiHeader;
RGBQUAD bmiColors[1];
} BITMAPINFO, *PBITMAPINFO;

而BITMAPINFOHEADER定义如下：

typedef struct tagBITMAPINFOHEADER{
DWORD biSize;
LONG biWidth;
LONG biHeight;
WORD biPlanes;
WORD biBitCount;
DWORD biCompression;
DWORD biSizeImage;
LONG biXPelsPerMeter;
LONG biYPelsPerMeter;
DWORD biClrUsed;
DWORD biClrImportant;
} BITMAPINFOHEADER, *PBITMAPINFOHEADER;

加入步骤(11)的两句话，调试运行，我发现，bmpInfo.bmiHeader.biWidth为320,就是采集的图像宽度;
bmpInfo.bmiHeader.biHeight为240，就是采集的图像高度，这些都是默认值，也可以改变这些值，通过
capSetVideoFormat宏来实现。
(12)那么，我们在步骤(9)中，回调函数第二个参数对应的结构体VIDEOHDR中，图像数据缓冲区的大小
dwBufferLength是多少呢？我们可以在回调函数中加一个MessageBox函数，输出这个值，
我们就可以发现，为230400,这个数很好，正好等于图像宽度X图像高度的3倍，
也就是说，是图像像素数目的3倍，这就对了，每个像素用3个字节存储的嘛。好啦，我们知道了，桢缓冲区中，存储
的完全是图像的像素信息，那么，具体哪个值对应哪个像素呢？
存储顺序是这样的：先从图像最下面一行开始，从左向右，依次存储，每一个像素用连续的3个字节，分别为B(蓝色分量)，
G(绿色分量)，R(红色分量)。然后存储倒数第二行，仍然按照图像从左向右存储，然后倒数第三行，
倒数第四行。。。。。。等等，最后存储正数第一行。

好啦，我所有想说的都说完啦，你明白了么？好累，现在是晚上，快10点钟了，我正好要去跑步去了。

Linux内核模块参数权限

在进行linux内核模块编程时，常常需要给模块传递参数，其作用是从使用的设备号到驱动应当任何操作的几个方面. 例如, SCSI 适配器的驱动常常有选项控制标记命令队列的使用, IDE 驱动允许用户控制 DMA 操作. 如果你的驱动控制老的硬件, 还需要被明确告知哪里去找硬件的 I/O 端口或者 I/O 内存地址. 内核通过在加载驱动的模块时指定可变参数的值, 支持这些要求.
       参数常常被声明为一个静态全局变量，如static int num=10;然后使用module_param(参数名，参数类型，参数读写权限)为模块定义一个参数，例如：
module_prarm(num,int,S_IRUGO);
这样你就可以在insmod（装载模块）的时候为参数指定值，如果没有指定则使用默认值，例如上面的num=10,则10是参数num的默认值。下面以一个例子说明：
#include <linux/init.h>
#include <linux/module.h>
MODULE_LICENSE("Dual BSD/GPL");
static int num=10;
module_param(num,int,S_IRUGO);
static int hello_init(void)
{
    printk("Hello module init.\n");
    printk("num=%d\n",num);
    return 0;
}

static void   hello_exit(void)
{
    printk("Goodbye module exit.\n");
}

module_init(hello_init);
module_exit(hello_exit);

MODULE_DESCRIPTION("a simple module");
MODULE_ALIAS("hello");
将以上代码保存为文件hello.c，编写Makefile文件对其进行编译:
# Makefile2.6
ifneq ($(KERNELRELEASE),)
obj-m := hello.o
else
PWD  := $(shell pwd)
KVER ?= $(shell uname -r)
KDIR := /lib/modules/$(KVER)/build
all:
    $(MAKE) -C $(KDIR) M=$(PWD)
endif
然后make就可以了，make会生成：
|-- Module.symvers
|-- built-in.o
|-- hello.ko
|-- hello.mod.c
|-- hello.mod.o
`-- hello.o
这些文件，其中的hello.ko就是编译生成的模块，使用insmod将hello.ko模块装载进内核，这个需要超级用户权限，我的系统是ubuntu7.10，所以使用如下命令装载：
sudo insmod hello.ko num=20
使用dmesg命令查看运行结果：
xiyoulinux@xiyoulinux-desktop:~/module$ dmesg ＃实际上是读取/var/log/messages文件的内容
... #省略以前的信息
[14801.675260] Hello module init.
[14801.675265] num=20
这就是运行结果。如果你插入的是sudo insmod hello.ko,那么：
使用dmesg命令查看运行结果：
xiyoulinux@xiyoulinux-desktop:~/module$ dmesg ＃实际上是读取/var/log/messages文件的内容
... #省略以前的信息
[14801.675260] Hello module init.
[14801.675265] num=10 ＃取默认值
以上是内核模块的编译和运行情况，实际上你还需要用到lsmod(查看模块是否被插入，一般在打印出来的第一行里)、rmmod(卸载装载的模块，只有当模块的引用计数为0时才能被卸载)等命令。
       那么实质上当你装载模块hello.ko时，系统会在/sys/module下生成一个hello文件夹：

xiyoulinux@xiyoulinux-desktop:/sys/module/hello$ tree
.
|-- holders
|-- initstate
|-- parameters
|   `-- num
|-- refcnt
|-- sections
|   |-- __param
|   `-- __versions
`-- srcversion

3 directories, 6 files
其中parameters目录中就存放的是该模块的参数，一个参数对应一个文件,文件的内容为参数的默认值例如：
xiyoulinux@xiyoulinux-desktop:/sys/module/hello/parameters$ tree
.
`-- num

0 directories, 1 file
xiyoulinux@xiyoulinux-desktop:/sys/module/hello/parameters$ cat num
10

在module_param(num,int,S_IRUGO);
定义参数时，其中的参数读写权限S_IRUGO其实是对参数文件的读写权限，所以权限的设置值就和对文件的设置值一样，例如上面对num参数权限的设置S_IRUGO就是对所有用户具有读的权限，而S_IRUGO|S_IWUSR 则允许 root 来改变参数。

gcc-3.2.2-5.i386.rpm  ：用来编译

ncurses-5.6.tar.gz：用来配合make menuconfig 命令配置内核

bison-2.4.tar.gz ：语法解析器

flex-2.5.35.tar.bz2 ：词法解析器

m4-1.4.9.tar.gz： 

modutils-2.4.26.tar.bz2 ： http://www.kernel.org/pub/linux/utils/kernel/module-init-tools/

module-init-tools-3.2.2.tar.bz2：  2.6配套工具包

http://www.kernel.org/pub/linux/utils/kernel/modutils/v2.4/

linux-2.6.15.5.tar.bz2 : 内核源码包

第一步：

    将上面所有软件都拷贝到虚拟机中（非/mnt下）

第二步：

    将内核源码包linux-2.6.15.5.tar.bz2 放入/usr/src目录中，并用 tar -jxvf linux-2.6.15.5.tar.bz2 将其解压

    ，然后用命令将linxu符号连接映射到linux-2.6.15.5 ：ln -s  linux-2.6.15.5  linux

第三步：rpm -ivh gcc-3.2.2-5.i386.rpm 安装GCC

第三步：安装ncurses-5.6.tar.gz

           tar zxvf  ncurses-5.6.tar.gz   

           进入解压后目录 ./configure 

           make 

           make install  安装

第四步：安装bison-2.4.tar.gz

            ./configure --prefix=/usr
             make

             make check  :本软件包自带测试套件，能执行一些测试，以确定它是否编译正确

             make install

第五步：安装flex-2.5.35.tar.bz2

./configure --prefix=/usr &&
make &&
make install

一些程序并不知道flex而是试图寻找lex程序（事实上，flex是实现lex功能的另一种也是更好的选择）。为了满足少数一些程序的需要，我们将创建一个lex脚本，这个脚本调用flex并通过它来模仿lex的输出文件命名惯例。

通过下面的命令创建一个新文件 /usr/bin/lex ： 

cat > /usr/bin/lex << "EOF"
#!/bin/sh
# Begin /usr/bin/lex

exec /usr/bin/flex -l "$@"

# End /usr/bin/lex
EOF
chmod 755 /usr/bin/lex

第六步：升级m4

首先要卸载原来的m4，然后再安装新的m4

./configure --prefix=/usr

             make

             make check  :本软件包自带测试套件，能执行一些测试，以确定它是否编译正确

             make install

第七步：安装modutils-2.4.26.tar.bz2 （如果原来安装了modutils 需要将其卸载：rpm -e --nodeps modutils）

(由于Linux2.6内核的内核模块处理过程有所改变,因此Linux2.4内核下的modutils工具包已不在适合Linux2.6内核).

 ./configure &&
make &&
make install

(参照：http://docs.huihoo.com/lfs/lfs-4.0/chapter06/modutils.html)

第八步：安装module-init-tools-3.2.2.tar.bz2

tar －jxvf module-init-tools-3.2.2.tar.bz2

./configure --prefix=/sbin

make

make install

./generate-modprobe.conf /etc/modprobe.conf

第九步：配置内核

make menuconfig

第十步：编译内核

make bzImage (生成使用gzip压缩的内核，生成的文件位于/usr/src/linux/arch/i386/boot目录)

make modules modules_install（编译内核模块并安装到/lib/modules/2.6.15.5目录）

qclient.cpp

/*********************************************************************
*******
    ** $Id: /sample/10/qclient.h2.3.2edited 2004-10-12 $
    **
    ** Copyright (C) 2004-2005 OURSELEC AS. All rights reserved.
    ** Http://www.ourselec.com
    ** This file is part of an example program for Qt. This example
    ** program may be used, distributed and modified without limitation.
    **
**********************************************************************
*******/
#include "qclient.h"
#include <qsocket.h>
#include <qapplication.h>
#include <qvbox.h>
#include <qhbox.h>
#include <qtextview.h>
#include <qlineedit.h>
#include <qlabel.h>
#include <qlayout.h>
#include <qpushbutton.h>
#include <qtextstream.h>
#include <qpoint.h>
QClient::QClient(QWidget *parent, const char *name)
    : QWidget(parent, name)
{
    infoText = new QTextView(this);
    QHBox *hb = new QHBox(this);
    inputText = new QLineEdit(hb);
    QHBox *addrBox = new QHBox(this);
    QLabel *ip= new QLabel("IP:", addrBox, "ip");
    ip->setAlignment(1);
    addrText= new QLineEdit(addrBox);
    QLabel *port = new QLabel("PORT:", addrBox, "port");
    port->setAlignment(1);
    portText= new QLineEdit(addrBox);
    QHBox *buttonBox = new QHBox(this);
    QPushButton *send= new QPushButton(tr("Send"), hb);
    QPushButton *close = new QPushButton(tr("Close connection"),
                buttonBox);
    QPushButton *quit= new QPushButton(tr("Quit"), buttonBox);
    QPushButton *Connect = new QPushButton(tr("Connect"),
                addrBox);
    connect(send, SIGNAL(clicked()),
          SLOT(sendToServer()) );
    connect(close, SIGNAL(clicked()),
          SLOT(closeConnection()) );
    connect(quit, SIGNAL(clicked()),
          qApp, SLOT(quit()) );
    connect(Connect, SIGNAL(clicked()),
          SLOT(connectToServer()) );
    socket = new QSocket(this);
    connect(socket, SIGNAL(connected()),
            SLOT(socketConnected()) );
    connect(socket, SIGNAL(connectionClosed()),
            SLOT(socketConnectionClosed()) );
    connect(socket, SIGNAL(readyRead()),
            SLOT(socketReadyRead()) );
    connect(socket, SIGNAL(error(int)),
            SLOT(socketError(int)) );
    QVBoxLayout *l = new QVBoxLayout(this);
    l->addWidget(infoText, 10);
    l->addWidget(hb, 1);
    l->addWidget(addrBox, 1);
    l->addWidget(buttonBox, 1);
   //connect to the server
   infoText->append(tr("Tying to connect to the server"));
}

void QClient::closeConnection()
{
     socket->close();
     if (QSocket::Closing == socket->state()) {
          // We have a delayed close
          connect(socket, SIGNAL(delayedCloseFinished()),
                    SLOT(socketClosed()));
     } else {
          // The socket is closed
          socketClosed();
     }
}

void QClient::sendToServer()
{
     // write to the server
     if (QSocket::Connection == socket->state()) {
          QTextStream os(socket);
          os << inputText->text() << "\n";
          inputText->setText("");
     } else {
          // The socket is unconnected
          infoText->append(tr("The server is lost\n"));
     }
}

void QClient::connectToServer()
{
     // connect to the server
     socket->connectToHost(addrText->text(), (portText->text()).toInt());
}

void QClient::socketReadyRead()
{
     // read from the server
     while (socket->canReadLine()) {
           infoText->append(socket->readLine());
     }
}

void QClient::socketConnected()
{
     infoText->append(tr("Connected to server\n"));
}

void QClient::socketConnectionClosed()
{
     infoText->append(tr("Connection closed by the server\n"));
}

void QClient::socketClosed()
{
     infoText->append(tr("Connection closed\n"));
}

void QClient::socketError(int e)
{
     if (e == QSocket::ErrConnectionRefused) {
           infoText->append(tr("Connection Refused\n"));
     } else if (e == QSocket::ErrHostNotFound) {
           infoText->append(tr("Host Not Found\n"));
     } else if (e == QSocket::ErrSocketRead) {
           infoText->append(tr("Socket Read Error\n"));
     }
}

qclient.h

 /**************************************************************
    **************
    ** $Id: /sample/10/qclient.h2.3.2edited 2004-10-12 $
    **
    ** Copyright (C) 2004-2005 OURSELEC AS. All rights reserved.
    ** Http://www.ourselec.com
    ** This file is part of an example program for Qt. This example
    ** program may be used, distributed and modified without limitation.
    **
**********************************************************************
*******/
#ifndef QCLIENT_H
#define QCLIENT_H

#include <qsocket.h>
#include <qapplication.h>
#include <qvbox.h>
#include <qhbox.h>
#include <qtextview.h>
#include <qlineedit.h>
#include <qlabel.h>
#include <qpushbutton.h>
#include <qtextstream.h>
class QClient : public QWidget
{
     Q_OBJECT
public:
     QClient(QWidget *parent = 0, const char *name = 0);
private slots:
  void closeConnection();     //关闭网络连接
     void sendToServer();     //发送数据到服务器端
     void connectToServer();
     void socketReadyRead();
     void socketConnected();
     void socketConnectionClosed();
     void socketClosed();
     void socketError(int);
private:
     QSocket *socket;
     QTextView *infoText;
     QLineEdit *addrText;
     QLineEdit *portText;
     QLineEdit *inputText;
};
#endif
//QCLIENT_H

main.cpp

/*********************************************************************
*******
    ** $Id: /sample/10/main.cpp2.3.2edited 2004-10-12 $
    **
    ** Copyright (C) 2004-2005 OURSELEC AS. All rights reserved.
    ** Http://www.ourselec.com
    ** This file is part of an example program for Qt. This example
 ** program may be used, distributed and modified without limitation.
    **
**********************************************************************
*******/

#include <qapplication.h>
#include "qclient.h"
int main( int argc, char **argv )
{
     QApplication app( argc, argv );
     QClient *client = new QClient( 0 );
     app.setMainWidget( client );
     client->show();
     int result = app.exec();
     return result;
}

server.cpp

/*********************************************************************
*******
    ** $Id: qt/server.cpp 3.0.5edited Oct 12 2001 $
    **
    ** Copyright (C) 1992-2000 Trolltech AS. All rights reserved.
    **
    ** This file is part of an example program for Qt. This example
    ** program may be used, distributed and modified without limitation.
    **
**********************************************************************
*******/

#include <qsocket.h>
#include <qserversocket.h>
#include <qapplication.h>
#include <qvbox.h>
#include <qtextview.h>
#include <qlabel.h>
#include <qpushbutton.h>
#include <qtextstream.h>

#include <stdlib.h>
/*The ClientSocket class provides a socket that is connected with a client.
For every client that connects to the server, the server creates a new
instance of this class.
*/
class ClientSocket : public QSocket
{
     Q_OBJECT
public:
     ClientSocket( int sock, QObject *parent=0, const char *name=0 ) :
          QSocket( parent, name )
     {
          line = 0;
          connect( this, SIGNAL(readyRead()), SLOT(readClient()) );
          connect( this, SIGNAL(connectionClosed()),
                    SLOT(connectionClosed()) );
          setSocket( sock );
     }
     ~ClientSocket()
     {
     }
private slots:
     void readClient()
     {
           while ( canReadLine() ) {
               QTextStream os( this );
               os << line << ": " << readLine();
               line++;
           }
     }
      void connectionClosed()
    {
           delete this;
     }
private:
     int line;
};

/*
The SimpleServer class handles new connections to the server. For every
client that connects, it creates a new ClientSocket -- that instance is now
responsible for the communication with that client.
*/

class SimpleServer : public QServerSocket
{
     Q_OBJECT
public:
     SimpleServer( QObject* parent=0 ) :
         QServerSocket( 4242, 1, parent )
     {
         if ( !ok() ) {
               qWarning("Failed to bind to port 4242");
               exit(1);
         }
     }
     ~SimpleServer()
    {
    }
     void newConnection( int socket )
    {
       (void)new ClientSocket( socket, this );
        emit newConnect();
     }
signals:
     void newConnect();
};
/*
The ServerInfo class provides a small GUI for the server. It also creates the
SimpleServer and as a result the server.
*/
class ServerInfo : public QVBox
{
     Q_OBJECT
public:
     ServerInfo()
     {
          SimpleServer *server = new SimpleServer( this );
        QString itext = QString(

               "This is a small server example.\n"
             "Connect with the client now."
          );
        QLabel *lb = new QLabel( itext, this );
        lb->setAlignment( AlignHCenter );
        infoText = new QTextView( this );
        QPushButton *quit = new QPushButton( "Quit" , this );
        connect( server, SIGNAL(newConnect()),
        SLOT(newConnect()) );
        connect( quit, SIGNAL(clicked()), qApp, SLOT(quit()) );
   }
      ~ServerInfo()
     {
     }
private slots:
     void newConnect()
     {
           infoText->append( "New connection\n" );
     }
private:
     QTextView *infoText;
};

int main( int argc, char** argv )
{
     QApplication app( argc, argv );
     ServerInfo info;
     app.setMainWidget( &info );
     info.show();
     return app.exec();
}
#include "server.moc"

其中,qclient.h qclient .cpp  main.cpp   是客户端程序  server.cpp 是服务端程序

关于QT程序在qvfb 和 Xwindows 运行的一点理解

        关于QT 的环境安装见《 安装与建立QT/E桌面的运行环境》   一文。    

        要使QT程序在不同的平台运行，就得重新编译源程序， 它是一次编写，处处编译的，

    要在qvfb   上运行用下面的环境变量配置：

export QTDIR=/s3c2410_linux/QT/qt-2.3.7
export TMAKE=/s3c2410_linux/QT/tmake
export TMAKEPATH=$TMAKE/lib/qws/linux-x86-g++
export PATH=$PATH:$TMAKE/bin
export LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH

    要在Xwindows 上运行用下面的环境变量配置：

#bash set environment for QTX11
export QTDIR=$PWD/qt-x11-2.3.2
export PATH=$QTDIR/bin:$PATH
export LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH
export TMAKEPATH=$PWD/tmake/lib/linux-g++
export PATH=$TMAKEPATH:$PATH

         注 意除了在QTDIR和LD_LIBRARY_PATH的不同，还有TMAKEPATH的不同，因为一般嵌入式设备上都是在framebuffer的方式，在X11上就是用qvfb 来模拟framebuffer的。

        要用framebuffer立式运程序就要用tmake\lib\qws\下的对应的编译器，这里是linux-x86平台，所以用linux-x86-g++。惹不是framebuffer就要用\tmake\lib\下的，这里是linux-g++。

tmake\lib\qws\linux-x86-g++\tmake.conf

# $Id: tmake.conf,v 1.1 1999/11/08 03:06:27 warwick Exp $
#
# tmake configuration for linux-g++
#

TEMPLATE   = app
CONFIG    = qt warn_on release

TMAKE_CC   = gcc
TMAKE_CFLAGS   = -pipe
TMAKE_CFLAGS_WARN_ON = -Wall -W
TMAKE_CFLAGS_WARN_OFF =
TMAKE_CFLAGS_RELEASE = -O2 -fno-default-inline
TMAKE_CFLAGS_DEBUG = -g
TMAKE_CFLAGS_SHLIB = -fPIC
TMAKE_CFLAGS_YACC = -Wno-unused -Wno-parentheses
TMAKE_CFLAGS_THREAD = -D_REENTRANT

TMAKE_CXX   = g++
TMAKE_CXXFLAGS   = $$TMAKE_CFLAGS -DQWS -fno-exceptions -fno-rtti
TMAKE_CXXFLAGS_WARN_ON = $$TMAKE_CFLAGS_WARN_ON
TMAKE_CXXFLAGS_WARN_OFF = $$TMAKE_CFLAGS_WARN_OFF
TMAKE_CXXFLAGS_RELEASE = $$TMAKE_CFLAGS_RELEASE
TMAKE_CXXFLAGS_DEBUG = $$TMAKE_CFLAGS_DEBUG
TMAKE_CXXFLAGS_SHLIB = $$TMAKE_CFLAGS_SHLIB
TMAKE_CXXFLAGS_YACC = $$TMAKE_CFLAGS_YACC
TMAKE_CXXFLAGS_THREAD = -D_REENTRANT

TMAKE_INCDIR   =
TMAKE_LIBDIR   =
TMAKE_INCDIR_X11 =
TMAKE_LIBDIR_X11 =
TMAKE_INCDIR_QT   = $(QTDIR)/include
TMAKE_LIBDIR_QT   = $(QTDIR)/lib
TMAKE_INCDIR_OPENGL = /usr/X11R6/include
TMAKE_LIBDIR_OPENGL = /usr/X11R6/lib

TMAKE_LINK   = g++
TMAKE_LINK_SHLIB = g++
TMAKE_LFLAGS   =
TMAKE_LFLAGS_RELEASE =
TMAKE_LFLAGS_DEBUG =
TMAKE_LFLAGS_SHLIB = -shared
TMAKE_LFLAGS_SONAME = -Wl,-soname,
TMAKE_LFLAGS_THREAD =
TMAKE_RPATH   = -Wl,-rpath,

TMAKE_LIBS   =
TMAKE_LIBS_X11   =
TMAKE_LIBS_X11SM =
TMAKE_LIBS_QT   = -lqte
TMAKE_LIBS_QT_THREAD = -lqte-mt
TMAKE_LIBS_OPENGL =
TMAKE_LIBS_THREAD = -lpthread

TMAKE_MOC   = $(QTDIR)/bin/moc
TMAKE_UIC   = $(QTDIR)/bin/uic

TMAKE_AR   = ar cqs
TMAKE_RANLIB   =

TMAKE_TAR   = tar -cf
TMAKE_GZIP   = gzip -9f

tmake\lib\linux-g++\tmake.conf

#
# $Id: tmake.conf,v 1.15 1999/07/28 15:21:49 hanord Exp $
#
# tmake configuration for linux-g++
#

TEMPLATE   = app
CONFIG    = qt warn_on release

TMAKE_CC   = gcc
TMAKE_CFLAGS   = -pipe
TMAKE_CFLAGS_WARN_ON = -Wall -W
TMAKE_CFLAGS_WARN_OFF =
TMAKE_CFLAGS_RELEASE = -O2
TMAKE_CFLAGS_DEBUG = -g
TMAKE_CFLAGS_SHLIB = -fPIC
TMAKE_CFLAGS_YACC = -Wno-unused -Wno-parentheses

TMAKE_CXX   = g++
TMAKE_CXXFLAGS   = $$TMAKE_CFLAGS
TMAKE_CXXFLAGS_WARN_ON = $$TMAKE_CFLAGS_WARN_ON
TMAKE_CXXFLAGS_WARN_OFF = $$TMAKE_CFLAGS_WARN_OFF
TMAKE_CXXFLAGS_RELEASE = $$TMAKE_CFLAGS_RELEASE
TMAKE_CXXFLAGS_DEBUG = $$TMAKE_CFLAGS_DEBUG
TMAKE_CXXFLAGS_SHLIB = $$TMAKE_CFLAGS_SHLIB
TMAKE_CXXFLAGS_YACC = $$TMAKE_CFLAGS_YACC

TMAKE_INCDIR   =
TMAKE_LIBDIR   =
TMAKE_INCDIR_X11 = /usr/X11R6/include
TMAKE_LIBDIR_X11 = /usr/X11R6/lib
TMAKE_INCDIR_QT   = $(QTDIR)/include
TMAKE_LIBDIR_QT   = $(QTDIR)/lib
TMAKE_INCDIR_OPENGL = /usr/X11R6/include
TMAKE_LIBDIR_OPENGL = /usr/X11R6/lib

TMAKE_LINK   = g++
TMAKE_LINK_SHLIB = g++
TMAKE_LFLAGS   =
TMAKE_LFLAGS_RELEASE =
TMAKE_LFLAGS_DEBUG =
TMAKE_LFLAGS_SHLIB = -shared
TMAKE_LFLAGS_SONAME = -Wl,-soname,

TMAKE_LIBS   =
TMAKE_LIBS_X11   = -lXext -lX11 -lm
TMAKE_LIBS_X11SM = -lICE -lSM
TMAKE_LIBS_QT   = -lqt
TMAKE_LIBS_QT_OPENGL = -lqgl
TMAKE_LIBS_OPENGL = -lMesaGL -lMesaGLU -lXmu

TMAKE_MOC   = moc

TMAKE_AR   = ar cqs
TMAKE_RANLIB   =

TMAKE_TAR   = tar -cf
TMAKE_GZIP   = gzip -9f

看了一下致有这些不同

TMAKE_CFLAGS_RELEASE = -O2 -fno-default-inline    qws

TMAKE_CFLAGS_RELEASE = -O2
                      
TMAKE_CXXFLAGS   = $$TMAKE_CFLAGS -DQWS -fno-exceptions -fno-rtti    qws

TMAKE_CXXFLAGS   = $$TMAKE_CFLAGS

TMAKE_CXXFLAGS_THREAD = -D_REENTRANT           qws

TMAKE_INCDIR_X11 = /usr/X11R6/include
TMAKE_LIBDIR_X11 = /usr/X11R6/lib

TMAKE_RPATH   = -Wl,-rpath,       qws

下面看看*.pro 有什么不同。

   server/server.pro (qvfb :$TMAKE/lib/qws/linux-x86-g++)
         TEMPLATE = app
          CONFIG   = qt warn_on release
         HEADERS   =
         SOURCES   = server.cpp
         TARGET   = server

server/server.pro (Xwindows :tmake/lib/linux-g++)
         TEMPLATE = app
         CONFIG   = qt warn_on release
         HEADERS   =
          SOURCES   = server.cpp
          TARGET   = server
它们的工程文件是一样的。

下面看看Makefile有什么不同。

server/Makefile (qvfb :$TMAKE/lib/qws/linux-x86-g++)

#############################################################################
# Makefile for building server
# Generated by tmake at 14:44, 2008/07/15
#     Project: server
#    Template: app
#############################################################################

####### Compiler, tools and options

CC = gcc
CXX = g++
CFLAGS = -pipe -Wall -W -O2 -fno-default-inline -DNO_DEBUG
CXXFLAGS= -pipe -DQWS -fno-exceptions -fno-rtti -Wall -W -O2 -fno-default-inline -DNO_DEBUG
INCPATH = -I$(QTDIR)/include
LINK = g++
LFLAGS =
LIBS = -L$(QTDIR)/lib -lqte
MOC = $(QTDIR)/bin/moc

TAR = tar -cf
GZIP = gzip -9f

####### Files

HEADERS =
SOURCES = server.cpp
OBJECTS = server.o
SRCMOC = server.moc
OBJMOC =
DIST =
TARGET = server

####### Implicit rules

.SUFFIXES: .cpp .cxx .cc .C .c

.cpp.o:
$(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

.cxx.o:
$(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

.cc.o:
$(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

.C.o:
$(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

.c.o:
$(CC) -c $(CFLAGS) $(INCPATH) -o $@ $<

####### Build rules

all: $(TARGET)

$(TARGET): $(OBJECTS) $(OBJMOC)
$(LINK) $(LFLAGS) -o $(TARGET) $(OBJECTS) $(OBJMOC) $(LIBS)

moc: $(SRCMOC)

tmake: Makefile

Makefile: server.pro
tmake server.pro -o Makefile

dist:
$(TAR) server.tar server.pro $(SOURCES) $(HEADERS) $(DIST)
$(GZIP) server.tar

clean:
-rm -f $(OBJECTS) $(OBJMOC) $(SRCMOC) $(TARGET)
-rm -f *~ core

####### Compile

server.o: server.cpp \
   server.moc

server.moc: server.cpp
$(MOC) server.cpp -o server.moc

server/Makefiel (Xwindows :tmake/lib/linux-g++)

#############################################################################
# Makefile for building server
# Generated by tmake at 10:47, 2008/07/15
#     Project: server
#    Template: app
#############################################################################

####### Compiler, tools and options

CC = gcc
CXX = g++
CFLAGS = -pipe -Wall -W -O2 -DNO_DEBUG
CXXFLAGS= -pipe -Wall -W -O2 -DNO_DEBUG
INCPATH = -I$(QTDIR)/include
LINK = g++
LFLAGS =
LIBS = -L$(QTDIR)/lib -lqt -L/usr/X11R6/lib -lXext -lX11 -lm
MOC = moc

TAR = tar -cf
GZIP = gzip -9f

####### Files

HEADERS =
SOURCES = server.cpp
OBJECTS = server.o
SRCMOC = server.moc
OBJMOC =
DIST =
TARGET = server

####### Implicit rules

.SUFFIXES: .cpp .cxx .cc .C .c

.cpp.o:
$(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

.cxx.o:
$(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

.cc.o:
$(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

.C.o:
$(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $<

.c.o:
$(CC) -c $(CFLAGS) $(INCPATH) -o $@ $<

####### Build rules

all: $(TARGET)

$(TARGET): $(OBJECTS) $(OBJMOC)
$(LINK) $(LFLAGS) -o $(TARGET) $(OBJECTS) $(OBJMOC) $(LIBS)

moc: $(SRCMOC)

tmake: Makefile

Makefile: server.pro
tmake server.pro -o Makefile

dist:
$(TAR) server.tar server.pro $(SOURCES) $(HEADERS) $(DIST)
$(GZIP) server.tar

clean:
-rm -f $(OBJECTS) $(OBJMOC) $(SRCMOC) $(TARGET)
-rm -f *~ core

####### Compile

server.o: server.cpp \
   server.moc

server.moc: server.cpp
$(MOC) server.cpp -o server.moc

下面几项Makefile有所不同。

server/Makefile (qvfb :$TMAKE/lib/qws/linux-x86-g++)

CFLAGS = -pipe -Wall -W -O2 -fno-default-inline -DNO_DEBUG
CXXFLAGS= -pipe -DQWS -fno-exceptions -fno-rtti -Wall -W -O2 -fno-default-inline -DNO_DEBUG

LIBS = -L$(QTDIR)/lib -lqte
MOC = $(QTDIR)/bin/moc

server/Makefiel (Xwindows :tmake/lib/linux-g++)

CFLAGS = -pipe -Wall -W -O2 -DNO_DEBUG
CXXFLAGS= -pipe -Wall -W -O2 -DNO_DEBUG

LIBS = -L$(QTDIR)/lib -lqt -L/usr/X11R6/lib -lXext -lX11 -lm
MOC = moc

红色比较主要。