Grove - Sensor de CO2, Temperatura y Humedad (SCD30)

El Grove - Sensor de CO2, Temperatura y Humedad (SCD30) es un sensor de dióxido de carbono de alta precisión, basado en el Sensirion SCD30. El rango de medición de este sensor es de 0 ppm-40'000 ppm, y la precisión de medición puede alcanzar ±(30 ppm + 3%) entre 400ppm y 10'000ppm.

Además de la tecnología de medición infrarroja no dispersiva (NDIR) para la detección de CO2, el SCD30 integra sensores de humedad y temperatura de Sensirion en el mismo módulo sensor.

Obtener Uno Ahora 🖱️

Actualizable a Sensores Industriales

Con el controlador S2110 y el registrador de datos S2100 de SenseCAP, puedes convertir fácilmente el Grove en un sensor LoRaWAN®. Seeed no solo te ayuda con la creación de prototipos, sino que también te ofrece la posibilidad de expandir tu proyecto con la serie SenseCAP de sensores industriales robustos.

Los sensores industriales de la serie SenseCAP S210x proporcionan una experiencia lista para usar para el monitoreo ambiental. Por favor, consulta el Sensor Inalámbrico S2103 de CO2, Temperatura y Humedad con mayor rendimiento y robustez para el monitoreo de la calidad del aire. La serie incluye sensores para humedad del suelo, temperatura y humedad del aire, intensidad de luz, CO2, EC, y una estación meteorológica 8 en 1. Prueba el último SenseCAP S210x para tu próximo proyecto industrial exitoso.

Sensor Industrial SenseCAP

S2103 Temp. y Humedad del Aire y CO2

Versión

Versión del Producto	Cambios	Fecha de Lanzamiento
Grove - Sensor de CO2, Temperatura y Humedad (SCD30) V1.0	Inicial	Dic 2018

Ideas de Aplicación

Purificador de Aire
Monitoreo Ambiental
Monitoreo Ambiental de Plantas

Características

Tecnología de sensor de CO2 NDIR
Sensor integrado de temperatura y humedad
Mejor relación rendimiento-precio
Detección de doble canal para estabilidad superior
Interfaz digital I2C
Bajo consumo de energía
Vida útil ultra larga del sensor (15 años)

Especificaciones

Parámetro	Valor
Voltaje de alimentación	3.3V / 5V
Temperatura de operación	0 – 50℃
Temperatura de almacenamiento	- 40°C – 70°C
Condiciones de humedad de operación	0 – 95 %RH
Vida útil del sensor	15 años
Interfaz	I2C
Dirección I2C	0x61
Tamaño	L: 61mm W: 42mm H: 19mm
Peso	19.7g
Tamaño del paquete	L: 110mm W: 70mm H: 40mm
Peso bruto	27g

Tabla 1.Especificaciones Generales

Parámetro	Condiciones	Valor
Rango de medición de CO2		0 – 40'000 ppm
Precisión	400ppm – 10'000ppm	± (30 ppm + 3%)
Repetibilidad	400ppm – 10'000ppm	10ppm
Tiempo de respuesta	τ63%	20 s

Tabla 2.Especificaciones del Sensor de CO2

Parámetro	Condiciones	Valor
Rango de medición de humedad		0 %RH – 100 %RH
Precisión	0 – 50°C, 0 – 100%RH	±2 %RH
Repetibilidad		0.1 %RH
Tiempo de respuesta	τ63%	8 s

Tabla 3.Especificaciones del Sensor de Humedad

Parámetro	Condiciones	Valor
Rango de medición de temperatura		-40°C – 120°C
Precisión	0 – 50°C	±0.5°C
Repetibilidad		0.1°C
Tiempo de respuesta	τ63%	> 2 s

Tabla 4.Especificaciones del Sensor de Temperatura

Parámetro	Condiciones	Valor
Corriente promedio	Intervalo de actualización 2 s	19 mA
Corriente máx.	Durante la medición	75 mA
Consumo de energía	1 medición	120 mJ

Tabla 5.Especificaciones Eléctricas

Descripción General del Hardware

Plataformas Compatibles

Arduino	Raspberry Pi

Primeros Pasos

Jugar con Arduino

Hardware

Materiales requeridos

