第21回 ブレッドボード回路の動作確認

/*
 * BME280温湿度大気圧センサ
 * ATD7410温度センサモジュール
 * LCDモジュール
 * 制御プログラム (試作版)
 * 
 * https://tool-lab.com/
 *
 * 更新
 *   2018. 2.12: 新規作成
 *   2018. 4. 1: 動作周波数を4MHz、I2Cクロック周波数を100kHzに変更
 *   2024. 2. 3: putch関数の引数の型をuint8_tからcharに変更
 * 
 */

//
// PIC16F18857コンィグレーション設定
//
// CONFIG1
#pragma config FEXTOSC = OFF    // External Oscillator mode selection bits (Oscillator not enabled)
#pragma config RSTOSC = HFINT1  // Power-up default value for COSC bits (HFINTOSC (1MHz))
#pragma config CLKOUTEN = OFF   // Clock Out Enable bit (CLKOUT function is disabled; i/o or oscillator function on OSC2)
#pragma config CSWEN = ON       // Clock Switch Enable bit (Writing to NOSC and NDIV is allowed)
#pragma config FCMEN = ON       // Fail-Safe Clock Monitor Enable bit (FSCM timer enabled)
//
// CONFIG2
#pragma config MCLRE = OFF      // Master Clear Enable bit (IO)
#pragma config PWRTE = ON       // Power-up Timer Enable bit (PWRT enabled)
#pragma config LPBOREN = OFF    // Low-Power BOR enable bit (ULPBOR disabled)
#pragma config BOREN = ON       // Brown-out reset enable bits (Brown-out Reset Enabled, SBOREN bit is ignored)
#pragma config BORV = LO        // Brown-out Reset Voltage Selection (Brown-out Reset Voltage (VBOR) set to 1.9V on LF, and 2.45V on F Devices)
#pragma config ZCD = OFF        // Zero-cross detect disable (Zero-cross detect circuit is disabled at POR.)
#pragma config PPS1WAY = ON     // Peripheral Pin Select one-way control (The PPSLOCK bit can be cleared and set only once in software)
#pragma config STVREN = ON      // Stack Overflow/Underflow Reset Enable bit (Stack Overflow or Underflow will cause a reset)
//
// CONFIG3
#pragma config WDTCPS = WDTCPS_31// WDT Period Select bits (Divider ratio 1:65536; software control of WDTPS)
#pragma config WDTE = OFF       // WDT operating mode (WDT Disabled, SWDTEN is ignored)
#pragma config WDTCWS = WDTCWS_7// WDT Window Select bits (window always open (100%); software control; keyed access not required)
#pragma config WDTCCS = SC      // WDT input clock selector (Software Control)
//
// CONFIG4
#pragma config WRT = OFF        // UserNVM self-write protection bits (Write protection off)
#pragma config SCANE = available// Scanner Enable bit (Scanner module is available for use)
#pragma config LVP = ON         // Low Voltage Programming Enable bit (Low Voltage programming enabled. MCLR/Vpp pin function is MCLR.)
//
// CONFIG5
#pragma config CP = OFF         // UserNVM Program memory code protection bit (Program Memory code protection disabled)
#pragma config CPD = OFF        // DataNVM code protection bit (Data EEPROM code protection disabled)

//
// ヘッダファイル
//   int_t型を使用するため、stdint.hをインクルード
//   printfを使用するため、stdio.hをインクルード
//
#include <xc.h>
#include <stdint.h>
#include <stdio.h>


//
// 定数
//

// I2C
#define I2C_ACK  0x00
#define I2C_NACK 0xff

// LCDモジュール
#define LCD_I2C_ADDRESS 0x7c  // LCDモジュールのI2Cアドレス

// ADT7410温度センサ
#define ADT7410_I2C_WRITE_ADDRESS 0x90  // ADT7410のI2Cアドレス(Write)
#define ADT7410_I2C_READ_ADDRESS  0x91  // ADT7410のI2Cアドレス(Read)
#define ADT7410_CONFIG_ADDRESS    0x03  // コンフィグレーション設定アドレス
#define ADT7410_TEMP_ADDRESS      0x00  // 温度格納アドレス(上位8ビット)
#define ADT7410_CONFIG_VALUE      0x80  // 設定値(16-bit分解能指定、他はデフォルト)

