ماژول ®ProMake ProMake Sensor TAG

توصیف

ProMake® Sensor TAG یک راه حل ایده آل برای جمع آوری داده های محیطی (مانند دما، رطوبت، حرکت و نور) است. مجموعه‌ای از حسگرهای با کاربری خاص را بر روی یک ماژول ProMake® برای ادغام آسان در محصول میزبان ارائه می‌کند.

منابع طراحی رایگان هستند و زمان رسیدن به بازار را تسریع می‌کنند تا بتوانید این ماژول از پیش مهندسی شده را به راحتی در محصول بعدی خود ادغام و قرار دهید.

قابلیتها

• قابلیت تشخیص سه هسته ای
• نور
• درجه حرارت

• رطوبت

• قابلیت تشخیص اختیاری

• حرکت (شتاب سنج)
• فشار هوا
• کیفیت هوای داخل ساختمان
• منابع رایگان طراحی و سرعت بخشی برای رسیدن به بازار
• پروتکل ساده و محبوب I2C ارتباطی
• طراحی فشرده، صرفه جویی در فضا
• قاببل استفاده در برد آموزشی
• رنج رطوبت: 0-100%RH
• رنج دما: -10 تا +80 درجه سانتی گراد
• دقت سنجش رطوبت: ±5.0%RH
• دقت سنجش دما: ±0.5℃

نکات مهم

منابع

نقشه پین مازول

نرم افزار

توسعه با آردینیو

برای راه‌اندازی سخت‌افزار، می‌توانید به راحتی این ماژول را به هر اسلاتی از کیت توسعه ProMake® Arduino مورد علاقه خود وصل کنید یا از برد آموزشی خود برای اتصال خطوط Power و I2C استفاده کنید.

خوانش دما و رطوبت

برای خوانش دما و رطوبت از سنسور SHT20، ابتدا نیاز دارید که "" برای خوانش دما و رطوبت ااز سنسور SHT20، ابتدا شما نیاز به نصب کتابخانه “uFire SHT20” دارید(توسط uFile) در محیط برنامه توسعه آردینیو. سپس با استفاده از برنامه زیر کیت آردینیو را برنامه ریزی کنید و " برنامه مانیتور سریال" را باز کنید بت خوانش از سنسور را مشاهده نمائید.

#include "uFire_SHT20.h"
uFire_SHT20 sht20;

void setup()
{
  Serial.begin(9600);
  Wire.begin();
  sht20.begin();
}

void loop()
{
  sht20.measure_all();
  Serial.println((String)sht20.tempC + "°C");
  Serial.println((String)sht20.tempF + "°F");
  Serial.println((String)sht20.dew_pointC + "°C dew point");
  Serial.println((String)sht20.dew_pointF + "°F dew point");
  Serial.println((String)sht20.RH + " %RH");
  Serial.println((String)sht20.vpd() + " kPa VPD");
  Serial.println();
  delay(5000);
}

خوانش سنسور نور

