hobbylab.jp 部品プロセッサー他 CH32V DS18B20

太陽光発電装置のモニター(一部未実装)を RaspberryPi と言う MPU を搭載したシングルボードコンピュータ(SBC)で作成している。
このモニターに、外温・室温・インバータ・バッテリー×２台で５個の温度測定を追加したい。

温度検出器にはデジタルで温度値を出力するもの、アナログで出力し別置きでデジタルに変換する装置を設置するものがあるが、今回は安価なものとして DS18B20(以下スレーブと呼ぶ)と言う名前の検出素子を使用する。

これはデジタルの温度値を出力し 1-Wire と言う信号伝送方法の温度検出器を使用する。

今回必要なスレーブは５個だが、温度情報を受け取る場合は下記プログラムが必要となる。
初期：スレーブのIDを取得
①温度変換指示を出す。
②温度変換するまで待つ
③温度を読み出すスレーブのIDを送信し、
　次に温度変換後の値を読み出し
　(今回は)５回繰り返し終われば ①へ

ところでMODBUSで使用している通信デバイスにはUSARTなどがあるが、これにはハード的なドライバーにより処理する機能があるため、Raspberry Pi はそのドライバーに Byte信号だけを受け渡しすれば良いが、上記初期や①、③で使用する 1-Wire と言う通信方法ではハード的ドライバーがなく通信信号をソフトで数十(us) 単位で制御する必要がある。
Raspberry Pi の標準 OS は特定の処理をミリ秒・マイクロ秒単位の精度で必ず実行する（リアルタイム性）機能は持たないので、処理負荷によって応答時間が変動する非リアルタイム（汎用）OSなためスレーブとの通信でタイミング信号（μs単位）がずれて通信エラーになる可能性がある。

そこでRaspberry Pi に直接組み込むことをやめ、安価な MCU で温度検出部を集約しそこで①~③のプログラムに加え、 RaspberryPi に温度情報を渡すプログラムを動作させることにした。

MCU と RaspberryPiの情報を渡す方法は、現状でRaspberryPi から電力関係の情報を MODBUS プロトコルで収集しているので、今回作成するMCUも MODBUS を使用して情報を伝送することにした。

MCUはできるだけ安価な003系を使用する。
想定するスレーブの最大数は8個とした。
※003系は割り込みが2系×2しか無いので、どうなるか・・

1.1.1　制御・設定内容

CH32V003J4m6による試作機

温度分解能は12bit固定とする。
(1) DeviceAddress：
　0x00(初期)〜0xF7(247)まで設定可能
(2) 通信速度：

0x00	9600(標準)
0x01	19200
0x02	38400
0x03	57600
0x04	119200
0x05	230400
0x06	460800
0x07	576000

(3) 変換待ち時間：

0x00	分解能変換時間 12bitの場合は 800(ms)
0x01〜0x41	1〜65秒で設定

(4) 温度変換指令：

0x00	off(標準)
0x01	自動繰り返し
0x10	手動温度変換指示

スレーブ登録が完了し、自動に設定した場合は次を繰り返す。
・全スレーブに対し温度変換指示。
・設定した変換待ち時間を待つ。
・全スレーブのScratchpadを読み出し温度値16(bit)を記録する。
・手動変換指示の場合は温度変換結果をアンサーする。

(5) 接続しているスレーブを登録する。

接続されているスレーブを検索し関係する情報を記録する。
最大スレーブ数は8個とする。
・検出されたスレーブの数を記録する。
・RomCodeを記録する。
・Scratchpadを読み出し、設定値(分解能)を記録する
なお標準の分解能(12bit)と違う場合は、1回のみScratchpadとEEPROMに記録指示を出す。
指定不能な場合はそのままの分解能とする。

1.1.2　情報の取得

(1) 記憶アドレスを指定してスレーブのRomCodeを読み出し
(2) 記録アドレスを指定してスレーブの設定(分解能)を読み出し
(3) 記録アドレスを指定してスレーブの温度(16bit)を読み出し

1.1.3　電源を入れた場合の処理

以下の初期処理を行う
(1) GPIO初期化
(2) TIM2で1000(ms)タイマー動作
(3) UART1初期化/割り込み初期化
(4) SW の割り込みを有効化
(5) スレーブ登録処理
(6) 分解能適正確認 12bitが悪ければ、11,10,9bitの動作確認
(7) 温度変換待ち時間計算

1.1.4　主な処理

プログラムは大きく別けて１つの割り込み方式の処理と１つのポーリング方式の処理を行っている。
(1)割り込み処理部

MODBUSの信号をUSART1で受信している。
この受信処理を割り込み処理としている。
スレーブ側で受信するbyte数は8Byteなので、その数でポーリング処理部にMODBUS信号を受信した事を示すフラグ変数(FgIntMBA)をセットします。
マスターから送る信号は他のスレーブとの通信も有ることから通信長は 8Byteとは限らないので、この信号をキャンセルするためにTIME1を使用している。
詳細は 3.2.1 マスターメッセージ長の確認処理を参照

(2)ポーリング処理部メイン関数部の繰り返し部の説明をする。

(1)温度変換が自動設定でないなら(9)へ
(2)温度検出素子が登録されていないなら(9)へ
(3)全温度検出素子に温度変換指示
(4)変換待時間になったか：なったら(8)へ
(5)フラグ変数(FgIntMBA)がセットさてないなら(4)へ
(6)MODBUSの信号解析(ModBusAnalyze)へ
(7)フラグ変数をリセットする (8)全温度検出器の温度データを読み込んで(1)へ

(9)フラグ変数(FgIntMBA)がセットさてないなら(1)へ
(10)MODBUSの信号解析(ModBusAnalyze)へ
(11)フラグ変数をリセットして(1)へ

MODBUSの信号解析はFunctionにより、DataAddresデータ、Registerデータを解析してその処理を行うが、DeviceAddressやCRCが合ってない場合は、エラーメッセージをマスターへ返す。

1.1.5　処理速度を早くする処理

(1)USART送信にDMA転送処理
(2)CRC生成処理 444(us)→118(us)
(3)メモリー転送 43.5(us)→28(us)
(4)温度だけの読み込み処理 177(ms)→120(ms)
(5)USART受信を割り込み処理 1Byte= (us) 最後のByte処理=　(us)

1.1.6　エラー処理

マスターがスレーブに対しエラーコードを指示した場合は、スレーブからマスターに対し下記応答をする。
0:Device Address = スレーブ側のアドレス
1:Function = マスターのコード + 0x80
2:Data数 = 2
3:Hi Register = ModBusErrCode0
4:Lo Register = ModBusErrCode1

なお温度検出器のエラーコードはホールディングレジスタの 0x0007〜0x000E に格納されている。
格納しているエラーコードを読み出した場合は、そのレジスターは初期化(0x00)される。
(1) スレーブが無い
(2) ファミリーコード0x28のスレーブが無い
(3) CRCエラー
(4) 分解能設定変更ができない
(5) EEPROMに設定変更の記録ができない

1.2　回路

1-Wireの温度計を最大8個接続し、そのデータをMODBUSにより転送する。
スイッチを動作させることにより、DeviceAddressと通信速度をリセットできるようにする。
リセットでは
・DeviceAddressは 0x00
・通信速度は 9600(bps)

1.2.1　開発時の回路

開発時はH32V003F4P6を使用して開発する。
理由は『003J4M6_開始』ページの4.3.2 USARTを使用する場合を参照下さい。

1.2.2　開発後の確認用回路

開発時はH32V003J4m6を使用して確認する。

1.3　通信速度

最低通信速度を9600(bps)から上限を576(kbps)とした。
これは単純に速度を8種類として
0:9800　1:19200　2:38400　3:57600　4:119200　5:230400　6:460800　7:576000
としただけで、大した根拠はない。

576(kbps)で動作できることを確認した。

