所感

思ったよりも反応が良くて使いやすいです。

UIを日本語設定にすることができますが、この手の中華製品にありがちなひどい明朝フォントになったりはせず、普通に使えるレベルだと思います。とはいえ英語設定で使ってますが…

他に買ったものや欲しいもの

10dB アッテネータはマトモなやつを1つ買いました。追加でいくつか安いアッテネータを注文しています。

この本は買う前に読んでいました。アマゾンではなく、CQ出版社のサイトから PDF を買ってます。

あとはリターンロスブリッジ (VSWR ブリッジ) が欲しいので作るかどうするか、という感じです。

方向性結合器は自分の欲しい周波数帯・耐電力のものは全く売っていないので作るしかありません。一度作っていますが、もっといいのを作りたいところです。

とはいえ50MHzまでならアンテナアナライザーもあるので、そこまで必要でもないかなという気がします。

LAN 経由でスクリーンショットをとる

まず測定画面のスクリーンショット(ハードコピー)ができないとかなり不便なので、ここから解決しました。

:PRIV:SNAP?

ref.

• http://cp.literature.agilent.com/litweb/pdf/5989-6717JAJP.pdf Linux を使用した LXI 測定器の 制御：VXI-11 の使用
• http://cp.literature.agilent.com/litweb/pdf/5989-6717JAJP.pdf Linux を使用した LXI 測定器の制御：TCP の使用

概要

大地経由での電流がコモンモード電流なので、フィルタのホットとコールドをショートして、TG のホットをフィルタを通してスペアナの入力にし、TG とスペアナのコールド側をショートさせれば計れそうです。要は単にRFチョークとして測定します。

なおコモンモードフィルタはだいたい-30dB ぐらいあれば十分な性能といえるらしいです。

測定方法

まずワニグチクリップをトラッキングジェネレータとスペアナ入力に直付けし、ホットコールドをそれぞれショートさせます。

この状態でTGの出力レベルを0dBmに設定し、ノーマライズします。(なおビビリなので外付けのアッテネータは入れてませんが内蔵アッテネータは10dB入れたままです) それなりに出力がないとノイズに測定結果が隠れてしまうので気をつけます。

ノーマライズされた状態でホット側をはずしてアイソレーションを確認します。-30dB 以上なければ測定の意味がないので、アイソレーションがとれてなさそうなら諦めてスパンを狭くして再度ノーマライズからやりなおします (意味がない結果が見えていると混乱するため)。

TG 側にワニグチクリップをつけたりして配線長を増やすと50MHz〜は容易にアイソレーションがとれなくなるので注意します。以下はオープンの状態のアイソレーションです。

この状態でフィルタに接続して測ります。フィルタの入力側(TG側)の線長が長いとこれまたアイソレーションがとれないので誤差の原因になりますが、排除するのが難しいです。シールドケースに入れて測るしかない気がしますが、今回は用意できてないので多少飛びこみがあります。

結果

今回計ったのはキットものの http://www.ddd-daishin.sakura.ne.jp/ddd/dcf/dcf-rf-29l3/kit-dcf-rf-29l3-ver2.htm これです。スペック的には 50MHz ぐらいまでは -30dB 余裕でとれるみたいなグラフがあります。

一応このように雑に測った感じでも 50MHz ぐらいまでは -30dB ぐらいになっているように見えます。(0〜100MHzのスパンなので真ん中が50MHzです)。とはいえ -40dB までとれている範囲はそれほどないです。

メモ：挿入インピーダンスとdB

入出力インピーダンス50Ωとして、例えばインピーダンスZを直列挿入した場合、入力側にかかる電圧は出力電圧を、挿入インピーダンス と入力インピーダンスで分圧した形になる。

なので、入力電圧は になる。dB で表わすと

これまでの漠然とした C++ への不安

#include <stdio.h>

typedef struct {
	unsigned counter;
} my_counter;

void my_counter_init(my_counter* this) {
	this->counter = 0;
}

void my_counter_incr(my_counter* this) {
	this->counter++;
}

unsigned my_counter_get_count(my_counter* this) {
	return this->counter;
}

int main() {
	my_counter counter;
	my_counter_init(&counter);

	printf("%d\n", my_counter_get_count(&counter));
	my_counter_incr(&counter);

	printf("%d\n", my_counter_get_count(&counter));
}

#include <cstdio>

class my_counter {
	unsigned counter;
public:
	my_counter(); // void init();
	void incr();
	unsigned get_count();
};

my_counter::my_counter() {
	this->counter = 0;
}

void my_counter::incr() {
	this->counter++;
}

unsigned my_counter::get_count() {
	return this->counter;
}

int main() {
	my_counter counter;

	printf("%d\n", counter.get_count());
	counter.incr();

	printf("%d\n", counter.get_count());
}

現時点での解決方法

ファームウェアの 1.15 が1月22日にリリースされており、これにある程度の修正が含まれています。

最新のファームウェアは http://int.rigol.com/Support/SoftDownload/3 からダウンロードできます。

Product Series → Spectrum Analyzer → DSA815 Firmware_00.01.15.01.00 というのをダウンロードします。DSA815(DSP)update.rar というやつです。

DSA815update.sys を USB メモリのルートディレクトリにコピーして、DSA815 のフロントUSBポートに接続し、Storage の画面でこのファイルを選択したあと、Sys Update を選択すると、アップデートが開始されます。数分で終わり、再起動すると最新のファームウェアで起動します。

↑ 使ったUSBメモリです。自宅にUSBメモリがなく、SDカードリーダーとSDカードで代用しようと思いましたが、DSA815 では認識されませんでした。純粋な USB メモリじゃないとダメなようです。ググってみると、メーカー的にはできるだけ容量が少ないほうが信頼性が高いということになっているみたいです。とはいえ現時点で新品はもはら8GB未満は売ってません。これは USB 3.0 メモリですが、DSA815 は USB 3.0 に対応してないので、古くてもなんでもいいはずです (信頼性は別として)。

解決したか?

見ての通りです。直結の場合では不連続部分はわかりません。一方バンドパスフィルタで見たときはすこし不連続な部分が残っているようにみえます。

ということで、完全には解決しません。挙動的にはまるめ誤差みたいなのが発生しているような感じますが実装がどうなっているかはわかりません。

とはいえ、このように修正が入るので、現状の状態は Rigol のエンジニアは把握しており、直すつもりはあるようです。ファームウェアアップデートだけですめばいいんですが……

ファームウェアアップデートと保証

DSA815-TG には3年保証がついているのですが、ファームウェアアップデート時にどのような扱いになるか不安になりました。(そもそも国内販売版のものが国際版と完全に同一であるかの確証もない)

国内のリゴルジャパンへメールで確認をとったところ、すぐに返信していただけました。

• 国内販売のものでもファームウェアは共通
• ファームウェアアップグレードしても保証期間内では無償サポート

とのことで、アップグレードしても大丈夫そうです。

1.15 での他に気になった挙動

購入直後スクリーンショットをLAN経由でとれるようにしましたが 1.15 になって、TCPソケット経由でのコマンド解釈がすこし厳密になって動かなくなったので直しました。

あと、スクリーンショットをとるコマンドは最後にリモートモードを解除するコードを入れていたのですが、動かなくなりました。リモートからコマンドを実行すると必ずリモートモードになってしまって若干鬱陶しいのでなんとかしたいのですが、こちらの原因はよくわかってません。

