A Simple Life

new toy

2008-06-03T00:52:00.001+01:00

Gumstix LCD pack (verdex XL6P + consoleLCD16-vx + netmicroSD + Samsung LCD).

A second hand is moving at every 0.5 second.

How to build mail-notificaton to suport SSL in Ubuntu.

2008-01-20T15:14:00.001Z

I'd had a problem with mail-notification in Ubuntu 7.10 for an ages. The problem was mail-notification didn't support SSL because it was compiled with --disable-ssl (it's something about a licence policy of Debian.). I need to use SSL for one of my email server and was lazy to find a replacement program. After ignoring the problem for a while, I finally found out how to compile mail-notification by using apt-src.

$ sudo aptitude install apt-src
$ mkdir build
$ cd build
$ sudo apt-src install mail-notification

It will create mail-notification_4.1.dfsg.1 directory, then we have to edit a rules file for Debian to enable SSL.

$ sudo gvim mail-notification_4.1.dfsg.1/debian/rules

Erase --disable-ssl and save the file. It's ready to build.

$ sudo apt-src build mail-notification

We finally get mail-notification_4.1.dfsg.1-2ubuntu1_i386.deb and mail-notification-evolution_4.1.dfsg.1-2ubuntu1_i386.deb.

$ sudo aptitude remove mail-notification
$ sudo dpkg -i mail-notification_4.1.dfsg.1-2ubuntu1_i386.deb

PS. you might need to install libssl-dev package by "sudo aptitude install libssl-dev" before you can compile mail-notification.

Upgrade from Ubuntu 7.04 to 7.10 in ThinkPad R50e.

2007-10-18T15:07:00.000+01:00

Upgrade from Ubuntu 7.04 to 7.10 in ThinkPad R50e.

I upgraded my computer from 7.04 to 7.10 via update-manager. It works fine with an old kernel but cannot boot from a new kernel which is 2.6.22 version. When I tried to boot from the new kernel, it paused for a while and then gave me a (initramfs) terminal with a message that I implied it could not detect a hard drive. I found out it happened because the initramfs script didn't load ide_generic module to the kernel. I tried to use yaird instead of initramfs-tools, but it doesn't work. I have no idea what's going on.

I solved this problem by compiling a kernel by myself. It's not a best choice to do but I like to have a custom kernel that fits to my computer. Instead of compiling ide_generic and piix as modules, I compiled both of them into the 2.6.22 kernel. I'm happy with the result and it works very well.

I recalled the problem has happened since I did upgrade from 6.10 to 7.04. Fortunately, my computer's running by my custom kernel and it didn't bother me to find out how to use the provided kernel. Just today, 25 Nov, something came up in my mind. When I got a terminal console after waiting for a while as I mention above, I inserted ide_generic module and then the hard drive had been detected. It meant that either 7.10 or kernel 2.6.22 doesn't need to load piix module which I normally used for my notebook to detect the hard drive. I's surprised!!! Moreover, there isn't piix module in the provided kernel. It's been removed for a while I guessed but I didn't notice. It might has happened since 7.04.

To make my computer run by the provided kernel, I edited my own /etc/initramfs-tools/modules from piix to ide_generic and reconfigured the kernel. Everything works very well. I would haven't had the problem if I installed Ubuntu 7.10 instead of upgrading.

My Old Documents

2007-08-19T19:20:00.000+01:00

วันนี้บังเอิญไปค้นเอกสารเก่าๆ แล้วเจอเอกสารย่อๆ เกี่ยวกับ RTOS และ Computer Control System พร้อมกับการแนะนำอย่างสั้นๆ สำหรับการติดตั้ง RTAI รุ่นโบราณ และ การติดตั้งโปรแกรม CNC ที่ชื่อ EMC เข้าไปหาในเว็ปของหน่วยงาน ไม่เจอ ไม่รู้ไปอยู่ไหน เลยเอามาไว้ที่นี่ด้วย จะได้กระจายๆ แบ่งปั้นความรู้กันไปครับ ดีกว่าเก็บไว้อ่านคนเดียว ก็หวังว่าคนอื่นจะได้เอาไปใช้ประโยชน์บ้างแม้จะเก่าอีกเช่นเคย

ปล. แนะนำให้เข้าไปดูที่ www.rtai.org สำหรับข้อมูลเพิ่มเติมของ RTAI และ www.linuxcnc.org สำหรับโปรแกรม EMC เดี๋ยวนี้เค้าทำไว้ดีมาก ติดตั้งง่ายกว่าเดิมเยอะ และก็สวยด้วย โปรแกรมก็ได้รับการปรับปรุงขึ้นกว่าเก่ามาก สำหรับ EMC ถ้าสนใจเพิ่มเติมลองติดต่อไปที่หน่วยงานในเอกสาร มีพนักงานที่ติดตามเรื่องนี้อยู่พร้อมที่จะให้ความช่วยเหลือเต็มที่ครับ ได้ยินว่าพิมพ์หนังสือเกี่ยวกับ EMC ออกว่างจำหน่ายด้วย แต่ผมยังไม่เคยเห็นหนังสือเลย :-)

วันนี้(23 มกราคม 2551)ไปเจอมาอีกตัวครับ เป็น pdf ของ RTLinux ทั้งห้าบทในบล๊อกนี้ เผื่อใครยังคิดว่ามันมีประโยชน์อยู่บ้าง อยากนำไปพิมพ์มาอ่าน แต่ไม่รับประกันว่าเหมือนกันกับในบล๊อกนะครับ อาจแตกต่างกันนิดหน่อย คำผิด หรือมีเพิ่มเติม

Installing Puppy Linux to USB Drive without writing any CD.

2007-07-17T03:33:00.000+01:00

Installing Puppy Linux to USB Drive without writing any CD.

I've tested the method with Ubuntu 7.04 and qemu. After getting Puppy Linux,
- Plug a usb drive in.
- Run lsusb to get ID xxxx:yyyy of the usb drive.
- Run the following command as root
sudo qemu -cdrom puppy-2.16-seamonkey-fulldrivers.iso -boot d -usbdevice host:xxxx:yyyy
- Install Puppy Linux to the usb drive via "Puppy Universal Installer" inside Setup menu.
- Following the instruction and restart to boot Puppy Linux with the usb drive.

I'm quite impressed by Puppy Linux. It's fast, easy to config X server and network system.

PS. Don't forget to set your computer to boot from USB Drive first.

ภาษาไทยสำหรับ Latex และ Ubuntu 7.04

2007-07-07T19:49:00.000+01:00

ภาษาไทยสำหรับ Latex และ Ubuntu 7.04

พยายามใช้ภาษาไทยใน Latex แต่ใช้ไม่ได้ package thailatex ที่ใช้เป็นรุ่น 0.4.0-1 บน Ubuntu ใช้ไม่ได้ในที่นี่คือเมื่อแปลงเป็น .dvi แล้วอักษรไทยกลายเป็น ธธธธ เสียส่วนมากสังเกตุว่าเป็นเพราะผมแก้ไขแฟ้ม latex ด้วย gvim หรือ gedit แล้วก็ locale ของระบบเป็น UTF-8 พอทำการบรรทึกมันจะทำการบันทึกโดยการเข้ารหัสเป็น UTF-8 (ยังไม่ได้ลองแก้เป็น TIS-620 ไม่รู้ว่าถ้าแก้เป็น TIS-620 แล้วเวลาแก้ไขแฟ้มเอกสารมันจะบันทึกเป็น TIS-620 หรือเปล่าน่ะครับ :-) ขี้เกี่ยจทำ ยังเป็นประเภทจะใช้ค่อยหาทางแก้อยู่) เมื่อได้แฟ้มมาผมก็สั่ง latex แล้วก็ได้ dvi มาแต่เป็น ธธธธธ ซะอย่างนั้น

วิธีแก้ไขง่ายๆ พอช่วยถูไถปัญหาไปได้ ผมแก้โดยการเปลี่ยนรหัสแฟ้มจาก UTF-8 ไปเป็น TIS-620 ปัญหาก็ไม่เกิดครับ .dvi ที่ได้ออกมาสวยงามอย่างที่ตั้งใจ แต่ว่าถ้าเอาแฟ้มต้นฉบับไปเปิดด้วย gvim หรือ gedti ทีนี้อ่านไม่ออกนะครับ เป็นภาษาไรไม่รู้เลย ดังนั้นขั้นตอนแก้ไขก็ใช้รหัสเป็น UTF-8 แหละครับเพื่อที่จะได้อ่านออก แต่ตอนจะแปลงเป็น dvi ต้องทำการแปลงรหัสเป็น TIS-620 ก่อนตามนี้ครับ สมมติว่าแฟ้มต้นฉบับชื่อ thai.tex

iconv -f UTF-8 -t TIS-620 thai.tex > thai_tis.tex <--- แปลงรหัสของแฟ้มครับ
swath -f latex < thai_tis.tex > thai_tis.ttex <--- ตัดคำภาษาไทยด้วย swath
latex thai_tis.ttex <--- แปลงไปเป็น dvi ครับ

แต่ ถ้าจะให้ดี ไม่ควรมีการแปลงไปแปลงมาระหว่างรหัสแฟ้มเอกสาร ... คงต้องให้ท่านอื่นช่วยหาทางแก้แล้วครับ ว่าจะทำอย่างไรได้บ้าง ผมไม่อยากคิดต่อ :-) เพราะผมใช้ lyx (www.lyx.org ) ก็สุขสบายดี โดยเฉพาะรุ่น 1.5 ตอนนี้ถึงจะเป็น RC อยู่ เพียงแค่ไปกำหนดค่าใน Document->Settings->Language->Thai แค่นี้มันก็จัดการแปลงรหัสแฟ้มให้อัตโนมัติหากต้องการ .dvi .pdf หรือ .ps สำหรับ Ubuntu สามารถ Donwload lyx รุ่น 1.5 RC2 ได้ที่ http://wiki.lyx.org/LyX/Download

ระบบปฏิบัติการเวลาจริง

2007-04-20T12:15:00.000+01:00

linux.thai.net/plone จะหยุดให้บริการแล้ว เลยเอาเอกสารเกี่ยวกับ RTLinux ที่เคยเขียนไว้เมื่อนานมาแล้วมาแปะไว้ที่นี่ก็แล้วกันครับ เนื้อหาอาจจะเก่าไปหน่อยแต่ก็หวังว่าจะยังคงมีประโยชน์กับใครบางคนบ้าง มีห้าตอนด้วยกัน ตอนต่อๆ ไปยังไม่ได้เขียนเลย ถ้าเขียนคงเปลี่ยนไปเป็น RTAI แทนที่ RTLinux ( แต่ไม่รู้ว่าจะได้เขียนหรือเปล่า ;-) )

"โฮมเพจนี้จัดทำขึ้นเพื่อบอกเล่าเรื่องราวที่ผมได้ทดลองเล่นเกี่ยวกับการนำ Linux ไปใช้ในงานที่ผมเเกี่ยวข้อง เนื้อหาโดยหลักๆ แล้วนำมาจากต้นฉบับของ NECTEC เพื่อจะเป็นอีกช่องทางสำหรับผู้สนใจที่ไม่สามารถเข้าไปอ่านได้จากเว็ปของ NECTEC

ตัวผมเองไม่ได้จบทางด้านคอมพิวเตอร์มา แต่จบมาทางด้านระบบควบคุม (Control System) ดังนั้นในบทความที่นำมาลงอาจจะไม่มีกลวิธีอะไรน่าสนใจนักสำหรับนักพัฒนาโปรแกรม แต่ก็หวังว่าจะเป็นจุดเริ่มต้นที่ดีได้สำหรับผู้ที่มีความสนใจ หรือต้องการใช้งาน Linux ในแนวทางที่ผมได้ทำอยู่

หวังว่าทุกท่านคงจะสนุกกับมันครับ

บทที่ห้ามาแล้วน่ะครับสำหรับ RTLinux ... 26/01/2004"

ปล. มีเป็น pdf ไฟล์ในบล๊อก My Old Documents นะครับ

2007-04-20T12:10:00.000+01:00

RTLinux : Linux สำหรับงานเวลาจริง

ตอนที่ 5. การอ่านและเขียนข้อมูลผ่าน I/O Port

พิเชษฐ์ บุญหนุน

1. บทนำ

การนำระบบปฏิบัติการ RTLinux ไปใช้ให้เกิดประโยชน์จะเห็นได้ชัดเจนมากเมื่อนำไปใช้ในการควบคุมหรือ ติดต่อกับอุปกรณ์ภายนอก โดยเฉพาะงานที่ต้องการการทำงานในเวลาจริงจากบทที่ผ่านๆ มาเรายังไม่ได้เห็นถึงวิธีการติดต่อกับอุปกรณ์ภายนอกเลยผู้อ่านหลายๆ ท่านอาจจะเบื่อไปบ้างแล้วก็ได้ แต่ในบทนี้ผู้เขียนคิดว่าคงทำให้สนุกขึ้นมาบ้างเราจะมาทำการติดต่อกับอุปกรณ์ภายนอกกันครับ

ในการเขียนโปรแกรมคอมพิวเตอร์เพื่อควบคุมการทำงานของอุปกรณ์ภายนอกจำเป็นจะต้องเขียนโปรแกรมติดต่อผ่านระบบI/O Port ของคอมพิวเตอร์ อาจจะเป็นการติดต่อผ่าน Parallel Port, Serial Port, ISA Bus หรือ PCI Bus เป็นต้น เพื่อความสะดวกในการทดลอง Parallel Port น่าจะเป็นอุปกรณ์ที่สะดวกที่สุดเพราะคอมพิวเตอร์ในปัจจุบันแทบทุกเครื่องต้องมีดังนั้นในบทนี้เราจะมาเขียนโปรแกรม RTLinux สำหรับอ่านและเขียนข้อมูลผ่านParallel Port กัน

การเขียนโปรแกรมติดต่อกับอุปกรณ์ภายนอกผ่านทาง I/O Port สำหรับ Linux แล้วนั้นสามารถเขียนได้ทั้งใน Kernel Space และ User Space แต่ในบทความตอนนี้เราจะได้ทดลองเฉพาะที่เขียนในKernel Space เพราะเราต้องการให้มันทำงานในเวลาจริงสำหรับผู้อ่านที่สนใจเกี่ยวกับการเขียนโปรแกรมบนUser Space ใน Linux นั้นสามารถหาข้อมูลเพิ่มเติมได้จาก [1]

วงจรที่ใช้ในการทดสอบผู้เขียนได้ทดสอบแล้วว่าใช้ได้แต่ไม่ขอรับประกันความเสียหายที่อาจเกิดขึ้นกับเครื่องคอมพิวเตอร์ของผู้อ่านฉะนั้นตรวจเช็คดีๆ ก่อนทดสอบด้วยนะครับ

2. การทำงานของ Printer Port และ วงจรทดสอบ

Parallel Port เป็นอุปกรณ์มาตรฐานที่ใช้ในการติดต่อกับเครื่องพิมพ์ของคอมพิวเตอร์มีความสามารถเป็นได้ทั้ง Input Port หรือ Output Port สำหรับรายละเอียดการทำงานสามารถอ่านได้จาก[2] ซึ่งพอจะสรุปขาต่าง ๆ ของ Paralle Port ที่เราจะนำไปทดสอบได้ดังตารางที่ 1

Table 1: ขาและลักษณะการใช้งานของ Parallel Port

Pin No (D-Type 25)	SPP Signal	Direction In/Out	Register	Hardware Inverted
1	nStrobe	In/Out	Control	Yes
2	Data 0	Out	Data
3	Data 1	Out	Data
4	Data 2	Out	Data
5	Data 3	Out	Data
6	Data 4	Out	Data
7	Data 5	Out	Data
8	Data 6	Out	Data
9	Data 7	Out	Data
10	nAck	In	Status
11	Busy	In	Status	Yes
12	Paper-Out	In	Status
13	Select	In	Status
14	nAuto-LineFeed	In/Out	Control	Yes
15	nError/nFault	In	Status
16	nInitialize	In/Out	Control
17	nSelect-Printer	In/Out	Control	Yes
18-25	Ground	Ground

Parallel Port แต่ละ Port ในโหมดการทำงานแบบ SPP จะมี Register อยู่ทั้งหมด3 ชุดใช้ในการรับส่งข้อมูล ประกอบด้วย Control Port, Data Port และ Status Port แต่ละ Port ทำหน้าที่ดังตารางต่อไปนี้

Table 2: ค่า Register ต่าง ๆ ของ Data Port

Offset

Name

Read/Write

Bit No.

Properties

Base + 0

Data Port

Write/Read*

Bit 7

Bit 6

Bit 5

Bit 4

Bit 3

Bit 2

Bit 1

Bit 0

Data 7 (Pin 9)

Data 6 (Pin 8)

Data 5 (Pin 7)

Data 4 (Pin 6)

Data 3 (Pin 5)

Data 2 (Pin 4)

Data 1 (Pin 3)

Data 0 (Pin 2)

*สำหรับ Data Port นี้โดยปรกติจะอยู่ในสถานะสำหรับเขียนแต่หากมีการกำหนดค่าในControl Port บิตที่ 5 Data Port จะสามารถใช้ในการอ่านได้ด้วย

Table 3: ค่า Register ต่าง ๆ ของ Status Port

Offset

Name

Read/Write

Bit No.

Properties

Base + 1

Status Port

Read Only

Bit 7

Bit 6

Bit 5

Bit 4

Bit 3

Bit 2

Bit 1

Bit 0

Busy

Ack

Paper Out

Select In

Error

IRQ(Not)

Reserved

Table 4: ค่า Register ต่าง ๆ ของ Control Port

Offset

Name

Read/Write

Bit No.

Properties

Base + 2

Control Port

Read/Write

Bit 7

Bit 6

Bit 5

Bit 4

Bit 3

Bit 2

Bit 1

Bit 0

Unused

Enable Bi-Directional Port

Enable IRQ Via Ack Line

Select Printer

Initialize Printer (Reset)

Auto Linefeed

Strobe

จากลักษณะ Parallel Port ได้ออกแบบวงจรสำหรับทดสอบดังรูปที่ 1 สำหรับทดสอบ Data Port ในโหมด Output โดยต่อเข้ากับตัวต้านทานและ LEDs และ ได้ต่อ ขา 10 และ ขา 11 กับสวิทซ์สำหรับทดสอบการรับค่า Input และทดสอบการทำงานแบบ Interrupt

**Figure 1:** วงจรทดสอบ Parallel Port

การอ่านหรือเขียนค่า Register ของ Parallel Port จะอ่านโดยใช้คำสั่งinb( io_port ) สำหรับอ่านค่าจาก Register และ outb( char var, io_port ) สำหรับกำหนดค่า var ให้ Register โดยที่ค่าio_port จะเป็นค่าตำแหน่งของที่อยู่ (Port Address) ที่ใช้อ้างถึงค่าRegister ต่าง ๆ โดยปรกติสำหรับ Parallel Port แล้วจะกำหนดค่า Port Address ตรงกับ Register ดังตารางที่ 5 ส่วนตำแหน่ง IRQ นั้นปรกติจะมีค่าเป็น 5 หรือ 7 แต่อาจไม่ตรงกันในเครื่องคอมพิวเตอร์แต่ละเครื่องต้องเข้าไปตรวจดูที่ BIOS อีกครั้งหนึ่ง

Table 5: Parallel Port Address

Address	Notes:
378h - 37Fh	Usual Address For LPT 1
278h - 27Fh	Usual Address For LPT 2

ค่าแรกในตารางจะเป็นค่า Base Port Address ของ Parallel Port นั้นๆจากตารางที่ 2, 3 และ 4 ใช่ช่อง Offset จะบอกค่า Port Address ต่าง ๆ ของ Register เช่น สำหรับ LPT1 มีค่า Base Port Address เท่ากับ 378h แสดงว่าสามารถติดต่อ Data Port Register ได้ที่ Port Address 378h, Status Port Register ได้ที่ Port Address 379h และ Control Port Register ได้ที่ Port Address 37Ah

3. โมดูลทดสอบ

การทำงานของโมดูลที่เขียนขึ้นจะแบ่งการทำงานออกเป็นสามแบบคือ กำหนดให้Data Port เป็น Output ขับ LEDs, ใช้ขาที่ 11 ของ Parallel Port หรือขา Busy ของ Status Port เป็นขา Input เพื่อรับสถานะของสวิทซ์ SW1 และใช้ขาที่10 ของ Parallel Port หรือ ขา Ack ของ Status Port เป็นขา Input รับสัญญาณInterrupt จากสวิทซ์ SW2 มาดูต้นหรัสของโปรแกรมกันเลยครับ จะขอตัดเป็นท่อนๆ อธิบายเป็นตอนๆ ไป

001. #ifndef __KERNEL__
002. #define __KERNEL__
003. #endif
004. #ifndef __MODULE__
005. #define __MODULE__
006. #endif
007. #include <rtl.h>
008. #include <time.h>
009. #include <pthread.h>
010. #include <linux/kernel.h>
011. #include <linux/version.h>
012. #include <linux/sched.h>
013. #include <linux/errno.h>
014. #include <linux/module.h>
015. #include <linux/ioport.h>
016. #include <asm/io.h>

ในบรรทัดที่ 15 และ 16 จะเพิ่มเข้ามาเพื่อให้โมดูลสามารถเรียกใช้ฟังก์ชันinb( io_port ) และ outb( char var, io_port ) ได้

017. #define DATA_PORT 0x378
018. #define STATUS_PORT 0x379
019. #define CONTROL_PORT 0x37a
020. #define IRQ_NO 7
021. MODULE_LICENSE("GPL v2");
022. MODULE_AUTHOR("Pished Bunnun");
023. MODULE_DESCRIPTION("using RTLinux with I/O Port");
024. #define D0 1
025. #define D1 2
026. #define D2 4
027. #define D3 8
028. #define D4 16
029. #define D5 32
030. #define D6 64
031. #define D7 128

กำหนดค่า DATA_PORT, STATUS_PORT และ CONTROL_PORT เพื่ออ้างอิงถึงPort Address ของ Data Register, Status Register และ Control Register ตามลำดับ และกำหนดค่า IRQ_NO เพื่ออ้างอิงถึงค่าของ Interrupt Number โดยค่าที่กำหนดเหล่านี้สามารถดูได้จาก BIOS ของคอมพิวเตอร์ว่ากำหนด Base Address ไว้ที่ใด และ กำหนดค่า Interrupt Number ไว้ที่ใด ส่วนค่า D0 ถึง D7 เป็นค่าที่กำหนดขึ้นเพื่อใช้อ้างอิงถึงตำแหน่งบิตต่าง ๆ ของRegister