// SPIピン設定
#define SPI_SCLK   LATCbits.LATC7
#define SPI_MISO   PORTCbits.RC6
#define SPI_MOSI   LATCbits.LATC5
#define SPI_SS     LATCbits.LATC4



//
// 関数プロトタイプ宣言
//

// LCDモジュール表示制御関数
void lcdInitialize(void);               // LCD初期化
void lcdClearDisplay(void);             // ディスプレイ全消去
void lcdSendCommand(uint8_t);           // コマンド送信
void lcdSendData(uint8_t);              // 1文字表示
void lcdSendString(char *);             // 文字列表示
void lcdLocateCursor(uint8_t,uint8_t);  // カーソル位置指定

// LCDモジュールI2C制御関数
void lcdGenerateI2CData(uint8_t, uint8_t, uint8_t);

// ADT7410温度センサ制御関数
void  adt7410Config(uint8_t);       // 動作設定
float adt7410GetTemperature(void);  // 温度取得

// I2Cプロトコル各信号の生成関数
void    i2cProtocolStart(void);        // スタートビット生成
void    i2cProtocolRepeatStart(void);  // リピートスタートビット生成
void    i2cProtocolStop(void);         // ストップビット生成
void    i2cProtocolSendData(uint8_t);  // 1バイトデータ送信
uint8_t i2cProtocolReceiveData(void);  // バイトデータ受信
uint8_t i2cProtocolAckCheck(void);     // ACK信号チェック
void    i2cProtocolSendAck(void);      // ACK送信
void    i2cProtocolSendNack(void);     // NACK送信

//   BME280センサー制御
void     bme280Initialization(void);
void     bme280ForcedMeasurement(void);
void     bme280ReadoutTrimmingParameters(void);
void     bme280WriteRegister(uint8_t reg_address, uint8_t data);
void     bme280ReadoutMeasuredRawData(void);
int32_t  bme280CompensateTemperature(void);
uint32_t bme280CompensatePressure(void);
uint32_t bme280CompensateHumidity(void);

// SPI通信制御関数
uint16_t spiRead2bytesData(uint8_t reg);
uint8_t  spiRead1ByteData(uint8_t reg);
void     spiWrite8bitSignal(uint8_t data);
uint8_t  spiRead8bitSignal();



// クロック周波数
// __delay_ms()関数が時間基準に使用する
#define _XTAL_FREQ 4000000

// グローバル変数
//
// BME280温湿度・気圧読み取りデータ
uint32_t hum_raw, temp_raw, pres_raw;
int32_t  temp_fine;

// BME280気温補正データ
uint16_t dig_T1;
int16_t  dig_T2;
int16_t  dig_T3;

// BME280湿度補正データ
uint8_t  dig_H1;
int16_t  dig_H2;
uint8_t  dig_H3;
int16_t  dig_H4;
int16_t  dig_H5;
int8_t   dig_H6;

// BME280気圧補正データ
uint16_t dig_P1;
int16_t  dig_P2;
int16_t  dig_P3;
int16_t  dig_P4;
int16_t  dig_P5;
int16_t  dig_P6;
int16_t  dig_P7;
int16_t  dig_P8;
int16_t  dig_P9;


