Indoor multi-screen air quality measurement

# Infineon XENSIV PAS CO2 sensor driver for MicroPython

from machine import I2C
from utime import sleep, sleep_ms

# Sensor Register Address Stack
_PASCO2_REG_SENS_STS    = const(0x01)  # Sensor status register address
_PASCO2_REG_MEAS_RATE_H = const(0x02)  # Measurement period MSB configuration register address
_PASCO2_REG_MEAS_CFG    = const(0x04)  # Measurement mode configuration register address
_PASCO2_REG_CO2PPM_H    = const(0x05)  # CO2 concentration result MSB register address
_PASCO2_REG_MEAS_STS    = const(0x07)  # Measurement status register address
_PASCO2_REG_SENS_RST    = const(0x10)  # Soft reset register address
_PASCO2_REG_PROD_ID     = const(0x00)  # Product and revision ID register address

# Error codes
_PASCO2_SUCCESS = 0
_PASCO2_ERROR = -1

addr = 0
mask = 1


class PASCO2:
    """IFX - XENSIV PAS CO2 sensor driver"""

    # RegAddr, Mask, <Later extend with register access type, bit position etc.>
    regMap = {
        "REG_SENS_STS_BITF_SENS_RDY" : [_PASCO2_REG_SENS_STS, 0x80],  # Sensor status bit
        "REG_MEAS_CFG_BITF_OP_MODE"  : [_PASCO2_REG_MEAS_CFG, 0x03],  # Operation Mode type bit
        "REG_MEAS_STS_BITF_DATA_RDY" : [_PASCO2_REG_MEAS_STS, 0x10],  # Data ready status bit
        "REG_CO2PPM_H_BITF_CO2_PPM_H": [_PASCO2_REG_CO2PPM_H, 0xFF],  # Stored CO2 value bit
        "REG_PROD_ID_BITF_PROD"      : [_PASCO2_REG_PROD_ID, 0xE0],   # Product id bit
        "REG_PROD_ID_BITF_REV"       : [_PASCO2_REG_PROD_ID, 0x1F],   # Revision id bit
    }

    def __init__(self, bus, measInterval=10, sensorAddr=0x28):
        """ " Intialize the sensor and required dependencies"""
        self.bus = bus
        self.sensorAddr = sensorAddr
        self.measInterval = measInterval
        self.softResetCode = b"\xa3"

    def _read_reg(self, regAddr, bytesToRead=1):
        """Internal function to read data from the sensor register and returns it raw"""
        readVal = self.bus.readfrom_mem(self.sensorAddr, regAddr, bytesToRead)
        return readVal

    def _write_reg(self, regAddr, writeData):
        """Internal function to write data to sensor register"""
        self.bus.writeto_mem(self.sensorAddr, regAddr, writeData)

    def _is_sensor_ready(self):
        """Helper function to check the sensor status"""
        reg = self.regMap["REG_SENS_STS_BITF_SENS_RDY"]
        return self._read_reg(reg[addr])[0] & reg[mask]

    def _soft_reset(self):
        """Helper function to perform soft reset of the sensor"""
        self._write_reg(_PASCO2_REG_SENS_RST, self.softResetCode)

    def _set_mode(self, mode):
        """Helper function to set the mode of sensor. Currently supported modes:
        1. Idle
        2. Continuous
        """
        if mode == "idle":
            modeVal = 0x00
        if mode == "continuous":
            modeVal = 0x02

        reg = self.regMap["REG_MEAS_CFG_BITF_OP_MODE"]
        readData = self._read_reg(reg[addr])[0]
        writeData = bytes([(readData & ~(reg[mask])) | modeVal])
        self._write_reg(_PASCO2_REG_MEAS_CFG, writeData)

    def initialize(self):
        """Public function to initialize the sensor"""
        try:
            # wait for sensor to be ready
            sensor_ready = self._is_sensor_ready()
            while not sensor_ready:
                sleep(1)
                sensor_ready = self._is_sensor_ready()

            # soft reset sensor register
            self._soft_reset()
            sleep_ms(800)

            # set measure rate
            buf = bytes([(self.measInterval >> 8) & 0xFF, self.measInterval & 0xFF])
            self._write_reg(_PASCO2_REG_MEAS_RATE_H, buf)

            # reset operation mode to idle mode
            self._set_mode("idle")

            # start continuous mode
            self._set_mode("continuous")

            return _PASCO2_SUCCESS

        except:
            return _PASCO2_ERROR

    def get_co2_value(self):
        """Public function to get the CO2 value"""
        while True:
            try:
                # get meas status
                reg = self.regMap["REG_MEAS_STS_BITF_DATA_RDY"]
                readStatus = self._read_reg(reg[addr])
                data_ready = readStatus[0] & reg[mask]

                if data_ready:
                    # get CO2 value
                    reg = self.regMap["REG_CO2PPM_H_BITF_CO2_PPM_H"]
                    readVal = self._read_reg(reg[addr], 2)
                    co2_value = (readVal[0] << 8) | readVal[1]
                    return co2_value
            except:
                return _PASCO2_ERROR

    def get_prod_id(self):
        """Public function to get the sensor product id"""
        try:
            reg = self.regMap["REG_PROD_ID_BITF_PROD"]
            readID = (self._read_reg(reg[addr])[0] & 0xE0) >> 5
            return readID

        except:
            return _PASCO2_ERROR

    def get_rev_id(self):
        """Public function to get the sensor revision id"""
        try:
            reg = self.regMap["REG_PROD_ID_BITF_REV"]
            readID = (self._read_reg(reg[addr])[0] & 0x1F) >> 0
            return readID

        except:
            return _PASCO2_ERROR