Seeeduino V4.2	Base Shield	Grove-CO2 & T&H SCD30

Obtener UNO Ahora	Obtener UNO Ahora	Obtener UNO Ahora

Además, puedes considerar nuestro nuevo Seeeduino Lotus M0+, que es equivalente a la combinación de Seeeduino V4.2 y Baseshield.

note

1 Por favor conecta el cable USB con cuidado, de lo contrario podrías dañar el puerto. Por favor usa el cable USB con 4 cables internos, el cable de 2 cables no puede transferir datos. Si no estás seguro sobre el cable que tienes, puedes hacer clic aquí para comprar

2 Cada módulo Grove viene con un cable Grove cuando lo compras. En caso de que pierdas el cable Grove, puedes hacer clic aquí para comprar.

Conexión del Hardware

Paso 1. Conecta el Grove - Sensor de CO2, Temperatura y Humedad (SCD30) al puerto I2C del Base Shield.
Paso 2. Conecta Grove - Base Shield al Seeeduino.
Paso 3. Conecta Seeeduino a la PC mediante un cable USB.

Software

caution

Si esta es la primera vez que trabajas con Arduino, te recomendamos encarecidamente que veas Primeros Pasos con Arduino antes de comenzar.

Paso 1. Descarga la Librería Seeed SCD30 desde Github.
Paso 2. Consulta Cómo instalar librería para instalar la librería para Arduino.
Paso 3. Reinicia el IDE de Arduino. Abre el ejemplo, puedes abrirlo de las siguientes tres maneras： a. Ábrelo directamente en el Arduino IDE a través de la ruta: File --> Examples -->Grove_scd30_co2_sensor-->SCD30_Example.

b. Ábrelo en tu computadora haciendo clic en SCD30_Example.ino que puedes encontrar en la carpeta XXXX\Arduino\libraries\Seeed_SCD30-master\examples\SCD30_Example, XXXX es la ubicación donde instalaste el Arduino IDE.

c. O, puedes simplemente hacer clic en el icono en la esquina superior derecha del bloque de código para copiar el siguiente código en un nuevo sketch en el Arduino IDE.

#include "SCD30.h"

#if defined(ARDUINO_ARCH_AVR)
 #pragma message("Defined architecture for ARDUINO_ARCH_AVR.")
 #define SERIAL Serial
#elif defined(ARDUINO_ARCH_SAM)
 #pragma message("Defined architecture for ARDUINO_ARCH_SAM.")
 #define SERIAL SerialUSB
#elif defined(ARDUINO_ARCH_SAMD)
 #pragma message("Defined architecture for ARDUINO_ARCH_SAMD.") 
 #define SERIAL SerialUSB
#elif defined(ARDUINO_ARCH_STM32F4)
 #pragma message("Defined architecture for ARDUINO_ARCH_STM32F4.")
 #define SERIAL SerialUSB
#else
 #pragma message("Not found any architecture.")
 #define SERIAL Serial
#endif



void setup()
{
    Wire.begin();
    SERIAL.begin(115200);
    SERIAL.println("SCD30 Raw Data");
    scd30.initialize();
}

void loop()
{
    float result[3] = {0};

    if(scd30.isAvailable())
    {
        scd30.getCarbonDioxideConcentration(result);
        SERIAL.print("Carbon Dioxide Concentration is: ");
        SERIAL.print(result[0]);
        SERIAL.println(" ppm");
        SERIAL.println(" ");
        SERIAL.print("Temperature = ");
        SERIAL.print(result[1]);
        SERIAL.println(" ℃");
        SERIAL.println(" ");
        SERIAL.print("Humidity = ");
        SERIAL.print(result[2]);
        SERIAL.println(" %");
        SERIAL.println(" ");
        SERIAL.println(" ");
        SERIAL.println(" ");
    }

    delay(2000);
}

caution

El archivo de biblioteca puede ser actualizado. Este código puede no ser aplicable al archivo de biblioteca actualizado, por lo que recomendamos que uses los primeros dos métodos.

Paso 4. Sube la demostración. Si no sabes cómo subir el código, por favor revisa Cómo subir código.

tip

Si todo va bien, los datos en bruto del Grove - CO2 & Temperature & Humidity Sensor (SCD30) deberían poder leerse desde el Monitor Serie.

