XBeeでドア開閉センサをつくる　制作編

#include <XBee.h>
#include <Wire.h>
#define SLAVE_ADDRESS 0x21

const uint8_t HIGH_STATE = 1;
const uint8_t LOW_STATE = 0;
const float SUPPLY_VOLT = 3.3;

uint8_t TEMP_PIN = A2;
uint8_t HUMID_PIN = A0;
uint8_t ILL_PIN = A3;
uint8_t MIC_PIN = A1;
uint8_t MOTION_PIN = 12;
uint8_t LED_PIN = 11;

float temp_avg = 0.0;
float humid_avg = 0.0;
float ill_avg = 0.0;
float mic_avg = 0.0;
uint8_t motion_avg = 0;

uint8_t door_e = 0;

// すべてのセンサは、問い合わせ時点から過去1分間の出力値の平均値を返す。
// ただし、モーションセンサについては、平均値が0.2以上なら「人がいた」と判定して1、
// 0.2未満なら「人がいない」と判定して0を返す
const uint8_t SENSOR_LOG_NUM = 60;
float temp_log[SENSOR_LOG_NUM];
float humid_log[SENSOR_LOG_NUM];
float ill_log[SENSOR_LOG_NUM];
float mic_log[SENSOR_LOG_NUM];
float motion_log[SENSOR_LOG_NUM];

// 玄関ドアの開閉状態については、4秒に1回通知されてくる。
// 過去１分間で１回でも"1"が記録されていたら、
// 「ドアが開いた」として1を返す
const uint8_t SENSOR_LOG_DOOR_NUM = 15;
uint8_t door_e_log[SENSOR_LOG_DOOR_NUM];
uint8_t door_e_log_index = 0;

uint8_t loop_count = 0;
byte sendByte;

//—————————————————————–
XBee xbee = XBee();
XBeeResponse response = XBeeResponse();
ZBRxResponse rx = ZBRxResponse();
ZBRxIoSampleResponse rxio = ZBRxIoSampleResponse();
ModemStatusResponse msr = ModemStatusResponse();

const uint32_t XBEE_ADDRESS_LIVING = 0x40CA2F26;
uint8_t receiveXBeeData_living[] = {0,0,0,0,0,0,0,0,0,0};
const uint32_t XBEE_ADDRESS_ENTRANCE = 0x40ADD42D;
//—————————————————————–

float getTemperature() {
    int LM35DZ_Value = analogRead(TEMP_PIN);
    return ((SUPPLY_VOLT * LM35DZ_Value) / 1024) * 100;
}

void updateTemperatureAvg() {
    float sum = 0.0;
    for (uint8_t i = 0; i < SENSOR_LOG_NUM; i++) {
        sum += temp_log[i];
    }
    temp_avg = sum / SENSOR_LOG_NUM;
}

float getHumidity(float temp) {
    int HIH4030_Value = analogRead(HUMID_PIN);
    float voltage = HIH4030_Value / 1024.0 * SUPPLY_VOLT;
    float sensorRH = 161.0 * voltage / SUPPLY_VOLT - 35;
    float trueRH = sensorRH / (1.0546 - 0.00216 * temp);
    return trueRH;
}

void updateHumidityAvg() {
    float sum = 0.0;
    for (uint8_t i = 0; i < SENSOR_LOG_NUM; i++) {
        sum += humid_log[i];
    }
    humid_avg = sum / SENSOR_LOG_NUM;
}

float getIlluminance() {
    int AMS302_Value = analogRead(ILL_PIN);
    float lx = AMS302_Value * (3300.0 / 1024.0) / 1000.0 / (0.26 / 100);
    return lx;
}

void updateIlluminanceAvg() {
    float sum = 0.0;
    for (uint8_t i = 0; i < SENSOR_LOG_NUM; i++) {
        sum += ill_log[i];
    }
    ill_avg = sum / SENSOR_LOG_NUM;
}

float getMic() {
    float ADMP401_Value = analogRead(MIC_PIN);
    return 3.3 * ADMP401_Value / 1024.0;
}

void updateMicAvg() {
    float sum = 0.0;
    for (uint8_t i = 0; i < SENSOR_LOG_NUM; i++) {
        sum += mic_log[i];
    }
    mic_avg = sum / SENSOR_LOG_NUM;
}