برای خواندن حسگر "LTR-303ALS-01"، ابتدا باید کتابخانه "thingTronics LTR303" (از https://github.com/automote/LTR303) را در Arduino® IDE خود نصب کنید. سپس از کد زیر برای برنامه ریزی آردوینو استفاده کنید و "Serial Monitor" را باز کنید تا خوانش های سنسور را ببینید:

#include <LTR303.h>

// Create an LTR303 object, here called "light":
LTR303 light;

unsigned char gain;     // Gain setting, values = 0-7 
unsigned char integrationTime;  // Integration ("shutter") time in milliseconds
unsigned char measurementRate;  // Interval between DATA_REGISTERS update

void setup() {
  // put your setup code here, to run once:
  // Initialize the Serial port:

  Serial.begin(9600);
  Serial.println("LTR303-ALS example sketch");

  // Initialize the LTR303 library
  // 100ms   initial startup time required
  delay(100);

  // You can pass nothing to light.begin() for the default I2C address (0x29)
  light.begin();

  // The light sensor has a default integration time of 100ms,
  // and a default gain of low (1X).

  // If you would like to change either of these, you can
  // do so using the setControl() and setMeasurementRate() command.

  // Gain can take any value from 0-7, except 4 & 5
  // If gain = 0, device is set to 1X gain (default)
  // If gain = 1, device is set to 2X gain
  // If gain = 2, device is set to 4X gain
  // If gain = 3, device is set to 8X gain
  // If gain = 4, invalid
  // If gain = 5, invalid
  // If gain = 6, device is set to 48X gain
  // If gain = 7, device is set to 96X gain
  gain = 3;
  Serial.println("Setting Gain...");
  light.setControl(gain, false, false);

  // If integrationTime = 0, integrationTime will be 100ms (default)
  // If integrationTime = 1, integrationTime will be 50ms
  // If integrationTime = 2, integrationTime will be 200ms
  // If integrationTime = 3, integrationTime will be 400ms
  // If integrationTime = 4, integrationTime will be 150ms
  // If integrationTime = 5, integrationTime will be 250ms
  // If integrationTime = 6, integrationTime will be 300ms
  // If integrationTime = 7, integrationTime will be 350ms

  unsigned char time = 7;
  Serial.println("Set timing...");
  light.setMeasurementRate(time,3);

  // To start taking measurements, power up the sensor:
  Serial.println("Powerup...");
  light.setPowerUp();

  // The sensor will now gather light during the integration time.
  // After the specified time, you can retrieve the result from the sensor.
  // Once a measurement occurs, another integration period will start.
}

void loop() {
  // Wait between measurements before retrieving the result
  // You can also configure the sensor to issue an interrupt 
  // when measurements are complete)

  // This sketch uses the LTR303's built-in integration timer.
  int ms = 1000;
  delay(ms);

  // Once integration is complete, we'll retrieve the data.

  // There are two light sensors on the device, one for visible light
  // and one for infrared. Both sensors are needed for lux calculations.

  // Retrieve the data from the device:
  unsigned int data0, data1;

  if (light.getData(data0,data1)) {
    // getData() returned true, communication was successful

    Serial.print("data0: ");
    Serial.println(data0);
    Serial.print("data1: ");
    Serial.println(data1);

    // To calculate lux, pass all your settings and readings
    // to the getLux() function.

    // The getLux() function will return 1 if the calculation
    // was successful, or 0 if one or both of the sensors was
    // saturated (too much light). If this happens, you can
    // reduce the integration time and/or gain.

    double lux;    // Resulting lux value
    boolean good;  // True if neither sensor is saturated

    // Perform lux calculation:
    good = light.getLux(gain,integrationTime,data0,data1,lux);

    // Print out the results:
    Serial.print(" lux: ");
    Serial.println(lux);
    if (good) Serial.println(" (good)"); else Serial.println(" (BAD)");
  }
  else {
    // getData() returned false because of an I2C error, inform the user.

    byte error = light.getError();
    printError(error);
  }
}

void printError(byte error) {
  // If there's an I2C error, this function will
  // print out an explanation.

  Serial.print("I2C error: ");
  Serial.print(error,DEC);
  Serial.print(", ");

  switch(error) {
    case 0:
      Serial.println("success");
      break;
    case 1:
      Serial.println("data too long for transmit buffer");
      break;
    case 2:
      Serial.println("received NACK on address (disconnected?)");
      break;
    case 3:
      Serial.println("received NACK on data");
      break;
    case 4:
      Serial.println("other error");
      break;
    default:
      Serial.println("unknown error");
  }
}

متأسفانه، کتابخانه "thingTronics LTR303" مشکلاتی در روشن کردن سنسور و محاسبه مقدار lux دارد، بنابراین ممکن است لازم باشد فایل "LTR303.cpp" را با دستورالعمل‌های زیر پچ کنید:

1. فایل "LTR303.cpp" را در پوشه "Documents\Arduino\libraries\LTR303-master" پیدا کنید.
2. تابع "setPowerUp()" را با کد زیر جایگزین کنید:

boolean LTR303::setPowerUp(void) {
    // Turn on LTR303, begin integrations
    // Returns true (1) if successful, false (0) if there was an I2C error
    // (Also see getError() below)

    // Write 0x01 (reset = 0 & mode = 1) to command byte (power on)
    return(writeByte(LTR303_CONTR,0x01));
}

1. تابع "getLux()" را با کد زیر جایگزین کنید:

boolean LTR303::getLux(byte gain, byte integrationTime, unsigned int CH0, unsigned int CH1, double &lux) {
    // Convert raw data to lux
    // gain: 0 (1X) or 7 (96X), see getControl()
    // integrationTime: integration time in ms, from getMeasurementRate()
    // CH0, CH1: results from getData()
    // lux will be set to resulting lux calculation
    // returns true (1) if calculation was successful
    // returns false (0) AND lux = 0.0 IF EITHER SENSOR WAS SATURATED (0XFFFF)

    double ratio, ALS_INT;
    int ALS_GAIN;

    // Determine if either sensor saturated (0xFFFF)
    // If so, abandon ship (calculation will not be accurate)
    if ((CH0 == 0xFFFF) || (CH1 == 0xFFFF)) {
        lux = 0.0;
        return(false);
    }

    // We will need the ratio for subsequent calculations
    ratio = CH1 / (CH0 + CH1);

    // Gain can take any value from 0-7, except 4 & 5
    // If gain = 4, invalid
    // If gain = 5, invalid
    switch(gain){
        case 0:            // If gain = 0, device is set to 1X gain (default)
            ALS_GAIN = 1;
            break;
        case 1:            // If gain = 1, device is set to 2X gain
            ALS_GAIN = 2;
            break;
        case 2:           // If gain = 2, device is set to 4X gain   
            ALS_GAIN = 4;
            break;
        case 3:           // If gain = 3, device is set to 8X gain    
            ALS_GAIN = 8;
            break;
        case 6:          // If gain = 6, device is set to 48X gain
            ALS_GAIN = 48;
            break;  
        case 7:           // If gain = 7, device is set to 96X gain  
            ALS_GAIN = 96;
            break;
        default:          // If gain = 0, device is set to 1X gain (default)         
            ALS_GAIN = 1;
            break;
    }

    switch(integrationTime){
        case 0:              // If integrationTime = 0, integrationTime will be 100ms (default)
            ALS_INT = 1;
            break;
        case 1:              // If integrationTime = 1, integrationTime will be 50ms
            ALS_INT = 0.5;
            break;
        case 2:              // If integrationTime = 2, integrationTime will be 200ms
            ALS_INT = 2;
            break;
        case 3:               // If integrationTime = 3, integrationTime will be 400ms
            ALS_INT = 4;
            break;
        case 4:               // If integrationTime = 4, integrationTime will be 150ms
            ALS_INT = 1.5;
            break;
        case 5:               // If integrationTime = 5, integrationTime will be 250ms
            ALS_INT = 2.5;
            break;
        case 6:               // If integrationTime = 6, integrationTime will be 300ms
            ALS_INT = 3;
            break;  
        case 7:               // If integrationTime = 7, integrationTime will be 350ms
            ALS_INT = 3.5;
            break;
        default:             // If integrationTime = 0, integrationTime will be 100ms (default)
            ALS_INT = 1;
            break;
    }

    // Determine lux per datasheet equations:
    if (ratio < 0.45) {
        lux = ((1.7743 * CH0) + (1.1059 * CH1))/ALS_GAIN/ALS_INT;
        return(true);
    }

    if ((ratio < 0.64) && (ratio >= 0.45)){
        lux = ((4.2785 * CH0) + (1.9548 * CH1))/ALS_GAIN/ALS_INT;
        return(true);
    }

    if ((ratio < 0.85) && (ratio >= 0.64)){
        lux = ((0.5926 * CH0) + (0.1185 * CH1))/ALS_GAIN/ALS_INT;
        return(true);
    }

    // if (ratio >= 0.85)
    else {  
        lux = 0.0;
        return(true);
    }   
}

خواندن سنسور فشار

برای خواندن سنسور "BMP-280"، ابتدا باید کتابخانه "Adafruit BMP280" (توسط Adafruit) را در Arduino® IDE خود نصب کنید. سپس از کد زیر برای برنامه ریزی آردوینو استفاده کنید و "Serial Monitor" را باز کنید تا خوانش های سنسور را ببینید:

#include <Adafruit_BMP280.h>

Adafruit_BMP280 bmp; // I2C

void setup() {
  Serial.begin(9600);
  while ( !Serial ) delay(100);   // wait for native usb
  Serial.println(F("BMP280 test"));
  unsigned status;
  status = bmp.begin(BMP280_ADDRESS_ALT, BMP280_CHIPID);
  //status = bmp.begin();
  if (!status) {
    Serial.println(F("Could not find a valid BMP280 sensor, check wiring or "
                      "try a different address!"));
    Serial.print("SensorID was: 0x"); Serial.println(bmp.sensorID(),16);
    Serial.print("        ID of 0xFF probably means a bad address, a BMP 180 or BMP 085\n");
    Serial.print("   ID of 0x56-0x58 represents a BMP 280,\n");
    Serial.print("        ID of 0x60 represents a BME 280.\n");
    Serial.print("        ID of 0x61 represents a BME 680.\n");
    while (1) delay(10);
  }

  /* Default settings from datasheet. */
  bmp.setSampling(Adafruit_BMP280::MODE_NORMAL,     /* Operating Mode. */
                  Adafruit_BMP280::SAMPLING_X2,     /* Temp. oversampling */
                  Adafruit_BMP280::SAMPLING_X16,    /* Pressure oversampling */
                  Adafruit_BMP280::FILTER_X16,      /* Filtering. */
                  Adafruit_BMP280::STANDBY_MS_500); /* Standby time. */
}

void loop() {
    Serial.print(F("Temperature = "));
    Serial.print(bmp.readTemperature());
    Serial.println(" *C");

    Serial.print(F("Pressure = "));
    Serial.print(bmp.readPressure());
    Serial.println(" Pa");

    Serial.print(F("Approx altitude = "));
    Serial.print(bmp.readAltitude(1013.25)); /* Adjusted to local forecast! */
    Serial.println(" m");

    Serial.println();
    delay(2000);
}

خواندن سنسور شتاب سنج

برای خواندن حسگر "LIS3DHTR"، ابتدا باید کتابخانه "SparkFun LIS3DH" (توسط SparkFun) را در Arduino® IDE خود نصب کنید. سپس از کد زیر برای برنامه ریزی آردوینو استفاده کنید و "Serial Monitor" را باز کنید تا هنگام حرکت سنسور، خوانش های سنسور را ببینید:

#include <SparkFunLIS3DH.h>

LIS3DH myIMU(I2C_MODE, 0x18); //Default constructor is I2C, addr 0x19.

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  delay(1000); //relax...
  Serial.println("Processor came out of reset.\n");

  //Call .begin() to configure the IMU
  myIMU.begin();
}