また、デフォルトで mDNS での DNS-SD の機能が無効になってみたいです。HTTP 経由でアクセスして設定しないと DNS-SD のクエリに応答しません。

備考

元のバージョンは00.01.12 でした。

アップグレード後は 00.01.15 です。

MQ-135

空気の汚染度に感度があるセンサーで、ベンジン・アルコール・煙などに反応しやすいと書いてあります。CO2 にもある程度反応するみたいで、ググると poor man's CO2 センサーとしても一定の人気があるみたいです。

自分としては、換気扇ごしに外からタバコの煙が自宅に入ってくることがあってほとほと不愉快なので、どんな時間帯にそういう状況になるかをつきとめたいというモチベーションがありますが、そういう用途に使えるかはわかりません。というかテストのためにタバコを買うのも絶対に嫌なのでテスト不可能です。

仕様

MQ-135 自体がデータシートでプリヒートを24時間以上求めています。常時起動してないとダメですね。とはいえ1時間ぐらいで値はほぼ安定しているようには見えます。

MQ-135のデータシート的には10kΩ〜47kΩの負荷抵抗を想定しているみたいですが、このモジュールは 102 (1kΩ) の抵抗が負荷抵抗になっているように見えますので、普通に使うより感度が低くなりそうです。

ググると頑張って ppm 単位の絶対値出力を出そうという試みがあるのですが、素人がキャリブレーションしようがない (他の正確な絶対値センサーが必要) ので、基本的には相対的な値を範囲を一定期間モニタリングしたうえで値を把握して使うほかない気がします。

実測出力

• 200mV / 数時間通電後の無人の部屋
• 700mV / アルコールティッシュを近付けたとき
• 800mV / サカムケアを近付けたとき (イソプロパノールなど)
• 1660mV / プラモデル用接着剤を近付けたとき (アセトンなど)

意外と反応が良くて、臭いがあるとすぐ変化が出力されます。

コード

ライブラリみたいにしてあるのもありましたが、結局自分で書きました。

入手したモジュールは125MHzが源クロックでした。

#include <Arduino.h>
#include <Wire.h>

template <uint32_t CLKIN>
class AD9850 {
	static constexpr double PHASE_FACTOR = 0x100000000 / (double)CLKIN;

	const uint16_t PIN_DATA;
	const uint16_t PIN_FQ_UD;
	const uint16_t PIN_W_CLK;
	const uint16_t PIN_RESET;

	void serial_write(uint32_t freq, uint8_t phase, bool powerdown) {
		// freq (delta phase)
		for (int i = 0; i < 32; i++) {
			digitalWrite(PIN_DATA, (freq>>i) & 1);
			digitalWrite(PIN_W_CLK, HIGH); delayMicroseconds(4);
			digitalWrite(PIN_W_CLK, LOW); delayMicroseconds(4);
		}

		// control bits
		digitalWrite(PIN_DATA, LOW);
		digitalWrite(PIN_W_CLK, HIGH); delayMicroseconds(4);
		digitalWrite(PIN_W_CLK, LOW); delayMicroseconds(4);
		digitalWrite(PIN_W_CLK, HIGH); delayMicroseconds(4);
		digitalWrite(PIN_W_CLK, LOW); delayMicroseconds(4);

		// powerdown
		digitalWrite(PIN_DATA, powerdown ? HIGH : LOW);
		digitalWrite(PIN_W_CLK, HIGH); delayMicroseconds(4);
		digitalWrite(PIN_W_CLK, LOW); delayMicroseconds(4);

		// phase
		for (int i = 0; i < 5; i++) {
			digitalWrite(PIN_DATA, (phase>>i) & 1);
			digitalWrite(PIN_W_CLK, HIGH); delayMicroseconds(4);
			digitalWrite(PIN_W_CLK, LOW); delayMicroseconds(4);
		}

		digitalWrite(PIN_FQ_UD, HIGH); delayMicroseconds(4);
		digitalWrite(PIN_FQ_UD, LOW); delayMicroseconds(4);
	}

public:
	AD9850(
			uint16_t data,
			uint16_t fq_ud,
			uint16_t w_clk,
			uint16_t reset
		) :
			PIN_DATA(data),
			PIN_FQ_UD(fq_ud),
			PIN_W_CLK(w_clk),
			PIN_RESET(reset)
	{
		pinMode(PIN_DATA, OUTPUT);
		pinMode(PIN_FQ_UD, OUTPUT);
		pinMode(PIN_W_CLK, OUTPUT);
		pinMode(PIN_RESET, OUTPUT);
	}
	
	/**
	 * W0 ... W31  -> Freq (LSB first)
	 * W32, W33    -> Control (for factory test)
	 * W34         -> Power-Down
	 * W35 ... W39 -> Phase (LSB first)
	 */

	void reset() {
		// ensure low
		digitalWrite(PIN_DATA, LOW);
		digitalWrite(PIN_FQ_UD, LOW);
		digitalWrite(PIN_W_CLK, LOW);

		// reset
		digitalWrite(PIN_RESET, HIGH); delay(1);
		digitalWrite(PIN_RESET, LOW); delay(1);

		// reset to serial mode
		// Pins of D0, D1 = HIGH, D2 = LOW for serial mode
		digitalWrite(PIN_W_CLK, HIGH); delayMicroseconds(4);
		digitalWrite(PIN_W_CLK, LOW); delayMicroseconds(4);

		digitalWrite(PIN_FQ_UD, HIGH); delayMicroseconds(4);
		digitalWrite(PIN_FQ_UD, LOW); delayMicroseconds(4);
	}

	void set_frequency(uint32_t frequency) {
		set_frequency(frequency, 0);
	}

	void set_frequency(uint32_t frequency, uint8_t phase) {
		uint32_t deltaPhase = PHASE_FACTOR * frequency;
		serial_write(deltaPhase, phase, 0);
	}

	void powerdown() {
		serial_write(0, 0, 1);
	}
};

AD9850<125000000> ad9850(9, 10, 11, 12);

void setup() {
	Serial.begin(9600);

	ad9850.reset();
	ad9850.set_frequency(10e6);
}

void loop() {
}

出力

商品説明だと40MHz まで出せると書いてありました。たしかに出せることは出せるようです。

このモジュールの出力には7次のローパスフィルタがついています。これはAD9851のデータシート通りの定数のフィルタのようで、70MHzぐらいにカットオフ周波数ががあるみたいです。

なおローパスフィルタの後の出力インピーダンスは200Ωになっているみたいです。

AD9850自体の出力は電流出力で、12ピンについている抵抗でフルスケールの出力電流が決まることになっています。このモジュールでは3.9kΩが実装されており、10mA フルスケールの出力に設定されています。200Ωで10mW(10dBm)。実際使う場合バッファして50Ω出力とする必要はありそうです。

片方だけにローパスフィルタが入っており、もう片方の出力は200Ωで電圧変換されて直接ピンヘッダに出ています。ということで差動出力には使えません。

コード

#include <Arduino.h>
#include <Wire.h>

template <uint32_t CLKIN, bool MULTIPLIER>
class AD9851 {
	static constexpr double PHASE_FACTOR = 0x100000000 / (double)(CLKIN * (MULTIPLIER ? 6 : 1));