void updateMotionAvg() {
    float sum = 0.0;
    motion_avg = 0;

    for (uint8_t i = 0; i < SENSOR_LOG_NUM; i++) {
        sum += motion_log[i];
    }

    float avg = sum / SENSOR_LOG_NUM;

    if (avg >= 0.2) {
        motion_avg = 1;
    }
}

void updateDoorE() {
    door_e = 0;

    for (uint8_t i = 0; i < SENSOR_LOG_DOOR_NUM; i++) {
        if (door_e_log[i] == 1) {
            door_e = 1;
            break;
        }
    }
}

void receiveData(int byteCount) {
    uint8_t i2c_command = -1;

    while (Wire.available()) {
        i2c_command = Wire.read();

        switch (i2c_command) {

            case 0xF0:
                updateTemperatureAvg();
                sendByte = (uint8_t)(int(temp_avg * 100));
                break;

            case 0xF1:
                sendByte = (uint8_t)(int(temp_avg * 100) >> 8);
                break;

            case 0xF2:
                updateHumidityAvg();
                sendByte = (uint8_t)(int(humid_avg * 100));
                break;

            case 0xF3:
                sendByte = (uint8_t)(int(humid_avg * 100) >> 8);
                break;

            case 0xF4:
                updateIlluminanceAvg();
                sendByte = (uint8_t)(int(ill_avg));
                break;

            case 0xF5:
                sendByte = (uint8_t)(int(ill_avg) >> 8);
                break;

            case 0xF6:
                updateMicAvg();
                sendByte = (uint8_t)(int(mic_avg * 100));
                break;

            case 0xF7:
                sendByte = (uint8_t)(int(mic_avg * 100) >> 8);
                break;

            case 0xF8:
                updateMotionAvg();
                sendByte = motion_avg;
                break;

            case 0xF9:
                sendByte = 0;
                break;

            case 0xE0: sendByte = receiveXBeeData_living[0]; break;
            case 0xE1: sendByte = receiveXBeeData_living[1]; break;
            case 0xE2: sendByte = receiveXBeeData_living[2]; break;
            case 0xE3: sendByte = receiveXBeeData_living[3]; break;
            case 0xE4: sendByte = receiveXBeeData_living[4]; break;
            case 0xE5: sendByte = receiveXBeeData_living[5]; break;
            case 0xE6: sendByte = receiveXBeeData_living[6]; break;
            case 0xE7: sendByte = receiveXBeeData_living[7]; break;
            case 0xE8: sendByte = receiveXBeeData_living[8]; break;
            case 0xE9: sendByte = receiveXBeeData_living[9]; break;

            case 0xD0:
                updateDoorE();
                sendByte = door_e;
                break;

            case 0xD1:
                sendByte = 0;
                break;
        }
    }
}

void sendData() {
    Wire.write(sendByte);
}

void setup() {
    // put your setup code here, to run once:
    Serial.begin(57600); // シリアル通信速度
    xbee.begin(Serial);

    pinMode(TEMP_PIN, INPUT);
    pinMode(HUMID_PIN, INPUT);
    pinMode(ILL_PIN, INPUT);
    pinMode(MIC_PIN, INPUT);
    pinMode(MOTION_PIN, INPUT);
    pinMode(LED_PIN, OUTPUT);
    digitalWrite(LED_PIN, LOW);

    Wire.begin(SLAVE_ADDRESS);
    Wire.onReceive(receiveData);
    Wire.onRequest(sendData);

    for (uint8_t i = 0; i < SENSOR_LOG_NUM; i++) {
        temp_log[i] = 0.0;
        humid_log[i] = 0.0;
        ill_log[i] = 0.0;
        mic_log[i] = 0.0;
        motion_log[i] = 0.0;
    }

    //Serial.println("Ready.");
}