右図のオシロ黄色線はマスター(PC)の送信信号だが、速度が早いた方形波が三角波になっており USB-RS23変換器の性能が危ない事がわかる。
青線はCH32V003の送信出力でまだ大丈夫そうだ。

1.4　動作確認

スレーブ(DS18B20)が３個接続しているが、矢印のモノは分解能 12bit しか反応が無い偽物ですが、今回作成したDS18B20-MODBUSプログラムは、各bitで全てが動作し、大きい分解能のbitで測定を実施するようになっており下記温度は12bitの分解能の値になっている。
Pythonでテスト用のMODBUSプログラムでスレーブの温度情報を読み取ったデータを下に示す。アドレス8にスレーブを検出した台数が入っている。

2　MODBUSの仕様

2.1　マスター側

マスターとはCH32V003に指令を出す側を言います。
プログラムの開発中はWCH-LinkEを接続するPC側です。

2.1.1　フレーム構造

8Byte固定です。

NoBytrs	0	1	2	3	4	5	6	7
項目	Device Address	Function	DataAddres		Register		CRC
項目	Device Address	Function	Top	Lo	Top	Lo	Top	Lo

2.1.2　DeviceAddress

スレーブ側のアドレスを入力する。
最初は0x00になっているが、MODBUSを通して 0x01〜0xF7(10進数 247) まで設定が出来る。

2.1.3　Function

今回作成するスレーブ Dataには
・読み書きできる2Byteデータ
・読込専用の2Byteデータ
の2種類がある。
このデータをどうするかこのFunctionで指示する。

Function Code	指示・レジスタ	概　　容
0x03	Read Holding Registers	ホールディングレジスタ(16ビットの値)の読み出し。
0x06	Write Holding Register	ホールディングレジスタ(16ビットの値)の書き込み。
0x04	Read Input Registers	インプットレジスタ（16ビットの値、読み出し専用）の読み出し。
0xFF	----------ｰｰｰｰｰｰｰｰｰｰ	スレーブからマスターへエラーメッセージ

2.1.4　DataAddres

レジスタ名	開始アドレス	終了アドレス	概　　容
Holding Registers	0x0000	0x003F	アドレスなど設定・エラー・ROM1・閾値1・分解能*1
Input Registers	0x0000	0x0010	測定した温度、エラーコード

*1 現在は変更出来ない。データアドレス詳細はスレーブの項を参照下さい。

2.1.5　Register

ここはファンクションにより違う内容になります。

Function Code	レジスターの内容
0x03	読み出すDevice Addressの数 n = (Hi Register +Lo Register)*n
0x04	読み出すDevice Addressの数 n = (Hi Register +Lo Register)*n
0x06	書き込むレジスタの値

ただしスレーブ側の応答の Data数 = N は Registerの数なので、上記レジスターの内容に出てくる nと違い、
n = N*2 となるので注意すること。

2.1.6　CRC

CRCについては『Software Protocol MODBUS 全般』のCRC参照下さい

2.2　スレーブ側

2.2.1フレーム構造

No Byte	0	1	2	3~(N*2)+1	4~(N*2)+2	N*2+3	N*2+4
項目	Device Address	Function	Data数 = N	Hi Register	Lo Register	Hi CRC	Lo CRC

スレーブの送信バッファーは　最大 133Byte必要　理由は以下による。

スレーブからマスターへ送るデータは
1Byte(Device Address) +
1Byte(Function) +
1Byte(Data数) +
128Byt(最大レジスター数 64×2) +
2Byte(CRC) = 133Byte
バッファーの数を確保できない場合は、プログラムで制限するとともに取り扱い説明書にData数の最大値を表記しておく必要がある。
なお
Data数 n = 単位は1Byteです。
ModBusのレジスターのデータは通常2Byteなので通常最低値は n = 2 となります。

2.2.2　DeviceAddress

ブロードキャストアドレスは0x00です。
　ブロードキャストアドレスでは全スレーブで
　　保持レジスターの書き込みに使用される。
　　マスターへ返答はしません。
設定できるアドレスの範囲は0x01〜0xF7です。
初期設定は0x01です。

2.2.3　Function

Function Code	内　　容
0x03	Read Holding Registers ：ホールディングレジスタ（16ビットの値、読み書き可能）の読み出し。
0x06	Write Holding Register ：ホールディングレジスタへの書き込み。
0x04	Read Input Registers ：インプットレジスタ（16ビットの値、読み出し専用）の読み出し。

2.2.4　DataAddress & Register

(1) ホールディングレジスタ

Data Address		項目	内容
Start	End	項目	Hi Register	Lo Register
0x0000	----	DeviceAddress	-ｰｰｰ	初期値は0x00　設定範囲は0x01〜0xF7
0x0001	----	通信スピード	----	初期値は0:9600bps　※1参照
0x0002	----	変換待ち時間	----	初期値は0で分解能の応じた時間　1~255:単位は1(sec)
0x0003	----	温度指令	----	初期値は0x00:off　0x01:自動(0x0002で設定した時間で計測開始) 0x10で変換指示
0x0004	----	スレーブの登録	ｰｰｰｰ	初期値0:完了　1:指示
0x0005	----	温度素子全体	Hi温度閾値	Lo温度閾値
0x0006	----	温度素子全体	0x00	変換分解bitなど
0x0007	----	スレーブ0	ErrCode 01※2	ErrCode 02※3
0x0008	----	スレーブ1	ErrCode 01※2	ErrCode 02※3
0x0009	----	スレーブ2	ErrCode 01※2	ErrCode 02※3
0x000A	----	スレーブ3	ErrCode 01※2	ErrCode 02※3
0x000B	----	スレーブ4	ErrCode 01※2	ErrCode 02※3
0x000C	----	スレーブ5	ErrCode 01※2	ErrCode 02※3
0x000D	----	スレーブ6	ErrCode 01※2	ErrCode 02※3
0x000E	----	スレーブ7	ErrCode 01※2	ErrCode 02※3
0x000F	----	MODBUS	ErrCode 01※4	ErrCode 02※5
0x0010	0x0013	スレーブ0	64bit RomCode 上位〜下位
0x0014	0x0017	スレーブ1	64bit RomCode 上位〜下位
0x0018	0x001B	スレーブ2	64bit RomCode 上位〜下位
0x001C	0x001F	スレーブ3	64bit RomCode 上位〜下位
0x0020	0x0014	スレーブ4	64bit RomCode 上位〜下位
0x0024	0x0017	スレーブ5	64bit RomCode 上位〜下位
0x0028	0x001B	スレーブ6	64bit RomCode 上位〜下位
0x002C	0x001F	スレーブ7	64bit RomCode 上位〜下位
0x0030	----	スレーブ0	Hi温度閾値	Lo温度閾値
0x0031	----	スレーブ1	Hi温度閾値	Lo温度閾値
0x0032	----	スレーブ2	Hi温度閾値	Lo温度閾値
0x0033	----	スレーブ3	Hi温度閾値	Lo温度閾値
0x0034	----	スレーブ4	Hi温度閾値	Lo温度閾値
0x0035	----	スレーブ5	Hi温度閾値	Lo温度閾値
0x0036	----	スレーブ6	Hi温度閾値	Lo温度閾値
0x0037	----	スレーブ7	Hi温度閾値	Lo温度閾値
0x0038	----	スレーブ0	----	分解能bit
0x0039	----	スレーブ1	----	分解能bit
0x003A	----	スレーブ2	----	分解能bit
0x003B	----	スレーブ3	----	分解能bit
0x003C	----	スレーブ4	----	分解能bit
0x003D	----	スレーブ5	----	分解能bit
0x003E	----	スレーブ6	----	分解能bit
0x003F	----	スレーブ7	----	分解能bit

今回は 0x0005,0x0006について変更出来ない。
※1　通信スピード枠の値と通信スピード(bps)

値	dec(bps)	8byte(us)	PassTime(us)
0x00	9600	8333	10000
0x01	19200	4167	5000
0x02	38400	2083	2500
0x03	57600	1389	1670
0x04	115200	694	830
0x05	230400	347	420
0x06	460800	174	210
0x07	576000	139	170

