白旗製作所

真空管とトランジスタのハイブリッドアンプ

ネタが無いので、過去ネタをもうちょっと持ってきます。


2年ほど前、タイの友人に、
真空管アンプ作成を回路図付きでオススメされ、
真空管を扱うのは自分でも初めてだったのですが、
せっかくなので作ってみました。

小信号増幅用真空管6922と
ダーリントントランジスタMJ10012の
ハイブリッドアンプです。

電圧増幅を6922で行い、真空管の増幅の特性をもたせます。
電流増幅をMJ10012で行うことで、OPTは省略しています。

電流増幅がA級になり、発熱がえらいことになりますが、ご愛嬌。
6922を差動増幅として使う回路は、
ぺるけ氏の差動ラインプリアンプ回路を参考にしました。
負帰還の前に電流増幅してオーバーオールにしてます。

6922(6DJ8)というと、YAHAアンプなんてのも有名ですが、
あれはまともな動作点で動作させていないもので、
真空管の扱いやすさ以外にあまり利点は無いと感じています。
まあそこが一番重要だったりしますがw
#YAHAアンプは、簡単に言うと、真空管をわざと低い電圧で動作させたあと
オペアンプで出力するヘッドホンアンプの類です。

真空管の電源はDC200Vを超える事が多く、
高電圧を扱うのを怖がる人もいますが、
扱いを気をつければ何とかなると思います。

まあ、電源回路の製作には十分気を払わなければなりませんが。
結構50Hzのノイズが出力に乗ってくるので、
電源のレギュレータや、抵抗とキャパシタによるLPFは必須です。

正直、出来上がったアンプの特性はそれほどよろしいものではありませんが、
真空管は、それを使っているだけで見た目補正がかかるので、
聞けるものにはなったと思っていますw


回路図はこちらから↓
TubeHybrid.png



tubehybrid.png


tubehybrid.jpg


スポンサーサイト
  1. 2012/12/13(木) 22:18:25|
  2. 真空管
  3. | トラックバック:0
  4. | コメント:0

Javaで行列演算

せっかくなので今更ながらブログ作りました。
ぼちぼちなんか書いていきます。

とりあえず、先日作ったJava用の行列計算クラスでも置いておきます。
行列型のようなもので、内部に2次元配列と、入出力メソッド、
積和、転置、逆、行列式等、基本的な行列演算メソッドを備えています。
なぜJavaで作ったのかは謎。

こちらにお世話になりました。
http://blogtool.flatlabs.net/source.html
もうちょっとインデント調整できないかな。


ダウンロードはこちらから。↓
Matrix.java_jpn
Matrix.java_eng