//
// main関数
//
void main(void) {

    // 動作周波数設定
    OSCCON1bits.NOSC = 0b110;   // 内部クロック使用
    OSCCON1bits.NDIV = 0b0000;  // 分周1:1
    OSCFRQbits.HFFRQ = 0b010;   // 4MHz
    
    // ピン属性設定
    ANSELA = 0b00000000;
    ANSELB = 0b00000000;
    ANSELC = 0b00000000;
    TRISA  = 0b00000000;
    TRISB  = 0b00000000;
    TRISC  = 0b01001100;
    
    // SPI信号線初期設定
    SPI_SCLK = 0;
    SPI_MOSI = 0;
    SPI_SS   = 1;

    
    //
    // I2C通信ピンのPPS設定
    //
    // 設定ロック解除
    PPSLOCK = 0x55;
    PPSLOCK = 0xAA;
    PPSLOCKbits.PPSLOCKED = 0x00;

    // SCL, SDAピンの割り当て
    SSP1DATPPSbits.SSP1DATPPS = 0x12;   // RC2をMSSP1:SDA1に設定
    SSP1CLKPPSbits.SSP1CLKPPS = 0x13;   // RC3をMSSP1:SCL1に設定
    RC3PPS = 0x14;   // RC3をMSSP1:SCL1に設定
    RC2PPS = 0x15;   // RC2をMSSP1:SDA1に設定

    // 設定ロック
    PPSLOCK = 0x55;
    PPSLOCK = 0xAA;
    PPSLOCKbits.PPSLOCKED = 0x01;
    
    
    //
    // I2C通信設定
    //
    // SMP Standard Speed; CKE disabled; 
    SSP1STAT = 0x80;
    // SSPEN enabled; CKP Idle:Low, Active:High; SSPM FOSC/4_SSPxADD_I2C; 
    SSP1CON1 = 0x28;
    // SBCDE disabled; BOEN disabled; SCIE disabled; PCIE disabled; DHEN disabled; SDAHT 300ns; AHEN disabled; 
    SSP1CON3 = 0x08;
    // Baud Rate Generator = 100kHz 
    SSP1ADD = 0x09;
    
    // LCDモジュール電源安定化時間待ち
    __delay_ms(100);
    
    // LCD初期化
    lcdInitialize();                    // LCD初期設定
    lcdClearDisplay();
    
    // ADT7410温度センサ初期化
    adt7410Config(ADT7410_CONFIG_VALUE);

    // BME280初期化
    //   コントロールレジスタ、補正係数取得
    bme280Initialization();

    // 実際の温湿度
    //
    // 
    float actual_temp;
    float actual_hum;
    float actual_press;

    // 補正データ
    int32_t  compensated_temp;
    uint32_t compensated_hum;
    uint32_t compensated_press;

    
    //
    while(1){

        //
        lcdLocateCursor(0, 0);
        printf("%3.2f", adt7410GetTemperature());
        lcdSendData(0xdf);
        lcdSendData('C');

        //
        // SPI通信で温湿度センサの値を取得
        bme280ForcedMeasurement();
        bme280ReadoutMeasuredRawData();

        // 取得したデータをキャリブレーション
        compensated_temp  = bme280CompensateTemperature();
        compensated_hum   = bme280CompensateHumidity();
        compensated_press = bme280CompensatePressure();

        // 実際の温湿度に変換
        actual_temp  = (float)compensated_temp  / 100.0;
        actual_hum   = (float)compensated_hum   / 1024.0;
        actual_press = (float)compensated_press / 100.0;

        printf("  %3.0f%%", actual_hum);
        lcdLocateCursor(0, 1);
        printf("%4.2fhPa", actual_press);
        
        //
        LATBbits.LATB0 = 1;
        LATBbits.LATB1 = 1;
        __delay_ms(1000);
        LATBbits.LATB0 = 0;
        LATBbits.LATB1 = 0;
        __delay_ms(1000);
    }

}


//
// ADT7410温度センサ関数
//

// 動作設定
void adt7410Config(uint8_t config_value) {
    
    i2cProtocolStart();                              // スタートビット生成
    i2cProtocolSendData(ADT7410_I2C_WRITE_ADDRESS);  // I2Cアドレス送信
    i2cProtocolSendData(ADT7410_CONFIG_ADDRESS);     // 書き込みアドレス送信
    i2cProtocolSendData(config_value);               // 設定値送信
    i2cProtocolStop();                               // ストップビット生成

}

// 温度取得
float adt7410GetTemperature(void) {
    
    uint8_t temp_high, temp_low;
    int16_t temp_value;
    
    i2cProtocolStart();
    i2cProtocolSendData(ADT7410_I2C_WRITE_ADDRESS);
    i2cProtocolSendData(ADT7410_TEMP_ADDRESS);
    i2cProtocolRepeatStart();
    i2cProtocolSendData(ADT7410_I2C_READ_ADDRESS);
    temp_high = i2cProtocolReceiveData();
    i2cProtocolSendAck();
    temp_low  = i2cProtocolReceiveData();
    i2cProtocolSendNack();
    i2cProtocolStop();
    
    if( temp_high & 0x80 ) {
        temp_value = ( (temp_high & 0x7f) << 8 ) + temp_low - 32768;
    } else {
        temp_value = ( (temp_high & 0x7f) << 8 ) + temp_low;
    }

    return (float)temp_value / 128.0;
    
}