"""
MicroPython Nokia 5110 PCD8544 84x48 LCD driver
https://github.com/mcauser/micropython-pcd8544

MIT License
Copyright (c) 2016-2018 Mike Causer

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""

from micropython import const
from ustruct     import pack
from utime       import sleep_us

# Function set 0010 0xxx
FUNCTION_SET     = const(0x20)
POWER_DOWN       = const(0x04)
ADDRESSING_VERT  = const(0x02)
EXTENDED_INSTR   = const(0x01)

# Display control 0000 1x0x
DISPLAY_BLANK    = const(0x08)
DISPLAY_ALL      = const(0x09)
DISPLAY_NORMAL   = const(0x0c)
DISPLAY_INVERSE  = const(0x0d)

# Temperature control 0000 01xx
TEMP_COEFF_0     = const(0x04)
TEMP_COEFF_1     = const(0x05)
TEMP_COEFF_2     = const(0x06) # default
TEMP_COEFF_3     = const(0x07)

# Bias system 0001 0xxx
BIAS_1_100       = const(0x10)
BIAS_1_80        = const(0x11)
BIAS_1_65        = const(0x12)
BIAS_1_48        = const(0x13)
BIAS_1_40        = const(0x14) # default
BIAS_1_24        = const(0x15)
BIAS_1_18        = const(0x16)
BIAS_1_10        = const(0x17)

# Set operation voltage
SET_VOP          = const(0x80)

# DDRAM addresses
COL_ADDR         = const(0x80) # x pos (0~83)
BANK_ADDR        = const(0x40) # y pos, in banks of 8 rows (0~5)

class PCD8544:
#	def __init__(self, spi, cs, dc, rst=None):
#	def __init__(self, spi, cs, dc):        
    def __init__(self, spi, dc):   
        self.width  = 84
        self.height = 48

        self.spi    = spi
#		self.cs     = cs   # chip enable, active LOW
        self.dc     = dc   # data HIGH, command LOW
#		self.rst    = rst  # reset, active LOW

#		self.cs.init(self.cs.OUT, value=1)
        self.dc.init(self.dc.OUT, value=0)

#		if self.rst:
#			self.rst.init(self.rst.OUT, value=1)
#		self.reset()
#		self.init()

    def init(self, horizontal=True, contrast=0x3f, bias=BIAS_1_40, temp=TEMP_COEFF_2):
		# power up, horizontal addressing, basic instruction set
        self.fn = FUNCTION_SET

		# switch to vertical addressing
        if not horizontal:
            self.fn |= ADDRESSING_VERT

        self.contrast(contrast, bias, temp)
        self.cmd(DISPLAY_NORMAL)
        self.clear()

#	def reset(self):
		# issue reset impulse to reset the display
#		self.rst(1)
#		sleep_us(100)
#		self.rst(0)
#		sleep_us(100) # reset impulse has to be >100 ns and <100 ms
#		self.rst(1)
#		sleep_us(100)

    def power_on(self):
#		self.cs(1)
        self.fn &= ~POWER_DOWN
        self.cmd(self.fn)

    def power_off(self):
        self.fn |= POWER_DOWN
        self.cmd(self.fn)

    def contrast(self, contrast=0x3f, bias=BIAS_1_40, temp=TEMP_COEFF_2):
        for cmd in (
			# extended instruction set is required to set temp, bias and vop
            self.fn | EXTENDED_INSTR,
			# set temperature coefficient
            temp,
			# set bias system (n=3 recommended mux rate 1:40/1:34)
            bias,
			# set contrast with operating voltage (0x00~0x7f)
			# 0x00 = 3.00V, 0x3f = 6.84V, 0x7f = 10.68V
			# starting at 3.06V, each bit increments voltage by 0.06V at room temperature
            SET_VOP | contrast,
			# revert to basic instruction set
            self.fn & ~EXTENDED_INSTR):
            self.cmd(cmd)

    def invert(self, invert):
        self.cmd(DISPLAY_INVERSE if invert else DISPLAY_NORMAL)

    def clear(self):
		# clear DDRAM, reset x,y position to 0,0
        self.data([0] * (self.height * self.width // 8))
        self.position(0, 0)

    def position(self, x, y):
		# set cursor to column x (0~83), bank y (0~5)
        self.cmd(COL_ADDR | x) # set x pos (0~83)
        self.cmd(BANK_ADDR | y) # set y pos (0~5)

    def cmd(self, command):
        self.dc(0)
#		self.cs(0)
        self.spi.write(bytearray([command]))
#		self.cs(1)

    def data(self, data):
        self.dc(1)
#		self.cs(0)
        self.spi.write(pack('B'*len(data), *data))
#		self.cs(1)

# Authors: Paul Cunnane 2016, Peter Dahlebrg 2016
#
# This module borrows from the Adafruit BME280 Python library. Original
# Copyright notices are reproduced below.
#
# Those libraries were written for the Raspberry Pi. This modification is
# intended for the MicroPython and esp8266 boards.
#
# Copyright (c) 2014 Adafruit Industries
# Author: Tony DiCola
#
# Based on the BMP280 driver with BME280 changes provided by
# David J Taylor, Edinburgh (www.satsignal.eu)
#
# Based on Adafruit_I2C.py created by Kevin Townsend.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.


import time
from ustruct import unpack, unpack_from
from array import array

# BME280 default address.
BME280_I2CADDR = 0x76

# Operating Modes
BME280_OSAMPLE_1 = 1
BME280_OSAMPLE_2 = 2
BME280_OSAMPLE_4 = 3
BME280_OSAMPLE_8 = 4
BME280_OSAMPLE_16 = 5

BME280_REGISTER_CONTROL_HUM = 0xF2
BME280_REGISTER_CONTROL = 0xF4


class BME280:

    def __init__(self,
                 mode=BME280_OSAMPLE_1,
                 address=BME280_I2CADDR,
                 i2c=None,
                 **kwargs):
        # Check that mode is valid.
        if mode not in [BME280_OSAMPLE_1, BME280_OSAMPLE_2, BME280_OSAMPLE_4,
                        BME280_OSAMPLE_8, BME280_OSAMPLE_16]:
            raise ValueError(
                'Unexpected mode value {0}. Set mode to one of '
                'BME280_ULTRALOWPOWER, BME280_STANDARD, BME280_HIGHRES, or '
                'BME280_ULTRAHIGHRES'.format(mode))
        self._mode = mode
        self.address = address
        if i2c is None:
            raise ValueError('An I2C object is required.')
        self.i2c = i2c

        # load calibration data
        dig_88_a1 = self.i2c.readfrom_mem(self.address, 0x88, 26)
        dig_e1_e7 = self.i2c.readfrom_mem(self.address, 0xE1, 7)
        self.dig_T1, self.dig_T2, self.dig_T3, self.dig_P1, \
            self.dig_P2, self.dig_P3, self.dig_P4, self.dig_P5, \
            self.dig_P6, self.dig_P7, self.dig_P8, self.dig_P9, \
            _, self.dig_H1 = unpack("<HhhHhhhhhhhhBB", dig_88_a1)

        self.dig_H2, self.dig_H3 = unpack("<hB", dig_e1_e7)
        e4_sign = unpack_from("<b", dig_e1_e7, 3)[0]
        self.dig_H4 = (e4_sign << 4) | (dig_e1_e7[4] & 0xF)

        e6_sign = unpack_from("<b", dig_e1_e7, 5)[0]
        self.dig_H5 = (e6_sign << 4) | (dig_e1_e7[4] >> 4)

        self.dig_H6 = unpack_from("<b", dig_e1_e7, 6)[0]

        self.i2c.writeto_mem(self.address, BME280_REGISTER_CONTROL,
                             bytearray([0x3F]))
        self.t_fine = 0

        # temporary data holders which stay allocated
        self._l1_barray = bytearray(1)
        self._l8_barray = bytearray(8)
        self._l3_resultarray = array("i", [0, 0, 0])

    def read_raw_data(self, result):
        """ Reads the raw (uncompensated) data from the sensor.

            Args:
                result: array of length 3 or alike where the result will be
                stored, in temperature, pressure, humidity order
            Returns:
                None
        """

        self._l1_barray[0] = self._mode
        self.i2c.writeto_mem(self.address, BME280_REGISTER_CONTROL_HUM,
                             self._l1_barray)
        self._l1_barray[0] = self._mode << 5 | self._mode << 2 | 1
        self.i2c.writeto_mem(self.address, BME280_REGISTER_CONTROL,
                             self._l1_barray)

        sleep_time = 1250 + 2300 * (1 << self._mode)
        sleep_time = sleep_time + 2300 * (1 << self._mode) + 575
        sleep_time = sleep_time + 2300 * (1 << self._mode) + 575
        time.sleep_us(sleep_time)  # Wait the required time

        # burst readout from 0xF7 to 0xFE, recommended by datasheet
        self.i2c.readfrom_mem_into(self.address, 0xF7, self._l8_barray)
        readout = self._l8_barray
        # pressure(0xF7): ((msb << 16) | (lsb << 8) | xlsb) >> 4
        raw_press = ((readout[0] << 16) | (readout[1] << 8) | readout[2]) >> 4
        # temperature(0xFA): ((msb << 16) | (lsb << 8) | xlsb) >> 4
        raw_temp = ((readout[3] << 16) | (readout[4] << 8) | readout[5]) >> 4
        # humidity(0xFD): (msb << 8) | lsb
        raw_hum = (readout[6] << 8) | readout[7]

        result[0] = raw_temp
        result[1] = raw_press
        result[2] = raw_hum

    def read_compensated_data(self, result=None):
        """ Reads the data from the sensor and returns the compensated data.

            Args:
                result: array of length 3 or alike where the result will be
                stored, in temperature, pressure, humidity order. You may use
                this to read out the sensor without allocating heap memory

            Returns:
                array with temperature, pressure, humidity. Will be the one from
                the result parameter if not None
        """
        self.read_raw_data(self._l3_resultarray)
        raw_temp, raw_press, raw_hum = self._l3_resultarray
        # temperature
        var1 = ((raw_temp >> 3) - (self.dig_T1 << 1)) * (self.dig_T2 >> 11)
        var2 = (((((raw_temp >> 4) - self.dig_T1) *
                  ((raw_temp >> 4) - self.dig_T1)) >> 12) * self.dig_T3) >> 14
        self.t_fine = var1 + var2
        temp = (self.t_fine * 5 + 128) >> 8

        # pressure
        var1 = self.t_fine - 128000
        var2 = var1 * var1 * self.dig_P6
        var2 = var2 + ((var1 * self.dig_P5) << 17)
        var2 = var2 + (self.dig_P4 << 35)
        var1 = (((var1 * var1 * self.dig_P3) >> 8) +
                ((var1 * self.dig_P2) << 12))
        var1 = (((1 << 47) + var1) * self.dig_P1) >> 33
        if var1 == 0:
            pressure = 0
        else:
            p = 1048576 - raw_press
            p = (((p << 31) - var2) * 3125) // var1
            var1 = (self.dig_P9 * (p >> 13) * (p >> 13)) >> 25
            var2 = (self.dig_P8 * p) >> 19
            pressure = ((p + var1 + var2) >> 8) + (self.dig_P7 << 4)

        # humidity
        h = self.t_fine - 76800
        h = (((((raw_hum << 14) - (self.dig_H4 << 20) -
                (self.dig_H5 * h)) + 16384)
              >> 15) * (((((((h * self.dig_H6) >> 10) *
                            (((h * self.dig_H3) >> 11) + 32768)) >> 10) +
                          2097152) * self.dig_H2 + 8192) >> 14))
        h = h - (((((h >> 15) * (h >> 15)) >> 7) * self.dig_H1) >> 4)
        h = 0 if h < 0 else h
        h = 419430400 if h > 419430400 else h
        humidity = h >> 12

        if result:
            result[0] = temp
            result[1] = pressure
            result[2] = humidity
            return result

        return array("i", (temp, pressure, humidity))

    @property
    def values(self):
        """ human readable values """

        t, p, h = self.read_compensated_data()

        p = p // 256
        pi = p // 100
        pd = p - pi * 100

        hi = h // 1024
        hd = h * 100 // 1024 - hi * 100
        return ("{}C".format(t / 100), "{}.{:02d}hPa".format(pi, pd),
                "{}.{:02d}%".format(hi, hd))

#source code is from here:
# https://www.instructables.com/Pi-Pico-Real-Time-Clock-DS3231-Workout/
# file name is: ds3231Modifies.py
#then I saved the most part (initialization and read/write) into a device library


#!/usr/bin/python
# -*- coding: utf-8 -*-
from machine import Pin, I2C
import utime
import binascii


#    the new version use i2c0,if it dont work,try to uncomment the line 14 and comment line 17
#    it should solder the R3 with 0R resistor if want to use alarm function,please refer to the Sch file on waveshare Pico-RTC-DS3231 wiki
#    https://www.waveshare.net/w/upload/0/08/Pico-RTC-DS3231_Sch.pdf
#I2C_PORT = 0
#I2C_SDA = 0
#I2C_SCL = 1

#i2c = I2C(0, sda = Pin(0), scl = Pin(1), freq = 100000)

ALARM_PIN = 3


class ds3231(object):
#            13:45:00 Mon 24 May 2021
#  the register value is the binary-coded decimal (BCD) format
#               sec min hour week day month year
    NowTime = b'\x00\x45\x13\x02\x24\x05\x21'
    w  = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];
    address = 0x68
    start_reg = 0x00
    alarm1_reg = 0x07
    control_reg = 0x0e
    status_reg = 0x0f


#    def __init__(self,i2c_port,i2c_scl,i2c_sda, i2c=None):
    def __init__(self,i2c=None):
#        print("Port: ", i2c_port)
#        print("I2C SCL: ", i2c_scl)
#        print("I2C SDA: ", i2c_sda)
#        self.bus = I2C(i2c_port,scl=Pin(i2c_scl),sda=Pin(i2c_sda))
#        self.bus = I2C(i2c_port,scl=i2c_scl,sda=i2c_sda)
        self.bus = i2c

    def set_time(self,new_time):
        hour = new_time[0] + new_time[1]
        minute = new_time[3] + new_time[4]
        second = new_time[6] + new_time[7]
        week = "0" + str(self.w.index(new_time.split(",",2)[1])+1)
        year = new_time.split(",",2)[2][2] + new_time.split(",",2)[2][3]
        month = new_time.split(",",2)[2][5] + new_time.split(",",2)[2][6]
        day = new_time.split(",",2)[2][8] + new_time.split(",",2)[2][9]
        now_time = binascii.unhexlify((second + " " + minute + " " + hour + " " + week + " " + day + " " + month + " " + year).replace(' ',''))
        #print(binascii.unhexlify((second + " " + minute + " " + hour + " " + week + " " + day + " " + month + " " + year).replace(' ','')))
        #print(self.NowTime)
        self.bus.writeto_mem(int(self.address),int(self.start_reg),now_time)
    
    def read_time(self):
        t = self.bus.readfrom_mem(int(self.address),int(self.start_reg),7)
        a = t[0]&0x7F  #second
        b = t[1]&0x7F  #minute
        c = t[2]&0x3F  #hour
        d = t[3]&0x07  #week
        e = t[4]&0x3F  #day
        f = t[5]&0x1F  #month
#        print("20%x/%02x/%02x %02x:%02x:%02x %s" %(t[6],t[5],t[4],t[2],t[1],t[0],self.w[t[3]-1]))
        
    def year(self):
        t = self.bus.readfrom_mem(int(self.address),int(self.start_reg),7)
        hi = int((t[6]&0x70)/16) * 10
        lo = t[6]&0x0F
        return hi + lo
        
    def sec(self):
        t = self.bus.readfrom_mem(int(self.address),int(self.start_reg),7)
        hi = int((t[0]&0x70)/16) * 10
        lo = t[0]&0x0F
        return hi + lo
    
    def minute(self):
        t = self.bus.readfrom_mem(int(self.address),int(self.start_reg),7)
        hi = int((t[1]&0x70)/16) * 10
        lo = t[1]&0x0F
        return hi + lo
    
    def hour(self):
        t = self.bus.readfrom_mem(int(self.address),int(self.start_reg),7)
        hi = int((t[2]&0x30)/16) * 10
        lo = t[2]&0x0F
        return hi + lo
    
    def week(self):
        t = self.bus.readfrom_mem(int(self.address),int(self.start_reg),7)
        lo = t[3]&0x07
        return lo
    
    def day(self):
        t = self.bus.readfrom_mem(int(self.address),int(self.start_reg),7)
        hi = int((t[4]&0x30)/16) * 10
        lo = t[4]&0x0F
        return hi + lo
    
    def month(self):
        t = self.bus.readfrom_mem(int(self.address),int(self.start_reg),7)
        hi = int((t[5]&0x10)/16) * 10
        lo = t[5]&0x0F
        return hi + lo
    
    def day_name(self):
        t = self.bus.readfrom_mem(int(self.address),int(self.start_reg),7)
        return(self.w[t[3]-1])
    
    def set_alarm_time(self,alarm_time):
        #    init the alarm pin
        self.alarm_pin = Pin(ALARM_PIN,Pin.IN,Pin.PULL_UP)
        #    set alarm irq
        self.alarm_pin.irq(lambda pin: print("alarm1 time is up"), Pin.IRQ_FALLING)
        #    enable the alarm1 reg
        self.bus.writeto_mem(int(self.address),int(self.control_reg),b'\x05')
        #    convert to the BCD format
        hour = alarm_time[0] + alarm_time[1]
        minute = alarm_time[3] + alarm_time[4]
        second = alarm_time[6] + alarm_time[7]
        date = alarm_time.split(",",2)[2][8] + alarm_time.split(",",2)[2][9]
        now_time = binascii.unhexlify((second + " " + minute + " " + hour +  " " + date).replace(' ',''))
        #    write alarm time to alarm1 reg
        self.bus.writeto_mem(int(self.address),int(self.alarm1_reg),now_time)
        
    def temperature(self):
        t = self.bus.readfrom_mem(int(self.address),int(self.start_reg),19)
        whole = t[17]&0xFF        
#modificare sa afiseje doar partea intreaga a temperaturii,  nu si cea zecimala:
#        decimal = ((t[18]& 192)/64) *0.25
        temp = whole # + decimal
        if (t[17]&0xFF) > 127:
            temp = temp * -1
        return temp

##########################################################################
# All the reading and writing procedures:
##########################################################################
#Initialisation of RTC reading:    
#rtc = ds3231(I2C_PORT,I2C_SCL,I2C_SDA)
#set RTC data:
#rtc.set_time('15:19:0,Tuesday,2023-08-3')

#rtc.set_alarm_time('13:34:15,Monday,2021-05-24')

#for reading and displaying data:
#    rtc.read_time()
#rtc.set_alarm_time('13:34:15,Monday,2021-05-24')
#    print(rtc.sec())
#    print(rtc.minute())
#    print(rtc.hour())
#    print(rtc.week())
#    print(rtc.day())
#    print(rtc.year())
#    print(rtc.month())
#    print(rtc.day_name())
#    print(rtc.temperature())
#    utime.sleep(1)
    

# SPDX-FileCopyrightText: Copyright (c) 2023 Jose D. Montoya
#
# SPDX-License-Identifier: MIT
"""
`i2c_helpers`
================================================================================