void loop() {

    xbee.readPacket();

    if (xbee.getResponse().isAvailable()) {
        // got something
        digitalWrite(LED_PIN, HIGH);
        delay(100);
        digitalWrite(LED_PIN, LOW);
        delay(100);

        if (xbee.getResponse().getApiId() == ZB_RX_RESPONSE) { 
            // APIモードフレームタイプ　0x90: RX受信
            // センサステーションからの受信は、LEDを計３回点滅させる
            digitalWrite(LED_PIN, HIGH);
            delay(100);
            digitalWrite(LED_PIN, LOW);
            delay(100);
            digitalWrite(LED_PIN, HIGH);
            delay(100);
            digitalWrite(LED_PIN, LOW);

            // got a zb rx packet

            // now fill our zb rx class
            xbee.getResponse().getZBRxResponse(rx);

            // どこのXBeeからデータから送られてきたデータか確認
            XBeeAddress64 address64 = rx.getRemoteAddress64();
            uint32_t address64_lsb = address64.getLsb(); 
            // 上位バイトはXBeeで共通なので、下位バイトでアドレスを判断する

            if (address64_lsb == XBEE_ADDRESS_LIVING) {
                // リビングのXBeeから送られてきたデータの場合
                uint8_t payload_length = rx.getDataLength();
                uint8_t* payload = rx.getData();

                for (int i = 0; i < payload_length - 1; i++) {
                    receiveXBeeData_living[i] = payload[i];
                }
            }

            if (rx.getOption() == ZB_PACKET_ACKNOWLEDGED) { 
                // 受信オプション　0x01: パケットには確認応答が返された
                // the sender got an ACK
                //flashLed(statusLed, 10, 10);
            } else {
                // we got it (obviously) but sender didn't get an ACK
                //flashLed(errorLed, 2, 20);
            }

            // set dataLed PWM to value of the first byte in the data
            //analogWrite(dataLed, rx.getData(0));

        } else if (xbee.getResponse().getApiId() == ZB_IO_SAMPLE_RESPONSE) { 
            // APIモードフレームタイプ　0x92: 入出力データサンプル受信通知
            // 玄関のXBeeからの受信は、LEDを計２回点滅させる

            digitalWrite(LED_PIN, HIGH);
            delay(100);
            digitalWrite(LED_PIN, LOW);

            xbee.getResponse().getZBRxIoSampleResponse(rxio);

            // どこのXBeeからデータから送られてきたデータか確認
            XBeeAddress64 address64 = rxio.getRemoteAddress64();
            uint32_t address64_lsb = address64.getLsb(); 
            // 上位バイトはXBeeで共通なので、下位バイトでアドレスを判断する

            if (address64_lsb == XBEE_ADDRESS_ENTRANCE) {
                // 玄関のXBeeから送られてきたデータの場合

                if (rxio.isDigitalEnabled(4)) { 
                    // ドアの開閉情報はDIO4を利用しているため

                    if (door_e_log_index == SENSOR_LOG_DOOR_NUM) {
                        door_e_log_index = 0;
                    }

                    door_e_log[door_e_log_index] = (uint8_t)rxio.isDigitalOn(4);
                    door_e_log_index++;
                }
            }

        } else if (xbee.getResponse().getApiId() == MODEM_STATUS_RESPONSE) { 
            // APIモードフレームタイプ　0x8a: モデムステータス

            xbee.getResponse().getModemStatusResponse(msr);
            // the local XBee sends this response on certain events, like association/dissociation

            if (msr.getStatus() == ASSOCIATED) {
                // yay this is great. flash led
                //flashLed(statusLed, 10, 10);

            } else if (msr.getStatus() == DISASSOCIATED) {
                // this is awful.. flash led to show our discontent
                //flashLed(errorLed, 10, 10);

            } else {
                // another status
                //flashLed(statusLed, 5, 10);
            }

        } else {
            // not something we were expecting
            //flashLed(errorLed, 1, 25);
        }

    } else if (xbee.getResponse().isError()) {
        //nss.print("Error reading packet. Error code: ");
        //nss.println(xbee.getResponse().getErrorCode());
    }

    if (loop_count == SENSOR_LOG_NUM) {
        loop_count = 0;
    }

    temp_log[loop_count] = getTemperature();
    humid_log[loop_count] = getHumidity(temp_log[loop_count]);
    ill_log[loop_count] = getIlluminance();
    mic_log[loop_count] = getMic();
    motion_log[loop_count] = (float)digitalRead(MOTION_PIN);

    loop_count++;

    delay(1000);
}