//
// LCD制御関数
//

void putch(char character) {

    lcdSendData(character);

}

//
// LCDモジュールに制御コードまたはデータを送信
//
void lcdGenerateI2CData(uint8_t address, uint8_t control_code, uint8_t data) {
    
    i2cProtocolStart();                 // スタートビット生成
    i2cProtocolSendData(address);       // アドレス送信
    i2cProtocolSendData(control_code);  // 制御コード送信
    i2cProtocolSendData(data);          // データ送信
    i2cProtocolStop();                  // ストップビット生成

    return;
}

//
// 1バイトデータ送信
//   0x40の後にデータを送信
void lcdSendData(uint8_t data){

    // データ送信の場合は制御コードは0x40
    lcdGenerateI2CData(LCD_I2C_ADDRESS, 0x40, data);
    
    // ウエイト
    __delay_us(60);

    return;
}

//
// コマンド送信
//   0x00の後にコマンドを送信
//
void lcdSendCommand(uint8_t command){

    // コマンド送信の場合は制御コードは0x00
    lcdGenerateI2CData(LCD_I2C_ADDRESS, 0x00, command);

    // ウエイト
    __delay_ms(20);
}

//
// ディスプレイ消去
//
void lcdClearDisplay(void){
    
    lcdSendCommand(0x01);

}

//
// カーソル位置移動
//   移動後に文字データを送信するとその位置から表示される
//
void lcdLocateCursor(uint8_t position_x, uint8_t position_y){
    
    uint8_t address;
    
    // Y座標位置のアドレス算出
    switch( position_y ) {
        // 1行目の場合
        case 0:
            address = 0x00 + 0x80;
            break;
        // 2行目の場合
        case 1:
            address = 0x40 + 0x80;
            break;
    }
    
    // X座標位置を加算して表示位置アドレス送信
    lcdSendCommand( address += position_x);
    
    return;
}

//
// 文字列を送信
//
void lcdSendString(char *str){
    
    // strの文字列を*strが0になるまでLCDモジュールに送信
    while(*str) {
        lcdSendData(*str++);
    }
    
    return;
}


//
// LCDモジュール初期化
//
void lcdInitialize(void){

    // 電源が安定するまでの時間待ち
    //__delay_ms(100);
    
    // 初期化コマンド送信
    lcdSendCommand(0x38); // 
    lcdSendCommand(0x39); //
    lcdSendCommand(0x14); //
    lcdSendCommand(0x70); //
    lcdSendCommand(0x56); // 5Vの時は50でOK。3.3Vの場合はBooster=ON、コントラストをあげる
    lcdSendCommand(0x6c); //
    
    // 時間待ち
    __delay_ms(300);
    
    // 初期化コマンド続き
    lcdSendCommand(0x38); //
    lcdSendCommand(0x0c); //
    lcdSendCommand(0x01); //
    // lcdSendCommand(0x06);
    
    return;
}


//
// I2Cプロトコル制御関数
//

// スタートビット生成
void i2cProtocolStart() {
    
    // SSPxCON2レジスタのSENビットを1に設定すると
    // スタートビットが発行される
    // 発行が完了するとSENに0がセットされるので
    // 発行完了までwhile文で待つ
	SSP1CON2bits.SEN = 1;
	while (SSP1CON2bits.SEN) {}

	return;
}

// リスタートビット生成
void i2cProtocolRepeatStart() {
    
	SSP1IF = 0;
	SSP1CON2bits.RSEN = 1;
	while (SSP1CON2bits.RSEN) {}

	return;
}

// ストップビット生成
void i2cProtocolStop() {
    
	SSP1IF = 0;
	SSP1CON2bits.PEN = 1;
	while (SSP1CON2bits.PEN) {}
	SSP1IF = 0;

	return;
}

