MacBook Pro を買う

以前に、Mac Mini を購入して、iPhone のソフトでも作ろうと思い色々やっていたけど、ある程度「俺俺フレームワーク」が動くようになってからは、Windows 環境に移って、放置していた。

ノートPCを新規に購入する時も、MacAir13 とかで悩んだけど、画面の解像度が低いのと、ビデオデバイスが、インテル内蔵でショボイので、敬遠して、NVIDIA のビデオデバイス内蔵で、薄くて軽い、ASUSのUltraBookを購入した。

知り合いに、「今時、Windows」などと言われて、「Mac が一番だと思ってるやつ」の心の狭さに、引いたー。

そんで、最近、仕事で Android のソフト開発をするようになったんだけど、Windows では、開発出来ない状況を経験だった、(みんな Mac を使っていた)。
これは、NDKで開発しているのだけど、C++ のソース数が異常に多くて(350ファイルくらいある)、Windows(cygwin) では、コマンドラインで受け付けるバッファがオーバーフローしてしまい、リンク出来ない。
※情けないぞ!

仕方無いので会社では Mac を使っていたが、たまたま、Mac のホームページを観にいったら、最近出た、インテルの新しい CPU を使い、Retina ディスプレイで、光学ドライブが無く、薄型で、軽い(1.57キロ)「MacBook Pro」が目に止まり、興味をそそられた。
会社で使っているのも Mac なので、ビデオデバイスが、インテルでショボイけど、ここらで、MacBook も欲しいなぁーと思い、ポチってしまった!
メモリーは、折角だから 16GB とかにしておいたが、かなりの高額な物になってしまったが仕方無い・・・

買って使ってみると、思いの他快適な事に少し驚いたが、何もかも Mac で完結する訳でも無いので、悪くは無いよねーって、少し強がってみる〜www

そんで良かったと思う事などー

・タッチパッドの操作性が凄く良い!
※UltraBook も少し見習うべき!
※このくらい操作性が良いと、普通の操作ではマウスは必要無いなぁー

・電池が凄く持つ!
※これは新しいインテルの CPU も貢献しているのかも。

・電池で動作させていても、電源を繋いでいる時とあまり変わらない操作性。
※よく出来ている〜

・基本 unix なんで、MinGW とかから違和感無く使え、ターミナル上で、emacs も普通に動く。

駄目なとこは・・・

・Windows にあって Mac に無いフリーソフトが結構あって、多少辛いとこもある。

・やはりシングルボタン系では厳しい場面がある。

・値段が少し高い。
※確かに、細かい部分の作り込みなど、非常に良く考えられていて、素晴らしい完成度なのだが、UltraBook とかの同列機から考えると、2割くらい割高だから、当たり前とも言えるか・・・

・ビデオデバイスが選べず、インテル内蔵のショボイまんま
※これは全体の構成を考えると、仕方無い部分もある、セカンダリーのデバイスを乗せると、電気も食うし、色々と考えなければならない事が多くある、セカンダリーのビデオデバイスを必要とする人も凄く少ないから、まぁしょうがないな・・・

そんなこんなで、結構快適に使ってますーwww

MacBook Pro 13 retina

次は、Windows で作っていた、「俺俺フレームワーク」を Mac に対応したので、次のブログで紹介したいと思います。

Makefile による別ディレクトリーへのオブジェクト、従属規則のセーブ

今まで、従属規則の生成には、X11 のコマンドであるところの「makedepend」を長らく使って来た、しかし、makedepend コマンドが無い場合(X11 関係アーカイブをインストールする必要がある)
や、コンパイラがインクルードファイルを検索する挙動とは多少違う場合もあったりしていた。
そこで、「gcc」の「-MM」オプションを使ってインクルードパスを収集する方法に切り替えた。
※このコンパイラーオプションは、コンパイラー自らのパスでインクルードファイルのフルパスを出力する、この時、「#if、#endif」などの制御文なども評価する。

通常、コンパイラーは、ソースコードと同じ場所にオブジェクトを生成する、ソースコードを共有して、複数のアプリケーションを作成すると、それでは、不具合が起こる場合もあり(コンパイラーオプションや、デバッグ、リリースビルドなど)、アプリケーション毎に、生成されたオブジェクトコードを管理したい。
そこで、生成オブジェクトを特定のディレクトリーに集中させるようにした。

また、複数のアプリケーションで Makefile の修正を最小限に出来るように、多少の工夫をしてみた。

Makefile の構文を学習しなおしたり、google 先生に教えてもらった make 関係のリンクを観たりで、自分の思ったような構成に出来たので紹介する。

ディレクトリーは以下のような構成にしている。

project:
    common:      ---> アプリケーション共通のソースコードを格納するディレクトリー
        ...:     ---> ソースモジュール毎のディレクトリー
            ...  ---> ソース郡
        ...:
            ...
        ...:
            ...
    xxxx:           ---> xxxx アプリケーションディレクトリー
        xxxx.cpp    ---> xxxx アプリケーション固有のソースコード
        Makefile    ---> xxxx アプリケーションの Makefile
    yyyy:           ---> yyyy アプリケーションディレクトリー
        yyyy.cpp
        Makefile

・各アプリケーションで共通するソースコード郡を「common」ディレクトリーに配置している。
・アプリケーションは、専用ディレクトリーを設けて、そこで、生成された二次ファイルを格納する。
※通常、「release」、「debug」のどちらか

一番のキモは、-MM コマンドの仕様で痛い部分を回避する為の小細工で、以下のリンクを参考にした。
※スイマセン、殆ど同じような物です、VPATH の指定が追加されたくらいです。

Makefile 別ディレクトリに中間ファイル & 自動依存関係設定

この問題は、オブジェクトファイルのパスがフルパスにならない点で、これを改善する為、sed による整形を使って、回避している。
リンクの sed スクリプトでは、「.o」のマッチングが不十分で、特定のファイル名の組み合わせなどで整形を失敗する、そこで、適切に修正した。
「\.o:」「.」を「\.」にする事で、正確に「.」(ピリオド)にマッチするようになる、また、一応、セパレーター「:」を追加して、厳密にマッチするようにしてある。
※詳しくは sed の仕様、-MM の説明を参照の事

「VPATH」を指定すると、make が、ファイルを検索するルートを指定出来るので、関係ソースコードを羅列する部分がスッキリする。

・以下の例は、アプリケーション「player」の Makefile です。
・「TARGET」アプリケーション名(Windows では .exe を追加する)
・「ICON_RC」アプリケーションアイコン指定がある場合、リソースの記述を行う
icon.rcの例

EXE_ICON ICON res/player.ico

・「BUILD」ビルドディレクトリー(debug、又は、release)
※従属規則 *.d 、とオブジェクトファイル *.o が格納される。
・「VPATH」共有ソースコードのルートディレクトリー
・「CSOURCES」C 言語ソースコードのリスト
・「PSOURCES」C++ 言語ソースコードのリスト
・「STDLIBS」標準的ライブラリーのリスト
・「OPTLIBS」オプションライブラリーのリスト
・「INC_SYS」システム系のインクルードパス
・「INC_LIB」ローカルライブラリーのインクルードパス
※従属規則に含まれない
・「PINC_APP」C++ 言語用、インクルードパス
・「CINC_APP」C 言語用、インクルードパス
※従属規則に含まれる
・「LIBDIR」ローカルライブラリーオブジェクトのリンクパス