032. pthread_t led_thread;
033. pthread_t switch_thread;
034. pthread_t irq_thread;
035. char command;
036. char control_port_register;

โมดูลนี้จะมีการทำงานอยู่ด้วยกัน 3 thread คือ led_thread จะเป็น thread ที่จัดการเกี่ยวกับการทำงานของ LEDs, switch_thread จะเป็น thread ที่จัดการเกี่ยวกับการทำงานของSW1 และ irq_thread จะเป็น thread ที่จัดการเกี่ยวกับ Interrupt โดยรับInterrupt จาก SW2

ตัวแปร command เป็นตัวแปร global ใช้สำหรับติดต่อระหว่างswitch_thread และ led_thread โดยที่ switch_thread จะเปลี่ยนค่า command เพื่อสั่งให้led_thread หยุดทำงาน จะกล่าวถึงอีกครั้งเมื่อมีการเรียกใช้ ส่วนตัวแปรcontrol_port_register ใช้สำหรับเก็บค่า Control Register ของ Parallel Port เดิมไว้ก่อนที่จะเปลี่ยนค่า เมื่อเลิกใช้งาน Parallel Port จะได้คืนค่าเดิมให้กับControl Register ได้

037. unsigned int irq_handler( unsigned int irq, struct pt_regs *regs ){
038. printk("Interrupt Handlern'');
039. rtl_hard_enable_irq( IRQ_NO );
040. return 0;
041. }

ฟังก์ชัน irq_handler( ) จะทำงานเมื่อเกิดInterrupt ขึ้นโดยการพิมพ์คำว่า``Interrupt Handler'' ไว้ใน Kernel Message (ใช้คำสั่ง dmesg เรียกดูครับ) ในบรรทัดที่ 39 มีการเรียกฟังก์ชัน rtl_hard_enable_irq( IRQ_NO ) ซึ่งจำเป็น หากไม่มีบรรทัดนี้แล้ว Interrupt จะไม่สามารถเกิดขึ้นได้อีกผู้อ่านลองคอมเมนต์บรรทัดนี้ออก แล้วสังเกตลักษณะการทำงานเทียบกันดูครับ

042. void *switch_thread_code( void * temp ){
043. char input, input_latch = 0, toggle = 0;
044. while( 1 ){
045. input = inb( STATUS_PORT );
046. if( (input & D7) == D7 ){
047. if( input_latch == 0 ){
048. input_latch = 1;
049. toggle = (toggle+1)%2;
050. if( toggle == 1 && command == 0 )
051. pthread_wakeup_np( led_thread );
052. else
053. command = 1;
054. }
055. }
056. else
057. input_latch = 0;
058. pthread_wait_np();
059. }
060. }

ฟังก์ชัน switch_thread_code( ) เป็นฟังก์ชันการทำงานของ switch_thread ตัวแปร input, และ input_latch ใช้สำหรับตรวจสถานะการกด SW1 ส่วน toggle ใช้สำหรับเก็บสถานะการกดปุ่มแบบสลับไปมา

ในบรรทัดที่ 45 และ 46 ใช้อ่านค่าจาก STATUS PORT และทำการเปรียบเทียบบิตที่7 ว่ามีการเปลี่ยนแปลงหรือไม่ หรือมีการกด SW1 หรือไม่ถ้ามีการกดก็จะเข้าไปตรวจสอบในบรรทัดที่47 ว่าเป็นการกดค้างไว้ หรือไม่ ถ้ากดค้างไว้ input_latch จะเท่ากับ1 และจะข้ามการทำงานส่วนนี้ไป แต่ถ้าเป็นการกดครั้งใหม่ค่า input_latch จะเท่ากับ 0 โมดูลจะเข้าไปทำงานในบรรทัดที่ 48 โดยกำหนดค่า input_latch เท่ากับ 1 เพื่อจะไม่ต้องเข้ามาทำงานอีกครั้งหากในรอบการทำงานต่อไป SW1 ยังไม่มีการปล่อย

บรรทัดที่ 49 ถึง 53 จะทำการตรวจสอบว่าเป็นการสั่งงานแบบไหนให้เรียกคืนการทำงาน(บรรทัดที่51) หรือ ให้หยูดการทำงาน(บรรทัดที่ 53) ของ led_thread สังเกตว่าเราจะใช้ตัวแปรโกลบอลcommand ทำหน้าที่หยุดการทำงานของ led_thread แล้วจะกล่าวถึงต่อไป

บรรทัดที่ 58 ก็จะเป็นการหยุดการทำงานของ thread นี้จนกว่าจะถึงคาบเวลาถัดไปจึงจะเริ่มทำงานใหม่เหมือนที่ผ่านๆ มา

061. void *led_thread_code( void * temp ){
062. char output;
063. output = 0xFF;
064. while( 1 ){
065. outb(output, DATA_PORT);
066. output = ~output;
067. if( command == 1 ){
068. command = 0;
069. pthread_suspend_np( pthread_self() );
070. }
071. pthread_wait_np();
072. }
073. }

ฟังก์ชัน led_thread_code( ) ทำหน้าที่สั่งให้ LEDs ทุกดวงกระพริบพร้อมๆกัน การสั่งให้ LEDs ดับหรือสว่างใช้ฟังก์ชัน outb( output, DATA_PORT ) ในบรรทัดที่ 65 ฟังก์ชันนี้ต่างจากคำสั่งใน DOS ตรงที่มันสลับตำแหน่งกันระหว่างค่าPORT ADDRESS และ DATA ที่ต้องการส่ง ส่วนบรรทัดที่ 66 เป็นการกลับค่าไปมาระหว่าง0x00 และ 0xFF

บรรทัด 67 ถึง 70 เป็นการรับคำสั่งจาก switch_thread ผ่านตัวแปรcommand เพื่อบอกให้หยุด การทำงานของ thread นี้หรือไม่วิธีนี้เป็นวิธีหนึ่งที่ใช้ในการหยุดการทำงานของthread โดย thread อื่นๆ เพื่อรับประกันว่าการทำงานของ thread ในส่วนที่สำคัญๆได้ทำงานเสร็จแล้วจริงๆ จึงหยุดการทำงานของ thread

074. int init_module(void){
075. pthread_attr_t attr;
076. struct sched_param sched_param;
077. rtl_irqstate_t irq_state;
078. command = 1;
079. if( check_region( DATA_PORT, 3 ) < 0){
080. printk(" I/O PORT region 0x378 is taken by other Devicen'');
081. return -EIO;
082. }
083. printk(" I/O PORT region 0x378 is OK.n'');
084. request_region( DATA_PORT, 3, "rt_parport" );
085. outb( 0xFF, DATA_PORT );
086. pthread_attr_init( &attr );
087. sched_param.sched_priority = 10;
088. pthread_attr_setschedparam( &attr, &sched_param );
089. pthread_create( &led_thread, &attr, led_thread_code, 0 );
090. pthread_attr_init( &attr );
091. sched_param.sched_priority = 1;
092. pthread_attr_setschedparam( &attr, &sched_param );
093. pthread_create( &switch_thread, &attr, switch_thread_code, 0 );
094. pthread_make_periodic_np( led_thread, gethrtime()+10000000, 1000000000);
095. pthread_make_periodic_np( switch_thread,gethrtime()+10000000, 10000000);
096. // Enable Interrupt
097. control_port_register = inb( CONTROL_PORT );
098. rtl_no_interrupts( irq_state );
099. rtl_request_irq( IRQ_NO, irq_handler );
100. rtl_hard_enable_irq( IRQ_NO );
101. rtl_restore_interrupts( irq_state );
102. // Enable IRQ via ACK Line
103. outb( control_port_register | D4, CONTROL_PORT );
104. return 0;
105. }

ฟังก์ชัน init_module(void) คงยังจำกันได้นะครับว่ามันทำงานเมื่อไหร่บรรทัดที่ 79 ถึง 84 จะทำการจอง PORT ADDRESS เพื่อใช้งานมีประโยชน์เพื่อใช้ในการตรวจสอบว่ามีโมดูลอื่นเรียกใช้PORT ADDRESS นี้อยู่หรือไม่ จะได้ไม่ไปใช้ทับซ้อนกันและหากไม่มีคนเรียกใช้เราก็จะได้จองไว้ และบอกให้โมดูลอื่นที่จะทำงานรู้ว่าเราใช้อยู่ให้ไปเรียกใช้PORT ADDRESS อื่นแทน

ค่าตัวแปร control_port_register ในบรรทัดที่ 97 ถูกอ่านเก็บไว้เพื่อคืนค่าเดิมเมื่อเราออกจากการทำงานของโมดูลนี้บรรทัดที่ 98 ถึง 101 เป็นการกำหนดให้ Interrupt ที่เกิดขึ้นที่ IRQ_NO ไปเรียกการทำงานที่ฟังก์ชัน irq_handler() ส่วนบรรทัดที่ 103 เป็นการสั่งให้Parallel Port รับ Interrupt ผ่านทาง SW2

105. int cleanup_module( void ){
106. rtl_free_irq( IRQ_NO );
107. outb( control_port_register, CONTROL_PORT );
108. outb( 0, DATA_PORT );
109. printk("Release I/O Port region 0x378n'');
110. pthread_delete_np( led_thread );
111. pthread_delete_np( switch_thread );
112. return 0;
113. }

ฟังก์ชัน cleanup_module(void) ก็คงยังคุ้นเคยกันดีนะครับ ในบรรทัดที่106 เป็นการคืนการจอง Interrupt ให้โมดูลอื่นเอาไปใช้ได้ บรรทัดที่ 107 เป็นการคืนค่าเก่าของ Control Register ของ Parallel Port ก่อนที่โมดูลของเราจะเริ่มทำงาน

4. สรุป

ในตอนนี้เราก็ได้เล่นสนุกเกี่ยวกับการเขียนโมดูลให้ทำงานติดต่อกับอุปกรณ์ภายนอกได้บ้างพอสมควรทั้งการติดต่อกับ Interrupt การอ่านเขียนสัญญาณ I/O ผ่านทาง Parallel Port คงเป็นที่ถูกอกถูกใจกันพอสมควรนะครับ แต่ก็อย่าหยุดเพียงเท่านี้ลองไปนั่งคิดเล่นๆ ดูครับ จะทำอย่างไรให้ LEDs มันกระพริบหลายๆ รูปแบบ, ทำอย่างไรให้ LEDs หยุดหรือเริ่มกระพริบอีกครั้งจากการสั่งโปรแกรมในUser Space นอกจากการกดสวิทซ์ SW1, ถ้านำ Parallel Port มาทำเป็น Input ต่ออุปกรณ์เพิ่มเป็น A/D จะทำได้หรือเปล่า ถ้าทำได้แล้วจะถ่ายโอนข้อมูลที่ได้เก็บลงเป็นแฟ้มข้อมูลได้อย่างไรหลังจากที่คิดเล่นๆ แล้ว ลองทำจริงๆ จังๆ ดูครับ คงได้อะไรไว้ทดลองเล่นหรือใช้งานกันจริงๆ จังๆ ซักอย่าง

ไว้พบกันตอนต่อไปครับ คงเป็นการเก็บรายละเอียดที่เหลือ เช่น การ Share Memory ระหว่างโมดูลที่ทำงานใน Kernel Space กับโปรแกรมที่ทำงานใน User Space ซึ่งเป็นอีกช่องทางสำหรับแลกเปลี่ยนข้อมูลระหว่างกันและกันนอกจากFIFO ที่เคยพูดมาแล้ว, การ Syncronize กันระหว่าง Thread เป็นต้นแล้วพบกันครับสวัสดี...

5. แหล่งข้อมูลเพิ่มเติม

About this document ...

This document was generated using the LaTeX2HTML translator Version 2002-2-1 (1.70)

The translation was initiated by root on 2004-01-26

Pished Bunnun 2004-01-26

2007-04-20T12:08:00.000+01:00

RTLinux : Linux สำหรับงานเวลาจริง

ตอนที่ 4. การแลกเปลี่ยนข้อมูล

พิเชษฐ์ บุญหนุน

1 บทนำ

พบกันอีกครั้งครับกับบทความในชุดนี้ ตอนนี้ก็เป็นตอนที่ 4 แล้ว ผมมีความเชื่อว่า สำหรับผู้อ่านหลายๆ ท่านหากมีเวลาพอที่จะศึกษาค้นคว้าด้วยตนเองต่อจากที่ได้แนวทางแล้วนั้น บทความในตอนนี้และตอนต่อๆ ไป อาจไม่จำเป็นต้องอ่านแล้วก็ได้ ไม่แน่ว่าสิ่งที่จะได้อ่านนี้อาจเป็นสิ่งที่ท่านรู้อยู่แล้วและอาจจะรู้มากกว่าเสียด้วย แต่สำหรับท่านที่ไม่มีเวลาพอหรือติดขัดประการใดก็คงต้องศึกษาและทดลองร่วมกันต่อไปครับ

ตอนที่ผ่านมาเราได้ทดลองเขียนโมดูลการทำงานในเวลาจริงแบบรายคาบกัน แต่การทำงานที่ได้ยังไม่เหมาะที่จะนำไปประยุกต์ใช้งานอย่างอื่น ไม่เหมาะตรงที่โมดูลจะทำงานในเวลาจริงทันทีที่แทรกเข้าไปใน kernel และจะหยุดการทำงานทันทีก็ต่อเมื่อลบมันออกจาก kernel เราไม่สามารถควบคุมการเริ่มหรือหยุดการทำงานได้โดยไม่ต้องทำการแทรกหรือลบโมดูลใหม่ นอกจากนี้แล้วมันยังไม่สามารถส่งข้อมูลให้กับโมดูลหรือโปรแกรมประยุกต์อื่นได้ หากมันมีความสามารถนี้ด้วยจะเป็นการดีอย่างยิ่งที่เราจะได้นำไปประยุกต์ใช้ในการจัดเก็บข้อมูลหรือสุ่มข้อมูลจากอุปกรณ์ภายนอกมาจัดเก็บลงแฟ้มข้อมูลสำหรับใช้ในการวิเคราะห์ผลต่อไป

อย่างที่ทราบกันแล้วว่า RTLinux ได้เตรียมวิธีการรับส่งข้อมูลไว้ให้แล้ว 2 วิธีคือ ผ่านทาง Shared Memory หรือ ผ่านทาง FIFO ในบทความตอนนี้จะได้เลือกการใช้งาน FIFO สำหรับการรับส่งข้อมูลระหว่างโมดูลกับโปรแกรมประยุกต์ ทั้งนี้เพราะ FIFO มีการใช้งานที่ง่าย ไม่ยุ่งยากซับซ้อน และยังมีคุณสมบัติบางประการที่เราจะนำมาใช้ประโยชน์ คุณสมบัติที่ว่านี้คืออะไร อดใจไว้อีกนิดเดี๋ยวเราก็จะได้ใช้กัน

ก่อนที่จะได้ทำการทดลองอะไรกันต่อไป ในครั้งนี้จะขอแนะนำให้รู้จักการใช้โปรแกรม make อย่างง่ายๆ กัน แล้วจะได้รู้ว่าการสั่งคอมไพล์ต้นรหัสง่ายขึ้นอีกเยอะหลังจากนั้นจึงจะเข้าเนื้อหากันจริงๆ โดยเริ่มจากการแนะนำถึง FIFO เสร็จแล้วเราจะได้ทำการพัฒนาโมดูลhello_rt ต่อจากตอนที่แล้วให้สามารถรับคำสั่งเริ่มหรือหยุดการทำงานในเวลาจริง และส่งข้อมูลให้กับโปรแกรมประยุกต์ที่เราจะพัฒนาขึ้นใหม่ สุดท้ายจะได้อธิบายถึงการทำงานของตัวอย่าง frank ที่มาพร้อมกับ RTLinux

2 ง่ายขึ้นอีกนิดกับ Makefile

โปรแกรม make เป็นเครื่องมือช่วยในการคอมไพล์ต้นรหัส เหมาะสำหรับใช้งานในกรณีที่จำเป็นต้องจัดการกับแฟ้มต้นรหัสที่มีจำนวนมาก เราสามารถสั่งเพียงแค่คำสั่ง ``make" คำสั่งเดียวในการจัดการคอมไพล์โปรแกรมประยุกต์หรือโมดูลทั้งหมด และมันยังเก่งพอที่จะจัดการคอมไพล์เฉพาะต้นรหัสที่มีการแก้ไขเท่านั้น ส่วนต้นรหัสที่เคยคอมไพล์ไว้แล้วและไม่มีการแก้ไข มันก็จะไม่ทำการสั่งให้คอมไพล์ซ้ำ โปรแกรม make จะใช้แฟ้มข้อมูลชื่อ ``Makefile" เป็นชื่อโดยปริยายที่มันจะอ่านและทำงานตามคำสั่งที่เขียนไว้ โครงสร้างง่ายๆ ของMakefile มีลักษณะดังนี้

01. all: ชื่อ โปรแกรมประยุกต์ อ๊อปเจ็ค หรือ โมดูลที่ต้องการคอมไพล์
02. ชื่อโปรแกรมประยุกต์: ชื่อแฟ้มต้นรหัส หากมีการแก้ไขให้ทำตามคำสั่งข้างล่างนี้
03. <-- Tab --> คำสั่งที่ต้องการให้ทำ
04. ชื่อโมดูล: ชื่อแฟ้มต้นรหัส หากมีการแก้ไขให้ทำตามคำสั่งข้างล่างนี้
05. <-- Tab --> คำสั่งที่ต้องการให้ทำ
06. อื่นๆ:
07. <-- Tab --> คำสั่งที่ต้องการให้ทำ

โครงสร้างของ Makefile

คำว่า ``Tab" ในบรรทัดที่ 03, 05 และ 07 หมายถึงการใช้แป้นอักษร Tab ในการเว้นระยะ ถ้าใช้อย่างอื่น เมื่อสั่งโปรแกรม make จะไม่สามารถทำงานได้ถูกต้อง โครงสร้างดังกล่าวนี้เป็นเพียงโครงสร้างง่ายๆ สำหรับใช้สั่งให้โปรแกรม make ทำงาน หากต้องการรายละเอียดเพิ่มเติมคงต้องหาจากเอกสารอ้างอิงที่จะให้รายละเอียดได้มากกว่า แล้วผู้อ่านจะเห็นประโยชน์จากมันเพิ่มขึ้นอีกมาก จากโครงสร้างนี้เราลองมาดูตัวอย่าง Makefile กัน

01. all: hello_app hello_rt.o
02. CC=kgcc
03. hello_app: hello_app.c common.h
04. ${CC} `rtl-config --include` -Wall -O2 hello_app.c -o hello_app
05. hello_rt.o: hello_rt.c common.h
06. ${CC} `rtl-config --cflags` -c hello_rt.c -o hello_rt.o
07. clean:
08. rm -f * .o *~ hello_app

ตัวอย่างแฟ้มข้อมูล Makefile

เมื่อเราเรียกคำสั่ง ``make" โปรแกรม make จะไปดูรายละเอียดการทำงานในแฟ้มข้อมูลชื่อ Makefile โดยปริยาย(หากเก็บ Makefile ไว้ในชื่ออื่นเช่น mymakefile ให้ใช้คำสั่ง ``make -f mymakefile") และหากเรียกใช้โปรแกรม make โดยไม่มีอาร์กิวเมนต์อื่น มันจะเริ่มทำงานที่ all: ในบรรทัดที่ 01 จากตัวอย่างก็คือจะทำตาม hello_app: และ hello_rt: โดยเรียกใช้คำสั่งในบรรทัดที่ตามมา เช่น hello_app: ก็จะทำการเรียกคำสั่งในบรรทัดที่ 04 แต่ก่อนที่จะมีการเรียกใช้มันจะตรวจสอบก่อนว่า โปรแกรม hello_app มีอยู่หรือไม่ ถ้าไม่มีจึงจะทำการเรียกใช้ แต่ถ้ามี โปรแกรม make ก็จะทำการตรวจสอบชื่อแฟ้มที่ตาม hello_app มา ในที่นี้คือ hello_app.c และ common.h หากมีการเปลี่ยนแปลงหลังจากที่เคยคอมไพล์โปรแกรม hello_app ไว้แล้วมันจะเรียกใช้คำสั่งในบรรทัดที่ 04 อีกครั้งหนึ่ง ส่วนในบรรทัดที่ 02 เป็นการกำหนดค่าให้ CC เพื่อจะนำไปใช้ในบรรทัดที่ 04 และ 06

เพื่อความเข้าใจยิ่งขึ้น ถ้าเราเรียกใช้คำสั่ง ``make clean" โปรแกรม make จะเรียกใช้คำสั่งในบรรทัดที่ 08 ทันทีโดยไม่ต้องคิดอะไรให้มาก และถ้าเราสั่ง ``make hello_rt.o" โปรแกรม make ก็จะจัดการทำงานเฉพาะ hello_rt.o: แล้วถ้าเราต้องการจะคอมไพล์เฉพาะโปรแกรม hello_app ล่ะ ท่านผู้อ่านคิดว่าจะต้องสั่งอย่างไร ถ้าตอบได้ทันทีก็แสดงว่าพอจะเข้าใจการทำงานของโปรแกรม make แล้ว แต่ถ้าตอบไม่ได้ไว้มาตอบอีกครั้งหลังจากได้ทดลองพัฒนาโมดูล hello_rt และเขียนโปรแกรม hello_app ซึ่งเราจะได้ทดลองใช้โปรแกรม make กัน รับรองว่าคราวนี้ตอบได้แน่นอนครับ

3 FIFO เข้าก่อนออกก่อน

FIFO(First In First Out) หรือ เข้าก่อนออกก่อนคือวิธีการรับส่งข้อมูลระหว่างกระบวนการวิธีหนึ่ง เป็นชื่อที่ได้มาจากลักษณะการถ่ายเทข้อมูล โดยข้อมูลที่ส่งเข้าไปใน FIFO ก่อนหากมีการเรียกจะถูกเรียกออกมาก่อน ดังรูปที่ 1 ใน RTLinux ได้จัดเตรียมวิธีการสร้าง FIFO ให้ การสร้างจะต้องสร้างด้วยโมดูล การอ่านและเขียนลงไปใน FIFO จึงจะทำได้ทั้งจากโมดูลและโปรแกรมประยุกต์ โดยปกติเราจะสามารถสร้าง FIFO ได้ทั้งหมด 64 ชุด(เราสามารถเพิ่มจำนวนชุดได้จากการปรับแก้ตัวเลือกของ RTLinux ในตัวเลือกที่เกี่ยวกับ Driver) ขนาดหน่วยความจำที่จะใช้สร้าง FIFO แต่ละชุดรวมกันแล้วจะถูกจำกัดโดยขนาดหน่วยความจำของเครื่องคอมพิวเตอร์

**Figure 1:** ลักษณะการทำงานของ FIFO

การอ่านหรือเขียนข้อมูลของ FIFO ในโมดูลจะใช้ฟังก์ชันเฉพาะแต่ในโปรแกรมประยุกต์จะมีการติดต่อกับ FIFO เหมือนกับการติดต่ออ่านหรือเขียนแฟ้มข้อมูลทั่วไปผ่านแฟ้มข้อมูลชื่อ ``/dev/rtf{fifo}" (เมื่อ fifo มีค่าได้ตั้งแต่ 0 ถึง 63) ที่ถูกสร้างขึ้นจากขั้นตอนการติดตั้ง RTLinux หากคอมพิวเตอ์ของท่านใดยังไม่มีให้ไปที่ไดเร็กตอรี่ของ RTLinux ที่ใช้ในการติดตั้งแล้วสั่ง ``make install"

นอกจาก FIFO จะเป็นทางผ่านของข้อมูลแล้ว RTLinux ยังได้เพิ่มความสามารถในการเรียกใช้งานฟังก์ชันที่กำหนดขึ้นหากมีการอ่านหรือเขียน FIFO ด้วยโปรแกรมประยุกต์หรือโมดูล ความสามารถนี้เราจะนำไปใช้ในการสั่งงานโมดูลเวลาจริงให้เริ่มหรือหยุดการทำงานกัน ตอนนี้เราก็รู้จักกับ FIFO พอสมควรแล้ว ได้เวลามาพัฒนาโมดูล hello_rt กันแล้วครับ

4 hello_rt โมดูลรุ่นพัฒนา

ก่อนจะได้ทดลองเขียนโปรแกรมประยุกต์ที่จะใช้ติดต่อกับโมดูลเวลาจริง เราจะได้เพิ่มความสามารถของโมดูล hello_rt ต่อจากตอนที่แล้วให้สามารถติดต่อรับส่งข้อมูลกับโปรแกรมประยุกต์ได้ หลักๆ แล้วเราจะเพิ่ม FIFO เข้าไปในโมดูลเพื่อใช้รับคำสั่งจากโปรแกรมประยุกต์และเพื่อใช้ส่งข้อมูลให้กับโปรแกรมประยุกต์นำไปแสดงผลหรือเก็บข้อมูลลงแฟ้มข้อมูล อันดับแรกเราจะสร้างแฟ้มข้อมูลชื่อ ``common.h" เพื่อใช้สำหรับอ้างอิงค่าต่างๆ ที่ทั้งโมดูลเวลาจริงและโปรแกรมประยุกต์จะใช้ร่วมกัน

01. #ifndef _COMMON_H_
02. #define _COMMON_H_
03. #define COMMAND_FIFO 0
04. #define DATA_FIFO 1
05. #define COMM_FIFO_SIZE 20
06. #define DATA_FIFO_SIZE 4000
07. #define START 0
08. #define STOP 1
09. struct data_struct{
10. unsigned int count;
11. unsigned int period;
12. };
13. struct command_struct{
14. unsigned char command;
15. hrtime_t period;
16. };
17. #endif // _COMMON_H_

รายละเอียด common.h

บรรทัดที่ 03 และ 04 จะใช้ในการสร้าง FIFO บรรทัดที่ 05 และ 06 ใช้ในการกำหนดขนาดของ FIFO มีหน่วยเป็น bytes บรรทัดที่ 07 และ 08 เป็นค่าคำสั่งที่จะใช้ในการเริ่มหรือหยุดการทำงานเวลาจริง โครงสร้าง data_struct เป็นโครงสร้างของข้อมูลที่โมดูลจะส่งให้โปรแกรมประยุกต์ ในขณะที่โครงสร้าง command_struct จะเป็นโครงสร้างของคำสั่งที่โปรแกรมประยุกต์จะส่งให้โมดูล

count ในบรรทัดที่ 10 จะหมายถึงรอบที่ thread เวลาจริงแบบรายคาบในโมดูล hello_rt ทำงาน และทำงานที่คาบเวลาโดยประมาณเท่ากับค่า period ในบรรทัดที่11 มีหน่วยเป็นนาโนวินาที ส่วน command ในบรรทัดที่ 14 จะเป็นคำสั่ง START ใช้สำหรับเริ่มทำงานเวลาจริง หรือ STOP ใช้สำหรับหยุดการทำงานเวลาจริง หากเป็น START โมดูล hello_rt จะเริ่มการทำงานเป็นรายคาบด้วยคาบเวลา period ในบรรทัดที่ 15 มีหน่วยเป็นนาโนวินาที เมื่อได้ข้อกำหนดต่างๆ เหล่านี้แล้ว เรามาดูโมดูล hello_rt ที่เราได้เพิ่มความสามารถแล้วดังต่อไปนี้

01. #include <linux/module.h>
02. #include <rtl.h>
03. #include <pthread.h>
04. #include <rtl_fifo.h>
05. #include <linux/errno.h>
06. #include "common.h"
07. MODULE_AUTHOR("XXX");
08. MODULE_LICENSE("GPL");
09. MODULE_DESCRIPTION("EXAMPLE PROGRAM");
10. pthread_t periodic_thread;
11. char command_stop = 0;
12. void * periodic_function( void * arg )
13. {
14. struct data_struct data;
15. hrtime_t time,time_old;
16. int count=0;
17. time_old = gethrtime( );
18. while( 1 )
19. {
20. pthread_wait_np( );
21. if( command_stop != 0 )
22. pthread_suspend_np( pthread_self( ) );
23. rtl_printf("%d t Hello World! n",++count);
24. data.count = count;
25. time = gethrtime( );
26. data.period = time-time_old;
27. rtf_put( DATA_FIFO, &data, sizeof(data) );
28. time_old = time;
29. }
30. return 0;
31. }
32. int fifo_handler( unsigned int handler )
33. {
34. struct command_struct ctl;
35. int err;
36. if( (err = rtf_get( COMMAND_FIFO, &ctl, sizeof(ctl) ) == sizeof(ctl )) )
37. switch( ctl.command )
38. {
39. case START:
40. command_stop = 0;
41. pthread_make_periodic_np( periodic_thread, gethrtime( ), ctl.period );
42. break;
43. case STOP:
44. command_stop = 1;
45. break;
46. default:
47. break;
48. }
49. else if( err != 0 )
50. {
51. return -EINVAL;
52. }
53. return 0;
54. }
55. int init_module(void)
56. {
57. struct sched_param p;
58. rtf_create( COMMAND_FIFO, COMM_FIFO_SIZE );
59. rtf_create( DATA_FIFO, DATA_FIFO_SIZE );
60. pthread_create( &periodic_thread, NULL, periodic_function, 0 );
61. p.sched_priority = 1;
62. pthread_setschedparam( periodic_thread, SCHED_FIFO, &p );
63. rtf_create_handler( COMMAND_FIFO, &fifo_handler );
64. return 0;
65. }
66. void cleanup_module(void)
67. {
68. rtf_destroy( COMMAND_FIFO );
69. rtf_destroy( DATA_FIFO );
70. pthread_delete_np( periodic_thread );
71. printk("Byen");
72. }

ต้นรหัส hello_rt.c

จากต้นรหัส hello_rt.c จะเห็นว่าฟังก์ชันของ RTLinux ที่เพิ่มเข้ามาประกอบไปด้วยฟังก์ชัน rtf_create( ), rtf_destroy( ), rtf_create_handler( ), rtf_put( ) และ rtf_get( ) เป็นฟังก์ชันที่ใช้จัดการเกี่ยวกับ FIFO นอกจากนี้ยังมีฟังก์ชัน pthread_suspend_pn( ) ที่ใช้หยุดการทำงานของ thread ส่วนฟังก์ชัน fifo_handler( ) เป็นฟังก์ชันที่เราเพิ่มเข้าไปเพื่อทำหน้าที่สั่งให้ thread เวลาจริงเริ่มหรือหยุดการทำงาน ลองมาดูรายละเอียดทีละฟังก์ชันกันครับ

int rtf_create( unsigned int fifo, int size ) เป็นฟังก์ชันที่ใช้สำหรับสร้าง FIFO ค่าตัวแปร fifo เป็นค่าที่ใช้บอกว่าเป็นการสร้าง FIFO ตัวใด โปรแกรมประยุกต์จะอ้างอิงกับแฟ้มข้อมูล /dev/rtf{fifo} เพื่อใช้ในการติดต่อกับ FIFO เช่น ถ้า fifo เท่ากับ 1 โปรแกรมประยุกต์จะสามารถอ่านหรือเขียน FIFO ตัวนี้ได้โดยการเปิดแฟ้มข้อมูล /dev/rtf1 เป็นต้น การเรียกใช้งานควรเรียกในฟังก์ชัน init_modules( ) ฟังก์ชันนี้จะคืนค่า 0 ถ้าทำงานสำเร็จ แต่จะคืนค่าติดลบถ้ามีข้อผิดพลาดเกิดขึ้น
int rtf_destroy( unsigned int fifo ) เป็นฟังก์ชันที่ใช้สำหรับลบ FIFO ตัวที่ fifo การเรียกใช้งานควรเรียกในฟังก์ชัน cleanup_modules( ) ฟังก์ชันนี้จะคืนค่า 0 ถ้าทำงานสำเร็จ แต่จะคืนค่าติดลบถ้ามีข้อผิดพลาดเกิดขึ้น
int rtf_create_handler( unsigned int fifo, int (* handler)() ) เป็นฟังก์ชันที่ใช้สำหรับกำหนดให้ฟังก์ชัน handler( ) ถูกเรียกใช้ทุกครั้งที่มีการอ่านหรือเขียน FIFO ตัวที่ fifo โดยโปรแกรมประยุกต์ แต่ถ้าหากต้องการเรียกใช้งานทุกครั้งที่มีการอ่านหรือเขียน FIFO โดยโมดูล(ใช้ฟังก์ชัน rtf_get( ) หรือ rtf_put( )) ให้ใช้ฟังก์ชัน rtf_create_rt_handler( ) แทน ฟังก์ชันนี้จะคืนค่า 0 ถ้าทำงานสำเร็จ แต่จะคืนค่าติดลบถ้ามีข้อผิดพลาดเกิดขึ้น
int rtf_get( unsigned int fifo, char * buf, int count ) เป็นฟังก์ชันที่ใช้สำหรับอ่านข้อมูลจาก FIFO ตัวที่ fifo เป็นจำนวน count ในหน่วย bytes และอ่านเสร็จจะเก็บข้อมูลในตัวแปร buf การเรียกใช้งานจะต้องเรียกภายในโมดูลเท่านั้น ฟังก์ชันนี้จะคืนค่าเป็นขนาดของข้อมูลที่อ่านได้ในหน่วย bytes อาจจะน้อยกว่าค่า count ถ้าข้อมูลที่อยู่ใน FIFO มีไม่ถึง แต่จะคืนค่าติดลบถ้ามีข้อผิดพลาดเกิดขึ้น
int rtf_put( unsigned int fifo, char * buf, int count ) เป็นฟังก์ชันที่ใช้สำหรับเขียนข้อมูลจากตัวแปร buf ลงใน FIFO ตัวที่ fifo เป็นจำนวน count ในหน่วย bytes การเรียกใช้งานจะต้องเรียกภายในโมดูลเท่านั้น ฟังก์ชันนี้จะคืนค่าเป็นขนาดของข้อมูลที่เขียนได้มีค่าเท่ากับ count แต่จะคืนค่าติดลบถ้ามีข้อผิดพลาดเกิดขึ้น
int pthread_suspend_np( pthread_t thread ) เป็นฟังก์ชันที่ใช้สำหรับหยุดการทำงานของ thread ในกรณีที่ระบบมีหนึ่งหน่วยประมวลผลกลาง เมื่อเรียกคำสั่งนี้ thread จะหยุดการทำงานทันที หากต้องการให้ thread กลับมาทำงานต่อเราสามารถเรียกใช้ฟังก์ชันpthread_wakeup_np( pthread_t thread ) หรือ อาจเรียกใช้ฟังก์ชัน pthread_make_periodic_np( ) เพื่อกำหนดคาบเวลาในการทำงานใหม่และเริ่มทำงานอีกครั้ง ฟังก์ชันนี้จะคืนค่าเป็น0 เสมอ

เมื่อรู้ว่าแต่ล่ะฟังก์ชันเอาไว้ทำอะไรแล้ว ท่านผู้อ่านพอจะรู้หรือไม่ว่าโมดูล hello_rt ทำงานอย่างไร ไม่ต้องคิดนานครับ มาอ่านกันต่อดีกว่า เมื่อเราทำการแทรกโมดูล hello_rt เข้าไปใน kernel มันจะเริ่มทำงานที่ฟังก์ชัน init_module( ) ในบรรทัดที่ 56-66 มีการสร้าง FIFO ขึ้น 2 ตัว COMMAND_FIFO สำหรับใช้รับคำสั่งจากโปรแกรมประยุกต์ ส่วน DATA_FIFO ใช้ในการส่งข้อมูลจากโมดูลไปยังโปรแกรมประยุกต์ หลังจากนั้นทำการสร้าง thread ชื่อ periodic_thread ที่ทำงานโดยฟังก์ชัน periodic_function( )(หลังจากการสร้าง periodic_thread ฟังก์ชันนี้จะทำงานจนถึงคำสั่ง pthread_wait_np( ) ในบรรทัดที่ 20 ทันที) และทำการกำหนดให้มีการเรียกใช้ฟังก์ชัน fifo_handler( ) ทุกครั้งที่มีการอ่านหรือเขียน COMMAND_FIFO โดยโปรแกรมประยุกต์

หลังจากทำงานที่ฟังก์ชัน init_module( ) แล้ว โมดูล hello_rt จะยังไม่มีการทำงานใดๆ ทั้งสิ้นจนกว่าจะมีการเขียน COMMAND_FIFO โดยโปรแกรมประยุกต์ จากพฤติกรรมนี้เราจะใช้ในการสั่งงานโมดูล hello_rt ได้ สมมติว่าเราสั่งให้โปรแกรมประยุกต์ทำการเขียน COMMAND_FIFO ด้วยข้อมูลที่มีโครงสร้างเป็น command_struct โมดูล hello_rt ก็จะทำการเรียกฟังก์ชัน fifo_handler( ) ในบรรทัดที่ 32-55 ในฟังก์ชันนี้จะมีการอ่านค่าคำสั่งจากโปรแกรมประยุกต์ หากเป็น START มันจะกำหนดให้ periodic_thread เริ่มทำงานเป็นรายคาบเท่ากับค่าที่โปรแกรมประยุกต์ส่งมาทันที แต่หากเป็น STOP มันจะกำหนดค่าตัวแปร command_stop เพื่อใช้ในการหยุดการทำงานแบบรายคาบของ periodic_thread

เมื่อมีการสั่งให้ periodic_thread มีการทำงานแบบรายคาบ ฟังก์ชัน periodic_function( ) จะเริ่มทำงานต่อจากบรรทัดที่ 20 มีการตรวจสอบว่า command_stop มีค่าเท่ากับ0 หรือไม่ ถ้าไม่เท่ากับ 0 มันจะทำการหยุดการทำงานของ thread ทันที แต่ถ้าเท่ากับ 0 มันจะทำงานต่อไปในบรรทัดที่ 23-28

ในบรรทัดที่ 23-28 จะมีการเก็บค่าต่างๆ ที่จะส่งให้โปรแกรมประยุกต์ ค่าที่จะส่งมีค่า count และค่าคาบเวลาการทำงาน period โดยประมาณ จากนั้นทำการเขียนข้อมูลลงในDATA_FIFO เพื่อให้โปรแกรมประยุกต์มาอ่านค่า และนำไปแสดงผลต่อไป

ผู้อ่านอาจจะส่งสัยว่าตัวแปร command_stop มีไว้ทำไม ไม่เห็นจำเป็นต้องใช้เลยก็สามารถสั่งให้ periodic_thread หยุดการทำงานแบบรายคาบได้ตั้งแต่ในฟังก์ชัน fifo_handler( ) ที่เราทำดังนี้เพื่อป้องกันปัญหาที่อาจเกิดขึ้นในกรณีที่ฟังก์ชัน periodic_function( ) กำลังทำงานที่จำเป็นอยู่แต่มีการสั่งให้หยุดการทำงานก่อนที่การทำงานเหล่านั้นจะเสร็จ วิธีการที่ดีที่สุดจึงต้องให้ฟังก์ชัน periodic_function( ) สั่งตัวเองให้หยุดการทำงาน ตอนนี้ก็คงพอจะรู้บ้างแล้วน่ะครับว่าสิ่งที่เราเพิ่มให้โมดูล hello_rt นั้นทำหน้าที่อะไรบ้าง ต่อไปจะได้เขียนโปรแกรมประยุกต์เพื่อใช้ในการสั่งงานโมดูลแล้วน่ะครับ

5 โปรแกรมประยุกต์ hello_app

จากโมดูล hello_rt ที่ผ่านมา หัวข้อนี้เราจะได้เขียนโปรแกรมประยุกต์ชื่อ hello_app เพื่อใช้ในการสั่งงานโมดูล ในขณะเดียวกันก็จะคอยรับข้อมูลจากโมดูลด้วย มาดูกันเลยครับ

01. #include <stdio.h>
02. #include <fcntl.h>
03. #include <unistd.h>
04. #include <rtl_time.h>
05. #include "common.h"
06. int main( void )
07. {
08. int fd_data, fd_ctl, i;
09. struct data_struct data;
10. struct command_struct ctl;
11. if ((fd_data = open("/dev/rtf1", O_RDONLY)) < 0) {
12. printf("Error opening /dev/rtf1 n");
13. exit(1);
14. }
15. if ((fd_ctl = open("/dev/rtf0", O_WRONLY)) < 0) {
16. printf("Error opening /dev/rtf0 n");
17. exit(1);
18. }
19. /* send command to hello_rt */
20. ctl.command = START;
21. ctl.period = 1000000000;
22. if (write(fd_ctl, &ctl, sizeof(ctl)) < 0) {
23. printf("Can't send a command to RT-task n");
24. exit(1);
25. }
26. /* read data from hello_rt */
27. for (i = 0; i < 10 ; i++) {
28. read(fd_data, &data, sizeof(data));
29. printf("Count:= %d t Period:= %d ns. n", data.count, data.period );
30. }
31. /* stop the tasks */
32. ctl.command = STOP;
33. if (write(fd_ctl, &ctl, sizeof(ctl)) < 0) {
34. printf("Can't send a command to RT-task n");
35. exit(1);
36. }
37. close( fd_data );
38. close( fd_ctl );
39. return 0;
40. }

ต้นรหัส hello_app.c

การทำงานของโปรแกรม hello_app ไม่ซับซ้อนอะไรมากนัก ในบรรทัดที่ 11-14 เป็นการเปิด FIFO ขึ้นมาสำหรับอ่านอย่างเดียว เป็น FIFO ตัวที่ 1 หรือ DATA_FIFO เพื่อใช้ในการรับข้อมูลที่โมดูล hello_rt จะส่งมาให้ ในบรรทัดที่ 15-18 ยังได้เปิด FIFO ขึ้นมาอีกหนึ่งตัวสำหรับเขียนอย่างเดียว เป็น FIFO ตัวที่ 0 หรือ CONTROL_FIFO เพื่อใช้ในการส่งคำสั่งจากโปรแกรมประยุกต์ให้โมดูล

บรรทัดที่ 20-25 เป็นการกำหนดค่าให้ตัวแปร ctl และเขียนลงไปใน COMMAND_FIFO โดยใช้ฟังก์ชัน write( ) เพื่อสั่งให้ periodic_thread ในโมดูล hello_rt เริ่มทำงานเวลาจริงแบบรายคาบด้วยคาบเวลา 1,000,000,000 นาโนวินาที หรือ 1 วินาที

บรรทัดที่ 27-30 เป็นการวนรอบอ่านค่าข้อมูลจำนวน 10 รอบจาก DATA_FIFO ที่โมดูลส่งมาให้ เราจะใช้ฟังก์ชัน read( ) ในการอ่านข้อมูลออกมา การอ่านด้วยวิธีนี้หากใน DATA_FIFO ไม่มีข้อมูลอยู่ โปรแกรม hello_app ก็จะหยุดการทำงานไว้ที่บรรทัดที่มีฟังก์ชัน read( ) จนกว่าจะมีข้อมูลที่ DATA_FIFO ให้อ่าน โปรแกรมจึงจะทำงานต่อไปได้

เมื่อทำการอ่านข้อมูลจนครบ 10 รอบแล้ว ในบรรทัดที่ 32-36 โปรแกรม hello_app จะทำการสั่งให้ periodic_thread ในโมดูล hello_rt หยุดการทำงานเวลาจริง โดยการเขียนคำสั่งลงไปใน COMMAND_FIFO อีกครั้งด้วยคำสั่ง STOP

ก่อนจบการทำงาน ในบรรทัดที่ 37,38 ได้สั่งปิดการติดต่อกับ DATA_FIFO และ COMMAND_FIFO หากไม่มีการปิดจะไม่สามารถลบโมดูล hello_rt ออกจาก kernel ได้ จากลักษณะการทำงานของโปรแกรมhello_app ที่อธิบายมานี้จะเห็นว่ามันง่ายมาก ท่านผู้อ่านสามารถที่จะนำไปประยุกต์ต่อได้ อาจจะเพิ่มส่วนที่ทำการบันทึกข้อมูลที่อ่านได้จากโมดูลลงแฟ้มข้อมูล หรือ อาจจะเพิ่มส่วน Graphical User Interface(GUI) ให้ผู้ใช้สามารถใช้งานได้สะดวกขึ้น หรือ อาจจะนำข้อมูลที่ได้ไปแสดงเป็นกราฟแบบเวลาจริงก็ได้ ในส่วนของการเขียนโปรแกรมแบบ GUI เพื่อติดต่อกับ RTLinux นี้ หากผู้เขียนมีเวลาพอเราอาจจะได้มาทดลองเขียนโปรแกรมประเภทนี้ด้วยกัน

6 ตัวอย่างการทำงานของ hello_rt และ hello_app

ได้เวลาลองใช้โปรแกรม make กันจริงๆ แล้วครับ หลังจากที่บันทึกแฟ้มข้อมูล Makefile, hello_rt.c, hello_app.c, และ common.h ไว้ในไดเร็กตอรี่เดียวกันแล้ว ลองสั่งคอมไพล์ด้วยคำสั่ง ``make" ดูครับ ถ้าไม่พิมพ์ต้นรหัสตกหล่นตรงไหน จะได้ผลดังรูปที่2 ครับ

**Figure 2:** ผลการทำงานด้วยคำสั่ง ``make"

หลังจากได้โมดูล hello_rt และ hello_app มาลองสั่งคำสั่ง ``./hello_app" ดู ผลที่ได้จะมีการแสดงข้อผิดพลาดขึ้นเหมือนในรูปที่ 2 เนื่องจากโปรแกรม hello_app ไม่สามารถเปิดแฟ้ม /dev/rtf1 เพื่ออ่านอย่างเดียวได้ถึงแม้จะมีชื่อแฟ้มนี้อยู่ในระบบก็ตาม ทั้งนี้เพราะว่ายังไม่มีโมดูลใดทำงานสร้าง FIFO ตัวที่ 1 ที่อ้างอิงกับแฟ้ม /dev/rtf1 เลย การสั่ง ``./hello_app" อักษร ``./" จำเป็นที่จะต้องใช้เพื่อบอกว่าโปรแกรม hello_app อยู่ในไดเร็กตอรี่ปัจจุบัน หากไม่มี ``./" แล้วจะไม่สามารถสั่งให้โปรแกรม hello_app ทำงานได้เพราะจะมีการค้นหาโปรแกรม hello_app ใน PATH(ลองใช้คำสั่ง ``export" และดูที่ PATH) ที่กำหนดไว้เท่านั้น

หวังว่าผู้อ่านจะยังคงไม่ลืมวิธีการแทรกโมดูลเวลาจริงเข้าไปใน kernel นะครับ เมื่อแทรกโมดูล hello_rt เข้าไปใน kernel แล้วลองใช้คำสั่ง ``dmesg" จะเห็นว่าโมดูล hello_rt ยังไม่มีการทำงานเวลาจริงแบบรายคาบ หลังจากนั้นสั่งคำสั่ง ``./hello_app" จะได้ผลดังรูปที่ 3 เมื่อสั่ง ``dmesg" จะได้ผลดังรูป 4 จะเห็นว่าโมดูล hello_rt จะทำงานเป็นรายคาบจำนวน 10 รอบเท่านั้นตามที่มีการสั่งไว้ในโปรแกรม hello_rt คราวนี้ลองสั่งคำสั่ง ``./hello_app" อีกครั้ง จะได้ผลดังรูปที่ 5 จะเห็นว่าโมดูล hello_rt จะเริ่มทำงานต่อจากเดิม ไม่ได้เริ่มต้นทำงานใหม่ทั้งหมดดูได้จากค่า count ที่เพิ่มขึ้นเป็น 11-20

**Figure 3:** ผลการทำงานด้วยคำสั่ง ``hello_app"

**Figure 4:** ผลการทำงานด้วยคำสั่ง ``dmesg"

**Figure 5:** ผลการทำงานด้วยคำสั่ง ``hello_app" อีกครั้ง

ค่า Period ที่ได้จากการทำงานจะเห็นว่ามีค่าใกล้เคียง 1 วินาทีตามที่เรากำหนดไว้ ตั้งแต่ตอนที่ผ่านมาท่านผู้อ่านเคยสงสัยไหมว่า เราจะสามารถกำหนดค่าคาบเวลาได้สั้นที่สุดเท่าใดที่เครื่องจะยังคงสามารถทำงานต่อไปได้ เราสามารถทดลองได้โดยการลดค่า ctr.period ในต้นรหัส hello_app.c ดูครับ เมื่อแก้ไขและบันทึนต้นรหัสเสร็จอลงสั่งคำสั่ง ``make" โปรแกรม make จะสั่งคอมไพล์เฉพาะโปรแกรม hello_app เท่านั้น ท่านผู้อ่านพอจะเห็นประโยชน์ของโปรแกรม make ยังครับ

เมื่อสั่งโปรแกรม hello_app หลังจากที่มีโมดูล hello_rt ใน kernel หากคอมพิวเตอร์ยังทำงานต่อไปได้ ก็ลองลดค่าของ ctr.period ลงไปเรื่อยๆ จนกว่าคอมพิวเตอร์จะไม่สามารถทำงานต่อไปได้ ค่าคาบเวลาสุดท้ายก่อนที่จะทำให้คอมพิวเตอร์หยุดทำงานได้ จะเป็นคาบเวลาที่สั้นที่สุดที่เราจะกำหนดให้งานเวลาจริงแบบรายคาบได้ ค่านี้ขึ้นกับความสามารถของคอมพิวเตอร์แต่ละเครื่อง ไม่จำเป็นที่จะต้องทำกัน จำคำนี้ไว้ครับ ``คอมพิวเตอร์ยิ่งแรง คาบเวลายิ่งสั้น"

7 การทำงานของตัวอย่าง frank

ผ่านกันมาหลายตอนแล้ว การทำงานของตัวอย่าง frank ที่มากับ RTLinux เป็นอย่างไรนั้น มาถึงตอนนี้ถ้าท่านผู้อ่านไปเปิดอ่านต้นรหัสดู ก็คงที่จะรู้ว่ามันทำงานอย่างไร เลยจะขอสรุปง่ายๆ เพื่อไม่ให้เปลืองหน้ากระดาษดังนี้นะครับ

ตัวอย่าง frank ประกอบไปด้วยโมดูล frank_module และ โปรแกรม frank_app ที่จะใช้ทำงานร่วมกัน โมดูล frank_module จะทำการสร้าง thread ขึ้น 2 thread ทั้งสอง thread จะทำงานเวลาจริงแบบรายคาบและแต่ละ thread จะส่งข้อมูลผ่าน FIFO ให้กับ frank_app FIFO ที่ frank_module สร้างจะมีด้วยกัน 5 FIFO 2 กลุ่ม FIFO กลุ่มแรกมีสองตัวคือตัวที่ 1 และ 2 จะใช้สำหรับส่งข้อมูลจาก frank_module ไปให้ frank_app ส่วนกลุ่มที่ 2 ประกอบด้วยตัวที่ 3 ใช้สำหรับส่งคำสั่งจาก frank_app ไปให้ frank_module ส่วนตัวที่ 4 และ 5 ใช้ในลักษณะเดียวกันกับตัวแปร command_stop ของตัวอย่าง hello_rt ของเรา

เมื่อเราทำการแทรก frank_module เข้าไปใน kernel มันจะยังไม่เริ่มทำงานแบบรายคาบจนกว่าเราจะสั่ง frank_app ให้ทำหน้าที่ส่งคำสั่งให้กับ frank_module คำสั่งที่ส่งประกอบด้วยค่าที่ใช้เลือก thread ที่ต้องการให้รับคำสั่ง คำสั่งเริ่มหรือหยุดการทำงาน และ ค่าคาบเวลาที่ต้องการให้ thread ทำงานแบบรายคาบ เมื่อมีการทำงานแบบรายคาบมันจะทำการเขียนข้อมูลลงใน FIFO ทุกๆ คาบเวลาเพื่อส่งให้ frank_app อ่านและแสดงผลข้อมูล โดยที่ thread แรกจะเขียนคำว่า ``Frank" ลงใน FIFO ตัวที่ 1 ในขณะที่อีกตัวจะเขียนคำว่า ``Zappa" ลงใน FIFO ตัวที่ 2

**Figure 6:** ผลการทำงานของตัวอย่าง frank

frank_app จะสั่งให้ thread ตัวที่ 1 เริ่มทำงานด้วยคาบเวลา 0.5 วินาทีและสั่งให้ thread ตัวที่ 2 เริ่มทำงานด้วยคาบเวลา 0.2 วินาที หลังจากนั้นมันจะวนรอบอ่านข้อมูลจากFIFO วิธีการอ่านข้อมูลของตัวอย่าง frank จะไม่เหมือนกับตัวอย่าง hello_rt ของเราตรงที่มันจะรออ่านข้อมูลจากFIFO เป็นเวลาจำกัด หากไม่มีข้อมูลมาให้อ่าน มันก็จะทำงานโดยวนรอบต่อไปเลยไม่หยุดรอข้อมูลจากFIFO เมื่อมันทำการวนรอบครบ 100 รอบแล้วมันจะสั่งให้ thread ทั้งสองหยุดการทำงานเป็นรายคาบ

การทำงานที่ได้จะเป็นดังรูปที่ 6 จะเห็นว่า thread ตัวที่ 1 มีการทำงานด้วยคาบเวลาที่ช้ากว่าตัวที่ 2 ดูได้จากการพิมพ์คำว่า``Zappa" มีมากกว่าการพิมพ์คำว่า ``Frank"

ตัวอย่างนี้เป็นตัวอย่างที่ดี ตัวอย่างหนึ่งที่แสดงให้เห็นถึงการทำงานของงานสองงานในลักษณะขนานกันไปหรือที่เรียกว่า multithread การทำงานของ thread ทั้งสองจะทำงานไม่ขึ้นแก่กัน ต่างคนต่างทำไป แต่ถ้าหากเราต้องการให้ทั้งสองงานทำงานแบบสอดคล้องกันล่ะ ไม่ใช่ต่างคนต่างทำ ท่านผู้อ่านคิดว่าจะต้องทำอย่างไร ถ้าคิดไม่ออกบอกใบ้ให้นิดหนึ่งครับ ลองดูตัวอย่าง mutex ที่มากับ RTLinux ครับ หรือไม่อย่างนั้นก็ลองไปค้นข้อมูลที่เกี่ยวกับคำว่า ``semaphore" ดูครับ

ถึงแม้ว่าเราจะบอกว่าตัวอย่างนี้มีการทำงานในลักษณะขนานกันไปแต่อย่าลืมนะครับว่าหากคอมพิวเตอร์ที่เราใช้อยู่มีตัวประมวลผลกลางเพียงตัวเดียว การทำงานจริงๆ นั้นก็ยังทำงานในลักษณะอนุกรมกันไปหรือทำงานต่อๆ กันไป ดังนั้นพึ่งจำไว้เสมอว่าการทำงานของ thread จะทำได้เมื่อหน่วยประมวลผลกลางว่างเท่านั้น อย่าออกแบบโมดูลโดยคิดว่ามันจะทำงานขนานกันได้จริงๆ จนทำให้ thread ตัวใดตัวหนึ่งไม่สามารถคืนการทำงานของหน่วยประมวลผลกลางให้ thread อื่นได้ทำงาน

8 สรุป

ในตอนนี้ทุกท่านคงคุ้นเคยกับโปรแกรม make และการติดต่อแลกเปลี่ยนข้อมูลระหว่างโมดูลเวลาจริงกับโปรแกรมประยุกต์กันพอสมควร เบื่อๆ กนหรือยัง หวังว่าคงยังไม่เบื่อกันก่อนนะครับ ไหนๆ ก็อุตสาห์ติดตามกันมาหลายเดือนตอนนี้ก็เป็นตอนที่ 4 แล้ว ก็ขอให้ติดตามกันต่อไปอีก ในตอนหน้ารับรองว่าไม่น่าเบื่อแน่นอนเพราะเราจะมาทดลองเขียนโปรแกรมติดต่อกับ Printer Port กัน ถ้าหน้ากระดาษมากพอ ก็คงจะพาทดลองทั้งการสร้างคลื่นสัญญาณสี่เหลี่ยมที่ความถี่ต่างๆ และทดลองเกี่ยวกับอินเตอร์รัพของ Printer Port ไว้พบกันอีกครับฉบับหน้าครับสวัสดี

9 แหล่งข้อมูลเพิ่มเติม

http://www.gnu.org/software/make/make.html เป็นโฮมเพจของโปรแกรม make
http://www.gnu.org/manual/make-3.79.1/make.html เป็นคู่มือของโปรแกรม make
http://www.csee.umbc.edu/ acedil1/umbc/makefile.shtml หากไม่ต้องการอ่านคู่มือของโปรแกรม make แบบละเอียด

About this document ...

This document was generated using the LaTeX2HTML translator Version 2K.1beta (1.48)

The translation was initiated by Pished Bunnun on 2003-02-14

Pished Bunnun 2003-02-14

2007-04-20T12:05:00.000+01:00

RTLinux : Linux สำหรับงานเวลาจริง

ตอนที่ 3. พื้นฐานการเขียนโปรแกรม RTLinux

พิเชษฐ์ บุญหนุน

1 บทนำ

จากบทความครั้งที่ผ่านมา ท่านผู้อ่านคงได้ทดลองติดตั้ง RTLinux กันไปแล้ว บางท่านอาจทำได้โดยไม่ยากเพราะเคยทำการคอมไพล์ kernel เองกันมาก่อน แต่บางท่านอาจจะต้องเหนื่อยกันหน่อยแต่ก็คงทำสำเร็จกันได้ด้วยดี มาในครั้งนี้เราจะได้กล่าวถึงการเขียนโปรแกรมการทำงานในเวลาจริงสำหรับระบบปฏิบัติการ RTLinux

การเขียนโปรแกรมการทำงานในเวลาจริง ไม่เหมือนกับการเขียนโปรแกรมทั่วไป เพราะต้องเขียนเป็นโมดูล(โปรแกรมในระดับ kernel space ต่อไปจะเรียกว่า โมดูล)สำหรับแทรกการทำงานในเวลาจริงเข้าไปในkernel ของ RTLinux ไม่ใช่การเขียนโปรแกรมประยุกต์ที่ทำการติดต่อกับผู้ใช้งาน(โปรแกรมในระดับ user space ต่อไปจะเรียกว่า โปรแกรมประยุกต์)ทั่วไป อย่างไรก็ตามนอกจากเราจะเขียนโมดูลแล้ว เราอาจจำเป็นต้องเขียนโปรแกรมประยุกต์เพื่อใช้สำหรับรับคำสั่ง แสดงผลการทำงาน หรือ ใช้เก็บข้อมูลลงแฟ้มข้อมูล แทนโมดูล ทั้งนี้เพราะว่าโดยลักษณะของโมดูลแล้วไม่สามารถทำงานในส่วนนี้ได้ จากความจำเป็นดังกล่าว การติดต่อรับส่งข้อมูลระหว่างโมดูลกับโปรแกรมประยุกต์ดังรูปที่ 1 จึงมีความจำเป็น

ใน RTLinux ได้จัดเตรียมวิธีรับส่งข้อมูลไว้ให้สองวิธิหลักๆ ด้วยกันคือ การติดต่อกันผ่านShared Memory หรือ ผ่าน FIFO หากยังจำกันได้ ทั้งสองวิธี จะเป็นตัวเลือกหนึ่งในขั้นตอนการปรับแก้kernel ของ RTLinux ในบทที่ผ่านมา

**Figure 1:** เส้นทางแลกเปลี่ยนข้อมูลระหว่างโมดูลกับโปรแกรมประยุกต์

กล่าวโดยสรุปแล้วการประยุกต์ใช้งาน RTLinux โดยทั่วไปประกอบไปด้วยการทำงานสองส่วนหลักคือ โมดูลการทำงานในเวลาจริง และ โปรแกรมประยุกต์สำหรับติดต่อกับผู้ใช้งาน โดยทั้งสองส่วนติดต่อกันผ่าน Shared Memory หรือ FIFO

สำหรับบทความในครั้งนี้เราจะเรียนรู้ถึงโครงสร้างของโมดูล การเขียนโมดูลให้ทำงานในเวลาจริง และหลังจากกล่าวถึงโครงสร้างพื้นฐานต่างๆ แล้วเราจะมาศึกษาตัวอย่างโปรแกรมการทำงานในเวลาจริงอย่างง่ายกัน ก่อนเริ่มต้นทดลองเขียนโมดูลต่างๆ ตามตัวอย่างในบทความ อย่าลืมบูตเครื่องคอมพิวเตอร์ด้วย kernel ของ RTLinux ก่อน ไม่เช่นนั้นโมดูลที่ได้อาจไม่ทำงานตามที่อธิบายไว้ และถ้าคำสั่งไหนไม่สามารถสั่งทำงานได้ลองใช้บัญชีรายชื่อเป็น root ดูครับ (แล้วทำไมต้องเป็น root ด้วยล่ะ ... ?)

2 โครงสร้างโมดูล

การเขียนโมดูลสำหรับแทรกการทำงานเข้าไปใน kernel ของ Linux ไม่ได้ยากไปกว่าการเขียนโปรแกรมประยุกต์เท่าใดนัก มีข้อกำหนดและโครงสร้างที่แตกต่างกันเท่านั้น หากเคยเขียนโปรแกรมประยุกต์มา และรู้โครงสร้างของโมดูล ก็สามารถที่จะเขียนโมดูลสำหรับใช้งานง่ายๆ ได้แล้ว โครงสร้างของโมดูลจะประกอบไปด้วยสองฟังก์ชันหลักที่จำเป็นต้องมีคือ

int init_module(void) จะมีการเรียกใช้เมื่อมีการแทรกโมดูลนี้เข้าไปใน kernel(แทรกโมดูลจะใช้คำสั่ง insmod) ใช้สำหรับกำหนดค่าเริ่มต้นการทำงานของโปรแกรม ตรวจสอบทรัพยากรของเครื่องก่อนเริ่มการทำงาน หรือ อื่นๆ ที่จำเป็นสำหรับการทำงาน
void cleanup_module(void) จะมีการเรียกใช้เมื่อมีการลบโมดูลนี้ออกจาก kernel(ลบโมดูลจะใช้คำสั่ง rmmod) ใช้สำหรับคืนค่าทรัพยากรที่ใช้ในโมดูลให้กับระบบ หรืออื่นๆ ที่จำเป็นต้องทำก่อนจบการทำงาน

นอกจากฟังก์ชันทั้งสองแล้วก็จะเป็นฟังก์ชันอื่นๆ ที่เราเพิ่มเข้าไปเพื่อใช้งาน ลองพิจารณาโมดูลง่ายๆ ที่จะทำการแสดงข้อความว่า ``Hello Wrold!" ใน kernel messages (ใช้คำสั่ง dmesg ในการแสดง kernel messages) เมื่อทำการแทรกเข้าไปใน kernel และแสดงข้อความว่า ``Bye" เมื่อทำการลบออกจาก kernel ดังรายละเอียดของโมดูลที่ 1.

01. #include <linux/module.h>
02. MODULE_AUTHOR("XXX");
03. MODULE_LICENSE("GPL");
04. MODULE_DESCRIPTION("EXAMPLE PROGRAM");
05. int init_module(void)
06. {
07. printk("Hello World!n");
08. return 0;
09. }
10. void cleanup_module(void)
11. {
12. printk("Bye!n");
13. }

โมดูลที่ 1. โมดูล hello

เมื่อบันทึกต้นรหัสของโมดูลไว้ในชื่อ ``hello.c" จากนั้นทำการคอมไพล์โดยใช้คำสั่ง ``kgcc `rtl-config -cflags` -c hello.c -o hello.o" จะเป็นการเรียกใช้คำสั่ง kgcc โดยที่ตัวเลือก `rtl-config -cflags` เป็นการเรียกคำสั่ง rtl-config เพื่อดึงตัวเลือกต่างๆ ที่จำเป็นในการคอมไพล์โมดูล(ลองใช้คำสั่ง ``rtl-config -cflags") สำหรับ `` ` " ที่อยู่หน้าและหลังของคำสั่ง rtl-config เป็นสัญลักษณ์ที่ได้จากแป้นพิมพ์ที่อยู่ที่เดียวกับ ``~ " ที่ใช้ในการเปลี่ยนภาษาแป้นพิมพ์ในระบบปฏิบัติการ M$ Window, -c เป็นการสั่งให้คอมไพเลอร์คอมไพล์ต้นรหัสเป็นออปเจ็คเท่านั้น ส่วน -o และชื่อแฟ้มข้อมูลที่ตามมาจะหมายถึงชื่อออปเจ็คที่ได้จากการคอมไพล์ในครั้งนี้ ดังนั้นเมื่อคอมไพล์โมดูลเสร็จและไม่มีปัญหาใดๆ เกิดขึ้นจะได้โมดูลที่พร้อมใช้งานในชื่อ hello.o

**Figure 2:** ผลที่ได้จากการใช้คำสั่ง lsmod หลังจากแทรกโมดูล hello เข้าไปใน kernel

หลังจากได้โมดูล hello แล้วลองใช้คำสั่ง ``insmod hello.o" จะเป็นการแทรกโมดูล hello เข้าไปใน kernel หากต้องการดูว่าขณะนี้มีโมดูลอะไรบ้างที่แทรกอยู่ในkernel ให้ใช้คำสั่ง ``lsmod" ผลที่ได้ดังรูปที่ 2 และเมื่อต้องการลบโมดูล hello ออกจาก kernel ให้ใช้คำสั่ง ``rmmod hello" (สังเกตว่าตอนใช้คำสั่ง insmod นั้น hello ที่ตามมาต้องมี ``.o" ด้วย หากไม่มี คำสั่ง insmod จะไปค้นหาโมดูลที่ชื่อ hello ในไดเร็กตอรี่ ``/lib/modules/kernel_version" โดยที่ kernel_version คือชื่อของ kernel รุ่นที่เครื่องคอมพิวเตอร์ทำงานอยู่ ส่วนคำสั่ง rmmod นั้น hello ไม่ต้องมี ``.o" ตาม )

**Figure 3:** ผลที่ได้จากการใช้คำสั่ง rmmod ลบโมดูล hello ออกจาก kernel

เมื่อใช้คำสั่ง ``dmesg" ดังรูปที่ 3 จะมีคำว่า ``Hello World!" และ ``Bye" ขึ้นที่ kernel messages โดยข้อความแรกเกิดขึ้นเมื่อเราแทรกโมดูล ส่วนข้อความที่สองเกิดขึ้นเมื่อเราลบโมดูลออกจาก kernel

จากตัวอย่างที่ผ่านมานอกจากฟังก์ชันหลักๆ สองฟังก์ชันที่ได้กล่าวไปแล้ว ยังมีฟังก์ชันprintk( ) ในบรรทัดที่ 07 และ 12 ที่ทำงานคล้ายๆ กับฟังก์ชัน printf( ) และในบรรทัดที่02-04 เป็นมาโครที่เพิ่มขึ้นมาใน kernel รุ่นใหม่ๆ ถึงไม่มีบรรทัดเหล่านี้ โมดูลที่ได้ก็ยังสามารถทำงานได้ตามปกติแต่...? ( ท่านผู้อ่านทดลองลบสามบรรทัดดังกล่าวออกก่อนทำการคอมไฟล์โมดูล และลองแทรกโมดูลที่ได้ดูครับ )

มาถึงขั้นนี้แล้วผู้อ่านก็คงพอจะเข้าใจหลักการเขียนโมดูลไม่มากก็น้อย หากต้องการศึกษาเพิ่มเติมก็ลองค้นคว้าได้จากเอกสารอ้างอิงในตอนท้ายบทความ

3 โมดูลการทำงานในเวลาจริง

หลังจากได้ลองเขียนโมดูล hello กันมาแล้ว เราจะมาเพิ่มความสามารถของโมดูลให้ทำงานในเวลาจริงกัน แต่ก่อนอื่นมาเข้าใจเพิ่มเติมจากเดิมอีกนิดว่าโมดูลการทำงานในเวลาจริงมีลักษณะอย่างไร

โมดูลการทำงานในเวลาจริงจะมีการเขียนโปรแกรมในแบบที่เรียกว่า multithread การทำงานในลักษณะนี้ ในหนึ่งโปรแกรมหรือหนึ่งกระบวนการ(process)สามารถทำงานได้หลายๆ thread พร้อมๆ กัน โดยที่แต่ละ thread ทำงานขนานกันไป

**Figure 4:** ลักษณะการทำงานแบบ *multithread*

ลองพิจารณารูปที่ 4 FUNCTION1 และ FUNCTION2 ด้านบนเป็นการทำงานในลักษณะที่เรียกว่า multithread โดยแต่ละฟังก์ชันทำงานในคนล่ะ thread และทำงานขนานกันไป ในขณะที่ FUNCTION1 และ FUNCTION2 ด้านล่าง เป็นการทำงานของโปรแกรมทั่วไปซึ่งมีการทำงานต่อกันไม่สามารถทำงานขนานกันไปได้ จากรูปจะเห็นว่าการทำงานแบบ multithread สามารถทำงานโดยใช้เวลาที่สั้นกว่าได้ อย่างไรก็ตามสำหรับระบบที่มีหน่วยประมวลผลกลาง(CPU)เพียงตัวเดียวอาจจะไม่เห็นประโยชน์ของการเขียนโปรแกรมแบบ muiltithread นี้มากนัก นอกจากลักษณะงานที่ต้องการนั้นจะมีหลายๆ งานที่สามารถทำงานขนานกันไปได้และในแต่ล่ะงานที่ว่านี้มีการรอค่าหรือรอสัญญาณจากภายนอกอย่างอื่นก่อนเริ่มทำงานต่อไป ซึ่งอาจทำให้หน่วยประมวลผลกลางว่างและสามารถมาทำงานอื่นก่อนได้เป็นต้น

ผู้อ่านบางท่านอาจเกิดคำถามว่า แล้วหากแต่ละงานเกิดต้องการทำงานพร้อมกันล่ะ จะเกิดอะไรขึ้น คำตอบคือ งานที่มีความสำคัญมากกว่าจะได้ทำงานก่อน และ ในระหว่างที่งานใดงานหนึ่งกำลังทำงานอยู่หากมีงานอื่นที่สำคัญกว่าต้องการทำงาน งานที่กำลังทำอยู่นั้นจะหยุดการทำงาน และให้งานที่มีความสำคัญกว่าทำงานก่อนเสมอ

ในเรื่องการทำงานแบบ multithread นี้ผู้เขียนขอจบไว้เพียงเท่านี้ หากผู้อ่านสนใจค้นคว้าข้อมูลเพิ่มเติมลองศึกษาได้จากเอกสารอ้างอิงที่ให้ไว้ และหวังว่ามันจะทำให้ผู้อ่านเกิดความสนใจการเขียนโปรแกรมในลักษณะนี้และนำมันไปใช้ให้เกิดประโยชน์ต่อไป

4 ตัวอย่างการเขียนโปรแกรมการทำงานในเวลาจริง

จากตัวอย่างโมดูล hello เราจะทำการแก้ไขให้โมดูลนี้ทำงานในเวลาจริงด้วยการทำงานเป็นรายคาบ ดังนั้นเมื่อเราทำการแทรกโมดูลที่แก้ไขแล้วเข้าไปใน kernel จะทำให้เกิดข้อความ ``Hello World!" ที่ kernel messages ซ้ำๆ ขึ้นด้วยคาบเวลาที่เรากำหนด ลองพิจารณาโมดูลที่ 2. ดูครับ

01. #include <linux/module.h>
02. #include <rtl.h>
03. #include <pthread.h>
04. MODULE_AUTHOR("XXX");
05. MODULE_LICENSE("GPL");
06. MODULE_DESCRIPTION("EXAMPLE PROGRAM");
07. pthread_t periodic_thread;
08. void * periodic_function( void * arg )
09. {
10. int count=0;
11. struct sched_param p;
12. p.sched_priority = 1;
13. pthread_setschedparam( pthread_self( ), SCHED_FIFO, &p );
14. pthread_make_periodic_np( pthread_self( ), gethrtime( ), 500000000 );
15. while( 1 )
16. {
17. pthread_wait_np( );
18. rtl_printf("%d t Hello World! n",++count);
19. }
20. return 0;
21. }
22. int init_module(void)
23. {
24. pthread_create( &periodic_thread, NULL, periodic_function, 0 );
25. return 0;
26. }
27. void cleanup_module(void)
28. {
29. pthread_delete_np( periodic_thread );
30. rtl_printf("Byen");
31. }

โมดูลที่ 2. โมดูลเวลาจริง hello_rt.o ที่ทำงานเป็นรายคาบ

เมื่อได้แฟ้มข้อมูล hello_rt.c แล้วให้ทำการคอมไพล์โมดูลโดยใช้คำสั่ง ``kgcc `rtl-config -cflags` -c hello_rt.c -o hello_rt.o" หลังจากคอมไพล์เสร็จจะได้โมดูลในชื่อ hello_rt.o แล้วลองแทรกโมดูลที่ได้โดยใช้คำสั่ง ``insmod hello_rt.o" จะพบว่าไม่สามารถแทรกโมดูลได้ทั้งนี้เนื่องจากโมดูล hello_rt มีการเรียกใช้ฟังก์ชันต่างๆ ที่ไม่ได้คอมไพล์รวมไว้ใน kernel ดังนั้นต้องมีการแทรกโมดูลที่จำเป็นก่อน เพื่อให้ kernel มีฟังก์ชันต่างๆ ที่ hello_rt ต้องการ

ลองแทรกโมดูลโดยใช้คำสั่ง ``rtlinux start hello_rt.o" จะได้ผลดังรูปที่ 5 คำสั่ง rtlinux เป็นคำสั่งที่ RTLinux เตรียมไว้ให้เพื่อแทรกโมดูลที่ RTLinux ใช้สำหรับการทำให้ kernel สามารถทำงานในเวลาจริงได้ ก่อนจะทำการแทรกโมดูลที่เราสร้างขึ้นต่อไป

**Figure 5:** ผลที่ได้จากการใช้คำสั่ง rtlinux สำหรับแทรกโมดูล hello_rt

จากรูปที่ 5 จะเห็นว่ามีการแทรกโมดูล mbuff, rtl_config, rtl, rtl_posixio, rtl_sched และ rtl_time ก่อนที่จะทำการแทรกโมดูล hello_rt จากโมดูลที่แทรกเข้าไปใน kernel นี้ มีโมดูลอะไรบ้างที่จำเป็นก่อนการแทรกโมดูล hello_rt สามารถดูได้จากการใช้คำสั่ง ``lsmod" จะได้ผลดังรูปที่ 6

**Figure 6:** ผลที่ได้จากการใช้คำสั่ง lsmod หลังจากแทรกโมดูล hello_rt

จากรูปที่ 6 สามารถอธิบายได้ว่าโมดูล hello_rt จะต้องใช้โมดูล rtl_sched, rtl_time และโมดูล rtl สำหรับการทำงานในเวลาจริง หากเราไม่ต้องการใช้คำสั่ง rtlinux ในการแทรกโมดูล hello_rt อาจจะใช้คำสั่ง insmod ในการแทรกโมดูลได้ แต่ต้องแทรกโมดูลเรียงตามลำดับดังนี้ rtl, rtl_time และ rtl_sched แล้วตามด้วย hello_rt

ส่วนโมดูล mbuff และ rtl_fifo ยังไม่จำเป็นต้องนำมาใช้ ทั้งสองเป็นโมดูลที่ใช้สำหรับการติดต่อรับส่งข้อมูลระหว่างโมดูลการทำงานในเวลาจริงกับโมดูลอื่น หรือ โปรแกรมประยุกต์อื่นๆ เราจะได้กล่าวถึงกันอีกครั้งในบทความครั้งต่อไป

มาดูผลการทำงานของโมดูล hello_rt กัน ลองใช้คำสั่ง ``dmesg" จะได้ผลดังรูปที่ 7 โมดูล hello_rt นี้จะทำงานเป็นรายคาบโดยพิมพ์คำว่า ``x Hello World!" การพิมพ์จะพิมพ์ซ้ำทุกๆ 0.5 วินาทีไปเรื่อยๆ จนกว่าจะมีการลบโมดูลนี้ออกจาก kernel โดยที่ x คือตัวเลขที่เริ่มจาก 1 และเพิ่มค่าขึ้นทุกๆ คร้งที่มีการพิมพ์

**Figure 7:** ผลที่ได้จากการใช้คำสั่ง dmesg หลังจากแทรกโมดูล hello_rt

การลบโมดูล hello_rt ออกจาก kernel ทำได้ 2 วิธี วิธีแรกใช้คำสั่ง ``rtlinux stop hello_rt" คำสั่งนี้จะทำการลบโมดูล hello_rt และโมดูบอื่นๆ ของ RTLinux ออกไปด้วย ส่วนวิธีที่สองใช้คำสั่ง ``rmmod hello_rt" คำสั่งนี้จะทำการลบเฉพาะโมดูล hello_rt ออกจาก kernel เท่านั้น วิธีนี้เหมาะสำหรับกรณีที่เราต้องการแทรกโมดูลการทำงานในเวลาจริงอีกครั้ง เราจะสามารถแทรกโมดูลนั้นได้เลยโดยใช้คำสั่ง insmod ซึ่งจะเร็วกว่าการใช้คำสั่ง rtlinux ทั้งนี้เพราะ โมดูลที่จำเป็นต่างๆ ยังอยู่ใน kernel

5 การทำงานของตัวอย่างโมดูลการทำงานในเวลาจริง

หลังจากได้ทดลองแทรกและลบโมดูล hello_rt แล้ว มาพิจารณาส่วนประกอบต่างๆ ของโมดูลhello_rt กันว่ามีอะไรเพิ่มขึ้นจากโมดูล hello บ้าง

ในบรรทัดที่ 02 และ 03 เพิ่มเข้ามาสำหรับอ้างอิงถึงประเภทตัวแปรและฟังก์ชันที่จะใช้ในการทำให้โมดูล hello ทำงานในเวลาจริง บรรทัดที่ 07 เป็นการประกาศตัวแปร periodic_thread สำหรับเก็บคุณสมบัติของ thread ที่เราจะสร้างขึ้นให้ทำงานในเวลาจริง

ฟังก์ชัน periodic_function( ) ในบรรทัดที่ 08 จะเป็นฟังก์ชันที่ทำงานใน periodic_thread โดยการเรียกให้เริ่มทำงานด้วยฟังก์ชัน pthread_create( ) ในบรรทัดที่ 24 บรรทัดที่ 10-14 (ก่อนการเรียกฟังก์ชัน while( 1 ))จะมีการเรียกใช้เพียงครั้งเดียว เมื่อโมดูลทำงานมาถึงคำสั่ง pthread_create( ) จึงเหมาะที่จะใช้ส่วนนี้ของฟังก์ชัน periodic_function( ) สำหรับกำหนดค่าเริ่มต้นต่างๆ ที่จะใช้ในการทำงานต่อไปภายในฟังก์ชัน

โครงสร้าง sched_param p ในบรรทัดที่ 11 จะใช้สำหรับกำหนดค่าคุณสมบัติทางด้านตารางเวลาของ thread บรรทัดที่ 12 เป็นการกำหนดลำดับความสำคัญของ thread จะใช้ในกรณีที่มีหลายๆ thread ทำงานพร้อมกัน ความสำคัญของ thread จะมากหรือน้อยขึ้นกับค่าที่กำหนดให้ ถ้ามีค่าน้อยกว่าเมื่อเทียบกับ thread อื่น แสดงว่า thread นี้มีความสำคัญต่ำกว่าและพร้อมจะคืนหน่วยประมวลผลกลางให้ thread อื่นได้ใช้งาน

ฟังก์ชัน pthread_setschedparam( ) ในบรรทัดที่ 13 ใช้สำหรับกำหนดคุณสมบัติทางด้านตารางเวลาของ thread ค่าตัวแปรแรกเป็น thread ที่ต้องการจะกำหนดคุณสมบัติ ในที่นี้ได้เรียกใช้ฟังก์ชันpthread_self( ) ซึ่งจะคืนค่าของ thread ที่เรียกใช้(thread ที่เรียกใช้คือperiodic_thread) ตัวแปรที่สองใน RTLinux รุ่นนี้จะใช้เฉพาะ SCHED_FIFO เท่านั้นเพื่อเป็นการบอกว่าจะใช้โครงสร้าง sched_param p เฉพาะค่า sched_priority สำหรับกำหนดคุณสมบัติของ thread ส่วนตัวแปรที่สามจะเป็นโครงสร้าง sched_param p ที่จะใช้ในการกำหนด

ฟังก์ชัน pthread_make_periodic_np( ) ในบรรทัดที่ 14 ใช้สำหรับกำหนด thread ที่ต้องการให้มีการทำงานในเวลาจริงแบบรายคาบ ตัวแปรแรกจะเป็น thread ที่ต้องการกำหนดให้ทำงานในเวลาจริง ในที่นี้คือ periodic_thread ซึ่งได้จากการเรียกใช้ฟังก์ชันpthread_self( ) ตัวแปรที่สองเป็นเวลาเริ่มต้นที่จะให้ periodic_thread เริ่มทำงานในเวลาจริง มีประเภทตัวแปรเป็น hrtime (signed integer 64 bit) ในหน่วย นาโนวินาที โดยเวลานี้จะมีค่าเทียบกับเวลาที่เริ่มนับตั้งแต่เครื่องคอมพิวเตอร์เริ่มทำงานด้วย RT kernel ในตัวอย่างได้เรียกใช้ฟังก์ชัน gethrtime( ) ซึ่งจะคืนค่าเวลาปัจจุบันในหน่วยนาโนวินาทีกลับมา ตัวแปรที่สามเป็นคาบเวลาที่ต้องการจะให้ periodic_thread ทำงานมี หน่วยเป็นนาโนวินาที ดังนั้นในตัวอย่างจะมีการเริ่มทำงานของ periodic_thread ทุกๆ 0.5 วินาที โดยเริ่มทำงานเป็นรายคาบทันทีที่เรียกใช้ฟังก์ชันนี้

การเรียกฟังก์ชัน while( 1 ) ในบรรทัดที่ 15 เป็นสิ่งจำเป็นสำหรับการทำงานเป็นรายคาบ เงื่อนไขใน while จะต้องจริงเสมอ เพื่อที่จะทำให้ฟังก์ชันในบรรทัดที่ 17-18 ทำงานวนซ้ำไปเรื่อยๆ ไม่มีจบ ในบรรทัดที่ 17 ฟังก์ชัน pthread_wait_np( ) จะหยุดการเรียกใช้งานหน่วยประมวลผลกลางไว้จนกว่าจะถึงคาบเวลาที่เรากำหนด periodic_thread จึงจะเรียกใช้หน่วยประมวลผลกลางและเริ่มทำงานในบรรทัดต่อไป ในระหว่างที่ periodic_thread ไม่ได้เรียกใช้งานหน่วยประมวลผลกลาง กระบวนการอื่น โปรแกรมอื่น หรือ thread อื่นสามารถเรียกใช้งานหน่วยประมวลผลกลางได้

บรรทัดที่ 18 และ 30 เรียกใช้ฟังก์ชัน rtl_printf( ) แทนฟังก์ชัน printk( ) ในบรรทัดที่ 18 จะพิมพ์คำว่า ``x Hello World!" โดยที่ x คือตัวเลข 1, 2, ... ในขณะที่บรรทัดที่ 30 จะพิมพ์คำว่า ``Bye"

บรรทัดที่ 24 เรียกใช้ฟังก์ชัน pthread_create( ) สำหรับสร้าง thread ตัวแปรแรก periodic_thread ใช้สำหรับเก็บคุณสมบัติต่างๆ ของ thread ที่เราสร้างขึ้นตัวแปรที่สองเป็นคุณสมบัติของ thread ที่ต้องการ หากใช้ค่า ``NULL" ฟังก์ชันจะใช้ค่าโดยปริยายตัวแปรที่สาม periodic_function( ) เป็นฟังก์ชันที่ทำงานใน thread ที่สร้างขึ้น ส่วนตัวแปรที่สี่เป็นค่าตัวแปรที่ส่งให้ฟังก์ชัน periodic_function( )

บรรทัดที่ 29 เรียกใช้ฟังก์ชัน pthread_delete_np( ) สำหรับลบการทำงานของ periodic_thread ออกจาก kernel เป็นการหยุดการทำงานเป็นรายคาบวิธีหนึ่งของฟังก์ชัน perodic_function( )

โดยสรุปแล้ว การทำงานของโมดูล hello_rt เมื่อทำการแทรกเข้าไปใน kernel จะเริ่มต้นทำงานที่ฟังก์ชัน init_module( ) ทำการสร้าง periodic_thread จากฟังก์ชัน pthread_create( ) และเรียกฟังก์ชัน periodic_function( ) ให้ทำงาน ในฟังก์ชัน periodic_function( ) มีการเรียกใช้ฟังก์ชัน pthread_make_periodic_np( ) เพื่อกำหนดให้ periodic_thread ทำงานเป็นรายคาบด้วยคาบเวลา 0.5 วินาที หลังจากนั้นจะเข้าไปทำงานวนซ้ำภายใต้ฟังก์ชันwhile( 1 ) แต่จะมีการหยุดและเริ่มทำงานใหม่เมื่อถึงคาบเวลาที่กำหนดด้วยฟังก์ชัน pthread_wait_np( ) การทำงานจะหยุดลงเมื่อทำการลบโมดูล hello_rt ออกจาก kernel โดยโมดูลจะไปทำงานที่ฟังก์ชัน cleanup_module( ) และทำการลบการทำงานของ periodic_thread ออกจาก kernel ด้วยฟังก์ชัน pthread_delete_np( )

6 สรุป

ในครั้งนี้ท่านผู้อ่านคงได้รู้และทดลองเขียนโมดูลสำหรับ Linux และ RTLinux กัน คงเกิดปัญหากันบ้าง บางท่านอาจคอมไพล์ไม่อ่าน บางท่านอาจแทรกโมดูลที่สร้างขึ้นไม่ได้ และ อีกหลายๆ บางที่อาจเกิดขึ้น มันก็เป็นเรื่องปกติครับ ผู้เขียนเองก็ผ่านเรื่องเหล่านี้มาจนชินกับมันเสียแล้ว เมื่อเจอปัญหาก็ขอให้ดีใจเถอะครับ ดีใจที่เราจะได้แก้ปัญหา ผมว่ามันเป็นบทเรียนที่ดีที่สุดเลยทีเดียว หากติดอะไร แก้ไม่ตก ก็อย่าได้เกรงใจ เขียนจดหมายอิเล็กทรอนิกส์มาปรึกษากันได้

ในครั้งหน้าเราจะได้ศึกษาถึงการติดต่อแลกเปลี่ยนข้อมูลระหว่างโมดูลกับโปรแกรมประยุกต์กัน โดยติดต่อกันผ่านทาง FIFO และจะได้อธิบายถึงการทำงานของตัวอย่าง frank ที่มากับ RTLinux

7 แหล่งข้อมูลเพิ่มเติม

Bradford Nichols, Dick Buttlar & Jacqueline Proulx Farrell, Pthreads Programming, O'Reilly & Associates, Inc.
Alessandro Rubini & Jonathan Corbet, Linux Device Drivers, 2nd Edition, http://www.xml.com/ldd/chapter/book
เอกสารที่มากับ RTLinux โดยเฉพาะเอกสารที่ชื่อ Gettingstart.txt

About this document ...

This document was generated using the LaTeX2HTML translator Version 2K.1beta (1.48)

The translation was initiated by Pished Bunnun on 2003-02-14

Pished Bunnun 2003-02-14

2007-04-20T12:00:00.000+01:00

RTLinux: Linux สำหรับงานเวลาจริง

ตอนที่ 2 การติดตั้งระบบปฏิบัติการ RTLinux

พิเชษฐ์ บุญหนุน

1 บทนำ

ในตอนที่แล้วเราได้ทำความรู้จักกับ RTLinux กันมาพอสมควร ผู้เขียนก็หวังว่ามันจะได้สร้างแรงจูงใจให้ท่านผู้อ่านสนใจที่จะศึกษาการใช้งาน RTLinux ต่อไป มาตอนนี้เราจะได้ทราบถึงขึ้นตอนการติดตั้ง RTLinux กัน

การติดตั้งระบบปฏิบัติการ RTLinux เป็นการเปลี่ยน kernel ของระบบปฏิบัติการ Linux เดิม ซึ่งอาจจะเป็นของผู้เผยแพร่รายใดก็ได้เช่น RedHat, Mandrake, Debian หรือ TLE มาใช้ kernel ของ RTLinux (ต่อไปจะเรียกว่า RT-Kernel) ที่พร้อมจะแทรก modules การทำงานในเวลาจริงได้ในขณะที่โปรแกรมการทำงานในส่วนต่างๆ ของ Linux ยังคงเหมือนเดิม

RTLinux ที่เผยแพร่ในระบบอินเตอร์เน็ตจะอยู่ในรูปของต้นรหัส การติดตั้งจำเป็นที่เราจะต้องปรับค่าตัวเลือกและคอมไพล์ต้นรหัสต่างๆ เอง ดังนั้นผู้ติดตั้งควรจะมีความรู้เรื่องการคอมไพล์ kernel อยู่บ้าง สำหรับผู้ที่ไม่เคยทำมาก่อนก็อย่าพึ่งกลัวไปก่อนว่าจะทำไม่ได้ การคอมไพล์ kernel ไม่ได้ยากอย่างที่คิด ขอแค่เรามีความอดทนและพยายามอ่านคู่มือช่วยเหลือ ก็สามารถที่จะคอมไพล์ kernel ให้ใช้ได้

การติดตั้ง RTLinux ประกอบด้วย 3 ขั้นตอนใหญ่ๆ ด้วยกัน ขั้นแรก คือการติดตั้ง Linux จะเป็นของผู้เผยแพร่รายใดก็ได้แล้วแต่ความชอบใจของผู้ใช้งาน ในขั้นตอนนี้อยู่นอกเหนือขอบเขตของบทความ อีกทั้งเอกสารที่อธิบายเกี่ยวกับวิธีการติดตั้งก็มีอยู่ทั่วไป จึงจะขอไม่กล่าวถึง ขั้นที่สอง คือการติดตั้ง RT-Kernel และขั้นสุดท้าย คือการติดตั้ง modules ที่จะใช้สำหรับการทำงานในเวลาจริง

ในตอนนี้จะได้พยายามอธิบายการติดตั้ง RTLinux ทีละขั้นตอน โดยอาศัยรูปภาพเพื่อช่วยให้ผู้อ่านเข้าใจได้ง่ายขึ้น และในแต่ละขั้นตอนได้พยายามแทรกข้อควรระวังเพื่อไม่ให้เกิดข้อผิดพลาดระหว่างการติดตั้ง

2 เตรียมการ

จากที่เคยกล่าวมาแล้วว่า RTLinux ที่เราจะทำการติดตั้งนี้ เป็นเพียงการเปลี่ยน Linux kernel ให้เป็น RT-Kernel เท่านั้น ฉะนั้นจำเป็นจะต้องติดตั้ง Linux ให้เสร็จเรียบร้อยก่อน เพื่อป้องกันปัญหาที่อาจจะเกิดขึ้นในภายหลัง ขอแนะนำให้พยายามติดตั้งDevelopment Packages ทุกอย่างที่ผู้เผยแพร่ได้เตรียมให้

หลังจากที่เราได้ทำการติดตั้ง Linux แล้ว ให้ไปนำไฟล์สำหรับการติดตั้ง RTLinux ดังต่อไปนี้มา

rtlinux-3.1.tar.gz จาก www.fsmlabs.com เป็นรุ่นล่าสุดของระบบปฏิบัติการ RTLinux
linux-2.4.4.tar.gz (หรือ linux-2.2.18.tar.gz) จาก www.kernel.org เป็น Kernel ที่ RTLinux 3.1 สนับสนุน

เมื่อได้ไฟล์ตามที่ต้องการมาแล้วให้ทำการคัดลอกไฟล์ที่ได้ไปที่ /usr/src/ แล้วสั่งคำสั่งต่อไปนี้

/usr/src/> tar zxvf linux-2.4.4.tar.gz	คลายการบีบอัดไฟล์ linux-2.4.4.tar.gz
/usr/src/> ln -s linux-2.4.4 linux	สร้าง symbolic link ของไดเร็กตอรี่ linux-2.4.4 เป็น linux
/usr/src/> tar zxvf rtlinux-3.1.tar.gz	คลายการบีบอัดไฟล์ rtlinux-3.1.tar.gz
/usr/src/> cd linux	เข้าไปในไดเร็กตอรี่ linux
/usr/src/linux> patch -p1 < ../rtlinux-3.1/kernel_patch-2.4.4	แก้ไขต้นรหัสของ kernel ด้วย patch ที่ RTLinux เตรียมไว้ให้

ปรับปรุง เพิ่มเติม
ในกรณีที่ท่านผู้อ่านต้องการใช้ kernel รุ่น 2.4.xx ลองไปหา patch ที่www.fsmlabs.at ซึ่งจะรวม patch ต่างๆสำหรับใช้ในการติดตั้ง RTLinux 3.1 ใน kernel ที่นอกเหนือจากรุ่น 2.4.4 นอกจากนี้ยังมีpatch สำหรับใช้กับคอมไพเลอร์รุ่น 3.2 ที่มีอยู่ใน Redhat 7.3 และ Mandrake 9.0

สมมติว่าเราต้องการติดตั้ง RTLinux ใน kernel รุ่น 2.4.18 ให้ไปนำ patch ชื่อ rt_patch-2.4.18smp-rtl3.1.tar.bz2 มา และอย่าลืมต้องนำแฟ้มข้อมูล linux-2.4.18.tar.bz2 มาด้วย และใช้คำสั่งต่อไปนี้

/usr/src/> tar jxvf linux-2.4.18.tar.bz2	คลายการบีบอัดไฟล์ linux-2.4.18.bz2
/usr/src/> ln -s linux-2.4.18 linux
/usr/src/> tar zxvf rtlinux-3.1.tar.gz
/usr/src/> tar jxvf rt_patch-2.4.18smp-rtl3.1.tar.bz2	คลายการบีบอัดไฟล์ rt_patch-2.4.18smp-rtl3.1.tar.bz2
/usr/src/> cd linux
/usr/src/linux/> patch -p1 <../patch_rtl-2.4.18-smp	แก้ไขต้นรหัสของ kernel ด้วย patch ที่หามาเพ่ิม
/usr/src/linux/> cd ../rtlinux-3.1
/usr/src/rtlinux-3.1/> patch -p1 <../patch_rtlinux-3.1-smp	แก้ไขต้นรหัสของ kernel ด้วย patch ที่หามาเพ่ิม

หลังจากนั้นก็ทำตามขั้นตอนต่อไป

3 การปรับค่าตัวเลือกของ Kernel

เมื่อถึงขั้นนี้เราจะได้ต้นรหัสของ kernel ที่ทำการแก้ไขบางส่วนให้มีความสามารถในเวลาจริง พร้อมที่จะทำการปรับค่าตัวเลือกและคอมไพล์ต่อไป การปรับค่าตัวเลือกของ kernel จะใช้คำสั่ง make config, make menuconfig หรือ make xconfig ก็ได้ สำหรับคำสั่ง make config และ make menuconfig เป็นการใช้งานใน Text Mode (Terminal Console) การใช้งานค่อนข้างจะยุ่งยากมากกว่าการใช้คำสั่ง make xconfig ที่ทำงานใน Graphic Mode (X-Windows) เพื่อให้ง่ายขอแนะนำให้ใช้คำสั่ง ``make xconfig'' ในการปรับค่าตัวเลือกของ kernel แต่อย่าลืมเข้า X-Windows ก่อน ไม่เช่นนั้นจะเกิดข้อความผิดพลาดขึ้น เดี๋ยวท่านผู้อ่านจะใจไม่ดีเสียก่อน

/usr/src/linux> make xconfig

เมื่อสั่งบนเทอร์มินอลใน X-Windows จะได้หน้าจอหลักดังรูปที่ 1

**Figure 1:** หน้าจอหลักของการปรับค่าตัวเลือกของ kernel

ในการปรับค่าตัวเลือกของ kernel จะมีตัวเลือกให้เลือกมากมายในหลายๆ หมวดหมู่ ขอให้พยายามเลือกตัวเลือกต่างๆ ให้เหมาะกับคอมพิวเตอร์ที่เราใช้อยู่ให้มากที่สุด ตัวเลือกไหนไม่เข้าใจ ไม่แน่ใจ พยายามกดปุ่มขอความช่วยเหลือ (``Help'') เพื่ออ่านดูคำแนะนำ โดยปกติตัวเลือกในแต่ละรายการจะมีทางเลือกให้ 3 ทาง คือ เลือกให้อยู่ใน kernel(y), เลือกเป็น module(m) หรือ ไม่ต้องการ(n) ในกรณีเลือกเป็น module หมายความว่าเมื่อจำเป็นต้องใช้ความสามารถนั้นๆ เราค่อยทำการแทรก module นั้นๆ เข้าไปใน kernel วิธีนี้ทำให้ตัว kernel มีขนาดเล็กและสามารถที่จะเพิ่มความสามารถในการทำงานเข้าไปได้เมื่อต้องการใช้งาน การจะเลือกให้ kernel สามารถแทรก module ได้จะต้องเลือกตัวเลือกดังรูปที่2 ในหัวข้อ ``Enable loadable modules support'' ให้อยู่ใน kernel

**Figure 2:** เลือกให้ Kernel สามารถแทรกโมดูลได้

ในการปรับค่าตัวเลือกของ kernel สำหรับ RTLinux มีข้อแนะนำในเอกสารของ RTLinux อยู่ว่า อย่าเลือกให้ kernel สนับสนุนการทำงานของ APM BIOS เพราะไม่อาจคาดเดาผลกระทบที่จะเกิดขึ้นกับการทำงานในเวลาจริงได้ ดังนั้นควรเลือกตัวเลือกดังรูปที่ 3 ในหัวข้อ ``Power Management support'' ไม่ให้อยู่ใน kernel

**Figure 3:** ตัวเลือกทั่วไป

โดยส่วนใหญ่สำหรับมือใหม่ที่ยังไม่เคยคอมไพล์ kernel ด้วยตัวเองมาก่อน มักจะไม่สามารถบูทเครื่องด้วย kernel ที่คอมไพล์เองได้ สาเหตุหลักๆ ที่เกิดขึ้นโดยมากมักมาจากการไม่ได้เลือกให้ kernel สนับสนุนประเภทของการติดต่อกับฮาร์ดดิสที่เครื่องมีอยู่ โดยปกติทั่วไปแล้วจะเป็นประเภท ATA/IDE ดังนั้นในการปรับค่าตัวเลือกของ kernel จะต้องเลือกให้ kernel สนับสนุนการติดต่อกับฮาร์ดดิสประเภทนี้ด้วย ดังนั้นควรเลือกตัวเลือกดังรูปที่ 4 ในหัวข้อ ``Inlcude IDE/ATA-2 DISK support'' ให้อยู่ใน kernel

**Figure 4:** ตัวเลือกประเภทการติดต่อกับฮาร์ดดิส

และอีกปัญหาหนึ่งที่มักพบคือ เราไม่ได้เลือกให้ kernel สนับสนุนระบบไฟล์ที่ Linux เดิมใช้งานอยู่ เช่น ถ้าระบบไฟล์ที่เราใช้อยู่เป็น ext2 แต่เราไม่ได้เลือกให้ kernel สนับสนุนระบบไฟล์ประเภทนี้ kernel ก็จะไม่สามารถอ่านไฟล์ใดๆ ในฮาร์ดดิสได้เลย เป็นผลให้เครื่องไม่สามารถบูทได้ ทางแก้ไขก็คือต้องเลือกให้ kernel สนับสนุนระบบไฟล์ที่ Linux ใช้งานอยู่(อาจจะตรวจสอบได้โดยใช้คำสั่ง mount) โดยปกติจะเป็นระบบไฟล์ ext2 เลือกตัวเลือกได้ดังรูปที่ 5

**Figure 5:** ตัวเลือกระบบไฟล์

ส่วนปัญหาอื่นๆ ที่เกิดขึ้นมักจะไม่เลวร้ายเหมือนสองปัญหาที่ผ่านมา คอมพิวเตอร์ยังสามารถบูทได้ แต่อาจไม่สามารถติดต่อกับฮาร์ดแวร์อื่นๆ ที่เรามี ปัญหานี้หากใจเย็นๆ และค่อยๆ อ่านข้อความช่วยเหลือที่มี ก็จะสามารถปรับค่าตัวเลือกของ kernel ให้สามารถทำงานได้เหมาะสมกับคอมพิวเตอร์ของเราได้มากที่สุด หลังจากปรับค่าตัวเลือกต่างๆ เสร็จแล้ว ให้กดปุ่ม ``Save and Exit'' ที่หน้าหลักเพื่อเตรียมตัวคอมไพล์ kernel ต่อไป แต่หากเราต้องการเก็บค่าตัวเลือกต่างๆ ที่เราได้ทำไว้เพื่อนำไปใช้ในเครื่องอื่น หรือ เพื่อเก็บไว้ใช้ในครั้งต่อๆ ไป ให้กดปุ่ม ``Store Configuration to File'' ที่หน้าหลัก เพื่อเก็บค่าตัวเลือกต่างๆ ลงแฟ้มข้อมูล เวลาที่เราจะนำค่าที่ได้เก็บไว้ไปใช้ สามารถทำได้โดยการกดปุ่ม ``Load Configuration from File''

4 การติดตั้ง Kernel

สำหรับ Linux ของค่าย RedHat และ Mandrake รุ่นใหม่ๆ คอมไพเลอร์ gcc จะเป็นรุ่น 2.96 ซึ่งมีปัญหากับการคอมไพล์ kernel เพื่อแก้ปัญหาที่เกิดขึ้น ทั้งสองค่ายได้เตรียมคอมไพเลอร์ไว้ให้แล้วในชื่อ kgcc (อยู่ในชุดโปรแกรม egcs, egcs-cpp, และ egcs-c++ จะเป็นคอมไพเลอร์ gcc รุ่น 2.91) การเปลี่ยนคอมไพเลอร์ที่ใช้ในการคอมไพล์ kernel ให้ไปแก้ที่แฟ้มข้อมุม ``/usr/src/linux/Makefile'' ในบรรทัดที่มีข้อความว่า CC=$(CROSS_COMPILER)gcc ไปเป็น CC=kgcc ส่วน Linux ของค่ายอื่นตรวจสอบรุ่นของ gcc ได้จากคำสั่ง gcc -version หากต่ำกว่ารุ่น 2.96 และสูงกว่าหรือเท่ากับรุ่น 2.91 ก็ใช้ได้

ปรับปรุง เพิ่มเติม
สำหรับผู้ที่ใช้ Debian Linux Woody 3.0r1 คอมไพเลอร์ gcc ที่ติดตั้งอยู่จะเป็นรุ่น 2.95 ที่ไม่มีปัญหากับการคอมไพล์ kernel จึงไม่มีความจำเป็นที่จะต้องเปลี่ยนแปลงแฟ้มข้อมูล ``/usr/src/linux/Makefile"

เมื่อตรวจสอบเป็นที่แน่ใจแล้วว่าคอมไพเลอร์ gcc ของเราไม่มีปัญหา ให้สั่งคำสั่งต่อไปนี้

/usr/src/linux> make dep	ทำการตรวจสอบความเกี่ยวเนื่องกันของแต่ล่ะไฟล์
/usr/src/linux> make modules	สร้างความสามารถที่เราเลือกให้เป็น module
/usr/src/linux> make modules_install	สำเนาไฟล์ module ต่างๆ ไปที่ /lib/modules/2.4.4-rtl
/usr/src/linux> make install	สร้างไฟล์ต่างๆ สำหรับการบูท และสำเนาไปยังไดเร็กตอรี่ /boot พร้อมกับติดตั้ง Lilo Bootloader

หากไม่มีข้อผิดพลาดเกิดขึ้นระหว่างขั้นตอนต่างๆ ก็เป็นที่อุ่นใจได้ในระดับหนึ่งว่าเราสามารถที่จะคอมไพล์ kernel สำเร็จแล้ว แต่เพื่อความมั่นใจว่าเราจะสามารถบูทเข้า Linux ได้อีกครั้งเพื่อทำการแก้ไขค่าตัวเลือกและทำการคอมไพล์ kernel ใหม่ได้อีกหาก kernel ที่เราสร้างไม่สามารถบูทเครื่องได้ให้ทำตามขั้นตอนต่อไปนี้

อันดับแรกให้ไปตรวจสอบว่าในไดเร็กตอรี่ /boot มีไฟล์ที่ขึ้นต้นด้วย vmlinuz อะไรบ้าง โดยใช้คำสั่ง ``ls -l vmlinuz*'' ดังรูปที่ 6

**Figure 6:** ไฟล์ kernel ในไดเร็กตอรี่ /boot

จะพบว่ามี Symbolic link อยู่ 2 ไฟล์ คือ vmlinuz กับ vmlinuz.old (Linux ของแต่ละค่ายอาจจะมีชื่อไม่เหมือนกัน) แล้วไปทำการแก้ไขไฟล์ /etc/lilo.conf โดยแทนชื่อไฟล์ที่เป็น Symbolic link ทั้งหมดด้วยชื่อไฟล์จริงดังรูปที่ 7 สำหรับไฟล์ initrd ก็ทำเช่นเดียวกัน เมื่อแก้เสร็จแล้วให้พิมพ์คำสั่ง ``lilo'' เพื่อทำการติดตั้ง Lilo Bootloader

**Figure 7:** ข้อความในไฟล์ lilo.conf สำหรับติดตั้ง lilo

หากเราทำการแก้ไขถูกต้องจะไม่มีข้อความผิดพลาดเกิดขึ้น ถึงขั้นตอนนี้เราก็สามารถบูทเครื่องได้อย่างไม่ต้องกังวลว่าเครื่องจะไม่สามารถบูท Linux ได้อีก เพราะหาก kernel ที่เราทำขึ้นไม่สามารถบูทเครื่องได้ เราก็ยังสามารถใช้ kernel ตัวเดิมบูทเครื่องได้

5 ติดตั้ง modules ของ RTLinux

หลังจากที่สามารถบูทเครื่องได้โดย RT-Kernel แล้ว อันดับต่อไปจะเป็นการติดตั้ง modules ของ RTLinux เพื่อใช้ในการเพิ่มคุณสมบัติให้ kernel สามารถทำงานในเวลาจริงได้ ขึ้นตอนการติดตั้งจะทำคล้ายๆ กับการติดตั้ง kernel แต่ง่ายกว่ามาก พิมพ์คำสั่งต่อไปนี้

/usr/src/> cd ../rtlinux-3.1	เข้าไปในไดเร็กตอรี่ rtlinux-3.1
/usr/src/rtlinux-3.1> ln -s ../linux-2.4.4 linux	สร้าง symbolic link ไดเร็กตอรี่ linux-2.4.4 เป็น linux ใน rtlinux-3.1
/usr/src/rtlinux-3.1> make xconfig	จะได้หน้าต่างดังรูปที่ 8

**Figure 8:** หน้าจอหลักของการปรับค่าตัวเลือกของ RTLinux

จะได้หน้าหลักดังรูปที่ 8 กดปุ่ม ``Support Options'' จะได้หน้าต่างดังรูปที่ 9 ในขั้นต้นลองเลือกค่าต่างๆ ตามรูปไปก่อน เมื่อเลือกค่าต่างๆ เสร็จแล้ว กดปุ่ม ``Drivers'' จะมีหน้าต่างดังรูปที่ 10 หน้าต่างนี้จะรวม Drivers ต่างๆ ที่มาพร้อมกับ RTLinux โดย fifo และ shared memory จะใช้สำหรับส่งผ่านข้อมูลระหว่าง module ที่ทำงานในเวลาจริง (อยู่ใน kernel space memory) กับโปรแกรมที่ทำงานบน Linux (อยู่ใน user space memory) ความสามารถนี้จะเป็นประโยชน์อย่างมากเมื่อใช้พัฒนาโปรแกรมที่จะทำงานในเวลาจริง เราจะได้กล่าวถึงอีกครั้งในบทความครั้งต่อไป เมื่อเลือกค่าต่างๆ แล้วให้กดปุ่ม ``Save and Exit'' ที่หน้าหลักแล้วสั่ง

**Figure 9:** ตัวเลือกต่างๆ ของRTLinux

**Figure 10:** ตัวเลือก Driver เพื่อเติมสำหรับงานเฉพาะอย่าง

/usr/src/rtlinux-3.1> make	คอมไพล์ modules ต่างๆ
/usr/src/rtlinux-3.1> make install	ติดตั้ง modules ของ RTLinux
/usr/src/rtlinux-3.1> cp -r doc/man /usr/share	ติดตั้ง manual เพื่อใช้สำหรับเรียกดูวิธีใช้ฟังก์ชันของ RTLinux ด้วยคำสั่ง man

เมื่อถึงขั้นตอนนี้ ก็ถือว่าเสร็จสิ้นการติดตั้ง RTLinux แล้ว เราสามารถเข้าไปทดลองโปรแกรมตัวอย่างที่มากับ RTLinux ได้ โปรแกรมตัวอย่างจะอยู่ในไดเร็กตอรี่ examples ขอแนะนำให้ทดลองโปรแกรมตัวอย่างในไดเร็กตอรี่ frank ใช้คำสั่งต่อไปนี้

/usr/src/rtlinux-3.1> cd examples/frank	เข้าไปในไดเร็กตอรี่ examples/frank
/usr/src/rtlinux-3.1> make	คอมไพล์โปรแกรม จะได้ frank_module.o และ frank_app
/usr/src/rtlinux-3.1> make test	ทำการทดสอบโปรแกรม

เมื่อสั่ง ``make test'' จะมีการแทรก modules เพื่อทำให้ RT-Kernel สามารถทำงานในเวลาจริงได้ แล้วจึงแทรก frank_module.o เข้าไปเพื่อสร้าง ``thread'' สำหรับทำงานในเวลาจริง โดยมีการสั่งให้ ``thread'' เริ่มทำงานหรือหยุดทำงานด้วยโปรแกรม frank_app เมื่อ ``thread'' ทำงานจะทำการส่งข้อมูลผ่าน FIFO มาให้โปรแกรม frank_app เพื่อแสดงผลที่หน้าจอ ที่หน้าจอจะมีคำว่า ``FIFO 1 ...FIFO 2 ...'' วนไปเรื่อยๆ แล้วจะหยุด ถึงตรงนี้หากผู้อ่านยังไม่เข้าใจกระบวนการทำงานของโปรแกรมก็ไม่เป็นไร เราจะได้กล่าวถึงรายละเอียดการทำงานของโปรแกรมนี้กันอีกครั้งในบทความครั้งต่อ ๆ ไป

6 สรุป

``ความพยายามอยู่ที่ไหน ความสำเร็จอยู่ที่นั่น'' เป็นคำกว่าวที่ยังคงใช้ได้เสมอ ไม่มีตกยุกต์ตกสมัย ในการติดตั้งระบบปฏิบัติการ RTLinux ที่กล่าวมาในบทความนี้ แม้จะมีขั้นตอนการติดตั้งที่ไม่ง่ายนัก เพราะ ต้องทำการคอมไพล์ kernel เองแต่สิ่งที่ได้รับกลับมาก็คงจะคุ้มค่ากับแรงกาย แรงใจ ที่เราได้พยามยามทุ่มลงไปหวังว่าท่านผู้อ่านจะไม่หมดความพยายามก่อนที่ความสำเร็จจะเกิดขึ้น ผู้เขียนรับรองได้แน่ว่าท่านผู้อ่านส่วนมากคงจะต้องมีปัญหาติดขัดในการติดตั้ง RTLinux ไม่มากก็น้อย บางท่านอาจจะติดตั้งแต่การติดตั้ง Linux, บางท่านอาจจะติดเนื่องจากลงโปรแกรมชุดพัฒนาไม่ครบทำให้คอมไพล์ kernel ไม่ได้, บางท่านอาจจะติดที่การปรับค่าตัวเลือกของ kernel และอะไรอีกหลายๆ อย่าง ก็ขอให้นึกถึงคำกล่าวที่ผู้เขียนได้อ้างไว้ในตอนต้น สุดท้ายก็หวังอีกครั้งว่าท่านผู้อ่านจะสนุกกับการติดตั้ง Linux และ RTLinux จนกว่าจะเจอกันในครั้งต่อไปกับการเริ่มต้นการใช้งาน RTLinux อย่างง่าย

7 แหล่งข้อมูลเพิ่มเติม

เอกสารในไดเร็กตอรี่ doc ที่มาพร้อมกับ RTLinux
เอกสารที่อธิบายเกี่ยวกับ kernel ของ Linux http://www.tldp.org/HOWTO/Kernel-HOWTO.html
เอกสารอีกชุดที่อธิบายเกี่ยวกับ kernel ของ Linux http://www.tldp.org/HOWTO/KernelAnalysis-HOWTO.html
เอกสารที่อธิบายเกี่ยวกับโมดูล http://www.tldp.org/HOWTO/Module-HOWTO/index.html
เอกสารที่อธิบายเกี่ยวกับ LILO Bootloader http://www.tldp.org/HOWTO/mini/LILO.html

About this document ...

This document was generated using the LaTeX2HTML translator Version 2K.1beta (1.48)

The translation was initiated by Pished Bunnun on 2003-02-14

Pished Bunnun 2003-02-14

2007-04-20T11:51:00.000+01:00

RTLinux : Linux สำหรับงานเวลาจริง

ตอนที่ 1. แนะนำระบบปฏิบัติการ RTLinux

พิเชษฐ์ บุญหนุน , ดร. มานพ วงศ์สายสุวรรณ และ ธเนศ ธีรศักดานนท์

1 บทนำ

ในปัจจุบันถ้าเอ่ยถึงคำว่า ``Linux" คนที่ใช้คอมพิวเตอร์แทบทุกคนในบ้านเราคงรู้จัก คุ้นเคยกับคำนี้ดีขึ้นกว่า เมื่อก่อนมากในฐานะของระบบปฏิบัติการสำหรับคอมพิวเตอร์ เนื่องจากความขึ้นชื่อเรื่องเสถียรภาพในการทำงาน และโดยเฉพาะอย่างยิ่งที่ Linux เป็นระบบปฏิบัติการที่สามารถนำมาใช้ได้ฟรีโดยไม่จำเป็นต้องเสียค่าใช้จ่าย ใดๆ ที่ผ่านๆ มาผู้อ่านคงจะคุ้นกับการนำ Linux ไปใช้ในงานด้าน Server ต่างๆ หรือใช้ในงานด้านเอกสาร ทั้งที่จริงๆ แล้วไม่ใช่เฉพาะสองอย่างนี้เท่านั้นที่ Linux สามารถทำได้ดี งานที่เกี่ยวกับการเชื่อมต่อและควบคุม ฮาร์ดแวร์ภายนอก Linux ก็สามารถนำมาพัฒนาใช้ได้ดีไม่แพ้ระบบปฏิบัติการอื่นเช่นกัน บทความในตอนนี้จะได้แนะนำให้ ผู้อ่านรู้จักกับระบบปฏิบัติการเวลาจริง, ระบบปฏิบัติการ RTLinux และตัวอย่างการประยุกต์ใช้งาน RTLinux ส่วนในบทอื่นๆ ที่จะตามมาจะได้กล่าวถึงการติดตั้ง RTLinux, การเขียนโปรแกรมการทำงานในเวลาจริง, ตัวอย่างการประยุกต์การใช้งานสุดท้าย แล้วผู้เขียนหวังว่าผู้อ่านจะสามารถนำ RTLinux ไปประยุกต์ใช้กับงานต่างๆได้จริงๆ

RTLinux เป็นระบบปฏิบัติการที่รวมเอาความสามารถของระบบปฏิบัติการทั่วไป (general-purpose OS) ซึ่งก็คือ Linux เข้ากับความสามารถของการทำงานในเวลาจริง (real time) ทำให้เราสามารถใช้RTLinux ในการทำงานที่ต้องการความ เที่ยงตรงของเวลาตอบสนอง เช่น ในการเก็บตัวอย่างข้อมูลหรือการควบคุมวงปิดโดยใช้คอมพิวเตอร์และยังสามารถใช้ ความสามารถของ Linux เช่น ความสามารถในด้านเครือข่าย (networking) หรือ การติดต่อกับผู้ใช้แบบกราฟิก (GUI) ได้อีกด้วย

เช่นเดียวกับ Linux, RTLinux เป็นซอฟแวร์ที่ใช้ลิขสิทธ์แบบ GPL ผู้ใช้สามารถนำต้นรหัส (source code) ไปพัฒนาต่อให้เหมาะสมกับการใช้งานยิ่งขึ้นได้ และผู้ใช้ ไม่ต้องเสียค่าใช้จ่ายให้ผู้ทำ RTLinux แต่อย่างใด แต่หากผู้ใช้ต้องการเก็บต้นรหัสไว้ หรือ ต้องการขายโปรแกรมที่พัฒนาขึ้นมา ผู้ใช้สามารถซื้อลิขสิทธิ์ได้จากผู้ที่ทำ RTLinux สำหรับในรุ่นที่ขาย นอกจากจะมีความสามารถเหมือน RTLinux รุ่นที่เป็น GPL แล้ว ยังได้เพิ่มความสามารถบางอย่างเข้าไปด้วย แต่ สำหรับผู้เขียนแล้วคิดว่าส่วนที่เพิ่มเข้ามานี้ไม่จำเป็นนักในการใช้งานทั่วๆ ไป

2 ระบบปฏิบัติการเวลาจริง (real time OS) คืออะไร

ในการนำคอมพิวเตอร์ไปประยุกต์ใช้งานบางประเภท เราต้องการมากกว่าการได้ผลลัพธ์ ที่ถูกต้อง เราอาจต้องการให้คอมพิวเตอร์ทำงานได้ภายในระยะเวลาที่เรา กำหนด หรือทำงานที่เวลาที่เรากำหนดโดยความผิดพลาดทางเวลาที่ยอมรับได้อาจจะน้อยมาก อาจจะเป็นมิลลิวินาทีหรือ น้อยกว่านั้น งานประเภทที่ว่านี้ก็เช่น ในการควบคุมเครื่องจักรกล เราต้องอ่านข้อมูลสถานะของเครื่องจักรกลเพื่อ ใช้ในการคำนวณสัญญานควบคุม และต้องส่งสัญญาณควบคุมที่คำนวณได้ไปควบคุมเครื่อง จักรกลนั้น ทั้งหมดนี้ต้องทำภายในระยะเวลาที่กำหนดแน่นอน ความผิดพลาดจากเวลาที่กำหนด อาจทำให้ไม่ได้สมรรถนะตามที่ต้องการ หรืออาจทำให้ระบบขาดเสถียรภาพและเกิดความเสียหายได้ เราเรียกการทำงานในลักษณะนี้ว่าการทำงานในเวลาจริง

จากความต้องการดังกล่าวการทำงานในเวลาจริงส่วนใหญ่จะใช้ฮาร์ดแวร์และซอฟท์แวร์ที่ออกแบบมาโดยเฉพาะสำหรับงานนั้นๆ ทำให้การพัฒนาระบบและนำไปใช้งานมีความยุ่งยากและอาจเสียค่าใช้จ่ายสูง นอกจากนั้น การเพิ่มความสามารถให้แก่ระบบที่มีอยู่เดิม เช่น การเพิ่มความสามารถในการเชื่อมต่อกับเครือข่าย การติดต่อกับผู้ใช้แบบกราฟิกหรือการติดต่อกับระบบฐานข้อมูล จะทำได้ยากหรือทำไม่ได้ ทั้งที่ความสามารถเหล่านี้มีอยู่ในระบบปฏิบัติการทั่วไปอยู่แล้ว

ดังนั้นจึงมีการพัฒนาระบบปฏิบัติการที่สามารถทำงานในเวลาจริงและยังสามารถทำงาน อื่นๆ ที่ระบบปฏิบัติการทั่วไปสามารถทำได้ รวมทั้งสามารถใช้งานบนเครื่อง คอมพิวเตอร์มาตรฐานเช่น IBM PC compatible ซึ่งมีใช้กันอย่างแพร่หลายและราคาถูก การมีระบบปฏิบัติการเวลาจริง ทำให้สามารถพัฒนาระบบและนำไปใช้งานได้อย่างรวดเร็ว มีค่าใช้จ่ายต่ำ รวมทั้งเรายังใช้ความสามารถของระบบปฏิบัติการทั่วไปได้อย่างสะดวก

ระบบปฏิบัติการเวลาจริงมีให้เลือกในท้องตลาดอยู่หลายผลิตพันธ์ เช่น VxWorks, QNX, LynxOS หรือ Windows NT ที่เพิ่มความสามารถด้านการทำงานเวลา จริงด้วย INTime, Hyperkernel หรือ RTX ส่วน RTLinux ก็เป็นอีกทางเลือกหนึ่ง ที่น่าสนใจเนื่องจากใช้ลิขสิทธ์แบบ GPL สามารถนำมาใช้ได้ฟรีไม่ต้องเสียค่าใช้จ่าย และสามารถนำต้นรหัสไปพัฒนาต่อให้ดียิ่งขึ้นได้ โดยมีข้อแม้เพียงว่าต้นรหัสที่พัฒนาต่อนั้นต้องใช้ลิขสิทธ์แบบ GPL ด้วย

3 เวลาจริงแบบแข็งกับแบบอ่อน (Hard and Soft Realtime)

โดยทั่วไปเราสามารถแบ่งประเภทของงานในเวลาจริงได้เป็น 2 ประเภทคือ เวลาจริงแบบแข็ง (Hard Realtime) กับ เวลาจริงแบบอ่อน (Soft Realtime)

เวลาจริงแบบแข็ง หมายถึง งานที่ต้องการความเที่ยงตรง และแม่นยำสูงในเรื่องของเวลา เมื่อมีการสั่งให้ทำงาน ต้องสามารถทำงานนั้นๆ ได้ทันที งานประเภทนี้ เช่น การควบคุมเครื่องจักรกลหรือการควบคุมอากาศยาน ความผิดพลาดทางเวลาเกินกว่าค่าที่ยอมรับได้อาจทำให้เกิดความเสียหายหรืออุบัติเหตุได้

เวลาจริงแบบอ่อน หมายถึง งานที่ต้องการการทำงานที่รวดเร็วพอ แต่อาจมีความผิดพลาดในเรื่องของเวลาได้ เป็นบางครั้ง งานประเภทนี้ เช่น ในการประมวลผลภาพเคลื่อนไหว เราต้องการให้ความเร็วในการประมวล ผลมากกว่า 30 เฟรมต่อวินาที การประมวลผลที่ช้าเกินไปจะทำให้ภาพเคลื่อนไหวที่ได้ มีคุณภาพลดลง แต่เราอาจยอมรับได้ถ้าเกิดขึ้นไม่บ่อยนัก โดยปกติแล้ว Linux และ MS-Windows ในตระกูล NT จะให้ความสามารถด้านเวลาได้เพียงระดับเวลาจริงแบบอ่อนนี้เท่านั้น

เนื่องจาก RTLinux ได้รับการออกแบบมาเพื่อแก้ปัญหาเวลาจริงแบบแข็ง ดังนั้นถ้าไม่ได้กล่าวไว้เป็นการเฉพาะ คำว่า ``เวลาจริง'' จะหมายถึง เวลาจริงแบบแข็ง

4 Linux กับการทำงานในเวลาจริง

Linux เป็นระบบปฏิบัติการที่สามารถใช้ได้โดยไม่ต้องเสียค่าใช้จ่าย สามารถทำงานได้ดีกับเครื่องคอมพิวเตอร์ ทั้งรุ่นใหม่และเก่า และจำนวนผู้ใช้ก็มีมากขึ้นเรื่อยๆ ดังนั้นจึงไม่ใช่เรื่องแปลกที่เราจะลองนำ Linux มาประยุกต์ใช้กับการทำงานในเวลาจริง แต่เราพบว่า Linux (และระบบปฏิบัติการแบบทั่วไปอื่นๆ) อาจไม่สามารถ ให้ควานเที่ยงตรงได้อย่างเพียงพอ เช่นถ้าเราต้องการอ่านข้อมูลจากอุปกรณ์ภายนอก คอมพิวเตอร์ทุกๆ 10 มิลลิวินาทีและนำมาเก็บไว้ในฮาร์ดดิสค์ เราจะพบว่า Linux ไม่สามารถให้ความเที่ยงตรงในระดับนี้ได้ทั้งที่ในทฤษฎีแล้วฮาร์ดแวร์ ของเราสามารถตอบสนองที่ความเร็วระดับนี้ได้

สาเหตุที่ทำให้ Linux ไม่สามารถตอบสนองความต้องการของการทำงานในเวลาจริงมี อยู่ด้วยกันหลายประการ เช่น

context switch time เมื่อ Linux ต้องการหยุดการทำงานของโปรแกรมหนึ่งเพื่อให้อีกโปรแกรมหนึ่งได้ทำงาน จะมีช่วงเวลาระยะหนึ่งที่ Linux จะต้องใช้เก็บข้อมูลสถานะของโปรแกรมเดิม ซึ่งอาจทำให้การทำงานของเราไม่ทันตามกำหนด
interrupt disabled delay บางขณะ Linux จะทำการ disable Interrupt เป็นช่วงระยะเวลาหนึ่งเพื่อแก้ไขข้อมูลในส่วนที่อาจมี Interrupt routine อื่นใช้งานเนื่องจากการทำงานในเวลาจริงต้องการใช้ Interrupt เพื่อกำหนดเวลา (Timer Interrupt) หรือใช้ Interrupt จากฮาร์ดแวร์ภายนอกเพื่อเป็นสัญญาณบอกให้เริ่มทำงาน การที่Linux ทำการ disable Interrupt ไว้จะทำให้เกิดความผิดพลาดทางเวลา
non-preemptive kernel โดยปกติ Linux สามารถที่จะหยุดการทำงานของโปรแกรมที่กำลังทำงานอยู่เพื่อให้โปรแกรมที่มีความสำคัญกว่าได้ทำงาน แต่ในกรณีที่โปรแกรมที่กำลังทำงานอยู่นั้น อยู่ในระหว่างการทำ system call เช่น fork(), exec() Linux จะไม่สามารถหยุดการทำงานของโปรแกรมนั้นได้ (เนื่องจากเป็นการทำงานในตัว Linux เอง) จะต้องรอให้ออกจาก system call ก่อน ทำให้เกิดความผิดพลาดทางเวลาได้เช่นกัน

5 โครงสร้างการทำงานของ RTLinux

ดังที่กล่าวในหัวข้อที่ผ่านมาว่า Linux โดยตัวของมันเองไม่เหมาะที่จะนำมาใช้ในการ ทำงานในเวลาจริง ดังนั้นจึงได้มีการพัฒนาระบบปฏิบัติการ RTLinux ขึ้นโดยกลุ่มนักวิจัย ที่ New Mexico Institute of Technology ซึ่งมี Dr. Victor Yodaiken เป็นหัวหน้า โครงการ การพัฒนาได้เริ่มมาตั้งแต่ปี คศ. 1996 ในขณะนี้ได้พัฒนาถึงรุ่นที่ 3.1

โครงสร้างของ RTLinux ที่จะทำให้ Linux มีความสามารถทำงานในเวลาจริงได้ จะทำโดยการเพิ่มชั้นของซอฟท์แวร์ระหว่างฮาร์ดแวร์ของคอมพิวเตอร์กับ Linux kernel ดังรูปที่ 1

**Figure 1:** โครงสร้างของ RTLinux

RTLinux จะมอง Linux kernel เป็นงานที่มีความสำคัญต่ำ จะทำงานได้ก็ต่อเมื่อไม่มีงาน ในเวลาจริง (RT Tasks) ต้องการทำงานเท่านั้น และเมื่อมีงานในเวลาจริงต้องการ ทำงาน RTLinux จะสามารถหยุดการทำงานของ Linux kernel ได้ตลอดเวลา ไม่ว่า Linux จะทำอะไร อยู่ก็ตาม ส่วนตัว Linux เองจะไม่เห็นความแตกต่างไปจากการที่ Linux ทำงานบน ฮาร์ดแวร์โดยตรง จากจุดนี้เองที่ทำให้เราสามารถใช้ความสามารถเดิมของ Linux ได้ทุกอย่าง ไม่ว่าจะ เป็นความสามารถด้านเครือข่ายหรือด้านกราฟิก

ในกรณีที่เกิด Interrupt จากฮาร์ดแวร์ RTLinux จะทำการดักสัญญาณ Interrupt นั้นไว้ ถ้าไม่มีงานในเวลาจริงอื่นๆ ต้องการสัญญาณที่ดักได้นี้จึงจะส่งต่อไปให้ Linux และกรณีที่ Linux ทำการ disable Interrupt เพื่อเหตุผลใดก็ตาม RTLinux จะไม่ทำการ disable Interrupt จริงๆ เพียงแต่ จะไม่ส่งสัญญาณ Interrupt นั้นให้กับ Linux kernel เท่านั้น

เพื่อความรวดเร็วในการทำงาน RTLinux จึงเป็นชั้นของซอฟท์แวร์ที่มีขนาดเล็ก ใช้ scheduler แบบง่ายๆ โดยจะให้งานที่มีความสำคัญมากกว่าได้ทำงานก่อนเสมอ และงานในเวลาจริงจะไม่มีการถูกสลับลง ฮาร์ดดิสก์ อีกทั้งงานในเวลาจริงทั้งหมดจะใช้ memory space เดียวกันกับ Linux kernel (เราเรียกว่าทำงานใน kernel space) จึงทำให้ไม่เสียเวลามากในการหยุดการ ทำงานของงานหนึ่งและให้อีกงานหนึ่งทำต่อ (fast context switch time) จากเหตุผลดังที่กล่าวมาทำให้ RTLinux สามารถให้ความเที่ยงตรงในระดับไมโครวินาทีบนเครื่องคอมพิวเตอร์ระดับ Pentium Class ได้

ข้อแตกต่างอย่างหนึ่งของงานในเวลาจริงกับโปรแกรมทั่วไปบน Linux คือ งานในเวลาจริง จะไม่ได้รับการป้องกันความผิดพลาดใดๆ จาก Linux ดังนั้นความผิดพลาดของซอฟท์แวร์ เช่นการหารด้วยศูนย์ จะทำให้เครื่องคอมพิวเตอร์หยุดการทำงานทันที ซึ่งต่างจาก โปรแกรมทั่วไปบน Linux (เราเรียกว่าทำงานใน user space) ซึ่ง Linux จะทำการหยุด การทำงานของโปรแกรมนั้นโดยไม่มีผลกระทบต่อโปรแกรมอื่นๆ ที่กำลังทำงานอยู่ คอมพิวเตอร์จะยังคงสามารถ ทำงานต่อไปได้อย่างปกติ จะมีเพียงโปรแกรมที่ทำงานผิดพลาดเท่านั้นที่จะหยุดทำงาน ตรงจุดนี้จึงเป็นข้อพึงระวังอย่างมากในการพัฒนาโปรแกรมที่ทำงานในเวลาจริง

6 การติดต่อแลกเปลี่ยนข้อมูลระหว่างกระบวนการของ RTLinux (RTLinux Interprocess Communication Mechanism)

RTLinux ได้รับการออกแบบให้มีขนาดเล็กและไม่ซับซ้อน ดังนั้นงานในเวลาจริง จึงไม่สามารถทำงานที่ต้องการการบริการของ Linux ได้ เช่น การติดต่อกับผู้ใช้งาน การอ่านเขียนข้อมูลในฮาร์ดดิกส์ หรือการติดต่อกับเครือข่าย งานดังกล่าวจะต้องทำโดยโปรแกรมที่ทำงานใน Linux

RTLinux ได้จัดเตรียมช่องทางที่จะให้งานในเวลาจริงสามารถติดต่อกับโปรแกรมที่ทำงานใน Linux ไว้ 2 วิธี คือ การติดต่อผ่านทาง FIFO ซึ่งมีลักษณะคล้ายกับการติดต่ออ่าน เขียนแฟ้มข้อมูล และอีกช่องทาง คือติดต่อผ่านทาง Shared Memory

การสื่อสารระหว่างงานในเวลาจริงด้วยกันสามารถทำได้ง่ายเนื่องจากงานในเวลาจริงทั้งหมดใช้ Memory Space เดียวกัน ทำให้สามารถเห็นข้อมูลของกันและกันได้หมด งานในเวลาจริงสามารถจัดสรรเวลาการเข้าถึงข้อมูลได้โดยใช้ semaphores และ mutex ซึ่งเป็นวิธีมาตรฐานของระบบปฏิบัติการแบบ UNIX (และ POSIX)

7 ทางเลือกอื่นนอกจาก RTLinux

ความพยายามที่จะทำให้ Linux สามารถทำงานในเวลาจริงได้ นอกจาก RTLinux แล้วยังมี RTAI ที่พยายามทำเช่นกัน โดยมีการพัฒนา มาจากแนวคิดของ RTLinux ที่ทำการแทรกชั้นของโปรแกรมเข้าไปขั้นกลางระหว่างฮาร์ดแวร์กับ Linux kernel ในรุ่นแรกๆ ทั้งสองกลุ่มจะมีชุดคำสั่งที่คล้ายๆ กัน แทบจะสามารถใช้แทนกันได้ แต่ต่อมาในรุ่นหลังๆ RTLinux ได้เน้นพัฒนาชุดคำสั่ง ให้สอดคล้องกับมาตรฐานPOSIX 1003.13 PES51 และมีความเป็นธุรกิจมากขึ้น ในขณะที่ RTAI ยังใช้ชุดคำสั่งเดิม และยังคงความเป็น GPL ต่อไป นอกจากนั้น RTAI ยังได้เพิ่มความสามารถของการทำงานในเวลาจริงให้กับโปรแกรมที่ทำงานอยู่บน Linux หรือทำงานอยู่ ใน user space memory ซึ่ง RTLinux ก็ได้เพิ่มส่วนนี้ด้วยเช่นกันแต่มีเฉพาะในรุ่นที่ขายเท่านั้น

นอกจากแนวทางที่ RTLinux ใช้แล้วยังมีอีกแนวทางหนึ่งที่พยายามทำให้ Linux สามารถทำงานในเวลาจริงได้ โดยแนว ทางนี้ได้พยายามพัฒนาให้ Linux kernel จากที่เป็น non-preemptive kernel ไปเป็น preemptive kernel สำหรับในแนวทางนี้ ผู้สนใจสามารถหาข้อมูลได้เพิ่มเติมจากเอกสารอ้างอิง

8 ตัวอย่างการประยุกต์ใช้งาน

ก่อนที่เราจะได้ลงลึกเกี่ยวกับการใช้งาน RTLinux ในครั้งต่อๆ ไป คงจะเป็นการดีที่จะได้พูดถึงตัวอย่าง การประยุกต์ใช้งาน เพื่อเป็นแรงจูงใจให้ผู้อ่านได้พยายามศึกษาการใช้งาน Linux และ RTLinux ไม่ท้อใจไปเสียก่อน ดัง ที่กล่าวมาแล้วว่า งานที่ประยุกต์ใช้RTLinux จะเป็นงานประเภทการเก็บตัวอย่างข้อมูล หรือ การควบคุมวงปิดโดย คอมพิวเตอร์ดังนั้นจะขอยกตัวอย่างงานที่เคยได้ทำมาแล้วทั้งสองกลุ่มนี้

ตัวอย่างแรก เป็นการประยุกต์ใช้งาน RTLinux ในการเก็บตัวอย่างข้อมูลลงฮาร์ดดิสก์ โครงการนี้เป็นความร่วมมือระหว่าง นพ.ทายาท ดีสุดจิต อาจารย์ประจำคณะแพทยศาสตร์, อ.เจิดกุล โสภาวนิตย์ และ อ.มานพ วงศ์สายสุวรรณ อาจารย์ประจำภาควิชาวิศวกรรมไฟฟ้า จุฬาลงกรณ์มหาวิทยาลัย ได้ จัดทำเครื่องอ่านคลื่นสมองขึ้น เครื่องนี้สามารถอ่านคลื่นสมอง ได้จำนวน 32 ช่องสัญญาณ ที่ความถี่ 200 Hz ต่อช่องสัญญาณ โครงสร้างของเครื่องเป็นดังรูปที่ 2 หลังจากที่ ไมโครคอนโทรลเลอร์ได้รับสัญญาณคลื่นสมองจากภาคขยายสัญญาณแล้ว จะทำการส่งต่อสัญญาณที่ได้ให้กับคอมพิวเตอร์ผ่านทาง RS-232 หลังจากคอมพิวเตอร์ได้รับแล้วจะทำการแสดงสัญญาณคลื่นสมองที่ได้เป็นกราฟ ในขณะเดียวกันก็เก็บข้อมูลลงฮาร์ดดิสก์ เพื่อที่แพทย์จะสามารถนำไปใช้ในการวินิจฉัยโรคต่อไป สิ่งที่ต้องการจากคอมพิวเตอร์คือ

**Figure 2:** โครงสร้างเครื่องวัดคลื่นสมอง

สามารถรับสัญญาณข้อมูลได้ทั้งหมด โดยไม่มีข้อมูลสูญหาย ปัญหาตรงจุดนี้คือในส่วนของไมโครคอลโทรลเลอร์ จะไม่มีที่พักข้อมูลหากคอมพิวเตอร์ไม่พร้อมที่จะทำการรับ กล่าวคือไมโครคอลโทรลเลอร์จะทำการส่งข้อมูลตลอดเวลา
มีความสามารถด้านกราฟิก เพื่อแสดงสัญญาณคลื่นสมองเป็นกราฟได้ในขณะที่รับข้อมูล
มีความสามารถด้านเครือข่าย เพื่อที่จะสามารถเรียกดูลักษณะคลื่นสมองผ่านทางระบบเครือข่ายได้
มีราคาในส่วนของโปรแกรมที่ไม่สูงมากนัก

จากเงื่อนไขความต้องการทั้งหมดจึงได้เลือกใช้ RTLinux เป็นระบบปฏิบัติการ คอมพิวเตอร์สามารถรับสัญญาณคลื่นสมองผ่านทาง RS-232 โดยใช้วิธี Interrupt ที่โหมดการทำงานด้วยอัตราส่งสูงสุดของ RS-232 ในส่วนนี้จะทำงานในเวลาจริง จากที่กล่าวมาแล้ว งานในเวลาจริงจะไม่สามารถเขียนข้อมูลลงฮาร์ดดิสก์ได้ แต่จะทำการส่งข้อมูลผ่านทาง FIFO ให้โปรแกรมที่ทำงานใน Linux ทำหน้าที่ เขียนข้อมูลลงฮาร์ดดิสก์แทน นอกจากเราจะได้วิธีการเขียนข้อมูลลงฮาร์ดดิสก์แล้ว การเขียนข้อมูลผ่านทาง FIFO ยังทำให้เราได้ที่ พักข้อมูลตามขนาดหน่วยความจำที่เรานำมาสร้างเป็น FIFO อีกด้วย ทำให้ถึงแม้ว่าโปรแกรมที่ทำหน้าที่เขียนข้อมูลลงฮาร์ดดิสก์ จะไม่สามารถเขียนข้อมูลได้ทันทีที่ได้รับข้อมูลจาก FIFO เนื่องจากอาจจะโดนงานอื่นแย่งการทำงานของ CPU ไป ข้อมูลก็จะยัง ค้างอยู่ที่ FIFO ไม่โดนเขียนทับจนกว่าที่พักข้อมูลจะเต็ม เครื่องนี้ปัจจุบันสามารถใช้งานได้จริง และยังได้รับรางวัลสิ่งประดิษฐ์ยอดเยี่ยมของสำนักงานคณะกรรมการการวิจัยแห่งชาติ ประจำปี พ.ศ. 2543 สำหรับกราฟิก ที่ใช้ในการแสดงสัญญาณดูได้จากรูปที่ 3

**Figure 3:** โปรแกรมแสดงสัญญาณคลื่นสมอง

ตัวอย่างที่สอง เป็นการประยุกต์ใช้งาน RTLinux ในงานควบคุมวงปิดด้วยคอมพิวเตอร์ โครงงานนี้เกิดขึ้นเนื่องจากทาง ศูนย์เทคโนโลยีอิเล็กทรอนิกส์และคอมพิวเตอร์แห่งชาติ โดย กฤษณ์ จงสฤษดิ์, อมร ช่วยชู และ ปณิธิ พุ่มวิเศษ ได้ ประดิษฐ์การ์ด Motion I/O ขึ้น แล้วต้องการแสดงให้เห็นถึงการประยุกต์ใช้งานการ์ดนี้ การ์ด Motion I/O เป็นการ์ดที่ ใช้เชื่อมต่อกับคอมพิวเตอร์ผ่านทางช่อง ISA ทำหน้าที่อ่านค่าตำแหน่งของเซอร์โวมอเตอร์ให้กับคอมพิวเตอร์ ขณะเดียวกันก็ทำหน้าที่แปลงคำสั่งที่ได้จากคอมพิวเตอร์ให้เป็นสัญญาณ PWM เพื่อส่งให้ชุดขับมอเตอร์ใช้ควบคุม เซอร์โวมอเตอร์ ตัวคอมพิวเตอร์จะทำหน้าที่คอยสร้างสัญญาณควบคุมจากค่าตำแหน่งของเซอร์โวมอเตอร์ที่ได้รับผ่านทางการ์ด Motion I/O ลักษณะโครงสร้างของระบบนี้เป็นดังรูปที่ 4

**Figure 4:** โครงสร้างการควบคุมระบบเซอร์โวมอเตอร์ด้วยคอมพิวเตอร์

ในการควบคุมวงปิดด้วยคอมพิวเตอร์สำหรับการ์ด Motion I/O นี้จะใช้ในการควบคุมตำแหน่ง หรือ ความเร็วของเซอร์โวมอเตอร์ ผลตอบของการควบคุมนอกจากจะขึ้นกับวิธีในการสร้างสัญญาณควบคุมแล้ว ยังขึ้นกับความสามารถในการทำงานในเวลาจริงของ คอมพิวเตอร์ด้วย คอมพิวเตอร์จะต้องสามารถทำงานในเวลาจริงในลักษณะที่เป็นรายคาบแน่นอนได้ ดังนั้นจึงได้เลือกใช้ RTLinux เป็นระบบปฏิบัติการ นอกจากจะได้ประโยชน์จากความสามารถในเวลาจริงแล้ว ยัง ได้การแสดงผลแบบกราฟิกของ Linux อีกด้วย ดังแสดงในรูปที่ 5

**Figure 5:** โปรแกรมควบคุมการเคลื่อนที่ของเซอร์โวมอเตอร์

9 สรุป

มาถึงจุดนี้ ผู้อ่านคงจะเข้าใจความหมาย ความสำคัญ และ แนวทางการประยุกต์ใช้งานระบบปฏิบัติการเวลาจริงไม่มากก็น้อย โดยเฉพาะ RTLinux ครั้งหน้าเราจะได้กล่าวถึงวิธีการติดตั้ง RTLinux กัน อย่างที่กล่าวไว้แล้วว่า RTLinux ก็คือ Linux ที่มีการปรับแก้ kernel ให้มีความสามารถเวลาจริง ดังนั้นก่อนการติดตั้ง RTLinux ก็ขอให้ผู้อ่านได้ทำการติดตั้ง Linux ที่เครื่องคอมพิวเตอร์เสียก่อน จะเป็น Linux ของผู้เผยแพร่รายใดก็ได้ สำหรับวิธีการติดตั้ง การใช้งาน Linux เบื้องต้น ก็คงหาได้จากหนังสือ หรือ Internet ซึ่งมีอยู่ทั่วไปแล้วในปัจจุบัน คงหาข้อมูลได้ไม่ยากนัก และในระหว่าง การติดตั้งขอแนะนำให้เลือกระบบไฟล์ที่จะใช้เป็น ext2, ext3 หรือ ReiserFS และในขั้นตอนการติดตั้ง Boot Loader ก็ขอแนะนำให้ ติดตั้ง LILO เพื่อจะได้ง่ายเมื่อต้องทำการติดตั้ง RTLinux สุดท้ายก็ขอให้ท่านผู้อ่านสนุกกับการติดตั้ง Linux นะครับ อย่าพึ่งท้อก่อน มีปัญหา สงสัยอะไรก็สามารถติดต่อผู้เขียนได้ทางเมลล์พร้อมจะช่วยเต็มที่หากช่วยได้ครับ ไว้พบกันใหม่ ในฉบับต่อไป

10 แหล่งข้อมูลเพิ่มเติม

FSMLabs, Inc. บริษัทที่ทำการพัฒนา RTLinux http://www.fsmlabs.com/
เอกสารต่างๆ เกี่ยวกับ RTLinux จาก FSMLabs http://www.fsmlabs.com/developers/man_pages/
บทความอธิบายเกี่ยวกับการทำงานในเวลาจริงกับ Linux http://www.linuxdevices.com/articles/AT5997007602.html
แหล่งข้อมูลของ RTAI http://www.aero.polimi.it/~rtai
แหล่งข้อมูลของ preemptive kernel http://kpreemptive.sourceforge.net
แหล่งข้อมูลอีกแหล่งของ preemptive kernel http://www.timesys.com
บทความที่น่าสนใจ http://www.linuxdevices.com/articles/AT7005360270.html
บทความที่น่าสนใจ http://www.linuxdevices.com/articles/AT4503827066.html
บทความเปรียบเทียบระหว่าง RTLinux กับ RTAI http://bernia.disca.upr.es/rtportal/comparative/rtl_vs_rtai.html
รวมบทความที่น่าสนใจ http://www.realtimelinuxfoundation.org/events/rtlws-2001/papers.html

About this document ...

This document was generated using the LaTeX2HTML translator Version 2K.1beta (1.48)

The translation was initiated by Pished Bunnun on 2003-02-14

Pished Bunnun 2003-02-14

Ubuntu Edgy 6.10+WPN111 USB Wireless.

2007-03-07T16:05:00.000Z

Ubuntu Edgy 6.10+WPN111 USB Wireless.

ndiswrapper version which's come along with Edgy 6.10 does't work. After installing and setting a wireless up, a computer freeze and we have to unplug USB wireless first before USB wireless can work properly. To solve this just uninstall all ndiswrapper package and download newer version of ndiswrapper(http://ndiswrapper.sourceforge.net/) i.e. 1.38. Then install ndiswrapper and set a wireless network as usual.

Changing a firewire camera mode in OpenCV.

2007-03-05T16:13:00.000Z

Changing a firewire camera mode in OpenCV.

All mode define in libdc1394/dc1394_control.h
enum
{
MODE_160x120_YUV444= 64,
MODE_320x240_YUV422,
MODE_640x480_YUV411,
MODE_640x480_YUV422,
MODE_640x480_RGB,
MODE_640x480_MONO,
MODE_640x480_MONO16
};

We can use cvSetCaptureProperty() to change a firewire camera mode, for example,

cvSetCaptureProperty( capture, CV_CAP_PROP_MODE, MODE_320x240_YUV422 );
or
cvSetCaptureProperty( capture, CV_CAP_PROP_MODE, 65 );

ChOpenCV 2.3 with OpenCV 1.0 in Linux

2007-03-05T16:08:00.000Z

You do not need to follow the instruction for using Ch and OpenCV 1.0 together cos. there is ChOpenCV version 2.5 with is working with OpenCV 1.0.

Installing ChOpenCV 2.3 with OpenCV 1.0 in Linux (Redhat WS 4 and Ubuntu 6.10).

Download OpenCV from http://sourceforge.net/projects/opencvlibrary/ and install as usual.

Download ChOpenCV from http://www.softintegration.com/products/thirdparty/opencv/ and uncompress in to OpenCV build directory.

Assume OpenCV build directory is opencv-1.0 and copy ChOpenCV source into this directory.

$cd opencv-1.0
$tar zxvf chopencv-2.3.0.tar.gz
$cd ch

Create pkgcreate.ch.patch text file which contains

161a162 > patch cxcore_chdl.c ../cxcore_chdl.c.patch

Create cxcore_chdl.c.patch text file which contains

1088c1088 < cvMixChannels(src, src_count, dst, dst_count, from_to, pair_count); --- > cvMixChannels((const CvArr**)src, src_count, dst, dst_count, from_to, pair_count);

$patch pkgcreate.ch pkgcreate.ch.patch
$make
$make install

Installing Ch by using non-root user.

2007-03-05T15:56:00.000Z

How to install Ch (http://www.softintegration.com/ ) by using non-root user in Linux.

If we install Ch by using non-root user, we might be faced a library linking problem. Solving the problem is simply by adding

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$CHHOME/extern/lib

into the end of .bashrc or .bash_profile in home directory.

In case we installed many programs and libraries into non-standard directory, we might be faced both linking and running problem when we run script under ch shell. We have to add library and bin path to ch shell by adding

_path = stradd(_path, "none standard path i.e. /home/xxx/bin:/home/yyy/bin");

putenv("LD_LIBRARY_PATH=none standard + standard library path i.e. /usr/lib:/usr/local/lib:/home/xxx/lib:/home/yyy/lib:$CHHOME/extern/lib")

into .chrc file in home directory. (We can copy a sample .chrc by using 'ch -d' command.)

Change to full screen mode in Gtkmm

2007-01-14T03:02:00.000Z

Change Gtk::Window to full screen mode by calling fullscreen() and change it back to normal mode by calling unfullscreen(). It works since version 2.2.

How to record a screen into swf video file.

2006-12-30T00:46:00.000Z

Look into http://www.unixuser.org/~euske/vnc2swf/. Python version works well in Ubunto without compilation and it can include sound with video file, I haven't test it yet.

Call to Thailand with VOIP.

2006-12-10T01:50:00.000Z

Calling to Thailand via www.voipdiscount.com is dirt cheap. We can use Twinkle in Ubuntu Edgy with G.711 codec instead of the provider's program. (Ekiga's not work cos it doesn't support required codecs.)

The method above works very well in Ubuntu 6.10 but when I upgraded it to Ubuntu 7.04 , Twinkle doesn't work properly. Instead of using Twinkle, I'm now happy with a free softphone from http://www.sjlabs.com/sjp.html. Even it's display font is quite ugly, it does work out of a box. Do not have any problem with a sound setting, give a acceptable sound quality, and a simple address book.

How to compile a custom kernel on Ubuntu Edgy for my R50e.

2006-11-26T18:19:00.000Z

Install necessary program for compiling a custom kernel.

$ sudo aptitude install fakeroot bzip2 kernel-package initramfs-tools linux-source

After installing them all.

$ cd /usr/src
$ sudo tar jxf linux-source-2.6.17.tar.bz2
$ cd /usr/src/linux-source-2.6.17
$ sudo cp /boot/config-$(uname -r) .config
$ sudo make oldconfig
$ sudo make gconfig --or-- make xconfig --or-- make menuconfig

Remove all unnecessary modules/function from the kernel to improve computer speed.

$ sudo fakeroot make-kpkg clean
$ sudo fakeroot make-kpkg --append-to-version "-r50e" --revision "261106" --us --uc --initrd kernel_image kernel_headers

After successful compiling, they should have linux-headers-2.6.17.13-r50e_2.6.17.13-r50e-261106_i386.deb and
linux-image-2.6.17.13-r50e_2.6.17.13-r50e-261106_i386.deb.

Installing the custom kernel by

$ sudo dpkg -i linux-image-2.6.17.13-r50e_2.6.17.13-r50e-261106_i386.deb

Prepare a firmware for ipw2200 (and others) by

$ sudo cp -R /lib/firmware/$(uname -r) /lib/firmware/2.6.17.13-r50e

Now it's time to reboot the computer with the custom kernel.

kernel-config-r50e is my kernel configuration file.

RTAI 3.4 + Ubuntu Edgy

2006-11-26T01:19:00.001Z

Get a kernel source linux-2.6.17.tar.bz2 from www.kernel.org and rtai-3.4.tar.bz2 from www.rtai.org. Assume both of them are in /usr/src directory.

$ cd /usr/src
$ sudo tar jxf rtai-3.4.tar.bz2
$ sudo tar linux-2.6.17.tar.bz2
$ cd linux-2.6.17
$ sudo patch -p1 <../rtai-3.4/base/arch/i386/patches/hal-linux-2.6.17-i386-1.3-08.patch

Then following the procedure in How to compile .... except

1. Selecting the following kernel configuration options

Disable "Module versioning support" under "Loadable module support".
Enable "Interrupt pipeline" under "Processor type and features".
Disable "Use register arguments" under "Processor type and features".

2. Editing Makefile a little bit to make sure we will get smooth compiling without any error. Change Makefile from the line
CC = $(CROSS_COMPILE)gcc to CC = $(CROSS_COMPILE)gcc-3.4
before running

$ sudo fakeroot make-kpkg --append-to-version "-rtai3.4" --revision "261106" --us --uc --initrd kernel_image kernel_headers

Then reboot your computer with the new kernel.

$ sudo mkdir rtai-build
$ cd rtai-build
$ sudo make -f ../rtai-3.4/makefile srctree=../rtai-3.4 gconfig

After configuring RTAI, edit ../rtai-3.4/makefile by changing CC=gcc to CC=gcc-3.4 in the second line and replace rtai-3.4/base/include/rtai_posix.h by rtai_posix.h from
http://cvs.gna.org/cvsweb/vulcano/base/include/rtai_posix.h?rev=1.19;content-type=text%2Fplain;cvsroot=rtai
because rtai_posix.h coming with rtai-3.4.tar.bz2 conflicts with /usr/include/pthread.h.

$ sudo make
$ sudo make install

For making device file in /dev for share memory and fifos application, run

$ sudo mknod -m 666 /lib/udev/devices/rtai_shm c 10 254
$ sudo for n in `seq 0 9`; do f=/lib/udev/devices/rtf$n; mknod -m 666 $f c 150 $n;done;

It will generate /dev/rtai_shm and /dev/rtf* after you reboot your computer.

Checking RTAI by running programs in /usr/realtime/testsuit.

Oh! filenames and variables. I've changed my mind.

2006-11-18T03:17:00.000Z

Replace "OLDword" in all files including in subdirectory by "NEWword".
$find -type f|xargs sed -i 's/OLDword/NEWword/g'

Delete all directory with "DirectoryName" including in subdirectory.
$find -name DirectoryName -type d|xargs rm -fr

Bash script below is used to change all filenames including in subdirectory containing *$original* to filenames containing *$replace* .

$chfilename before after
#!/bin/sh
#chfilename.sh
IN=INtxt
original=$1
replace=$2
find -name "*$original*" -type f > $IN
while read infilename
do
src=$infilename
tgt=$(echo $infilename | sed -e "s/$original/$replace/")
mv $src $tgt
done < $IN
rm -f $IN

Stronger file protection than zip/unzip

2006-11-17T12:54:00.000Z

Using GnuPG to protect a file is a stronger file protection than zip/unzip with password.

Generating our own keys by running $gpg --gen-key. It will generate .gnupg in home directory with key files inside.
$gpg -e filename --> it will generate filename.gpg and if someone wanna get filename back, one must have the keys and the password.
$gpg -s -e filename --> it will generate filename.gpg like above command but including a signature to the output.
$gpg filename.gpg --> decrypt filename.gpg to filename.

screen - screen manager with VT100/ANSI terminal emulation

2006-11-17T12:44:00.000Z

It's very useful when working at home and work place with the same sever.
In work place after ssh to the server, run $screen and then press Ctr-a+c to create a terminal. Changing to others terminal by pressing Ctr-a+n or Ctr-a+p or Ctr-a Ctr-a or Ctr-a "number of terminal".

At home, ssh to the server and resume the screen by $screen -d -r.

References:
http://www.debianclub.com/node/22
http://mm.co.th/poonlap/node/251

GSpace and Zip

2006-11-13T16:07:00.000Z

Using GSpace extension in Firefox to backup files in gamil account is very interesting option. We've got more than 2.7 GB space for one gmail account.

Using zip/unzip with password protection is very easy. For example, if we wanna compress directory XXX-directory and use password protection, we can use
zip -r XXX-filename.zip XXX-directory -e
.
Zip will ask us to type a password.

Eclipse's shortcut

2006-11-01T11:44:00.000Z

Ctrl+PgUp/PgDown : used to switch left and right between tabs.
Ctrl+F6 : switched between the files opened in the editor's tab.
Ctrl+SpaceBar : complete typing.

No sound in Ubuntu Edgy (IBM R50e)

2006-10-28T18:50:00.000+01:00

The solution is here http://www.ubuntux.org/no-sound-on-ubuntu-dapper.

Cool pictures

2006-10-27T23:56:00.000+01:00

Friends of mine

OpenOffice.org in Ubuntu 6.06

2006-10-16T01:42:00.000+01:00

If you want to use Thai feature in OpenOffice.org 2.0, click Tools->Options and select Language Settings -> Language Tab . Choose Thai for CTL as in the image below.

Do not move /var directory ...?

2006-09-25T14:06:00.000+01:00

Do not move /var directory into another partition and make a link to it cos Gnome Desktop will be delay for a long time before starting a GUI screen.

When /var is moved to another partition, lo ( locale network ) will not start correctly and affect to Gnome Desktop.

Start date on Blogger

2006-09-13T16:11:00.000+01:00

Today is Wednesday, 13 September 2006.