カテゴリー
writer

自作ROMライター その1

 PCのサウンド出力を多チャンネル化し複数の信号を扱える装置をなぜ作っているかの理由ですが、8085を動かすためにはどうしてもROMが必要で、それにはROMライタがなければ何もできません。

 ROMライタを手に入れれば何のことも無いのですが、勉強がてら作成することにしました。

 マイコンボードをUSBに繋いでROMに必要な信号を送る方法が定石のようですが8085の時代にUSBや今のシングルボードコンピュータがあったわけではないのでオペアンプとジャンクに近い部品で作成しようとしています。

#include <iostream>
#include <windows.h>
#include <math.h>
#include <MMSystem.h>

#pragma comment (lib, "winmm.lib")

void createWave(LPWORD lpData, size_t frequency, size_t sampling, WORD amplitude) {
    size_t wavelength = sampling / frequency;
    double d = 360.0 / wavelength;
    double pi = 3.14159265359;
    for (int i = 0; i < wavelength; i++) {
        lpData[i] = (WORD)(amplitude * sin(d * (i % wavelength) / 180.0 * pi));
    }
}

int main() {

    WAVEFORMATEX wfe;
    static HWAVEOUT hWaveOut;
    static WAVEHDR whdr;
    static LPWORD lpWave;
    static LPWORD lpData;

    // 最初と最後の1sは出力しないので3以上とする
    size_t terms = 12;

    size_t i, j, k, start, end;
    size_t frequency = 400;
    size_t sampling = 192000;
    size_t wavelength = sampling / frequency;

    wavelength = sampling / frequency;
    wfe.wFormatTag = WAVE_FORMAT_PCM;
    wfe.nChannels = 2;
    wfe.wBitsPerSample = 16;
    wfe.nBlockAlign = wfe.nChannels * wfe.wBitsPerSample / 8;
    wfe.nSamplesPerSec = (DWORD)sampling;
    wfe.nAvgBytesPerSec = wfe.nSamplesPerSec * wfe.nBlockAlign;
    waveOutOpen(&hWaveOut, 0, &wfe, 0, 0, CALLBACK_NULL);
    lpWave = (LPWORD)calloc(sizeof(WORD), wfe.nChannels * sampling * terms);

    end = sampling * wfe.nChannels * 1;
    WORD amplitude = 32767/4;
    for (i = 0; i < end; i++) {
        lpWave[i] = 0;
    }

    // 最初の1sは出力しない
    start = sampling * wfe.nChannels * 1;
    end = wfe.nChannels * sampling * terms;
    // 最後の1sは出力しない
    end -= sampling * wfe.nChannels * 1;

    size_t valWavelength;
    size_t valFrequency;

    lpData = (LPWORD)calloc(sizeof(WORD), wavelength);
    createWave(lpData, frequency, sampling, amplitude);
    for (i = start, j = 0; i < end; i += 2) {
        lpWave[i] = lpData[j];
        ++j;
        if (j >= wavelength) { j = 0; }
    }
    free(lpData);

    valFrequency = 3200;
    valWavelength = sampling / valFrequency;
    for (i = start + 1, j = 0, k = 0; i < end; i += 2) {
        if (j == 0) {
            lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
            createWave(lpData, valFrequency, sampling, amplitude);
        }
        if (sampling/4 * 0 <= k && k < sampling/4 * 1) {
            lpWave[i] = lpData[j];
        }
        ++j;
        ++k;
        if (j >= valWavelength) {
            j = 0;
            free(lpData);
        }
        if (k >= sampling) {
            k = 0;
        }
    }

    valFrequency = 8000;
    valWavelength = sampling / valFrequency;
    for (i = start + 1, j = 0, k = 0; i < end; i += 2) {
        if (j == 0) {
            lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
            createWave(lpData, valFrequency, sampling, amplitude);
        }
        if (sampling/4 * 1 <= k && k < sampling/4 * 2) {
            lpWave[i] += lpData[j];
        }
        ++j;
        ++k;
        if (j >= valWavelength) {
            j = 0;
            free(lpData);
        }
        if (k >= sampling) {
            k = 0;
        }
    }
 
    valFrequency = 11300;
    valWavelength = sampling / valFrequency;
    for (i = start + 1, j = 0, k = 0; i < end; i += 2) {
        if (j == 0) {
            lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
            createWave(lpData, valFrequency, sampling, amplitude);
        }
        if (sampling/4 * 2 <= k && k < sampling/4 * 3) {
            lpWave[i] += lpData[j];
        }
        ++j;
        ++k;
        if (j >= valWavelength) {
            j = 0;
            free(lpData);
        }
        if (k >=  sampling) {
            k = 0;
        }
    }
 
    valFrequency = 17000;
    valWavelength = sampling / valFrequency;
    for (i = start + 1, j = 0, k = 0; i < end; i += 2) {
        if (j == 0) {
            lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
            createWave(lpData, valFrequency, sampling, amplitude);
        }
        if (sampling/4 * 3 <= k && k < sampling/4 * 4) {
            lpWave[i] += lpData[j];
        }
        ++j;
        ++k;
        if (j >= valWavelength) {
            j = 0;
            free(lpData);
        }
        if (k >= sampling) {
            k = 0;
        }
    }
    
    whdr.lpData = (LPSTR)lpWave;
    whdr.dwBufferLength = wfe.nAvgBytesPerSec * terms;
    whdr.dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP;
    whdr.dwLoops = 1;
    waveOutPrepareHeader(hWaveOut, &whdr, sizeof(WAVEHDR));
    waveOutWrite(hWaveOut, &whdr, sizeof(WAVEHDR));

    char str[128];
    std::cout << "hello, world\n";
    std::cin >> str;

}

 4つの異なる周波数の信号を混合しPCからサウンド出力します。それぞれ別に信号が出ている時はhigh、出ていない時はlowとすれば1つのアナログ信号を4つのデジタル信号として解釈できるはずです。