# Makefile
TARGET    = player.exe

ICON_RC   = icon.rc

# 'debug' or 'release'
BUILD     = release

VPATH     = ../common

CSOURCES  = minizip/ioapi.c \
            minizip/unzip.c

PSOURCES  = main.cpp \
            player.cpp \
            core/glcore.cpp \
.....

STDLIBS    =
OPTLIBS    =    glfw3 glew32 opengl32 glu32 gdi32 imm32 \
                pthread \
                openal winmm dsound \
                png16 jpeg_x86 openjp2 \
                freetype \
                id3tag \
                z \
                mad \
                faad mp4ff

INC_SYS     =    /usr/local/boost_1_54_0

INC_LIB	    =    /usr/local/include \
                 /usr/local/include/libpng16 \
                 /usr/local/include/libjpeg_x86 \
                 /usr/local/include/openjpeg-2.0 \
                 /usr/local/include/freetype2

PINC_APP    =   . ../common
CINC_APP    =   . ../common
LIBDIR      =   /usr/local/lib

INC_S   =    $(addprefix -I, $(INC_SYS))
INC_L   =    $(addprefix -I, $(INC_LIB))
INC_P   =    $(addprefix -I, $(PINC_APP))
INC_C   =    $(addprefix -I, $(CINC_APP))
CINCS   =    $(INC_S) $(INC_L) $(INC_C)
PINCS   =    $(INC_S) $(INC_L) $(INC_P)
LIBS    =    $(addprefix -L, $(LIBDIR))
LIBN    =    $(addprefix -l, $(STDLIBS))
LIBN   +=    $(addprefix -l, $(OPTLIBS))

#
# Compiler, Linker Options, Resource_compiler
#
CP      =    g++
CC      =    gcc
LK      =    g++
RC      =    windres

POPT    =   -O2 -std=gnu++11
COPT    =   -O2
LOPT    =

PFLAGS  =   -DWIN32 -DHAVE_STDINT_H
CFLAGS  =   -DWIN32

ifeq ($(BUILD),debug)
    POPT += -g
    COPT += -g
    PFLAGS += -DDEBUG
    CFLAGS += -DDEBUG
endif

ifeq ($(BUILD),release)
    PFLAGS += -DNDEBUG
    CFLAGS += -DNDEBUG
endif

# 	-static-libgcc -static-libstdc++
LFLAGS	=

# -Wuninitialized -Wunused -Werror -Wshadow
CCWARN	= -Wimplicit -Wreturn-type -Wswitch \
          -Wformat
CPPWARN	= -Wall

OBJECTS	= $(addprefix $(BUILD)/,$(patsubst %.cpp,%.o,$(PSOURCES))) \
          $(addprefix $(BUILD)/,$(patsubst %.c,%.o,$(CSOURCES)))
DEPENDS = $(patsubst %.o,%.d, $(OBJECTS))

ifdef ICON_RC
    ICON_OBJ = $(addprefix $(BUILD)/,$(patsubst %.rc,%.o,$(ICON_RC)))
endif

.PHONY: all clean
.SUFFIXES :
.SUFFIXES : .rc .hpp .h .c .cpp .o

all: $(BUILD) $(TARGET)

$(TARGET): $(OBJECTS) $(ICON_OBJ) Makefile
    $(LK) $(LFLAGS) $(LIBS) $(OBJECTS) $(ICON_OBJ) $(LIBN) -o $(TARGET)

$(BUILD)/%.o : %.c
    mkdir -p $(dir $@); \
    $(CC) -c $(COPT) $(CFLAGS) $(CINCS) $(CCWARN) -o $@

lt;

$(BUILD)/%.o : %.cpp
mkdir -p $(dir $@); \
$(CP) -c $(POPT) $(PFLAGS) $(PINCS) $(CPWARN) -o $@


lt;

$(ICON_OBJ): $(ICON_RC)
$(RC) -i


lt; -o $@

$(BUILD)/%.d : %.c
mkdir -p $(dir $@); \
$(CC) -MM -DDEPEND_ESCAPE $(COPT) $(CFLAGS) $(INC_C)


lt; \
| sed 's/$(notdir $*)\.o:/$(subst /,\/,$(patsubst %.d,%.o,$@) $@):/' > $@ ; \
[ -s $@ ] || rm -f $@

$(BUILD)/%.d : %.cpp
mkdir -p $(dir $@); \
$(CP) -MM -DDEPEND_ESCAPE $(POPT) $(PFLAGS) $(INC_P)


lt; \
| sed 's/$(notdir $*)\.o:/$(subst /,\/,$(patsubst %.d,%.o,$@) $@):/' > $@ ; \
[ -s $@ ] || rm -f $@

run:
./$(TARGET)

clean:
rm -rf $(BUILD) $(TARGET)

clean_depend:
rm -f $(DEPENDS)

dllname:
objdump -p $(TARGET) | grep "DLL Name"

tarball:
tar cfvz $(subst .exe,,$(TARGET))_$(shell date +%Y%m%d%H).tgz \
*.[hc]pp Makefile ../common/*/*.[hc]pp ../common/*/*.[hc]

