#!/usr/bin/python3

"""
Display live sensor values.
"""

import configparser
import time
import serial
import pms_a03
from datetime import datetime
from pathlib import Path

# Methods
# ---------------------------------------------------------------------------
def read_value(sensor):
    """Read a sensor value and store it in the database."""
    # Read the value from the sensor.
    reading = sensor.read()
    now = datetime.utcnow()
    print("{}: pm10: {:8d} pm25: {:8d} pm100: {:8d}".format(now.isoformat(), reading.pm10_cf1, reading.pm25_cf1, reading.pm100_cf1))

def main():
    """The main method"""
    # Access the sensor over the serial line.
    sensor = pms_a03.Sensor("/dev/serial0")
    # Reading sensor data until terminated
    while True:
        read_value(sensor)
        time.sleep(2)

if __name__ == '__main__':
    main()


# EOF

"""
Interface to read from the plantower PMS A003 sensor.
"""

import serial
import time

# Constants
# ---------------------------------------------------------------------------
DEFAULT_SERIAL_PORT = "/dev/serial0"
DEFAULT_READ_TIMEOUT = 2

# Classes
# ---------------------------------------------------------------------------
class SensorReading(object):
    """One single reading."""
    def __init__(self, line):
        self.pm10_cf1 = line[4] * 256 + line[5]
        self.pm25_cf1 = line[6] * 256 + line[7]
        self.pm100_cf1 = line[8] * 256 + line[9]
        self.pm10_std = line[10] * 256 + line[11]
        self.pm25_std = line[12] * 256 + line[13]
        self.pm100_std = line[14] * 256 + line[15]
        self.gr03um = line[16] * 256 + line[17]
        self.gr05um = line[18] * 256 + line[19]
        self.gr10um = line[20] * 256 + line[21]
        self.gr25um = line[22] * 256 + line[23]
        self.gr50um = line[24] * 256 + line[25]
        self.gr100um = line[26] * 256 + line[27]

class SensorException(Exception):
    """Exception if no data can be read."""
    pass

class Sensor(object):
    """The interface class."""
    def __init__(self,
                 port=DEFAULT_SERIAL_PORT,
                 read_timeout=DEFAULT_READ_TIMEOUT):
        self.port = port
        self.read_timeout = read_timeout
        try:
            self.serial =  serial.Serial(port=self.port, baudrate=9600, timeout=1)
        except serial.SerialException as e:
            raise SensorException(str(e))

    def _verify(self, recv):
        """Verify the checksum of the data."""
        calc = 0
        ord_arr = []
        for c in bytearray(recv[:-2]):
            calc += c
            ord_arr.append(c)
        sent = (recv[-2] << 8) | recv[-1]
        if sent != calc:
            raise SensorException("Checksum invalid")

    def read(self):
        """Read a new value from the sensor."""
        recv = b''
        timeout_time = time.monotonic() + self.read_timeout
        self.serial.reset_input_buffer()
        while True:
            inp = self.serial.read(1)
            if inp == '':
                time.sleep(0.1)
                continue
            if inp == b'\x42':
                recv += inp
                inp = self.serial.read(1)
                if inp == b'\x4d':
                    recv += inp
                    recv += self.serial.read(30)
                    break
            if time.monotonic() > timeout_time:
                raise SensorException("No message recieved")
        self._verify(recv)
        return SensorReading(recv)

//
// Read the current values from the MiCS VZ 89TE sensor.
// ---------------------------------------------------------------------------
// (c)2019 by Lucky Resistor. See LICENSE for details.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//

#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/i2c-dev.h>
#include <chrono>
#include <thread>
#include <cstdint>
#include <iostream>


// This code is required, because this sensor has a little bit special
// protocol to access the values.

/// The I2C address of the chip.
///
const uint8_t cChipAddress = 0x70;

/// The device to use.
///
const std::string cDevicePath = "/dev/i2c-1";

/// The delay to wait before the result is read from the sensor.
///
const std::chrono::milliseconds cReadDelay(300);

/// The command.
///
enum class Command : uint8_t {
    SetPPMCO2     = 0b000001000,
    GetStatus     = 0b000001100,
    GetRevision   = 0b000001101,
    GetR0         = 0b000010000
};


/// The file pointer to the I2C device.
///
int i2c_fd = 0;

/// If the command shall display verbose messages.
///
bool isVerbose = false;

/// Open the I2C device.
///
/// @return `true` on success.
///
bool openBus() {
    if (isVerbose) {
        std::cout << "# Open the bus." << std::endl;
    }
    i2c_fd = open(cDevicePath.c_str(), O_RDWR);
    if (i2c_fd < 0) {
        std::cerr << "Failed to open the I2C bus device. Path: " << cDevicePath << std::endl;
        return false;
    }
    if (ioctl(i2c_fd, I2C_SLAVE, cChipAddress) < 0) {
        std::cerr << "Failed to configure the I2C bus device. Error: " << errno << std::endl;
        return false;
    }
    return true;
}

/// Close the I2C device.
///
/// @return `true` on success.
///
bool closeBus() {
    if (isVerbose) {
        std::cout << "# Close the bus." << std::endl;
    }
    close(i2c_fd);
    return true;
}