I2C Communications helpers


* Author(s): Jose D. Montoya

Based on
* adafruit_register.i2c_struct. Author(s): Scott Shawcroft
* adafruit_register.i2c_bits.  Author(s): Scott Shawcroft

MIT License

Copyright (c) 2016 Adafruit Industries

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

"""
# pylint: disable=too-many-arguments
import struct


class CBits:
    """
    Changes bits from a byte register
    """

    def __init__(
        self,
        num_bits: int,
        register_address: int,
        start_bit: int,
        register_width=1,
        lsb_first=True,
    ) -> None:
        self.bit_mask = ((1 << num_bits) - 1) << start_bit
        self.register = register_address
        self.star_bit = start_bit
        self.lenght = register_width
        self.lsb_first = lsb_first

    def __get__(
        self,
        obj,
        objtype=None,
    ) -> int:
        mem_value = obj._i2c.readfrom_mem(obj._address, self.register, self.lenght)

        reg = 0
        order = range(len(mem_value) - 1, -1, -1)
        if not self.lsb_first:
            order = reversed(order)
        for i in order:
            reg = (reg << 8) | mem_value[i]

        reg = (reg & self.bit_mask) >> self.star_bit

        return reg

    def __set__(self, obj, value: int) -> None:
        memory_value = obj._i2c.readfrom_mem(obj._address, self.register, self.lenght)

        reg = 0
        order = range(len(memory_value) - 1, -1, -1)
        if not self.lsb_first:
            order = range(0, len(memory_value))
        for i in order:
            reg = (reg << 8) | memory_value[i]
        reg &= ~self.bit_mask

        value <<= self.star_bit
        reg |= value
        reg = reg.to_bytes(self.lenght, "big")

        obj._i2c.writeto_mem(obj._address, self.register, reg)


class RegisterStruct:
    """
    Register Struct
    """

    def __init__(self, register_address: int, form: str) -> None:
        self.format = form
        self.register = register_address
        self.lenght = struct.calcsize(form)

    def __get__(
        self,
        obj,
        objtype=None,
    ):
        if self.lenght <= 2:
            value = struct.unpack(
                self.format,
                memoryview(
                    obj._i2c.readfrom_mem(obj._address, self.register, self.lenght)
                ),
            )[0]
        else:
            value = struct.unpack(
                self.format,
                memoryview(
                    obj._i2c.readfrom_mem(obj._address, self.register, self.lenght)
                ),
            )
        return value

    def __set__(self, obj, value):
        mem_value = struct.pack(self.format, value)
        obj._i2c.writeto_mem(obj._address, self.register, mem_value)


def twos_complement(val: int, bits: int) -> int:
    """
    Two complements
    """
    if val & (1 << (bits - 1)):
        val -= 1 << bits

    return val

#Statie pentru masurarea calitatii aerului la interior
import socket
import network
import time
import utime as time

from machine import I2C
from machine import Pin

from utime import sleep_us
from time  import sleep

from A_Definitions import *
from B_Backlight import *
from C_Display_small_big_numbers import *
from E_Display_text_fix import *
from F_Web_site import *

from bme280 import BME280
from ds3231 import ds3231
from lib    import dps310
import pasco2 as sensor

#constant used to calcul the relative altitude with BME280 sensor:
pressure_sea_level=1013.25

#configure I2C interface between sensord and PSoC6:
i2c = I2C(0, scl='P6_0', sda='P6_1', freq=100000)
#configure I2C for BME280:
bme = BME280(i2c = i2c)
#configure I2C for DS3231 RTC:
rtc = ds3231(i2c = i2c)
#configure I2C for DPS310 sensor (used with DPS 368 sensor):
dps = dps310.DPS310(i2c)
#configure I2C for PAS CO2 sensor:
bus = i2c
pasco2 = sensor.PASCO2(bus)
init_status = pasco2.initialize()

num = None #variable used for display results on LCD Nokia 5110

#74HC595: set pins to output PIN objects for reset all 74HC505:
ResetPin_b = Pin('P6_2', Pin.OUT, None, value=Pin.STATE_HIGH)
ResetPin_d = Pin('P8_0', Pin.OUT, None, value=Pin.STATE_HIGH)

### Initializing all 74HC595 at startup
ResetPin_d.value(0); sleep_us(1);
ResetPin_d.value(1); sleep_us(1);

#reset 74HC595 backlight at startup:
ResetPin_b.value(0); sleep_us(1);
ResetPin_b.value(1); sleep_us(1);

#setup and activate network wlan:
ap = network.WLAN(network.AP_IF)
ap.active(True)            #activating
ap.ifconfig(('192.168.0.4', '255.255.255.0', '192.168.0.1', '8.8.8.8'))
ap.config(essid=ssid, password=password)

while ap.active() == False:
  pass
print('Connection is successful')
print(ap.ifconfig())

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #creating socket object
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(('', 80)) # Legarea serverului la adresa i portul specificate
s.listen(1)      # Ateptarea pentru conexiune
s.settimeout(5) # Setarea unui timeout pentru accept() (de exemplu, 5 secunde)

### Functions used to in initialize the LCDs Nokia 5110:
def initialize_display_01():
    init_display(enabling_display_01,reseting_display_01,0x3c)
def initialize_display_02():
    init_display(enabling_display_02,reseting_display_02,0x3c)
def initialize_display_03():
    init_display(enabling_display_03,reseting_display_03,0x3c)
def initialize_display_04():
    init_display(enabling_display_04,reseting_display_04,0x3c)
def initialize_display_05():
    init_display(enabling_display_05,reseting_display_05,0x3c)
def initialize_display_06():
    init_display(enabling_display_06,reseting_display_06,0x3c)  
def initialize_display_07():
    init_display(enabling_display_07,reseting_display_07,0x3c) 
def initialize_display_08():
    init_display(enabling_display_08,reseting_display_08,0x3c)
def initialize_display_09():
    init_display(enabling_display_09,reseting_display_09,0x3c) 
def initialize_display_10():
    init_display(enabling_display_10,reseting_display_10,0x3c)
def initialize_display_11():
    init_display(enabling_display_11,reseting_display_11,0x3c)
def initialize_display_12():
    init_display(enabling_display_12,reseting_display_12,0x3c) 

### Calculus data displayed on each LCD Nokia 5110:
def calcul_temperatura():
    num = round( float(t), 0 )
    impartire_valoare_in_digiti(num)
    afisare_cifre_mari(0,2)
def calcul_umiditate():
    num = round( float(hi), 0 )
    impartire_valoare_in_digiti(num)
    afisare_cifre_mari(0,2)
def calcul_ITU():
    num = round( float(itu), 0 )
    impartire_valoare_in_digiti(num)
    afisare_cifre_mari(0,2)    
    num = round( float(itu), 0 )
    if num<=65:
        afisare_simbol_ITU_normal(64,2)
    elif 65<num<80:
        afisare_simbol_ITU_alerta(64,2)
    elif num>=80:
        afisare_simbol_ITU_disconfort(64,2)           
def calcul_presiune():    
    num = round( float(press), 0 )
    impartire_valoare_in_digiti(num)
    afisare_cifre_mari(0,2)
def calcul_punct_de_roua():
    num = round( float(Dewpoint), 0 )
    impartire_valoare_in_digiti(num)    
    afisare_cifre_mari(0,2)  
def calcul_altitudine():
    num = round( float(alt), 0 )
    if num<0:
        num=0
        impartire_valoare_in_digiti(num)    
        afisare_cifre_mari(0,2)
    elif num>=0:
        impartire_valoare_in_digiti(num)    
        afisare_cifre_mari(0,2)        
def calcul_data_si_ora():
    rtc.read_time()
    num = round( float(rtc.hour()), 0 )
    impartire_valoare_in_digiti(num)  
    afisare_cifre_mici(24,2)
    lcd.position(36, 2); lcd.data(Semnul_doua_puncte)
    num = round( float(rtc.minute()), 0 )
    impartire_valoare_in_digiti(num)   
    afisare_cifre_mici(44,2)
    num = round( float(rtc.day()), 0 )
    impartire_valoare_in_digiti(num) 
    afisare_cifre_mici(6,3)
    lcd.position(18, 3); lcd.data(Semnul_impartire)
    num = round( float(rtc.month()), 0 )
    impartire_valoare_in_digiti(num)   
    afisare_cifre_mici(26,3)
    lcd.position(38, 3); lcd.data(Semnul_impartire)
    lcd.position(46, 3); lcd.data(Cifra_2)
    lcd.position(52, 3); lcd.data(Cifra_0)
    num = round( float(rtc.year()), 0 )
    impartire_valoare_in_digiti(num) 
    afisare_cifre_mici(58,3)
    num = round( float(rtc.temperature()), 0 )
    impartire_valoare_in_digiti(num)
    afisare_cifre_mici(55,5)
def calcul_barometru():
    num = round( float(press), 0 )
    impartire_valoare_in_digiti(num)   
    if num<750:
        if 740<=num<745:
            num = 00; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,2)
            num = 50; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,3)
            num = 50; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,4)
            afisare_sageata_transparenta(0,2)
            afisare_simbol_sageata(0,3)
            afisare_simbol_sageata(0,4)
            num = round( float(press), 0 )
        elif 745<=num<750:
            num = 00; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,2)
            num = 10; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,3)
            num = 90; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,4)
            afisare_sageata_transparenta(0,2)
            afisare_sageata_transparenta(0,3)
            afisare_simbol_sageata(0,4)
            num = round( float(press), 0 )     
    elif 750<=num<760:
        if 750<=num<752:
            num = 00; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,2)
            num = 90; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,3)
            num = 10; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,4)
            afisare_sageata_transparenta(0,2)
            afisare_simbol_sageata(0,3)
            afisare_sageata_transparenta(0,4)
            num = round( float(press), 0 )
        elif 752<=num<755:
            num = 25; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,2)
            num = 50; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,3)
            num = 25; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,4)
            afisare_sageata_transparenta(0,2)
            afisare_simbol_sageata(0,3)
            afisare_sageata_transparenta(0,4)            
            num = round( float(press), 0 )                
        elif 755<=num<759:
            num = 90; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,2)
            num = 10; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,3)
            num = 00; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,4)
            afisare_simbol_sageata(0,2)
            afisare_sageata_transparenta(0,3)
            afisare_sageata_transparenta(0,4)            
            num = round( float(press), 0 )  
    elif num>=760:
        if 760<=num<765:
            num = 50; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,2)
            num = 50; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,3)
            num = 00; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,4)
            afisare_simbol_sageata(0,2)
            afisare_simbol_sageata(0,3)
            afisare_sageata_transparenta(0,4)            
            num = round( float(press), 0 )
        elif 765<=num:
            num = 90; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,2)
            num = 10; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,3)
            num = 00; impartire_valoare_in_digiti(num); lcd = pcd8544_mod.PCD8544(spi, DC); afisare_cifre_mici(58,4)
            afisare_simbol_sageata(0,2)
            afisare_sageata_transparenta(0,3)
            afisare_sageata_transparenta(0,4)             
            num = round( float(press), 0 ) 
def calcul_atm_press_Infineon():
    num = round( float(dps.pressure*0.75), 0 )
    impartire_valoare_in_digiti(num)
    afisare_cifre_mari(0,2)
def calcul_altitudine_Infineon():
    num = round( float(dps.altitude), 0 )
    impartire_valoare_in_digiti(num)
    afisare_cifre_mari(0,2)    
def calcul_co2_Infineon():
    co2value = co2ppm
    if co2value<0:
        num=000
    else:
        num = co2ppm
    impartire_valoare_in_digiti(num)
    afisare_cifre_mari(0,2)   
def sensor_init(): 
    if init_status != 0:
        print("[co2-module] : Sensor setup failed!")
        return -1
    else:
        print("[co2-module] : Sensor setup done successfully!")
        return pasco2
def read_sensor_data(co2Obj):
    global co2ppm
    co2ppm = co2Obj.get_co2_value()
    if co2ppm == -1:
        print("[co2-module] : Measurement not ready yet")
    else:
        print("[co2-module] : co2 ppm value: ", co2ppm)
           
### Display data in REPL console:  
def afisare_date_in_consola():
    print("Temperature:       {}".format(t), "C")
    print("Humidity:          {}".format(hi), "%")
    print("Indice ITU:        {}".format(itu), "%")
    print("Presiune atm:      {}".format(press), "mmHg")
    print("Punct de roua DEW: {}".format(Dewpoint), "C")
    print("Altitudine:        {}".format(alt), "meters")
    print(rtc.day(),"/",rtc.month(),"/20",rtc.year(),"  ",rtc.hour(),":",rtc.minute(),":",rtc.sec())
    print("RTC temp: ",rtc.temperature(), "C")
    print("Presiune atm Infineon: {}".format(dps.pressure*0.75), "mmHg")
    print("Altitude rel Infineon: {}".format(dps.altitude), "meters")
    print("CO2 Infineon: ", co2ppm, "ppm")    

### Initializare display-uri:
def initializare_display_uri():
    initialize_display_01() #initializa display 01
    initialize_display_02() #initializa display 02
    initialize_display_03() #initializa display 03
    initialize_display_04() #initializa display 04
    initialize_display_05() #initializa display 05
    initialize_display_06() #initializa display 06
    initialize_display_07() #initializa display 07
    initialize_display_08() #initializa display 08
    initialize_display_09() #initializa display 00
    initialize_display_10() #initializa display 10
    initialize_display_11() #initializa display 11
    initialize_display_12() #initializa display 12

### Read all sensors:
def read_all_sensors():
    global t; global p; global h; global hi; global itu; global press; global Dewpoint; global alt; global press_I; global alt_I;
    t,p,h = bme.read_compensated_data()
    t = t / 100
    p = p // 256
    pi = p // 100
    pd = p - pi * 100    
    hi = h // 1024
    hd = h * 100 // 1024 - hi * 100
    itu = (t*1.8 + 32) - (0.55 - 0.0055*hi) * ((t*1.8 + 32)-58)
    itu = round(float(itu), 0 )
    press=pi*0.75 #convert from hPa in mmHg
    Dewpoint = ((t)-(100-hi)/5)
    alt = (153.84*((t)+273.15))*(1-((p/100)/pressure_sea_level)**(1/5.257)) #calculus for relative altitude
    read_sensor_data(co2Obj)
    press_I = dps.pressure*0.75 # for web page display
    alt_I   = dps.altitude      # for web page display

def display_data_on_LCDs():
    select_or_reset_display(enabling_display_01); afisare_text_fix_Temperatura();           calcul_temperatura();         #show data on display 01:        
    select_or_reset_display(enabling_display_02); afisare_text_fix_Umiditate();             calcul_umiditate();           #show data on display 02:
    select_or_reset_display(enabling_display_03); afisare_text_fix_ITU();                   calcul_ITU();                 #show data on display 03:   
    select_or_reset_display(enabling_display_04); afisare_text_fix_Punct_de_roua_DEW();     calcul_punct_de_roua();       #show data on display 04:   
    select_or_reset_display(enabling_display_05); afisare_text_fix_Presiune_atm();          calcul_presiune();            #show data on display 05:      
    select_or_reset_display(enabling_display_06); afisare_text_fix_Altitudine();            calcul_altitudine();          #show data on display 06:     
    select_or_reset_display(enabling_display_07); afisare_text_fix_Barometru();             calcul_barometru();           #show data on display 07:   
    select_or_reset_display(enabling_display_08); afisare_text_fix_DATA_SI_ORA();           calcul_data_si_ora();         #show data on display 08:
    select_or_reset_display(enabling_display_09); afisare_text_fix_Presiune_atm_Infineon(); calcul_atm_press_Infineon();  #show data on display 09:
    select_or_reset_display(enabling_display_10); afisare_text_fix_Altitudine_Infineon();   calcul_altitudine_Infineon(); #show data on display 10:
    select_or_reset_display(enabling_display_11); afisare_text_fix_CO2_Infineon();          calcul_co2_Infineon();        #show data on display 11:
    select_or_reset_display(enabling_display_12); afisare_text_fix_connectivity();                                        #show data on display 12:
    
##################### MAIN PROGRAM: ######################
initializare_display_uri()
backlight_off_at_start()
co2Obj = sensor_init()
joc_la_pornire()

while True:
    try:        
        conn, addr = s.accept()                     # Socket accept() 
        print("Got connection from %s" % str(addr))
        print("Date cu conexiune la wlan AP!")    
        request=conn.recv(1024)                     # Socket receive()
        print("")
        print("Content %s" % str(request))
        request = str(request)                      # Socket send()
        update = request.find('/getData')
        if update == 6:
            read_all_sensors()                      # read all sensord 
            afisare_date_in_consola()               # display data in REPL console
            #create string with data to displat in web page:
            response = str(round(t))+"|"+str(round(hi))+"|"+str(round(itu))+"|"+str(round(Dewpoint))+"|"+str(round(press))+"|"+str(round(alt))+"|"+str(round(press_I))+"|"+str(round(alt_I))+"|"+str(round(co2ppm))
        else:
            response = web_page()       
        # Create a socket reply
        conn.send('HTTP/1.1 200 OK\n')
        conn.send('Content-Type: text/html\n')
        conn.send('Connection: close\n\n')
        conn.sendall(response)    
        conn.close()                                # Socket close()
    except:
        print("Date fara conexiune la wlan AP!")
        read_all_sensors()                          # read all sensord 
        afisare_date_in_consola()                   # display data in REPL console
        display_data_on_LCDs()
        sleep(10)
s.close()