ROMライターアナログ部
ROMライターアナログ部

 741Cを2個1組にして4組のフィルタで分離しそれぞれをまた741Cで増幅後、ダイオードで検波しています。各信号を復調し信号を取り出す仕組みです。

 PCからLEDを順に点灯する信号を出してみました。意図通りそれぞれ別の周波数のhighとlowの信号が4つに分離されています。

 振幅偏移変調による多重化通信装置の完成です。

カテゴリー
Filter

アクティブバンドパスフィルタ4

 オペアンプ二段増幅型バンドパスフィルタが思いのほか上手く出来たので4個並べてみました。

4チャンネルバンドパスフィルタ
3,148Hz付近
7,680Hz付近
11,294Hz付近
17,455Hz付近
上部 -6, +6両電源(LM386)
下部 4チャンネル化するためのフィルター
#include <iostream>
#include <windows.h>
#include <math.h>
#include <MMSystem.h>

#pragma comment (lib, "winmm.lib")

void createWave(LPWORD lpData, size_t frequency, size_t sampling, WORD amplitude) {
    size_t wavelength = sampling / frequency;
    double d = 360.0 / wavelength;
    double pi = 3.14159265359;
    for (int i = 0; i < wavelength; i++) {
        lpData[i] = (WORD)(amplitude * sin(d * (i % wavelength) / 180.0 * pi));
    }
}