Calibración y Colocación

Para obtener resultados más precisos en un escenario práctico, necesitas prestar atención a los siguientes dos puntos:

1. La colocación correcta
1. Calibración

Colocación

Por favor consulta las Guías de Diseño SCD30 para la colocación correcta.

Calibración

Cuando se activa por primera vez, se necesita un período mínimo de 7 días para que el algoritmo pueda encontrar su conjunto inicial de parámetros para ASC. El sensor debe estar expuesto al aire fresco durante al menos 1 hora cada día. También durante ese período, el sensor no debe desconectarse de la fuente de alimentación, de lo contrario el procedimiento para encontrar parámetros de calibración se aborta y debe reiniciarse desde el principio. Los parámetros calculados exitosamente se almacenan en la memoria no volátil del SCD30 teniendo el efecto de que después de un reinicio los parámetros previamente encontrados para ASC siguen presentes. Para más detalles sobre la calibración, por favor consulta la Descripción de Interfaz del Módulo Sensor Sensirion SCD30

Hay dos muestras ino en la carpeta de la biblioteca SCD30, puedes ejecutar el SCD30_auto_calibration.ino para iniciar la calibración.

Jugar con Raspberry Pi

Hardware

Paso 1. Cosas usadas en este proyecto:

Raspberry pi	Grove Base Hat para RasPi	Grove-CO2 & T&H SCD30

Obtener UNO Ahora	Obtener UNO Ahora	Obtener UNO Ahora

Paso 2. Conecta el Grove Base Hat al Raspberry.
Paso 3. Conecta el Grove-CO2 al puerto I2C del Base Hat.
Paso 4. Conecta el Raspberry Pi a la PC a través del cable USB.

pir

Software

note

Si estás usando Raspberry Pi con Raspberrypi OS >= Bullseye, tienes que usar esta línea de comandos solo con Python3.

Paso 1. Sigue Configuración de Software para configurar el entorno de desarrollo.
Paso 2. Entra al entorno virtual relevante.

source ~/grove_env/env/bin/activate
cd ~/grove_env/grove.py/grove

Paso 3. Ejecuta el siguiente comando para ejecutar el código.
Lo siguiente es para revisar el código grove_co2_scd30.py.

less grove_co2_scd30.py

from typing import NoReturn
from grove.i2c import Bus
import struct
import time