	const uint16_t PIN_DATA;
	const uint16_t PIN_FQ_UD;
	const uint16_t PIN_W_CLK;
	const uint16_t PIN_RESET;

	void serial_write(uint32_t freq, uint8_t phase, bool powerdown) {
		// freq (delta phase)
		for (int i = 0; i < 32; i++) {
			digitalWrite(PIN_DATA, (freq>>i) & 1);
			digitalWrite(PIN_W_CLK, HIGH); delayMicroseconds(4);
			digitalWrite(PIN_W_CLK, LOW); delayMicroseconds(4);
		}

		// control bits
		digitalWrite(PIN_DATA, MULTIPLIER ? HIGH : LOW);
		digitalWrite(PIN_W_CLK, HIGH); delayMicroseconds(4);
		digitalWrite(PIN_W_CLK, LOW); delayMicroseconds(4);
		digitalWrite(PIN_DATA, LOW);
		digitalWrite(PIN_W_CLK, HIGH); delayMicroseconds(4);
		digitalWrite(PIN_W_CLK, LOW); delayMicroseconds(4);

		// powerdown
		digitalWrite(PIN_DATA, powerdown ? HIGH : LOW);
		digitalWrite(PIN_W_CLK, HIGH); delayMicroseconds(4);
		digitalWrite(PIN_W_CLK, LOW); delayMicroseconds(4);

		// phase
		for (int i = 0; i < 5; i++) {
			digitalWrite(PIN_DATA, (phase>>i) & 1);
			digitalWrite(PIN_W_CLK, HIGH); delayMicroseconds(4);
			digitalWrite(PIN_W_CLK, LOW); delayMicroseconds(4);
		}

		digitalWrite(PIN_FQ_UD, HIGH); delayMicroseconds(4);
		digitalWrite(PIN_FQ_UD, LOW); delayMicroseconds(4);
	}

public:
	AD9851(
			uint16_t data,
			uint16_t fq_ud,
			uint16_t w_clk,
			uint16_t reset
		) :
			PIN_DATA(data),
			PIN_FQ_UD(fq_ud),
			PIN_W_CLK(w_clk),
			PIN_RESET(reset)
	{
		pinMode(PIN_DATA, OUTPUT);
		pinMode(PIN_FQ_UD, OUTPUT);
		pinMode(PIN_W_CLK, OUTPUT);
		pinMode(PIN_RESET, OUTPUT);
	}
	
	/**
	 * W0 ... W31  -> Freq (LSB first)
	 * W32, W33    -> Control (for factory test)
	 * W34         -> Power-Down
	 * W35 ... W39 -> Phase (LSB first)
	 */

	void reset() {
		// ensure low
		digitalWrite(PIN_DATA, LOW);
		digitalWrite(PIN_FQ_UD, LOW);
		digitalWrite(PIN_W_CLK, LOW);

		// reset
		digitalWrite(PIN_RESET, HIGH); delay(1);
		digitalWrite(PIN_RESET, LOW); delay(1);

		// reset to serial mode
		// Pins of D0, D1 = HIGH, D2 = LOW for serial mode
		digitalWrite(PIN_W_CLK, HIGH); delayMicroseconds(4);
		digitalWrite(PIN_W_CLK, LOW); delayMicroseconds(4);

		digitalWrite(PIN_FQ_UD, HIGH); delayMicroseconds(4);
		digitalWrite(PIN_FQ_UD, LOW); delayMicroseconds(4);
	}

	void set_frequency(uint32_t frequency) {
		set_frequency(frequency, 0);
	}

	void set_frequency(uint32_t frequency, uint8_t phase) {
		uint32_t deltaPhase = PHASE_FACTOR * frequency;
		serial_write(deltaPhase, phase, 0);
	}

	void powerdown() {
		serial_write(0, 0, 1);
	}
};

AD9851<30000000, true> ad9851(9, 10, 11, 12);

void setup() {
	Serial.begin(9600);

	ad9851.reset();
	ad9851.set_frequency(10e6);
}

void loop() {
}

AD9851 とほぼ同じですが、6倍の周波数逓倍器がの有効無効化のビットがあるので、その部分だけ実装を変えてあります。

出力

購入したモジュールは 30MHz の源発振のものなので、逓倍後は 180MHz になります。

40MHz ぐらいから出力が低くなります。

GPS Fix に時間がかかる

窓際で受信させてみましたが、いつまで経っても GPS Fix しません。u-center でしばらく眺めていると1時間〜2時間ぐらいでようやく GPS Fix しました。

スマフォ内蔵のGPSだと窓際でもすぐGPS Fixできるので、ちょっと残念なところです。

1度3D Fixまでいけば、割と安定して受信が継続されました。

NEO-6M は GPS(アメリカ)のみに対応していて、GLONASS (ロシア)やQZSS(日本)は対応していないので、そのせいかもしれません。

1PPS

自宅でGPS使って位置を知れてもあんまり意味がありません。このGPS モジュールの最大の目的は1PPSです。

1PPS (Pulse Per Second) 出力はLED が接続されており、GPS Fix 時には1秒ごとにLEDがフラッシュします。

この1PPSはGPS衛星に搭載されている原子時計と同期しているので、とても正確です。ただし、GPSモジュール内蔵クロックが48MHzなので最大42nsぐらいのジッタはありそうです。そこそこに長い目で見ると原子時計並に正確な1Hzが得られるというものです。

• For best timepulse performance it is recommended to disable the SBAS subsystem. 

2016-02-16 15:28:5.000Z VALID:YES / 3D Fix [1: 31dB*] [3: 21dB*] [7: 26dB*] [8: 0dB] [10: 0dB] [11: 15dB*] [16: 15dB*] [17: 0dB] [22: 0dB] [27: 0dB] [28: 19dB*] [30: 0dB*]

#!ruby -v
require 'serialport'

@port = SerialPort.new(
	"/dev/tty.usbserial-A50285BI",
	9600,
	8,
	1,
	0
)

cols = `tput cols`.to_i

status = {
	using: [],
	sates: {}
}

loop do
	while line = @port.gets
		type, *rest = line.chomp.split(/,/)
		next unless type[0] == '$'
		_ = rest.pop
		case type
		when "$GPRMC"
			h, m, s = *rest[0].match(/(..)(..)(.+)/).captures.map {|i| i.to_f }
			dd, mm, yy = *rest[8].match(/(..)(..)(..)/).captures.map {|i| i.to_i }
			datetime = "%04d-%02d-%02d %02d:%02d:%02.3fZ" % [yy + 2000, mm, dd, h, m, s]
			state = rest[1]
			status[:UTC] = datetime
			status[:is_valid] = state == "A"
		when "$GPGGA"
			sate_count = rest[6]
			status[:sate_count] = sate_count
		when "$GPGSA"
			mode = rest[0]
			type = rest[1] # 1 = invalid, 2 = 2d, 3 = 3d
			sate_nums = rest[2, 12]
			status[:mode] = mode
			status[:type] = type
			status[:using] = sate_nums.map {|i| i.to_i }
		when "$GPGSV"
			total = rest.shift
			current = rest.shift
			if current == 1
				status[:sates] = {}
			end
			_ = rest.shift # count
			until rest.empty?
				num = rest.shift
				e = rest.shift
				d = rest.shift
				sn = rest.shift
				status[:sates][num] = {
					num: num.to_i,
					e: e,
					d: d,
					sn: sn.to_i,
				}
			end
			if total == current
				# done
			end
		else
			# ignore
		end
		out = "%s VALID:%s / %s Fix %s" % [
			status[:UTC],
			status[:is_valid] ? "YES" : "NO",
			status[:type] == "1" ? "NO" : "#{status[:type]}D",
			status[:sates].values.sort_by {|i| i[:num] }.map {|i|
				"[%s: %ddB%s]" % [
					i[:num],
					i[:sn],
					status[:using].find_index(i[:num]) ? "*" : ""
				]
			}.join(" ")
		]
		print "%- #{cols-1}s\r" % out
		$stdout.flush
	end