int main() {

    WAVEFORMATEX wfe;
    static HWAVEOUT hWaveOut;
    static WAVEHDR whdr;
    static LPWORD lpWave;
    static LPWORD lpData;

    // 最初と最後の1sは出力しないので3以上とする
    size_t terms = 7;

    size_t i, j, start, end;
    size_t frequency = 400;
    size_t sampling = 192000;
    size_t wavelength = sampling / frequency;

    wavelength = sampling / frequency;
    wfe.wFormatTag = WAVE_FORMAT_PCM;
    wfe.nChannels = 2;
    wfe.wBitsPerSample = 16;
    wfe.nBlockAlign = wfe.nChannels * wfe.wBitsPerSample / 8;
    wfe.nSamplesPerSec = (DWORD)sampling;
    wfe.nAvgBytesPerSec = wfe.nSamplesPerSec * wfe.nBlockAlign;
    waveOutOpen(&hWaveOut, 0, &wfe, 0, 0, CALLBACK_NULL);
    lpWave = (LPWORD)calloc(sizeof(WORD), wfe.nChannels * sampling * terms);

    end = sampling * wfe.nChannels * 1;
    WORD amplitude = 32767;
    for (i = 0; i < end; i++) {
        lpWave[i] = 0;
    }

    // 最初の1sは出力しない
    start = sampling * wfe.nChannels * 1;
    end = wfe.nChannels * sampling * terms;
    // 最後の1sは出力しない
    end -= sampling * wfe.nChannels * 1;

    size_t valWavelength;
    size_t valFrequency;

    lpData = (LPWORD)calloc(sizeof(WORD), wavelength);
    createWave(lpData, frequency, sampling, amplitude);
    for (i = start, j = 0; i < end; i += 2) {
        lpWave[i] = lpData[j];
        ++j;
        if (j >= wavelength) { j = 0; }
    }
    free(lpData);

    for (i = start + 1, j = 0; i < end; i += 2) {
        if (j == 1) {
            valFrequency = frequency + ((i - start) * (20000.0 - frequency)) / (sampling * wfe.nChannels * (terms - 2));
            valWavelength = sampling / valFrequency;
            lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
            createWave(lpData, valFrequency, sampling, amplitude);
        }
        lpWave[i] = lpData[j];
        ++j;
        if (j >= valWavelength) {
            j = 0;
            free(lpData);
        }
    }

    whdr.lpData = (LPSTR)lpWave;
    whdr.dwBufferLength = wfe.nAvgBytesPerSec * terms;
    whdr.dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP;
    whdr.dwLoops = 1;
    waveOutPrepareHeader(hWaveOut, &whdr, sizeof(WAVEHDR));
    waveOutWrite(hWaveOut, &whdr, sizeof(WAVEHDR));

    char str[128];
    std::cout << "hello, world\n";
    std::cin >> str;

}

 可聴範囲を4分割し多チャンネル化できました。普通のPCであればステレオサウンド出力は付いているので左右に適用すれば8チャンネル、フィルタをもっと丁寧に作ればそれ以上も可能と思います。

カテゴリー
Filter

アクティブバンドパスフィルタ3

 流石にアクティブバンドフィルターは期待通りの性能を出せました。低周波領域でもオペアンプを使えば部品点数も少なく理想的なフィルタが作れそうです。続いて信号の分離性を高めるためQの高いフィルタで実験してみました。

R1=220200Ω
R2=4771Ω
R3=4630Ω
C1=2677pF
IC=UPC741C
Q=46.851
f0=12649.593Hz

二段増幅型バンドパスフィルタで400Hzから20kHzをスイープしている様子

 このくらいのQであれば信号の分離ができそうです。

400Hz付近
12kHz付近
20kHz付近
オペアンプ二段増幅型バンドパスフィルタ
オペアンプ二段増幅型バンドパスフィルタ

 部品点数も少なくQが高いバンドフィルタを作ることができました。これであればPCのサウンドライン出力に複数の信号を混合し受け側で分離すればライン1チャンネルを複数チャンネルにすることができそうです。1つのプログラム、1つのチャンネル、1つの受け側となるので波形単位の制御が必要なデジタル信号処理にも耐えられると思います。

#include <iostream>
#include <windows.h>
#include <math.h>
#include <MMSystem.h>

#pragma comment (lib, "winmm.lib")

