標題: SHT30-31-35手冊CAD模型,Arduino源代碼等資料 [打印本頁]
作者: xiaoxiao365    時間: 2019-11-19 19:37
標題: SHT30-31-35手冊CAD模型,Arduino源代碼等資料
SHT30-31-35資料


單片機源程序如下:
  1. #include <Wire.h>

  3. #include "ClosedCube_SHT3XD.h"

  5. ClosedCube_SHT3XD::ClosedCube_SHT3XD()
  6. {
  7. }

  9. SHT3XD_ErrorCode ClosedCube_SHT3XD::begin(uint8_t address) {
  10.         SHT3XD_ErrorCode error = NO_ERROR;
  11.         _address = address;
  12.         Wire.begin();

  14.         return error;
  15. }

  17. SHT3XD ClosedCube_SHT3XD::periodicFetchData()
  18. {
  19.         SHT3XD_ErrorCode error = writeCommand(CMD_FETCH_DATA);
  20.         if (error == NO_ERROR)
  21.                 return readTemperatureAndHumidity();
  22.         else
  23.                 returnError(error);
  24. }

  26. SHT3XD_ErrorCode ClosedCube_SHT3XD::periodicStop() {
  27.         return writeCommand(CMD_STOP_PERIODIC);
  28. }

  30. SHT3XD_ErrorCode ClosedCube_SHT3XD::periodicStart(SHT3XD_Repeatability repeatability, SHT3XD_Frequency frequency)
  31. {
  32.         SHT3XD_ErrorCode error;

  34.         switch (repeatability)
  35.         {
  36.         case REPEATABILITY_LOW:
  37.                 switch (frequency)
  38.                 {
  39.                 case FREQUENCY_HZ5:
  40.                         error = writeCommand(CMD_PERIODIC_HALF_L);
  41.                         break;
  42.                 case FREQUENCY_1HZ:
  43.                         error = writeCommand(CMD_PERIODIC_1_L);
  44.                         break;
  45.                 case FREQUENCY_2HZ:
  46.                         error = writeCommand(CMD_PERIODIC_2_L);
  47.                         break;
  48.                 case FREQUENCY_4HZ:
  49.                         error = writeCommand(CMD_PERIODIC_4_L);
  50.                         break;
  51.                 case FREQUENCY_10HZ:
  52.                         error = writeCommand(CMD_PERIODIC_10_L);
  53.                         break;
  54.                 default:
  55.                         error = PARAM_WRONG_FREQUENCY;
  56.                         break;
  57.                 }
  58.                 break;
  59.         case REPEATABILITY_MEDIUM:
  60.                 switch (frequency)
  61.                 {
  62.                 case FREQUENCY_HZ5:
  63.                         error = writeCommand(CMD_PERIODIC_HALF_M);
  64.                         break;
  65.                 case FREQUENCY_1HZ:
  66.                         error = writeCommand(CMD_PERIODIC_1_M);
  67.                         break;
  68.                 case FREQUENCY_2HZ:
  69.                         error = writeCommand(CMD_PERIODIC_2_M);
  70.                         break;
  71.                 case FREQUENCY_4HZ:
  72.                         error = writeCommand(CMD_PERIODIC_4_M);
  73.                         break;
  74.                 case FREQUENCY_10HZ:
  75.                         error = writeCommand(CMD_PERIODIC_10_M);
  76.                         break;
  77.                 default:
  78.                         error = PARAM_WRONG_FREQUENCY;
  79.                         break;
  80.                 }
  81.                 break;

  83.         case REPEATABILITY_HIGH:
  84.                 switch (frequency)
  85.                 {
  86.                 case FREQUENCY_HZ5:
  87.                         error = writeCommand(CMD_PERIODIC_HALF_H);
  88.                         break;
  89.                 case FREQUENCY_1HZ:
  90.                         error = writeCommand(CMD_PERIODIC_1_H);
  91.                         break;
  92.                 case FREQUENCY_2HZ:
  93.                         error = writeCommand(CMD_PERIODIC_2_H);
  94.                         break;
  95.                 case FREQUENCY_4HZ:
  96.                         error = writeCommand(CMD_PERIODIC_4_H);
  97.                         break;
  98.                 case FREQUENCY_10HZ:
  99.                         error = writeCommand(CMD_PERIODIC_10_H);
  100.                         break;
  101.                 default:
  102.                         error = PARAM_WRONG_FREQUENCY;
  103.                         break;
  104.                 }
  105.                 break;
  106.         default:
  107.                 error = PARAM_WRONG_REPEATABILITY;
  108.                 break;
  109.         }

  111.         return error;
  112. }

  114. SHT3XD ClosedCube_SHT3XD::readTempAndHumidity(SHT3XD_Repeatability repeatability, SHT3XD_Mode mode, uint8_t timeout)
  115. {
  116.         SHT3XD result;

  118.         switch (mode) {
  119.         case MODE_CLOCK_STRETCH:
  120.                 result = readTempAndHumidityClockStretch(repeatability);
  121.                 break;
  122.         case MODE_POLLING:
  123.                 result = readTempAndHumidityPolling(repeatability, timeout);
  124.                 break;
  125.         default:
  126.                 result = returnError(PARAM_WRONG_MODE);
  127.                 break;
  128.         }

  130.         return result;
  131. }


  134. SHT3XD ClosedCube_SHT3XD::readTempAndHumidityClockStretch(SHT3XD_Repeatability repeatability)
  135. {
  136.         SHT3XD_ErrorCode error = NO_ERROR;
  137.         SHT3XD_Commands command;

  139.         switch (repeatability)
  140.         {
  141.         case REPEATABILITY_LOW:
  142.                 error = writeCommand(CMD_CLOCK_STRETCH_L);
  143.                 break;
  144.         case REPEATABILITY_MEDIUM:
  145.                 error = writeCommand(CMD_CLOCK_STRETCH_M);
  146.                 break;
  147.         case REPEATABILITY_HIGH:
  148.                 error = writeCommand(CMD_CLOCK_STRETCH_H);
  149.                 break;
  150.         default:
  151.                 error = PARAM_WRONG_REPEATABILITY;
  152.                 break;
  153.         }

  155.         if (error == NO_ERROR) {
  156.                 return readTemperatureAndHumidity();
  157.         }
  158.         else {
  159.                 return returnError(error);
  160.         }

  162. }


  165. SHT3XD ClosedCube_SHT3XD::readTempAndHumidityPolling(SHT3XD_Repeatability repeatability, uint8_t timeout)
  166. {
  167.         SHT3XD_ErrorCode error = NO_ERROR;
  168.         SHT3XD_Commands command;

  170.         switch (repeatability)
  171.         {
  172.         case REPEATABILITY_LOW:
  173.                 error = writeCommand(CMD_POLLING_L);
  174.                 break;
  175.         case REPEATABILITY_MEDIUM:
  176.                 error = writeCommand(CMD_POLLING_M);
  177.                 break;
  178.         case REPEATABILITY_HIGH:
  179.                 error = writeCommand(CMD_POLLING_H);
  180.                 break;
  181.         default:
  182.                 error = PARAM_WRONG_REPEATABILITY;
  183.                 break;
  184.         }

  186.         if (error == NO_ERROR) {
  187.                 return readTemperatureAndHumidity();
  188.         }
  189.         else {
  190.                 return returnError(error);
  191.         }

  193. }

  195. SHT3XD ClosedCube_SHT3XD::readAlertHighSet() {
  196.         return readAlertData(CMD_READ_ALR_LIMIT_HS);
  197. }

  199. SHT3XD ClosedCube_SHT3XD::readAlertHighClear() {
  200.         return readAlertData(CMD_READ_ALR_LIMIT_HC);
  201. }

  203. SHT3XD ClosedCube_SHT3XD::readAlertLowSet() {
  204.         return readAlertData(CMD_READ_ALR_LIMIT_LS);
  205. }

  207. SHT3XD ClosedCube_SHT3XD::readAlertLowClear() {
  208.         return readAlertData(CMD_READ_ALR_LIMIT_LC);
  209. }


  212. SHT3XD_ErrorCode ClosedCube_SHT3XD::writeAlertHigh(float temperatureSet, float temperatureClear, float humiditySet, float humidityClear) {
  213.         SHT3XD_ErrorCode error = writeAlertData(CMD_WRITE_ALR_LIMIT_HS, temperatureSet, humiditySet);
  214.         if (error == NO_ERROR)
  215.                 error = writeAlertData(CMD_WRITE_ALR_LIMIT_HC, temperatureClear, humidityClear);

  217.         return error;
  218. }

  220. SHT3XD_ErrorCode ClosedCube_SHT3XD::writeAlertLow(float temperatureClear, float temperatureSet, float humidityClear, float humiditySet) {
  221.         SHT3XD_ErrorCode error = writeAlertData(CMD_WRITE_ALR_LIMIT_LS, temperatureSet, humiditySet);
  222.         if (error == NO_ERROR)
  223.                 writeAlertData(CMD_WRITE_ALR_LIMIT_LC, temperatureClear, humidityClear);

  225.         return error;
  226. }

  228. SHT3XD_ErrorCode ClosedCube_SHT3XD::writeAlertData(SHT3XD_Commands command, float temperature, float humidity)
  229. {
  230.         SHT3XD_ErrorCode  error;

  232.         if ((humidity < 0.0) || (humidity > 100.0) || (temperature < -40.0) || (temperature > 125.0))
  233.         {
  234.                 error = PARAM_WRONG_ALERT;
  235.         }
  236.         else
  237.         {
  238.                 uint16_t rawTemperature = calculateRaWTemperature(temperature);
  239.                 uint16_t rawHumidity = calculateRawHumidity(humidity);
  240.                 uint16_t data = (rawHumidity & 0xFE00) | ((rawTemperature >> 7) & 0x001FF);

  242.                 uint8_t        buf[2];
  243.                 buf[0] = data >> 8;
  244.                 buf[1] = data & 0xFF;

  246.                 uint8_t checksum = calculateCrc(buf);

  248.                 Wire.beginTransmission(_address);
  249.                 Wire.write(command >> 8);
  250.                 Wire.write(command & 0xFF);
  251.                 Wire.write(buf[0]);
  252.                 Wire.write(buf[1]);
  253.                 Wire.write(checksum);
  254.                 return (SHT3XD_ErrorCode)(-10 * Wire.endTransmission());
  255.         }

  257.         return error;
  258. }


  261. SHT3XD_ErrorCode ClosedCube_SHT3XD::writeCommand(SHT3XD_Commands command)
  262. {
  263.         Wire.beginTransmission(_address);
  264.         Wire.write(command >> 8);
  265.         Wire.write(command & 0xFF);
  266.         return (SHT3XD_ErrorCode)(-10 * Wire.endTransmission());
  267. }

  269. SHT3XD_ErrorCode ClosedCube_SHT3XD::softReset() {
  270.         return writeCommand(CMD_SOFT_RESET);
  271. }

  273. SHT3XD_ErrorCode ClosedCube_SHT3XD::generalCallReset() {
  274.         Wire.beginTransmission(0x0);
  275.         Wire.write(0x06);
  276.         return (SHT3XD_ErrorCode)(-10 * Wire.endTransmission());
  277. }

  279. SHT3XD_ErrorCode ClosedCube_SHT3XD::heaterEnable() {
  280.         return writeCommand(CMD_HEATER_ENABLE);
  281. }

  283. SHT3XD_ErrorCode ClosedCube_SHT3XD::heaterDisable() {
  284.         return writeCommand(CMD_HEATER_DISABLE);
  285. }

  287. SHT3XD_ErrorCode ClosedCube_SHT3XD::artEnable() {
  288.         return writeCommand(CMD_ART);
  289. }


  292. uint32_t ClosedCube_SHT3XD::readSerialNumber()
  293. {
  294.         uint32_t result = NO_ERROR;
  295.         uint16_t buf[2];

  297.         if (writeCommand(CMD_READ_SERIAL_NUMBER) == NO_ERROR) {
  298.                 if (read(buf, 2) == NO_ERROR) {
  299.                         result = (buf[0] << 16) | buf[1];
  300.                 }
  301.         }

  303.         return result;
  304. }

  306. SHT3XD_RegisterStatus ClosedCube_SHT3XD::readStatusRegister()
  307. {
  308.         SHT3XD_RegisterStatus result;

  310.         SHT3XD_ErrorCode error = writeCommand(CMD_READ_STATUS);
  311.         if (error == NO_ERROR)
  312.                 error = read(&result.rawData, 1);

  314.         return result;
  315. }

  317. SHT3XD_ErrorCode ClosedCube_SHT3XD::clearAll() {
  318.         return writeCommand(CMD_CLEAR_STATUS);
  319. }


  322. SHT3XD ClosedCube_SHT3XD::readTemperatureAndHumidity()
  323. {
  324.         SHT3XD result;

  326.         result.t = 0;
  327.         result.rh = 0;

  329.         SHT3XD_ErrorCode error;
  330.         uint16_t buf[2];

  332.         if (error == NO_ERROR)
  333.                 error = read(buf, 2);

  335.         if (error == NO_ERROR) {
  336.                 result.t = calculateTemperature(buf[0]);
  337.                 result.rh = calculateHumidity(buf[1]);
  338.         }
  339.         result.error = error;

  341.         return result;
  342. }

  344. SHT3XD ClosedCube_SHT3XD::readAlertData(SHT3XD_Commands command)
  345. {
  346.         SHT3XD result;

  348.         result.t = 0;
  349.         result.rh = 0;

  351.         SHT3XD_ErrorCode error;
  352.         uint16_t buf[1];

  354.         error = writeCommand(command);

  356.         if (error == NO_ERROR)
  357.                 error = read(buf, 1);

  359.         if (error == NO_ERROR) {
  360.                 result.rh = calculateHumidity(buf[0] << 7);
  361.                 result.t = calculateTemperature(buf[0] & 0xFE00);
  362.         }

  364.         result.error = error;

  366.         return result;
  367. }

  369. SHT3XD_ErrorCode ClosedCube_SHT3XD::read(uint16_t* data, uint8_t numOfPair)
  370. {
  371.         uint8_t        buf[2];
  372.         uint8_t checksum;

  374.         const uint8_t numOfBytes = numOfPair * 3;

  376.         Wire.beginTransmission(_address);
  377.         Wire.requestFrom(_address, numOfBytes);

  379.         int counter = 0;
  380.         while (Wire.available() < numOfBytes)
  381.         {
  382.                 counter++;
  383.                 delay(50);
  384.                 if (counter > 100)
  385.                         return TIMEOUT_ERROR;
  386.         }

  388.         for (counter = 0; counter < numOfPair; counter++) {
  389.                 Wire.readBytes(buf, 2);
  390.                 checksum = Wire.read();

  392.                 if (checkCrc(buf, checksum) != 0)
  393.                         return CRC_ERROR;

  395.                 data[counter] = (buf[0] << 8) | buf[1];
  396.         }

  398.         Wire.endTransmission();

  400.         return NO_ERROR;
  401. }


  404. uint8_t ClosedCube_SHT3XD::checkCrc(uint8_t data[], uint8_t checksum)
  405. {
  406.         return calculateCrc(data) != checksum;
  407. }

  409. float ClosedCube_SHT3XD::calculateTemperature(uint16_t rawValue)
  410. {
  411.         return 175.0f * (float)rawValue / 65535.0f - 45.0f;
  412. }


  415. float ClosedCube_SHT3XD::calculateHumidity(uint16_t rawValue)
  416. {
  417.         return 100.0f * rawValue / 65535.0f;
  418. }

  420. uint16_t ClosedCube_SHT3XD::calculateRaWTemperature(float value)
  421. {
  422.         return (value + 45.0f) / 175.0f * 65535.0f;
  423. }

  425. uint16_t ClosedCube_SHT3XD::calculateRawHumidity(float value)
  426. {
  427.         return value / 100.0f * 65535.0f;
  428. }

  430. uint8_t ClosedCube_SHT3XD::calculateCrc(uint8_t data[])
  431. {
  432.         uint8_t bit;
  433.         uint8_t crc = 0xFF;
  434.         uint8_t dataCounter = 0;

  436.         for (; dataCounter < 2; dataCounter++)
  437.         {
  438.                 crc ^= (data[dataCounter]);
  439.                 for (bit = 8; bit > 0; --bit)
  440.                 {
  441.                         if (crc & 0x80)
  442.                                 crc = (crc << 1) ^ 0x131;
  443.                         else
  444.                                 crc = (crc << 1);
  445.                 }
  446.         }

  448.         return crc;
  449. }

  451. SHT3XD ClosedCube_SHT3XD::returnError(SHT3XD_ErrorCode error) {
  452.         SHT3XD result;
  453.         result.t = 0;
  454.         result.rh = 0;
  455.         result.error = error;
  456.         return result;
  457. }
復制代碼

所有資料51hei提供下載:
SHT30-31-35全套資料.zip (3 MB, 下載次數(shù): 35)

作者: jzhok    時間: 2019-12-23 19:56
謝謝分享�。。�



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1