PssTimeはマスターからのメッセージが8Byteより短い場合に受信カウンターをリセットする時間を言う。

(2) インプットレジスタ

Register	項目	備考
0x0000	温度計接続数	HiByteは用途無しLoByteに温度計接続数
0x0001	温度計エラー	※１
0x0002	温度温度0	※1値は符号付きで1/16にすること。
0x0003	温度温度1	※1
0x0004	温度温度2	※1
0x0005	温度温度3	※1
0x0006	温度温度4	※1
0x0007	温度温度5	※1
0x0008	温度温度6	※1
0x0009	温度温度7	※1

3　プログラムの設定と確認

3.1　割り込み順位

ディバイス	Preemption	Sub
USART1 Rx	0	1
USART1 Tx DMA	1	1
TIM1	0	0
TIM2	1	0

3.2　エラー処理

3.2.1　マスターメッセージ長の確認処理

マスターメッセージ長の確認が必要な理由

このアプリて使用するマスターのメッセージ長は8Byte。
プログラムではメッセージを1Byte受信するたびに配列に入れる。
8Byte受信すると配列のデータを解析してコードが正しければ応答メッセージを返すようにしている。
しかしマスターのメッセージが8Byteでない場合に次に送られてくるメッセージの受信に対して不具合が出てきます。
例えば本装置以外へのマスターからのメッセージで6Byteしか来ない場合、次のマスターからのメッセージの先頭2Byteを加えて、一つのメッセージとして処理することになるため以降、常に間違ったメッセージになってしまう。

これを防止するため

8Byteより短いデータであることを検出し、受信データの配列を最初に戻すようにTIM1を使用する。
このTIM1の時間は8Byteより多少長い時間を設定する。
USART1の速度を変更する時にTIM1の時間も変更する。

もう少し具体的に

メッセージの1byte目でTIM1の割り込み処理を使用する。
メッセージの8byte目でTIM1の割り込み処理を停止、受信データを解析して処理、受信データの配列を最初に戻す。
メッセージが8Byte以下の場合はTIM1の割り込み処理により、受信データの配列を最初に戻す。

TIM1:タイマー値確認

通信速度(bps)	設定値(us)	測定結果(us)
9600	9170	9160
19200	4580	4580
38400	2290	2290
57600	1530	1530
115200	760	760
230400	380	380
460800	190	190
576000	150	150
921600	100	100

上記に多少関係することでマスターから次のデータが送らてくるまでの時間をGoogleのAIで確認した。

MODBUSのメッセージで次のメッセージを送るまでの間隔（時間）について規定はありますか

Modbusプロトコルでは、次のメッセージを送るまでの間隔（時間）について、使用する
伝送モード（主にRTUモードとASCIIモード）によって具体的な規定があります。 
RTUモードの場合
RTUモードでは、メッセージの開始と終了を識別するために無通信時間が重要です。 
    ・メッセージ間の間隔: 1つのメッセージの終了から次のメッセージの開始までは、
    最低3.5文字時間（3.5キャラクタータイム）以上の無通信時間が必要です。
    ・メッセージ内のバイト間隔: 1つのメッセージ内の各バイト間隔は、
    最大1.5文字時間以内である必要があります。これを超えると、
    受信側デバイスはメッセージが不完全であると判断し、破棄します。
    ・通信速度と時間: この「文字時間」はボーレート（通信速度）によって変化します。
    例えば、9600bpsでは約4.0ms、19200bpsでは約2.0msが3.5文字時間に相当します。
    ただし、19200bpsを超えるボーレートでは、3.5ms（または1.75ms）といった固定値が
    使用されることもあります。 

ASCIIモードの場合
ASCIIモードでは、メッセージの開始と終了が特定の文字（開始はコロン『:』、
終了はCR/LF）で区切られるため、メッセージ内のバイト間隔の規定はRTUモードほど厳密ではありません。 

    メッセージ内のバイト間隔: メッセージ内の文字間隔は最大1秒まで許容されます。 

補足事項
    ・マスタとスレーブ: 通常、マスタ側は次の要求メッセージを送信する前に、
    スレーブからの応答を待つか、タイムアウトするまで待機します。
    スレーブは応答メッセージの送信後、次のメッセージを受信する前に3.5文字時間以上の
    無通信時間を確保する必要があります。
    ・機器固有の仕様: 多くの機器では標準仕様に準拠していますが、一部の機器（スレーブ）によっては、
    応答遅延時間の設定（0～1000msなど）ができる場合や、特定の推奨値が設定されている場合もあります。 

したがって、Modbusのメッセージ間隔は、使用するモードとボーレートに依存し、
特にRTUモードでは厳密なタイミング規定が存在します。機器の仕様書を確認することをお勧めします

3.2.2　マスターメッセージの確認処理

表面上には出てこないが
プログラムを作成していく中で動作テストをするが、MODBUSコードが合っていあに場合にUSART1にエラーコードを送信するようにしている。
そこで使用しているエラーコードを記載する。(通常使用時はコメントアウトしている。)
変数名 ErrCode

CodeNo		使用関数
bit	Hex	ModBusAnalyze	ModBus0*	USART1_SET
0b00000001	0x01	--	Register 0	---
0b00000010	0x02	--	Register > Max	---
0b00000100	0x04	--	DataAddres > Max	---
0b00001000	0x08	--	DataAddres+Register > Max	---
0b00010000	0x10	DeviceAddress		---
0b00100000	0x20	CRC		---
0b01000000	0x40	FunctionNo		---
0b10000000	0x80			通信速度No

テスト例(TIM1の設定も含む確認する)

マスターからのメッセージ: 0x02,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x53 0x41
下図のオシロ波形説明
黄色線：マスターの要求メッセージ速度は115200(bps)
水色線：スレーブで処理したエラーコード CRC異常(テスト用エラー表示、通常はｺﾒﾝﾄｱｳﾄしている)
赤色線：USARTのRx割り込み処理を示す。
青色線：TIM1の動作を示す。

1.マスターの要求メッセージ8Btye(0x02,0x03,0x00,0x00,0x00,0x00,0x00)を受信。
2.TIM1をリセットして
3.メッセージ最後の2ByteはCRC値になるが、CRCを計算すると0x45 0xF9になり、違うためエラー出力
続いて
4.TIM1を動作させ残り6Byteを受信開始(図の[AX]部)
5.メッセージが8ByteにならないのでTIM1の設定値 760(us)経過(図の[BX]部)で受信データの配列を最初に戻す。
[AX]〜[BX]の時間は Cursors の ΔX: 760(us)
以上により次のマスター要求データを異常なく受信できるようになる。

続いて正常なマスターからのメッセージを送信: 0x2 0x3 0x0 0x0 0x0 0x1 0x84 0x39
スレーブ側では正常に応答メッセージを送信(自分のDeviceAddressを返答)

3.3　動作確認

3.3.1　通常動作

UART1速度115200(bps)
マスターからのメッセージ : 0x02 0x03 0x00 0x00 0x00 0x02 0xC4 0x38
下図のオシロ波形説明
黄色線：マスターの要求メッセージ
水色線：スレーブの返答メッセージ
赤色線：USARTのRx割り込み処理を示す。
青色線：TIM1の動作を示す。

応答メッセージは DeviceAddress = 2 通信速度 = 4 = 115200(bps)を表している。

3.3.2　DeviceAddress変更

DeviceAddressを2➡1へ変更 UART1速度115200(bps)
マスターからのメッセージ : 0x02 0x06 0x00 0x00 0x00 0x01 0x48 0x39
下図のオシロ波形説明
黄色線：マスターの要求メッセージ
水色線：スレーブの返答メッセージ
赤色線：USARTのRx割り込み処理を示す。
青色線：TIM1の動作を示す。

DeviceAddressを1以外はスレーブから返答がなかった

