Browse Source

In UNIXTimer.c, callback function is called every time the callback function is called
Fix to reconfigure.
(Add signal () in UNIXTimer_ON ())
(In IRIX, coping with the fact that the callback function is cleared for each call)

Since ualarm () is BSD dependent, it is modified to use alarm ().

Unit Timer class interval time setting unit changed from microseconds to milliseconds.

Supports serial communication. (See WonxSerialPort, WWSerialPort, comm.c)

With printf () in key.c, when the function name was not displayed when displaying the return value
Fix.

Version 0.4 beta - from wonx-b04.tar.gz

Hiroaki Sakai 23 years ago
parent
commit
96b108c909
24 changed files with 875 additions and 56 deletions
  1. 21 0
      HISTORY
  2. 3 3
      Makefile
  3. 0 1
      README
  4. 25 15
      UNIXTimer.c
  5. 1 1
      UNIXTimerP.h
  6. 5 5
      WWDisplay.c
  7. 1 1
      WWScreen.c
  8. 3 3
      WWScreen.h
  9. 1 1
      WWScreenP.h
  10. 84 0
      WWSerialPort.c
  11. 67 0
      WWSerialPort.h
  12. 39 0
      WWSerialPortP.h
  13. 8 0
      Wonx.c
  14. 2 0
      Wonx.h
  15. 1 0
      WonxP.h
  16. 59 0
      WonxSerialPort.c
  17. 35 0
      WonxSerialPort.h
  18. 26 0
      WonxSerialPortP.h
  19. 0 2
      WonxSystem.c
  20. 469 11
      comm.c
  21. 4 4
      disp.c
  22. 12 6
      key.c
  23. 1 1
      text.c
  24. 8 2
      wonx_configure.h

+ 21 - 0
HISTORY

@@ -1,3 +1,24 @@
+2000/11/18(土)
+
+wonx-b04 公開
+
+UNIXTimer.c で,コールバック関数が呼ばれるたびにコールバック関数を
+設定しなおすように修正.
+(UNIXTimer_ON() 中に signal() を追加)
+(IRIX ではコール毎にコールバック関数がクリアされてしまうことへの対処)
+
+ualarm() は BSD 依存なので,alarm() を使用するように修正.
+
+UNIXTimer クラスのインターバル時間の設定の単位をマイクロ秒からミリ秒に変更.
+
+シリアル通信をサポート.(WonxSerialPort, WWSerialPort, comm.c 参照)
+
+key.c 中の printf() で,戻り値の表示の際に関数名が表示されていなかったのを
+修正.
+
+
+
+
 2000/11/13(月)
 
 wonx-b03 公開

+ 3 - 3
Makefile

@@ -2,12 +2,12 @@ XINCLUDEDIR = /usr/X11R6/include
 INCLUDEDIR = .
 XLIBDIR = /usr/X11R6/lib
 
-VERSION = Wonx-b03
-PKGNAME = wonx-b03
+VERSION = Wonx-b04
+PKGNAME = wonx-b04
 
 SMAC = smac-b02
 
-OBJS = WWCharacter.o WWColorMap.o WWDisplay.o WWLCDPanel.o WWPalette.o WWScreen.o WWSprite.o WWText.o WWInterrupt.o WWTimer.o Wonx.o WonxDisplay.o WonxText.o WonxSystem.o XDisplay.o UNIXTimer.o bank.o comm.o disp.o text.o key.o sound.o system.o timer.o etc.o
+OBJS = WWCharacter.o WWColorMap.o WWDisplay.o WWLCDPanel.o WWPalette.o WWScreen.o WWSprite.o WWText.o WWInterrupt.o WWTimer.o WWSerialPort.o Wonx.o WonxDisplay.o WonxText.o WonxSystem.o WonxSerialPort.o XDisplay.o UNIXTimer.o bank.o comm.o disp.o text.o key.o sound.o system.o timer.o etc.o
 
 CC = gcc
 

+ 0 - 1
README

@@ -329,7 +329,6 @@ wonx 
 関数を呼び出しても,何も起こりません.(空の関数になっている)
 
 ・サウンド
-・シリアル通信
 ・その他いっぱい
 
 ■ 注意しなければならないこと

+ 25 - 15
UNIXTimer.c

@@ -25,9 +25,9 @@ static void UNIXTimer_CallBackFunction(int argument)
   int ret;
 
   /*
-    static なフラグを立てて,コールバック関数からコールバック関数が
-    呼ばれたのを検出するのが必要かも.
-    */
+   * static なフラグを立てて,コールバック関数からコールバック関数が
+   * 呼ばれたのを検出するのが必要かも.
+   */
 
   if (pointed_unix_timer == NULL) return;
   if (!pointed_unix_timer->timer_on) return;
@@ -101,9 +101,29 @@ static void UNIXTimer_CallBackFunction(int argument)
 
 int UNIXTimer_ON(UNIXTimer unix_timer)
 {
+  int t;
+
   unix_timer->timer_on = 1;
   pointed_unix_timer = unix_timer;
-  ualarm(unix_timer->interval, 0);
+
+  /*
+   * SIGALRM を使用するので,sleep() 中にアラームが起きた場合には,
+   * コールバック関数からの復帰後に sleep() の残り時間は継続されない.
+   */
+  signal(SIGALRM, UNIXTimer_CallBackFunction);
+
+#if 0 /* use ualarm() */
+  /* ualarm(); の引数に0を用いてはダメなので */
+  t = unix_timer->interval * 1000;
+  if (t < 1) t = 1;
+  ualarm(t, 0);
+#else /* use alarm() */
+  /* alarm(); の引数に0を用いてはダメなので */
+  t = unix_timer->interval / 1000;
+  if (t < 1) t = 1;
+  alarm(t);
+#endif
+
   return (0);
 }
 
@@ -207,11 +227,7 @@ int UNIXTimer_IsAutoPreset(UNIXTimer unix_timer)
 int UNIXTimer_GetInterval(UNIXTimer unix_timer)
 { return (unix_timer->interval); }
 int UNIXTimer_SetInterval(UNIXTimer unix_timer, int interval)