void loop() {
  // put your main code here, to run repeatedly:
  //Get all parameters
  Serial.print("\nAccelerometer:\n");
  Serial.print(" X = ");
  Serial.println(myIMU.readFloatAccelX(), 4);
  Serial.print(" Y = ");
  Serial.println(myIMU.readFloatAccelY(), 4);
  Serial.print(" Z = ");
  Serial.println(myIMU.readFloatAccelZ(), 4);

  delay(1000);
}

خواندن ADC

برای خواندن "ADC081"، از کد زیر برای برنامه ریزی آردوینو استفاده کنید و "Serial Monitor" را باز کنید تا هنگام تغییر سطح ولتاژ ورودی، خوانش ها را ببینید:

#include <Wire.h>

#define ADC_ADDR 0x52     // I2C address of the ADC121C021

void setup(){
  Wire.begin();         // Join I2c Bus as master
  pinMode(13, OUTPUT);  // Set pin 13 to output for status LED
                        // I2C Pins on the Arduino Uno are A4 for SDA and A5 for SCL
  Serial.begin(9600);   // Start serial communication for serial console output

  // Start I2C Transmission
  Wire.beginTransmission(ADC_ADDR);
  // Select configuration register
  Wire.write(0x02);
  // Automatic conversion mode enabled
  Wire.write(0x20);
  // Stop I2C Transmission
  Wire.endTransmission();
  delay(300);  
}