void createWave(LPWORD lpData, size_t frequency, size_t sampling, WORD amplitude) {
    size_t wavelength = sampling / frequency;
    double d = 360.0 / wavelength;
    double pi = 3.14159265359;
    for (int i = 0; i < wavelength; i++) {
        lpData[i] = (WORD)(amplitude * sin(d * (i % wavelength) / 180.0 * pi));
    }
}

int main() {

    WAVEFORMATEX wfe;
    static HWAVEOUT hWaveOut;
    static WAVEHDR whdr;
    static LPWORD lpWave;
    static LPWORD lpData;

    // 最初と最後の1sは出力しないので3以上とする
    size_t terms = 7;

    size_t i, j, start, end;
    size_t frequency = 400;
    size_t sampling = 384000;
    size_t wavelength = sampling / frequency;

    wavelength = sampling / frequency;
    wfe.wFormatTag = WAVE_FORMAT_PCM;
    wfe.nChannels = 2;
    wfe.wBitsPerSample = 16;
    wfe.nBlockAlign = wfe.nChannels * wfe.wBitsPerSample / 8;
    wfe.nSamplesPerSec = (DWORD)sampling;
    wfe.nAvgBytesPerSec = wfe.nSamplesPerSec * wfe.nBlockAlign;
    waveOutOpen(&hWaveOut, 0, &wfe, 0, 0, CALLBACK_NULL);
    lpWave = (LPWORD)calloc(sizeof(WORD), wfe.nChannels * sampling * terms);

    end = sampling * wfe.nChannels * 1;
    WORD amplitude = 32767;
    for (i = 0; i < end; i++) {
        lpWave[i] = 0;
    }

    // 最初の1sは出力しない
    start = sampling * wfe.nChannels * 1;
    end = wfe.nChannels * sampling * terms;
    // 最後の1sは出力しない
    end -= sampling * wfe.nChannels * 1;

    size_t valWavelength;
    size_t valFrequency;
    for (i = start, j = 0; i < end; i += 2) {
        if (j == 0) {
            valFrequency = frequency + ((i - start) * (20000.0- frequency)) / (sampling * wfe.nChannels * (terms - 2));
            valWavelength = sampling / valFrequency;
            lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
            createWave(lpData, valFrequency, sampling, amplitude);
        }
        lpWave[i] = lpData[j];
        ++j;
        if (j >= valWavelength) {
            j = 0;
            free(lpData);
        }
    }

    lpData = (LPWORD)calloc(sizeof(WORD), wavelength);
    createWave(lpData, frequency, sampling, amplitude);
    for (i = start+1, j = 0; i < end; i += 2) {
        lpWave[i] = lpData[j];
        ++j;
        if (j >= wavelength) { j = 0; }
    }
    free(lpData);

    whdr.lpData = (LPSTR)lpWave;
    whdr.dwBufferLength = wfe.nAvgBytesPerSec * terms;
    whdr.dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP;
    whdr.dwLoops = 1;
    waveOutPrepareHeader(hWaveOut, &whdr, sizeof(WAVEHDR));
    waveOutWrite(hWaveOut, &whdr, sizeof(WAVEHDR));
    
    char str[128];
    std::cout << "hello, world\n";
    std::cin >> str;

}
カテゴリー
Filter

アクティブバンドパスフィルタ2

 パッシブバンドフィルタが上手くいかなかったのでオペアンプを使用してアクティブバンドフィルタの実験を行いました。

Multiple Feedback Band Pass Filter
Multiple Feedback Band Pass Filter

R1=4649Ω
R2=4763Ω
R3=477.8kΩ
C1=287pF
C2=295pF
IC=UPC741C
Q=7.125
f0=16314.28Hz

パッシブバンドフィルタ

 可聴周波数をスイープして出力しフィルタを通した様子です。フィルタが機能しているのが判ります。しかし、複数の信号を狭い帯域に載せるにはもっとQが高くないと分離が上手くいかないような気がします。