3.3.3　USART1速度変更

速度を230400(bps)➡115200(bps)へ変更する。
マスターからのメッセージ : 0x2 0x6 0x0 0x1 0x0 0x4 0xd9 0xfa
下図のオシロ波形説明
黄色線：マスターの要求メッセージ速度は230400(bps)
水色線：スレーブの返答メッセージ速度は115200(bps)
赤色線：速度変更の動作を示す。
青色線：TIM1の動作を示す。

3.3.4　CRC処理方法の比較

(1) CRCの計算は２箇所あり

　マスターからの要求フォーマットのCRC計算
　スレーブからの応答フォーマットのCRC計算

(2) ModBusのCRC計算方法として今回は2種類を比較する。

　①純計算方式
　②配列を組合せた計算方式

(3) CRCの対象Byte数

　マスターからの要求フォーマットは6Byte固定
　スレーブの応答ファーマットは最大131Byte 〜最小5Byte
処理時間の測定は、マスターからの8Byte目の受信〜スレーブの応答データをTx用のDMAへ送るまでの時間を測定する。

計算方法	対象Byte	実行時間(us)
①	6+131	444
①	6+5	46
②	6+131	118
②	6+5	19

(4) 結果

　配列を組合せた計算方式の方が4倍早い事が判った。
　今回のこの方式を採用する。

今回の時間データから
A + B × Byte数の式で固定時間(A)とByte変動時間(B) を出したのが下表。

計算方式 A(us) B(us)

① 11.25 3.16

② 10.35 0.79

①/② 1.087 4

計算方式	A(us)	B(us)
①	11.25	3.16
②	10.35	0.79
①/②	1.087	4

3.3.5　コピー方法の比較

①	6+131	118
①	6+5	19
②	6+131	111
②	6+5	18

3.3.6　メインプログラム

プログラム概容

初期
・各部の初期化
・スレーブ登録
・スレーブがあれば温度測定　停止→自動

①自動になっているか no → ⑩ → ①へ
　↓
②スレーブ台数が有る場合は no → ⑩ → ①へ
　↓
③温度変換指令
　↓
④-1　⑩
④-2　待時間が超えたか no→④-1へ
　↓
⑤各スレーブの温度を読込、配列へ記録
　↓
①へ

⑩ModBusの信号が来たか(ディバイス番号が合っているかまでを割り込み処理で判定している。) no→ 戻る
　↓
　⑳
　↓
戻る

⑳ ファンクション他解析、実行
　↓
戻る

メインプログラムの動作例

(1)ModBusで変換指示 0x(00,06,00,03,00,10,79,d7)
(2)全スレーブに温度変換指示を出す
(3)変換待ち時間待機
(4)各スレーブの温度を取得してModBusで使用している配列にデータを格納する。
(5)ModBusで変換したデータを受信 0x(00,04,12,01,37,01,3a,01,33,01,3f,01,3f,01,3b,01,4a,01,3c,00,08,fa,92)
時間をオシロで観測　黄線 CH32V003のRX、水線 TX、赤線 1-Wire動作青線 1-Wire

(1)〜(5)の全体波形

(4) 処理時間は121(ms)　　(5) 24(ms)

(1) 8.22(ms)　　(2)3.2(ms)

信号内容について (1) 黄線したのHex値の通り
(1)~(2)初め 8.25(ms)
(2) 0011001100100010→11001100(0xCC)01000100(0x44)

4　プログラム

プログラムはMounRiver Studio Ⅱで作成しました。
コメントや無駄なプログラムは消したつもりです。
プログラムとしては 1000行程度になりました。
無駄なものや改善点がございましたら、お教え下さい。
プログラムの説明用ページは後日になります。

/********************** (C)  2026 hobbylab.jp *********************
 * File Name          : DS18B20_MODBUS main.c
 * Version            : V1.0.0
 * Date               : 2026/3/
 *本プログラムは自由にご利用いただけますが、
 *利用によって生じた損害等について制作者は一切の責任を負いません。
 *******************************************************************/
#include "debug.h"
#include "string.h"
#include "stdlib.h"

uint16_t syscl1;
uint16_t syscl2;
uint8_t Query[8] = {0x00, 0x07, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00};
uint8_t QueryArrQuant = 0;
uint8_t QueryArrNo = 0;
#define dfQueryArrNoMax 7
uint8_t QueryAddStart = 0;
uint8_t QueryAddQuant = 0;
uint8_t QueryAddEnd = 0;
uint8_t Reply[133];
uint8_t ReplyArrQuant = 0;
#define dfBaudMax 9
#define dfReferenceBaud 0
uint32_t baud[9] = {9600, 19200, 38400, 57600, 115200, 230400, 460800, 576000, 921600};
uint16_t PassTime[9] = {9170, 4580, 2290, 1530, 760, 380, 190, 150, 100};
uint16_t ModbusRxCancelTime;
uint8_t FgIntMBA;
#define dfHoldingRegArrMax 63
#define dfHoldingRegArrQuantityMax (dfHoldingRegArrMax + 1)
#define dfChangeHoldingRegArrMax 4
#define dfErrHoldingRegArrStart 7
#define dfErrHoldingRegArrQuantityMax 9
static uint8_t HoldingReg[64][2] = {
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0X00},
    {0x00, 0X00},
    {0x00, 0X00},
    {0x00, 0X00},
    {0x00, 0X00},
    {0x00, 0X00},
    {0x00, 0X00},
    {0x00, 0X00},
    {0x00, 0X00},
    {0x00, 0X00},
    {0x00, 0X00},
    {0x00, 0X00},
    {0x00, 0X00},
    {0x00, 0X00},
    {0x00, 0X00},
    {0x00, 0X00}
};

#define dfInputRegArrMax 10
#define dfInputRegArrQuantityMax (dfInputRegArrMax + 1)
static uint8_t InputReg[17][2] = {
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
    {0x00, 0x00},
};

static uint16_t crc16_table[256] = {
    0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
    0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
    0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
    0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
    0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
    0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
    0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
    0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
    0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
    0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
    0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
    0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
    0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
    0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
    0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
    0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
    0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
    0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
    0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
    0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
    0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
    0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
    0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
    0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
    0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
    0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
    0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
    0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
    0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
    0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
    0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
    0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040};
static uint8_t ModBusErrCode1;

#define dfT0 500
#define dfT1 90
#define dfT3 410
#define dfTS0 2
#define dfTS5 120
#define dfTREC 2
#define dfTR0 2
#define dfTR3 6
#define dfTR4 120

#define dfReadRom 0x33
#define dfSkipRom 0xCC
#define dfMatchRom 0x55
#define dfAlarmSeaech 0xEC
#define dfSearchROM 0xF0

#define dfReadScratchpad 0xBE
#define dfWriteScratchpad 0x4E
#define dfConvertT 0x44
#define dfCopyScratchpad 0x48
#define dfReCall 0xB8
#define dfReadParasitePower 0xB4
#define dfSlaveMax 8

uint64_t RomCode64[dfSlaveMax] = {
    0x0000000000000000ULL,
    0x0000000000000000ULL,
    0x0000000000000000ULL,
    0x0000000000000000ULL,
    0x0000000000000000ULL,
    0x0000000000000000ULL,
    0x0000000000000000ULL,
    0x0000000000000000ULL};

uint8_t RomCodeChkCrc[dfSlaveMax] = {0};
uint8_t bitPos[dfSlaveMax] = {0x00};
uint8_t SlaveValue = 0;

uint8_t ScratchPad[dfSlaveMax][9] = {
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
};

uint8_t ScratchPadChkCrc[dfSlaveMax] = {0};
uint16_t cvTime;
uint8_t cobit[4] = {9, 10, 11, 12};
uint8_t setrg[4] = {0x1F, 0x3F, 0x5F, 0x7F};
int8_t IntegerTemp = 0;
uint16_t convTime[4] = {100, 200, 400, 800};
#define dfIniRes 0x7F
#define dfCopyTime 20000
#define dfRecallTime 20000