bin_zip:
$(LK) $(LFLAGS) $(LIBS) $(OBJECTS) icon.o $(LIBN) -mwindows -o $(TARGET)
rm -f $(subst .exe,,$(TARGET))_$(shell date +%Y%m%d%H)_bin.zip
zip $(subst .exe,,$(TARGET))_$(shell date +%Y%m%d%H)_bin.zip *.exe *.dll res/*.*

-include $(DEPENDS)

完全な Makefile は Github にプシュした!

C 言語よりお得な C++ その10

以前に、std::iostream に代わる小規模なクラスの紹介をしました。
その中で、std::iostream に馴染めなくて、printf 形式が忘れられない人の為に、「boost::format.hpp」を紹介しました。
しかしながら、「boost::format.hpp」は、std::iostream に依存している為、そのままでは、結局リソースを大量に消費してしまい、小規模な組み込みマイコンでは使えません。
そこで、機能を絞った簡易的な format クラスに相当する物を実装してみましたので紹介します。
※機能が足りなければ、自分で拡張する事も出来ると思います。
※本家では、エラーの場合は、例外がスローされますが、それでは使いにくいと思い、エラー関数クラスでハンドリングするようにしています。
※「例外」をスローさせたい場合は、エラー関数から、例外を投げれば良いと思います。
※組み込みマイコン向けに、A/D 変換などの値(整数)を、10進表示する場合に小数点位置を指定して、それを簡単に表示できるようなフォーマットも用意しました。

このように使います。

    int x = 1095;
    int y = 123;
    utils::format<output>("Pos: %d, %d\n") % x % y;

Pos: 1095, 123

    int adv = 257;
    utils::format<output>("A/D Ch0: %2.4:8y\n") % adv;

/// 2.4 ---> 実数2桁、小数4桁。
/// :8 ---> 小数点以下8ビットとして扱う。

A/D Ch0:  1.0039

ここで「output」は、文字の出力クラスで、以下のような定義を行います。
struct output {
    void operator() (char ch) {
        serial_out_(ch);  ///< ターミナルへ文字出力
    }
};
「operator()」を定義する事で、以下のように関数オブジェクトとして使えます。
    output o;
    o('a');    ///< 'a' を出力
    o('\n');   ///< 改行を出力
※「operator()」を「public」にする為、あえて、「struct」としています。

さて、実際の実装ですが、まず format の設計方針を決めます。
・名前空間を「utils」とします。
・float の表示は、基本的に行わない事とします。(今後コンパイルオプションで切り替える)
・整数計算のみを使い、巨大にならないよう配慮する。
・クラッシュは論外としても、きめ細かいエラーのハンドリングは省略する。(必要なら追加する事も可能)
・printf のフォーマットに近い仕様を網羅する。
・2進、8進、16進表示を行う。
・ゼロサプレスの制御
・有効表示数の制御
・オートフォーマットは未サポートとする。

format の中

・フォーマット文字列をスキャンして「%」以下の書式を読み取る。
    void next_() {
        if(form_ == 0) {
            err_(error_case::NULL_PTR);
            return;
        }
        char ch;
        bool fm = false;
        bool point = false;
        bool ppos = false;
        uint8_t n = 0;
        while((ch = *form_++) != 0) {
            if(fm) {
                if(ch == '+') {
                    sign_ = true;  // 符号付きの場合
                } else if(ch >= '0' && ch <= '9') {
                    if(n == 0 && ch == '0') {
                        zerosupp_ = true;  // 最初の数字が「0」なら、0サプレスしない。
                    } else if(point || ppos) {
                        if(point) {
                            decimal_ *= 10;
                            decimal_ += static_cast(ch - '0');
                        } else {
                            ppos_ *= 10;
                            ppos_ += static_cast(ch - '0');
                        }
                    } else {
                        real_ *= 10;
                        real_ += static_cast(ch - '0');
                    }
                    ++n;
                } else if(ch == '.') {
                    ppos = false;
                    point = true;
                } else if(ch == ':') {
                    ppos = true;
                    point = false;
                } else if(ch == 's') {
                    mode_ = mode::STR;
                    return;
                } else if(ch == 'c') {
                    mode_ = mode::CHA;
                    return;
                } else if(ch == 'b') {
                    mode_ = mode::BINARY;
                    return;
#ifdef WITH_OCTAL_FORMAT
                } else if(ch == 'o') {
                    mode_ = mode::OCTAL;
                    return;
#endif
                } else if(ch == 'd') {
                    mode_ = mode::DECIMAL;
                    return;
                } else if(ch == 'u') {
                    mode_ = mode::U_DECIMAL;
                    return;
                } else if(ch == 'x') {
                    mode_ = mode::HEX;
                    return;
                } else if(ch == 'X') {
                    mode_ = mode::HEX_CAPS;
                    return;
                } else if(ch == 'y') {
                    mode_ = mode::FIXED_REAL;
                    return;
#if defined(WITH_FLOAT_FORMAT) | defined(WITH_DOUBLE_FORMAT)
                } else if(ch == 'f' || ch == 'F') {
                    mode_ = mode::REAL;
                    return;
                } else if(ch == 'e' || ch == 'E') {
                    mode_ = mode::EXPONENT;
                    return;
                } else if(ch == 'g' || ch == 'G') {
                    mode_ = mode::REAL_AUTO;
                    return;
#endif
                } else if(ch == '%') {
                    out_(ch);
                    fm = false;
                } else {
                    err_(error_case::UNKNOWN_TYPE);
                    return;
                }
            } else if(ch == '%') {
                fm = true;  // フォーマットの開始を検出!
            } else {
                out_(ch);  // フォーマットに関係しない文字は、そのまま出力
            }
        }
    }
・オペレーター「%」を定義する
//  この定義では、int 型の値が代入された場合の挙動を記述します。
//  事前に format 文字列の中をスキャン(next_() 関数)して、「%」を見つけ、それに続く「型」を「mode_」に格納しておきます。
    format& operator % (int val) {
        if(mode_ == mode::BINARY) {
            out_bin_(val);
        } else if(mode_ == mode::OCTAL) {
            out_oct_(val);
        } else if(mode_ == mode::DECIMAL) {
            out_dec_(val);
        } else if(mode_ == mode::HEX) {
            out_hex_(static_cast(val), 'a');
        } else if(mode_ == mode::HEX_CAPS) {
            out_hex_(static_cast(val), 'A');
        } else if(mode_ == mode::FIXED_REAL) {
            if(decimal_ == 0) decimal_ = 3;
            out_fixed_point_(val, ppos_);
        } else {
            err_(error_case::DIFFERENT_TYPE);
        }
        reset_();  // 変数をリセット
        next_();  // 「%」のスキャンを再始動
        return *this;
    }

※これらはソースの一部です。
「%」オペレーターでは、「int」型、「unsigned int」型、「const char*」型など、色々な型を定義してあり、コンパイラが適合する型を選択して呼び出してくれます。

組み込みマイコンでは、A/D 変換した値(大抵、電圧や電流値)を、小数点以下まで表示させたい場合があります、そこで、「y」フォーマットを用意しておきました、これは、整数値を固定小数として扱い、小数点以下も変換して表示します、小数点の位置は「:x」として自由に設定できます。(最大28ビット)
※浮動小数点が扱えない場合などに重宝します。
たとえば、12ビットのA/Dコンバーターで、基準電圧を2.5V(4096)の場合で、A/D入力に1/5の電圧が分圧される場合は、以下のようになります。


    uint32_t adv = get_adc();
    utils::format<output>("A/D Chanel: %2.3:13y\n") % (adv * 25);  // 2.5 * 5 * 2 
//  2.5 * 5 ---> 12.5 なので、さらに倍にして、小数点以下を12に1を加えて13ビットとする。

※8進数は、あまり使わないと思うので、コンパイルオプションとしました。(リソースの節約)
※逆に、2進数表示は大抵必要なので、「%b」フォーマットを追加してあります。
※浮動小数点は、実装中です、仕様が複雑なので、今後の対応、課題とします。

最終的なソースコードは、format.hpp ここにあります。
※いつもの github

MinGW でビルドする RX マイコン用 gcc

開発環境を MinGW に移行して、懸案だった RX マイコン用 gcc の構築を行った。

以前の cygwin 環境では、途中で、gcc が止まったり、妙なエラーが出て、上手くコンパイル出来ない状態だった・・
これは、適切なオプションを選択する事で回避出来るようだが、情報が無いし、試行錯誤に疲れて棚上げ状態だった。

MinGW 環境では、何とも普通にコンパイル出来るので、逆に不思議でさえ思ったが、これが普通なんだろうね・・・

コンパイルの詳細は、「Interface 2014年2月号」に詳しく載っているようだが、ネットにあるクロスコンパイラの構築などを参考にしても良いだろう。

手順が複雑で、扱うパッケージのバージョンとの相性などがある為、上手くいかない場合があると思う。

—–

RX マイコン用では、gcc-4.7.3 が良いようだ、C++11 を本格利用は出来ないが、C++0x は使えるので、問題無いと思う、gcc-4.8.x は失敗するようだ。

RX-gcc-4.7.3-ELF パッケージ
※コンパイル済みバイナリーを置いておく。(107MB)
※gcc-4.8.1 で構築した。

C 言語よりお得な C++ その9

以前に、文字列を渡す場合に、「const char*」と、「const std::string&」などの参照コンテナで渡すのと、どちらを選択すべきか書いた。

C++ はオブジェクト指向言語であり、ポインターを渡すより、コンテナを参照渡しする方が殆どの場合有利なのは明白なのだが、C から移って来た場合、オブジェクト指向プログラムに不慣れな場合もあり、中途半端な設計(ポインターだったり、コンテナだったり)になってしまう事がある。
※思い返してみると、これは自分もそうだった・・・

今回、同じような事例として、「x、y軸」の位置を渡す方法を考えてみたい。

たとえば・・・

void set(int x, int y) { }

のような関数がある場合・・・

struct xy {
    int x;
    int y;
};
void set(const xy& p) { }

このように、「x、y軸」をコンテナに入れて、参照渡しにする方が何かと都合が良い。

しかし、多くの場合、直で値を入れたい場合は、冗長では?
みたいな意見もあるのだが、通常、直で値を入れて呼ぶ事は「稀」と思うけど、それでもそのようなケースが多いなら、以下のようにすべきだろう。

struct xy {
    int x;
    int y;
    xy() { }
    xy(int x_, int y_) : x(x_), y(y_) { }   ///< コンストラクターを定義
};
void set(const xy& p) { }
void set(int x, int y) { set(xy(x, y)); }   ///< 直で呼べるように定義を追加

    set(100, 200);        ///< 直接指定
    set(xy(100, 200));    ///< 直で呼びたい場合、このように書ける。

ここで、構造体 xy だが、メンバーは、public になっていて、アクセサーを使わずにダイレクトにアクセスしている点を検討すべき問題として付け加えておく。
※この例では、自分の流儀でそのような仕様にしているだけで、本来は、このような単純なクラスでも、アクセサーを用意してアクセスする事が望ましいと思う、自分の裁量で、メンバーに与える影響などが少ない場合は、ダイレクトでも良いと思っている為で、このようなダイレクトなアクセス方法に注意して欲しい。
内部の変数にアクセサーでアクセスするようにする事で、安全性や最適化など得られるメリットは他に色々あるのですが、範囲が大きくなり過ぎると思うので、これは、又、別の機会に論じる事とします。

上の例では、メンバーの型は「int」でしたが、構造体 xy をテンプレートにする事で、他の型も簡単に定義できる。

typedef xy<short> s_xy;
typedef xy<int>   i_xy;
typedef xy<float> f_xy;

template<typename T>
struct xy {
    typedef T value_type;
    T x;
    T y;
    void set(T x_, T y_) { x = x_; y = y_; }
    xy() { }
    xy(T v) : x(v), y(v) { }     ///< カスタムコンストラクター(同じ値で初期化)
    xy(T x_, T y_) : x(x_), y(y_) { }    ///< カスタムコンストラクター(個別に初期化)
    xy& operator = (const s_xy& p) { set(static_cast(p.x), static_cast(p.y)); return *this; }
    xy& operator = (const i_xy& p) { set(static_cast(p.x), static_cast(p.y)); return *this; }
    xy& operator = (const f_xy& p) { set(static_cast(p.x), static_cast(p.y)); return *this; }
};

「operator = 」を使い、複数の型に対応する事で、型が違う代入をスムーズに行えるようになるが、「float -> short」や、「float -> int」は、変換出来ない場合がある為注意する必要がある。
※そのような変換が起こった場合は、例外を出すなどが必要かもしれない。

typedef T value_type;

は、テンプレートの実装では、よく使われるやり方で、元の「型」を再定義する事で、そのクラスで使われている「型」にアクセスする方法を提供する。

    s_xy pos(0);    ///< カスタムコンストラクターが定義されている為、x、y、を同じ値で初期化する事が出来る。
    for(s_xy::value_type i = pos.x; i < (pos.x + 10); ++i) {
        ...
    }

※これは、例題なので、名前空間に入れていないが、実際に使う場合には、必ず、何らかの名前空間に入れて運用する必要がある、そうしないと、クラス名が既存のクラスとぶつかってしまう事になる。

「代数」のクラスは、自分で実装しなくても、ネットを探すと、色々なソースを見つける事が出来る、自分で実験的に実装する事で、より広範囲な理解とスキルを身につける事が出来る、そうしてから、より洗練された実装を利用しても良い。
※ある程度自分で作って、利用していると、愛着も沸くし、他の同じような実装に移るのが難しくなる、しかしながら、自分で作ったクラスはメンテナンスし易く、機能を追加したり改良するのが、楽であるメリットがある。

MicroChip RN-52 Bluetooth モジュールを使ったオーディオ再生

Bluetooth オーディオで、音楽を飛ばす場合(A2DP)は、圧縮フォーマットの関係で、良い音で聞くのが物理的に困難だった。
しかし、最近になって、新しい高音質プロファイル(APT-X/AAC)などに対応する機器が出始めた。

丁度、Microchip 社が、↑のプロファイルに対応した Bluetooth モジュールの販売を始めたので、使ってみる事にした。
RN-52
※Microchip 社のオンラインストアでも、1個から購入可能、モジュールが20ドル、送料が10ドル程かかる(発送には2週間程度かかるようだ)

このモジュールの特徴は:
・APT-X/AAC プロファイルに対応
・デジタル出力を出せる
※設定を行う必要がある。
・比較的安価
・外付け部品が殆どいらない
・Bluetooth のオーディオ系のプロファイル(AVRCP など)を全てサポートしている
・認証:FCC、IC、CE、Bluetooth SIG
・言うまでも無く、手軽に、自分だけの Bluetooth 機器を作れる

バッテリー内臓で、持ち運びが出来る、小さいラジカセのような物が欲しかったので、丁度良い感じ~

昨日、モジュールが届いたので、早速、簡単な動作確認をしてみた。

最初のハードルは、モジュールに出ているピンの間隔が 1.2mm と狭い為、工夫しないと、ユニバーサル基板に乗せられない。
自分は、適当な基板に絶縁用の板(フォーレックス)を乗せ、その上にモジュールを置いて、ワイヤーをハンダ付けした。
RN-52 Board

モジュールを自力で何とかするのが厳しい人は、SparkFun のブレークアウトを利用すれば良いだろう~(44.95ドル)

しかし、1.2mm 間隔のハンダ付けは、そんなに厳しいものでは無いので、根気だけだと思うな。

モジュールが出来たら、必要な配線をして、ペアリングをしてみよう~

・POWEN(21) —> パワースイッチ
・VDD(22) —> 3.3V(電流は動作中は少ないけど、ピークで30mA くらいは流れるみたいだ・・)
・GND(1,18,27,44,45,46,47,48,49,50) —> GND(接地)
・LED1(32) —> LED 赤色(470)
・LED0(33) —> LED 青色(47)
・AGND(39) —> AGND(アナログ接地)
・SPKR_R-(40) —> 右SP-
・SPKR_L-(41) —> 左SP-
・SPKR_R+(42) —> 右SP+
・SPKR_L+(43) —> 左SP-
※L-、R- は独立した出力なので、共通にする事は出来ない、又、インピーダンスの低い負荷(直でスピーカー)をドライブする事も難しいと思う。
※一般的なステレオイヤホン(ステレオプラグなど、接地が共通の場合)などを繋ぐ場合には、アンプを入れる必要があると思う、ドキュメントの回路図などが参考になる。
※電源には1uF程度のパスコンを念のため入れておく。

とりあえず、これだけ接続して、パワースイッチを押せば電源が入る。
長押しすれば、赤、青の LED が交互に光って、ペアリング待ちになる。

——
以前に USB のデジタルオーディオインターフェースを作った時に、バーブラウンの 24 ビット DAC などを買ったので、それを接続しようと思う~
S/PDIF 出力を行うには、RXD、TXD にターミナルを接続して、コマンドで設定が必要みたいだ。

IMG_0575s

APT-X/AAC などに対応した、USB アダプターは、最近ようやく入手出来るようになってきた。
※ドライバーがカスで、使えないやつもあるみたいなので注意!、MM-BTUD44 は、問題無く使えている。

アイデア次第で、自分だけのオーディオ機器を気軽に自作できて、これは流行りそうだなー

IMG_0577s
ラジオデパートの4階で、1個200円で売っていたスピーカー(F70A21-5)と、アンプを繋いで鳴らしてみた、このスピーカー、200円とは思えないwww、これは、ちゃんと箱に入れれば、普通に使えそうだなー

☆Bluetooth AUDIO としては、ポケットに入れて持ち運べるタイプも欲しい、そこで、ヘッドホンでの音を確認する為、ヘッドホンアンプとしては最強との呼び声の TI の TPA6120A2を繋いで視聴してみたー
RN-52 内臓の D/A コンバーターもそんなに悪く無い感じだ。
※TPA6120A2 は、+-両電源が必要なので、DC/DC(MAU106) コンバーターを使っている。
※一般に売っているタイプはスティックタイプで、凄く小さいけど、電池はあまり長持ちしないし、あそこまで小さい必要は感じないので、パワフルなアンプを入れてガッツリ作りたい。
やっぱりボリュームが欲しいなぁー
IMG_0579s

C 言語よりお得な C++ その8

「printf」の功罪と「iostream」

C++ 初心者の頃 C 言語から C++ に移行して、大きな驚きを感じたのは、文字の入出力関係でしょうか?

現在 C++ でプログラムを作成するのが「常」となり、結論から言わせてもらうと、C++ では、もはや「printf」を使う理由は全く無い事です。

今「え?」と言った人は、C++ にまだ移行できていない中途半端な状態だと思われます。

    printf("Hello !!!\n");

では無くて、

    std::cout << "Hello !!!" << std::endl;

です!

C++ に馴染みの無い人には、今まで観た事の無いような、記述で、凄く奇妙に写ると思います。
C++ ではオペレーターをオーバーロード出来る為、「<<」を「シフト」では無く、全く別の意味で使う事が出来ます。
「iostream」クラスでは、cout(stdout)オブジェクトに対して、文字列を流し込む事で、文字の表示を行う事が出来るような設計になっています。
※入力は、std::cin オブジェクトから「>>」で行えます。

以前にとあるプログラマーが「iostream はわかりずらいので使う価値が無い」的な事を言っていましたが、甚だしい勘違いです。
「使い易い」、「使いずらい」と言う感覚は、単純に個人の「慣れ」の問題であって、その感覚だけで「扱いづらい」と結論してしまう事に危機的な危うさを感じます。
多分、iostream を設計した人々は、printf に関連する諸問題にとっくの昔に気がついていて、それを避け、尚且つ簡単に扱えるようにするにはどうしたら良いかを長い時間考えたり、ディスカッションして、現在の実装になったと思います。
iostream は、printf に比べると速度が遅い(負荷が大きい)と言うのはあるかもしれませんが、printf に比べると、安全で、プログラマーが受けられる恩恵が大きい優れた物です、それを良く理解しないままにわざわざ禁止する必要は無いのです。

「どんなに注意しても、人間は間違いを犯す」と言う基本的な事実があります。
printf 内のフォーマットと、可変長の引数の「型」の整合性は、コンパイラではチェックに限界があり、極めて深刻な問題をそのままエラー無くコンパイルする事が可能で、その場合、スタックを破壊する事で、微妙で見つけにくいバグをアプリケーションの動作に取り込んでしまう事があります。

iostream であれば、うっかりミスは、コンパイラがエラーを出しますし、スタックを壊すような危険な事もありません。

それでも、尚、printf の使い易さが忘れられない人には、「boost/format.hpp」を使って下さい。
これなら、ほとんど printf のような感覚で、しかも、安全に運用する事が出来ます。
※フォーマットと、引数の型の誤りには「例外」がスローされます。

文字列から数値、数値から文字列の変換には、「boost/lexical_cast.hpp」
と言うのがあり、非常に便利です、これがあれば、scanf を使う必要もありません。
※変換の失敗には「bad_lexical_cast 例外」がスローされるので、それをキャッチして、変換の失敗に備える必要がある。

—–
これはゲームの開発での話ですが、ほとんど何処の会社でも printf を使う事を禁止しています、それは、どんなに注意しても、ミスを無くす事は出来ない為、見つける事が困難な問題をシステムに混入させてしまう危険を避ける為です。
※通常、リリースビルドでは #define で printf、sprintf などをオーバーロードして、命令を無効にするようなマクロが組まれています。

ただ、組み込みでは、残念な事があります、gcc の stdc++ ライブラリーでは、iostream クラスは他との依存が大きく巨大で、リンクすると、通常数百キロバイトのプログラムメモリーと、数十キロバイトのワークエリアを消費してしまいます、これでは、少ないリソースのマイコンでは物理的に使えません。
そこで、もし必要なら、小規模な iostream クラスを作成する必要があります(これは車輪の再発明ではありません)、ホビーで使うのであっても、あくまでも、安全性と利便性から、printf を使わない決断をすべき事項だと思います。
※以前、C 言語の時代でも、printf が巨大な為、多くの人が、tiny printf のような物を作って使っていました。
※オペレーターや、オブジェクト指向の勉強にもなるので、自分で作ってみると楽しいかもしれません。

一応、私が実装した、クラスを紹介します。
※これは、出力先として、「void sci_put(char);」、「void sci_puts(const char*);」などのシリアルインターフェースを使っています。

namespace utils {
    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
    /*!
        @brief  chout クラス
    */
    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
    struct chout {
	static const char endl = '\n';

    private:
	char		sup_ch_;
	char		hex_ch_;
	uint8_t		len_;

    public:
        //-----------------------------------------------------------------//
        /*!
            @brief  コンストラクター
	    @param[in]	out	文字出力関数
        */
        //-----------------------------------------------------------------//
	 chout() : sup_ch_('0'), hex_ch_('a'), len_(0) { }


        //-----------------------------------------------------------------//
        /*!
            @brief  16 進表示の英数字を大文字にする
	    @param[in]	cap	「false」を指定すると小文字
        */
        //-----------------------------------------------------------------//
	void hexa_decimal_capital(bool cap = true) {
	    if(cap) hex_ch_ = 'A'; else hex_ch_ = 'a';
	}


        //-----------------------------------------------------------------//
        /*!
            @brief  表示文字数を指定
	    @param[in]	len	表示文字数
        */
        //-----------------------------------------------------------------//
	void set_length(uint8_t len) { len_ = len; }


        //-----------------------------------------------------------------//
        /*!
            @brief  ゼロサプレス時の文字を指定
	    @param[in]	ch	文字
        */
        //-----------------------------------------------------------------//
	void suppress_char(char ch) { sup_ch_ = ch; }


        //-----------------------------------------------------------------//
        /*!
            @brief  文字表示
	    @param[in]	ch	文字
        */
        //-----------------------------------------------------------------//
	void put(char ch) const { sci_putch(ch); }


        //-----------------------------------------------------------------//
        /*!
            @brief  文字列の表示
	    @param[in]	str	文字列
        */
        //-----------------------------------------------------------------//
	void string(const char* str) const { sci_puts(str); }


        //-----------------------------------------------------------------//
        /*!
            @brief  長さ指定文字列表示
	    @param[in]	str	文字列
	    @param[in]	len	長さ
        */
        //-----------------------------------------------------------------//
	void len_string(const char* str, uint8_t len) const {
	    while(len_ > len) {
	        put(sup_ch_);
		++len;
	    }
	    string(str);
	}


        //-----------------------------------------------------------------//
        /*!
            @brief  16 進数の表示
	    @param[in]	val	値
        */
        //-----------------------------------------------------------------//
	uint16_t hexa_decimal(uint32_t val) const {
	    char tmp[8 + 1];
	    uint16_t pos = sizeof(tmp);
	    --pos;
	    tmp[pos] = 0;
	    do {
		--pos;
		char n = val & 15;
		if(n > 9) tmp[pos] = hex_ch_ - 10 + n;
		else tmp[pos] = '0' + n;
		val >>= 4;
	    } while(val != 0) ;

	    len_string(&tmp[pos], sizeof(tmp) - pos - 1);
	    return sizeof(tmp) - pos - 1;
	}


        //-----------------------------------------------------------------//
        /*!
            @brief  10 進数の表示
	    @param[in]	val	値
	    @param[in]	minus	マイナス符号を表示する場合「true」
	    @return	表示文字数
        */
        //-----------------------------------------------------------------//
	uint16_t decimal(uint32_t val, bool minus = false) const {
	    char tmp[11 + 1];
	    uint16_t pos = sizeof(tmp);
	    --pos;
	    tmp[pos] = 0;
	    do {
	        --pos;
		tmp[pos] = '0' + (val % 10);
		val /= 10;
	    } while(val != 0) ;

	    if(minus) {
		--pos;
		tmp[pos] = '-';
	    }

	    len_string(&tmp[pos], sizeof(tmp) - pos - 1);
	    return sizeof(tmp) - pos - 1;
	}


        //-----------------------------------------------------------------//
        /*!
            @brief  符号付き 10 進数の表示
	    @param[in]	val	値
	    @return	表示文字数
        */
        //-----------------------------------------------------------------//
	uint16_t decimal(int32_t val) const {
	    bool minus = false;
	    if(val < 0) {
	        minus = true;
		val = -val;
	    }
	    return decimal(static_cast(val), minus);
	}


	chout& operator << (const uint32_t val) {
	    decimal(val);
	    return *this;
	}


	chout& operator << (const int32_t val) {
	    decimal(val);
	    return *this;
	}


	chout& operator << (const char* str) {
	    string(str);
	    return *this;
	}


	chout& operator << (const char ch) {
	    put(ch);
	    return *this;
	}
    };
}