// 1バイトデータ送信
void i2cProtocolSendData(uint8_t data) {
    
	SSP1IF = 0;
	SSP1BUF = data;
	while (!SSP1IF) {}

	return;
}

// 1バイトデータ受信
uint8_t i2cProtocolReceiveData() {
    
	SSP1IF = 0;
	SSP1CON2bits.RCEN = 1;
	while (SSP1CON2bits.RCEN) {}

	return SSP1BUF;
}

// Ackステータスチェック
uint8_t i2cProtocolAckCheck() {
    
	uint8_t data;

	if (SSP1CON2bits.ACKSTAT) {
		data = I2C_NACK;
	} else {
		data = I2C_ACK;
	}

	return data;
}

// Ack送信
void i2cProtocolSendAck() {
    
    // ACKDTにACKをセット(負論理なので0を設定)
	SSP1CON2bits.ACKDT = 0;

    // NACK信号生成
	SSP1CON2bits.ACKEN = 1;
	while (SSP1CON2bits.ACKEN) {}

	return;
}

// Nack送信
void i2cProtocolSendNack() {
    
    // ACKDTにNACKをセット(負論理なので1を設定)
	SSP1CON2bits.ACKDT = 1;

    // NACK信号生成
	SSP1CON2bits.ACKEN = 1;
	while (SSP1CON2bits.ACKEN) {}

	return;
}



//
// BME280初期化関数
//
void bme280Initialization(void) {

    // 動作パラメータ設定
    uint8_t t_sb    = 0;  // スタンドバイ時間は使用しない
    uint8_t filter  = 0;  // フィルタOFF
    uint8_t spi3or4 = 0;  // SPIは4線式
    uint8_t osrs_t  = 1;  // 温度オーバーサンプリング x1
    uint8_t osrs_p  = 1;  // 大気圧オーバーサンプリング x1
    uint8_t osrs_h  = 1;  // 湿度オーバーサンプリング x1
    uint8_t Mode    = 0;  // 設定後はスリープモードに移行

    // 設定値をフォーマットに合わせる
    uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | Mode;
    uint8_t config_reg    = (t_sb << 5) | (filter << 2) | spi3or4;
    uint8_t ctrl_hum_reg  = osrs_h;

    // BME280動作パラメータ書き込み
    bme280WriteRegister(0xF2, ctrl_hum_reg);
    bme280WriteRegister(0xF4, ctrl_meas_reg);
    bme280WriteRegister(0xF5, config_reg);
    __delay_ms(1000);

    // 補正値読み込み
    //   センサごとに固定ちのため、初期化時のみ読み込む
    bme280ReadoutTrimmingParameters();

}

void bme280ForcedMeasurement(void) {

    // 動作パラメータ設定
    uint8_t t_sb    = 0;  // スタンドバイ時間は使用しない
    uint8_t filter  = 0;  // フィルタOFF
    uint8_t spi3or4 = 0;  // SPIは4線式
    uint8_t osrs_t  = 1;  // 温度オーバーサンプリング x1
    uint8_t osrs_p  = 1;  // 大気圧オーバーサンプリング x1
    uint8_t osrs_h  = 1;  // 湿度オーバーサンプリング x1
    uint8_t Mode    = 1;  // 測定指示

    // 設定値をフォーマットに合わせる
    uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | Mode;
    uint8_t config_reg    = (t_sb << 5) | (filter << 2) | spi3or4;
    uint8_t ctrl_hum_reg  = osrs_h;

    // BME280動作パラメータ書き込み
    bme280WriteRegister(0xF2, ctrl_hum_reg);
    bme280WriteRegister(0xF4, ctrl_meas_reg);
    bme280WriteRegister(0xF5, config_reg);

    // 測定待ち
    //   statusレジスタを監視して測定完了を判断すべきだが
    //   while文での動作ができなかったので時間待ちで代用
    __delay_ms(10);
    
    // この段階でBME280の温湿度大気圧レジスタに測定値が格納されている
    // このあと自動的にスリープモードに入る

}