end

platformio での開発

platformio.ini を以下にようにして

[env:lpc]
platform = nxplpc
framework = mbed
board = lpc1114fn28
build_flags = -std=c++1y

main.cpp を以下にようにしました。

#include "mbed.h"

DigitalOut led(LED1);

int main() {
	while(1) {
		led = 1;
		wait(0.5);
		led = 0;
		wait(0.5);
	}
	return 0;
}

この状態で platformio run をすると .pioenvs/lpc/firmware.bin にコンパイル済みバイナリができます。

platformio は mbed の開発環境を前提としているようで、upload では単に upload_port 先のディレクトリにコピーをしようとします。今回はシリアル経由で書きこむので、platformio 経由での upload は使いませんでした。

ピンアサイン

https://developer.mbed.org/platforms/LPC1114FN28/ このページを見るのが一番良いようです。

上記コード中で指定している LED1 は左下の dp14 になります。

書きこみ

書きこみツールは lpc21isp を使うのが一番簡単なようです。展開して make するだけで OS X でも普通に動きました。

https://sourceforge.net/projects/lpc21isp/files/lpc21isp/ からダウンロードできます。

以下にような感じで書きこめました。115200 は書きこみ時のボーレート、12000 はMCUの動作周波数をkHz単位で指定するようです。内蔵RCは12MHzなので12Mhzを指定しています。が、mbed 実行時は逓倍して48MHzで動いているようなので、どっちを指定するのかよくわかりません。

lpc21isp -control -bin .pioenvs/lpc/firmware.bin /dev/tty.usbserial-A50285BI 115200 12000

ここでは -control を指定しています

         -control     for controlling RS232 lines for easier booting
                      (Reset = DTR, EnableBootLoader = RTS)

となっており、この通りにシリアル変換の DTR を nR (RESET) 、RTS を dp24 に接続することで、自動リセットしてISPモードへ移行して書きこめます。冒頭の写真の通りの配線です。

追記：シリアル通信を行う

上記の方法だと、普通にシリアル通信を行おうとするとRTS/DTRまわりの挙動によってリセットが発生してISPモードに入ってしまうことがあります。なので普通に screen などでシリアル出力を見ることができません。これは RESET の配線を切れば問題ないのですが面倒くさいところです。

実はこれもlpc21ispを使って以下にようにすると、配線を変えずにシリアルモニタができるようです。

lpc21isp -termonly -control /dev/tty.usbserial-A50285BI 115200 12000

コード例

#include "mbed.h"

Serial serial(USBTX, USBRX);
DigitalOut led(LED1);

int main() {
	serial.baud(115200);

	while(1) {
		serial.printf("Hello, World!\n");
		led = 1;
		wait(0.5);
		led = 0;
		wait(0.5);
	}
	return 0;
}

ref.

• https://developer.mbed.org/platforms/LPC1114FN28/
• http://qiita.com/erukiti/items/7815134e2dab6183d4c8
• http://morecatlab.akiba.coocan.jp/lab/index.php/2014/01/lpc21isp-lpc1114/

コード

Arduino のコードとほぼ一緒です。というか殆ど正規表現で置換しただけで動かすことができました。GPIO の操作だけなので本当に頭を一切使わずに移植できました。

GCC かつ -std=c++14 な環境なため mbed のオンラインコンパイラではコンパイルできないと思います (すこし修正すればいけるはずですが C++14 が使えない環境に興味がないので……)

また、なんとなくシリアル経由で周波数を変えるインターフェイスにしてみました。mbed のライブラリに CircularBuffer があるので簡単です。C++ の STL に circular buffer / ring buffer 相当のものがないのが不思議なんですが、いつか入る予定はあるんでしょうかね？

#include "mbed.h"
#include <CircularBuffer.h>
#include <cstdlib>
#include <string>

template <uint32_t CLKIN, bool MULTIPLIER>
class AD9851 {
	static constexpr double PHASE_FACTOR = 0x100000000 / (double)(CLKIN * (MULTIPLIER ? 6 : 1));

	DigitalOut PIN_DATA;
	DigitalOut PIN_FQ_UD;
	DigitalOut PIN_W_CLK;
	DigitalOut PIN_RESET;

	void serial_write(uint32_t freq, uint8_t phase, bool powerdown) {
		// freq (delta phase)
		for (int i = 0; i < 32; i++) {
			PIN_DATA = (freq>>i & 1);
			PIN_W_CLK = 1; wait_us(4);
			PIN_W_CLK = 0; wait_us(4);
		}

		// control bits
		PIN_DATA = MULTIPLIER ? 1 : 0;
		PIN_W_CLK = 1; wait_us(4);
		PIN_W_CLK = 0; wait_us(4);
		PIN_DATA = 0;
		PIN_W_CLK = 1; wait_us(4);
		PIN_W_CLK = 0; wait_us(4);

		// powerdown
		PIN_DATA = powerdown ? 1 : 0;
		PIN_W_CLK = 1; wait_us(4);
		PIN_W_CLK = 0; wait_us(4);

		// phase
		for (int i = 0; i < 5; i++) {
			PIN_DATA = (phase>>i & 1);
			PIN_W_CLK = 1; wait_us(4);
			PIN_W_CLK = 0; wait_us(4);
		}

		PIN_FQ_UD = 1; wait_us(4);
		PIN_FQ_UD = 0; wait_us(4);
	}

public:
	AD9851(
			PinName data,
			PinName fq_ud,
			PinName w_clk,
			PinName reset
		) :
			PIN_DATA(DigitalOut(data)),
			PIN_FQ_UD(DigitalOut(fq_ud)),
			PIN_W_CLK(DigitalOut(w_clk)),
			PIN_RESET(DigitalOut(reset))
	{
		PIN_DATA = 0;
		PIN_FQ_UD = 0;
		PIN_W_CLK = 0;
		PIN_RESET = 0;
	}

	/**
	 * W0 ... W31  -> Freq (LSB first)
	 * W32, W33    -> Control (for factory test)
	 * W34         -> Power-Down
	 * W35 ... W39 -> Phase (LSB first)
	 */

	void reset() {
		// ensure low
		PIN_DATA = 0;
		PIN_FQ_UD = 0;
		PIN_W_CLK = 0;

		// reset
		PIN_RESET = 1; wait(1);
		PIN_RESET = 0; wait(1);

		// reset to serial mode
		// Pins of D0, D1 = 1, D2 = 0 for serial mode
		PIN_W_CLK = 1; wait_us(4);
		PIN_W_CLK = 0; wait_us(4);

		PIN_FQ_UD = 1; wait_us(4);
		PIN_FQ_UD = 0; wait_us(4);
	}

