Ignore:
Timestamp:
Aug 23, 2017, 9:27:43 AM (7 years ago)
Author:
coas-nagasima
Message:

文字コードを設定

Location:
EcnlProtoTool/trunk/mrbgems/mruby-arduino/src
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/arduino.c

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-csrc to text/x-csrc;charset=UTF-8
    r270 r321  
    1919#include "sRtc.h"
    2020
    21 //バージョンのセット
     21//バージョンのセット
    2222volatile char   ProgVer[] = {WRBB_VERSION};
    2323
     
    2626void mrb_mruby_arduino_gem_init(mrb_state *mrb)
    2727{
    28         kernel_Init(mrb);       /* カーネル関連メソッドの設定 */
    29         sys_Init(mrb);          /* システム関連メソッドの設定 */
    30         serial_Init(mrb);       /* シリアル通信関連メソッドの設定 */
    31         mem_Init(mrb);          /* ファイル関連メソッドの設定 */
    32         i2c_Init(mrb);          /* I2C関連メソッドの設定 */
    33         servo_Init(mrb);        /* サーボ関連メソッドの設定 */
     28        kernel_Init(mrb);       /* カーネル関連メソッドの設定 */
     29        sys_Init(mrb);          /* システム関連メソッドの設定 */
     30        serial_Init(mrb);       /* シリアル通信関連メソッドの設定 */
     31        mem_Init(mrb);          /* ファイル関連メソッドの設定 */
     32        i2c_Init(mrb);          /* I2C関連メソッドの設定 */
     33        servo_Init(mrb);        /* サーボ関連メソッドの設定 */
    3434
    3535#if REALTIMECLOCK
    36         rtc_Init(mrb);          /* RTC関連メソッドの設定 */
     36        rtc_Init(mrb);          /* RTC関連メソッドの設定 */
    3737#endif
    3838
    3939#if FIRMWARE == JAM
    40         pancake_Init(mrb);              /* PanCake関連メソッドの設定 */
     40        pancake_Init(mrb);              /* PanCake関連メソッドの設定 */
    4141#endif
    4242
    4343#if BOARD == BOARD_GR || FIRMWARE == SDBT || FIRMWARE == SDWF
    44         sdcard_Init(mrb);               /* SDカード関連メソッドの設定 */
     44        sdcard_Init(mrb);               /* SDカード関連メソッドの設定 */
    4545#endif
    4646
    4747#if FIRMWARE == SDWF
    48         esp8266_Init(mrb);              /* WiFi関連メソッドの設定 */
     48        esp8266_Init(mrb);              /* WiFi関連メソッドの設定 */
    4949#endif
    5050}
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sI2c.c

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-csrc to text/x-csrc;charset=UTF-8
    r270 r321  
    11/*
    2  * I2C通信関連
     2 * I2C通信関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    2323
    2424/******************************************************/
    25 /* メモリの開放時に走る*/
     25/* メモリの開放時に走る*/
    2626/******************************************************/
    2727static void i2c_free(mrb_state *mrb, void *ptr)
     
    3232
    3333/******************************************************/
    34 /* この構造体の意味はよくわかっていない*/
     34/* この構造体の意味はよくわかっていない*/
    3535/******************************************************/
    3636static struct mrb_data_type i2c_type = {"I2c", i2c_free};
    3737
    3838/******************************************************/
    39 /* I2Cを初期化します: I2c.new*/
    40 /*  I2c.new(num) */
    41 /*  num: 通信番号(0:SDA-0/SCL-1, 1:SDA-5/SCL-6, 2:SDA-7/SCL-8, 3:SDA-12/SCL-11, 4:SDA-9(26)/SCL-3)*/
    42 /**/
    43 /* 戻り値*/
    44 /*  I2cのインスタンス*/
     39/* I2Cを初期化します: I2c.new*/
     40/*  I2c.new(num) */
     41/*  num: 通信番号(0:SDA-0/SCL-1, 1:SDA-5/SCL-6, 2:SDA-7/SCL-8, 3:SDA-12/SCL-11, 4:SDA-9(26)/SCL-3)*/
     42/**/
     43/* 戻り値*/
     44/*  I2cのインスタンス*/
    4545/******************************************************/
    4646static mrb_value mrb_i2c_initialize(mrb_state *mrb, mrb_value self)
     
    5555
    5656        if (num <= 0 && num >= WIRE_MAX) {
    57                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     57                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    5858        }
    5959
     
    6666
    6767/******************************************************/
    68 /* アドレスにデータを書き込みます: I2c.write*/
     68/* アドレスにデータを書き込みます: I2c.write*/
    6969/*  I2c.write( deviceID, address, data )*/
    70 /*      deviceID: デバイスID*/
    71 /*  address: 書き込みアドレス*/
    72 /*  data: データ*/
    73 /**/
    74 /*  戻り値は以下のとおり*/
    75 /*              0: 成功*/
    76 /*              4: その他のエラー*/
     70/*      deviceID: デバイスID*/
     71/*  address: 書き込みアドレス*/
     72/*  data: データ*/
     73/**/
     74/*  戻り値は以下のとおり*/
     75/*              0: 成功*/
     76/*              4: その他のエラー*/
    7777/******************************************************/
    7878mrb_value mrb_i2c_write(mrb_state *mrb, mrb_value self)
     
    8888
    8989/******************************************************/
    90 /* アドレスからデータを読み込み: I2c.read*/
     90/* アドレスからデータを読み込み: I2c.read*/
    9191/*  I2c.read( deviceID, addressL[, addressH] )*/
    92 /*      deviceID: デバイスID*/
    93 /*  addressL: 読み込み下位アドレス*/
    94 /*  addressH: 読み込み上位アドレス*/
    95 /**/
    96 /*  戻り値は読み込んだ値*/
     92/*      deviceID: デバイスID*/
     93/*  addressL: 読み込み下位アドレス*/
     94/*  addressH: 読み込み上位アドレス*/
     95/**/
     96/*  戻り値は読み込んだ値*/
    9797/******************************************************/
    9898mrb_value mrb_i2c_read(mrb_state *mrb, mrb_value self)
     
    113113
    114114/******************************************************/
    115 /* I2Cデバイスに対して送信を開始するための準備をする: I2c.begin*/
     115/* I2Cデバイスに対して送信を開始するための準備をする: I2c.begin*/
    116116/*      I2c.begin( deviceID )*/
    117 /*      この関数は送信バッファを初期化するだけで、実際の動作は行わない。繰り返し呼ぶと、送信バッファがå
    118 ˆé ­ã«æˆ»ã‚‹ã€‚*/
    119 /*      deviceID: デバイスID 0~0x7Fまでの純粋なアドレス*/
     117/*      この関数は送信バッファを初期化するだけで、実際の動作は行わない。繰り返し呼ぶと、送信バッファが先頭に戻る。*/
     118/*      deviceID: デバイスID 0~0x7Fまでの純粋なアドレス*/
    120119/******************************************************/
    121120mrb_value mrb_i2c_beginTransmission(mrb_state *mrb, mrb_value self)
     
    130129        i2c_byte_write(i2c, deviceID);
    131130
    132         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    133 }
    134 
    135 /******************************************************/
    136 /* 送信バッファの末尾に数値を追加する: I2c.lwrite*/
     131        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     132}
     133
     134/******************************************************/
     135/* 送信バッファの末尾に数値を追加する: I2c.lwrite*/
    137136/*      I2c.lwrite( data )*/
    138 /*      data: セットする値*/
    139 /**/
    140 /* 戻り値は、送信したバイト数(バッファに溜めたバイト数)を返す。*/
    141 /*      送信バッファ(260バイト)に空き容量が無ければ失敗して0を返す*/
     137/*      data: セットする値*/
     138/**/
     139/* 戻り値は、送信したバイト数(バッファに溜めたバイト数)を返す。*/
     140/*      送信バッファ(260バイト)に空き容量が無ければ失敗して0を返す*/
    142141/******************************************************/
    143142mrb_value mrb_i2c_lwrite(mrb_state *mrb, mrb_value self)
     
    153152
    154153/******************************************************/
    155 /* デバイスに対してI2Cの送信シーケンスを発行する: I2c.end*/
     154/* デバイスに対してI2Cの送信シーケンスを発行する: I2c.end*/
    156155/*      I2c.end()*/
    157 /*      I2Cの送信はこの関数を実行して初めて実際に行われる。*/
    158 /**/
    159 /* 戻り値は以下のとおり*/
    160 /*      0: 成功*/
    161 /*      4: その他のエラー*/
     156/*      I2Cの送信はこの関数を実行して初めて実際に行われる。*/
     157/**/
     158/* 戻り値は以下のとおり*/
     159/*      0: 成功*/
     160/*      4: その他のエラー*/
    162161/******************************************************/
    163162mrb_value mrb_i2c_endTransmission(mrb_state *mrb, mrb_value self)
     
    169168
    170169/******************************************************/
    171 /* デバイスに対して受信シーケンスを発行しデータを読み出す: I2c.request*/
     170/* デバイスに対して受信シーケンスを発行しデータを読み出す: I2c.request*/
    172171/*      I2c.request( address, count )*/
    173 /*  num: 通信番号(0:SDA-0/SCL-1, 1:SDA-5/SCL-6, 2:SDA-7/SCL-8, 3:SDA-12/SCL-11, 4:SDA-9(26)/SCL-3)*/
    174 /*      address: 読み込み開始アドレス*/
    175 /*      count: 読み出す数*/
    176 /**/
    177 /*  戻り値は、実際に受信したバイト数。*/
     172/*  num: 通信番号(0:SDA-0/SCL-1, 1:SDA-5/SCL-6, 2:SDA-7/SCL-8, 3:SDA-12/SCL-11, 4:SDA-9(26)/SCL-3)*/
     173/*      address: 読み込み開始アドレス*/
     174/*      count: 読み出す数*/
     175/**/
     176/*  戻り値は、実際に受信したバイト数。*/
    178177/******************************************************/
    179178mrb_value mrb_i2c_requestFrom(mrb_state *mrb, mrb_value self)
     
    192191
    193192/******************************************************/
    194 /* デバイスに対して受信シーケンスを発行しデータを読み出す: I2c.lread*/
     193/* デバイスに対して受信シーケンスを発行しデータを読み出す: I2c.lread*/
    195194/*      I2c.lread()*/
    196195/**/
    197 /*  戻り値は読み込んだ値*/
     196/*  戻り値は読み込んだ値*/
    198197/******************************************************/
    199198mrb_value mrb_i2c_lread(mrb_state *mrb, mrb_value self)
     
    204203
    205204/******************************************************/
    206 /* デバイスに対して受信バッファå†
    207 ã«ã‚るデータ数を調べる: I2c.available*/
     205/* デバイスに対して受信バッファ内にあるデータ数を調べる: I2c.available*/
    208206/*      I2c.available()*/
    209207/**/
    210 /*  戻り値はデータ数*/
     208/*  戻り値はデータ数*/
    211209/******************************************************/
    212210mrb_value mrb_i2c_available(mrb_state *mrb, mrb_value self)
     
    217215#if 0
    218216/******************************************************/
    219 /* 周波数を変更する: I2c.freq*/
     217/* 周波数を変更する: I2c.freq*/
    220218/*  I2c.freq( Hz )*/
    221 /*  Hz: クロックの周波数をHz単位で指定する。*/
    222 /*      有効な値は1~200000程度。基本的にソフトでやっているので400kHzは出ない。*/
     219/*  Hz: クロックの周波数をHz単位で指定する。*/
     220/*      有効な値は1~200000程度。基本的にソフトでやっているので400kHzは出ない。*/
    223221/******************************************************/
    224222mrb_value mrb_i2c_freq(mrb_state *mrb, mrb_value self)
     
    230228        i2c_frequency(i2c, fq);
    231229
    232         return mrb_nil_value();                 /* 戻り値は無しですよ。 */
     230        return mrb_nil_value();                 /* 戻り値は無しですよ。 */
    233231}
    234232#endif
    235233/******************************************************/
    236 /* ライブラリを定義します*/
     234/* ライブラリを定義します*/
    237235/******************************************************/
    238236void i2c_Init(mrb_state *mrb)
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sI2c.h

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-chdr to text/x-chdr;charset=UTF-8
    r270 r321  
    11/*
    2  * I2C通信関連
     2 * I2C通信関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    99 */
    1010/******************************************************/
    11 /* ライブラリを定義します*/
     11/* ライブラリを定義します*/
    1212/******************************************************/
    1313void i2c_Init(mrb_state *mrb);
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sKernel.c

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-csrc to text/x-csrc;charset=UTF-8
    r270 r321  
    11/*
    2  * カーネル関連
     2 * カーネル関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    1717
    1818/******************************************************/
    19 /* デジタルライト*/
     19/* デジタルライト*/
    2020/*  digitalWrite(pin, value) */
    2121/*      pin*/
    22 /*              ピンの番号*/
     22/*              ピンの番号*/
    2323/*      value*/
    2424/*              0: LOW*/
     
    3434        pin = get_pin(pintype_gpio, pinno);
    3535        if (pin == NULL)
    36                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     36                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    3737
    3838        gpio_write(&pin->gpio, value);
    3939
    40         return mrb_nil_value(); /*戻り値は無しですよ。*/
    41 }
    42 
    43 /******************************************************/
    44 /* PINのモード設定*/
     40        return mrb_nil_value(); /*戻り値は無しですよ。*/
     41}
     42
     43/******************************************************/
     44/* PINのモード設定*/
    4545/*  pinMode(pin, mode) */
    4646/*  pin*/
    47 /*              ピンの番号*/
     47/*              ピンの番号*/
    4848/*      mode*/
    49 /*              0: INPUTモード*/
    50 /*              1: OUTPUTモード*/
     49/*              0: INPUTモード*/
     50/*              1: OUTPUTモード*/
    5151/******************************************************/
    5252mrb_value mrb_kernel_pinMode(mrb_state *mrb, mrb_value self)
     
    5959        pin = get_pin(pintype_gpio, pinno);
    6060        if (pin == NULL)
    61                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     61                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    6262
    6363        gpio_dir(&pin->gpio, value);
    6464
    65         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    66 }
    67 
    68 /******************************************************/
    69 /* ディレイ 強制GCを行っています*/
     65        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     66}
     67
     68/******************************************************/
     69/* ディレイ 強制GCを行っています*/
    7070/*  delay(value) */
    7171/*      value*/
    72 /*              時間(ms)*/
     72/*              時間(ms)*/
    7373/******************************************************/
    7474mrb_value mrb_kernel_delay(mrb_state *mrb, mrb_value self)
     
    7878        mrb_get_args(mrb, "i", &value);
    7979
    80         /*試しに強制gcをå
    81 ¥ã‚Œã¦è¦‹ã‚‹*/
     80        /*試しに強制gcを入れて見る*/
    8281        mrb_full_gc(mrb);
    8382
     
    8685        }
    8786
    88         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    89 }
    90 
    91 
    92 /******************************************************/
    93 /* ミリ秒を取得します: millis*/
     87        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     88}
     89
     90
     91/******************************************************/
     92/* ミリ秒を取得します: millis*/
    9493/*      millis()*/
    95 /* 戻り値*/
    96 /*      起動してからのミリ秒数*/
     94/* 戻り値*/
     95/*      起動してからのミリ秒数*/
    9796/******************************************************/
    9897mrb_value mrb_kernel_millis(mrb_state *mrb, mrb_value self)
     
    102101
    103102/******************************************************/
    104 /* マイクロ秒を取得します: micros*/
     103/* マイクロ秒を取得します: micros*/
    105104/*      micros()*/
    106 /* 戻り値*/
    107 /*      起動してからのマイクロ秒数*/
     105/* 戻り値*/
     106/*      起動してからのマイクロ秒数*/
    108107/******************************************************/
    109108mrb_value mrb_kernel_micros(mrb_state *mrb, mrb_value self)
     
    113112
    114113/******************************************************/
    115 /* デジタルリード: digitalRead*/
     114/* デジタルリード: digitalRead*/
    116115/*  digitalRead(pin) */
    117 /*      pin: ピンの番号*/
     116/*      pin: ピンの番号*/
    118117/*      */
    119118/*              0:LOW*/
     
    129128        pin = get_pin(pintype_gpio, pinno);
    130129        if (pin == NULL)
    131                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     130                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    132131
    133132        value = gpio_read(&pin->gpio);
     
    138137
    139138/******************************************************/
    140 /* アナログリファレンス: analogReference*/
     139/* アナログリファレンス: analogReference*/
    141140/*      analogReference(mode)*/
    142 /*  アナログå
    143 ¥åŠ›ã§ä½¿ã‚ã‚Œã‚‹åŸºæº–電圧を設定します*/
    144 /*      mode: 0:DEFAULT:5.0V Arduino互換, 1:INTERNAL:1.1V å†
    145 è”µé›»åœ§, 2:EXTERNAL:AVREFピン供給電圧, 3:RAW12BIT:3.3V 12ビットA/D変換を行う*/
     141/*  アナログ入力で使われる基準電圧を設定します*/
     142/*      mode: 0:DEFAULT:5.0V Arduino互換, 1:INTERNAL:1.1V 内蔵電圧, 2:EXTERNAL:AVREFピン供給電圧, 3:RAW12BIT:3.3V 12ビットA/D変換を行う*/
    146143/******************************************************/
    147144mrb_value mrb_kernel_analogReference(mrb_state *mrb, mrb_value self)
     
    165162                break;
    166163        }
    167         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    168 }
    169 
    170 /******************************************************/
    171 /* アナログリード: analogRead*/
     164        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     165}
     166
     167/******************************************************/
     168/* アナログリード: analogRead*/
    172169/*  analogRead(pin) */
    173 /*      pin: アナログの番号*/
     170/*      pin: アナログの番号*/
    174171/*      */
    175 /*              10ビットの値(0~1023)*/
     172/*              10ビットの値(0~1023)*/
    176173/******************************************************/
    177174mrb_value mrb_kernel_analogRead(mrb_state *mrb, mrb_value self)
     
    184181        pin = get_pin(pintype_analogin, anapin);
    185182        if (pin == NULL)
    186                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     183                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    187184
    188185        value = analogin_read_u16(&pin->analogin);
     
    193190#if 0
    194191/****************************************************/
    195 /* 出力ピンが並列接続されているピンとショートするかどうか調べます*/
     192/* 出力ピンが並列接続されているピンとショートするかどうか調べます*/
    196193/**/
    197 /* true: 衝突している*/
    198 /* false: 衝突していない。片方がINPUTである。*/
     194/* true: 衝突している*/
     195/* false: 衝突していない。片方がINPUTである。*/
    199196/****************************************************/
    200197bool IsWritePinCollision(int pinSub)
     
    209206
    210207/******************************************************/
    211 /* PWM出力: pwm*/
     208/* PWM出力: pwm*/
    212209/*      pwm(pin, value)*/
    213 /*      pin: ピンの番号(0,1,7,8,11,23ピンがPWM可能)*/
    214 /*       ãŸã ã—、23ピンは5ピンと24ピン短絡しているので、使用時は5ピンと24ピンをINPUTにしておく*/
    215 /*  value:      出力PWM比率(0~255)*/
     210/*      pin: ピンの番号(0,1,7,8,11,23ピンがPWM可能)*/
     211/*       ただし、23ピンは5ピンと24ピン短絡しているので、使用時は5ピンと24ピンをINPUTにしておく*/
     212/*  value:      出力PWM比率(0~255)*/
    216213/******************************************************/
    217214mrb_value mrb_kernel_pwm(mrb_state *mrb, mrb_value self)
     
    224221        pin = get_pin(pintype_pwmout, pinno);
    225222        if (pin == NULL)
    226                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     223                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    227224
    228225        pwmout_pulsewidth_us(&pin->pwmout, value);
    229226
    230         return mrb_nil_value();                 /*戻り値は無しですよ。*/
     227        return mrb_nil_value();                 /*戻り値は無しですよ。*/
    231228}
    232229#if 0
    233230/******************************************************/
    234 /* PWM周波数設定: pwmHz*/
     231/* PWM周波数設定: pwmHz*/
    235232/*      pwmHz(value)*/
    236 /*  value:      周波数(12~184999)Hz*/
     233/*  value:      周波数(12~184999)Hz*/
    237234/******************************************************/
    238235mrb_value mrb_kernel_pwmHz(mrb_state *mrb, mrb_value self)
     
    245242        pin = get_pin(pintype_pwmout, pinno);
    246243        if (pin == NULL)
    247                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     244                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    248245
    249246        if (value >= 12 && value < 18500) {
     
    254251        }
    255252
    256         return mrb_nil_value();                 /*戻り値は無しですよ。*/
     253        return mrb_nil_value();                 /*戻り値は無しですよ。*/
    257254}
    258255#endif
    259256/******************************************************/
    260 /* トーン出力停止: noTone*/
     257/* トーン出力停止: noTone*/
    261258/*      noTone(pin)*/
    262 /*  pin: ピン番号*/
     259/*  pin: ピン番号*/
    263260/******************************************************/
    264261mrb_value mrb_kernel_noTone(mrb_state *mrb, mrb_value self)
     
    269266
    270267        if (pin == 4 || pin >= 20) {
    271                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     268                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    272269        }
    273270
    274271        noTone(pin);
    275272
    276         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    277 }
    278 
    279 /******************************************************/
    280 /* トーン出力: tone*/
     273        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     274}
     275
     276/******************************************************/
     277/* トーン出力: tone*/
    281278/*      tone(pin, frequency[,duration])*/
    282 /*  pin: ピン番号*/
    283 /*  frequency: 周波数(2~62500)Hz*/
    284 /*  duration: 出力を維持する時間[ms]。省略時、0指定時は出力し続ける。*/
     279/*  pin: ピン番号*/
     280/*  frequency: 周波数(2~62500)Hz*/
     281/*  duration: 出力を維持する時間[ms]。省略時、0指定時は出力し続ける。*/
    285282/******************************************************/
    286283mrb_value mrb_kernel_tone(mrb_state *mrb, mrb_value self)
     
    293290
    294291        if (pin == 4 || pin >= 20) {
    295                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     292                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    296293        }
    297294
     
    301298                tone(pin, freq, dura);
    302299        }
    303         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    304 }
    305 
    306 /******************************************************/
    307 /* アナログDACピン初期化: initDac*/
     300        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     301}
     302
     303/******************************************************/
     304/* アナログDACピン初期化: initDac*/
    308305/*      initDac()*/
    309306/******************************************************/
     
    311308{
    312309        setPinModeDac(RB_PIN9);
    313         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    314 }
    315 
    316 /******************************************************/
    317 /* アナログDAC出力: analogDac*/
     310        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     311}
     312
     313/******************************************************/
     314/* アナログDAC出力: analogDac*/
    318315/*      analogDac(value)*/
    319 /*  value:      10bit精度(0~4095)*/
     316/*  value:      10bit精度(0~4095)*/
    320317/******************************************************/
    321318mrb_value mrb_kernel_analogDac(mrb_state *mrb, mrb_value self)
     
    330327                pin = get_pin(pintype_dac, RB_PIN9);
    331328                if (pin == NULL)
    332                         return mrb_nil_value();                 /*戻り値は無しですよ。*/
     329                        return mrb_nil_value();                 /*戻り値は無しですよ。*/
    333330
    334331                analogout_write_u16(&pin->dac, (value << 6) | (value >> 4));
     
    336333#endif
    337334
    338         return mrb_nil_value();                 /*戻り値は無しですよ。*/
     335        return mrb_nil_value();                 /*戻り値は無しですよ。*/
    339336}
    340337
     
    351348
    352349/******************************************************/
    353 /* LEDオンオフ: led*/
     350/* LEDオンオフ: led*/
    354351/*      led(sw)*/
    355352/******************************************************/
     
    369366#endif
    370367
    371         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    372 }
    373 
    374 /******************************************************/
    375 /* 乱数を得るための種を与えます: randomSeed*/
     368        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     369}
     370
     371/******************************************************/
     372/* 乱数を得るための種を与えます: randomSeed*/
    376373/*  randomSeed(value)*/
    377 /*  value: 種となる値*/
     374/*  value: 種となる値*/
    378375/******************************************************/
    379376mrb_value mrb_kernel_randomSeed(mrb_state *mrb, mrb_value self)
     
    385382        randomSeed(value);
    386383
    387         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    388 }
    389 
    390 /******************************************************/
    391 /* 乱数を取得します: random*/
     384        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     385}
     386
     387/******************************************************/
     388/* 乱数を取得します: random*/
    392389/*  random([min,] max)*/
    393 /*  min: 乱数の取りうる最小値。省略可*/
    394 /*  max: 乱数の取りうる最大値*/
     390/*  min: 乱数の取りうる最小値。省略可*/
     391/*  max: 乱数の取りうる最大値*/
    395392/******************************************************/
    396393mrb_value mrb_kernel_random(mrb_state *mrb, mrb_value self)
     
    408405
    409406/******************************************************/
    410 /* 隠しコマンドです:  El_Psy.Congroo*/
     407/* 隠しコマンドです:  El_Psy.Congroo*/
    411408/*      El_Psy.Congroo()*/
    412409/******************************************************/
     
    415412        mrb_raise(mrb, mrb_class_get(mrb, "Sys#exit Called"), "Normal Completion");
    416413
    417         return mrb_nil_value(); /*戻り値は無しですよ。*/
    418 }
    419 
    420 /******************************************************/
    421 /* ライブラリを定義します*/
     414        return mrb_nil_value(); /*戻り値は無しですよ。*/
     415}
     416
     417/******************************************************/
     418/* ライブラリを定義します*/
    422419/******************************************************/
    423420void kernel_Init(mrb_state *mrb)
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sKernel.h

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-chdr to text/x-chdr;charset=UTF-8
    r270 r321  
    11/*
    2  * カーネル関連
     2 * カーネル関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    1212
    1313/******************************************************/
    14 /* ライブラリを定義します*/
     14/* ライブラリを定義します*/
    1515/******************************************************/
    1616void kernel_Init(mrb_state *mrb);
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sMem.c

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-csrc to text/x-csrc;charset=UTF-8
    r270 r321  
    11/*
    2  * ファイル関連
     2 * ファイル関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    1717
    1818FILEEEP Fpj0;
    19 FILEEEP *Fp0 = &Fpj0;                   /*コマンド用*/
     19FILEEEP *Fp0 = &Fpj0;                   /*コマンド用*/
    2020FILEEEP Fpj1;
    21 FILEEEP *Fp1 = &Fpj1;                   /*コマンド用*/
    22 
    23 /******************************************************/
    24 /* openしたファイルから1バイト読み込みます: MemFile.read*/
     21FILEEEP *Fp1 = &Fpj1;                   /*コマンド用*/
     22
     23/******************************************************/
     24/* openしたファイルから1バイト読み込みます: MemFile.read*/
    2525/*      MemFile.read( number )*/
    26 /*      number: ファイル番号 0 または 1*/
    27 /* 戻り値*/
    28 /*      0x00~0xFFが返る。ファイルの最後だったら-1が返る。*/
     26/*      number: ファイル番号 0 または 1*/
     27/* 戻り値*/
     28/*      0x00~0xFFが返る。ファイルの最後だったら-1が返る。*/
    2929/******************************************************/
    3030mrb_value mrb_mem_read(mrb_state *mrb, mrb_value self)
     
    4646
    4747/******************************************************/
    48 /* openしたファイルバイナリデータを書き込む: MemFile.write*/
     48/* openしたファイルバイナリデータを書き込む: MemFile.write*/
    4949/*      MemFile.write( number, buf, len )*/
    50 /*      number: ファイル番号 0 または 1*/
    51 /*      buf: 書き込むデータ*/
    52 /*      len: 書き込むデータサイズ*/
    53 /* 戻り値*/
    54 /*      実際に書いたバイト数*/
     50/*      number: ファイル番号 0 または 1*/
     51/*      buf: 書き込むデータ*/
     52/*      len: 書き込むデータサイズ*/
     53/* 戻り値*/
     54/*      実際に書いたバイト数*/
    5555/******************************************************/
    5656mrb_value mrb_mem_write(mrb_state *mrb, mrb_value self)
     
    7878
    7979/******************************************************/
    80 /* ファイルをオープンします: MemFile.open*/
     80/* ファイルをオープンします: MemFile.open*/
    8181/*      MemFile.open( number, filename[, mode] )*/
    82 /*      number: ファイル番号 0 または 1*/
    83 /*      filename: ファイル名(8.3形式)*/
     82/*      number: ファイル番号 0 または 1*/
     83/*      filename: ファイル名(8.3形式)*/
    8484/*      mode: 0:Read, 1:Append, 2:New Create*/
    85 /* 戻り値*/
    86 /*      成功: 番号, 失敗: -1*/
     85/* 戻り値*/
     86/*      成功: 番号, 失敗: -1*/
    8787/******************************************************/
    8888mrb_value mrb_mem_open(mrb_state *mrb, mrb_value self)
     
    142142
    143143/******************************************************/
    144 /* ファイルをクローズします: MemFile.close( number )*/
     144/* ファイルをクローズします: MemFile.close( number )*/
    145145/*      MemFile.close( number )*/
    146 /*      number: ファイル番号 0 または 1*/
     146/*      number: ファイル番号 0 または 1*/
    147147/******************************************************/
    148148mrb_value mrb_mem_close(mrb_state *mrb, mrb_value self)
     
    159159        }
    160160
    161         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    162 }
    163 
    164 /******************************************************/
    165 /* openしたファイルの読み出し位置を移動する: MemFile.seek*/
     161        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     162}
     163
     164/******************************************************/
     165/* openしたファイルの読み出し位置を移動する: MemFile.seek*/
    166166/*      MemFile.seek( number, byte )*/
    167 /*      number: ファイル番号 0 または 1*/
    168 /*      byte: seekするバイト数(-1)でファイルの最後に移動する*/
    169 /* 戻り値*/
    170 /*      成功: 1, 失敗: 0*/
     167/*      number: ファイル番号 0 または 1*/
     168/*      byte: seekするバイト数(-1)でファイルの最後に移動する*/
     169/* 戻り値*/
     170/*      成功: 1, 失敗: 0*/
    171171/******************************************************/
    172172mrb_value mrb_mem_seek(mrb_state *mrb, mrb_value self)
     
    206206
    207207/******************************************************/
    208 /* ファイルをコピーします: MemFile.cp*/
     208/* ファイルをコピーします: MemFile.cp*/
    209209/*  MemFile.cp( srcFilename, dstFilename[, mode] )*/
    210 /*  srcFilename: コピーå
    211 ƒãƒ•ã‚¡ã‚¤ãƒ«å*/
    212 /*  dstFilename: コピーå
    213 ˆãƒ•ã‚¡ã‚¤ãƒ«å*/
    214 /*  mode: 0上書きしない, 1:上書きする*/
    215 /* 戻り値*/
    216 /*      成功: 1, 失敗: 0*/
     210/*  srcFilename: コピー元ファイル名*/
     211/*  dstFilename: コピー先ファイル名*/
     212/*  mode: 0上書きしない, 1:上書きする*/
     213/* 戻り値*/
     214/*      成功: 1, 失敗: 0*/
    217215/******************************************************/
    218216mrb_value mrb_mem_cp(mrb_state *mrb, mrb_value self)
     
    247245
    248246/******************************************************/
    249 /* ファイルを削除します: MemFile.rm*/
     247/* ファイルを削除します: MemFile.rm*/
    250248/*  MemFile.rm( Filename )*/
    251 /*  Filename: 削除するファイル名*/
    252 /* 戻り値*/
    253 /*      成功: 1, 失敗: 0*/
     249/*  Filename: 削除するファイル名*/
     250/* 戻り値*/
     251/*      成功: 1, 失敗: 0*/
    254252/******************************************************/
    255253mrb_value mrb_mem_rm(mrb_state *mrb, mrb_value self)
     
    267265
    268266/******************************************************/
    269 /* ライブラリを定義します*/
     267/* ライブラリを定義します*/
    270268/******************************************************/
    271269void mem_Init(mrb_state *mrb)
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sMem.h

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-chdr to text/x-chdr;charset=UTF-8
    r270 r321  
    11/*
    2  * ファイル関連
     2 * ファイル関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    99 */
    1010/******************************************************/
    11 /* ライブラリを定義します*/
     11/* ライブラリを定義します*/
    1212/******************************************************/
    1313void mem_Init(mrb_state *mrb);
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sPanCake.c

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-csrc to text/x-csrc;charset=UTF-8
    r270 r321  
    11/*
    2  * PanCake関連
     2 * PanCake関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    2727
    2828/******************************************************/
    29 /* 画面を消去: PanCake.clear*/
     29/* 画面を消去: PanCake.clear*/
    3030/*  PanCake.clear(cn)*/
    31 /*  cn: 色番号*/
     31/*  cn: 色番号*/
    3232/******************************************************/
    3333mrb_value mrb_pancake_Clear(mrb_state *mrb, mrb_value self)
     
    4444        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    4545
    46         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    47 }
    48 
    49 /******************************************************/
    50 /* 画面に線を引く: PanCake.line*/
     46        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     47}
     48
     49/******************************************************/
     50/* 画面に線を引く: PanCake.line*/
    5151/*  PanCake.line(x1,y1,x2,y2,cn)*/
    52 /*  (x1,y1)-(x2,y2)に線を引きます*/
    53 /*  cn: 色番号*/
     52/*  (x1,y1)-(x2,y2)に線を引きます*/
     53/*  cn: 色番号*/
    5454/******************************************************/
    5555mrb_value mrb_pancake_Line(mrb_state *mrb, mrb_value self)
     
    7474        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    7575
    76         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    77 }
    78 
    79 /******************************************************/
    80 /* 画面に円を描く: PanCake.circle*/
     76        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     77}
     78
     79/******************************************************/
     80/* 画面に円を描く: PanCake.circle*/
    8181/*  PanCake.circle(xc, yc, ra, cn)*/
    82 /*  (xc,yc)を中心に円を描く*/
    83 /*  ra: 半径*/
    84 /*  cn: 色番号*/
     82/*  (xc,yc)を中心に円を描く*/
     83/*  ra: 半径*/
     84/*  cn: 色番号*/
    8585/******************************************************/
    8686mrb_value mrb_pancake_Circle(mrb_state *mrb, mrb_value self)
     
    103103        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    104104
    105         return mrb_nil_value();                 /*戻り値は無しですよ。*/
     105        return mrb_nil_value();                 /*戻り値は無しですよ。*/
    106106}
    107107
    108108int hex2int(char s)
    109109{
    110         /* '0' から '9' の文字なら*/
     110        /* '0' から '9' の文字なら*/
    111111        if ('0' <= s && s <= '9') {
    112112                return(s - '0');
    113113        }
    114         /*'A' から 'F' の文字なら*/
     114        /*'A' から 'F' の文字なら*/
    115115        else if ('A' <= s && s <= 'F') {
    116116                return(s - 'A' + 10);
    117117        }
    118         /*'a' から 'f' の文字なら*/
     118        /*'a' から 'f' の文字なら*/
    119119        else if ('a' <= s && s <= 'f') {
    120120                return(s - 'a' + 10);
     
    125125
    126126/******************************************************/
    127 /* 画面に8x8の絵を描く: PanCake.stamp*/
     127/* 画面に8x8の絵を描く: PanCake.stamp*/
    128128/*  PanCake.stamp(px, py, tc, string)*/
    129 /*  px,py: 絵の左上座標*/
    130 /*  tc: 透明色*/
    131 /*  string: 16進数の文字列が64個*/
     129/*  px,py: 絵の左上座標*/
     130/*  tc: 透明色*/
     131/*  string: 16進数の文字列が64個*/
    132132/******************************************************/
    133133mrb_value mrb_pancake_Stamp(mrb_state *mrb, mrb_value self)
     
    155155        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    156156
    157         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    158 }
    159 
    160 /******************************************************/
    161 /* 画面に8x8の1色の絵を描く: PanCake.stamp1*/
     157        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     158}
     159
     160/******************************************************/
     161/* 画面に8x8の1色の絵を描く: PanCake.stamp1*/
    162162/*  PanCake.stamp1(px, py, cn, string)*/
    163 /*  px,py: 絵の左上座標*/
    164 /*  cn: 描く色*/
    165 /*  string: 16進数の文字列が16個*/
     163/*  px,py: 絵の左上座標*/
     164/*  cn: 描く色*/
     165/*  string: 16進数の文字列が16個*/
    166166/******************************************************/
    167167mrb_value mrb_pancake_Stamp1(mrb_state *mrb, mrb_value self)
     
    189189        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    190190
    191         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    192 }
    193 
    194 /******************************************************/
    195 /* 画面に組み込み画像を描く: PanCake.image*/
     191        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     192}
     193
     194/******************************************************/
     195/* 画面に組み込み画像を描く: PanCake.image*/
    196196/*  PanCake.image(num)*/
    197 /*  num: 組み込み画像の番号*/
     197/*  num: 組み込み画像の番号*/
    198198/******************************************************/
    199199mrb_value mrb_pancake_Image(mrb_state *mrb, mrb_value self)
     
    210210        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    211211
    212         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    213 }
    214 
    215 /******************************************************/
    216 /* ビデオ出力のON/OFF: PanCake.video*/
     212        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     213}
     214
     215/******************************************************/
     216/* ビデオ出力のON/OFF: PanCake.video*/
    217217/*  PanCake.video(sw)*/
    218 /*  sw: スイッチON/OFF[01/00]*/
     218/*  sw: スイッチON/OFF[01/00]*/
    219219/******************************************************/
    220220mrb_value mrb_pancake_Video(mrb_state *mrb, mrb_value self)
     
    231231        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    232232
    233         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    234 }
    235 
    236 /******************************************************/
    237 /* 4ch同時に音を鳴らす: PanCake.sound*/
     233        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     234}
     235
     236/******************************************************/
     237/* 4ch同時に音を鳴らす: PanCake.sound*/
    238238/*  PanCake.sound(o0, s0, o1, s1, o2, s2, o3, s3)*/
    239 /*  o0,o1,o2,o3: オクターブ(0~4~7)*/
    240 /*  s0,s1,s2,s3: 音程(0~b) eはノイズ音*/
    241 /*               HighBits4は音色(0~3)*/
    242 /*               éŸ³ã‚’消すのは FF*/
     239/*  o0,o1,o2,o3: オクターブ(0~4~7)*/
     240/*  s0,s1,s2,s3: 音程(0~b) eはノイズ音*/
     241/*               HighBits4は音色(0~3)*/
     242/*               音を消すのは FF*/
    243243/******************************************************/
    244244mrb_value mrb_pancake_Sound(mrb_state *mrb, mrb_value self)
     
    263263        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    264264
    265         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    266 }
    267 
    268 /******************************************************/
    269 /* 1ch音を鳴らす: PanCake.sound1*/
     265        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     266}
     267
     268/******************************************************/
     269/* 1ch音を鳴らす: PanCake.sound1*/
    270270/*  PanCake.sound1(cn, on, sn)*/
    271 /*  cn: チャネル*/
    272 /*  on: オクターブ(0~4~7)*/
    273 /*  sn: 音程(0~b) eはノイズ音*/
    274 /*      HighBits4は音色(0~3)*/
    275 /*      音を消すのは FF*/
     271/*  cn: チャネル*/
     272/*  on: オクターブ(0~4~7)*/
     273/*  sn: 音程(0~b) eはノイズ音*/
     274/*      HighBits4は音色(0~3)*/
     275/*      音を消すのは FF*/
    276276/******************************************************/
    277277mrb_value mrb_pancake_Sound1(mrb_state *mrb, mrb_value self)
     
    290290        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    291291
    292         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    293 }
    294 
    295 /******************************************************/
    296 /* 初期状æ
    297 ‹ã«ã™ã‚‹: PanCake.reset*/
     292        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     293}
     294
     295/******************************************************/
     296/* 初期状態にする: PanCake.reset*/
    298297/*  PanCake.reset()*/
    299298/******************************************************/
     
    306305        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    307306
    308         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    309 }
    310 
    311 /******************************************************/
    312 /* OUTポートに出力: PanCake.out*/
     307        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     308}
     309
     310/******************************************************/
     311/* OUTポートに出力: PanCake.out*/
    313312/*  PanCake.out(pf)*/
    314 /*  pf: HIGHにするポート番号を16進数で指定*/
     313/*  pf: HIGHにするポート番号を16進数で指定*/
    315314/******************************************************/
    316315mrb_value mrb_pancake_Out(mrb_state *mrb, mrb_value self)
     
    327326        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    328327
    329         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    330 }
    331 
    332 /******************************************************/
    333 /* スプライトを開始する: Sprite.start*/
     328        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     329}
     330
     331/******************************************************/
     332/* スプライトを開始する: Sprite.start*/
    334333/*  Sprite.start(num)*/
    335 /*  num: 背景に使う組み込み画像番号*/
    336 /*       èƒŒæ™¯ã‚’ベタ塗りにする場合は num のHighBitsを1にします。*/
    337 /*      スプライト処理を停止するには num を FF にします。*/
     334/*  num: 背景に使う組み込み画像番号*/
     335/*       背景をベタ塗りにする場合は num のHighBitsを1にします。*/
     336/*      スプライト処理を停止するには num を FF にします。*/
    338337/******************************************************/
    339338mrb_value mrb_pancake_Start(mrb_state *mrb, mrb_value self)
     
    350349        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    351350
    352         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    353 }
    354 
    355 /******************************************************/
    356 /* スプライトを作る: Sprite.create*/
     351        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     352}
     353
     354/******************************************************/
     355/* スプライトを作る: Sprite.create*/
    357356/*  Sprite.create(sn, si)*/
    358 /*  sn: スプライト番号 0~15*/
    359 /*  si: 組み込みスプライト画像番号*/
    360 /*      消すのは FF*/
     357/*  sn: スプライト番号 0~15*/
     358/*  si: 組み込みスプライト画像番号*/
     359/*      消すのは FF*/
    361360/******************************************************/
    362361mrb_value mrb_pancake_Create(mrb_state *mrb, mrb_value self)
     
    374373        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    375374
    376         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    377 }
    378 
    379 /******************************************************/
    380 /* スプライトの移動: Sprite.move*/
     375        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     376}
     377
     378/******************************************************/
     379/* スプライトの移動: Sprite.move*/
    381380/*  Sprite.move(sn, px,py)*/
    382 /*  sn: スプライト番号 0~15*/
    383 /*  px,py: 画面座標*/
     381/*  sn: スプライト番号 0~15*/
     382/*  px,py: 画面座標*/
    384383/******************************************************/
    385384mrb_value mrb_pancake_Move(mrb_state *mrb, mrb_value self)
     
    398397        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    399398
    400         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    401 }
    402 
    403 /******************************************************/
    404 /* 音楽再生する: Music.play*/
     399        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     400}
     401
     402/******************************************************/
     403/* 音楽再生する: Music.play*/
    405404/*  Music.play(sw)*/
    406405/*  sw: START/STOP[01/00]*/
     
    419418        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    420419
    421         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    422 }
    423 
    424 /******************************************************/
    425 /* C D E F G A B を0x0 ~ 0xBに置き換えます*/
     420        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     421}
     422
     423/******************************************************/
     424/* C D E F G A B を0x0 ~ 0xBに置き換えます*/
    426425/* C  D  E  F  G  A  B*/
    427426/* 0  2  4  5  7  9  B*/
     
    454453
    455454/******************************************************/
    456 /* MMLをサウンドchに登録する: Music.score*/
     455/* MMLをサウンドchに登録する: Music.score*/
    457456/*  Music.score(ch, pn, tt, string)*/
    458 /*  ch: チャンネル(00~03)*/
    459 /*  pn: 01:即再生、00:後で再生*/
    460 /*  tt: テンポ(0~F)+音色 [ex. 30 == テンポ3、音色0]*/
    461 /*  string: MML 64バイトまで*/
     457/*  ch: チャンネル(00~03)*/
     458/*  pn: 01:即再生、00:後で再生*/
     459/*  tt: テンポ(0~F)+音色 [ex. 30 == テンポ3、音色0]*/
     460/*  string: MML 64バイトまで*/
    462461/******************************************************/
    463462mrb_value mrb_pancake_Score(mrb_state *mrb, mrb_value self)
     
    539538        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    540539
    541         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    542 }
    543 
    544 /******************************************************/
    545 /* PanCakeで使うシリアルポート番号を指定: PanCake.serial*/
     540        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     541}
     542
     543/******************************************************/
     544/* PanCakeで使うシリアルポート番号を指定: PanCake.serial*/
    546545/*  PanCake.serial(num)*/
    547 /*  num: シリアルポート番号(1~3)*/
     546/*  num: シリアルポート番号(1~3)*/
    548547/******************************************************/
    549548mrb_value mrb_pancake_Serial(mrb_state *mrb, mrb_value self)
     
    560559        SerialNum = num;
    561560
    562         /*シリアル通信の初期化をします*/
     561        /*シリアル通信の初期化をします*/
    563562        if (serial[SerialNum] != 0) {
    564563                serial_free(serial[SerialNum]);
     
    567566
    568567        if(!portToPins(SCI_SCI0P2x, &txpin, &rxpin))
    569                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     568                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    570569
    571570        serial[SerialNum] = mrb_malloc(mrb, sizeof(serial_t));
     
    573572        serial_baud(serial[SerialNum], PANCAKE_BAURATE);
    574573
    575         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    576 }
    577 
    578 /******************************************************/
    579 /* スプライトの左右反転: Sprite.flip*/
     574        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     575}
     576
     577/******************************************************/
     578/* スプライトの左右反転: Sprite.flip*/
    580579/*  Sprite.flip(sn, fs)*/
    581 /*  sn: スプライト番号 0~15*/
     580/*  sn: スプライト番号 0~15*/
    582581/*  fs: ON/OFF[01/00]*/
    583582/******************************************************/
     
    596595        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    597596
    598         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    599 }
    600 
    601 /******************************************************/
    602 /* スプライトの回転: Sprite.rotate*/
     597        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     598}
     599
     600/******************************************************/
     601/* スプライトの回転: Sprite.rotate*/
    603602/*  Sprite.rotate(sn, ra)*/
    604 /*  sn: スプライト番号 0~15*/
    605 /*  ra: 角度[0:0°,1:-90°,2:180°,3:90°]*/
     603/*  sn: スプライト番号 0~15*/
     604/*  ra: 角度[0:0°,1:-90°,2:180°,3:90°]*/
    606605/******************************************************/
    607606mrb_value mrb_pancake_Rotate(mrb_state *mrb, mrb_value self)
     
    619618        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    620619
    621         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    622 }
    623 
    624 /******************************************************/
    625 /* スプライト用8x8画像の定義: Sprite.user*/
     620        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     621}
     622
     623/******************************************************/
     624/* スプライト用8x8画像の定義: Sprite.user*/
    626625/*  Sprite.user(dn, tc, string)*/
    627 /*  dn: スプライトの定義番号 FD か FE*/
    628 /*  tc: 透明色*/
    629 /*  string: 16進数の文字列が64個(色の番号です)*/
     626/*  dn: スプライトの定義番号 FD か FE*/
     627/*  tc: 透明色*/
     628/*  string: 16進数の文字列が64個(色の番号です)*/
    630629/******************************************************/
    631630mrb_value mrb_pancake_User(mrb_state *mrb, mrb_value self)
     
    650649        serial_write(serial[SerialNum], (const unsigned char *)PanSend, PanSend[1]);
    651650
    652         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    653 }
    654 
    655 /******************************************************/
    656 /* ライブラリを定義します*/
     651        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     652}
     653
     654/******************************************************/
     655/* ライブラリを定義します*/
    657656/******************************************************/
    658657void pancake_Init(mrb_state *mrb)
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sPanCake.h

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-chdr to text/x-chdr;charset=UTF-8
    r270 r321  
    11/*
    2  * PanCake関連
     2 * PanCake関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    99 */
    1010/******************************************************/
    11 /* ライブラリを定義します*/
     11/* ライブラリを定義します*/
    1212/******************************************************/
    1313void pancake_Init(mrb_state *mrb);
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sRtc.c

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-csrc to text/x-csrc;charset=UTF-8
    r270 r321  
    11/*
    2  * RTC関連
     2 * RTC関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    1919
    2020/******************************************************/
    21 /* RTCの時計を取得します: Rtc.getTime*/
     21/* RTCの時計を取得します: Rtc.getTime*/
    2222/*  Rtc.getTime()*/
    2323/**/
    24 /*  戻り値は以下の値がé
    25 åˆ—で返ります*/
    26 /*  year: å¹´(2000-2099)*/
    27 /*  mon: 月(1-12)*/
    28 /*  day: 日(1-31)*/
    29 /*  hour: 時(0-23)*/
    30 /*  min: 分(0-59)*/
    31 /*  second: 秒(0-59)*/
    32 /*  weekday: 曜日(0-6)0:日,1:月,2:火,3:æ°´,4:木,5:金,6:土*/
     24/*  戻り値は以下の値が配列で返ります*/
     25/*  year: 年(2000-2099)*/
     26/*  mon: 月(1-12)*/
     27/*  day: 日(1-31)*/
     28/*  hour: 時(0-23)*/
     29/*  min: 分(0-59)*/
     30/*  second: 秒(0-59)*/
     31/*  weekday: 曜日(0-6)0:日,1:月,2:火,3:水,4:木,5:金,6:土*/
    3332/******************************************************/
    3433mrb_value mrb_rtc_getTime(mrb_state *mrb, mrb_value self)
     
    4948
    5049/******************************************************/
    51 /* RTCの時計をセットします: Rtc.setTime*/
     50/* RTCの時計をセットします: Rtc.setTime*/
    5251/*  Rtc.setTime( array )*/
    53 /*  array: å¹´(0000-9999),月(1-12),日(1-31),時(0-23),分(0-59),秒(0-59)のé
    54 åˆ—*/
     52/*  array: 年(0000-9999),月(1-12),日(1-31),時(0-23),分(0-59),秒(0-59)の配列*/
    5553/**/
    56 /*  戻り値は以下のとおり*/
    57 /*              0: 失敗*/
    58 /*              1: 成功*/
     54/*  戻り値は以下のとおり*/
     55/*              0: 失敗*/
     56/*              1: 成功*/
    5957/******************************************************/
    6058mrb_value mrb_rtc_setTime(mrb_state *mrb, mrb_value self)
     
    7573
    7674/******************************************************/
    77 /* RTCを停止します: Rtc.deinit*/
     75/* RTCを停止します: Rtc.deinit*/
    7876/*  Rtc.deinit()*/
    7977/**/
    80 /* 戻り値は以下のとおり*/
    81 /*      0: 失敗*/
    82 /*      1: 成功*/
     78/* 戻り値は以下のとおり*/
     79/*      0: 失敗*/
     80/*      1: 成功*/
    8381/******************************************************/
    8482mrb_value mrb_rtc_deinit(mrb_state *mrb, mrb_value self)
     
    8987
    9088/******************************************************/
    91 /* RTCを起動します: Rtc.init*/
     89/* RTCを起動します: Rtc.init*/
    9290/*  Rtc.init()*/
    9391/**/
    94 /* 戻り値は以下のとおり*/
    95 /*      0: 起動失敗*/
    96 /*      1: 起動成功*/
    97 /*      2: RTCは既に起動していた(成功)*/
     92/* 戻り値は以下のとおり*/
     93/*      0: 起動失敗*/
     94/*      1: 起動成功*/
     95/*      2: RTCは既に起動していた(成功)*/
    9896/******************************************************/
    9997mrb_value mrb_rtc_init(mrb_state *mrb, mrb_value self)
     
    108106
    109107/******************************************************/
    110 /* ライブラリを定義します*/
     108/* ライブラリを定義します*/
    111109/******************************************************/
    112110void rtc_Init(mrb_state *mrb)
     
    123121
    124122/*rtc_attach_alarm_handler*/
    125 /*概要        アラーム発生時に処理する関数を登録します。*/
    126 /*文法        rtc_attach_alarm_handler(void(*)(void) function)*/
    127 /*パラメータ       function: 処理する関数*/
    128 /*戻り値     ãªã—*/
     123/*概要    アラーム発生時に処理する関数を登録します。*/
     124/*文法    rtc_attach_alarm_handler(void(*)(void) function)*/
     125/*パラメータ         function: 処理する関数*/
     126/*戻り値   なし*/
    129127/**/
    130128/*rtc_set_alarm_time*/
    131 /*概要        アラーム時間を設定します。*/
    132 /*文法        int rtc_set_alarm_time (int hour, int min, int week_flag)*/
    133 /*パラメータ       hour: 時*/
    134 /*min: 分*/
    135 /*week_flag: 曜日(複数指定の場合は論理和で指定)*/
    136 /*戻り値     0:失敗、1:成功*/
     129/*概要    アラーム時間を設定します。*/
     130/*文法    int rtc_set_alarm_time (int hour, int min, int week_flag)*/
     131/*パラメータ         hour: 時*/
     132/*min: */
     133/*week_flag: 曜日(複数指定の場合は論理和で指定)*/
     134/*戻り値   0:失敗、1:成功*/
    137135/**/
    138136/*rtc_alarm_on*/
    139 /*概要        アラームをONにします。*/
    140 /*文法        rtc_alarm_on()*/
    141 /*パラメータ       ãªã—*/
    142 /*戻り値     ãªã—*/
     137/*概要    アラームをONにします。*/
     138/*文法    rtc_alarm_on()*/
     139/*パラメータ         なし*/
     140/*戻り値   なし*/
    143141/**/
    144142/*rtc_alarm_off*/
    145 /*概要        アラームをOFFにします。*/
    146 /*文法        rtc_alarm_off()*/
    147 /*パラメータ       ãªã—*/
    148 /*戻り値     ãªã—*/
     143/*概要    アラームをOFFにします。*/
     144/*文法    rtc_alarm_off()*/
     145/*パラメータ         なし*/
     146/*戻り値   なし*/
    149147/**/
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sRtc.h

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-chdr to text/x-chdr;charset=UTF-8
    r270 r321  
    11/*
    2  * RTC関連
     2 * RTC関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    99 */
    1010/******************************************************/
    11 /* ライブラリを定義します*/
     11/* ライブラリを定義します*/
    1212/******************************************************/
    1313void rtc_Init(mrb_state *mrb);
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sSdCard.c

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-csrc to text/x-csrc;charset=UTF-8
    r270 r321  
    11/*
    2  * SDカード関連
     2 * SDカード関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    2121
    2222/******************************************************/
    23 /*ファイルが存在するかどうか調べる: SD_exists*/
     23/*ファイルが存在するかどうか調べる: SD_exists*/
    2424/*      SD_exists( filename )*/
    25 /*  filename: 調べるファイル名*/
    26 /**/
    27 /* 戻り値*/
    28 /*      存在する: 1, 存在しない: 0*/
     25/*  filename: 調べるファイル名*/
     26/**/
     27/* 戻り値*/
     28/*      存在する: 1, 存在しない: 0*/
    2929/******************************************************/
    3030mrb_value mrb_sdcard_exists(mrb_state *mrb, mrb_value self)
     
    4646
    4747/******************************************************/
    48 /* ディレクトリを作成する: SD_mkdir*/
     48/* ディレクトリを作成する: SD_mkdir*/
    4949/*      SD_mkdir( dirname )*/
    50 /*  dirname: 作成するディレクトリ名*/
    51 /**/
    52 /* 戻り値*/
    53 /*      成功: 1, 失敗: 0*/
     50/*  dirname: 作成するディレクトリ名*/
     51/**/
     52/* 戻り値*/
     53/*      成功: 1, 失敗: 0*/
    5454/******************************************************/
    5555mrb_value mrb_sdcard_mkdir(mrb_state *mrb, mrb_value self)
     
    7171
    7272/******************************************************/
    73 /* ファイルを削除する: SD_remove*/
     73/* ファイルを削除する: SD_remove*/
    7474/*      SD_remove( filename )*/
    75 /*  filename: 削除するファイル名*/
    76 /**/
    77 /* 戻り値*/
    78 /*      成功: 1, 失敗: 0*/
     75/*  filename: 削除するファイル名*/
     76/**/
     77/* 戻り値*/
     78/*      成功: 1, 失敗: 0*/
    7979/******************************************************/
    8080mrb_value mrb_sdcard_remove(mrb_state *mrb, mrb_value self)
     
    9696
    9797/******************************************************/
    98 /* ファイルをコピーする: SD_copy*/
     98/* ファイルをコピーする: SD_copy*/
    9999/*      SD_copy( srcfilename, distfilename )*/
    100 /*  srcfilename: コピーå
    101 ƒãƒ•ã‚¡ã‚¤ãƒ«å*/
    102 /*  distfilename: コピーå
    103 ˆãƒ•ã‚¡ã‚¤ãƒ«å*/
    104 /**/
    105 /* 戻り値*/
    106 /*      成功: 1, 失敗: 0*/
     100/*  srcfilename: コピー元ファイル名*/
     101/*  distfilename: コピー先ファイル名*/
     102/**/
     103/* 戻り値*/
     104/*      成功: 1, 失敗: 0*/
    107105/******************************************************/
    108106mrb_value mrb_sdcard_copy(mrb_state *mrb, mrb_value self)
     
    124122        }
    125123
    126         /*既存のファイルをコピーする*/
     124        /*既存のファイルをコピーする*/
    127125        File *s = &Fp[0];
    128126        File *d = &Fp[1];
     
    147145
    148146/******************************************************/
    149 /* ディレクトリを削除する: SD_rmdir*/
     147/* ディレクトリを削除する: SD_rmdir*/
    150148/*      SD_rmdir( dirname )*/
    151 /*  dirname: 削除するディレクトリ名*/
    152 /**/
    153 /* 戻り値*/
    154 /*      成功: 1, 失敗: 0*/
     149/*  dirname: 削除するディレクトリ名*/
     150/**/
     151/* 戻り値*/
     152/*      成功: 1, 失敗: 0*/
    155153/******************************************************/
    156154mrb_value mrb_sdcard_rmdir(mrb_state *mrb, mrb_value self)
     
    172170
    173171/******************************************************/
    174 /* ファイルをオープンします: SD_open*/
     172/* ファイルをオープンします: SD_open*/
    175173/*      SD_open( number, filename[, mode] )*/
    176 /*      number: ファイル番号 0 または 1*/
    177 /*      filename: ファイル名(8.3形式)*/
     174/*      number: ファイル番号 0 または 1*/
     175/*      filename: ファイル名(8.3形式)*/
    178176/*      mode: 0:Read, 1:Append, 2:New Create*/
    179 /* 戻り値*/
    180 /*      成功: 番号, 失敗: -1*/
     177/* 戻り値*/
     178/*      成功: 番号, 失敗: -1*/
    181179/******************************************************/
    182180mrb_value mrb_sdcard_open(mrb_state *mrb, mrb_value self)
     
    196194
    197195        if (mode == 2) {
    198                 /*新規書き込み*/
     196                /*新規書き込み*/
    199197                if (SD_exists(str) == true) {
    200198                        SD_remove(str);
     
    221219
    222220/******************************************************/
    223 /* openしたファイルをクローズします: SD_close*/
     221/* openしたファイルをクローズします: SD_close*/
    224222/*      SD_close( number )*/
    225 /*      number: ファイル番号 0 または 1*/
     223/*      number: ファイル番号 0 または 1*/
    226224/******************************************************/
    227225mrb_value mrb_sdcard_close(mrb_state *mrb, mrb_value self)
     
    235233        }
    236234
    237         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    238 }
    239 
    240 /******************************************************/
    241 /* openしたファイルから1バイト読み込みます: SD_read*/
     235        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     236}
     237
     238/******************************************************/
     239/* openしたファイルから1バイト読み込みます: SD_read*/
    242240/*      SD_read( number )*/
    243 /*      number: ファイル番号 0 または 1*/
    244 /* 戻り値*/
    245 /*      0x00~0xFFが返る。ファイルの最後だったら-1が返る。*/
     241/*      number: ファイル番号 0 または 1*/
     242/* 戻り値*/
     243/*      0x00~0xFFが返る。ファイルの最後だったら-1が返る。*/
    246244/******************************************************/
    247245mrb_value mrb_sdcard_read(mrb_state *mrb, mrb_value self)
     
    260258
    261259/******************************************************/
    262 /* openしたファイルの読み出し位置を移動する: SD_seek*/
     260/* openしたファイルの読み出し位置を移動する: SD_seek*/
    263261/*      SD_seek( number, byte )*/
    264 /*      number: ファイル番号 0 または 1*/
    265 /*      byte: seekするバイト数(-1)でファイルの最後に移動する*/
    266 /* 戻り値*/
    267 /*      成功: 1, 失敗: 0*/
     262/*      number: ファイル番号 0 または 1*/
     263/*      byte: seekするバイト数(-1)でファイルの最後に移動する*/
     264/* 戻り値*/
     265/*      成功: 1, 失敗: 0*/
    268266/******************************************************/
    269267mrb_value mrb_sdcard_seek(mrb_state *mrb, mrb_value self)
     
    291289
    292290/******************************************************/
    293 /* openしたファイルにバイナリデータを書き込む: SD_write*/
     291/* openしたファイルにバイナリデータを書き込む: SD_write*/
    294292/*      SD_write( number, buf, len )*/
    295 /*      number: ファイル番号 0 または 1*/
    296 /*      buf: 書き込むデータ*/
    297 /*      len: 書き込むデータサイズ*/
    298 /* 戻り値*/
    299 /*      実際に書いたバイト数*/
     293/*      number: ファイル番号 0 または 1*/
     294/*      buf: 書き込むデータ*/
     295/*      len: 書き込むデータサイズ*/
     296/* 戻り値*/
     297/*      実際に書いたバイト数*/
    300298/******************************************************/
    301299mrb_value mrb_sdcard_write(mrb_state *mrb, mrb_value self)
     
    318316
    319317/******************************************************/
    320 /* openしたファイルの書き込みをフラッシュします: SD_flush*/
     318/* openしたファイルの書き込みをフラッシュします: SD_flush*/
    321319/*      SD_flush( number )*/
    322 /*      number: ファイル番号 0 または 1*/
     320/*      number: ファイル番号 0 または 1*/
    323321/******************************************************/
    324322mrb_value mrb_sdcard_flush(mrb_state *mrb, mrb_value self)
     
    332330        }
    333331
    334         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    335 }
    336 
    337 /******************************************************/
    338 /* openしたファイルのサイズを取得します: SD_size*/
     332        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     333}
     334
     335/******************************************************/
     336/* openしたファイルのサイズを取得します: SD_size*/
    339337/*      SD_size( number )*/
    340 /*      number: ファイル番号 0 または 1*/
    341 /**/
    342 /* 戻り値*/
    343 /*      ファイルサイズ*/
     338/*      number: ファイル番号 0 または 1*/
     339/**/
     340/* 戻り値*/
     341/*      ファイルサイズ*/
    344342/******************************************************/
    345343mrb_value mrb_sdcard_size(mrb_state *mrb, mrb_value self)
     
    358356
    359357/******************************************************/
    360 /* openしたファイルのseek位置を取得します: SD_position*/
     358/* openしたファイルのseek位置を取得します: SD_position*/
    361359/*      SD_position( number )*/
    362 /*      number: ファイル番号 0 または 1*/
    363 /**/
    364 /* 戻り値*/
    365 /*      シーク位置*/
     360/*      number: ファイル番号 0 または 1*/
     361/**/
     362/* 戻り値*/
     363/*      シーク位置*/
    366364/******************************************************/
    367365mrb_value mrb_sdcard_position(mrb_state *mrb, mrb_value self)
     
    380378
    381379/******************************************************/
    382 /* ライブラリを定義します*/
     380/* ライブラリを定義します*/
    383381/******************************************************/
    384382int sdcard_Init(mrb_state *mrb)
    385383{
    386         /*日付と時刻を返す関数を登録*/
     384        /*日付と時刻を返す関数を登録*/
    387385        /*SdFile::dateTimeCallback( &SD_DateTime );*/
    388386
     
    408406
    409407/******************************************************/
    410 /* 日付と時刻を返すコールバック関数*/
     408/* 日付と時刻を返すコールバック関数*/
    411409/******************************************************/
    412410void SD_DateTime(uint16_t *date, uint16_t *time)
     
    427425        second = tm->tm_sec;
    428426
    429         /* FAT_DATEマクロでフィールドを埋めて日付を返す*/
     427        /* FAT_DATEマクロでフィールドを埋めて日付を返す*/
    430428        *date = (year - 1980) << 9 | month << 5 | day;
    431429
    432         /* FAT_TIMEマクロでフィールドを埋めて時間を返す*/
     430        /* FAT_TIMEマクロでフィールドを埋めて時間を返す*/
    433431        *time = hour << 11 | minute << 5 | second >> 1;
    434432}
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sSdCard.h

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-chdr to text/x-chdr;charset=UTF-8
    r270 r321  
    11/*
    2  * SDカード関連
     2 * SDカード関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    99 */
    1010/******************************************************/
    11 /* ライブラリを定義します*/
     11/* ライブラリを定義します*/
    1212/******************************************************/
    1313int sdcard_Init(mrb_state *mrb);
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sSerial.c

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-csrc to text/x-csrc;charset=UTF-8
    r270 r321  
    11/*
    2  * シリアル通信関連
     2 * シリアル通信関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    2424
    2525/******************************************************/
    26 /* メモリの開放時に走る*/
     26/* メモリの開放時に走る*/
    2727/******************************************************/
    2828static void mrb_serial_free(mrb_state *mrb, void *ptr)
     
    3333
    3434/******************************************************/
    35 /* この構造体の意味はよくわかっていない*/
     35/* この構造体の意味はよくわかっていない*/
    3636/******************************************************/
    3737static struct mrb_data_type serial_type = {"Serial", mrb_serial_free};
     
    3939
    4040/******************************************************/
    41 /* シリアル通信を初期化します: Serial.new*/
    42 /*  Serial.new(num[, bps]) */
    43 /*  num: 通信番号(0:USB, 1:TX-0/RX-1, 2:TX-5/RX-6, 3:TX-7/RX-8, 4:TX-12/RX-11, 5:TX-9(26)/RX-3)*/
    44 /*  bps: ボーレート*/
     41/* シリアル通信を初期化します: Serial.new*/
     42/*  Serial.new(num[, bps]) */
     43/*  num: 通信番号(0:USB, 1:TX-0/RX-1, 2:TX-5/RX-6, 3:TX-7/RX-8, 4:TX-12/RX-11, 5:TX-9(26)/RX-3)*/
     44/*  bps: ボーレート*/
    4545/**/
    46 /* 戻り値*/
    47 /*  Serialのインスタンス*/
     46/* 戻り値*/
     47/*  Serialのインスタンス*/
    4848/******************************************************/
    4949static mrb_value mrb_serial_initialize(mrb_state *mrb, mrb_value self)
     
    6060
    6161        if (num < 0 && num >= SERIAL_MAX) {
    62                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     62                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    6363        }
    6464
    6565        if(!portToPins(num, &txpin, &rxpin))
    66                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     66                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    6767
    6868        serial_t* serialc = mrb_malloc(mrb, sizeof(serial_t));
     
    7878
    7979/******************************************************/
    80 /* ボーレートを設定します: Serial.bps*/
     80/* ボーレートを設定します: Serial.bps*/
    8181/*  Serial.bps(bps)*/
    82 /*  bps: ボーレート */
     82/*  bps: ボーレート */
    8383/******************************************************/
    8484mrb_value mrb_serial_bps(mrb_state *mrb, mrb_value self)
     
    9292        serial_baud(serialc, bps);
    9393
    94         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    95 }
    96 
    97 /******************************************************/
    98 /* シリアルに出力します: Serial.print*/
     94        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     95}
     96
     97/******************************************************/
     98/* シリアルに出力します: Serial.print*/
    9999/*  Serial.print([str])*/
    100 /*  str: 文字列*/
    101 /*    省略時は何も出力しません*/
     100/*  str: 文字列*/
     101/*    省略時は何も出力しません*/
    102102/******************************************************/
    103103mrb_value mrb_serial_print(mrb_state *mrb, mrb_value self)
     
    112112                serial_print(serialc, RSTRING_PTR(text));
    113113        }
    114         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    115 }
    116 
    117 /******************************************************/
    118 /* シリアルに\r\n付きで出力します: Serial.println*/
     114        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     115}
     116
     117/******************************************************/
     118/* シリアルに\r\n付きで出力します: Serial.println*/
    119119/*  Serial.println([str])*/
    120 /*  str: 文字列*/
    121 /*    省略時は改行のみ*/
     120/*  str: 文字列*/
     121/*    省略時は改行のみ*/
    122122/******************************************************/
    123123mrb_value mrb_serial_println(mrb_state *mrb, mrb_value self)
     
    135135                serial_println(serialc, "");
    136136        }
    137         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    138 }
    139 
    140 /******************************************************/
    141 /* シリアルデータがあるかどうか調べます: Serial.available*/
     137        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     138}
     139
     140/******************************************************/
     141/* シリアルデータがあるかどうか調べます: Serial.available*/
    142142/*  Serial.available()*/
    143 /*  戻り値 シリアルバッファにあるデータのバイト数。0の場合はデータなし*/
     143/*  戻り値 シリアルバッファにあるデータのバイト数。0の場合はデータなし*/
    144144/******************************************************/
    145145mrb_value mrb_serial_available(mrb_state *mrb, mrb_value self)
     
    151151
    152152/******************************************************/
    153 /* シリアルからデータを取得します: Serial.read*/
     153/* シリアルからデータを取得します: Serial.read*/
    154154/*  Serial.read()*/
    155 /* 戻り値*/
    156 /*      データé
    157 åˆ—*/
     155/* 戻り値*/
     156/*      データ配列*/
    158157/******************************************************/
    159158mrb_value mrb_serial_read(mrb_state *mrb, mrb_value self)
     
    176175
    177176/******************************************************/
    178 /* シリアルにデータを出力します: Serial.write*/
     177/* シリアルにデータを出力します: Serial.write*/
    179178/*  Serial.write(buf,len)*/
    180 /*      buf: 出力データ*/
    181 /*      len: 出力データサイズ*/
    182 /* 戻り値*/
    183 /*      出力したバイト数*/
     179/*      buf: 出力データ*/
     180/*      len: 出力データサイズ*/
     181/* 戻り値*/
     182/*      出力したバイト数*/
    184183/******************************************************/
    185184mrb_value mrb_serial_write(mrb_state *mrb, mrb_value self)
     
    202201
    203202/******************************************************/
    204 /* シリアルデータをフラッシュします: Serial.flash*/
     203/* シリアルデータをフラッシュします: Serial.flash*/
    205204/*  Serial.flash()*/
    206205/******************************************************/
     
    211210        //serial_flush(serialc);
    212211
    213         return mrb_nil_value();                 /*戻り値は無しですよ。*/
     212        return mrb_nil_value();                 /*戻り値は無しですよ。*/
    214213}
    215214#if 0
    216215unsigned char WiFiData[256];
    217216/***************************************************/
    218 /* USBポートとESP8266をシリアルで直結します: WiFi.bypass*/
     217/* USBポートとESP8266をシリアルで直結します: WiFi.bypass*/
    219218/*  WiFi.bypass()*/
    220 /* リセットするまで、処理は戻りません。*/
     219/* リセットするまで、処理は戻りません。*/
    221220//**************************************************/
    222221mrb_value mrb_wifi_bypass(mrb_state *mrb, mrb_value self)
     
    238237                                WiFiData[i] = (unsigned char)serial_read(RbSerial[0]);
    239238
    240                                 if(WiFiData[i] == 0x0d){ /*0x0Dのみの改行を連打したらbypassモードを抜ける*/
     239                                if(WiFiData[i] == 0x0d){ /*0x0Dのみの改行を連打したらbypassモードを抜ける*/
    241240                                        retCnt++;
    242241                                        if(retCnt > 20){
    243                                                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     242                                                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    244243                                        }
    245244                                }
     
    260259                }
    261260        }
    262         return mrb_nil_value();                 /*戻り値は無しですよ。*/
     261        return mrb_nil_value();                 /*戻り値は無しですよ。*/
    263262}
    264263#endif
    265264
    266265/******************************************************/
    267 /* ライブラリを定義します*/
     266/* ライブラリを定義します*/
    268267/******************************************************/
    269268void serial_Init(mrb_state* mrb)
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sSerial.h

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-chdr to text/x-chdr;charset=UTF-8
    r270 r321  
    11/*
    2  * シリアル通信関連
     2 * シリアル通信関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    99 */
    1010/******************************************************/
    11 /* ライブラリを定義します*/
     11/* ライブラリを定義します*/
    1212/******************************************************/
    1313void serial_Init(mrb_state *mrb);
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sServo.c

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-csrc to text/x-csrc;charset=UTF-8
    r270 r321  
    11/*
    2  * サーボ・ハード関連
     2 * サーボ・ハード関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    2222
    2323/******************************************************/
    24 /* サーボ出力を任意のピンに割り当てます: Servo.attach*/
     24/* サーボ出力を任意のピンに割り当てます: Servo.attach*/
    2525/* Servo.attach(ch, pin[,min,max])*/
    26 /*      ch: サーボのチャネル 0~11まで指定できます*/
    27 /*  pin: 割り当てるピン番号*/
    28 /*  min: サーボの角度が0度のときのパルスå¹
    29 (マイクロ秒)。デフォルトは544*/
    30 /*  max: サーボの角度が180度のときのパルスå¹
    31 (マイクロ秒)。デフォルトは2400*/
     26/*      ch: サーボのチャネル 0~11まで指定できます*/
     27/*  pin: 割り当てるピン番号*/
     28/*  min: サーボの角度が0度のときのパルス幅(マイクロ秒)。デフォルトは544*/
     29/*  max: サーボの角度が180度のときのパルス幅(マイクロ秒)。デフォルトは2400*/
    3230/******************************************************/
    3331mrb_value mrb_servo_attach(mrb_state *mrb, mrb_value self)
     
    4240
    4341        if (pinno >= 20) {
    44                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
    45         }
    46 
    47         /* nが2以下のときは、minが引数に無いので、 */
     42                return mrb_nil_value();                 /*戻り値は無しですよ。*/
     43        }
     44
     45        /* nが2以下のときは、minが引数に無いので、 */
    4846        if (n <= 2) {
    4947                min = 544;
    5048        }
    5149
    52         /* nが3以下のときは、maxが引数に無いので、 */
     50        /* nが3以下のときは、maxが引数に無いので、 */
    5351        if (n <= 3) {
    5452                max = 2400;
     
    5654
    5755        if (ch < 0 || ch >= ATTACH_MAX) {
    58                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     56                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    5957        }
    6058
     
    6664        pin = get_pin(pintype_pwmout, pinno);
    6765        if (pin == NULL)
    68                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     66                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    6967
    7068        servo[ch] = pin;
     
    7270        servo[ch]->max = max;
    7371
    74         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    75 }
    76 
    77 /******************************************************/
    78 /* サーボの角度をセットします: Servo.write*/
     72        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     73}
     74
     75/******************************************************/
     76/* サーボの角度をセットします: Servo.write*/
    7977/* Servo.write(ch,angle)*/
    80 /*      ch: サーボのチャネル 0~11まで指定できます*/
    81 /*  angle: 角度 0~180*/
     78/*      ch: サーボのチャネル 0~11まで指定できます*/
     79/*  angle: 角度 0~180*/
    8280/******************************************************/
    8381mrb_value mrb_servo_write(mrb_state *mrb, mrb_value self)
     
    9189
    9290        if (ch < 0 || ch >= ATTACH_MAX) {
    93                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     91                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    9492        }
    9593
    9694        if (servo[ch] == NULL) {
    97                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     95                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    9896        }
    9997
     
    106104        pwmout_pulsewidth_us(&servo[ch]->pwmout, (angle * (max - min)) / 180 + min);
    107105
    108         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    109 }
    110 
    111 /******************************************************/
    112 /* サーボモータにus単位で角度を指定する: Servo.us*/
     106        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     107}
     108
     109/******************************************************/
     110/* サーボモータにus単位で角度を指定する: Servo.us*/
    113111/* Servo.us(ch,us)*/
    114 /*      ch: サーボのチャネル 0~11まで指定できます*/
    115 /*  us: 出力したいパルスのå¹
    116  1~19999, 0で出力 OFF*/
    117 /*   ã‚µãƒ¼ãƒœãƒ¢ãƒ¼ã‚¿ã«ä¸Žãˆã‚‰ã‚Œã‚‹ãƒ‘ルスは20ms周期で、1周期中のHighの時間を直接指定する。*/
    118 /*   å®Ÿè³ªçš„にPWM出力。連続回転タイプのサーボでは、回転のスピードが設定することができる。*/
     112/*      ch: サーボのチャネル 0~11まで指定できます*/
     113/*  us: 出力したいパルスの幅 1~19999, 0で出力 OFF*/
     114/*   サーボモータに与えられるパルスは20ms周期で、1周期中のHighの時間を直接指定する。*/
     115/*   実質的にPWM出力。連続回転タイプのサーボでは、回転のスピードが設定することができる。*/
    119116/******************************************************/
    120117mrb_value mrb_servo_us(mrb_state *mrb, mrb_value self)
     
    126123
    127124        if (ch < 0 || ch >= ATTACH_MAX) {
    128                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     125                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    129126        }
    130127
    131128        if (servo[ch] == 0) {
    132                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     129                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    133130        }
    134131
    135132        pwmout_pulsewidth_us(&servo[ch]->pwmout, us);
    136133
    137         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    138 }
    139 
    140 /******************************************************/
    141 /* 最後に設定された角度を読み出す: Servo.read*/
     134        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     135}
     136
     137/******************************************************/
     138/* 最後に設定された角度を読み出す: Servo.read*/
    142139/* Servo.read(ch)*/
    143 /*      ch: サーボのチャネル 0~11まで指定できます*/
    144 /* 戻り値*/
    145 /*  マイクロ秒単位 us(ch) で与えた値は読みとれない*/
     140/*      ch: サーボのチャネル 0~11まで指定できます*/
     141/* 戻り値*/
     142/*  マイクロ秒単位 us(ch) で与えた値は読みとれない*/
    146143/******************************************************/
    147144mrb_value mrb_servo_read(mrb_state *mrb, mrb_value self)
     
    166163
    167164/******************************************************/
    168 /* ピンにサーボが割り当てられているかを確認する: Servo.attached*/
     165/* ピンにサーボが割り当てられているかを確認する: Servo.attached*/
    169166/* Servo.attached(ch)*/
    170 /*      ch: サーボのチャネル 0~11まで指定できます*/
    171 /* 戻り値*/
    172 /*  1: 割り当てられている*/
    173 /*  0: 割り当てはない*/
     167/*      ch: サーボのチャネル 0~11まで指定できます*/
     168/* 戻り値*/
     169/*  1: 割り当てられている*/
     170/*  0: 割り当てはない*/
    174171/******************************************************/
    175172mrb_value mrb_servo_attached(mrb_state *mrb, mrb_value self)
     
    196193
    197194/******************************************************/
    198 /* サーボの動作を止め、割り込みを禁止する: Servo.detach*/
     195/* サーボの動作を止め、割り込みを禁止する: Servo.detach*/
    199196/* Servo.detach(ch)*/
    200 /*      ch: サーボのチャネル 0~9まで指定できます*/
     197/*      ch: サーボのチャネル 0~9まで指定できます*/
    201198/******************************************************/
    202199mrb_value mrb_servo_detach(mrb_state *mrb, mrb_value self)
     
    207204
    208205        if (ch < 0 || ch >= ATTACH_MAX) {
    209                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     206                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    210207        }
    211208
    212209        if (servo[ch] == NULL) {
    213                 return mrb_nil_value();                 /*戻り値は無しですよ。*/
     210                return mrb_nil_value();                 /*戻り値は無しですよ。*/
    214211        }
    215212
     
    217214        servo[ch] = 0;
    218215
    219         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    220 }
    221 
    222 /******************************************************/
    223 /* ライブラリを定義します*/
     216        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     217}
     218
     219/******************************************************/
     220/* ライブラリを定義します*/
    224221/******************************************************/
    225222void servo_Init(mrb_state *mrb)
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sServo.h

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-chdr to text/x-chdr;charset=UTF-8
    r270 r321  
    11/*
    2  * サーボ・ハード関連
     2 * サーボ・ハード関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    99 */
    1010/******************************************************/
    11 /* ライブラリを定義します*/
     11/* ライブラリを定義します*/
    1212/******************************************************/
    1313void servo_Init(mrb_state *mrb);
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sSys.c

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-csrc to text/x-csrc;charset=UTF-8
    r270 r321  
    11/*
    2  * システム関連
     2 * システム関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    2828
    2929/******************************************************/
    30 /* 終了させます*/
     30/* 終了させます*/
    3131/*      System.exit()*/
    32 /*      エラー値がもどり、即終了*/
     32/*      エラー値がもどり、即終了*/
    3333/******************************************************/
    3434mrb_value mrb_system_exit(mrb_state *mrb, mrb_value self)
     
    3636        mrb_raise(mrb, mrb_class_get(mrb, "Sys#exit Called"), "Normal Completion");
    3737
    38         return mrb_nil_value(); /*戻り値は無しですよ。*/
    39 }
    40 
    41 /******************************************************/
    42 /* 次に実行するスクリプトファイルをVmFilenameにセットします。*/
     38        return mrb_nil_value(); /*戻り値は無しですよ。*/
     39}
     40
     41/******************************************************/
     42/* 次に実行するスクリプトファイルをVmFilenameにセットします。*/
    4343/* System.setRun( filename )*/
    4444/******************************************************/
     
    5656        RubyFilename[0] = '\0';
    5757
    58         return mrb_nil_value(); /*戻り値は無しですよ。*/
    59 }
    60 
    61 /******************************************************/
    62 /* システムのバージョンを取得します*/
     58        return mrb_nil_value(); /*戻り値は無しですよ。*/
     59}
     60
     61/******************************************************/
     62/* システムのバージョンを取得します*/
    6363/* System.version([R])*/
    64 /* 引数があればmrubyのバーションを返す*/
     64/* 引数があればmrubyのバーションを返す*/
    6565/******************************************************/
    6666mrb_value mrb_system_version(mrb_state *mrb, mrb_value self)
     
    7878
    7979/******************************************************/
    80 /*フラッシュメモリに書き込みます*/
     80/*フラッシュメモリに書き込みます*/
    8181/* System.push(address, buf, length)*/
    82 /*      address: 書き込み開始アドレス(0x0000~0x00ff)*/
    83 /*  buf: 書き込むデータ*/
    84 /*  length: 書き込むサイズ*/
    85 /* 戻り値*/
    86 /*  1:成功, 0:失敗*/
     82/*      address: 書き込み開始アドレス(0x0000~0x00ff)*/
     83/*  buf: 書き込むデータ*/
     84/*  length: 書き込むサイズ*/
     85/* 戻り値*/
     86/*  1:成功, 0:失敗*/
    8787/******************************************************/
    8888mrb_value mrb_system_push(mrb_state *mrb, mrb_value self)
     
    115115
    116116/******************************************************/
    117 /*フラッシュメモリから読み出します*/
     117/*フラッシュメモリから読み出します*/
    118118/* System.pop(address, length)*/
    119 /*      address: 読み込みアドレス(0x0000~0x00ff)*/
    120 /*  length: 読み込みサイズ(MAX 32バイト)*/
    121 /* 戻り値*/
    122 /*  読み込んだデータ*/
     119/*      address: 読み込みアドレス(0x0000~0x00ff)*/
     120/*  length: 読み込みサイズ(MAX 32バイト)*/
     121/* 戻り値*/
     122/*  読み込んだデータ*/
    123123/******************************************************/
    124124mrb_value mrb_system_pop(mrb_state *mrb, mrb_value self)
     
    147147
    148148/******************************************************/
    149 /* ファイルローダーを呼び出します*/
     149/* ファイルローダーを呼び出します*/
    150150/* System.fileload()*/
    151151/******************************************************/
    152152mrb_value mrb_system_fileload(mrb_state *mrb, mrb_value self)
    153153{
    154         /*ファイルローダーの呼び出し*/
     154        /*ファイルローダーの呼び出し*/
    155155        if (fileloader((const char*)ProgVer, MRUBY_VERSION) == 1) {
    156                 mrb_full_gc(mrb);       /*強制GCをå
    157 ¥ã‚Œã‚‹*/
    158                 /*強制終了*/
     156                mrb_full_gc(mrb);       /*強制GCを入れる*/
     157                /*強制終了*/
    159158                mrb_raise(mrb, mrb_class_get(mrb, "Sys#exit Called"), "Normal Completion");
    160159        }
    161160
    162         mrb_full_gc(mrb);       /*強制GCをå
    163 ¥ã‚Œã‚‹*/
    164 
    165         return mrb_nil_value(); /*戻り値は無しですよ。*/
    166 }
    167 
    168 /******************************************************/
    169 /* リセットします*/
     161        mrb_full_gc(mrb);       /*強制GCを入れる*/
     162
     163        return mrb_nil_value(); /*戻り値は無しですよ。*/
     164}
     165
     166/******************************************************/
     167/* リセットします*/
    170168/* System.reset()*/
    171169/******************************************************/
    172170mrb_value mrb_system_reset(mrb_state *mrb, mrb_value self)
    173171{
    174         system_reboot(REBOOT_USERAPP);  /*リセット後にユーザアプリを起動する*/
    175 
    176         return mrb_nil_value(); /*戻り値は無しですよ。*/
    177 }
    178 
    179 /******************************************************/
    180 /* SDカードを使えるようにします: System.useSD*/
     172        system_reboot(REBOOT_USERAPP);  /*リセット後にユーザアプリを起動する*/
     173
     174        return mrb_nil_value(); /*戻り値は無しですよ。*/
     175}
     176
     177/******************************************************/
     178/* SDカードを使えるようにします: System.useSD*/
    181179/* System.useSD()*/
    182 /*戻り値*/
    183 /* 0:使用不可, 1:使用可能*/
     180/*戻り値*/
     181/* 0:使用不可, 1:使用可能*/
    184182/******************************************************/
    185183mrb_value mrb_system_useSD(mrb_state *mrb, mrb_value self)
     
    188186
    189187#if BOARD == BOARD_GR || FIRMWARE == SDBT || FIRMWARE == SDWF || BOARD == BOARD_P05 || BOARD == BOARD_P06
    190         ret = sdcard_Init(mrb);         /*SDカード関連メソッドの設定*/
     188        ret = sdcard_Init(mrb);         /*SDカード関連メソッドの設定*/
    191189#endif
    192190
     
    195193
    196194/******************************************************/
    197 /* WiFiモジュールESP8266ボードを使えるようにします: System.useWiFi*/
     195/* WiFiモジュールESP8266ボードを使えるようにします: System.useWiFi*/
    198196/* System.useWiFi()*/
    199 /*戻り値*/
    200 /* 0:使用不可, 1:使用可能*/
     197/*戻り値*/
     198/* 0:使用不可, 1:使用可能*/
    201199/******************************************************/
    202200mrb_value mrb_system_useWiFi(mrb_state *mrb, mrb_value self)
     
    205203
    206204#if (BOARD == FIRMWARE && BOARD == SDWF) || BOARD == BOARD_P05 || BOARD == BOARD_P06
    207         ret = esp8266_Init(mrb);                /*ESP8266ボード関連メソッドの設定*/
     205        ret = esp8266_Init(mrb);                /*ESP8266ボード関連メソッドの設定*/
    208206#endif
    209207
     
    212210
    213211/******************************************************/
    214 /* 実行しているmrbファイルパスを取得します: System.getMrbPath*/
     212/* 実行しているmrbファイルパスを取得します: System.getMrbPath*/
    215213/* System.getMrbPath()*/
    216 /*戻り値*/
    217 /* 実行しているmrbファイルパス*/
     214/*戻り値*/
     215/* 実行しているmrbファイルパス*/
    218216/******************************************************/
    219217mrb_value mrb_system_getmrbpath(mrb_state *mrb, mrb_value self)
     
    223221
    224222/******************************************************/
    225 /* ライブラリを定義します*/
     223/* ライブラリを定義します*/
    226224/******************************************************/
    227225void sys_Init(mrb_state *mrb)
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sSys.h

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-chdr to text/x-chdr;charset=UTF-8
    r270 r321  
    11/*
    2  * システム関連
     2 * システム関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    99 */
    1010/******************************************************/
    11 /* ライブラリを定義します*/
     11/* ライブラリを定義します*/
    1212/******************************************************/
    1313void sys_Init(mrb_state *mrb);
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sWiFi.c

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-csrc to text/x-csrc;charset=UTF-8
    r270 r321  
    11/*
    2  * ESP-WROOM-02関連
     2 * ESP-WROOM-02関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    2626
    2727unsigned char WiFiData[256];
    28 int WiFiRecvOutlNum = -1;       /*ESP8266からの受信を出力するシリアル番号: -1の場合は出力しない。*/
    29 
    30 /******************************************************/
    31 /* OK 0d0a か ERROR 0d0aが来るまで WiFiData[]に読むか、*/
    32 /* 指定されたシリアルポートに出力します*/
     28int WiFiRecvOutlNum = -1;       /*ESP8266からの受信を出力するシリアル番号: -1の場合は出力しない。*/
     29
     30/******************************************************/
     31/* OK 0d0a か ERROR 0d0aが来るまで WiFiData[]に読むか、*/
     32/* 指定されたシリアルポートに出力します*/
    3333/**/
    34 /* 1:受信した, 0:受信できなかった*/
     34/* 1:受信した, 0:受信できなかった*/
    3535/******************************************************/
    3636int getData(int wait_msec)
     
    4949        times = us_ticker_read() / 1000;
    5050        while (n < 256) {
    51                 /*digitalWrite(get_pin(WIFI_CTS), 0);   //送信許可*/
    52 
    53                 /*wait_msec å¾
    54 ã¤*/
     51                /*digitalWrite(get_pin(WIFI_CTS), 0);   //送信許可*/
     52
     53                /*wait_msec 待つ*/
    5554                if ((us_ticker_read() / 1000) - times > wait_msec) {
    5655                        DEBUG_PRINT("WiFi get Data", "Time OUT");
     
    6362                                c = serial_getc(RbSerial[WIFI_SERIAL]);
    6463
    65                                 /*指定のシリアルポートに出す設定であれば、受信値を出力します*/
     64                                /*指定のシリアルポートに出す設定であれば、受信値を出力します*/
    6665                                if (WiFiRecvOutlNum >= 0) {
    6766                                        serial_putc(RbSerial[WiFiRecvOutlNum], (unsigned char)c);
     
    107106                }
    108107        }
    109         /*digitalWrite(get_pin(WIFI_CTS), 0);   //送信許可*/
     108        /*digitalWrite(get_pin(WIFI_CTS), 0);   //送信許可*/
    110109        return 1;
    111110}
    112111
    113112/******************************************************/
    114 /* ステーションモードの設定: WiFi.cwmode*/
     113/* ステーションモードの設定: WiFi.cwmode*/
    115114/*  WiFi.cwmode(mode)*/
    116115/*  mode: 1:Station, 2:SoftAP, 3:Station + SoftAP*/
     
    128127        serial_println(RbSerial[WIFI_SERIAL], tmode);
    129128
    130         /*OK 0d0a か ERROR 0d0aが来るまで WiFiData[]に読か、指定されたシリアルポートに出力します*/
     129        /*OK 0d0a か ERROR 0d0aが来るまで WiFiData[]に読か、指定されたシリアルポートに出力します*/
    131130        getData(WIFI_WAIT_MSEC);
    132131
     
    135134
    136135/******************************************************/
    137 /* コマンド応答のシリアル出力設定: WiFi.sout*/
     136/* コマンド応答のシリアル出力設定: WiFi.sout*/
    138137/*  WiFi.sout( mode[,serialNumber] )*/
    139 /*      mode: 0:出力しない, 1:出力する*/
    140 /*  serialNumber: 出力å
    141 ˆã®ã‚·ãƒªã‚¢ãƒ«ç•ªå·*/
     138/*      mode: 0:出力しない, 1:出力する*/
     139/*  serialNumber: 出力先のシリアル番号*/
    142140/******************************************************/
    143141mrb_value mrb_wifi_Sout(mrb_state *mrb, mrb_value self)
     
    158156                }
    159157        }
    160         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    161 }
    162 
    163 /******************************************************/
    164 /* ATコマンドの送信: WiFi.at*/
     158        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     159}
     160
     161/******************************************************/
     162/* ATコマンドの送信: WiFi.at*/
    165163/*  WiFi.at( command[, mode] )*/
    166 /*      commnad: ATコマンドå†
    167 å®¹*/
    168 /*  mode: 0:'AT+'を自動追加する、1:'AT+'を自動追加しない*/
     164/*      commnad: ATコマンド内容*/
     165/*  mode: 0:'AT+'を自動追加する、1:'AT+'を自動追加しない*/
    169166/******************************************************/
    170167mrb_value mrb_wifi_at(mrb_state *mrb, mrb_value self)
     
    191188        /*DEBUG_PRINT("WiFi.at",(const char*)WiFiData);*/
    192189
    193         /*OK 0d0a か ERROR 0d0aが来るまで WiFiData[]に読か、指定されたシリアルポートに出力します*/
     190        /*OK 0d0a か ERROR 0d0aが来るまで WiFiData[]に読か、指定されたシリアルポートに出力します*/
    194191        getData(WIFI_WAIT_MSEC);
    195192
     
    198195
    199196/******************************************************/
    200 /* WiFi接続します: WiFi.cwjap*/
     197/* WiFi接続します: WiFi.cwjap*/
    201198/*  WiFi.cwjap(SSID,Passwd)*/
    202 /*  SSID: WiFiのSSID*/
    203 /*  Passwd: パスワード*/
     199/*  SSID: WiFiSSID*/
     200/*  Passwd: パスワード*/
    204201/******************************************************/
    205202mrb_value mrb_wifi_Cwjap(mrb_state *mrb, mrb_value self)
     
    245242        serial_println(RbSerial[WIFI_SERIAL], (const char*)WiFiData);
    246243
    247         /*OK 0d0a か ERROR 0d0aが来るまで WiFiData[]に読か、指定されたシリアルポートに出力します*/
     244        /*OK 0d0a か ERROR 0d0aが来るまで WiFiData[]に読か、指定されたシリアルポートに出力します*/
    248245        getData(WIFI_WAIT_MSEC);
    249246
     
    252249
    253250/******************************************************/
    254 /* IPアドレスとMACアドレスの表示: WiFi.cifsr*/
     251/* IPアドレスとMACアドレスの表示: WiFi.cifsr*/
    255252/*  WiFi.cwjap()*/
    256253/******************************************************/
     
    259256        serial_println(RbSerial[WIFI_SERIAL], "AT+CIFSR");
    260257
    261         /*OK 0d0a か ERROR 0d0aが来るまで WiFiData[]に読か、指定されたシリアルポートに出力します*/
     258        /*OK 0d0a か ERROR 0d0aが来るまで WiFiData[]に読か、指定されたシリアルポートに出力します*/
    262259        getData(WIFI_WAIT_MSEC);
    263260
     
    266263
    267264/******************************************************/
    268 /* USBポートとESP8266をシリアルで直結します: WiFi.bypass*/
     265/* USBポートとESP8266をシリアルで直結します: WiFi.bypass*/
    269266/*  WiFi.bypass()*/
    270 /* リセットするまで、処理は戻りません。*/
     267/* リセットするまで、処理は戻りません。*/
    271268/******************************************************/
    272269mrb_value mrb_wifi_bypass(mrb_state *mrb, mrb_value self)
     
    297294                }
    298295        }
    299         return mrb_nil_value();                 /*戻り値は無しですよ。*/
    300 }
    301 
    302 /******************************************************/
    303 /* ライブラリを定義します*/
     296        return mrb_nil_value();                 /*戻り値は無しですよ。*/
     297}
     298
     299/******************************************************/
     300/* ライブラリを定義します*/
    304301/******************************************************/
    305302int esp8266_Init(mrb_state *mrb)
     
    307304        PinName txpin, rxpin;
    308305
    309         /*ESP8266からの受信を出力しないに設定*/
     306        /*ESP8266からの受信を出力しないに設定*/
    310307        WiFiRecvOutlNum = -1;
    311308
    312         /*CTS用にPIN15をOUTPUTに設定します*/
     309        /*CTS用にPIN15をOUTPUTに設定します*/
    313310        /*pinMode(get_pin(WIFI_CTS), 1);*/
    314311        /*digitalWrite(get_pin(WIFI_CTS), 1);*/
    315312
    316         /*WiFiのシリアル3を設定*/
    317         /*シリアル通信の初期化をします*/
     313        /*WiFiのシリアル3を設定*/
     314        /*シリアル通信の初期化をします*/
    318315        portToPins(SCI_SCI0P2x, &txpin, &rxpin);
    319316        serial_init(RbSerial[WIFI_SERIAL], txpin, rxpin);
     
    321318        int len;
    322319
    323         /*受信バッファを空にします*/
     320        /*受信バッファを空にします*/
    324321        while ((len = serial_readable(RbSerial[WIFI_SERIAL])) > 0) {
    325322                /*serial_print(RbSerial[0], len);*/
     
    329326        }
    330327
    331         /*ECHOオフコマンドを送信する*/
     328        /*ECHOオフコマンドを送信する*/
    332329        serial_println(RbSerial[WIFI_SERIAL], "ATE0");
    333330
    334         /*OK 0d0a か ERROR 0d0aが来るまで WiFiData[]に読む*/
     331        /*OK 0d0a か ERROR 0d0aが来るまで WiFiData[]に読む*/
    335332        if (getData(500) == 0) {
    336333                return 0;
  • EcnlProtoTool/trunk/mrbgems/mruby-arduino/src/sWiFi.h

    • Property svn:keywords deleted
    • Property svn:mime-type changed from text/x-chdr to text/x-chdr;charset=UTF-8
    r270 r321  
    11/*
    2  * ESP-WROOM-02関連
     2 * ESP-WROOM-02関連
    33 *
    44 * Copyright (c) 2016 Wakayama.rb Ruby Board developers
     
    99 */
    1010/******************************************************/
    11 /* ライブラリを定義します*/
     11/* ライブラリを定義します*/
    1212/******************************************************/
    1313int esp8266_Init(mrb_state *mrb);
Note: See TracChangeset for help on using the changeset viewer.