※ただ、このクラスでは、浮動小数点や、2進数、8進数の表示をサポートしていません、浮動小数点表示が出来ないのは痛いので、改修する予定です。

このソースコード一式は、GitHUB にプッシュしてあります。

MinGW による GLFW3、FreeType2、Bullet 環境の構築

今まで、Windows では主に cygwin64 を使って開発環境を整えていた。
しかし、ここにきて、色々な不具合に遭遇する・・・

たとえば、組み込みマイコンのクロス開発環境として、gcc をビルドするのだけど、cygwin では途中で必ず失敗する。
※cygwin では、何か特別なオプションを追加するのかもしれないが、情報が無いし、原因を追って、試すのに時間が掛かり過ぎる。
※大抵は、gcc がコンパイルエラーで止まる。
また、少し大きなライブラリー(bullet physics)をコンパイルしようとした場合にスタック不足で gcc-w64-mingw32-gcc がクラッシュしたり、リンク中に止まったりと、非常に辛い状況が連発していた。
状況を改善する為に、ソースを追ったり、オプションを追加したり、情報を求めて時間を浪費したものの、良い改善策が見つからない、これは、cygwin のバージョンアップにより解消するのかも知れないと思ったりもしたが、もう疲れた・・・
そこで、別の解決策として、MinGW 環境を試してみる事にした。