400Hz付近
11kHz付近、コンデンサの容量が小さいのでブレッドボードの影響を受けている模様
20kHz付近
オペアンプ多重帰還型バンドパスフィルタ
オペアンプ多重帰還型バンドパスフィルタ
#include <iostream>
#include <windows.h>
#include <math.h>
#include <MMSystem.h>

#pragma comment (lib, "winmm.lib")

void createWave(LPWORD lpData, size_t frequency, size_t sampling, WORD amplitude) {
    size_t wavelength = sampling / frequency;
    double d = 360.0 / wavelength;
    double pi = 3.14159265359;
    for (int i = 0; i < wavelength; i++) {
        lpData[i] = (WORD)(amplitude * sin(d * (i % wavelength) / 180.0 * pi));
    }
}

int main() {

    WAVEFORMATEX wfe;
    static HWAVEOUT hWaveOut;
    static WAVEHDR whdr;
    static LPWORD lpWave;
    static LPWORD lpData;

    // 最初と最後の1sは出力しないので3以上とする
    size_t terms = 7;

    size_t i, j, start, end;
    size_t frequency = 400;
    size_t sampling = 384000;
    size_t wavelength = sampling / frequency;

    wavelength = sampling / frequency;
    wfe.wFormatTag = WAVE_FORMAT_PCM;
    wfe.nChannels = 2;
    wfe.wBitsPerSample = 16;
    wfe.nBlockAlign = wfe.nChannels * wfe.wBitsPerSample / 8;
    wfe.nSamplesPerSec = (DWORD)sampling;
    wfe.nAvgBytesPerSec = wfe.nSamplesPerSec * wfe.nBlockAlign;
    waveOutOpen(&hWaveOut, 0, &wfe, 0, 0, CALLBACK_NULL);
    lpWave = (LPWORD)calloc(sizeof(WORD), wfe.nChannels * sampling * terms);

    end = sampling * wfe.nChannels * 1;
    WORD amplitude = 32767;
    for (i = 0; i < end; i++) {
        lpWave[i] = 0;
    }

    // 最初の1sは出力しない
    start = sampling * wfe.nChannels * 1;
    end = wfe.nChannels * sampling * terms;
    // 最後の1sは出力しない
    end -= sampling * wfe.nChannels * 1;

    size_t valWavelength;
    size_t valFrequency;
    for (i = start, j = 0; i < end; i += 2) {
        if (j == 0) {
            valFrequency = frequency + ((i - start) * (20000.0- frequency)) / (sampling * wfe.nChannels * (terms - 2));
            valWavelength = sampling / valFrequency;
            lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
            createWave(lpData, valFrequency, sampling, amplitude);
        }
        lpWave[i] = lpData[j];
        ++j;
        if (j >= valWavelength) {
            j = 0;
            free(lpData);
        }
    }

    lpData = (LPWORD)calloc(sizeof(WORD), wavelength);
    createWave(lpData, frequency, sampling, amplitude);
    for (i = start+1, j = 0; i < end; i += 2) {
        lpWave[i] = lpData[j];
        ++j;
        if (j >= wavelength) { j = 0; }
    }
    free(lpData);

    whdr.lpData = (LPSTR)lpWave;
    whdr.dwBufferLength = wfe.nAvgBytesPerSec * terms;
    whdr.dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP;
    whdr.dwLoops = 1;
    waveOutPrepareHeader(hWaveOut, &whdr, sizeof(WAVEHDR));
    waveOutWrite(hWaveOut, &whdr, sizeof(WAVEHDR));
    
    char str[128];
    std::cout << "hello, world\n";
    std::cin >> str;

}
カテゴリー
Filter

パッシブバンドフィルター

 PCのサウンドラインに複数の信号を混合して出力し受け側で利用するためにはフィルタで分離する必要があります。早速簡単なLCフィルターで実験してみました。手持ちに丁度良いコイルが無かったので小信号トランスで代用しました。