uint16_t lbtim[72] = {0};
uint16_t TimMax = 0, TimMin = 0;
uint16_t CompleteTim = 0, MaxCountTim = 0;
uint8_t CountTim;
#define dfPwOff 0
#define dfEtPwOn 1
#define dfPsPwOn 2
uint8_t Pow = 0;
uint16_t sysclock = 0;

void RomCodeOthersClear (void) {
    SlaveValue = 0;
    for (uint8_t i1 = 0; i1 < dfSlaveMax; ++i1) {
        RomCode64[i1] = 0ULL;
        RomCodeChkCrc[i1] = 0ULL;
    }
}

uint8_t crc8_byte (uint8_t crc, uint8_t data) {
    crc ^= data;

for (int i = 0; i < 8; i++) {
        if (crc & 0x01) {
            crc = (crc >> 1) ^ 0x8C;
        } else {
            crc >>= 1;
        }
    }
    return crc;
}

uint8_t crc64_calculate (uint64_t data, int len) {
    uint8_t crc = 0;
    unsigned char byte;

for (uint8_t lop1 = 0; lop1 < len; ++lop1) {
        byte = (unsigned char)((data >> lop1 * 8) & 0xFF);
        crc = crc8_byte (crc, byte);
    }
    return crc;
}

uint8_t crc8_calculate (uint8_t *data, int len) {
    uint8_t crc = 0;

for (int i = 0; i < len; i++) {
        crc = crc8_byte (crc, data[i]);
    }
    return crc;
}

void TIM1_SET (u16 dv, u16 count) {
    RCC_APB2PeriphClockCmd (RCC_APB2Periph_TIM1, ENABLE);
    TIM_TimeBaseInitTypeDef TIM_Time1 = {0};
    TIM_Time1.TIM_Prescaler = dv - 1;
    TIM_Time1.TIM_Period = count - 1;
    TIM_Time1.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_Time1.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseInit (TIM1, &TIM_Time1);
    TIM_ITConfig (TIM1, TIM_IT_Update, ENABLE);
}

void TIM1_NVIC_INIT (void) {
    NVIC_InitTypeDef NVIC_TIM1 = {0};
    NVIC_TIM1.NVIC_IRQChannel = TIM1_UP_IRQn;
    NVIC_TIM1.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_TIM1.NVIC_IRQChannelSubPriority = 0;
    NVIC_TIM1.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init (&NVIC_TIM1);
}

void TIM2_SET (u16 dv, u16 count) {
    RCC_APB1PeriphClockCmd (RCC_APB1Periph_TIM2, ENABLE);
    TIM_TimeBaseInitTypeDef TIM_Time2 = {0};
    TIM_Time2.TIM_Prescaler = dv - 1;
    TIM_Time2.TIM_Period = count - 1;
    TIM_Time2.TIM_ClockDivision = TIM_CKD_DIV1;
    TIM_Time2.TIM_CounterMode = TIM_CounterMode_Up;
    TIM_TimeBaseInit (TIM2, &TIM_Time2 );
    TIM_ITConfig (TIM2, TIM_IT_Update, DISABLE);
    TIM_ClearFlag (TIM2, TIM_FLAG_Update);
    TIM_Cmd (TIM2, ENABLE);
}

void GPIO_INIT (void) {
    RCC_APB2PeriphClockCmd (RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOC, ENABLE);
    GPIO_InitTypeDef GPIO_InitStructure = {0};
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_Init (GPIOA, &GPIO_InitStructure);
    GPIO_InitTypeDef GPIO_1Wire = {0};
    GPIO_1Wire.GPIO_Pin = GPIO_Pin_4;
    GPIO_1Wire.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_1Wire.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init (GPIOC, &GPIO_1Wire);
}

void PA2_EXTI_INIT (uint8_t cmd) {
    GPIO_EXTILineConfig (GPIO_PortSourceGPIOA, GPIO_PinSource2);
    EXTI_InitTypeDef EXTI_InitStructure = {0};
    EXTI_InitStructure.EXTI_Line = EXTI_Line2;
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
    EXTI_InitStructure.EXTI_LineCmd = cmd;
    EXTI_Init (&EXTI_InitStructure);
    NVIC_InitTypeDef NVIC_InitStructure = {0};
    NVIC_InitStructure.NVIC_IRQChannel = EXTI7_0_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init (&NVIC_InitStructure);
}

void UART1_INIT (void) {
    RCC_APB2PeriphClockCmd (RCC_APB2Periph_GPIOD | RCC_APB2Periph_USART1, ENABLE);
    RCC_AHBPeriphClockCmd (RCC_AHBPeriph_DMA1, ENABLE);
    GPIO_InitTypeDef GPIO_USART1_Tx_Setup = {0};
    GPIO_USART1_Tx_Setup.GPIO_Pin = GPIO_Pin_5;
    GPIO_USART1_Tx_Setup.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_USART1_Tx_Setup.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_Init (GPIOD, &GPIO_USART1_Tx_Setup);
    GPIO_InitTypeDef GPIO_USART1_Rx_Setup = {0};
    GPIO_USART1_Rx_Setup.GPIO_Pin = GPIO_Pin_6;
    GPIO_USART1_Rx_Setup.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init (GPIOD, &GPIO_USART1_Rx_Setup);
}

void USART1_SET (void) {
    uint8_t SelNo = HoldingReg[1][1];
    if (SelNo >= dfBaudMax) {
        ModBusErrCode1 |= 0b10000000;
        SelNo = dfReferenceBaud;
        HoldingReg[1][1] = dfReferenceBaud;
    }
    ModbusRxCancelTime = PassTime[SelNo];
    syscl1 = SystemCoreClock / 1000000;
    TIM_Cmd (TIM1, DISABLE);
    TIM_ITConfig (TIM1, TIM_IT_Update, DISABLE);
    TIM_SetCounter (TIM1, 0);
    TIM_ClearITPendingBit (TIM1, TIM_IT_Update);
    TIM1_SET (syscl1, ModbusRxCancelTime);
    TIM_ITConfig (TIM1, TIM_IT_Update, ENABLE);
    USART_Cmd (USART1, DISABLE);
    USART_InitTypeDef USART_Setup;
    USART_Setup.USART_BaudRate = baud[SelNo];
    USART_Setup.USART_WordLength = USART_WordLength_8b;
    USART_Setup.USART_StopBits = USART_StopBits_1;
    USART_Setup.USART_Parity = USART_Parity_No;
    USART_Setup.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_Setup.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;
    USART_Init (USART1, &USART_Setup);
    USART_Cmd (USART1, ENABLE);
}

void USART1_NVIC_DMA_INIT (void) {
    NVIC_InitTypeDef NVIC_USART = {0};
    NVIC_USART.NVIC_IRQChannel = USART1_IRQn;
    NVIC_USART.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_USART.NVIC_IRQChannelSubPriority = 1;
    NVIC_USART.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init (&NVIC_USART);
    USART_ITConfig (USART1, USART_IT_RXNE, ENABLE);
    DMA_DeInit (DMA1_Channel4);
    DMA_InitTypeDef DMA_USART = {0};
    DMA_USART.DMA_PeripheralBaseAddr = (uint32_t)&USART1->DATAR;
    DMA_USART.DMA_MemoryBaseAddr = (uint32_t)Reply;
    DMA_USART.DMA_DIR = DMA_DIR_PeripheralDST;
    DMA_USART.DMA_BufferSize = sizeof (Reply);
    DMA_USART.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_USART.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_USART.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    DMA_USART.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    DMA_USART.DMA_Mode = DMA_Mode_Normal;
    DMA_USART.DMA_Priority = DMA_Priority_High;
    DMA_USART.DMA_M2M = DMA_M2M_Disable;
    DMA_Init (DMA1_Channel4, &DMA_USART);
    USART_DMACmd (USART1, USART_DMAReq_Tx, ENABLE);
}