//
// キャリブレーションデータ読み込み
//
void bme280ReadoutTrimmingParameters(void) {

    // 気温データ
    dig_T1 = spiRead2bytesData(0x88);
    dig_T2 = (int16_t)spiRead2bytesData(0x8A);
    dig_T3 = (int16_t)spiRead2bytesData(0x8C);

    // 気圧データ
    dig_P1 = spiRead2bytesData(0x8E);
    dig_P2 = (int16_t)spiRead2bytesData(0x90);
    dig_P3 = (int16_t)spiRead2bytesData(0x92);
    dig_P4 = (int16_t)spiRead2bytesData(0x94);
    dig_P5 = (int16_t)spiRead2bytesData(0x96);
    dig_P6 = (int16_t)spiRead2bytesData(0x98);
    dig_P7 = (int16_t)spiRead2bytesData(0x9A);
    dig_P8 = (int16_t)spiRead2bytesData(0x9C);
    dig_P9 = (int16_t)spiRead2bytesData(0x9E);

    // 湿度データ
    dig_H1 = spiRead1ByteData(0xA1);
    dig_H2 = (int16_t)spiRead2bytesData(0xE1);
    dig_H3 = spiRead1ByteData(0xE3);
    dig_H4 = (int16_t)((spiRead1ByteData(0xE4) << 4) | (spiRead1ByteData(0xE5) & 0x0F));
    dig_H5 = (int16_t)((spiRead1ByteData(0xE6) << 4) | (spiRead1ByteData(0xE5) >> 4));
    dig_H6 = (int8_t)spiRead1ByteData(0xE7);

}

//
// BME280動作パラメータ設定レジスタ書き込み
//
void bme280WriteRegister(uint8_t reg_address, uint8_t data) {

    // スレーブセレクトアクティブ
    SPI_SS = 0;

    // アドレス指定(書き込みは最上位ビット0)
    spiWrite8bitSignal(reg_address & 0b01111111);

    // データ書き込み
    spiWrite8bitSignal(data);

    // スレーブセレクトインアクティブ
    SPI_SS = 1;
  
}

// 
// 温湿度・気圧データ読み込み
// 
void bme280ReadoutMeasuredRawData() {

    uint32_t data[8];
    uint8_t i;

    // スレーブセレクトアクティブ
    SPI_SS = 0;

    // 読み込み開始アドレス指定
    spiWrite8bitSignal(0xF7 | 0b10000000);
    // データ読み込み
    for(i=0; i<8; i++){
      data[i] = spiRead8bitSignal();
    }

    // スレーブセレクトインアクティブ
    SPI_SS = 0;

    // 読み込みしたデータから気温、湿度、気圧データを生成
    pres_raw = (data[0] << 12) | (data[1] << 4) | (data[2] >> 4); //0xF7, msb+lsb+xlsb=19bit
    temp_raw = (data[3] << 12) | (data[4] << 4) | (data[5] >> 4); //0xFA, msb+lsb+xlsb=19bit
    hum_raw  = (data[6] << 8) | data[7];  //0xFD, msb+lsb=19bit(16:0)

}

//
// 気温キャリブレーション
// 　　BME280データシートの計算プログラム使用
// 
int32_t bme280CompensateTemperature() {
  
    int32_t var1, var2, T;

    var1 = ((((temp_raw >> 3) - ((int32_t)dig_T1<<1))) * ((int32_t)dig_T2)) >> 11;
    var2 = (((((temp_raw >> 4) - ((int32_t)dig_T1)) * ((temp_raw>>4) - ((int32_t)dig_T1))) >> 12) * ((int32_t)dig_T3)) >> 14;
    temp_fine = var1 + var2;
    T = (temp_fine * 5 + 128) >> 8;

    return T; 

}