class GroveCo2Scd30(object):
    __COMMAND_TRIGGER_CONTINUOUS_MEASUREMENT = 0x0010
    __COMMAND_STOP_CONTINUOUS_MEASUREMENT = 0x0104
    __COMMAND_SET_MEASUREMENT_INTERVAL = 0x4600
    __COMMAND_GET_DATA_READY_STATUS = 0x0202
    __COMMAND_READ_MEASUREMENT = 0x0300
    __COMMAND_ACTIVATE_ASC = 0x5306
    __COMMAND_SET_FRC = 0x5204
    __COMMAND_SET_TEMPRATURE_OFFSET = 0x5403
    __COMMAND_ALTITUDE_COMPENSATION = 0x5102
    __COMMAND_READ_FIRMWARE_VERSION = 0xd100
    __COMMAND_SOFT_RESET = 0xd304

    def __init__(self, address=0x61, bus=1):
        self.address = address
        self.bus = Bus(bus)

        self.set_measurement_interval(2)
        self.trigger_continuous_measurement()

    @staticmethod
    def _calc_crc(data: list) -> int:
        crc = 0xff

        for d in data:
            crc ^= d

            for _ in range(8):
                if crc & 0x80:
                    crc = ((crc << 1) ^ 0x31) & 0xff
                else:
                    crc = (crc << 1) & 0xff

        return crc

    def _write(self, cmd: int, data: list):
        write_data = list(struct.pack(">H", cmd))
        if data is not None:
            for d in data:
                write_data.extend(struct.pack(">H", d))
                write_data.append(GroveCo2Scd30._calc_crc(struct.pack(">H", d)))

        write_msg = self.bus.msg.write(self.address, write_data)
        self.bus.i2c_rdwr(write_msg)

    def _read(self, address: int, data_number: int) -> list:
        write_data = list(struct.pack(">H", address))

        write_msg = self.bus.msg.write(self.address, write_data)
        self.bus.i2c_rdwr(write_msg)

        read_msg = self.bus.msg.read(self.address, 3 * data_number)
        self.bus.i2c_rdwr(read_msg)

        result = []
        for i in range(data_number):
            d = read_msg.buf[i*3:i*3+2]
            if GroveCo2Scd30._calc_crc(d) != read_msg.buf[i*3+2][0]:
                raise ValueError("CRC mismatch")

            result.append(struct.unpack(">H", d)[0])

        return result

    def trigger_continuous_measurement(self, pressure: int = 0):
        self._write(self.__COMMAND_TRIGGER_CONTINUOUS_MEASUREMENT, [pressure])

    def stop_continuous_measurement(self):
        self._write(self.__COMMAND_STOP_CONTINUOUS_MEASUREMENT, None)

    def set_measurement_interval(self, interval: int):
        self._write(self.__COMMAND_SET_MEASUREMENT_INTERVAL, [interval])

    def get_measurement_interval(self) -> int:
        data = self._read(self.__COMMAND_SET_MEASUREMENT_INTERVAL, 1)

        return data[0]

    def get_data_ready_status(self) -> bool:
        data = self._read(self.__COMMAND_GET_DATA_READY_STATUS, 1)

        return True if data[0] == 1 else False

    def read_measurement(self) -> tuple:
        data = self._read(self.__COMMAND_READ_MEASUREMENT, 6)

        data_bytes = struct.pack(">HHHHHH", data[0], data[1], data[2], data[3], data[4], data[5])
        data_floats = struct.unpack(">fff", data_bytes)
        co2 = data_floats[0]
        temp = data_floats[1]
        humi = data_floats[2]

        return co2, temp, humi

    def set_forced_recalibration(self, co2: float):
        self._write(self.__COMMAND_SET_FRC, [int(co2)])

    def set_automatic_self_calibration(self, activate: bool):
        self._write(self.__COMMAND_ACTIVATE_ASC, [1 if activate else 0])

    def get_automatic_self_calibration(self) -> bool:
        data = self._read(self.__COMMAND_ACTIVATE_ASC, 1)

        return True if data[0] == 1 else False

    def set_temperature_offset(self, offset: float):
        self._write(self.__COMMAND_SET_TEMPRATURE_OFFSET, [int(offset * 100)])

    def get_temperature_offset(self) -> float:
        data = self._read(self.__COMMAND_SET_TEMPRATURE_OFFSET, 1)

        return float(data[0]) / 100

    def set_altitude_compensation(self, altitude: int):
        self._write(self.__COMMAND_ALTITUDE_COMPENSATION, [altitude])

    def get_altitude_compensation(self) -> int:
        data = self._read(self.__COMMAND_ALTITUDE_COMPENSATION, 1)

        return data[0]

    def read(self) -> tuple:
        if not self.get_data_ready_status():
            return None

        return self.read_measurement()


def main() -> NoReturn:
    sensor = GroveCo2Scd30()

    while True:
        if sensor.get_data_ready_status():
            co2, temperature, humidity = sensor.read()
            print(f"CO2 concentration is {co2:.1f} ppm")
            print(f"Temperature in Celsius is {temperature:.2f} C")
            print(f"Relative Humidity is {humidity:.2f} %")

        time.sleep(1)


if __name__ == "__main__":
    main()

Ejecuta este código

python grove_co2_scd30.py

Si todo va bien, verás el siguiente fenómeno.😄

pir

Jugar con Wio Terminal (ArduPy)

Hardware

Paso 1. Prepara los siguientes elementos:

Wio Terminal	Grove-CO2 & T&H SCD30

Obtener Uno Ahora	Obtener Uno Ahora

Paso 2. Conecta Grove-CO2 & T&H SCD30 al puerto Grove I2C del Wio Terminal.
Paso 3. Conecta el Wio Terminal a la PC a través del cable USB Type-C.

Software

Paso 1. Sigue Introducción a ArduPy para configurar el entorno de desarrollo ArduPy en Wio Terminal.
Paso 2. Asegúrate de que el firmware ArduPy esté flasheado en Wio Terminal. Para más información, sigue aquí.