void Wire_out (void) {
    GPIOC->CFGLR |= 0b00000000000001110000000000000000;
}

void Wire_in (void) {
    GPIOC->CFGLR &= 0b11111111111101001111111111111111;
}

uint8_t Reset_Presence (void) {
    uint8_t fg = 0;
    Wire_out();
    GPIOC->OUTDR &= 0b11111111111111111111111111101111;
    Delay_Us (dfT0);
    GPIOC->OUTDR |= 0b00000000000000000000000000010000;
    Wire_in();
    Delay_Us (dfT1);
    fg = !(GPIOC->INDR & 0b00000000000000000000000000010000);
    Delay_Us (dfT3);
    return fg;
}

void WriteTimeSlot (uint8_t writebit) {
    Wire_out();
    GPIOC->OUTDR &= 0b11111111111111111111111111101111;
    writebit = writebit & 0b00000001;
    Delay_Us (dfTS0);
    if (writebit == 1) {
        GPIOC->OUTDR |= 0b00000000000000000000000000010000;
        Delay_Us (dfTS5);
    } else {
        Delay_Us (dfTS5);
        GPIOC->OUTDR |= 0b00000000000000000000000000010000;
    }
    Delay_Us (dfTREC);
}

uint8_t ReadTimeSlot (void) {
    uint8_t readbit;
    Wire_out();
    GPIOC->OUTDR &= 0b11111111111111111111111111101111;
    Delay_Us (dfTR0);
    GPIOC->OUTDR |= 0b00000000000000000000000000010000;
    Wire_in();
    Delay_Us (dfTR3);
    readbit = (GPIOC->INDR & 0b00000000000000000000000000010000) >> 4;
    // GPIO_WriteBit (GPIOC, GPIO_Pin_6, readbit); // OSC3
    Delay_Us (dfTR4);
    // GPIO_WriteBit (GPIOC, GPIO_Pin_7, Bit_RESET);  // OSC4
    // GPIO_WriteBit (GPIOC, GPIO_Pin_6, Bit_RESET);  // OSC3
    Delay_Us (dfTREC);
    return readbit;
}

void ByteWriteTimeSlot (uint8_t writebyte) {
    uint8_t lop1;
    for (lop1 = 0; lop1 < 8; lop1++) {
        WriteTimeSlot (writebyte);
        writebyte >>= 1;
    }
}

void RomCodeWriteTimeSlot (uint64_t deta) {
    uint8_t Dbit, lop1;
    for (lop1 = 0; lop1 < 64; lop1++) {
        Dbit = (deta >> lop1) & 0xff;
        WriteTimeSlot (Dbit);
    }
}

void SearchRom (uint8_t FamilyCode) {
    uint64_t RomCodeD;
    uint64_t bit1;
    uint8_t bit2, bit3;
    uint8_t ReadBitPos;
    uint8_t SearchRomSlaveNo = 0;
    RomCodeOthersClear();
    InputReg[0][1] = 0;
    RomCode64[0] = FamilyCode;
    bitPos[0] = 7;
    while (SearchRomSlaveNo < dfSlaveMax) {
        if (!Reset_Presence()) {
            HoldingReg[0x0F][0] |= 0b00000001;
            goto Errend;
        }
        RomCodeD = 0;
        ByteWriteTimeSlot (dfSearchROM);
        for (ReadBitPos = 0; ReadBitPos < 64; ++ReadBitPos) {
            bit1 = 0;
            bit1 = ReadTimeSlot();
            bit3 = ReadTimeSlot();
            bit2 = bit1 << 1 | bit3;
            if (bitPos[SearchRomSlaveNo] >= ReadBitPos) { 
                bit1 = (RomCode64[SearchRomSlaveNo] >> ReadBitPos) & 0x01;
            } else {
                switch (bit2) {
                case 0x00:
                    if (SlaveValue < dfSlaveMax - 1) {
                        ++SlaveValue;
                        RomCode64[SlaveValue] = RomCodeD;
                        RomCode64[SlaveValue] |= 1ULL << ReadBitPos;
                        bitPos[SlaveValue] = ReadBitPos;
                    }
                    break;
                case 0x03:
                    HoldingReg[SearchRomSlaveNo + 7][0] |= 0b10000000;
                    RomCode64[SearchRomSlaveNo] = 0;
                    goto Errend;
                    break;
                }
            }
            RomCodeD |= bit1 << ReadBitPos;
            WriteTimeSlot (bit1);
        }
        RomCode64[SearchRomSlaveNo] = RomCodeD;
        if (SearchRomSlaveNo == SlaveValue) {
            break;
        }
        ++SearchRomSlaveNo;
    }
    InputReg[8][1] = SearchRomSlaveNo + 1;
    for (uint8_t ArrayNo = 0; ArrayNo <= SlaveValue; ++ArrayNo) {
        RomCodeChkCrc[ArrayNo] = crc64_calculate (RomCode64[ArrayNo], 8);
        if (RomCodeChkCrc[ArrayNo] == 0) {
            uint64_t *arradd;
            for (uint8_t i1 = 0; i1 <= SearchRomSlaveNo; ++i1) {
                arradd = (uint64_t *)&HoldingReg[(i1 * 4) + 16][0];
                *arradd = RomCode64[i1];
            }
        } else {
            RomCode64[ArrayNo] = 0;
            HoldingReg[ArrayNo + 7][0] |= 0b00000010;
        }
    }
Errend:;
}

uint8_t ReadScratchPad (uint8_t thrg, uint8_t tlrg, uint8_t cofrg) {
    uint8_t vL1, Lop1, Lop2;
    uint8_t ErrCode=0; 
    uint8_t RxDArr[9] = {0};
    uint8_t svv = InputReg[8][1];
    if (svv > dfSlaveMax) {
        svv = dfSlaveMax;
    }

for (uint8_t svNo = 0; svNo < svv; ++svNo) {
        if (Reset_Presence()) {
            ByteWriteTimeSlot (dfMatchRom);
            RomCodeWriteTimeSlot (RomCode64[svNo]);
            ByteWriteTimeSlot (dfReadScratchpad);
            for (Lop1 = 0; Lop1 < 9; Lop1++) {
                vL1 = 0;
                for (Lop2 = 0; Lop2 < 8; Lop2++) {
                    if (ReadTimeSlot() == 1) {
                        vL1 |= 0x01 << Lop2;
                    }
                }
                switch (Lop1) {
                case 0:
                    InputReg[svNo][1] = vL1;
                    break;
                case 1:
                    InputReg[svNo][0] = vL1;
                    break;
                case 2:
                    HoldingReg[svNo + 48][0] = vL1;
                    if(vL1 != thrg){ErrCode |=0b00010000;}
                    break;
                case 3:
                    HoldingReg[svNo + 48][1] = vL1;
                    if(vL1 != tlrg){ErrCode |=0b00100000;}
                    break;
                case 4:
                    HoldingReg[svNo + 56][1] = vL1;
                    if(vL1 != cofrg){ErrCode |=0b01000000;}
                    break;
                case 9:
                    RxDArr[Lop1] = vL1;
                }
            }
            uint8_t ckval = Lop1;
            uint8_t calculated_crc = crc8_calculate (RxDArr, ckval);
            if (calculated_crc > 0) {
                ErrCode |= 0b00000010;
            }
        } else {
            ErrCode |= 0b00000001;
        }
        HoldingReg[svNo + 7][1]=ErrCode;
        ErrCode &= 0x40;
    }
    return ErrCode;
}