//
// 気圧キャリブレーション
// 　　BME280データシートの計算プログラム使用
// 
uint32_t bme280CompensatePressure() {

    int32_t var1, var2;
    uint32_t P;

    var1 = (((int32_t)temp_fine)>>1) - (int32_t)64000;
    var2 = (((var1>>2) * (var1>>2)) >> 11) * ((int32_t)dig_P6);
    var2 = var2 + ((var1*((int32_t)dig_P5))<<1);
    var2 = (var2>>2)+(((int32_t)dig_P4)<<16);
    var1 = (((dig_P3 * (((var1>>2)*(var1>>2)) >> 13)) >>3) + ((((int32_t)dig_P2) * var1)>>1))>>18;
    var1 = ((((32768+var1))*((int32_t)dig_P1))>>15);
    if (var1 == 0)
      return 0;

    P = (((uint32_t)(((int32_t)1048576)-pres_raw)-(var2>>12)))*3125;
    if(P<0x80000000)
      P = (P << 1) / ((uint32_t) var1);   
    else
      P = (P / (uint32_t)var1) * 2;

    var1 = (((int32_t)dig_P9) * ((int32_t)(((P>>3) * (P>>3))>>13)))>>12;
    var2 = (((int32_t)(P>>2)) * ((int32_t)dig_P8))>>13;
    P = (uint32_t)((int32_t)P + ((var1 + var2 + dig_P7) >> 4));

    return P;

}

//
// 湿度キャリブレーション
// 　　BME280データシートの計算プログラム使用
// 
uint32_t bme280CompensateHumidity() {

    int32_t v_x1;

    v_x1 = (temp_fine - ((int32_t)76800));
    v_x1 = (((((hum_raw << 14) -(((int32_t)dig_H4) << 20) - (((int32_t)dig_H5) * v_x1)) + 
             ((int32_t)16384)) >> 15) * (((((((v_x1 * ((int32_t)dig_H6)) >> 10) * 
             (((v_x1 * ((int32_t)dig_H3)) >> 11) + ((int32_t) 32768))) >> 10) + ((int32_t)2097152)) * 
             ((int32_t) dig_H2) + 8192) >> 14));
    v_x1 = (v_x1 - (((((v_x1 >> 15) * (v_x1 >> 15)) >> 7) * ((int32_t)dig_H1)) >> 4));
    // v_x1 = (v_x1 < 0 ? 0 : v_x1);
    if( v_x1 < 0 ){
        v_x1 = 0;
    }
    // v_x1 = (v_x1 > 419430400 ? 419430400 : v_x1);
    if( v_x1 > 419430400 ) {
        v_x1 = 419430400;
    }

    return (uint32_t)(v_x1 >> 12);

}


//
// SPIデータを指定アドレスから2バイト読み込み
// 
uint16_t spiRead2bytesData(uint8_t reg) {
  
    uint16_t data1, data2;
    uint16_t data;

    // スレーブセレクトアクティブ
    SPI_SS = 0;

    // 読み込みデータアドレス指定 (読み込みアドレスは最上位ビットを1にする)
    spiWrite8bitSignal(reg | 0b10000000);
    // データを2バイト読み込み
    data1 = spiRead8bitSignal();
    data2 = spiRead8bitSignal();
    //16ビットデータ生成
    data = (data2 << 8) | data1;

    // スレーブセレクトインアクティブ
    SPI_SS = 1;

    return data;

}


//
// SPIデータを指定アドレスから1バイト読み込み
// 
uint8_t spiRead1ByteData(uint8_t reg) {

    uint8_t data;

    SPI_SS = 0;
    spiWrite8bitSignal(reg);
    __delay_us(10);
    data = spiRead8bitSignal();
    SPI_SS = 1;

    return data;

}

//
// SPIデータ8ビット書き込み
// 　　プリミティブな関数であるため
// 　　スレーブセレクト信号はこの関数の前後で制御すること
void spiWrite8bitSignal(uint8_t data) {

    for (int i=7; i>=0; i--) {
      SPI_SCLK = 0;
      if( data & (1<<i) ) {
          SPI_MOSI = 1;
      } else {
          SPI_MOSI = 0;
      }
      SPI_SCLK = 1;
    }

}

//
// SPIデータ8ビット読み込み
// 　　プリミティブな関数であるため
// 　　スレーブセレクト信号はこの関数の前後で制御すること
//
uint8_t spiRead8bitSignal() {

    uint8_t read_data = 0;

    for (int i=7; i>=0; i--) {
      read_data <<= 1;
      SPI_SCLK = 0;
      SPI_MOSI = 0;
      SPI_SCLK = 1;
      if(SPI_MISO){
        read_data |= 1;
      }
    }

    return read_data;

}