public class Matrix{

//内部で扱われる2次元配列
private double[][] matrix;

//コンストラクタ(行列サイズの初期化)
public Matrix(int rowSize, int columnSize)
{
matrix = new double[rowSize][columnSize];
}

//------------------------------------------------------------------------//
// メッセージ関数 //
//------------------------------------------------------------------------//
//行サイズを取得
public int getRowSize()
{
return matrix.length;
}

//列サイズを取得
public int getColumnSize()
{
return matrix[0].length;
}

//行列のサイズを取得
public int[] getSize()
{
int[] size = {matrix[0].length, matrix.length};
return size;
}

//行列の要素を取得
public double get(int row, int column)
{
return matrix[row][column];
}
//行列の値を設定
public double[][] get()
{
return matrix;
}

//行列の要素に値を設定
public void set(int row, int column, double value)
{
matrix[row][column] = value;
}
//行列の値を設定
public void set(double[][] value)
{
matrix = value;
}

//行列のある行の値を取得
public double[] getRow(int row)
{
return matrix[row];
}

//行列のある行に値を設定
public void setRow(int row, double[] value)
{
matrix[row] = value;
}

//行列のある列の値を取得
public double[] getColumn(int column)
{
return matrix[column];
}

//行列のある列に値を設定
public void setColumn(int column, double[] value)
{
matrix[column] = value;
}

//行列の値を表示
public void print( String name )
{
int i,j,row, column;
row = getRowSize();
column = getColumnSize();

System.out.println( name + "= " ) ;

for( i=0; i<row; i++ ){
System.out.print( " " ) ;
for( j=0; j<column; j++ ){
System.out.print( matrix[i][j] + " " ) ;
}
System.out.println("");
}
}

//------------------------------------------------------------------------//
// 行列の演算関数群 //
//------------------------------------------------------------------------//
//行列の和
public Matrix plus(Matrix target)
{
int i,j,row, column;
row = getRowSize();
column = getColumnSize();
Matrix result = new Matrix(row,column);

for( i=0; i<row; i++ ){
for( j=0; j<column; j++ ){
result.set(i, j, (matrix[i][j]+target.get(i,j)) );
}
}
return result;
}
public Matrix plus(double value)
{
int i,j,row, column;
row = getRowSize();
column = getColumnSize();
Matrix result = new Matrix(row,column);

for( i=0; i<row; i++ ){
for( j=0; j<column; j++ ){
result.set(i, j, (matrix[i][j]+value) );
}
}
return result;
}

//行列の差
public Matrix minus(Matrix target)
{
int i, j, row, column;
row = getRowSize();
column = getColumnSize();
Matrix result = new Matrix(row,column);

for( i=0; i<row; i++ ){
for( j=0; j<column; j++ ){
result.set(i, j, (matrix[i][j]-target.get(i,j)) );
}
}
return result;
}
public Matrix minus(double value)
{
int i, j, row, column;
row = getRowSize();
column = getColumnSize();
Matrix result = new Matrix(row,column);

for( i=0; i<row; i++ ){
for( j=0; j<column; j++ ){
result.set(i, j, (matrix[i][j]-value) );
}
}
return result;
}

//行列の積
public Matrix multiply(Matrix target)
{
int i, j, k, row, column;
double temp;

row = getRowSize();
column = getColumnSize();
Matrix result = new Matrix(row,row);

for( i=0; i<row; i++ ){
for( j=0; j<row; j++ ){
temp = 0;
for ( k=0; k<column; k++ ){
temp += matrix[i][k] * target.get(k,j);
}
result.set(i, j, temp);
}
}
return result;
}
public Matrix multiply(double value)
{
int i, j, row, column;
row = getRowSize();
column = getColumnSize();
Matrix result = new Matrix(row,column);

for( i=0; i<row; i++ ){
for( j=0; j<column; j++ ){
result.set(i, j, (matrix[i][j]*value) );
}
}
return result;
}

//各々の配列要素の積
public Matrix multiplyEach(Matrix target)
{
int i, j, row, column;
row = getRowSize();
column = getColumnSize();
Matrix result = new Matrix(row,column);

for( i=0; i<row; i++ ){
for( j=0; j<column; j++ ){
result.set(i, j, (matrix[i][j]*target.get(i, j)) );
}
}
return result;
}

//割り算
public Matrix division(double value)
{
int i, j, row, column;
row = getRowSize();
column = getColumnSize();
Matrix result = new Matrix(row,column);

for( i=0; i<row; i++ ){
for( j=0; j<column; j++ ){
result.set(i, j, (matrix[i][j]/value) );
}
}
return result;
}

//転置行列
public Matrix transpose()
{
int i, j, row, column;
row = getRowSize();
column = getColumnSize();
Matrix result = new Matrix(row,column);

for( i=0; i<row; i++ ){
for( j=0; j<column; j++ ){
result.set(i, j, matrix[j][i]);
}
}
return result;
}

//行列式
public double determinant()
{
int row, column;
row = getRowSize();
column = getColumnSize();

//正方行列でない
if(row != column){ return 0.0; }
//行列が1*1
else if(row == 1){ return matrix[0][0]; }
//行列が2*2
else if(row == 2){ return (matrix[0][0]*matrix[1][1]-matrix[0][1]*matrix[1][0]); }
//行列が3*3以上
else{
int i;
double det=0;
Matrix cofactorMatrix = new Matrix(row-1,column-1);

for( i=0; i<row; i++ ){
cofactorMatrix = spritMatrix(i,0);
if( i%2 == 0) det += matrix[i][0]*cofactorMatrix.determinant();
else det -= matrix[i][0]*cofactorMatrix.determinant();
}
return det;
}
}

//逆行列
public Matrix inverse()
{
int i, j, row, column;
row = getRowSize();
column = getColumnSize();
Matrix result = new Matrix(row,column);

for( i=0; i<row; i++ ){
for( j=0; j<column; j++ ){
if( (i+j)%2 == 0) result.set(i, j, spritMatrix(i,j).determinant() );
else result.set(i, j, (-1)*spritMatrix(i,j).determinant() );
}
}
return result.transpose().division(determinant());
}

//行列の要素を指定すると、その行・列を排除した行列を返す
private Matrix spritMatrix(int row, int column)
{
int i, j, m=0, n=0;
int rowSize = getRowSize();
int columnSize = getColumnSize();
Matrix result = new Matrix(rowSize-1,columnSize-1);

m=0;
for( i=0; i<rowSize; i++ ){
if(i!=row){
n=0;
for( j=0; j<columnSize; j++ ){
if(j!=column){
result.set(m, n, matrix[i][j]);
n++;
}
}
m++;
}
}
return result;
}
}
//file end.-------------------------------------------------------------------//

  1. 2012/12/10(月) 23:31:40|
  2. Java
  3. | トラックバック:0
  4. | コメント:0