冒頭の略伝に「力学の究極理由、運動法則そのものの究極理由を求めた時に、それが数学の中には見つからない、形而上学に戻らなければならないと気が付いて全く驚きました。そこで私はエンテレケイアに立ち帰って」とあります。
数学や物理は自然科学の分野ですが究極理由を追い求めると哲学まで遡って考えを深める必要があったと理解しました。
この本が神学ではなく自然科学であるということなら神、現実と空想も人工知能には必要と思いました。
カテゴリー: ニュース
ニュース
カテゴリー
自作ROMライター その7
変調波の周波数をもっと高くして実用的なデータ転送速度にする為に搬送波の周波数は高いほうを使います。
ステレオサウンド出力の左右それぞれ二つの変調波を載せて合計4チャンネルの信号を装置に送ります。
搬送波:19kHz, 21kHz
変調波:700Hz
をそれぞれ左右に出力
この時アナログ/デジタル変換にシュミットトリガーを使っていたのですが上手くいかずヒステリシス付きのコンパレータに変更しました。
#include <iostream>
#include <windows.h>
#include <math.h>
#include <MMSystem.h>
#pragma comment (lib, "winmm.lib")
constexpr auto SAMPLING = 192000;
constexpr auto CHANNEL = 2;
constexpr auto BITSPERSAMPLE = 16;
constexpr auto MAXAMP = 32767;
constexpr auto DIV = 4;
constexpr auto BUFFERING = 10;
void createWave(LPWORD lpData, size_t frequency, size_t sampling, WORD amplitude) {
double wavelength = (double)sampling / (double)frequency;
// double pi = 3.14159265359;
for (int i = 0; i < wavelength; i++) {
lpData[i] = (WORD)(amplitude * sin((i*6.28318530718) / wavelength));
}
}
BOOLEAN isON(unsigned char data, size_t bit, size_t bitLength, size_t value) {
int oneByte = 8;
for (int i = 0; i < oneByte; i++) {
unsigned char mask = 0x80 >> i;
if (((data & mask) == mask) &&
// (bitLength * ((bit - oneByte) + i)) <= (value % (bitLength * bit)) &&
// (value % (bitLength * bit)) < (bitLength * ((bit - oneByte + 1) + i))) {
(bitLength * (bit - oneByte + i)) <= (value % (bitLength * bit)) &&
(value % (bitLength * bit)) < (bitLength *(bit - oneByte + 1 + i))) {
return true;
}
}
return false;
}
void addWave(LPWORD param1, LPWORD param2, size_t length) {
for (int i = 0; i < length; i++) {
param1[i] += param2[i];
}
}
DWORD soundOut(
LPWORD* lpWaveData,
HWAVEOUT hWaveOut,
unsigned char data,
size_t bit,
size_t cFrequency,
BOOL reset,
BOOL control
) {
LPWORD lpSinWave;
LPWORD lpWave;
LPWORD lpWaveTemp;
size_t i, j;
size_t cWavelength = SAMPLING / cFrequency;
size_t dataLength;
size_t andSequence = 0;
size_t dWavelength;
size_t dFrequency;
dataLength = (size_t)CHANNEL * (BITSPERSAMPLE / 8) * cWavelength * bit / sizeof(WORD);
if (control == TRUE) {
andSequence = (size_t)CHANNEL * (BITSPERSAMPLE / 8) * cWavelength / sizeof(WORD);
}
lpWave = (LPWORD)calloc(sizeof(WORD), dataLength + andSequence);
for (i = 0; i < dataLength + andSequence; i++) {
lpWave[i] = 0;
}
lpWaveTemp = (LPWORD)calloc(sizeof(WORD), dataLength + andSequence);
lpSinWave = (LPWORD)calloc(sizeof(WORD), SAMPLING);
/* チャンネル1 ********************************/
// シリアルデータ
dFrequency = 21000;
dWavelength = SAMPLING / dFrequency;
createWave(lpSinWave, dFrequency, SAMPLING, MAXAMP / 2);
memset(lpWaveTemp, 0x00, (dataLength + andSequence) * sizeof(WORD));
for (i = 0, j = 0; i < dataLength; i += CHANNEL, ++j) {
lpWaveTemp[i] = lpSinWave[j];
if (j >= dWavelength) { j = 0; }
}
for (i = 0; i < dataLength; i += CHANNEL) {
if (isON(0xff- data, bit, cWavelength * CHANNEL, i)) {
lpWaveTemp[i] = 0;
}
}
addWave(lpWave, lpWaveTemp, dataLength + andSequence);
// 制御データ
if (andSequence > 0) {
dFrequency = 16000;
dWavelength = SAMPLING / dFrequency;
createWave(lpSinWave, dFrequency, SAMPLING, MAXAMP / 2);
memset(lpWaveTemp, 0x00, (dataLength + andSequence) * sizeof(WORD));
for (i = dataLength + andSequence / 2, j = 0; i < dataLength + andSequence; i += CHANNEL, ++j) {
lpWaveTemp[i] = lpSinWave[j];
if (j >= dWavelength) { j = 0; }
}
addWave(lpWave, lpWaveTemp, dataLength + andSequence);
}
/* チャンネル2 ********************************/
// クロック
dFrequency = 21000;
dWavelength = SAMPLING / dFrequency;
createWave(lpSinWave, dFrequency, SAMPLING, MAXAMP / 2);
memset(lpWaveTemp, 0x00, (dataLength + andSequence) * sizeof(WORD));
for (i = 1, j = 0; i < dataLength; i += CHANNEL) {
lpWaveTemp[i] = lpSinWave[j];
++j;
if (j >= dWavelength) { j = 0; }
}
for (i = 1, j = 0; i < dataLength; i += CHANNEL, ++j) {
if (j < cWavelength/1.4) { lpWaveTemp[i] = 0; }
if (j >= cWavelength) { j = 0; }
}
addWave(lpWave, lpWaveTemp, dataLength + andSequence);
// リセット
if (reset == TRUE) {
dFrequency = 16000;
dWavelength = SAMPLING / dFrequency;
createWave(lpSinWave, dFrequency, SAMPLING, MAXAMP / 2);
memset(lpWaveTemp, 0x00, (dataLength + andSequence) * sizeof(WORD));
for (i = 1, j = 0; i < cWavelength/2; i += CHANNEL, ++j) {
lpWaveTemp[i] = lpSinWave[j];
if (j >= dWavelength) { j = 0; }
}
addWave(lpWave, lpWaveTemp, dataLength + andSequence);
}
free(lpSinWave);
free(lpWaveTemp);
*lpWaveData = lpWave;
return (DWORD)(dataLength + andSequence) * sizeof(WORD);
}
int main() {
LPWORD lpWave[BUFFERING];
WAVEHDR whdr[BUFFERING];
WAVEFORMATEX wfe;
HWAVEOUT hWaveOut;
wfe.wFormatTag = WAVE_FORMAT_PCM;
wfe.nChannels = CHANNEL;
wfe.wBitsPerSample = BITSPERSAMPLE;
wfe.nBlockAlign = CHANNEL * BITSPERSAMPLE / 8;
wfe.nSamplesPerSec = SAMPLING;
wfe.nAvgBytesPerSec = wfe.nSamplesPerSec * wfe.nBlockAlign;
for (int i = 0; i < BUFFERING; i++) {
whdr[i].dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP;
whdr[i].dwLoops = 1;
lpWave[i] = NULL;
}
std::string str;
std::cout << "2桁毎の16進コードを入力しEnterを押して下さい。（00 ～ FF）" << std::endl;
std::cout << "続けて入力する場合は間を空けないでください。" << std::endl;
std::cout << "Ctrl+Zを入力しEnterで終了します。" << std::endl;
std::cin >> str;
waveOutOpen(&hWaveOut, 0, &wfe, 0, 0, CALLBACK_NULL);
char strData[3];
strData[2] = 0x00;
size_t bit = 9;
// 変調波
size_t frequency = 700;
int freeBuffer = 0;
for (int i = 0, j = 0, k = 0; i < str.size(); i += 2, j++, k++) {
if (j >= BUFFERING) {
j = 0;
}
freeBuffer = j + 1;
if (freeBuffer >= BUFFERING) {
freeBuffer = 0;
}
if (lpWave[freeBuffer] != NULL) {
free(lpWave[freeBuffer]);
lpWave[freeBuffer] = NULL;
}
strData[0] = str[i];
strData[1] = str[(size_t)i + 1];
// 入力された文字列をデータに変換
unsigned char data = (unsigned char)strtol(strData, NULL, 16);
// サウンド出力
if (j % 3 == 0) {
whdr[j].dwBufferLength = soundOut(&lpWave[j], hWaveOut, data, bit, frequency, TRUE, FALSE);
}
else if (j % 3 == 2) {
whdr[j].dwBufferLength = soundOut(&lpWave[j], hWaveOut, data, bit -1, frequency, FALSE, TRUE);
}
else {
whdr[j].dwBufferLength = soundOut(&lpWave[j], hWaveOut, data, bit - 1, frequency, FALSE, FALSE);
}
whdr[j].lpData = (LPSTR)lpWave[j];
waveOutPrepareHeader(hWaveOut, &whdr[j], sizeof(WAVEHDR));
waveOutWrite(hWaveOut, &whdr[j], sizeof(WAVEHDR));
if (k > BUFFERING - 3) {
Sleep((1000 * (DWORD)bit) / (DWORD)frequency);
}
}
int num = (int)str.size() / 2;
if (num == 0) {
num = 1;
}
else if (num > BUFFERING) {
num = BUFFERING;
}
Sleep((1000 * (DWORD)bit * (num + 1)) / (DWORD)frequency);
waveOutReset(hWaveOut);
waveOutClose(hWaveOut);
for (int i = 0; i < num; i++) {
if (lpWave[i] != NULL) {
free(lpWave[i]);
lpWave[i] = NULL;
}
}
}
前書きによれば特殊相対性理論は初等的知識で理解することができるが不完全性定理は入門書を読んだくらいでは到底理解することはできないと威し文句が書かれています。恐ろしげな本ですが勉強してみます。
読んでみましたが前半の論文本体はやはり難しく理解が進みませんでしたが後半の解説でかろうじて概要を掴むことができたと思います。
ある数学の系に矛盾がないことをその系自体で証明できない。
自身の正当性を自身のみでは証明できないなんて人間のような話でした。
常々人工知能には「知」のみでは無く「能」もなければそれは単なる知の集合であって知能ではないと思っていました。
「能」に当たる部分を本能とすれば知の集合と本能を併せて人工知能ができると考えた訳です。
不完全性定理を読んで「知」と「能」のみならず「勇気」と「創造」も必要であると考えを改めました。
ゲーテルに勇気と創造がなければ系が持つ矛盾を乗り越えることはできなかったでしょう。
https://www.renesas.com/jp/ja/doc/DocumentServer/005/G10517JJ9V0DS00.pdf
https://ja.na4.teamsupport.com/knowledgeBase/17797905
ChatGPTに聞いてみた。
User
uPC339Cは何ですか。
ChatGPT
uPC339Cは、クアッドコンパレータ（Quad Comparator）IC（集積回路）の1つです。このICは、4つのコンパレータを持ち、入力信号を比較し、出力信号を生成することができます。また、このICは、低消費電力であるため、電池駆動のアプリケーションに適しています。
uPC339Cは、デュアルインラインパッケージ（DIP）で提供され、14ピンのパッケージングを採用しています。このICには、4つのコンパレータがあり、それぞれのコンパレータには、非反転入力ピン、反転入力ピン、出力ピン、電源ピンがあります。
uPC339Cは、入力信号の比較、スイッチング機能、オーバーボルテージ保護などのために広く使用されています。また、このICは、オーディオ機器、産業用途、自動車用途、モータードライブなどのアプリケーションにも使用されています。
カテゴリー
相対性理論 電気力学の部
電気力学の部
運動学の部と同じように解るところまで数式を勉強します。
$$
\frac{1}{c^2}\frac{\partial E_x}{\partial t}=\frac{\partial B_z}{\partial y}-\frac{\partial B_y}{\partial z},
$$
$$
\frac{\partial B_x}{\partial t}=-\left(\frac{\partial E_z}{\partial y}-\frac{\partial E_y}{\partial z}\right),
$$
$$
\frac{1}{c^2}\frac{\partial E_y}{\partial t}=\frac{\partial B_x}{\partial z}-\frac{\partial B_z}{\partial x},
$$
$$
\frac{\partial B_y}{\partial t}=-\left(\frac{\partial E_x}{\partial z}-\frac{\partial E_z}{\partial x}\right),
$$
$$
\frac{1}{c^2}\frac{\partial E_z}{\partial t}=\frac{\partial B_y}{\partial x}-\frac{\partial B_x}{\partial y},
$$
$$
\frac{\partial B_z}{\partial t}=-\left(\frac{\partial E_y}{\partial x}-\frac{\partial E_x}{\partial y}\right),
$$
$$\left.\begin{array}{c}
\frac{1}{c^2}\frac{\partial E_x}{\partial \tau}=\frac{\partial}{\partial\eta}\left\{\beta\left(E_z-\frac{v}{c^2}E_y\right)\right\}-\frac{\partial}{\partial\zeta}\left\{\beta\left(B_y+\frac{v}{c^2}E_z\right)\right\},
\\
\frac{1}{c^2}\frac{\partial}{\partial \tau}\{\beta(E_y-vB_z)\}=\frac{\partial B_x}{\partial\zeta}-\frac{\partial}{\partial\xi}\left\{\beta\left(B_z-\frac{v}{c^2}E_y\right)\right\},
\\
\frac{1}{c^2}\frac{\partial}{\partial \tau}\{\beta(E_z+vB_y)\}=\frac{\partial}{\partial\xi}\left\{\beta\left(B_y+\frac{v}{c^2}E_z\right)\right\}-\frac{\partial}{\partial\eta}B_x,
\end{array}\right\}
$$
$$
\left.\begin{array}{c}
\frac{\partial B_x}{\partial\tau}=-\frac{\partial}{\partial\eta}\{\beta(E_z+vB_y)\}+\frac{\partial}{\partial\zeta}\{\beta(E_y-vB_z)\},
\\
\frac{\partial}{\partial\tau}\left\{\beta\left(B_y+\frac{v}{c^2}E_z\right)\right\}=-\frac{\partial}{\partial\zeta}E_x+\frac{\partial}{\partial\xi}\{\beta(E_z+vB_y)\},
\\
\frac{\partial}{\partial\tau}\left\{\beta\left(B_z-\frac{v}{c^2}E_y\right)\right\}=-\frac{\partial}{\partial\xi}\{\beta(E_y-vB_z)\}+\frac{\partial}{\partial\eta}E_x.
\end{array}\right\}
$$
$$\beta=\frac{1}{\sqrt{1-(v/c)^2}}$$
$$
\frac{1}{c^2}\frac{\partial E’_{\xi}}{\partial\tau}=\frac{\partial B’_{\zeta}}{\partial\eta}-\frac{\partial B’_{\eta}}{\partial\zeta},
$$
$$
\frac{\partial B’_{\xi}}{\partial\tau}=-\left(\frac{\partial E’_{\zeta}}{\partial\eta}-\frac{\partial E’_{\eta}}{\partial\zeta}\right),
$$
$$
\frac{1}{c^2}\frac{\partial E’_{\eta}}{\partial\tau}=\frac{\partial B’_{\xi}}{\partial\zeta}-\frac{\partial B’_{\zeta}}{\partial\xi},
$$
$$
\frac{\partial B’_{\eta}}{\partial\tau}=-\left(\frac{\partial E’_{\xi}}{\partial\zeta}-\frac{\partial E’_{\zeta}}{\partial\xi}\right),
$$
$$
\frac{1}{c^2}\frac{\partial E’_{\zeta}}{\partial\tau}=\frac{\partial B’_{\eta}}{\partial\xi}-\frac{\partial B’_{\xi}}{\partial\eta},
$$
$$
\frac{\partial B’_{\zeta}}{\partial\tau}=-\left(\frac{\partial E’_{\eta}}{\partial\xi}-\frac{\partial E’_{\xi}}{\partial\eta}\right).
$$
$$
E'_{\xi}=\psi(v)E_x,
\space
B’_{\xi}=\psi(v)B_x,
$$
$$
E'_{\eta}=\psi(v)\beta(E_y-vB_z),
\space
B’_{\eta}=\psi(v)\beta\{B_y+(v/c^2)E_z\},
$$
$$
E'_{\zeta}=\psi(v)\beta(E_z+vB_y),
\space
B’_{\zeta}=\psi(v)\beta\{B_z-(v/c^2)E_y\}.
$$
$$\psi(v)\cdot\psi(-v)=1.$$
$$\psi(v)=\psi(-v).$$
$$\psi(v)=1$$
$$E’_{\xi}=E_x,\space B’_{\xi}=B_x,$$
$$
E’_{\eta}=\beta(E_y-vB_z),\space B’_{\eta}=\beta\left(B_y+\frac{v}{c^2}E_z\right),
$$
$$
E’_{\zeta}=\beta(E_z-vB_y),\space B’_{\zeta}=\beta\left(B_z+\frac{v}{c^2}E_y\right).
$$
$$
E_x=E_{x0}\space sin\space\varPhi,\space B_x=B_{x0}\space sin\space\varPhi,
$$
$$
E_y=E_{y0}\space sin\space\varPhi,\space B_y=B_{y0}\space sin\space\varPhi,
$$
$$
E_z=E_{z0}\space sin\space\varPhi,\space B_z=B_{z0}\space sin\space\varPhi,
$$
$$
\varPhi=\omega\{t-(lx+my+nz)/c\}.
$$
$$
E’_{\xi}=E_{x0}\space sin\space\varPhi’,\space B’_{\xi}=B_{x0}\space sin\space\varPhi’,
$$
$$
E’_{\eta}=\beta(E_{y0}-vB_{z0})\space sin\space\varPhi’,\space B’_{\eta}=\beta\left(B_{y0}+\frac{v}{c^2}E_{z0}\right)\space sin\space\varPhi’,
$$
$$
E’_{\zeta}=\beta(E_{z0}-vB_{y0})\space sin\space\varPhi’,\space B’_{\zeta}=\beta\left(B_{z0}+\frac{v}{c^2}E_{y0}\right)\space sin\space\varPhi’,
$$
$$\varPhi’=\omega’\{\tau-(l’\xi+m’\eta+n’\zeta)/c\}.$$
$$\omega’=\omega\beta\left(1-l\frac{v}{c}\right),$$
$$l’=\left.\left(l-\frac{v}{c}\right)\middle/\left(1-l\frac{v}{c}\right)\right.,$$
$$m’=\left. m\middle/\beta\left(1-l\frac{v}{c}\right)\right.,$$
$$n’=\left. n\middle/\beta\left(1-l\frac{v}{c}\right)\right. .$$
$$\nu’=\left.\nu\left(1-\frac{v}{c}cos\space\varphi\right)\middle/\sqrt{1-\left(\frac{v}{c}\right)^2}\right.$$
$$\nu’=\nu\sqrt{\left.\left(1-\frac{v}{c}\right)\middle/\left(1+\frac{v}{c}\right)\right.}.$$
$$cos\space\varphi’=\left.\left(cos\space\varphi-\frac{v}{c}\right)\middle/\left(1-\frac{v}{c}cos\space\varphi\right)\right..$$
$$cos\space\varphi’=-\frac{v}{c}.$$
$$
(A’)^2=A^2\left.\left(1-\frac{v}{c}cos\space\varphi\right)^2\middle/\left\{1-\left(\frac{v}{c}\right)^2\right\}\right..
$$
$$\varphi=0$$
$$
(A’)^2=A^2\left.\left(1-\frac{v}{c}\right)\middle/\left(1+\frac{v}{c}\right)\right..
$$
この式のところで「観測者が速さcで光源に向かって走ればこの人から見たとき光源は無限に強い明るさに輝いて見えることになる」とあったのですが直ぐに理解できなかったので補足しておきます。
光源に向かっているのでvはマイナスの値になります。vがcに近づくほど分母は1+v/cなので0に近づきます。分子は1-v/cなので2に近づきます。従って限り無く2に近い値を限り無く0に近い値で割るので無限に大きい振幅になるということです。
$$w=(\vec E\cdot\vec D+\vec H\cdot\vec B)/2$$
$$(x-lct)^2+(y-mct)^2+(z-nct)^2=R^2$$
$$\left(\beta\xi-l\frac{v}{c}\beta\xi\right)^2+\left(\eta-m\frac{v}{c}\beta\xi\right)^2+\left(\zeta-n\frac{v}{c}\beta\xi\right)^2=R^2$$
$$
\frac{S’}{S}=\left.\sqrt{1-\left(\frac{v}{c}\right)^2}\middle/\left(1-\frac{v}{c}cos\space\varphi\right)\right.
$$
$$
\frac{E’}{E}=\frac{w’S’}{wS}=\frac{(A’)^2S’}{(A)^2S}=\frac{1-(v/c)cos\space\varphi}{\sqrt{1-(v/c)^2}}
$$
$$\varphi=0$$
$$\frac{E’}{E}=\sqrt{\frac{1-(v/c)}{1+(v/c)}}.$$
$$
A’=A\{1-(v/c)cos\space\varphi\}/\sqrt{1-(v/c)^2},
$$
$$
cos\space\varphi’=\{cos\space\varphi-(v/c)\}/\{1-(v/c)cos\space\varphi\},
$$
$$
\nu’=\nu\cdot\{1-(v/c)cos\space\varphi\}/\sqrt{1-(v/c)^2}
$$
$$
A^{\prime\prime}=A’,\space cos\space\varphi^{\prime\prime}=-cos\space\varphi’,\space\nu^{\prime\prime}=\nu’
$$
$$
A^{\prime\prime\prime}=A^{\prime\prime}\frac{1+(v/c)cos\space\varphi^{\prime\prime}}{\sqrt{1-(v/c)^2}}=A\frac{1-2(v/c)cos\space\varphi+(v/c)^2}{1-(v/c)^2},
$$
$$
cos\space\varphi^{\prime\prime\prime}=\frac{cos\space\varphi^{\prime\prime}+(v/c)}{1+(v/c)cos\space\varphi^{\prime\prime}}=-\frac{\{1+(v/c)^2\}cos\space\varphi-2(v/c)}{1-2(v/c)cos\space\varphi+(v/c)^2},
$$
$$
\nu^{\prime\prime\prime}=\nu^{\prime\prime}\frac{1+(v/c)cos\space\varphi^{\prime\prime}}{\sqrt{1-(v/c)^2}}=\nu\frac{1-2(v/c)cos\space\varphi+(v/c)^2}{\{1-(v/c)\}^2},
$$
$$
P=2w\frac{\{cos\space\varphi-(v/c)\}^2}{1-(v/c)^2}.
$$
$$P=2w\space cos^2\varphi$$
ようやく「力」が出てきました。
$$
\frac{\partial D_x}{\partial t}+\rho u_x=\frac{\partial H_z}{\partial y}-\frac{\partial H_y}{\partial z},\space\frac{\partial B_x}{\partial t}=-\frac{\partial E_z}{\partial y}+\frac{\partial E_y}{\partial z},
$$
$$
\frac{\partial D_y}{\partial t}+\rho u_y=\frac{\partial H_x}{\partial z}-\frac{\partial H_z}{\partial x},\space\frac{\partial B_y}{\partial t}=-\frac{\partial E_x}{\partial z}+\frac{\partial E_z}{\partial x},
$$
$$
\frac{\partial D_z}{\partial t}+\rho u_z=\frac{\partial H_y}{\partial x}-\frac{\partial H_x}{\partial y},\space\frac{\partial B_z}{\partial t}=-\frac{\partial E_y}{\partial x}+\frac{\partial E_x}{\partial y}.
$$
$$
\rho=\frac{\partial D_x}{\partial x}+\frac{\partial D_y}{\partial y}+\frac{\partial D_z}{\partial z}
$$
$$
\frac{\partial D’_\xi}{\partial\tau}+\rho’ u_\xi=\frac{\partial H’_\zeta}{\partial \eta}-\frac{\partial H’_\eta}{\partial \zeta},\space\frac{\partial B’_\xi}{\partial\tau}=-\frac{\partial E’_\zeta}{\partial \eta}+\frac{\partial E’_\eta}{\partial \zeta},
$$
$$
\frac{\partial D’_\eta}{\partial\tau}+\rho’ u_\eta=\frac{\partial H’_\xi}{\partial \zeta}-\frac{\partial H’_\zeta}{\partial \xi},\space\frac{\partial B’_\eta}{\partial\tau}=-\frac{\partial E’_\xi}{\partial \zeta}+\frac{\partial E’_\zeta}{\partial \xi},
$$
$$
\frac{\partial D’_\zeta}{\partial\tau}+\rho’ u_\zeta=\frac{\partial H’_\eta}{\partial \xi}-\frac{\partial H’_\xi}{\partial \eta},\space\frac{\partial B’_\zeta}{\partial\tau}=-\frac{\partial E’_\eta}{\partial \xi}+\frac{\partial E’_\xi}{\partial \eta}.
$$
$$u_\xi=\frac{u_x-v}{1-(u_xv/c^2)},\space u_\eta=\frac{u_y}{\beta\{1-(u_xv/c^2)\}},\space u_\zeta=\frac{u_z}{\beta\{1-(u_xv/c^2)\}},$$
$$\rho’=\frac{\partial D’_\xi}{\partial\xi}+\frac{\partial D’_\eta}{\partial\eta}+\frac{\partial D’_\zeta}{\partial\zeta}=\beta\left(1-\frac{u_xv}{c^2}\right)\rho.$$
$$
\mu\frac{d^2x}{dt^2}=\varepsilon E_x,
\space
\mu\frac{d^2y}{dt^2}=\varepsilon E_y,
\space
\mu\frac{d^2z}{dt^2}=\varepsilon E_z
$$
ここの説明に \(\mu\) は「その質量を表す」とあります。「力」に続き「質量」も登場してきました。
$$t=x=y=z=0$$
$$\tau=\xi=\eta=\zeta=0$$
$$\tau=\beta\{t-(v/c^2)x\},$$
$$\xi=\beta(x-vy),\space E’_\xi=E_x,$$
$$\eta=y,\space E’_\eta=\beta(E_y-vB_z),$$
$$\zeta=z,\space E’_\zeta=\beta(E_z+vB_y).$$
$$\left.\begin{array}{c}
\frac{d^2x}{dt^2}=\frac{\varepsilon}{\mu}\frac{1}{\beta^3}E_x,
\\
\frac{d^2y}{dt^2}=\frac{\varepsilon}{\mu}\frac{1}{\beta}(E_y-vB_z),
\\
\frac{d^2z}{dt^2}=\frac{\varepsilon}{\mu}\frac{1}{\beta}(E_z+vB_y).
\end{array}\right\}
$$
$$\mu\beta^3\frac{d^2x}{dt^2}=\varepsilon E_x =\varepsilon E’\xi,$$
$$\mu\beta^2\frac{d^2y}{dt^2}=\varepsilon\beta(E_y-vB_z) =\varepsilon E’\eta,$$
$$\mu\beta^2\frac{d^2z}{dt^2}=\varepsilon\beta(E_z+vB_y) =\varepsilon E’\zeta,$$
$$mass \times acceleration = power$$
$$longitudinal\space mass=\left.\mu\middle/\left\{\sqrt{1-\left(\frac{v}{c}\right)^2}\right\}^3\right.,$$
$$transverse\space mass=\left.\mu\middle/\left\{1-\left(\frac{v}{c}\right)^2\right\}\right.$$
$$W=\int\varepsilon E_xdx=\mu\int_0^v\beta^3vdv=\mu c^2\left\{\frac{1}{\sqrt{1-(v/c)^2}}-1\right\}.$$
$$A_m/A_e=v/c$$
$$P=\int E_xdx=\frac{\mu}{\varepsilon}c^2\left\{\frac{1}{\sqrt{1-(v/c)^2}}-1\right\}.$$
$$-\frac{d^2y}{dt^2}=\frac{v^2}{R}=\frac{\varepsilon}{\mu}vB\sqrt{1-(v/c)^2},$$
$$R=\mu v/\varepsilon B\sqrt{1-(v/c)^2}.$$
光速が不変となった為に運動学の部では時間と空間が可変となり、電気力学の部では質量までも可変になってしまいました。当時最新の科学であったであろう電磁波と数百年来慣れ親しんだ力学を統一した理論で再構築しあらゆる科学に見直しを迫るというとてつもない偉業が書かれている一冊でした。
カテゴリー
自作ROMライター その6
パソコンから３バイト単位（アドレス１６ビット、データ８ビット）で信号を送ることができるようになりました。クロック４３Hz、アドレス＋データ２４ビット、リセット信号をキーボドから入力した値に応じて送りLEDを点灯しています。最後のビットを送った後に書き込み信号を送ることができればROMに書き込みができるはずです。
#include <iostream>
#include <windows.h>
#include <math.h>
#include <MMSystem.h>
#pragma comment (lib, "winmm.lib")
constexpr auto SAMPLING = 192000;
constexpr auto CHANNEL = 2;
constexpr auto BITSPERSAMPLE = 16;
constexpr auto MAXAMP = 32767;
constexpr auto DIV = 4;
constexpr auto BUFFERING = 10;
void createWave(LPWORD lpData, size_t frequency, size_t sampling, WORD amplitude) {
double wavelength = (double)sampling / (double)frequency;
double d = 360.0 / wavelength;
double pi = 3.14159265359;
for (int i = 0; i < wavelength; i++) {
lpData[i] = (WORD)(amplitude * sin(d * i / 180.0 * pi));
}
}
BOOLEAN isON(unsigned char data, size_t bit, size_t bitLength, size_t value) {
int oneByte = 8;
for (int i = 0; i < oneByte; i++) {
unsigned char mask = 0x80 >> i;
if (((data & mask) == mask) &&
(bitLength *((bit-oneByte )+i)) <= (value % (bitLength * bit)) &&
(value % (bitLength * bit)) < (bitLength * ((bit - oneByte + 1) + i))) {
return true;
}
}
return false;
}
DWORD soundOut(
LPWORD *lpWaveData,
HWAVEOUT hWaveOut,
unsigned char data,
size_t bit,
size_t cFrequency,
BOOL reset
) {
LPWORD lpSinWave;
LPWORD lpWave;
LPWORD lpWave1;
LPWORD lpWave2;
LPWORD lpWave3;
LPWORD lpWave4;
size_t i, j, end;
size_t cWavelength = SAMPLING / cFrequency;
size_t dataLength = (size_t)CHANNEL * (BITSPERSAMPLE / 8) * cWavelength * bit;
size_t dWavelength;
size_t dFrequency;
WORD amplitude = MAXAMP / DIV;
lpWave = (LPWORD)calloc(sizeof(WORD), dataLength);
lpWave1 = (LPWORD)calloc(sizeof(WORD), dataLength);
lpWave2 = (LPWORD)calloc(sizeof(WORD), dataLength);
lpWave3 = (LPWORD)calloc(sizeof(WORD), dataLength);
lpWave4 = (LPWORD)calloc(sizeof(WORD), dataLength);
end = dataLength/(BITSPERSAMPLE / 8);
for (i = 0; i < end; i++) {
lpWave[i] = 0;
lpWave1[i] = 0;
lpWave2[i] = 0;
lpWave3[i] = 0;
lpWave4[i] = 0;
}
/* チャンネル1 ********************************/
lpSinWave = (LPWORD)calloc(sizeof(WORD), cWavelength);
createWave(lpSinWave, cFrequency, SAMPLING, MAXAMP);
for (i = 0, j = 0; i < end; i += CHANNEL) {
lpWave[i] = lpSinWave[j];
++j;
if (j >= cWavelength) { j = 0; }
}
free(lpSinWave);
/* チャンネル2 ********************************/
// クロック
dFrequency = 3200;
dWavelength = SAMPLING / dFrequency;
lpSinWave = (LPWORD)calloc(sizeof(WORD), dWavelength);
createWave(lpSinWave, dFrequency, SAMPLING, amplitude);
for (i = 1, j = 0; i < end; i += CHANNEL) {
lpWave1[i] = lpSinWave[j];
++j;
if (j >= dWavelength) { j = 0; }
}
for (i = 1, j = 0; i < end; i += CHANNEL, ++j) {
if (j < cWavelength/2) { lpWave1[i] = 0; }
if (j >= cWavelength) { j = 0; }
}
free(lpSinWave);
// 制御データ
dFrequency = 8000;
dWavelength = SAMPLING / dFrequency;
lpSinWave = (LPWORD)calloc(sizeof(WORD), dWavelength);
createWave(lpSinWave, dFrequency, SAMPLING, amplitude);
for (i = 1, j = 0; i < end; i += CHANNEL) {
lpWave2[i] = lpSinWave[j];
++j;
if (j >= dWavelength) { j = 0; }
}
for (i = 1, j = 0; i < end; i += CHANNEL, ++j) {
if (j < cWavelength/1.2) { lpWave2[i] = 0; }
if (j >= cWavelength) { j = 0; }
}
free(lpSinWave);
// シリアルデータ２
dFrequency = 11300;
dWavelength = SAMPLING / dFrequency;
lpSinWave = (LPWORD)calloc(sizeof(WORD), dWavelength);
createWave(lpSinWave, dFrequency, SAMPLING, amplitude);
for (i = 1, j = 0; i < end; i += CHANNEL, ++j) {
lpWave3[i] = lpSinWave[j];
if (j >= dWavelength) { j = 0; }
}
for (i = 1; i < end; i += CHANNEL) {
if (isON(data, bit, cWavelength * CHANNEL, i)) {
lpWave3[i] = 0;
}
}
free(lpSinWave);
// リセット
if (reset) {
dFrequency = 17000;
dWavelength = SAMPLING / dFrequency;
lpSinWave = (LPWORD)calloc(sizeof(WORD), dWavelength);
createWave(lpSinWave, dFrequency, SAMPLING, amplitude);
for (i = 1, j = 0; i < cWavelength; i += CHANNEL, ++j) {
lpWave4[i] = lpSinWave[j];
if (j >= dWavelength) { j = 0; }
}
free(lpSinWave);
}
// チャンネル２に合成
for (i = 1; i < end; i += CHANNEL) {
lpWave[i] = lpWave1[i] + lpWave2[i] + lpWave3[i] + lpWave4[i];
}
*lpWaveData = lpWave;
return (DWORD)dataLength;
}
int main() {
LPWORD lpWave[BUFFERING];
WAVEHDR whdr[BUFFERING];
WAVEFORMATEX wfe;
HWAVEOUT hWaveOut;
wfe.wFormatTag = WAVE_FORMAT_PCM;
wfe.nChannels = CHANNEL;
wfe.wBitsPerSample = BITSPERSAMPLE;
wfe.nBlockAlign = CHANNEL * BITSPERSAMPLE / 8;
wfe.nSamplesPerSec = SAMPLING;
wfe.nAvgBytesPerSec = wfe.nSamplesPerSec * wfe.nBlockAlign;
waveOutOpen(&hWaveOut, 0, &wfe, 0, 0, CALLBACK_NULL);
for (int i = 0; i < BUFFERING; i++) {
whdr[i].dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP;
whdr[i].dwLoops = 1;
lpWave[i] = NULL;
}
std::string str;
do {
std::cout << "2桁毎の16進コードを入力しEnterを押して下さい。（00 ～ FF）" << std::endl;
std::cout << "続けて入力する場合は間を空けないでください。" << std::endl;
std::cout << "Ctrl+Zを入力しEnterで終了します。" << std::endl;
std::cin >> str;
// Ctrl+Zで終了
if (std::cin.eof()) { break; }
char strData[3];
strData[2] = 0x00;
size_t bit = 9;
size_t frequency = 43;
int freeBuffer = 0;
for (int i = 0, j = 0, k = 0; i < str.size(); i += 2, j++, k++) {
if (j >= BUFFERING) {
j = 0;
}
freeBuffer = j + 1;
if (freeBuffer >= BUFFERING) {
freeBuffer = 0;
}
if (lpWave[freeBuffer] != NULL) {
std::cout << "free=" << std::dec << freeBuffer << std::endl;
free(lpWave[freeBuffer]);
lpWave[freeBuffer] = NULL;
}
strData[0] = str[i];
strData[1] = str[(size_t)i + 1];
// 入力された文字列をデータに変換
unsigned char data = (unsigned char)strtol(strData, NULL, 16);
// サウンド出力
if (i % 3 == 0) {
whdr[j].dwBufferLength = soundOut(&lpWave[j], hWaveOut, data, bit, frequency, true);
}
else {
whdr[j].dwBufferLength = soundOut(&lpWave[j], hWaveOut, data, bit-1, frequency, false);
}
whdr[j].lpData = (LPSTR)lpWave[j];
waveOutPrepareHeader(hWaveOut, &whdr[j], sizeof(WAVEHDR));
waveOutWrite(hWaveOut, &whdr[j], sizeof(WAVEHDR));
std::cout << "no=" << std::dec << j << ", data=" << std::hex << (int)data << "H" << std::endl;
if (k > BUFFERING-3) {
Sleep((1000 * (DWORD)bit) / (DWORD)frequency);
}
}
int num = (int)str.size() / 2;
if (num == 0) {
num = 1;
}
else if (num > BUFFERING) {
num = BUFFERING;
}
Sleep((1000 * (DWORD)bit * (num +1)) / (DWORD)frequency);
for (int i = 0; i < num; i++) {
if (lpWave[i] != NULL) {
std::cout << "free=" << std::dec << i << std::endl;
free(lpWave[i]);
lpWave[i] = NULL;
}
}
} while (true);
waveOutClose(hWaveOut);
}
カテゴリー
自作ROMライター その5
ソフトウェアを改良し複数バイトのデータを送り込めるようにしました。これでROMに書き込みたいデータとクロックや制御信号を混合してパソコンからサウンド出力し、受け側の装置で分離してロジックICを意図通りに動かすことができるようになりました。
#include <iostream>
#include <windows.h>
#include <math.h>
#include <MMSystem.h>
#pragma comment (lib, "winmm.lib")
constexpr auto SAMPLING = 192000;
constexpr auto CHANNEL = 2;
constexpr auto BITSPERSAMPLE = 16;
constexpr auto MAXAMP = 32767;
constexpr auto DIV = 4;
constexpr auto BUFFERING = 10;
void createWave(LPWORD lpData, size_t frequency, size_t sampling, WORD amplitude) {
double wavelength = (double)sampling / (double)frequency;
double d = 360.0 / wavelength;
double pi = 3.14159265359;
for (int i = 0; i < wavelength; i++) {
lpData[i] = (WORD)(amplitude * sin(d * i / 180.0 * pi));
}
}
BOOLEAN isON(unsigned char data, size_t bit, size_t bitLength, size_t value) {
int oneByte = 8;
for (int i = 0; i < oneByte; i++) {
unsigned char mask = 0x80 >> i;
if (((data & mask) == mask) &&
(bitLength *((bit-oneByte )+i)) <= (value % (bitLength * bit)) &&
(value % (bitLength * bit)) < (bitLength * ((bit - oneByte + 1) + i))) {
return true;
}
}
return false;
}
DWORD soundOut(LPWORD *lpWaveData, HWAVEOUT hWaveOut, unsigned char data, size_t bit, size_t cFrequency) {
LPWORD lpSinWave;
LPWORD lpWave;
LPWORD lpWave1;
LPWORD lpWave2;
LPWORD lpWave3;
LPWORD lpWave4;
size_t i, j, end;
size_t cWavelength = SAMPLING / cFrequency;
size_t dataLength = (size_t)CHANNEL * (BITSPERSAMPLE / 8) * cWavelength * bit;
size_t dWavelength;
size_t dFrequency;
WORD amplitude = MAXAMP / DIV;
lpWave = (LPWORD)calloc(sizeof(WORD), dataLength);
lpWave1 = (LPWORD)calloc(sizeof(WORD), dataLength);
lpWave2 = (LPWORD)calloc(sizeof(WORD), dataLength);
lpWave3 = (LPWORD)calloc(sizeof(WORD), dataLength);
lpWave4 = (LPWORD)calloc(sizeof(WORD), dataLength);
end = dataLength/(BITSPERSAMPLE / 8);
for (i = 0; i < end; i++) {
lpWave[i] = 0;
lpWave1[i] = 0;
lpWave2[i] = 0;
lpWave3[i] = 0;
lpWave4[i] = 0;
}
/* チャンネル1 ********************************/
lpSinWave = (LPWORD)calloc(sizeof(WORD), cWavelength);
createWave(lpSinWave, cFrequency, SAMPLING, MAXAMP);
for (i = 0, j = 0; i < end; i += CHANNEL) {
lpWave[i] = lpSinWave[j];
++j;
if (j >= cWavelength) { j = 0; }
}
free(lpSinWave);
/* チャンネル2 ********************************/
// クロック
dFrequency = 3200;
dWavelength = SAMPLING / dFrequency;
lpSinWave = (LPWORD)calloc(sizeof(WORD), dWavelength);
createWave(lpSinWave, dFrequency, SAMPLING, amplitude);
for (i = 1, j = 0; i < end; i += CHANNEL) {
lpWave1[i] = lpSinWave[j];
++j;
if (j >= dWavelength) { j = 0; }
}
for (i = 1, j = 0; i < end; i += CHANNEL, ++j) {
if (j < cWavelength/2) { lpWave1[i] = 0; }
if (j >= cWavelength) { j = 0; }
}
free(lpSinWave);
// 制御データ
dFrequency = 8000;
dWavelength = SAMPLING / dFrequency;
lpSinWave = (LPWORD)calloc(sizeof(WORD), dWavelength);
createWave(lpSinWave, dFrequency, SAMPLING, amplitude);
for (i = 1, j = 0; i < end; i += CHANNEL) {
lpWave2[i] = lpSinWave[j];
++j;
if (j >= dWavelength) { j = 0; }
}
for (i = 1, j = 0; i < end; i += CHANNEL, ++j) {
if (j < cWavelength/1.2) { lpWave2[i] = 0; }
if (j >= cWavelength) { j = 0; }
}
free(lpSinWave);
// シリアルデータ２
dFrequency = 11300;
dWavelength = SAMPLING / dFrequency;
lpSinWave = (LPWORD)calloc(sizeof(WORD), dWavelength);
createWave(lpSinWave, dFrequency, SAMPLING, amplitude);
for (i = 1, j = 0; i < end; i += CHANNEL, ++j) {
lpWave3[i] = lpSinWave[j];
if (j >= dWavelength) { j = 0; }
}
for (i = 1; i < end; i += CHANNEL) {
if (isON(data, bit, cWavelength * CHANNEL, i)) {
lpWave3[i] = 0;
}
}
free(lpSinWave);
// リセット
dFrequency = 17000;
dWavelength = SAMPLING / dFrequency;
lpSinWave = (LPWORD)calloc(sizeof(WORD), dWavelength);
createWave(lpSinWave, dFrequency, SAMPLING, amplitude);
for (i = 1, j = 0; i < cWavelength; i += CHANNEL, ++j) {
lpWave4[i] = lpSinWave[j];
if (j >= dWavelength) { j = 0; }
}
free(lpSinWave);
// チャンネル２に合成
for (i = 1; i < end; i += CHANNEL) {
lpWave[i] = lpWave1[i] + lpWave2[i] + lpWave3[i] + lpWave4[i];
}
*lpWaveData = lpWave;
return (DWORD)dataLength;
}
int main() {
LPWORD lpWave[BUFFERING];
WAVEHDR whdr[BUFFERING];
WAVEFORMATEX wfe;
HWAVEOUT hWaveOut;
wfe.wFormatTag = WAVE_FORMAT_PCM;
wfe.nChannels = CHANNEL;
wfe.wBitsPerSample = BITSPERSAMPLE;
wfe.nBlockAlign = CHANNEL * BITSPERSAMPLE / 8;
wfe.nSamplesPerSec = SAMPLING;
wfe.nAvgBytesPerSec = wfe.nSamplesPerSec * wfe.nBlockAlign;
waveOutOpen(&hWaveOut, 0, &wfe, 0, 0, CALLBACK_NULL);
for (int i = 0; i < BUFFERING; i++) {
whdr[i].dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP;
whdr[i].dwLoops = 1;
lpWave[i] = NULL;
}
std::string str;
do {
std::cout << "2桁毎の16進コードを入力しEnterを押して下さい。（00 ～ FF）" << std::endl;
std::cout << "続けて入力する場合は間を空けないでください。" << std::endl;
std::cout << "Ctrl+Zを入力しEnterで終了します。" << std::endl;
std::cin >> str;
// Ctrl+Zで終了
if (std::cin.eof()) { break; }
char strData[3];
strData[2] = 0x00;
size_t bit = 9;
size_t frequency = 43;
int freeBuffer = 0;
for (int i = 0, j = 0, k = 0; i < str.size(); i += 2, j++, k++) {
if (j >= BUFFERING) {
j = 0;
}
freeBuffer = j + 1;
if (freeBuffer >= BUFFERING) {
freeBuffer = 0;
}
if (lpWave[freeBuffer] != NULL) {
std::cout << "free=" << std::dec << freeBuffer << std::endl;
free(lpWave[freeBuffer]);
lpWave[freeBuffer] = NULL;
}
strData[0] = str[i];
strData[1] = str[(size_t)i + 1];
// 入力された文字列をデータに変換
unsigned char data = (unsigned char)strtol(strData, NULL, 16);
// サウンド出力
whdr[j].dwBufferLength = soundOut(&lpWave[j], hWaveOut, data, bit, frequency);
whdr[j].lpData = (LPSTR)lpWave[j];
waveOutPrepareHeader(hWaveOut, &whdr[j], sizeof(WAVEHDR));
waveOutWrite(hWaveOut, &whdr[j], sizeof(WAVEHDR));
std::cout << "no=" << std::dec << j << ", data=" << std::hex << (int)data << "H" << std::endl;
if (k > BUFFERING-3) {
Sleep((1000 * (DWORD)bit) / (DWORD)frequency);
}
}
int num = (int)str.size() / 2;
if (num == 0) {
num = 1;
}
else if (num > BUFFERING) {
num = BUFFERING;
}
Sleep((1000 * (DWORD)bit * (num +1)) / (DWORD)frequency);
for (int i = 0; i < num; i++) {
if (lpWave[i] != NULL) {
std::cout << "free=" << std::dec << i << std::endl;
free(lpWave[i]);
lpWave[i] = NULL;
}
}
} while (true);
waveOutClose(hWaveOut);
}
が究極のナチュラルコンピューティングかもしれない。導体に拘らなければ新しい世界が拓けるだろう。
2020年10月3日 近い理論を知りました。光で演算する方法です。
https://doi.org/10.1364/OE.399495
なので今後も「The Optical Society」を注目していきます。
カテゴリー
自作ROMライター その4
74HC164Nでシリアルパラレル変換した後74LS273PCでその値を保持できるか実験してみました。同時にソフトウェアを改良しキーボードからバイト単位に信号を送出できるようにしました。
キーボードで16進数を1バイト分入力しEnterを押すとその値に応じてLEDが点灯しています。
#include <iostream>
#include <windows.h>
#include <math.h>
#include <MMSystem.h>
#pragma comment (lib, "winmm.lib")
constexpr auto SAMPLING = 192000;
constexpr auto CHANNEL = 2;
constexpr auto BITSPERSAMPLE = 16;
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));
}
}
BOOLEAN isON(unsigned char data, size_t bit, size_t i) {
size_t bit9 = bit * 9;
size_t bit8 = bit * 8;
size_t bit7 = bit * 7;
size_t bit6 = bit * 6;
size_t bit5 = bit * 5;
size_t bit4 = bit * 4;
size_t bit3 = bit * 3;
size_t bit2 = bit * 2;
if (((data & 0x80) == 0x80) && 0 <= (i % (bit9)) && (i % (bit9)) < (bit)) {
return true;
}
if (((data & 0x40) == 0x40) && (bit) <= (i % (bit9)) && (i % (bit9)) < (bit2)) {
return true;
}
if (((data & 0x20) == 0x20) && (bit2) <= (i % (bit9)) && (i % (bit9)) < (bit3)) {
return true;
}
if (((data & 0x10) == 0x10) && (bit3) <= (i % (bit9)) && (i % (bit9)) < (bit4)) {
return true;
}
if (((data & 0x08) == 0x08) && (bit4) <= (i % (bit9)) && (i % (bit9)) < (bit5)) {
return true;
}
if (((data & 0x04) == 0x04) && (bit5) <= (i % (bit9)) && (i % (bit9)) < (bit6)) {
return true;
}
if (((data & 0x02) == 0x02) && (bit6) <= (i % (bit9)) && (i % (bit9)) < (bit7)) {
return true;
}
if (((data & 0x01) == 0x01) && (bit7) <= (i % (bit9)) && (i % (bit9)) < (bit8)) {
return true;
}
return false;
}
static LPWORD lpWave;
static WAVEHDR whdr;
void soundOut(HWAVEOUT hWaveOut, unsigned char data) {
LPWORD lpData;
LPWORD lpWave1;
LPWORD lpWave2;
LPWORD lpWave3;
LPWORD lpWave4;
// 最初と最後の1sは出力しないので3以上とする
DWORD terms = 3;
size_t i, j, k, start, end;
size_t frequency = 9;
size_t wavelength = SAMPLING / frequency;
size_t dataLength = (size_t)CHANNEL * (size_t)SAMPLING * terms;
lpWave = (LPWORD)calloc(sizeof(WORD), dataLength);
lpWave1 = (LPWORD)calloc(sizeof(WORD), dataLength);
lpWave2 = (LPWORD)calloc(sizeof(WORD), dataLength);
lpWave3 = (LPWORD)calloc(sizeof(WORD), dataLength);
lpWave4 = (LPWORD)calloc(sizeof(WORD), dataLength);
end = SAMPLING * CHANNEL;
WORD amplitude = 32767 / 4;
for (i = 0; i < end; i++) {
lpWave[i] = 0;
lpWave1[i] = 0;
lpWave2[i] = 0;
lpWave3[i] = 0;
lpWave4[i] = 0;
}
size_t bit = CHANNEL * SAMPLING / frequency;
// 最初の1sは出力しない
start = SAMPLING * CHANNEL;
end = (size_t)CHANNEL * (size_t)SAMPLING * (size_t)terms;
// 最後の1sは出力しない
end -= SAMPLING * CHANNEL;
size_t valWavelength;
size_t valFrequency;
/* チャンネル1 ********************************/
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);
/* チャンネル2 ********************************/
// クロック
valFrequency = 3200;
valWavelength = SAMPLING / valFrequency;
lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
createWave(lpData, valFrequency, SAMPLING, amplitude);
for (i = start + 1, j = 0, k = 0; i < end; i += 2, ++j, ++k) {
if (k < SAMPLING / frequency / 2) { lpWave1[i] = lpData[j]; }
if (j >= valWavelength) { j = 0; }
if (k >= SAMPLING / frequency) { k = 0; }
}
free(lpData);
// シリアルデータ１
valFrequency = 8000;
valWavelength = SAMPLING / valFrequency;
lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
createWave(lpData, valFrequency, SAMPLING, amplitude);
for (i = 1, j = 0; i < end; i += 2, ++j) {
lpWave2[start + i] = lpData[j];
if (j >= valWavelength) { j = 0; }
}
free(lpData);
// シリアルデータ２
valFrequency = 11300;
valWavelength = SAMPLING / valFrequency;
lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
createWave(lpData, valFrequency, SAMPLING, amplitude);
for (i = 1, j = 0; i < end; i += 2, ++j) {
lpWave3[start + i] = lpData[j];
if (j >= valWavelength) { j = 0; }
}
for (i = 1, j = 0; i < end; i += 2, j += 2) {
if (j >= bit * 9) { j = 0; }
if (isON(data, bit, i)) {
lpWave3[start + i] = 0;
}
}
free(lpData);
// リセット
valFrequency = 17000;
valWavelength = SAMPLING / valFrequency;
lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
createWave(lpData, valFrequency, SAMPLING, amplitude);
for (i = 1; i < end; i += 2, ++j) {
lpWave4[start + i] = 0;
}
for (i = 1, j = 0; i < (end - bit * 9); i += 2, ++j) {
if ((i % (bit * 9)) < bit) {
lpWave4[start + i - bit] = lpData[j];
}
if (j >= valWavelength) { j = 0; }
}
free(lpData);
// チャンネル２に合成
for (i = 1; i < end; i += 2) {
lpWave[i] = lpWave1[i] + lpWave2[i] + lpWave3[i] + lpWave4[i];
}
// サウンド出力
whdr.lpData = (LPSTR)lpWave;
whdr.dwBufferLength = SAMPLING * (CHANNEL * BITSPERSAMPLE / 8) * terms;
whdr.dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP;
whdr.dwLoops = 1;
waveOutPrepareHeader(hWaveOut, &whdr, sizeof(WAVEHDR));
waveOutWrite(hWaveOut, &whdr, sizeof(WAVEHDR));
}
int main() {
WAVEFORMATEX wfe;
HWAVEOUT hWaveOut;
wfe.wFormatTag = WAVE_FORMAT_PCM;
wfe.nChannels = CHANNEL;
wfe.wBitsPerSample = BITSPERSAMPLE;
wfe.nBlockAlign = CHANNEL * BITSPERSAMPLE / 8;
wfe.nSamplesPerSec = SAMPLING;
wfe.nAvgBytesPerSec = wfe.nSamplesPerSec * wfe.nBlockAlign;
waveOutOpen(&hWaveOut, 0, &wfe, 0, 0, CALLBACK_NULL);
char str[128];
do {
std::cout << "2桁の16進コードを入力しEnterを押して下さい。（00 ～ FF）" << std::endl;
std::cout << "Ctrl+Zを入力しEnterを入力すると終了します。" << std::endl;
std::cin >> str;
// 入力された文字列をデータに変換
unsigned char data = (unsigned char)strtol(str, NULL, 16);
// Ctrl+Zで終了
if (std::cin.eof()) { break; }
// データをサウンド出力する
soundOut(hWaveOut, data);
} while (true);
waveOutClose(hWaveOut);
}
ここまででPCのサウンド出力を使ってデジタル素子を制御出来ることが解りました。
ChatGPTに聞いてみた。
User
レギュレーターの7905は何ですか。
ChatGPT
7905は、負の電源電圧を出力する固定型線形レギュレーターの1つで、5Vの出力を提供します。このレギュレーターは、電源電圧が入力されると、出力電圧を一定に保ち、負荷の変化に対しても安定した出力を提供することができます。
7905は、TO-220パッケージで提供され、3ピンのパッケージングを採用しています。このレギュレーターには、入力ピン、共通接地ピン、出力ピンがあります。また、一部の製品には、過熱保護回路も内蔵されています。
7905は、入力電圧が6.5Vから35Vの範囲で動作し、出力電流は最大1Aまで供給することができます。また、このレギュレーターは、定電圧により多くの電子回路で使用されており、オーディオ機器、電子機器、制御機器、産業用途などに広く使用されています。
ChatGPTに聞いてみた。
User
SN74HC04Nは何ですか。
ChatGPT
SN74HC04Nは、ヘキサインバータ（Hex Inverter）IC（集積回路）の1つです。このICは、6つのインバータを持っており、入力信号を反転させ、出力信号を生成することができます。また、このICは、高速で動作し、低消費電力であるため、多くのデジタルシステムに適しています。
SN74HC04Nは、デュアルインラインパッケージ（DIP）で提供され、14ピンのパッケージングを採用しています。このICには、6つのインバータがあり、それぞれのインバータには、入力ピンと出力ピンがあります。
SN74HC04Nは、高速な信号反転や駆動、多くのデジタルシステムでの信号調整などのアプリケーションに適しています。また、このICは、パルスジェネレーション、クロックドライバ、バッファリングなどのために、広く使用されています。
カテゴリー
自作ROMライター その3
74HC164Nでシリアルパラレル変換ができるとはByteデータを送り込めるということになります。ソフトウェアを改良しByte単位にデータを送れるか実験してみました。
ピークが１５回出ています。これが74HC164Nにリセット信号を送っているところで、その手前が1バイトのビットデータとなります。74HC164NはNOT出力ですので信号が立っているところが0、立っていないところが1と解釈してください。1、3、5、7と増えていくのが波形からわかります。
#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));
}
}
BOOLEAN isON(unsigned char data, size_t bit, size_t i) {
size_t bit9 = bit * 9;
size_t bit8 = bit * 8;
size_t bit7 = bit * 7;
size_t bit6 = bit * 6;
size_t bit5 = bit * 5;
size_t bit4 = bit * 4;
size_t bit3 = bit * 3;
size_t bit2 = bit * 2;
if (((data & 0x80) == 0x80) && 0 <= (i % (bit9)) && (i % (bit9)) < (bit)) {
return true;
}
if (((data & 0x40) == 0x40) && (bit) <= (i % (bit9)) && (i % (bit9)) < (bit2)) {
return true;
}
if (((data & 0x20) == 0x20) && (bit2) <= (i % (bit9)) && (i % (bit9)) < (bit3)) {
return true;
}
if (((data & 0x10) == 0x10) && (bit3) <= (i % (bit9)) && (i % (bit9)) < (bit4)) {
return true;
}
if (((data & 0x08) == 0x08) && (bit4) <= (i % (bit9)) && (i % (bit9)) < (bit5)) {
return true;
}
if (((data & 0x04) == 0x04) && (bit5) <= (i % (bit9)) && (i % (bit9)) < (bit6)) {
return true;
}
if (((data & 0x02) == 0x02) && (bit6) <= (i % (bit9)) && (i % (bit9)) < (bit7)) {
return true;
}
if (((data & 0x01) == 0x01) && (bit7) <= (i % (bit9)) && (i % (bit9)) < (bit8)) {
return true;
}
return false;
}
int main() {
WAVEFORMATEX wfe;
static HWAVEOUT hWaveOut;
static WAVEHDR whdr;
static LPWORD lpWave;
static LPWORD lpWave1;
static LPWORD lpWave2;
static LPWORD lpWave3;
static LPWORD lpWave4;
static LPWORD lpData;
// 最初と最後の1sは出力しないので3以上とする
DWORD terms = 17;
size_t i, j, k, start, end;
size_t frequency = 9;
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);
lpWave1 = (LPWORD)calloc(sizeof(WORD), wfe.nChannels * sampling * terms);
lpWave2 = (LPWORD)calloc(sizeof(WORD), wfe.nChannels * sampling * terms);
lpWave3 = (LPWORD)calloc(sizeof(WORD), wfe.nChannels * sampling * terms);
lpWave4 = (LPWORD)calloc(sizeof(WORD), wfe.nChannels * sampling * terms);
end = sampling * wfe.nChannels;
WORD amplitude = 32767/4;
for (i = 0; i < end; i++) {
lpWave[i] = 0;
lpWave1[i] = 0;
lpWave2[i] = 0;
lpWave3[i] = 0;
lpWave4[i] = 0;
}
// 最初の1sは出力しない
start = sampling * wfe.nChannels;
end = wfe.nChannels * sampling * terms;
// 最後の1sは出力しない
end -= sampling * wfe.nChannels;
size_t valWavelength;
size_t valFrequency;
size_t bit = wfe.nChannels * sampling / frequency;
/* チャンネル1 ********************************/
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);
/* チャンネル2 ********************************/
// クロック
valFrequency = 3200;
valWavelength = sampling / valFrequency;
lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
createWave(lpData, valFrequency, sampling, amplitude);
for (i = start + 1, j = 0, k = 0; i < end; i += 2, ++j, ++k) {
if (k < sampling / frequency / 2) { lpWave1[i] = lpData[j]; }
if (j >= valWavelength) { j = 0; }
if (k >= sampling / frequency) { k = 0; }
}
free(lpData);
const unsigned char dataList[] = {
0x01,
0x03,
0x07,
0x0F,
0x1F,
0x3F,
0x7F,
0xFF,
0x7F,
0x3F,
0x1F,
0x0F,
0x07,
0x03,
0x01
};
size_t dataLen = sizeof(dataList) / sizeof(*dataList);
unsigned char data = 0x00;
// シリアルデータ１
valFrequency = 8000;
valWavelength = sampling / valFrequency;
lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
createWave(lpData, valFrequency, sampling, amplitude);
for (i = 1, j = 0; i < end; i += 2, ++j) {
lpWave2[start + i] = lpData[j];
if (j >= valWavelength) { j = 0; }
}
free(lpData);
// シリアルデータ２
valFrequency = 11300;
valWavelength = sampling / valFrequency;
lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
createWave(lpData, valFrequency, sampling, amplitude);
for (i = 1, j = 0; i < end; i += 2, ++j) {
lpWave3[start + i] = lpData[j];
if (j >= valWavelength) { j = 0; }
}
for (i = 1, j = 0, k = 0; i < end; i += 2, j += 2) {
data = dataList[k];
if (j >= bit * 9) { j = 0; ++k; }
if (k >= dataLen) { k = 0; }
if (isON(data, bit, i)) {
lpWave3[start + i] = 0;
}
}
free(lpData);
// リセット
valFrequency = 17000;
valWavelength = sampling / valFrequency;
lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
createWave(lpData, valFrequency, sampling, amplitude);
for (i = 1; i < end; i += 2, ++j) {
lpWave4[start + i] = 0;
}
for (i = 1, j = 0; i < end; i += 2, ++j) {
if ((i % (bit * 9)) < bit) {
lpWave4[start + i - bit] = lpData[j];
}
if (j >= valWavelength) { j = 0; }
}
free(lpData);
// チャンネル２に合成
for (i = 1; i < end; i += 2) {
lpWave[i] = lpWave1[i] + lpWave2[i] + lpWave3[i] + lpWave4[i];
}
// サウンド出力
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;
}
カテゴリー
自作ROMライター その2
アナログ信号をデジタル信号のようにON/OFFしてLEDを明滅させたとしても信号自体はアナログであるためそのままでデジタル素子を制御できるわけではありません。
そこでデジタル素子で扱える信号にするため74HC14APを使いhigh:+5V, low:0Vの本物のデジタル信号にできるか実験してみました。
4chフィルタから出た信号を検波(復調)後74HC14APで波形を整え74HC164Nでシリアルパラレル変換しました。
#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 lpWave1;
static LPWORD lpWave2;
static LPWORD lpWave3;
static LPWORD lpWave4;
static LPWORD lpData;
// 最初と最後の1sは出力しないので3以上とする
size_t terms = 402;
size_t i, j, k, start, end, cycle;
size_t frequency = 16;
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);
lpWave1 = (LPWORD)calloc(sizeof(WORD), wfe.nChannels * sampling * terms);
lpWave2 = (LPWORD)calloc(sizeof(WORD), wfe.nChannels * sampling * terms);
lpWave3 = (LPWORD)calloc(sizeof(WORD), wfe.nChannels * sampling * terms);
lpWave4 = (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;
lpWave1[i] = 0;
lpWave2[i] = 0;
lpWave3[i] = 0;
lpWave4[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;
cycle = frequency;
/* チャンネル1 ********************************/
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);
/* チャンネル2 ********************************/
// クロック
valFrequency = 3200;
valWavelength = sampling / valFrequency;
lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
createWave(lpData, valFrequency, sampling, amplitude);
for (i = start + 1, j = 0, k = 0; i < end; i += 2, ++j, ++k) {
if (k < sampling / cycle / 2) { lpWave1[i] = lpData[j]; }
if (j >= valWavelength) { j = 0; }
if (k >= sampling / cycle) { k = 0; }
}
free(lpData);
// シリアルデータ１
valFrequency = 8000;
valWavelength = sampling / valFrequency;
lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
createWave(lpData, valFrequency, sampling, amplitude);
for (i = 0, j = 0; i < end; i += 2, ++j) {
lpWave2[1 + i] = lpData[j];
if (j >= valWavelength) { j = 0; }
}
free(lpData);
for (i = 0,j = 0, k = 0; i < end- (wfe.nChannels * sampling / cycle * 2); i += 2, ++k) {
if (j < 8) {
lpWave2[start + 1 + i + (wfe.nChannels * sampling / cycle * 2)] = 0;
}
if (k >= sampling / cycle) {
k = 0;
++j;
}
if (j >= 8) { j = 0; }
}
// シリアルデータ２
valFrequency = 11300;
valWavelength = sampling / valFrequency;
lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
createWave(lpData, valFrequency, sampling, amplitude);
for (i = 0, j = 0; i < end; i += 2, ++j) {
lpWave3[1 + i] = lpData[j];
if (j >= valWavelength) { j = 0; }
}
free(lpData);
for (i = 0, j = 0, k = 0; i < end - (wfe.nChannels * sampling / cycle * 2); i += 2, ++k) {
if (j < 3) {
lpWave3[start + 1 + i + (wfe.nChannels * sampling / cycle * 2)] = 0;
}
if (k >= sampling / cycle) {
k = 0;
++j;
}
if (j >= 8) { j = 0; }
}
// リセット
valFrequency = 17000;
valWavelength = sampling / valFrequency;
lpData = (LPWORD)calloc(sizeof(WORD), valWavelength);
createWave(lpData, valFrequency, sampling, amplitude);
for (i = 0, j = 0; i < end; i += 2, ++j) {
lpWave4[start + 1 + i] = lpData[j];
if (j >= valWavelength) { j = 0; }
}
free(lpData);
for (i = 0; i < end; i += 2) {
if (wfe.nChannels * sampling / cycle * 1 < i) {
lpWave4[start + 1 + i] = 0;
}
}
// チャンネル２に合成
for (i = 1, j = 0; i < end; i += 2) {
lpWave[i] = lpWave1[i] + lpWave2[i] + lpWave3[i] + lpWave4[i];
}
// サウンド出力
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;
}
デジタルのようなアナログ信号が綺麗な矩形波に整えられているいることがわかる波形です。
ソフトウェアでPCのサウンド出力にクロック、リセット、データの3チャンネル混合信号を送出しフィルター検波ー波形整形ーシリアルパラレル変換するところまでできるようになりました。
カテゴリー
自作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つのデジタル信号として解釈できるはずです。
741Cを2個１組にして4組のフィルタで分離しそれぞれをまた741Cで増幅後、ダイオードで検波しています。各信号を復調し信号を取り出す仕組みです。
PCからLEDを順に点灯する信号を出してみました。意図通りそれぞれ別の周波数のhighとlowの信号が4つに分離されています。
振幅偏移変調による多重化通信装置の完成です。
クワッド低ノイズ演算増幅回路
ChatGPTに聞いてみた。
User
uPC458Cは何ですか。
ChatGPT
uPC458Cは、オペアンプ（Operational Amplifier）IC（集積回路）の1つです。このICは、高利得、高入力インピーダンス、高CMRR（共通モード抑制比）、低歪みなどの特性を持っており、アナログ回路における信号増幅やフィルタリング、波形整形などに使用されます。
uPC458Cは、デュアルインラインパッケージ（DIP）で提供され、8ピンのパッケージングを採用しています。このICには、2つのオペアンプがあり、それぞれのオペアンプには、非反転入力ピン、反転入力ピン、出力ピン、電源ピンがあります。
uPC458Cは、高速な信号増幅やフィルタリング、低歪みなどの特性を持っており、音響機器、計測機器、通信機器、制御機器などのアプリケーションに広く使用されています。
カテゴリー
アクティブバンドパスフィルタ４
オペアンプ二段増幅型バンドパスフィルタが思いのほか上手く出来たので4個並べてみました。
下部 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チャンネル、フィルタをもっと丁寧に作ればそれ以上も可能と思います。
カテゴリー
相対性理論 運動学の部
文庫本として読んでみましたが理解できませんでした。前半が論文で後半が解説になっており一般の人でも解る構成だそうですが、光速が不変であることぐらいしか読み取ることができませんでした。これで終わってはもったいないので数式を解るところまで勉強してみます。
運動学の部
$$t_B-t_A=t’_A-t_B$$
$$\frac{2\overline{AB}}{t’_A-t_A}=c$$
$$t_B-t_A=\frac{r_{AB}}{c-v’}$$
$$t’_A-t_B=\frac{r_{AB}}{c+v’}$$
$$\frac{1}{2}(\tau_0+\tau_2)=\tau_1$$
$$\frac{1}{2}\left\{\tau(0,0,0,t)+\\\tau\left(0,0,0,t+\frac{l’}{c-v}+\frac{l’}{c+v}\right)\right\}\\=\tau\left(l’,0,0,t+\frac{l’}{c-v}\right).$$
$$\frac{\partial \tau}{\partial x’}+\frac{v}{c^2-v^2}\frac{\partial \tau}{\partial t}=0$$
$$\frac{\partial \tau}{\partial y}=0, \frac{\partial \tau}{\partial z}=0$$
$$\tau=a\left(t-\frac{v}{c^2-v^2}x’\right)$$
$$\xi=c\tau$$
$$\xi=ac\left(t-\frac{v}{c^2-v^2}x’\right)$$
$$\frac{x’}{c-v}=t.$$
$$\xi=a\frac{c^2}{c^2-v^2}x’.$$
$$\eta=c\tau=ac\left(t-\frac{v}{c^2-v^2}x’\right).$$
$$\frac{y}{\sqrt{c^2-v^2}}=t,\space x’=0$$
$$\eta=a\frac{c}{\sqrt{c^2-v^2}}y.$$
$$\xi=a\frac{c}{\sqrt{c^2-v^2}}z.$$
$$x’=x-vt$$
$$\tau=\varphi(v)\beta\left(t-\frac{v}{c^2}x\right),$$
$$\xi=\varphi(v)\beta(x-vt),$$
$$\eta=\varphi(v)y,$$
$$\zeta=\varphi(v)z.$$
$$\beta=\frac{1}{\sqrt{1-(v/c)^2}},$$
$$\varphi(v)=\frac{a(v)}{\sqrt{1-(v/c)^2}}$$
$$x^2+y^2+z^2=c^2 t^2$$
$$\xi^2+\eta^2+\zeta^2=c^2 \tau^2$$
$$t’=\varphi(-v)\cdot\beta(-v)\left(\tau+\frac{v}{c^2}\xi\right)=\\\varphi(v)\cdot\varphi(-v)t,$$
$$x’=\varphi(-v)\cdot\beta(-v)(\xi+vt)=\\ \varphi(v)\cdot\varphi(-v)x,$$
$$y’=\varphi(-v)\eta=\varphi(v)\cdot\varphi(-v)y,$$
$$z’=\varphi(-v)\zeta=\varphi(v)\cdot\varphi(-v)z.$$
$$\varphi(v)\cdot\varphi(-v)=1$$
$$x_1=vt,\space y_1=\frac{l}{\varphi(v)’},\space z_1=0.$$
$$x_2=vt,\space y_2=0,\space z_2=0.$$
$$\frac{l}{\varphi(v)}=\frac{l}{\varphi(-v)},$$
$$\varphi(v)=\varphi(-v)$$
$$\tau=\beta\cdot\left(t-\frac{v}{c^2}x\right),$$
$$\xi=\beta\cdot(x-vt),$$
$$\eta=y,\space \zeta=z.$$
$$\beta=\frac{1}{\sqrt{1-(v/c)^2}}$$
$$\xi^2+\eta^2+\zeta^2=R^2.$$
$$\left\{\frac{x}{\sqrt{1-(v/c)^2}}\right\}^2+y^2+z^2=R^2.$$
$$R\sqrt{1-(v/c)^2},\space R,\space R$$
$$1:\sqrt{1-(v/c)^2}$$
$$\tau=\left. \left(t-\frac{v}{c^2}x\right)\middle/\sqrt{1-\left(\frac{v}{c}\right)^2}.\right.$$
$$x=vt$$
$$\tau=t\sqrt{1-\left(\frac{v}{c}\right)^2}=\\t-\left\{1-\sqrt{1-\left(\frac{v}{c}\right)^2}\right\}t$$
$$\left\{1-\sqrt{1-(v/c)^2}\right\}$$
$$\xi=w_{\xi}\tau,\space \eta=w_{\eta}\tau,\space \zeta=0$$
$$x=\frac{w_{\xi}+v}{1+(vw_{\xi}/c^2)}t,$$
$$y=\frac{\sqrt{1-(v/c)^2}}{1+(vw_{\xi}/c^2)}w_{\eta}t,$$
$$z=0.$$
$$U^2=\left(\frac{dx}{dt}\right)^2+\left(\frac{dy}{dt}\right)^2,$$
$$w^2=(w_{\xi})^2+(w_{\eta})^2,$$
$$\alpha=arctan(w_{\eta}/w_{\xi})$$
$$U=\frac{\sqrt{(v^2+w^2+2vw\space cos\space \alpha)-(vw\space sin\space\alpha/c)^2}}{1+(vw\space cos \space\alpha/c^2)}.$$
$$U=\frac{v+w}{1+(vw/c^2)}.$$
$$U=c\frac{2c-\kappa-\lambda}{2c-\kappa-\lambda+\frac{\kappa\lambda}{c}}<c.$$
$$U=\frac{c+w}{1+(w/c)}=c.$$
$$\frac{v+w}{1+(vw/c^2)}$$
相対性理論の前までは速度は一つの物理量として自由に加減できたのですが、光速が不変とわかったとき、速度に関わる法則を見直さなければならなくなり、それまで不変としてきた時間や空間を可変にすることで法則の維持を図ったのだと思います。それを実証する為に今でも観測や実験が繰り返されているのでしょう。
カテゴリー
アクティブバンドパスフィルタ３
流石にアクティブバンドフィルターは期待通りの性能を出せました。低周波領域でもオペアンプを使えば部品点数も少なく理想的なフィルタが作れそうです。続いて信号の分離性を高めるためQの高いフィルタで実験してみました。
R1=220200Ω
R2=4771Ω
R3=4630Ω
C1=2677pF
IC=UPC741C
Q=46.851
f0=12649.593Hz
このくらいのQであれば信号の分離ができそうです。
部品点数も少なくQが高いバンドフィルタを作ることができました。これであればPCのサウンドライン出力に複数の信号を混合し受け側で分離すればライン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;
}
カテゴリー
アクティブバンドパスフィルタ２
パッシブバンドフィルタが上手くいかなかったのでオペアンプを使用してアクティブバンドフィルタの実験を行いました。
R1=4649Ω
R2=4763Ω
R3=477.8kΩ
C1=287pF
C2=295pF
IC=UPC741C
Q=7.125
f0=16314.28Hz
可聴周波数をスイープして出力しフィルタを通した様子です。フィルタが機能しているのが判ります。しかし、複数の信号を狭い帯域に載せるにはもっとQが高くないと分離が上手くいかないような気がします。
#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;
}