	void set_frequency(uint32_t frequency) {
		set_frequency(frequency, 0);
	}

	void set_frequency(uint32_t frequency, uint8_t phase) {
		uint32_t deltaPhase = PHASE_FACTOR * frequency;
		serial_write(deltaPhase, phase, 0);
	}

	void powerdown() {
		serial_write(0, 0, 1);
	}
};

AD9851<30000000, true> ad9851(/*data*/dp28, /*fq_ud*/dp26, /*w_clk*/dp25, /*reset*/dp1);

//AnalogIn adc1(dp9);
//AnalogIn adc2(dp10);
//AnalogIn adc3(dp11);
//AnalogIn adc4(dp13);

Serial serial(USBTX, USBRX);

CircularBuffer<char, 80> serial_buffer;

int main() {
	serial.baud(115200);
	serial.printf("init\n");

	ad9851.reset();
	ad9851.set_frequency(10e6);

	for (;;) {
		if (serial.readable()) {
			char c = serial.getc();
			if (c == 0x0D) continue; // ignore CR
			if (c == 0x0A) { // treat LF as line end
				std::string line(80, '\0');
				line.clear();

				char c;
				while (serial_buffer.pop(c)) {
					line += c;
				}
				serial_buffer.reset();

				serial.printf("GOT: %s\n", line.c_str());

				uint32_t new_freq = std::atoi(line.c_str()) * 1e6;
				ad9851.set_frequency(new_freq);
				continue;
			}

			serial_buffer.push(c);
		}
	}
	return 0;
}

メモ: mbed 移植正規表現

S/digitalWrite\(([^,]+), ([^)]+)\)/\1 = \2/
s/delayMicroseconds/wait_us/g
s/delay/wait/g

ghq で全部落としとくぞ

Mercurial (hg) のレポジトリとして公開されている。

 ghq get https://cho45@developer.mbed.org/users/mbed_official/code/mbed-src/
 ghq get https://cho45@developer.mbed.org/users/mbed_official/code/mbed/ 

してmbed 関係のヘッダと実装を手元に置いておく

mbed LPC1114

メインのレポジトリはこっちなのですが、ヘッダファイルだけ
https://developer.mbed.org/users/mbed_official/code/mbed/file/252557024ec3/TARGET_LPC1114/TARGET_NXP/TARGET_LPC11XX_11CXX/TARGET_LPC11XX

実装は mbed-src にあった。
https://developer.mbed.org/users/mbed_official/code/mbed-src/file/a11c0372f0ba/targets/cmsis/TARGET_NXP/TARGET_LPC11XX_11CXX/TARGET_LPC11XX/system_LPC11xx.c

AD8307

AD8307を使ってログアンプ検波するバージョンの SWR 計の例があることは知っていましたが、前回はそこまですることはないと思ってとりあえず簡単な方法で作りました。

というのもログアンプは大変高価だからです。秋月でAD8307のDIP版が売っていますが、単価が1100円します。なお DigiKey で買うともっと高価なので、秋月は安いほうです。

(最近知りましたが中華性AD8307というセカンドソース品、というよりコピー品があり、こちらは単価が50円!!と激安のようです。SOICで、ebay で手に入ります)

方向性結合器 + 検波 + ADC

例の回路をほぼ完全にパクって実装しました。

方向性結合器は、タンデムマッチで、FT82-43 を使い、20T にしてみました (26.02dB のカップラに)。線間容量を減らして、高い周波数での特性が改善しないか?と思い巻数を減らしています。#43 は透磁率が高いので、多少巻数を減らしてもインピーダンスは高いままですが、ロスは多くなるはずです。

検波部は結合器からの出力をアッテネータ(16.1dB)を通し、インピーダンス変換を行なって AD8307 に入力しています。AD8307 のオフセットや切片調整はしていないので、25mV/dB の出力にはるはずです。

方向性結合器で 26.02dB、アッテネータで16.1dBなので、AD8307 には 42.12dB 減衰された信号が入力されます。言いかえると、AD8307の入力範囲は -72〜+16dBm ですから、-29.88〜+58.12dBm の入力範囲 (約1μW〜648W) にシフトしたことになります。

ADC は ADS1015 という 4ch + PGA 付き I2C デバイスにしてみました。ここは入手性の問題からオリジナルと違います。

実装

最初は方向性結合器の部分も基板を起こしていましたが、どうも作りにくいので立体配線に変えました。2つのトロイダルコアの間に容量結合防止のためのGNDを立てたいわけですが、プリント基板だとかえって面倒でした。

そんなこともあろうかと、基板を作る段階で途中で切って使えるような感じにしておいたので良かったです。

検証

作ったはいいのですが、どうもうまくいかず悩みました。

一つはコイルを逆付けしていてまともに方向性結合器として動いていなかったのが原因でした。

もう一つはAD8307の出力の問題で、どうしても入力電力から計算される出力電圧が出ず、未だ完全に理由がわかっていません。

方向性結合器

SWR はこんな感じでした

SWR だとよくわからないので、リターンロスでみるとこんな感じです

肝心のディレクティビティなどの特性です。蓋をあけた状態で電圧をオシロで計って50Ω換算で出しています。残念ながら前回作ったものよりも良くありません。

ログアンプの効果

ダイオード検波の場合、微小電力ではダイオードの Vf を超えることができず、それはそのまま誤差になります。

ログアンプ検波することで、ダイオード検波の欠点はなくなり、微小電力から計れるようになりました。具体的には、スペアナのトラッキングジェネレータ出力を 0dBm にして計っても、多少の誤差はありますがちゃんと 1mW ぐらいの値が出てきます。

通常送信機の電力測定ではこんな微小電力まで計れる必要は特にないかと思いますが、SWR 計として反射電力を計りたい場合、SWR が低いときには反射電力も非常に小さくなりますから、ダイナミックレンジの広い測定が必要になります。ダイオード検波と通常のリニアなADCを使うことに対する最大のメリットはここだと思います。

方向性結合器部分はまだ追試が必要

SWR計としてまとめるのではなく、方向性結合器として一旦作って評価をしてから、検波回路を外付けするほうが安定したものが作れそうです。次はそのようにしたいと思います。

制御

インターフェイスはまともに作っていなくて、Arduino で I2C から値を呼んで計算させてシリアルに出力だけさせてテストしていました。今のところまだ実用にはなっていません。

結果

solve([2188 * a + b = 2109, 1050 * a + b = 959], [a, b]);

仕様変更

30ターンにしたので、カップリングは -29.54dB になっています。アッテネータとあわせて 45.64dB の減衰。-26.36〜61.64dBm (2μW〜1458W)

感想

センサー部分としては十分上出来になったと思います。すくなくとも前回作ったときよりは、かなり良くなりました。

これで I2C 接続の SWR 計ができたことになるので、インターフェイスをうまいこと作ってあげたいという気持ちになりました。

他のライブラリでどうにかする

こういうことをするライブラリを調べてみると、Metro というのがあります。これは以下のようにして使うライブラリのようです。

Metro interval250 = Metro(250); 

void loop() {
    if (interval250.check()) {
        // ここで 250msごとの処理
    }
}

もちろん悪くはないのですが、変数宣言と実際の処理が分かれており、余計な変数を宣言する必要があってなんか嫌です。(変数名をいちいち考えたくないという意味です)