/// Write data to the I2C bus.
///
/// @param data The data to write.
/// @param size The size of the data to write.
/// @return `true` on success.
///
bool writeData(const uint8_t *data, int size) {
    if (write(i2c_fd, data, size) != size) {
        std::cerr << "Failed to write to the bus. Error: " << errno << std::endl;
        return false;
    }
    return true;
}

/// Read data from the I2C bus.
///
/// @param data The buffer to read data into it.
/// @param size The number of bytes to read.
/// @return `true` on success.
///
bool readData(uint8_t *data, int size) {
    if (read(i2c_fd, data, size) != size) {
        std::cerr << "Failed to read from the bus. Error: " << errno << std::endl;
        return false;
    }
    return true;
}

/// Calculate the checksum for a command.
///
/// @param buffer The buffer to use for calculation.
/// @param size The size of the buffer.
/// @return The calculated checksum.
///
uint8_t getCRC(const uint8_t *buffer, const uint8_t size) {
    uint16_t sum = 0;
    for (uint8_t i=0; i<size; i++) {
        sum += buffer[i];
    }
    uint8_t crc = static_cast<uint8_t>(sum);
    crc += (sum / 0x0100);
    crc = (0xff-crc);
    return crc;
}

/// Write a command to the bus.
///
/// @param cmd The command to send.
/// @param data The data to attach to the command.
/// @return `true` on succes.
///
bool writeCommand(const Command cmd, const uint32_t data = 0) {
    uint8_t buffer[6];
    buffer[0] = static_cast<uint8_t>(cmd);
    buffer[1] = static_cast<uint8_t>(data & 0x000000ffUL);
    buffer[2] = static_cast<uint8_t>((data & 0x0000ff00UL)>>8);
    buffer[3] = static_cast<uint8_t>((data & 0x00ff0000UL)>>16);
    buffer[4] = static_cast<uint8_t>((data & 0xff000000UL)>>24);
    buffer[5] = getCRC(buffer, 5);
    const auto result = writeData(buffer, 6);
    if (!result) {
        std::cerr << "Failed to send a command to the bus." << std::endl;
    }
    return result;
}

/// Read a result from the bus.
///
/// @param data The data to read.
/// @return `true` on success.
///
bool readResult(uint8_t data[7]) {
    if (!readData(data, 7)) {
        return false;
    }
    const uint8_t crc = getCRC(data, 6);
    if (data[6] != crc) {
        std::cerr << "The checksum of the received result is not valid." << std::endl;
        return false;
    }
    return true;
}

/// Get the current values from the sensor.
///
/// @param[out] voc The voc value.
/// @param[out] co2 The co2 value.
/// @return `true` on success.
///
bool getValues(float &voc, float &co2) {
    if (isVerbose) {
        std::cout << "# Reading the current values." << std::endl;
    }
    // Repeat the read three times if necessary.
    for (uint8_t comTry = 0; comTry < 3; ++comTry) {
        if (writeCommand(Command::GetStatus)) {
            std::this_thread::sleep_for(cReadDelay);
            uint8_t data[7];
            if (readResult(data)) {
                if (isVerbose) {
                    const uint32_t rawValue = (static_cast<uint32_t>(data[2])<<16)|(static_cast<uint32_t>(data[3])<<8)|static_cast<uint32_t>(data[2]);
                    std::cout << "# Raw data values: voc=" << static_cast<uint32_t>(data[0])
                        << " co2=" << static_cast<uint32_t>(data[1]) << " raw=" << rawValue << std::endl;
                }
                //voc = static_cast<float>(static_cast<int16_t>(data[0]-13)) * static_cast<float>(1000.0f/229.0f);
                //co2 = (static_cast<float>(static_cast<int16_t>(data[1]-13)) * static_cast<float>(1600.0f/229.0f)) + static_cast<float>(400.0f);
                // Formula supplied by the manufacturer:
                voc = ((data[0] - 13) * (1000 / 229)); 
                co2 = ((data[1] - 13) * (1600 / 229) + 400);
                return true;
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(20));
        }
    }
    std::cerr << "Failed to read the values from the sensor." << std::endl;
    return false;
}


/// Parse the command line parameters.
///
bool parseCommandLine(int argc, char *argv[]) {
    for (int i = 0; i < argc; ++i) {
        const auto arg = std::string(argv[i]);
        if (arg == "-h" || arg == "--help") {
            std::cerr << "Usage: read_mics_vz_89te [-h][-v]" << std::endl;
            std::cerr << " -h|--help   Display this help." << std::endl;
            std::cerr << " -v          Show verbose messages." << std::endl;
            return false;
        } else if (arg == "-v") {
            isVerbose = true;
        }
    }
    return true;
}


int main(int argc, char *argv[]) {
    // Initialize and open the bus.
    if (isVerbose) {
        std::cout << "# Success." << std::endl;
    }
    if (!parseCommandLine(argc, argv)) {
        return 1;
    }
    if (!openBus()) {
        return 1;
    }
    float voc = 0.0f;
    float co2 = 0.0f;
    if (!getValues(voc, co2)) {
        return 1;
    }
    // Output the values as JSON
    std::cout << "{ \"voc\": " << voc << ", \"co2\": " << co2 << " }" << std::endl;
    // Close the bus.
    closeBus();
    // Success
    if (isVerbose) {
        std::cout << "# Success." << std::endl;
    }
    return 0;
}