MinGW は、よりコンパクトに必要最小限のコマンドを集約した、gcc を使った Windows の開発環境と思えば良いと思う。
MinGW には MinGW の流儀(常識)があり、それを学ぶ必要がある為、時間がかかるので、躊躇していたが、使ってみない事には判らない。

それで、とりあえず、インストーラーを使ってインストールしてみた。

しかし、入れたハズの gcc すら動かない!?
何で?、と思って数日、profile のパスにバグがあり、それが原因だったようだ。

/c/MinGW/msys/1.0/etc/profile
の19、21行目
/mingw/bin:/bin ---> /c/mingw/bin:/bin
ドライブレターが抜けているようだが、正規のインストーラーでインストールしてこの完成度は「痛い」としか言い様が無い、ホント大丈夫なの?

気を取り直して、コマンド窓を、評判の mintty にしてみた、これは簡単、情報も多く直ぐに導入出来た。

自分は emacs 使いなので、コンソールで使える emacs を使いたかったが、MinGW では標準では無いので、仕方なく、Windows の emacs を入れて、パスを通した。

ここまで出来て、判った事。

・MinGW では、コンソールで emacs を動かすのは難しいようだ。(vim は標準であるが、キーバインドの慣れもあるので自分には使いづらい)
・Windows の日本語ファイル名などをスマートに解決出来ないようだ。(色々な理由で UTF-8 を使いたいが、それだと色々破綻する、とはいえ、CP932(Shift-JIS)も駄目で、日本語ファイル名の文字化けは我慢するしか無いようだ。
・cygwin では、大抵の unix コマンドは揃っていて、インストーラーで簡単にインストール出来るが、MinGW では、標準に無い物は自分でコンパイルして導入する必要があり、簡単に導入出来るものと、パッチを当てたり、改修する必要がある物など、簡単では無い場合があるようだ。

まず、自分のフレームワークで使っているライブラリーをコンパイルする必要がある。
「configure、make」で解決できるものと、「cmake」を使う物があるみたいなので、cmake の windows 版をインストールして、パスを通した。
※cmake はMinGW で動作する実行ファイルを作るのでは無く、windows 専用の物を使うようで、GUI 環境で使える版も付いてくる。

(1)標準的な各種ライブラリーのインストール

Windows 関係ライブラリー:
    mingw-get install mingw32-w32api

pthread ライブラリー:
    mingw-get install mingw32-pthreads-w32

zlib ライブラリー:(標準では DLL しか入らないようだ)
    mingw-get install mingw32-libz

※「mingw-get」で、GUI が起動するので、それで、必要そうな物はインストール出来る。

(2)GLFW-3.0.4 のコンパイル
MinGW の常識が判っていなかった為、コンパイル出来るまで試行錯誤が続いた。
glfw3 のアーカイブを解凍したら、ディレクトリーを移って。

    cmake -G "MSYS Makefiles" -DCMAKE_INSTALL_PREFIX=/usr/local

として作成する。
※cmake は途中で失敗したら、キャッシュが残るようで、後何をやっても駄目ななので、アーカイブからやり直した(他にもっと良い方法があると思う)

後はお決まりの・・・

    make
    make install

とりあえず、GLFW3 のコンパイルは出来た。

ここまでの感触で、自分フレームワークを MinGW に移っても問題無いように感じた。

追記:2014/1/21
(3)freetype-2.5.2 ライブラリーの構築
freetype は、TrueType のレンダリングを行うオープンソースライブラリーで、自分のフレームワークでも日本語フォントの描画で使っている。
このライブラリーのコンパイルは、少し工夫が必要だった・・
インクルードファイルの相互依存の影響で、定義がすっぽ抜ける現象が起こる、本来はもっとスマートに解決したいが、無理やりだが以下のように解決した。

「ftgip.c」に、typedef を二行追加。
    typedef long off_t;
    typedef long long off64_t;

    ./configure --without-png
※ PNG が必要なのは、TrueType ファイル内に PNG でエンコードされたフォントのビットマップがあるのだろうけど、とりあえず、無視するようにした。

    make
    make install

(4)physics bullet-2.82 のコンパイルとデモプログラムの生成
bullet は物理法則をシュミレーションする演算ライブラリーで、色々な場面で使われている。
Visual Studio でコンパイルするのが一般的なようだが、MinGW でもライブラリーを作成する事が可能なようだ。
※現状の gcc-4.8.1 では、コンパイル中にクラッシュする為、ライブラリーを作れないが、クラッシュするソースを微妙に修正するとコンパイルが正常終了する事が判った。

修正1: src/BulletCollision/CollisionDispatch % emacs btInternalEdgeUtility.cpp
内「struct btConnectivityProcessor : public btTriangleCallback」クラスで、

btVector3 calculatedEdge = edgeCrossA.cross(edgeCrossB);
を、以下のように修正
calculatedEdge = edgeCrossA.cross(edgeCrossB);

btVector3 calculatedNormalB = normalA;
を、以下のように修正
calculatedNormalB = normalA;

変数として以下の二行を追加する。
	btVector3 calculatedEdge;
	btVector3 calculatedNormalB;
※この修正、厳密には正しく無いが、多分動作するだろうと思う、正しく動作しているかの検証はしていない、bullet は発展途上で、実装があっても使われていない事もあるので、どのデモプログラムを動作した場合にこのクラスが動くか見極めていない、コンパイルが通るだけのワークアラウンドと思って欲しい。

修正2: src/BulletDynamics/Character % emacs btKinematicCharacterController.cpp
383、384 行目をコメントアウト(単純に使われていないが、あるだけで gcc がクラッシュする・・)
///     btScalar hitDistance;
///     hitDistance = (callback.m_hitPointWorld - m_currentPosition).length();

GLUT の対応:
GLUT は、MinGW 用にコンパイルすれば良いのだが、GLFW3 を使うようになって OpenGL では使わなくなった為、bullet のデモを動かす為の対応として、
Glut/GL/glut.h ---> /c/MinGW/mingw32/include/GL にコピーする。
又、ライブラリー glut32.lib を、名前を変更して、コピーする ---> /c/MinGW/mingw32/lib/libglut32.a
※VisualStudio で C 言語ソースだけでコンパイルされたライブラリーは gcc のライブラリーと互換性がある。

    cmake -G "MSYS Makefiles" -DCMAKE_INSTALL_PREFIX=/usr/local
    make
    make install

(5)libpng-1.6.8 ライブラリーの構築
これは、普通に問題なく構築できる

    ./configure
    make
    make install

(6)openjpeg-2.0.0 ライブラリーの構築
標準的には、シェアードライブラリー形式(DLL)で生成される為、それをOFFにしてスタティックライブラリーにする

    cmake -G "MSYS Makefiles" -DBUILD_SHARED_LIBS:BOOL=OFF -DCMAKE_INSTALL_PREFIX=/usr/local
    make
    make install  

(7)JPEG ライブラリーの構築
JPEG ライブラリーは、x86 CPU の場合、マルチメディア命令で最適化されたバージョンがあるので、それを使う。
Independent JPEG Group’s JPEG software release 6b
with x86 SIMD extension for IJG JPEG library version 1.02

※VisualStudio の C コンパイラで作成されたライブラリーファイルは、gcc と互換性があるので、「xxx.lib」を「libxxx.a」などにリネームすれば良い。
このライブラリーは非常に高速なので、画面をキャプチャーしてそれをリアルタイムに JPEG 圧縮して出力すれば、動画にも対応できる。(モーション JPEG 的な・・)
※生の画像を出力しない方が、ファイルサイズが小さくなり、高速化する。

(8)mupdf-1.3 ライブラリーの構築
mupdf ライブラリーはオープンソースの PDF ファイルを展開してビットマップを生成するライブラリーで、PDF を簡単に開けるので、便利に使っている。
このライブラリーは、freetype、openjpeg、jpeg、jbig2dec などを利用するのだけど、各ライブラリーのバージョンの違いを吸収する為、全てのソースコードを同梱している、構築には無駄にならないように、自前のライブラリーをリンクさせる。

まず Makefile を修正

3 行目「build ?= debug」を「build ?= release」としとく。

「include Makethird」をコメントアウトしておく「# include Makethird」

LIBS に追加「LIBS += -L/usr/local/lib -lpng -ljpeg_x86 -lopenjp2 -ljbig2dec -lfreetype -lz」

CFLAGS にも追加「CFLAGS += -I/usr/local/include -I/usr/local/include/openjpeg-2.0 -I/usr/local/include/libjpeg_x86 -I/usr/local/include/freetype2」
※JPEG ライブラリーは x86 CPU 用に最適化されたバージョンを使っている。

    make
    make install

C 言語よりお得な C++ その7

前回、コンペアマッチタイマーの制御をテンプレート化してみました。

今回は、少し複雑ですが、シリアルコミュニケーションインターフェースをテンプレート化してみます。

実用的なシリアルコミュニケーションでは、通常、受信、送信は割り込みによって行い、メインとは FIFO などでやりとりします。
さらに RX マイコンでは、DMA も使う事が出来ますが、やりとりするデータ量と、出し入れに係わる細かい操作を考えると、DMA を使う事にあまりメリットが無いので、通常の割り込みで行う設計とします。

FIFO のバッファサイズは、アプリケーションの構造、送受信のボーレート、などにより最適なサイズがあると思われますので、可変に出来るようにします。
※以前のコンペアマッチタイマーより、バッファサイズをパラメーターとしている為、少し複雑です。

    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
    /*!
        @brief  SCI I/O 制御クラス
        @param[in]  SCI SCIx 定義クラス
        @param[in]  recv_size   受信バッファサイズ
        @param[in]  send+size   送信バッファサイズ
    */
    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
    template <class SCIx, uint32_t recv_size, uint32_t send_size>
    class sci_io {

        static utils::fifo<recv_size>   recv_;
        static utils::fifo<send_size>   send_;

        static INTERRUPT_FUNC void recv_task_()
        {
            bool err = false;
            if(SCIx::SSR.ORER()) {  ///< 受信オーバランエラー状態確認
                SCIx::SSR = 0x00;   ///< 受信オーバランエラークリア
                err = true;
            }
            ///< フレーミングエラー/パリティエラー状態確認
            if(SCIx::SSR() & (SCIx::SSR.FER.b() | SCIx::SSR.PER.b())) {
                err = true;
            }
            if(!err) recv_.put(SCIx::RDR());
        }

        static INTERRUPT_FUNC void send_task_()
        {
            SCIx::TDR = send_.get();
            if(send_.length() == 0) {
                SCIx::SCR.TEIE = 0;
            }
        }
...

重要な部分は、fifo の定義です、割り込み関数とクラスとで、送受信データをやりとりする必要がある為、「static」としています。
テンプレートのパラメーターから、受信サイズ、送信サイズを受け取って、静的に宣言されます。
割り込み関数も static 宣言します、この関数アドレスは、初期化時、割り込みベクターに渡されるようにしています。

    sci_io<device::SCI0, 128, 128> sci0_;
    sci_io<device::SCI1,  64, 256> sci1_;

↑のように、SCI0、SCI1 を宣言すると、テンプレートパラメーター SCIx が異なる為、static に宣言された fifo の領域は SCI0、SCI1 で別々に確保されます。

クラス内の static 宣言では実態を別に宣言しておく必要があります。

    template<class SCIx, uint32_t recv_size, uint32_t send_size>
        utils::fifo<recv_size> sci_io<SCIx, recv_size, send_size>::recv_;
    template<class SCIx, uint32_t recv_size, uint32_t send_size>
        utils::fifo<send_size> sci_io<SCIx, recv_size, send_size>::send_;

どうでしょうか、これで、チャネル毎バッファサイズを変更して静的に使う事が出来ます。

全ソースコードは github にあります。

デジタル・スイッチング・レギュレーター

現在、SW レギュレーターを組もうと思ったら、専用の IC を買えば済む、しかし、微妙に違う仕様のICが数限りなくあり、ベストな選択をする事が難しいし、数個購入するとなると、割高でもある。

とりあえずのゴールは、リチウムイオン電池の充電や、ブラシレスモーターの制御なのだが、専用 IC で組むとそれなりの値段になってしまうし、より細かい制御をしようと思うと、マイコンの助けも必要なので、1個のマイコンだけで、全ての制御を行う予定。

まず、「昇圧」は、電流の管理が必須で、誤るとドライバーを破壊するので、無難な「降圧」方式で実験してみた。

12 ビットの A/D コンバーターを使って、フィードバックを行い、指令電圧に追従させてみた。
まず、一番単純な制御で行ってみた。

IMG_0534ss

A/D チャネル0: 10K のボリューム(指令電圧)
A/D チャネル1: 出力電圧(1/6)
A/D チャネル2: 入力電圧(1/6)

A/D の入力には、AD8656 をバッファアンプに使い、1/6 に分圧して、基準電圧には 2.5V のリファレンスを使った、電源は 12V 。
※写真のボードでは、保護抵抗やリミッターを省いているが、付けた方が無難だろう。

パワー MOS-FET は、IR 社の IRLR3114 、ドライバーはリニアテクノロジーの LTC4442

LTC4442 の制御電圧は FET のゲート電圧を考えて 10V 程度を供給している。
※バイパスコンデンサをしっかり配置しないと、正常に動作しない、使うのにコツがいるようだ、ハイサイド側が ON した時、かなりハンチングしているようで、原因が良く判らない・・・
IMG_0535ss
LTC4442 は、上下の FET が貫通しないような工夫がしてあるので、デッドタイムの制御はしなくていいのでコンビニエンスだ・・(それが正しく働いてなくて、ハンチングしているのかも・・)

RX63T は、PWM タイマーの周波数として 100MHz を扱えるので、9 ビットの分解能として、187.5KHz (96MHz / 512) を実現している。
インダクターは TDK の 22uH 電圧にもよるけど、このサイズ(容量)なら 500mA 程度なら取り出せるだろうか・・

メインループは、1000Hz なので、応答は、そんなに高速では無いが、サンプリング方式では、どのみち限界がある。

ソースコード一式を、github にプッシュしてある。

—–
今後の課題として、もっと違った制御法を試して、ステップ応答などの特性を評価してみないといけない。

追記 (2014/1/1)(2014/1/2):
・比例制御から、もう少し違う制御にしてみた・・
・A/D の変換タイミングを、PWM に同期させてみた。
・ハイサイドの FET をチャージポンプで駆動している為、パルスが無くならないように、最低値と最大値を制限。
・サンプリングは 10KHz にした。

    bool up = true;
    int32_t base_gain = 651;
    int32_t high_gain = 1500;
    int32_t low_limit = 10;
    int32_t high_limit = 500;
    int32_t cpv = low_limit;
    while(1) {
        adc_.start(0b00000111);

        cmt_.sync();

        // A/D 変換開始
        adc_.sync();
//        int32_t ref = static_cast<int32_t>(adc_.get(0)); // 指令電圧
        int32_t out = static_cast<int32_t>(adc_.get(1)); // 出力電圧
        int32_t inp = static_cast<int32_t>(adc_.get(2)); // 入力電圧

        // 三角波
        if(up) {
            ref += 20;
        } else {
            ref -= 20;
        }
        if(ref > 1700) {
            up = false;
            ref = 1700;
        } else if(ref < 200) {
            up = true;
            ref = 200;
        }

        int32_t dif = ref - out;  // 誤差
        // PWM の制御量に対するスレッショルド
        if(std::abs(dif) < 40) {
            if(dif < 0) --cpv;
            else ++cpv;
        } else {
            // 基本的な制御量の計算
            int32_t d = dif * 512 / inp;

            // 指令電圧、入力電圧の比に応じて、ゲインを制御
            // ・指令電圧が低い場合はゲインを小さくする
            int32_t g = (high_gain - base_gain) * ref / inp;
            g += base_gain;
            if(d < 0) g -= g / 4;
            cpv += d * g / 4096;
        }

        // 出力リミッター
        if(cpv < low_limit) cpv = low_limit;
        else if(cpv > high_limit) cpv = high_limit;

        gpt_.set_a(cpv);
        uint16_t ofs = (512 - cpv) / 2;
        gpt_.set_ad_a(cpv + ofs);   // A/D 変換開始タイミング

↑はメインループ(サンプリング)部分
※実用的には過電流保護なども必要。
出力に 1000uF のコンデンサと 10uF のセラミックコンデンサを入れたら、リップルはかなり小さくなり、これなら実用的と思える。
※電圧が低い場合にはゲインを抑えるように改修

IMG_0537ss
※三角波を出力したところ
これなら、まぁ許容できるかも・・

追記(2014/1/7):
トップのオン時、出力が振動するのは、リニアテクノロジーの資料を読んでたら、トップ側FETに並列にショットキーダイオードを入れる事で改善する事が判り、早速入れてみた、完全には無くならないが、確かに改善してる。
全体的にリップルも減った。