loop() でいきなり使える定期実行

そこで以下のようなスニペットを考えました。interval class が本体です。

template <uint16_t time>
class interval {
	uint32_t next_run = 0;

	template <class T>
	void _run(T func) {
		uint32_t now = millis();
		if (next_run < now) {
			func();
			next_run = now + time;
		}
	}

	interval() {}
public:

	template <class T>
	static void run(T func) {
		static interval<time> instance;
		instance._run(func);
	}
};

void setup() {
	Serial.begin(9600);
}

void loop() {
	interval<250>::run([]{
		Serial.println("250ms 1");
	});

	interval<250>::run([]{
		Serial.println("250ms 2");
	});

	interval<1000>::run([]{
		Serial.println("1000ms");
	});

}

loop() 内でいきなり適当な書きかたをするだけですみます。

interval クラス

事前準備 (グローバル変数やstatic変数を自力で宣言したり) をせず、いきなり静的な関数ないしメソッドを読んで使うことができるようにするため、以下のような感じになっています。

まず、interval クラスは time をテンプレート引数にとっているので、time ごとに別のクラスが作られます。

各 time を持つ interval クラスには、さらに引数 func の型をテンプレート引数にとる run() という static メソッドを持っています。

run() は内部で static 変数として interval を持って、実際の処理を行うインスタンスメソッドを呼びます。

func には lambda 式を書くことを想定しています。lambda 式の型は書く度に違うものになるので、同じ time を持つ処理も複数書けます。

つまり、テンプレート引数を使うことで、グローバルな状態を複数作っています。自分で余計な変数を宣言せずに「状態」を持つためにはこのような小細工が必要なようです。

これにより、各 time と引数 func ごとに interval のインスタンスがつくられ、それぞれの処理が、別々のカウンタを持って動くことができます。

MORION MV102 10MHz +12V OCXO

出力は HCMOS 矩形波 (10kΩ 39pF 負荷) となっています。正弦波出力が欲しかったのですが間違えて買ってしまいました。バッファしてフィルタすればいい気はします。とりあえずデジタル回路に直結でき、軽くテストするには便利なのでこれはこれで良いことにします。

GND          Us

RF   Uref   Uin

というピンアサインになっています。Us は +12V入力、RF は出力、Uref はリファレンス電圧(5V)、Uin はVCOの入力のようです。

Uin には 0〜5V で入力し、これにより±4e-7 (±4Hz) 調整できるというスペックです。

#include "mbed.h"
#include <stdint.h>

constexpr uint32_t CLOCK = 10000000;
constexpr uint16_t HISTORY = 1000;

int16_t errors[HISTORY];
uint16_t error_index = 0;
uint16_t error_count = 0;

volatile bool updated = 0;
Serial serial(USBTX, USBRX);

InterruptIn gps1pps(dp25);

int main() {
	// enable 32bit counter
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<9/*CT32B0 32bit counter clock*/);

	// Capture pin dp14
	LPC_IOCON->PIO1_5         |= (0b010<<0/*FUNC=CT32B0_CAP0*/);

	// Match output (not used)
	//	LPC_IOCON->PIO1_6         |= (0b010<<0/*FUNC=CT32B0_MAT0*/);
	//	LPC_IOCON->PIO1_7         |= (0b010<<0/*FUNC=CT32B0_MAT1*/);
	//	LPC_IOCON->PIO0_1         |= (0b010<<0/*FUNC=CT32B0_MAT2*/);
	//	LPC_IOCON->R_PIO0_11      |= (0b011<<0/*FUNC=CT32B0_MAT3*/);

	LPC_TMR32B0->PR  = 0;
	LPC_TMR32B0->CCR = 0;
	LPC_TMR32B0->CTCR =
		(0b01<<0/*Counter/Timer Mode=Counter, Rising Edge*/) |
		(0b00<<2/*Count Input Select*/);
	LPC_TMR32B0->TCR = (1<<0/*Counter Enable*/);

	gps1pps.rise([]{
		static uint32_t prev = 0;

		uint32_t count = LPC_TMR32B0->TC;
		uint32_t pps_counter;
		if (prev < count) {
			pps_counter = count - prev;
		} else {
			// overflowed
			pps_counter = (0xffffff - prev) + count + 1;
		}
		prev = count;
		serial.printf("pps_counter: %lu\n", pps_counter);

		int16_t error = static_cast<int32_t>(CLOCK) - static_cast<int32_t>(pps_counter);
		error_index = (error_index + 1) % HISTORY;
		errors[error_index] = error;
		if (error_count < HISTORY) {
			error_count++;
		}
		updated = 1;
	});

	// NVIC_SetPriority();

	serial.baud(115200);
	for (;;) {
		if (updated) {
			updated = 0;
//			serial.printf("last: %d\n", errors[error_index]);
//
//			uint32_t sum = 0;
//			for (int i = 0; i < error_count; i++) {
//				sum += errors[ (error_index + HISTORY - i) % HISTORY ];
//			}
//			uint32_t error = sum * 1000 / error_count;
//			serial.printf("sum(%ds): %d\n", error_count, error);
		}
	}
}

優先度をつけるには

もし優先順位をつけてネスト可能にする場合、CMSIS（ARM規定のAPI群）のAPI (NVIC_SetPriority()) を使えば可能です。ただ、このAPIを使うためには、mbedのどのAPIでどんな割り込みを設定しているかを把握している必要があります (mbed 側のコードを全部読む必要がある)。

Cortex-M0 の NVIC の割り込みの優先の仕組み

優先順位は0から3までの4段階あり、0が最も優先です。

デフォルトでは全ての割り込みが0に設定されているので、相互に割り込みがネストすることはなく、通常処理が動いている間だけ割り込みが発生します。

また、通常処理についても、__disable_irq() を呼ぶと一時的に優先度0のコードになり、割り込みが発生しなくなります。__enable_irq() で元の優先度に戻ります。

外部ピン変化割り込みで情報が失われるケース

割り込み発生から、次の割り込みまでの間に2回ピン変化が起こると、2つめの変化による割り込み情報は失われます。

ある割り込みを優先した場合、その割り込みと同じ優先度の割り込み（その割り込み自身を含む）の処理時間だけ考えればいいことになります。

MPU のクロック自体を OCXO の 10MHz とする

前回は mbed デフォルト (内蔵の12MHz CRクロックを逓倍した48MHz) でやっていました。別にこれでもいいのですが、せっかく高精度な 10MHz があるのに、これをクロックにしないのももったいないなという感じになりました。