void loop() {
  Wire.beginTransmission(ADC_ADDR); // Begin transmission with given device on I2C bus
  Wire.write(0x00);                 // calling Conversion Result register
  Wire.endTransmission();           // End transmission and release I2C bus
  delay(500);                       // delay

  Wire.beginTransmission(ADC_ADDR);   // Begin transmission with given device on I2C bus
  Wire.requestFrom(ADC_ADDR, 2);         // Request 2 bytes

  // Read the bytes if they are available
  // The first two bytes are
  if(Wire.available() == 2) {                
    int b1 = Wire.read();
    int b2 = Wire.read();
    Wire.endTransmission();               // End transmission and release I2C bus

    int rawADC = b1 << 8 | b2;           // combine b1 and b2
    rawADC = rawADC & 0x0fff;      // masking
    double volt=rawADC*5/4096.0;
    Serial.print("value: ");            // print output
    Serial.println(volt);

  }
  else
  {
    Serial.println("Not enough bytes available on wire.");
  }
}

توسعه با رزبری

برای توسعه با برد سنسور تگ با برد پیکو می توانید از این برنامه استفاده نمائید.

#This code run on ProMake PI PICO Kit HW REV 1.2
#For getting data from SHT20 and VEML7700(Light Sensor)

from machine import Pin, I2C,ADC
from time import sleep
import ssd1306
import veml7700