void ReadTemp(void) {
    uint8_t vL1, Lop1, Lop2;
    uint8_t svv = InputReg[8][1];
    if (svv > dfSlaveMax) {
        svv = dfSlaveMax;
    }

void ConvertTemp(void) {
    if (Reset_Presence()) {
        ByteWriteTimeSlot (dfSkipRom);
        ByteWriteTimeSlot (dfConvertT);
    } else {
        HoldingReg[0x0F][0] |= 0b00000001;
    }
}

void calCvTime(void){
    if (InputReg[8][1]==0){
        cvTime = convTime[ dfIniRes >> 5 ];
        HoldingReg[5][1] = dfIniRes;
    }else{
        cvTime = HoldingReg[2][1];
        if(cvTime == 0 ){
            cvTime = convTime[ HoldingReg[5][1] >> 5 ];
        }else{
            cvTime = (cvTime * 1000) - 125;
        }
    }
    InputReg[9][1] = (uint8_t)(cvTime & 0x00FF);
    InputReg[9][0] = cvTime >> 8;
}

void Convert_ReadTemp(void) {
    ConvertTemp();
    Delay_Ms (cvTime);
    ReadTemp();
}

void SetScratchpad (uint8_t thrg, uint8_t tlrg, uint8_t cofrg) {
    if (Reset_Presence()) {
        ByteWriteTimeSlot (dfSkipRom);
        ByteWriteTimeSlot (dfWriteScratchpad);
        ByteWriteTimeSlot (thrg);
        ByteWriteTimeSlot (tlrg);
        ByteWriteTimeSlot (cofrg);
    } else {
        HoldingReg[0x0F][0] |= 0b00000001;
    }
    if (Reset_Presence()) {
        ByteWriteTimeSlot (dfSkipRom);
        ByteWriteTimeSlot (dfCopyScratchpad);
    } else {
        HoldingReg[0x0F][0] |= 0b00000001;
    }
    Delay_Ms (10);
    if (Reset_Presence()) {
        ByteWriteTimeSlot (dfSkipRom);
        ByteWriteTimeSlot (dfReCall);
    } else {
        HoldingReg[0x0F][0] |= 0b00000001;
    }
    Delay_Ms (10);
}

uint16_t ModBus_crc (const uint8_t *data, uint16_t length) {
    uint16_t crc = 0xFFFF;
    for (uint16_t i = 0; i < length; i++) {
        crc ^= data[i];
        for (uint8_t j = 0; j < 8; j++) {
            if (crc & 0x0001) {
                crc >>= 1;
                crc ^= 0xA001;
            } else {
                crc >>= 1;
            }
        }
    }
    return crc;
}

uint16_t ModBus_crc_fast (const uint8_t *data, uint16_t length) {
    uint16_t crc = 0xFFFF;  // Modbus CRCの初期値
    while (length--) {
        // 現在のCRCとデータのXORをとり、インデックスとしてテーブルを参照
        crc = (crc >> 8) ^ crc16_table[(crc ^ *data++) & 0xFF];
    }
    return crc;
}

void DMA_USART_crcTx (uint8_t Size) {
    uint16_t crc = 0;
    uint8_t crcByte = 0;
    //  crc = ModBus_crc (Reply, ReplyArrQuant);
    crc = ModBus_crc_fast (Reply, ReplyArrQuant);
    crcByte = crc & 0x00FF;
    Reply[ReplyArrQuant] = crcByte;
    crcByte = (crc >> 8);
    Reply[++ReplyArrQuant] = crcByte;
    ++ReplyArrQuant;
    DMA_Cmd (DMA1_Channel4, DISABLE);
    DMA_SetCurrDataCounter (DMA1_Channel4, ReplyArrQuant);
    DMA_Cmd (DMA1_Channel4, ENABLE);
}

void ModBus03 (void) {
    QueryAddQuant = Query[5];
    if (QueryAddQuant == 0) {
        ModBusErrCode1 |= 0b00000001;
        goto jpend;
    }
    if (QueryAddQuant > (dfHoldingRegArrQuantityMax)) {
        ModBusErrCode1 |= 0b00000010;
        goto jpend;
    }
    QueryAddStart = Query[3];
    if (QueryAddStart > dfHoldingRegArrMax || Query[2] > 0) {
        ModBusErrCode1 |= 0b00000100;
        goto jpend;
    }
    QueryAddEnd = QueryAddStart + QueryAddQuant - 1;
    if (QueryAddEnd > dfHoldingRegArrMax || Query[4] > 0) {
        ModBusErrCode1 |= 0b00001000;
        goto jpend;
    }
    ReplyArrQuant = QueryAddQuant * 2;
    Reply[0] = HoldingReg[0][1];
    Reply[1] = 0x03;
    Reply[2] = ReplyArrQuant;
    memcpy (&(Reply[3]), &(HoldingReg[QueryAddStart][0]), ReplyArrQuant);
    ReplyArrQuant = ReplyArrQuant + 3;
    if (QueryAddEnd >= dfErrHoldingRegArrStart) {
        uint8_t imax = QueryAddEnd - dfErrHoldingRegArrStart + 1;
        if (imax > dfErrHoldingRegArrQuantityMax) {
            imax = dfErrHoldingRegArrQuantityMax;
        }
        for (uint8_t i = 0; i < imax; ++i) {
            uint8_t arrNo = dfErrHoldingRegArrStart + i;
            HoldingReg[arrNo][0] = 0;
            HoldingReg[arrNo][1] = 0;
        }
    }
jpend:;
}

void ModBus04 (void) {
    QueryAddQuant = Query[5];
    if (QueryAddQuant == 0) {
        ModBusErrCode1 |= 0b00000001;
        goto jpend;
    }
    if (QueryAddQuant > dfInputRegArrQuantityMax) {
        ModBusErrCode1 |= 0b00000010;
        goto jpend;
    }
    QueryAddStart = Query[3];
    if (QueryAddStart > dfInputRegArrMax || Query[2] > 0) {
        ModBusErrCode1 |= 0b00000100;
        goto jpend;
    }
    QueryAddEnd = QueryAddStart + QueryAddQuant - 1;
    if (QueryAddEnd > dfInputRegArrMax || Query[4] > 0) {
        ModBusErrCode1 |= 0b00001000;
        goto jpend;
    }
    ReplyArrQuant = QueryAddQuant * 2;
    Reply[0] = HoldingReg[0][1];
    Reply[1] = 04;
    Reply[2] = ReplyArrQuant;
    memcpy (&(Reply[3]), &(InputReg[QueryAddStart][0]), ReplyArrQuant);
    ReplyArrQuant = ReplyArrQuant + 3;
jpend:;
}

void BestResolution (void) {
    uint8_t thrg=0x4B,tlrg=0x46,cofrg=0,i1=0;
    uint8_t ErrCode=0;
    for(uint8_t i=0 ; i < 4 ; ++i ){
        i1= 3 - i; //12bitから確認する
        cofrg=setrg[i1];
        SetScratchpad (thrg,tlrg,cofrg);
        ErrCode = ReadScratchPad(thrg,tlrg,cofrg);
        if( !(ErrCode & 0x40) ){goto good;}
        ErrCode = 0;
    }
good:
    HoldingReg[5][1] = cofrg;
}

void ModBus06 (void) {
    QueryAddStart = Query[3];
    if (QueryAddStart > dfChangeHoldingRegArrMax || Query[2] > 0) {
        ModBusErrCode1 |= 0b00000100;
        goto jpend;
    }
    if ((HoldingReg[QueryAddStart][1] == Query[5])) {
        ModBusErrCode1 |= 0b00000001;
        goto jpend;
    }
    switch (QueryAddStart) {
    case 0:
        if(Query[5] > 247){
            ModBusErrCode1 |= 0b00000010;
            goto jpend;}
        HoldingReg[0][1] = Query[5];
        break;
    case 1:
        HoldingReg[1][1] = Query[5];
        USART1_SET();
        break;
    case 2:
        if(Query[5] > 65){
            ModBusErrCode1 |= 0b00000010;
            goto jpend;}
        HoldingReg[2][1] = Query[5];
        calCvTime();
        break;
    case 3:
        switch (Query[5]) {
        case 0x00:
            break;
        case 0x01:
            break;
        case 0x10:
            if(FgIntMBA==2){
                ModBusErrCode1 |= 0b10000000;
                goto jpend;}
            Convert_ReadTemp();
            Query[1]=0x04;
            Query[2]=0x00;
            Query[3]=0x00;
            Query[4]=0x00;
            Query[5]=0x09;
            ModBus04();
            goto jpend;
            break;
        default:
            ModBusErrCode1 |= 0b00000010;
            goto jpend;
        }
        HoldingReg[3][1] = Query[5]; 
        break;
    case 4:
        if(FgIntMBA==2){
            ModBusErrCode1 |= 0b10000000;
            goto jpend;}
        HoldingReg[4][1] = Query[5];
        // スレーブの登録
        SearchRom (0x28);
        BestResolution();
        calCvTime();
        HoldingReg[4][1] = 0;
        break;
    default:
        ModBusErrCode1 |= 0b01000000;
        goto jpend;
    }
    Reply[0] = HoldingReg[0][1];  // Device Address
    Reply[1] = 0x06;
    Reply[2] = 2;
    Reply[3] = HoldingReg[QueryAddStart][0];
    Reply[4] = HoldingReg[QueryAddStart][1];
    ReplyArrQuant = 5;
jpend:;
}

void ModBusAnalyze (void) {
    uint16_t crc;
    uint8_t crcByteHi, crcByteLo;
    ModBusErrCode1 = 0b00000000;
    if (Query[0] != HoldingReg[0][1]) {
        goto pass;
    }
    crc = ModBus_crc_fast (Query, (QueryArrQuant - 2));
    crcByteHi = crc & 0x00FF;
    crcByteLo = (crc >> 8);
    if (Query[(QueryArrQuant - 2)] != crcByteHi || Query[(QueryArrQuant - 1)] != crcByteLo) {
        ModBusErrCode1 |= 0b00100000;
        goto jpend;
    }
    switch (Query[1]) {
    case 3:
        ModBus03();
        break;
    case 4:
        ModBus04();
        break;
    case 6:
        ModBus06();
        break;
    default:
        ModBusErrCode1 |= 0b01000000;
        break;
    }
jpend:
    if (ModBusErrCode1 > 0) {
        HoldingReg[0x0F][1] = ModBusErrCode1;
        Reply[0] = HoldingReg[0][1];
        Reply[1] = Query[1] + 0x80;
        Reply[2] = 2;
        Reply[3] = 0;
        Reply[4] = ModBusErrCode1;
        ReplyArrQuant = 5;
        HoldingReg[0x0F][0] = ModBusErrCode1;
    }
    DMA_USART_crcTx (ReplyArrQuant);
pass:;
}

void Init (void) {
    GPIO_INIT();
    syscl2 = SystemCoreClock / 1000;
    TIM2_SET(syscl2,1000);
    while (TIM_GetFlagStatus (TIM2, TIM_FLAG_Update) == RESET);
    TIM_ClearFlag (TIM2, TIM_FLAG_Update);
    UART1_INIT();
    USART1_SET();
    USART1_NVIC_DMA_INIT();
    TIM1_NVIC_INIT();
    PA2_EXTI_INIT (ENABLE);
    if (InputReg[8][1]==0){
        cvTime = convTime[ dfIniRes >> 5 ];
        HoldingReg[2][0] = 0;
        HoldingReg[2][1] = 0;
        HoldingReg[3][1] = 0;
        HoldingReg[5][1] = dfIniRes;
        InputReg[9][1] = (uint8_t)(cvTime & 0x00FF);
        InputReg[9][0] = cvTime >> 8;
    }    
    QueryArrNo = 0;
}

int main (void) {
    Delay_Init();
    Delay_Ms (1000);
    Init();
    SearchRom (0x28);
    BestResolution();
    HoldingReg[2][1] = 1;
    if(InputReg[8][1]>0){
        HoldingReg[3][1] = 1;
        calCvTime();
    }else{
        HoldingReg[3][1] = 0;
    }

while (1) {
        if(HoldingReg[3][1]==0x00){goto jpend; }
        if(InputReg[8][1]==0x00){goto jpend;}
        ConvertTemp();
        TIM_ClearFlag(TIM2, TIM_FLAG_Update);
        TIM2->ATRLR = cvTime - 1;
        TIM2->CNT = 0;
        while(TIM_GetFlagStatus(TIM2, TIM_FLAG_Update ) == RESET){
            if ( FgIntMBA > 0 ){
                FgIntMBA = 2; //手動により温度変換は出来ない。
                ModBusAnalyze();
                FgIntMBA = 0;
                }
        }
        ReadTemp();
   jpend:
        if ( FgIntMBA == 1 ){
            ModBusAnalyze();
            FgIntMBA = 0;
           }
    }
}

void TIM1_UP_IRQHandler (void) __attribute__ ((interrupt ("WCH-Interrupt-fast")));
void TIM1_UP_IRQHandler (void) {
    if (TIM_GetITStatus (TIM1, TIM_IT_Update) != RESET) {
        QueryArrNo = 0;
        TIM_Cmd (TIM1, DISABLE);
        TIM_ClearITPendingBit (TIM1, TIM_IT_Update);
    }
}

void TIM2_IRQHandler (void) __attribute__ ((interrupt ("WCH-Interrupt-fast")));
void TIM2_IRQHandler (void) {
    if (TIM_GetITStatus (TIM2, TIM_IT_Update)) {

TIM_ClearITPendingBit (TIM2, TIM_IT_Update);
        TIM_Cmd (TIM2, DISABLE);

}
}

void USART1_IRQHandler (void) __attribute__ ((interrupt ("WCH-Interrupt-fast")));
void USART1_IRQHandler (void) {
    if (USART_GetITStatus (USART1, USART_IT_RXNE) != RESET) {
        Query[QueryArrNo] = USART_ReceiveData (USART1);
        if (QueryArrNo == 0) {
            // TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE);
            TIM_Cmd (TIM1, ENABLE);  }
        if (QueryArrNo >= dfQueryArrNoMax) {
            TIM_Cmd (TIM1, DISABLE);
            // TIM_ITConfig(TIM1, TIM_IT_Update, DISABLE);
            TIM_SetCounter (TIM1, 0);
            TIM_ClearITPendingBit (TIM1, TIM_IT_Update);
            QueryArrQuant = QueryArrNo + 1;
            while (USART_GetFlagStatus (USART1, USART_FLAG_TC) == RESET);
            FgIntMBA = 1;
            QueryArrNo = 0;
        } else {
            ++QueryArrNo;
        }
    }
}

void DMA1_Channel4_IRQHandler (void) __attribute__ ((interrupt ("WCH-Interrupt-fast")));
void DMA1_Channel4_IRQHandler (void) {
    if (DMA_GetITStatus (DMA1_IT_TC4) != RESET) {
        DMA_ClearITPendingBit (DMA1_IT_TC4);
    }
}

void EXTI7_0_IRQHandler (void) __attribute__ ((interrupt ("WCH-Interrupt-fast")));
void EXTI7_0_IRQHandler (void) {
    if (EXTI_GetITStatus (EXTI_Line2) != RESET) {
        HoldingReg[0][1] = 0x00;
        HoldingReg[1][1] = 0x00;
        EXTI_ClearITPendingBit (EXTI_Line2);
    }
}

1 はじめに

1.1 装置開発経緯と概容

1.1.1 制御・設定内容

1.1.2 情報の取得

1.1.3 電源を入れた場合の処理

1.1.4 主な処理

1.1.5 処理速度を早くする処理

1.1.6 エラー処理

1.2 回路

1.2.1 開発時の回路

1.2.2 開発後の確認用回路

1.3 通信速度

1.4 動作確認

2 MODBUSの仕様

2.1 マスター側

2.1.1 フレーム構造

2.1.2 DeviceAddress

2.1.3 Function

2.1.4 DataAddres

2.1.5 Register

2.1.6 CRC

2.2 スレーブ側