aip install Seeed-Studio/seeed-ardupy-scd30
aip build
aip flash

Paso 3. Copia el siguiente código y guárdalo como ArduPy-scd30.py:

from arduino import grove_scd30
from machine import LCD
from machine import Sprite
import time

scd30 = grove_scd30()
lcd = LCD()
spr = Sprite(lcd) # Create a buff

def main():
    spr.createSprite(320, 240)
    while True:
        spr.setTextSize(2)
        spr.fillSprite(spr.color.BLACK)
        spr.setTextColor(lcd.color.ORANGE)
        spr.drawString("SCD30 Reading", 90, 10)
        spr.drawFastHLine(40, 35, 240, lcd.color.DARKGREY)
        spr.setTextColor(lcd.color.WHITE)
        spr.drawString("- CO2 Level: ", 20, 50)
        spr.drawString("- Temperature: ", 20, 80)
        spr.drawString("- Humidity: ", 20, 110)

        if(scd30.isAvailable()):
            data = scd30.getCarbonDioxideConcentration()
            spr.drawFloat(data[0], 2,220,50) # CO2
            spr.drawFloat(data[1], 2, 220,80)
            spr.drawFloat(data[2], 2, 220,110)
            spr.pushSprite(0,0)
        time.sleep_ms(500)

        print("\nCarbon Dioxide Concentration:", data[0])
        print("Temperature:", data[1])
        print("Humidity:", data[2])

if __name__ == "__main__":
    main()

Paso 4. Guarda el ArduPy-scd30.py en una ubicación que conozcas. Ejecuta el siguiente comando y reemplaza <YourPythonFilePath> con la ubicación de tu ArduPy-scd30.py.

aip shell -n -c "runfile <YourPythonFilePath>"
# Example:
# aip shell -n -c "runfile /Users/ansonhe/Desktop/ArduPy-scd30.py"

Paso 5. Veremos los 3 valores de datos mostrados en la terminal como se muestra a continuación, y también en la pantalla LCD del Wio Terminal.

ansonhe@Ansons-Macbook-Pro ~:aip shell -n -c "runfile /Users/ansonhe/Desktop/ArduPy-scd30.py"
Positional argument (/dev/cu.usbmodem1414301) takes precedence over --open.
Connected to ardupy
Carbon Dioxide Concentration: 2360.639
Temperature: 29.18707
Humidity: 66.88538

Carbon Dioxide Concentration: 2360.639
Temperature: 29.18707
Humidity: 66.88538

Carbon Dioxide Concentration: 2500.573
Temperature: 29.17372
Humidity: 66.61072

Visor de Esquemas en Línea

Recursos

[ZIP] Archivo de esquemas Grove - CO2 & Temperature & Humidity Sensor (SCD30)
[PDF] Guía de Diseño SCD30
[PDF] Hoja de Datos SCD30
[PDF] Descripción de Interfaz SCD30

Soporte Técnico y Discusión de Productos

¡Gracias por elegir nuestros productos! Estamos aquí para brindarte diferentes tipos de soporte para asegurar que tu experiencia con nuestros productos sea lo más fluida posible. Ofrecemos varios canales de comunicación para satisfacer diferentes preferencias y necesidades.

Actualizable a Sensores Industriales​

Versión​

Ideas de Aplicación​

Características​

Especificaciones​

Descripción General del Hardware​

Plataformas Compatibles​

Primeros Pasos​

Jugar con Arduino​

Hardware​

Software​

Calibración y Colocación​

Colocación​

Calibración​

Jugar con Raspberry Pi​

Hardware​

Software​

Jugar con Wio Terminal (ArduPy)​

Hardware​

Software​

Visor de Esquemas en Línea​

Recursos​

Soporte Técnico y Discusión de Productos​

Actualizable a Sensores Industriales

Versión

Ideas de Aplicación

Características

Especificaciones

Descripción General del Hardware

Plataformas Compatibles

Primeros Pasos

Jugar con Arduino

Hardware

Software

Calibración y Colocación

Colocación

Calibración

Jugar con Raspberry Pi

Hardware

Software

Jugar con Wio Terminal (ArduPy)

Hardware

Software

Visor de Esquemas en Línea

Recursos

Soporte Técnico y Discusión de Productos