Passive Band Pass Filter
Passive Band Pass Filter

R=1305Ω
L=494mH
C=4633pF
Q=7.912
f0=3326.791Hz

パッシブフィルターの性能

 400Hzから20kHzまでスイープして信号を出力してみましたが、実用にできるほどの分離性はみられませんでした。

パッシブバンドフィルタ
RLC パッシブバンドフィルタ

 扱っているのが低周波なので性能の良いコイルを小さく作らないと使い物にならないことがわかりました。

#include <iostream>
#include <windows.h>
#include <math.h>
#include <MMSystem.h>

#pragma comment (lib, "winmm.lib")

void createWave(LPWORD lpData, size_t frequency, size_t sampling, WORD amplitude) {
    size_t wavelength = sampling / frequency;
    double d = 360.0 / wavelength;
    double pi = 3.14159265359;
    for (int i = 0; i < wavelength; i++) {
        lpData[i] = (WORD)(amplitude * sin(d * (i % wavelength) / 180.0 * pi));
    }
}

int main() {

    WAVEFORMATEX wfe;
    static HWAVEOUT hWaveOut;
    static WAVEHDR whdr;
    static LPWORD lpWave;
    static LPWORD lpData;

    // 最初と最後の1sは出力しないので3以上とする
    size_t terms = 7;

    size_t i, j, start, end;
    size_t frequency = 400;
    size_t sampling = 384000;
    size_t wavelength = sampling / frequency;

    wavelength = sampling / frequency;
    wfe.wFormatTag = WAVE_FORMAT_PCM;
    wfe.nChannels = 2;
    wfe.wBitsPerSample = 16;
    wfe.nBlockAlign = wfe.nChannels * wfe.wBitsPerSample / 8;
    wfe.nSamplesPerSec = (DWORD)sampling;
    wfe.nAvgBytesPerSec = wfe.nSamplesPerSec * wfe.nBlockAlign;
    waveOutOpen(&hWaveOut, 0, &wfe, 0, 0, CALLBACK_NULL);
    lpWave = (LPWORD)calloc(sizeof(WORD), wfe.nChannels * sampling * terms);

    end = sampling * wfe.nChannels * 1;
    WORD amplitude = 32767;
    for (i = 0; i < end; i++) {
        lpWave[i] = 0;
    }

    // 最初の1sは出力しない
    start = sampling * wfe.nChannels * 1;
    end = wfe.nChannels * sampling * terms;
    // 最後の1sは出力しない
    end -= sampling * wfe.nChannels * 1;

    size_t valWavelength;
    size_t valFrequency;
    for (i = start, j = 0; i < end; i += 2) {
        if (j == 0) {
            valFrequency = frequency + ((i - start) * (20000.0- frequency)) / (sampling * wfe.nChannels * (terms - 2));
            valWavelength = sampling / valFrequency;
            lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
            createWave(lpData, valFrequency, sampling, amplitude);
        }
        lpWave[i] = lpData[j];
        ++j;
        if (j >= valWavelength) {
            j = 0;
            free(lpData);
        }
    }

    lpData = (LPWORD)calloc(sizeof(WORD), wavelength);
    createWave(lpData, frequency, sampling, amplitude);
    for (i = start+1, j = 0; i < end; i += 2) {
        lpWave[i] = lpData[j];
        ++j;
        if (j >= wavelength) { j = 0; }
    }
    free(lpData);

    whdr.lpData = (LPSTR)lpWave;
    whdr.dwBufferLength = wfe.nAvgBytesPerSec * terms;
    whdr.dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP;
    whdr.dwLoops = 1;
    waveOutPrepareHeader(hWaveOut, &whdr, sizeof(WAVEHDR));
    waveOutWrite(hWaveOut, &whdr, sizeof(WAVEHDR));
    
    char str[128];
    std::cout << "hello, world\n";
    std::cin >> str;

}