void set_system_clock_to_external_10mhz() {
#ifdef DEBUG_CLOCK
	// XXX: set CLKOUT to debug (dp24)
	LPC_IOCON->PIO0_1 = (0b001<<0/*FUNC=CLKOUT*/);
	LPC_SYSCON->CLKOUTCLKSEL = 0b11; /*0b00=IRC, 0b01=SysOsc, 0b10=WDT, 0b11=Main*/
	LPC_SYSCON->CLKOUTDIV = 1;
	LPC_SYSCON->CLKOUTUEN = 0;
	LPC_SYSCON->CLKOUTUEN = 1;
#endif

	// Power down config (irc=on, sysosc=on)
	LPC_SYSCON->PDRUNCFG     &= ~(
		(1<<0/*IRCOUT_PD*/) |
		(1<<1/*IRC_PD*/)
	);

	// Ensure clock source to internal in temporary
	LPC_SYSCON->MAINCLKSEL = 0b00;
	LPC_SYSCON->MAINCLKUEN = 0x00;
	LPC_SYSCON->MAINCLKUEN = 0x01;
	while ( (LPC_SYSCON->MAINCLKUEN & 0b1) == 0);

	// Power down config (syspll=off, sysosc=off)
	LPC_SYSCON->PDRUNCFG     |= (
		(1<<5/*SYSOSC_PD*/) |
		(1<<7/*SYSPLL_PD*/)
	);

	// Set System OSC = BYPASS (clock fed to XTALIN directly 1.8V / XTALOUT must be floating)
	LPC_SYSCON->SYSOSCCTRL = (1<<0/*BYPASS*/);

	// PLL Clock Source = System OSC
	LPC_SYSCON->SYSPLLCLKSEL = (0b01<<0/*SEL*/);

	// Update PLL Source
	LPC_SYSCON->SYSPLLCLKUEN = 0;
	LPC_SYSCON->SYSPLLCLKUEN = 1;
	while ( (LPC_SYSCON->SYSPLLCLKUEN & 0b1) == 0 ); 

	// Set PLL
	// M = F_clkout / F_clkin
	// FCCO = 2 * P * F_clkout (P = {1, 2, 4, 8}) (FCCO=156-320MHz)
	// F_clkout = 50MHz / M = 5 / P = 2 / FCCO = 200MHz
	LPC_SYSCON->SYSPLLCTRL = ( (5 - 1)<<0/*MSEL*/) | (0b01<<5/*PSEL*/);

	// Power down config (syspll=on)
	LPC_SYSCON->PDRUNCFG     &= ~(
		(1<<7/*SYSPLL_PD*/)
	);
	// Wait for PLL Lock
	while ( (LPC_SYSCON->SYSPLLSTAT & 0b1) == 0 );

	// Update Main Clock to PLL Output
	LPC_SYSCON->MAINCLKSEL = 0b11;
	LPC_SYSCON->MAINCLKUEN = 0x00;
	LPC_SYSCON->MAINCLKUEN = 0x01;
	while ( (LPC_SYSCON->MAINCLKUEN & 0b1) == 0); 

	// Power down config (irc=off)
	LPC_SYSCON->PDRUNCFG     |= (
		(1<<0/*IRCOUT_PD*/) |
		(1<<1/*IRC_PD*/)
	);

	SystemCoreClock = 50000000;
}

constexpr uint32_t CLOCK = 10000000;
constexpr uint16_t HISTORY = 1000;

int8_t errors[HISTORY];
uint16_t error_index = 0;
uint16_t error_count = 0;

volatile bool updated = 0;
Serial serial(USBTX, USBRX);

extern "C" void TIMER32_0_IRQHandler (void) {
	static uint32_t prev = 0;
	uint32_t count = LPC_TMR32B0->CR0;
	uint32_t pps_counter;

	if (prev < count) {
		pps_counter = count - prev;
	} else {
		// overflowed
		pps_counter = (0xffffff - prev) + count + 1;
	}
	prev = count;

	int16_t error = static_cast<int32_t>(CLOCK) - static_cast<int32_t>(pps_counter);
	if (abs(error) < 15) {
		error_index = (error_index + 1) % HISTORY;
		errors[error_index] = error;
		if (error_count < HISTORY) {
			error_count++;
		}
		updated = 1;
	}

	LPC_TMR32B0->IR = (1<<4/*CR0 Interrupt*/);
}

int main() {
	set_system_clock_to_external_10mhz();
	NVIC_EnableIRQ(TIMER_32_0_IRQn);

	// enable 32bit counter
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<9/*CT32B0 32bit counter clock*/);

	// Capture pin dp14 (for gps 1pps)
	LPC_IOCON->PIO1_5         |= (0b010<<0/*FUNC=CT32B0_CAP0*/);

	// Match output (not used)
	//	LPC_IOCON->PIO1_6         |= (0b010<<0/*FUNC=CT32B0_MAT0*/);
	//	LPC_IOCON->PIO1_7         |= (0b010<<0/*FUNC=CT32B0_MAT1*/);
	//	LPC_IOCON->PIO0_1         |= (0b010<<0/*FUNC=CT32B0_MAT2*/);
	//	LPC_IOCON->R_PIO0_11      |= (0b011<<0/*FUNC=CT32B0_MAT3*/);

	// Prescaler
	LPC_TMR32B0->PR  = 4;
	// Capture on CAP0 Rising Edge (to CR0) and Enable Interrupt
	LPC_TMR32B0->CCR =
		(1<<0/*CAP0RE*/) |
		(1<<2/*CAP0I*/);
	LPC_TMR32B0->MCR = 0;
	LPC_TMR32B0->CTCR = (0b00<<0/*Counter/Timer Mode=Timer*/);
	LPC_TMR32B0->TCR = (1<<0/*Counter Enable*/);

	serial.baud(115200);
	for (;;) {
		if (updated) {
			updated = 0;
			serial.printf("[%d] last: %+d\n", error_count, errors[error_index]);

			if (error_count >= 10) {
				int32_t sum = 0;
				for (int i = 0; i < 10; i++) {
					sum += errors[ (error_index + HISTORY - i) % HISTORY ];
				}
				serial.printf("[%d] %+ddHz\n", error_count, sum);
			}
			if (error_count >= 100) {
				int32_t sum = 0;
				for (int i = 0; i < 100; i++) {
					sum += errors[ (error_index + HISTORY - i) % HISTORY ];
				}
				serial.printf("[%d] %+dcHz\n", error_count, sum);
			}
			if (error_count >= 1000) {
				int32_t sum = 0;
				for (int i = 0; i < 1000; i++) {
					sum += errors[ (error_index + HISTORY - i) % HISTORY ];
				}
				// 1000_0000000
				serial.printf("[%d] %+dmHz\n", error_count, sum);
			}
		}
	}
}

PWM による VFC のコントロール

OCXO から出ている Vref を PWM でスイッチングしてローパスフィルタにかけてコントロール電圧を生成します。DAC デバイスの電源電圧を Vref にするという形でもよさそうですが手元に DAC デバイスがないので PWM でやっています。

#include "mbed.h"
#include <stdint.h>
#include <inttypes.h>