-{
-  /* ualarm(); の引数に0を用いてはダメなので */
-  if (interval < 1) interval = 1;
-  return (unix_timer->interval = interval);
-}
+{ return (unix_timer->interval = interval); }
 
 /*---------------------------------------------------------------------------*/
 /* コールバック関数の呼び出し時のパラメータ                                  */
@@ -260,12 +276,6 @@ UNIXTimer UNIXTimer_Create(int auto_preset, int interval, void * parameter,
   UNIXTimer_SetParameter(unix_timer, parameter);
   UNIXTimer_SetCallBack(unix_timer, callback);
 
-  /*
-   * SIGALRM を使用するので,sleep() 中にアラームが起きた場合には,
-   * コールバック関数からの復帰後に sleep() の残り時間は継続されない.
-   */
-  signal(SIGALRM, UNIXTimer_CallBackFunction);
-
   return (unix_timer);
 }
 

+ 1 - 1
UNIXTimerP.h

@@ -32,7 +32,7 @@ typedef struct _UNIXTimer {
   int interrupt_in_pause;
 
   int auto_preset; /* オートプリセット.1 だとオートプリセットを行う */
-  int interval; /* タイマのインターバル.マイクロ秒で指定 */
+  int interval; /* タイマのインターバル.ミリ秒で指定 */
   void * parameter; /* コールバック関数の呼び出し時のパラメータ */
   UNIXTimerCallBack callback; /* コールバック関数 */
 

+ 5 - 5
WWDisplay.c

@@ -214,8 +214,8 @@ static int WWDisplay_DrawScreen(WWDisplay display, WWScreen screen)
   lcd_panel_width  = WWLCDPanel_GetWidth( lcd_panel);
   lcd_panel_height = WWLCDPanel_GetHeight(lcd_panel);
 
-  if ( (WWScreen_GetMode(screen) == WWSCREEN_INSIDE_ONLY) ||
-       (WWScreen_GetMode(screen) == WWSCREEN_OUTSIDE_ONLY) ) {
+  if ( (WWScreen_GetMode(screen) == WW_SCREEN_INSIDE_ONLY) ||
+       (WWScreen_GetMode(screen) == WW_SCREEN_OUTSIDE_ONLY) ) {
     sx = WWScreen_GetDrawX(screen);
     sy = WWScreen_GetDrawX(screen);
 
@@ -246,7 +246,7 @@ static int WWDisplay_DrawScreen(WWDisplay display, WWScreen screen)
 
   for (y = 0; y < lcd_panel_height; y++) {
 
-    if (mode == WWSCREEN_INSIDE_ONLY) {
+    if (mode == WW_SCREEN_INSIDE_ONLY) {
       if (y > ey) { break; }
       if (y < sy) { y = sy - 1; continue; }
     }
@@ -255,10 +255,10 @@ static int WWDisplay_DrawScreen(WWDisplay display, WWScreen screen)
 
     for (x = 0; x < lcd_panel_width; x++) {
 
-      if (mode == WWSCREEN_INSIDE_ONLY) {
+      if (mode == WW_SCREEN_INSIDE_ONLY) {
 	if (x > ex) { x = lcd_panel_width - 1; continue; }
 	if (x < sx) { x = sx - 1; continue; }
-      } else if (mode == WWSCREEN_OUTSIDE_ONLY) {
+      } else if (mode == WW_SCREEN_OUTSIDE_ONLY) {
 	if ( (x >= sx) && (x <= ex) && (y >= sy) && (y <= ey) ) {
 	  x = ex;
 	  continue;

+ 1 - 1
WWScreen.c

@@ -210,7 +210,7 @@ WWScreen WWScreen_Create(int number,
   WWScreen_SetRollY( screen, 0);
 
   WWScreen_SetEnable(screen, 1);
-  WWScreen_SetMode(  screen, WWSCREEN_DRAW_ALL);
+  WWScreen_SetMode(  screen, WW_SCREEN_DRAW_ALL);
 
   WWScreen_SetDrawX( screen, draw_x);
   WWScreen_SetDrawY( screen, draw_y);

+ 3 - 3
WWScreen.h

@@ -20,9 +20,9 @@ typedef struct _WWScreen * WWScreen;
 /* 定数の定義                                                                */
 /*****************************************************************************/
 
-#define WWSCREEN_DRAW_ALL     0
-#define WWSCREEN_INSIDE_ONLY  1
-#define WWSCREEN_OUTSIDE_ONLY 2
+#define WW_SCREEN_DRAW_ALL     0
+#define WW_SCREEN_INSIDE_ONLY  1
+#define WW_SCREEN_OUTSIDE_ONLY 2
 
 /*****************************************************************************/
 /* メンバ関数の宣言                                                          */

+ 1 - 1
WWScreenP.h

@@ -33,7 +33,7 @@ typedef struct _WWScreen {
   int enable; /* 表示/非表示のフラグ */
 
   int mode; /* 表示モード */
-  /* WWSCREEN_DRAW_ALL, WWSCREEN_INSIDE_ONLY, WWSCREEN_OUTSIDE_ONLY の */
+  /* WW_SCREEN_DRAW_ALL, WW_SCREEN_INSIDE_ONLY, WW_SCREEN_OUTSIDE_ONLY の */
   /* いずれかの値を取る                                                */
 
   /* 表示領域(スクリーン2のウインドウ機能用.スクリーン1では未使用) */

+ 84 - 0
WWSerialPort.c

@@ -0,0 +1,84 @@
+/*****************************************************************************/
+/* ここから                                                                  */
+/*****************************************************************************/
+
+#include "WWSerialPortP.h"
+#include "etc.h"
+
+/*****************************************************************************/
+/* メンバ関数の定義                                                          */
+/*****************************************************************************/
+
+int WWSerialPort_ON(   WWSerialPort s) { return (s->port_on =  1); }
+int WWSerialPort_OFF(  WWSerialPort s) { return (s->port_on =  0); }
+int WWSerialPort_IsON( WWSerialPort s) { return (s->port_on != 0); }
+int WWSerialPort_IsOFF(WWSerialPort s) { return (s->port_on == 0); }
+
+int WWSerialPort_GetBaudrate(WWSerialPort s) { return (s->baudrate); }
+int WWSerialPort_SetBaudrate(WWSerialPort s, int baudrate)
+{ return (s->baudrate = baudrate); }
+
+int WWSerialPort_SetBaudrate9600(WWSerialPort s)
+{ return (WWSerialPort_SetBaudrate(s, WW_SERIAL_PORT_BAUDRATE_9600)); }
+int WWSerialPort_SetBaudrate38400(WWSerialPort s)
+{ return (WWSerialPort_SetBaudrate(s, WW_SERIAL_PORT_BAUDRATE_38400)); }
+int WWSerialPort_IsBaudrate9600(WWSerialPort s)
+{ return (WWSerialPort_GetBaudrate(s) == WW_SERIAL_PORT_BAUDRATE_9600); }
+int WWSerialPort_IsBaudrate38400(WWSerialPort s)
+{ return (WWSerialPort_GetBaudrate(s) == WW_SERIAL_PORT_BAUDRATE_38400); }
+
+int WWSerialPort_GetSendTimeout(WWSerialPort s)
+{ return (s->send_timeout); }
+int WWSerialPort_SetSendTimeout(WWSerialPort s, int timeout)
+{ return (s->send_timeout = timeout); }
+int WWSerialPort_GetReceiveTimeout(WWSerialPort s)
+{ return (s->receive_timeout); }
+int WWSerialPort_SetReceiveTimeout(WWSerialPort s, int timeout)
+{ return (s->receive_timeout = timeout); }
+
+unsigned int WWSerialPort_GetCancelKey(WWSerialPort s)
+{ return (s->cancel_key); }
+unsigned int WWSerialPort_SetCancelKey(WWSerialPort s, int cancel_key)
+{ return (s->cancel_key = cancel_key); }
+
+/*---------------------------------------------------------------------------*/
+/* オブジェクトの作成                                                        */
+/*---------------------------------------------------------------------------*/
+
+WWSerialPort WWSerialPort_Create()
+{
+  WWSerialPort ww_serial_port;
+
+  ww_serial_port = (WWSerialPort)malloc(sizeof(_WWSerialPort));
+  if (ww_serial_port == NULL)
+    Wonx_Error("WWSerialPort_Create", "Cannot allocate memory.");
+
+  WWSerialPort_OFF(ww_serial_port);
+  WWSerialPort_SetBaudrate38400(ww_serial_port);
+  WWSerialPort_SetSendTimeout(ww_serial_port, 100);
+  WWSerialPort_SetReceiveTimeout(ww_serial_port, 100);
+
+  return (ww_serial_port);
+}
+
+/*---------------------------------------------------------------------------*/
+/* オブジェクトの削除                                                        */
+/*---------------------------------------------------------------------------*/
+
+WWSerialPort WWSerialPort_Destroy(WWSerialPort ww_serial_port)
+{
+  if (ww_serial_port == NULL)
+    Wonx_Error("WWSerialPort_Destroy", "Object is not created.");
+
+  free(ww_serial_port);
+
+  return (NULL);
+}
+
+/*****************************************************************************/
+/* ここまで                                                                  */
+/*****************************************************************************/
+
+/*****************************************************************************/
+/* End of File.                                                              */
+/*****************************************************************************/

+ 67 - 0
WWSerialPort.h

@@ -0,0 +1,67 @@
+#ifndef _WWSerialPort_h_INCLUDED_
+#define _WWSerialPort_h_INCLUDED_
+
+/*****************************************************************************/
+/* ここから                                                                  */
+/*****************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "wonx_include/comm.h"
+
+#define WW_SERIAL_PORT_BAUDRATE_9600  0
+#define WW_SERIAL_PORT_BAUDRATE_38400 1
+
+/*****************************************************************************/
+/* クラスの定義                                                              */
+/*****************************************************************************/
+
+typedef struct _WWSerialPort * WWSerialPort;
+
+/*****************************************************************************/
+/* メンバ関数の宣言                                                          */
+/*****************************************************************************/
+
+int WWSerialPort_ON(   WWSerialPort s);
+int WWSerialPort_OFF(  WWSerialPort s);
+int WWSerialPort_IsON( WWSerialPort s);
+int WWSerialPort_IsOFF(WWSerialPort s);
+
+int WWSerialPort_GetBaudrate(WWSerialPort s);
+int WWSerialPort_SetBaudrate(WWSerialPort s, int baudrate);
+
+int WWSerialPort_SetBaudrate9600(WWSerialPort s);
+int WWSerialPort_SetBaudrate38400(WWSerialPort s);
+int WWSerialPort_IsBaudrate9600(WWSerialPort s);
+int WWSerialPort_IsBaudrate38400(WWSerialPort s);
+
+int WWSerialPort_GetSendTimeout(WWSerialPort s);
+int WWSerialPort_SetSendTimeout(WWSerialPort s, int timeout);
+int WWSerialPort_GetReceiveTimeout(WWSerialPort s);
+int WWSerialPort_SetReceiveTimeout(WWSerialPort s, int timeout);
+
+unsigned int WWSerialPort_GetCancelKey(WWSerialPort s);
+unsigned int WWSerialPort_SetCancelKey(WWSerialPort s, int cancel_key);
+
+/*---------------------------------------------------------------------------*/
+/* オブジェクトの作成                                                        */
+/*---------------------------------------------------------------------------*/
+
+WWSerialPort WWSerialPort_Create();
+
+/*---------------------------------------------------------------------------*/
+/* オブジェクトの削除                                                        */
+/*---------------------------------------------------------------------------*/
+
+WWSerialPort WWSerialPort_Destroy(WWSerialPort ww_serial_port);
+
+/*****************************************************************************/
+/* ここまで                                                                  */
+/*****************************************************************************/
+
+#endif
+
+/*****************************************************************************/
+/* End of File.                                                              */
+/*****************************************************************************/

+ 39 - 0
WWSerialPortP.h

@@ -0,0 +1,39 @@
+#ifndef _WWSerialPortP_h_INCLUDED_
+#define _WWSerialPortP_h_INCLUDED_
+
+/*****************************************************************************/
+/* ここから                                                                  */
+/*****************************************************************************/
+
+#include "WWSerialPort.h"
+
+/*****************************************************************************/
+/* クラスの定義                                                              */
+/*****************************************************************************/
+
+typedef struct _WWSerialPort {
+
+  int port_on; /* ポートの状態 */
+  int baudrate; /* ボーレート */
+
+  /*
+   * タイムアウト時間
+   * 本来は VBLANK 単位で指定するのだが,wonx では
+   * WONX_SERIAL_PORT_TIMETICKS 単位で指定することにする.
+   */
+  int send_timeout;
+  int receive_timeout;
+
+  unsigned int cancel_key;
+
+} _WWSerialPort;
+
+/*****************************************************************************/
+/* ここまで                                                                  */
+/*****************************************************************************/
+
+#endif
+
+/*****************************************************************************/
+/* End of File.                                                              */
+/*****************************************************************************/

+ 8 - 0
Wonx.c

@@ -4,6 +4,7 @@
 #include "wonx_include/disp.h"
 #include "wonx_include/text.h"
 #include "wonx_include/system.h"
+#include "wonx_include/comm.h"
 
 /*****************************************************************************/
 /* ¥Ç¥£¥¹¥×¥ì¥¤¤Î³ÎÊÝ                                                        */
@@ -40,6 +41,8 @@ void Wonx_Create(void)
 
   wonx->wonx_system = WonxSystem_Create();
 
+  wonx->wonx_serial_port = WonxSerialPort_Create();
+
   return;
 }
 
@@ -58,3 +61,8 @@ WonxSystem Wonx_GetWonxSystem(void)
   return (wonx->wonx_system);
 }
 
+WonxSerialPort Wonx_GetWonxSerialPort(void)
+{
+  return (wonx->wonx_serial_port);
+}
+

+ 2 - 0
Wonx.h

@@ -4,6 +4,7 @@
 #include "WonxDisplay.h"
 #include "WonxText.h"
 #include "WonxSystem.h"
+#include "WonxSerialPort.h"
 
 /*****************************************************************************/
 /* ¥Ç¥£¥¹¥×¥ì¥¤¤Î³ÎÊÝ                                                        */
@@ -14,5 +15,6 @@ void Wonx_Create(void);
 WonxDisplay Wonx_GetWonxDisplay(void);
 WonxText Wonx_GetWonxText(void);
 WonxSystem Wonx_GetWonxSystem(void);
+WonxSerialPort Wonx_GetWonxSerialPort(void);
 
 #endif

+ 1 - 0
WonxP.h

@@ -15,6 +15,7 @@ typedef struct _Wonx {
   WonxDisplay wonx_display;
   WonxText wonx_text;
   WonxSystem wonx_system;
+  WonxSerialPort wonx_serial_port;
 } _Wonx;
 
 typedef struct _Wonx * Wonx;

+ 59 - 0
WonxSerialPort.c

@@ -0,0 +1,59 @@
+/*****************************************************************************/
+/* ここから                                                                  */
+/*****************************************************************************/
+
+#include "WonxSerialPortP.h"
+#include "etc.h"
+
+/*****************************************************************************/
+/* メンバ関数の定義                                                          */
+/*****************************************************************************/
+
+WWSerialPort WonxSerialPort_GetWWSerialPort(WonxSerialPort wonx_serial_port)
+{ return (wonx_serial_port->ww_serial_port); }
+WWSerialPort WonxSerialPort_SetWWSerialPort(WonxSerialPort wonx_serial_port,
+					    WWSerialPort ww_serial_port)
+{ return (wonx_serial_port->ww_serial_port = ww_serial_port); }
+
+WonxSerialPort WonxSerialPort_Create()
+{
+  WonxSerialPort wonx_serial_port;
+  WWSerialPort ww_serial_port;
+
+  wonx_serial_port = (WonxSerialPort)malloc(sizeof(_WonxSerialPort));
+  if (wonx_serial_port == NULL)
+    Wonx_Error("WonxSerialPort_Create", "Cannot allocate memory.");
+
+  ww_serial_port = WWSerialPort_Create();
+  if (ww_serial_port == NULL)
+    Wonx_Error("WonxSerialPort_Create",
+	       "Cannot create WonderWitch serial port.");
+  WonxSerialPort_SetWWSerialPort(wonx_serial_port, ww_serial_port);
+
+  return (wonx_serial_port);
+}
+
+WonxSerialPort WonxSerialPort_Destroy(WonxSerialPort wonx_serial_port)
+{
+  WWSerialPort ww_serial_port;
+
+  if (wonx_serial_port == NULL)
+    Wonx_Error("WonxSerialPort_Destroy", "Object is not created.");
+
+  ww_serial_port = WonxSerialPort_GetWWSerialPort(wonx_serial_port);
+  if (ww_serial_port)
+    WonxSerialPort_SetWWSerialPort(wonx_serial_port,
+				   WWSerialPort_Destroy(ww_serial_port));
+
+  free(wonx_serial_port);
+
+  return (NULL);
+}
+
+/*****************************************************************************/
+/* ここまで                                                                  */
+/*****************************************************************************/
+
+/*****************************************************************************/
+/* End of File.                                                              */
+/*****************************************************************************/

+ 35 - 0
WonxSerialPort.h

@@ -0,0 +1,35 @@
+#ifndef _WonxSerialPort_h_INCLUDED_
+#define _WonxSerialPort_h_INCLUDED_
+
+/*****************************************************************************/
+/* ここから                                                                  */
+/*****************************************************************************/
+
+#include "WWSerialPort.h"
+
+/*****************************************************************************/
+/* クラスの定義                                                              */
+/*****************************************************************************/
+
+typedef struct _WonxSerialPort * WonxSerialPort;
+
+/*****************************************************************************/
+/* メンバ関数の定義                                                          */
+/*****************************************************************************/
+
+WWSerialPort WonxSerialPort_GetWWSerialPort(WonxSerialPort wonx_serial_port);
+WWSerialPort WonxSerialPort_SetWWSerialPort(WonxSerialPort wonx_serial_port,
+					    WWSerialPort ww_serial_port);
+
+WonxSerialPort WonxSerialPort_Create();
+WonxSerialPort WonxSerialPort_Destroy(WonxSerialPort wonx_serial_port);
+
+/*****************************************************************************/
+/* ここまで                                                                  */
+/*****************************************************************************/
+
+#endif
+
+/*****************************************************************************/
+/* End of File.                                                              */
+/*****************************************************************************/

+ 26 - 0
WonxSerialPortP.h

@@ -0,0 +1,26 @@
+#ifndef _WonxSerialPortP_h_INCLUDED_
+#define _WonxSerialPortP_h_INCLUDED_
+
+/*****************************************************************************/
+/* ここから                                                                  */
+/*****************************************************************************/
+
+#include "WonxSerialPort.h"
+
+/*****************************************************************************/
+/* クラスの定義                                                              */
+/*****************************************************************************/
+
+typedef struct _WonxSerialPort {
+  WWSerialPort ww_serial_port;
+} _WonxSerialPort;
+
+/*****************************************************************************/
+/* ここまで                                                                  */
+/*****************************************************************************/
+
+#endif
+
+/*****************************************************************************/
+/* End of File.                                                              */
+/*****************************************************************************/

+ 0 - 2
WonxSystem.c

@@ -87,7 +87,6 @@ WonxSystem WonxSystem_Create()
     Wonx_Error("WonxSystem_Create", "Cannot create WonderWitch interrupt.");
   WonxSystem_SetWWInterrupt(wonx_system, ww_interrupt);
 
-  /* VBlank は WONX_VBLANK_INTERVAL * 0.1 秒毎とする */
   ww_timer = WWTimer_Create(1, WONX_VBLANK_INTERVAL);
   if (ww_timer == NULL)
     Wonx_Error("WonxSystem_Create", "Cannot create WonderWitch VBlank timer.");
@@ -113,7 +112,6 @@ WonxSystem WonxSystem_Create()
   WWTimer_OFF(WonxSystem_GetWWVBlankCountUpTimer(wonx_system));
   WWTimer_OFF(WonxSystem_GetWWHBlankCountUpTimer(wonx_system));
 
-  /* タイマのインターバルは,0.1 秒単位とする */
   unix_timer = UNIXTimer_Create(1, WONX_TIMER_INTERVAL, wonx_system,
 				(UNIXTimerCallBack)WonxTimer_Callback);
   if (unix_timer == NULL)

+ 469 - 11
comm.c

@@ -4,10 +4,17 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/time.h>
 
 #include "wonx_include/comm.h"
 
+#include "wonx_configure.h"
 #include "Wonx.h"
+#include "etc.h"
 
 /*****************************************************************************/
 /* 互換関数の定義                                                            */
@@ -30,66 +37,517 @@
  */
 
 void comm_open(void)
-{}
+{
+  WWSerialPort ww_serial_port;
+
+  if (!Wonx_IsCreated()) Wonx_Create();
+
+  /* タイマを一時停止する */
+  UNIXTimer_Pause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  printf("call : comm_open() : \n");
+  fflush(stdout);
+
+  ww_serial_port = WonxSerialPort_GetWWSerialPort(Wonx_GetWonxSerialPort());
+
+  if (WWSerialPort_IsON(ww_serial_port))
+    Wonx_Error("comm_open", "Serial port has already opened.");
+
+  WWSerialPort_ON(ww_serial_port);
+
+  WonxDisplay_Sync(Wonx_GetWonxDisplay());
+
+  printf("call : comm_open() : return value = none\n");
+  fflush(stdout);
+
+  /* タイマをもとに戻す */
+  UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  return;
+}
 
 void comm_close(void)
-{}
+{
+  WWSerialPort ww_serial_port;
+
+  if (!Wonx_IsCreated()) Wonx_Create();
+
+  /* タイマを一時停止する */
+  UNIXTimer_Pause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  printf("call : comm_close() : \n");
+  fflush(stdout);
+
+  ww_serial_port = WonxSerialPort_GetWWSerialPort(Wonx_GetWonxSerialPort());
+
+  if (!WWSerialPort_IsON(ww_serial_port))
+    Wonx_Error("comm_close", "Serial port is not opened.");
+
+  WWSerialPort_OFF(ww_serial_port);
+
+  WonxDisplay_Sync(Wonx_GetWonxDisplay());
+
+  printf("call : comm_close() : return value = none\n");
+  fflush(stdout);
+
+  /* タイマをもとに戻す */
+  UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  return;
+}
+
+static void comm_output(unsigned char c)
+{
+  if      (c == '\n') printf("\\n");
+  else if (c == '\r') printf("\\r");
+  else if (c == '\t') printf("\\t");
+  else if (isprint(c)) fputc(c, stdout);
+  else printf("^%02x", (int)c);
+  fflush(stdout);
+  return;
+}
+
+static int comm_input(int timeout)
+{
+  int tmp;
+  int c;
+  fd_set bitmap;
+  struct timeval t;
+  struct timeval * t_p;
+
+  /*
+   * 0 のときは,即時
+   * -1 のときは,無期限待ち
+   */
+  if (timeout == -1) {
+    t_p = NULL;
+  } else {
+    tmp = WONX_SERIAL_PORT_TIMETICKS * timeout;
+    t.tv_sec  =  tmp / 1000;
+    t.tv_usec = (tmp % 1000) * 1000;
+    t_p = &t;
+  }
+
+  FD_ZERO(&bitmap);
+  FD_SET(fileno(stdin), &bitmap);
+
+  /*
+   * FreeBSD3.4 で実験したところ,
+   * アラームシグナルを使用する場合,select()でのブロック中に
+   * アラームシグナルが発生すると,その直後にselect()もタイムアウト
+   * してしまうので,注意.
+   * (select() がタイムアウトした後にアラームシグナルが発生する場合は,
+   *  正常に動作した)
+   * 論理上は問題が無いが,期待した時間だけ待ってくれないという現象が
+   * 起きる可能性がある.
+   */
+  select(fileno(stdin) + 1, &bitmap, NULL, NULL, t_p);
+
+  c = FD_ISSET(fileno(stdin), &bitmap) ? fgetc(stdin) : -1;
+
+  return (c);
+}
 
 int comm_send_char(unsigned char c)
 {
-  return (0);
+  int ret;
+
+  WWSerialPort ww_serial_port;
+
+  if (!Wonx_IsCreated()) Wonx_Create();
+
+  /* タイマを一時停止する */
+  UNIXTimer_Pause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  printf("call : comm_send_char() : character = 0x%02x\n", (int)c);
+  fflush(stdout);
+
+  ww_serial_port = WonxSerialPort_GetWWSerialPort(Wonx_GetWonxSerialPort());
+
+  if (!WWSerialPort_IsON(ww_serial_port))
+    Wonx_Error("comm_send_char", "Serial port is not opened.");
+
+  printf("output to serial port : ");
+  comm_output(c);
+  printf("\n");
+  fflush(stdout);
+  ret = 0;
+
+  WonxDisplay_Sync(Wonx_GetWonxDisplay());
+
+  printf("call : comm_send_char() : return value = %d\n", ret);
+  fflush(stdout);
+
+  /* タイマをもとに戻す */
+  UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  return (ret);
 }
 
 int comm_receive_char(void)
 {
-  return (0);
+  WWSerialPort ww_serial_port;
+  int c;
+  int ret;
+
+  if (!Wonx_IsCreated()) Wonx_Create();
+
+  /* タイマを一時停止する */
+  UNIXTimer_Pause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  printf("call : comm_receive_char() : \n");
+  fflush(stdout);
+
+  ww_serial_port = WonxSerialPort_GetWWSerialPort(Wonx_GetWonxSerialPort());
+
+  if (!WWSerialPort_IsON(ww_serial_port))
+    Wonx_Error("comm_receive_char", "Serial port is not opened.");
+
+  c = comm_input(WWSerialPort_GetReceiveTimeout(ww_serial_port));
+
+  if (c == -1) ret = ERR_SIO_TIMEOUT;
+  else ret = c;
+
+  WonxDisplay_Sync(Wonx_GetWonxDisplay());
+
+  printf("call : comm_receive_char() : return value = %d\n", ret);
+  fflush(stdout);
+
+  /* タイマをもとに戻す */
+  UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  return (ret);
 }
 
 int comm_receive_with_timeout(int timeout)
 {
-  return (0);
+  WWSerialPort ww_serial_port;
+  int c;
+  int ret;
+
+  if (!Wonx_IsCreated()) Wonx_Create();
+
+  /* タイマを一時停止する */
+  UNIXTimer_Pause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  printf("call : comm_receive_with_timeout() : timeout = %d\n", timeout);
+  fflush(stdout);
+
+  ww_serial_port = WonxSerialPort_GetWWSerialPort(Wonx_GetWonxSerialPort());
+
+  if (!WWSerialPort_IsON(ww_serial_port))
+    Wonx_Error("comm_receive_with_timeout", "Serial port is not opened.");
+
+  c = comm_input(timeout);
+
+  if (c == -1) ret = ERR_SIO_TIMEOUT;
+  else ret = c;
+
+  WonxDisplay_Sync(Wonx_GetWonxDisplay());
+
+  printf("call : comm_receive_with_timeout() : return value = %d\n", ret);
+  fflush(stdout);
+
+  /* タイマをもとに戻す */
+  UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  return (ret);
 }
 
 int comm_send_string(char * string)
 {
-  return (0);
+  WWSerialPort ww_serial_port;
+  int ret;
+  int i;
+
+  if (!Wonx_IsCreated()) Wonx_Create();
+
+  /* タイマを一時停止する */
+  UNIXTimer_Pause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  printf("call : comm_send_string() : string = %s\n", string);
+  fflush(stdout);
+
+  ww_serial_port = WonxSerialPort_GetWWSerialPort(Wonx_GetWonxSerialPort());
+
+  if (!WWSerialPort_IsON(ww_serial_port))
+    Wonx_Error("comm_send_string", "Serial port is not opened.");
+
+  printf("output to serial port : ");
+  for (i = 0; string[i]; i++) {
+    comm_output(string[i]);
+  }
+  printf("\n");
+  fflush(stdout);
+  ret = 0;
+
+  WonxDisplay_Sync(Wonx_GetWonxDisplay());
+
+  printf("call : comm_send_string() : return value = %d\n", ret);
+  fflush(stdout);
+
+  /* タイマをもとに戻す */
+  UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  return (ret);
 }
 
 int comm_send_block(void * buffer, int size)
 {
-  return (0);
+  WWSerialPort ww_serial_port;
+  int ret;
+  int i;
+
+  if (!Wonx_IsCreated()) Wonx_Create();
+
+  /* タイマを一時停止する */
+  UNIXTimer_Pause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  printf("call : comm_send_block() : buffer = %p, size = %d\n", buffer, size);
+  fflush(stdout);
+
+  ww_serial_port = WonxSerialPort_GetWWSerialPort(Wonx_GetWonxSerialPort());
+
+  if (!WWSerialPort_IsON(ww_serial_port))
+    Wonx_Error("comm_send_block", "Serial port is not opened.");
+
+  printf("output to serial port : ");
+  for (i = 0; i < size; i++) {
+    comm_output(((char *)buffer)[i]);
+  }
+  printf("\n");
+  fflush(stdout);
+  ret = 0;
+
+  WonxDisplay_Sync(Wonx_GetWonxDisplay());
+
+  printf("call : comm_send_block() : return value = %d\n", ret);
+  fflush(stdout);
+
+  /* タイマをもとに戻す */
+  UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  return (ret);
 }
 
 int comm_receive_block(void * buffer, int size)
 {
-  return (0);
+  WWSerialPort ww_serial_port;
+  int ret;
+  int c;
+  int i;
+
+  if (!Wonx_IsCreated()) Wonx_Create();
+
+  /* タイマを一時停止する */
+  UNIXTimer_Pause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  printf("call : comm_receive_block() : buffer = %p, size = %d\n",
+	 buffer, size);
+  fflush(stdout);
+
+  ww_serial_port = WonxSerialPort_GetWWSerialPort(Wonx_GetWonxSerialPort());
+
+  if (!WWSerialPort_IsON(ww_serial_port))
+    Wonx_Error("comm_receive_block", "Serial port is not opened.");
+
+  ret = 0;
+  for (i = 0; i < size; i++) {
+    c = comm_input(WWSerialPort_GetReceiveTimeout(ww_serial_port));
+    if (c == -1) {
+      ret = ERR_SIO_TIMEOUT;
+      break;
+    }
+    ((char *)buffer)[i] = c;
+  }
+
+  WonxDisplay_Sync(Wonx_GetWonxDisplay());
+
+  printf("call : comm_receive_block() : return value = %d\n", ret);
+  fflush(stdout);
+
+  /* タイマをもとに戻す */
+  UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  return (ret);
 }
 
 void comm_set_timeout(int recv_timeout, int send_timeout)
 {
+  WWSerialPort ww_serial_port;
+
+  if (!Wonx_IsCreated()) Wonx_Create();
+
+  /* タイマを一時停止する */
+  UNIXTimer_Pause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  printf("call : comm_set_timeout() : receive_timeout = %d, send_timeout = %d\n", recv_timeout, send_timeout);
+  fflush(stdout);
+
+  ww_serial_port = WonxSerialPort_GetWWSerialPort(Wonx_GetWonxSerialPort());
+
+  WWSerialPort_SetReceiveTimeout(ww_serial_port, recv_timeout);
+  WWSerialPort_SetSendTimeout(   ww_serial_port, send_timeout);
+
+  WonxDisplay_Sync(Wonx_GetWonxDisplay());
+
+  printf("call : comm_set_timeout() : return value = none\n");
+  fflush(stdout);
+
+  /* タイマをもとに戻す */
+  UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  return;
 }
 
 void comm_set_baudrate(int baudrate)
 {
+  WWSerialPort ww_serial_port;
+
+  if (!Wonx_IsCreated()) Wonx_Create();
+
+  /* タイマを一時停止する */
+  UNIXTimer_Pause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  printf("call : comm_set_baudrate() : baudrate = %d\n", baudrate);
+  fflush(stdout);
+
+  ww_serial_port = WonxSerialPort_GetWWSerialPort(Wonx_GetWonxSerialPort());
+
+  switch (baudrate) {
+  case COMM_SPEED_9600:  WWSerialPort_SetBaudrate9600( ww_serial_port); break;
+  case COMM_SPEED_38400: WWSerialPort_SetBaudrate38400(ww_serial_port); break;
+  default: Wonx_Error("comm_set_baudrate", "Invalid baudrate");
+  }
+
+  WonxDisplay_Sync(Wonx_GetWonxDisplay());
+
+  printf("call : comm_set_baudrate() : return value = none\n");
+  fflush(stdout);
+
+  /* タイマをもとに戻す */
+  UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  return;
 }
 
 int comm_get_baudrate(void)
 {
-  return (0);
+  WWSerialPort ww_serial_port;
+  int ret = 0;
+
+  if (!Wonx_IsCreated()) Wonx_Create();
+
+  /* タイマを一時停止する */
+  UNIXTimer_Pause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  printf("call : comm_get_baudrate() : \n");
+  fflush(stdout);
+
+  ww_serial_port = WonxSerialPort_GetWWSerialPort(Wonx_GetWonxSerialPort());
+
+  if (WWSerialPort_IsBaudrate9600(ww_serial_port))
+    ret = COMM_SPEED_9600;
+  else if (WWSerialPort_IsBaudrate38400(ww_serial_port))
+    ret = COMM_SPEED_38400;
+  else Wonx_Error("comm_get_baudrate", "Invalid baudrate");
+
+  WonxDisplay_Sync(Wonx_GetWonxDisplay());
+
+  printf("call : comm_get_baudrate() : return value = %d\n", ret);
+  fflush(stdout);
+
+  /* タイマをもとに戻す */
+  UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  return (ret);
 }
 
 void comm_set_cancel_key(unsigned int pattern)
 {
+  WWSerialPort ww_serial_port;
+
+  if (!Wonx_IsCreated()) Wonx_Create();
+
+  /* タイマを一時停止する */
+  UNIXTimer_Pause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  printf("call : comm_set_cancel_key() : pattern = %u\n", (int)pattern);
+  fflush(stdout);
+
+  ww_serial_port = WonxSerialPort_GetWWSerialPort(Wonx_GetWonxSerialPort());
+
+  WWSerialPort_SetCancelKey(ww_serial_port, pattern);
+
+  WonxDisplay_Sync(Wonx_GetWonxDisplay());
+
+  printf("call : comm_set_cancel_key() : return value = none\n");
+  fflush(stdout);
+
+  /* タイマをもとに戻す */
+  UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  return;
 }
 
 unsigned int comm_get_cancel_key(void)
 {
-  return (0);
+  WWSerialPort ww_serial_port;
+  unsigned int ret;
+
+  if (!Wonx_IsCreated()) Wonx_Create();
+
+  /* タイマを一時停止する */
+  UNIXTimer_Pause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  printf("call : comm_get_cancel_key() : \n");
+  fflush(stdout);
+
+  ww_serial_port = WonxSerialPort_GetWWSerialPort(Wonx_GetWonxSerialPort());
+
+  /* ここに処理を書く */
+  ret = WWSerialPort_GetCancelKey(ww_serial_port);
+
+  WonxDisplay_Sync(Wonx_GetWonxDisplay());
+
+  printf("call : comm_get_cancel_key() : return value = %u\n", (int)ret);
+  fflush(stdout);
+
+  /* タイマをもとに戻す */
+  UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  return (ret);
 }
 
 int comm_xmodem(void * xmodem)
 {
-  return (0);
+  WWSerialPort ww_serial_port;
+  int ret;
+
+  if (!Wonx_IsCreated()) Wonx_Create();
+
+  /* タイマを一時停止する */
+  UNIXTimer_Pause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  printf("call : comm_xmodem() : xmodem = %p\n", xmodem);
+  fflush(stdout);
+
+  ww_serial_port = WonxSerialPort_GetWWSerialPort(Wonx_GetWonxSerialPort());
+
+  /* 未サポート */
+  printf("call : comm_xmodem() : not supported.\n");
+  fflush(stdout);
+  ret = 0;
+
+  WonxDisplay_Sync(Wonx_GetWonxDisplay());
+
+  printf("call : comm_xmodem() : return value = %d\n", ret);
+  fflush(stdout);
+
+  /* タイマをもとに戻す */
+  UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
+
+  return (ret);
 }
 
 /*****************************************************************************/

+ 4 - 4
disp.c

@@ -60,10 +60,10 @@ void display_control(unsigned int flags)
 
   if      ((flags & 0x0030) == DCM_SCR2_WIN_INSIDE)
     WWScreen_SetMode(WWDisplay_GetScreen(ww_display, SCREEN2),
-		     WWSCREEN_INSIDE_ONLY);
+		     WW_SCREEN_INSIDE_ONLY);
   else if ((flags & 0x0030) == DCM_SCR2_WIN_OUTSIDE)
     WWScreen_SetMode(WWDisplay_GetScreen(ww_display, SCREEN2),
-		     WWSCREEN_OUTSIDE_ONLY);
+		     WW_SCREEN_OUTSIDE_ONLY);
 
   WWDisplay_SetBorder(ww_display, (flags & DCM_BORDER_COLOR) >> 7);
 
@@ -106,10 +106,10 @@ unsigned int display_status(void)
     ret |= DCM_SPR_WIN;
 
   switch (WWScreen_GetMode(WWDisplay_GetScreen(ww_display, SCREEN2))) {
-    case WWSCREEN_INSIDE_ONLY:
+    case WW_SCREEN_INSIDE_ONLY:
       ret |= DCM_SCR2_WIN_INSIDE;
       break;
-    case WWSCREEN_OUTSIDE_ONLY:
+    case WW_SCREEN_OUTSIDE_ONLY:
       ret |= DCM_SCR2_WIN_OUTSIDE;
       break;
     default:

+ 12 - 6
key.c

@@ -48,7 +48,8 @@ int key_press_check(void)
 
   WonxDisplay_Sync(Wonx_GetWonxDisplay());
 
-  printf("return value = 0x%04x\n", (int)ret); fflush(stdout);
+  printf("call : key_press_check() : return value = 0x%04x\n", (int)ret);
+  fflush(stdout);
 
   /* タイマをもとに戻す */
   UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
@@ -75,7 +76,8 @@ int key_hit_check(void)
 
   WonxDisplay_Sync(Wonx_GetWonxDisplay());
 
-  printf("return value = 0x%04x\n", (int)ret); fflush(stdout);
+  printf("call : key_hit_check() : return value = 0x%04x\n", (int)ret);
+  fflush(stdout);
 
   /* タイマをもとに戻す */
   UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
@@ -109,7 +111,8 @@ int key_wait(void)
 
   WonxDisplay_Sync(Wonx_GetWonxDisplay());
 
-  printf("return value = 0x%04x\n", (int)ret); fflush(stdout);
+  printf("call : key_wait() : return value = 0x%04x\n", (int)ret);
+  fflush(stdout);
 
   /* タイマをもとに戻す */
   UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
@@ -129,7 +132,7 @@ void key_set_repeat(int rate, int delay)
 
   WonxDisplay_Sync(Wonx_GetWonxDisplay());
 
-  printf("return value = none\n"); fflush(stdout);
+  printf("call : key_set_repeat() : return value = none\n"); fflush(stdout);
 
   /* タイマをもとに戻す */
   UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
@@ -152,7 +155,8 @@ int key_get_repeat(void)
 
   WonxDisplay_Sync(Wonx_GetWonxDisplay());
 
-  printf("return value = 0x%04x\n", (int)ret); fflush(stdout);
+  printf("call : key_get_repeat() : return value = 0x%04x\n", (int)ret);
+  fflush(stdout);
 
   /* タイマをもとに戻す */
   UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));
@@ -179,7 +183,9 @@ int key_hit_check_with_repeat(void)
 
   WonxDisplay_Sync(Wonx_GetWonxDisplay());
 
-  printf("return value = 0x%04x\n", (int)ret); fflush(stdout);
+  printf("call : key_hit_check_with_repeat() : return value = 0x%04x\n",
+	 (int)ret);
+  fflush(stdout);
 
   /* タイマをもとに戻す */
   UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));

+ 1 - 1
text.c

@@ -93,7 +93,7 @@ void text_window_init(int x, int y, int w, int h, unsigned int base)
 
   WonxDisplay_Flush(Wonx_GetWonxDisplay());
 
-  printf("call : text_screen_init() : return value = none\n"); fflush(stdout);
+  printf("call : text_window_init() : return value = none\n"); fflush(stdout);
 
   /* ¥¿¥¤¥Þ¤ò¤â¤È¤ËÌ᤹ */
   UNIXTimer_Unpause(WonxSystem_GetUNIXTimer(Wonx_GetWonxSystem()));

+ 8 - 2
wonx_configure.h

@@ -3,13 +3,19 @@
 #ifndef _WONX_winx_configure_h_INCLUDED_
 #define _WONX_wonx_configure_h_INCLUDED_
 
-/* Wonx でのタイマ割り込みの周期(単位はマイクロ秒) */
-#define WONX_TIMER_INTERVAL 100000 /* 0.1 秒*/
+/* Wonx でのタイマ割り込みの周期(単位はミリ秒) */
+#define WONX_TIMER_INTERVAL 100 /* 0.1 秒 */
 
 /* HBLANK, VBLANK 割り込みのデフォルトのインターバル(0.1秒単位) */
 #define WONX_HBLANK_INTERVAL ( 3 * 10) /*  3 秒毎 */
 #define WONX_VBLANK_INTERVAL (20 * 10) /* 20 秒毎 */
 
+/*
+ * シリアル通信時のタイムアウト時間の単位
+ * (単位はミリ秒だが,そんなに精度は無い)
+ */
+#define WONX_SERIAL_PORT_TIMETICKS 100 /* 1/10 秒単位 */
+
 #endif /* _WONX_wonx_configure_h_INCLUDED_ */
 
 /* End of wonx_configure.h */