i2c = I2C(0, scl=Pin(17), sda=Pin(16), freq=10000)

veml = veml7700.VEML7700(address=0x10, i2c=i2c, it=100, gain=1/8)


oled = ssd1306.SSD1306_I2C(128, 32, i2c)


def sht20_temperature():
    """Obtain the temperature value of SHT20 module
    Return:Temperature
    """
    i2c.writeto(0x40,b'\xf3')                       # Write byte “0xf3” to address 0x40, SHT20
    sleep(.070)                                    # SHT20 measurement takes time, must wait
    t=i2c.readfrom(0x40, 2)                         # Read 2 bytes of data from the x40 address, SHT20
    return -46.86+175.72*(t[0]*256+t[1])/65535      # Perform temperature conversion processing on the read data T=-46.86+175.72*St/2^16

def sht20_humidity():
    """Obtain the humidity value of SHT20 module
    Return:Humidity
    """
    i2c.writeto(0x40,b'\xf5')                       # Write byte “0xf5” to address 0x40, SHT20
    sleep(0.025)                                    # SHT20 measurement takes time, must wait
    t=i2c.readfrom(0x40, 2)                         # Read 2 bytes of data from the x40 address, SHT20
    return -6+125*(t[0]*256+t[1])/65535             # Perform humidity conversion processing on the read data RH=-6+125*Srh/2^16

while True:

    temper=sht20_temperature()
    humid=sht20_humidity()
    lux_val = veml.read_lux()

    oled.fill(0)
    oled.text("Temper:%0.1fC" %(temper),0,2,1)
    oled.text("Humidity:%d%%" %(humid),0,13,1)
    oled.text("Lux_Value:%1d" %(lux_val),0,25,1)
    oled.show()

    print("sht20 temperature: %0.1fC sht20 humidity: %0.1f%%  Lux_Value: %1d" %(temper,humid,lux_val))

    sleep(1)