void set_system_clock_to_external_10mhz() {
#ifdef DEBUG_CLOCK
	// XXX: set CLKOUT to debug (dp24)
	LPC_IOCON->PIO0_1 = (0b001<<0/*FUNC=CLKOUT*/);
	LPC_SYSCON->CLKOUTCLKSEL = 0b11; /*0b00=IRC, 0b01=SysOsc, 0b10=WDT, 0b11=Main*/
	LPC_SYSCON->CLKOUTDIV = 1;
	LPC_SYSCON->CLKOUTUEN = 0;
	LPC_SYSCON->CLKOUTUEN = 1;
#endif

	// Power down config (irc=on, sysosc=on)
	LPC_SYSCON->PDRUNCFG     &= ~(
		(1<<0/*IRCOUT_PD*/) |
		(1<<1/*IRC_PD*/)
	);

	// Ensure clock source to internal in temporary
	LPC_SYSCON->MAINCLKSEL = 0b00;
	LPC_SYSCON->MAINCLKUEN = 0x00;
	LPC_SYSCON->MAINCLKUEN = 0x01;
	while ( (LPC_SYSCON->MAINCLKUEN & 0b1) == 0);

	// Power down config (syspll=off, sysosc=off)
	LPC_SYSCON->PDRUNCFG     |= (
		(1<<5/*SYSOSC_PD*/) |
		(1<<7/*SYSPLL_PD*/)
	);

	// Set System OSC = BYPASS (clock fed to XTALIN directly 1.8V / XTALOUT must be floating)
	LPC_SYSCON->SYSOSCCTRL = (1<<0/*BYPASS*/);

	// PLL Clock Source = System OSC
	LPC_SYSCON->SYSPLLCLKSEL = (0b01<<0/*SEL*/);

	// Update PLL Source
	LPC_SYSCON->SYSPLLCLKUEN = 0;
	LPC_SYSCON->SYSPLLCLKUEN = 1;
	while ( (LPC_SYSCON->SYSPLLCLKUEN & 0b1) == 0 ); 

	// Set PLL
	// M = F_clkout / F_clkin
	// FCCO = 2 * P * F_clkout (P = {1, 2, 4, 8}) (FCCO=156-320MHz)
	// F_clkout = 50MHz / M = 5 / P = 2 / FCCO = 200MHz
	LPC_SYSCON->SYSPLLCTRL = ( (5 - 1)<<0/*MSEL*/) | (0b01<<5/*PSEL*/);

	// Power down config (syspll=on)
	LPC_SYSCON->PDRUNCFG     &= ~(
		(1<<7/*SYSPLL_PD*/)
	);
	// Wait for PLL Lock
	while ( (LPC_SYSCON->SYSPLLSTAT & 0b1) == 0 );

	// Update Main Clock to PLL Output
	LPC_SYSCON->MAINCLKSEL = 0b11;
	LPC_SYSCON->MAINCLKUEN = 0x00;
	LPC_SYSCON->MAINCLKUEN = 0x01;
	while ( (LPC_SYSCON->MAINCLKUEN & 0b1) == 0); 

	// Power down config (irc=off)
	LPC_SYSCON->PDRUNCFG     |= (
		(1<<0/*IRCOUT_PD*/) |
		(1<<1/*IRC_PD*/)
	);

	SystemCoreClock = 50000000;
}

constexpr uint32_t CLOCK = 10000000;
constexpr uint16_t HISTORY = 1000;

int8_t errors[HISTORY];
uint16_t error_index = 0;
uint16_t error_count = 0;

volatile bool updated = 0;
volatile uint8_t skip_second = 0;
Serial serial(USBTX, USBRX);
PwmOut osc_control(dp1);

extern "C" void TIMER32_0_IRQHandler (void) {
	static uint32_t prev = 0;
	LPC_TMR32B0->IR = (1<<4/*CR0 Interrupt*/);

	uint32_t count = LPC_TMR32B0->CR0;
	uint32_t pps_counter;

	if (prev < count) {
		pps_counter = count - prev;
	} else {
		// overflowed
		pps_counter = (0xffffff - prev) + count + 1;
	}
	prev = count;

	if (skip_second > 0) {
		skip_second--;
		return;
	}

	int16_t error = static_cast<int32_t>(pps_counter) - static_cast<int32_t>(CLOCK);
	if (abs(error) < 15) {
		error_index = (error_index + 1) % HISTORY;
		errors[error_index] = error;
		if (error_count < HISTORY) {
			error_count++;
		}
		updated = 1;
	}
}

int16_t pulsewidth = 16500;

void vcf_plus(uint8_t count) {
	pulsewidth -= count;
	osc_control.pulsewidth_us(pulsewidth);
	skip_second = 2;
	serial.printf("osc_control = %d\n", pulsewidth);
}

void vcf_minus(uint8_t count) {
	pulsewidth += count;
	osc_control.pulsewidth_us(pulsewidth);
	skip_second = 2;
	serial.printf("osc_control = %d\n", pulsewidth);
}

int main() {
	set_system_clock_to_external_10mhz();
	NVIC_EnableIRQ(TIMER_32_0_IRQn);

	osc_control.period_us(1<<15);
	osc_control.pulsewidth_us(pulsewidth);

	// enable 32bit counter
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<9/*CT32B0 32bit counter clock*/);

	// Capture pin dp14 (for gps 1pps)
	LPC_IOCON->PIO1_5         |= (0b010<<0/*FUNC=CT32B0_CAP0*/);

	// Match output (not used)
	//	LPC_IOCON->PIO1_6         |= (0b010<<0/*FUNC=CT32B0_MAT0*/);
	//	LPC_IOCON->PIO1_7         |= (0b010<<0/*FUNC=CT32B0_MAT1*/);
	//	LPC_IOCON->PIO0_1         |= (0b010<<0/*FUNC=CT32B0_MAT2*/);
	//	LPC_IOCON->R_PIO0_11      |= (0b011<<0/*FUNC=CT32B0_MAT3*/);

	// Prescaler
	LPC_TMR32B0->PR  = 4;
	// Capture on CAP0 Rising Edge (to CR0) and Enable Interrupt
	LPC_TMR32B0->CCR =
		(1<<0/*CAP0RE*/) |
		(1<<2/*CAP0I*/);
	LPC_TMR32B0->MCR = 0;
	LPC_TMR32B0->CTCR = (0b00<<0/*Counter/Timer Mode=Timer*/);
	LPC_TMR32B0->TCR = (1<<0/*Counter Enable*/);

	serial.baud(115200);
	for (;;) {
		if (serial.readable()) {
			char c = serial.getc();
			serial.putc(c);
			serial.printf(" %d\n", c);
			if (c == '+' || c == 'p') {
				vcf_plus(100);
			} else
			if (c == '-' || c == 'm') {
				vcf_minus(100);
			}
		}

		if (updated) {
			updated = 0;
			int8_t last = errors[error_index];
			serial.printf("[%d] last: %+d\n", error_count, last);
			if (last >= 2) {
				vcf_minus(1);
			} else
			if (last <= -2) {
				vcf_plus(1);
			}

			if (error_count >= 10) {
				int32_t sum = 0;
				for (int i = 0; i < 10; i++) {
					sum += errors[ (error_index + HISTORY - i) % HISTORY ];
				}
				serial.printf("[%d] %+ddHz\n", error_count, sum);

				if (sum >= 2) {
					vcf_minus(1);
				} else
				if (sum <= -2) {
					vcf_plus(1);
				}

			}
			if (error_count >= 100) {
				int32_t sum = 0;
				for (int i = 0; i < 100; i++) {
					sum += errors[ (error_index + HISTORY - i) % HISTORY ];
				}
				serial.printf("[%d] %+dcHz\n", error_count, sum);

				if (sum >= 2) {
					vcf_minus(1);
				} else
				if (sum <= -2) {
					vcf_plus(1);
				}
			}
			if (error_count >= 1000) {
				int32_t sum = 0;
				for (int i = 0; i < 1000; i++) {
					sum += errors[ (error_index + HISTORY - i) % HISTORY ];
				}
				// 1000_0000000
				serial.printf("[%d] %+dmHz\n", error_count, sum);

				if (sum >= 2) {
					vcf_minus(1);
				} else
				if (sum <= -2) {
					vcf_plus(1);
				}
			}
		}
	}
}