单片机论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 274|回复: 1
收起左侧

SHT30-31-35手册CAD模型,Arduino源代码等资料

[复制链接]
xiaoxiao365 发表于 2019-11-19 19:37 | 显示全部楼层 |阅读模式
SHT30-31-35资料
51hei.png 51hei.png

单片机源程序如下:
  1. #include <Wire.h>

  2. #include "ClosedCube_SHT3XD.h"

  3. ClosedCube_SHT3XD::ClosedCube_SHT3XD()
  4. {
  5. }

  6. SHT3XD_ErrorCode ClosedCube_SHT3XD::begin(uint8_t address) {
  7.         SHT3XD_ErrorCode error = NO_ERROR;
  8.         _address = address;
  9.         Wire.begin();

  10.         return error;
  11. }

  12. SHT3XD ClosedCube_SHT3XD::periodicFetchData()
  13. {
  14.         SHT3XD_ErrorCode error = writeCommand(CMD_FETCH_DATA);
  15.         if (error == NO_ERROR)
  16.                 return readTemperatureAndHumidity();
  17.         else
  18.                 returnError(error);
  19. }

  20. SHT3XD_ErrorCode ClosedCube_SHT3XD::periodicStop() {
  21.         return writeCommand(CMD_STOP_PERIODIC);
  22. }

  23. SHT3XD_ErrorCode ClosedCube_SHT3XD::periodicStart(SHT3XD_Repeatability repeatability, SHT3XD_Frequency frequency)
  24. {
  25.         SHT3XD_ErrorCode error;

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

  74.         case REPEATABILITY_HIGH:
  75.                 switch (frequency)
  76.                 {
  77.                 case FREQUENCY_HZ5:
  78.                         error = writeCommand(CMD_PERIODIC_HALF_H);
  79.                         break;
  80.                 case FREQUENCY_1HZ:
  81.                         error = writeCommand(CMD_PERIODIC_1_H);
  82.                         break;
  83.                 case FREQUENCY_2HZ:
  84.                         error = writeCommand(CMD_PERIODIC_2_H);
  85.                         break;
  86.                 case FREQUENCY_4HZ:
  87.                         error = writeCommand(CMD_PERIODIC_4_H);
  88.                         break;
  89.                 case FREQUENCY_10HZ:
  90.                         error = writeCommand(CMD_PERIODIC_10_H);
  91.                         break;
  92.                 default:
  93.                         error = PARAM_WRONG_FREQUENCY;
  94.                         break;
  95.                 }
  96.                 break;
  97.         default:
  98.                 error = PARAM_WRONG_REPEATABILITY;
  99.                 break;
  100.         }

  101.         return error;
  102. }

  103. SHT3XD ClosedCube_SHT3XD::readTempAndHumidity(SHT3XD_Repeatability repeatability, SHT3XD_Mode mode, uint8_t timeout)
  104. {
  105.         SHT3XD result;

  106.         switch (mode) {
  107.         case MODE_CLOCK_STRETCH:
  108.                 result = readTempAndHumidityClockStretch(repeatability);
  109.                 break;
  110.         case MODE_POLLING:
  111.                 result = readTempAndHumidityPolling(repeatability, timeout);
  112.                 break;
  113.         default:
  114.                 result = returnError(PARAM_WRONG_MODE);
  115.                 break;
  116.         }

  117.         return result;
  118. }


  119. SHT3XD ClosedCube_SHT3XD::readTempAndHumidityClockStretch(SHT3XD_Repeatability repeatability)
  120. {
  121.         SHT3XD_ErrorCode error = NO_ERROR;
  122.         SHT3XD_Commands command;

  123.         switch (repeatability)
  124.         {
  125.         case REPEATABILITY_LOW:
  126.                 error = writeCommand(CMD_CLOCK_STRETCH_L);
  127.                 break;
  128.         case REPEATABILITY_MEDIUM:
  129.                 error = writeCommand(CMD_CLOCK_STRETCH_M);
  130.                 break;
  131.         case REPEATABILITY_HIGH:
  132.                 error = writeCommand(CMD_CLOCK_STRETCH_H);
  133.                 break;
  134.         default:
  135.                 error = PARAM_WRONG_REPEATABILITY;
  136.                 break;
  137.         }

  138.         if (error == NO_ERROR) {
  139.                 return readTemperatureAndHumidity();
  140.         }
  141.         else {
  142.                 return returnError(error);
  143.         }

  144. }


  145. SHT3XD ClosedCube_SHT3XD::readTempAndHumidityPolling(SHT3XD_Repeatability repeatability, uint8_t timeout)
  146. {
  147.         SHT3XD_ErrorCode error = NO_ERROR;
  148.         SHT3XD_Commands command;

  149.         switch (repeatability)
  150.         {
  151.         case REPEATABILITY_LOW:
  152.                 error = writeCommand(CMD_POLLING_L);
  153.                 break;
  154.         case REPEATABILITY_MEDIUM:
  155.                 error = writeCommand(CMD_POLLING_M);
  156.                 break;
  157.         case REPEATABILITY_HIGH:
  158.                 error = writeCommand(CMD_POLLING_H);
  159.                 break;
  160.         default:
  161.                 error = PARAM_WRONG_REPEATABILITY;
  162.                 break;
  163.         }

  164.         if (error == NO_ERROR) {
  165.                 return readTemperatureAndHumidity();
  166.         }
  167.         else {
  168.                 return returnError(error);
  169.         }

  170. }

  171. SHT3XD ClosedCube_SHT3XD::readAlertHighSet() {
  172.         return readAlertData(CMD_READ_ALR_LIMIT_HS);
  173. }

  174. SHT3XD ClosedCube_SHT3XD::readAlertHighClear() {
  175.         return readAlertData(CMD_READ_ALR_LIMIT_HC);
  176. }

  177. SHT3XD ClosedCube_SHT3XD::readAlertLowSet() {
  178.         return readAlertData(CMD_READ_ALR_LIMIT_LS);
  179. }

  180. SHT3XD ClosedCube_SHT3XD::readAlertLowClear() {
  181.         return readAlertData(CMD_READ_ALR_LIMIT_LC);
  182. }


  183. SHT3XD_ErrorCode ClosedCube_SHT3XD::writeAlertHigh(float temperatureSet, float temperatureClear, float humiditySet, float humidityClear) {
  184.         SHT3XD_ErrorCode error = writeAlertData(CMD_WRITE_ALR_LIMIT_HS, temperatureSet, humiditySet);
  185.         if (error == NO_ERROR)
  186.                 error = writeAlertData(CMD_WRITE_ALR_LIMIT_HC, temperatureClear, humidityClear);

  187.         return error;
  188. }

  189. SHT3XD_ErrorCode ClosedCube_SHT3XD::writeAlertLow(float temperatureClear, float temperatureSet, float humidityClear, float humiditySet) {
  190.         SHT3XD_ErrorCode error = writeAlertData(CMD_WRITE_ALR_LIMIT_LS, temperatureSet, humiditySet);
  191.         if (error == NO_ERROR)
  192.                 writeAlertData(CMD_WRITE_ALR_LIMIT_LC, temperatureClear, humidityClear);

  193.         return error;
  194. }

  195. SHT3XD_ErrorCode ClosedCube_SHT3XD::writeAlertData(SHT3XD_Commands command, float temperature, float humidity)
  196. {
  197.         SHT3XD_ErrorCode  error;

  198.         if ((humidity < 0.0) || (humidity > 100.0) || (temperature < -40.0) || (temperature > 125.0))
  199.         {
  200.                 error = PARAM_WRONG_ALERT;
  201.         }
  202.         else
  203.         {
  204.                 uint16_t rawTemperature = calculateRaWTemperature(temperature);
  205.                 uint16_t rawHumidity = calculateRawHumidity(humidity);
  206.                 uint16_t data = (rawHumidity & 0xFE00) | ((rawTemperature >> 7) & 0x001FF);

  207.                 uint8_t        buf[2];
  208.                 buf[0] = data >> 8;
  209.                 buf[1] = data & 0xFF;

  210.                 uint8_t checksum = calculateCrc(buf);

  211.                 Wire.beginTransmission(_address);
  212.                 Wire.write(command >> 8);
  213.                 Wire.write(command & 0xFF);
  214.                 Wire.write(buf[0]);
  215.                 Wire.write(buf[1]);
  216.                 Wire.write(checksum);
  217.                 return (SHT3XD_ErrorCode)(-10 * Wire.endTransmission());
  218.         }

  219.         return error;
  220. }


  221. SHT3XD_ErrorCode ClosedCube_SHT3XD::writeCommand(SHT3XD_Commands command)
  222. {
  223.         Wire.beginTransmission(_address);
  224.         Wire.write(command >> 8);
  225.         Wire.write(command & 0xFF);
  226.         return (SHT3XD_ErrorCode)(-10 * Wire.endTransmission());
  227. }

  228. SHT3XD_ErrorCode ClosedCube_SHT3XD::softReset() {
  229.         return writeCommand(CMD_SOFT_RESET);
  230. }

  231. SHT3XD_ErrorCode ClosedCube_SHT3XD::generalCallReset() {
  232.         Wire.beginTransmission(0x0);
  233.         Wire.write(0x06);
  234.         return (SHT3XD_ErrorCode)(-10 * Wire.endTransmission());
  235. }

  236. SHT3XD_ErrorCode ClosedCube_SHT3XD::heaterEnable() {
  237.         return writeCommand(CMD_HEATER_ENABLE);
  238. }

  239. SHT3XD_ErrorCode ClosedCube_SHT3XD::heaterDisable() {
  240.         return writeCommand(CMD_HEATER_DISABLE);
  241. }

  242. SHT3XD_ErrorCode ClosedCube_SHT3XD::artEnable() {
  243.         return writeCommand(CMD_ART);
  244. }


  245. uint32_t ClosedCube_SHT3XD::readSerialNumber()
  246. {
  247.         uint32_t result = NO_ERROR;
  248.         uint16_t buf[2];

  249.         if (writeCommand(CMD_READ_SERIAL_NUMBER) == NO_ERROR) {
  250.                 if (read(buf, 2) == NO_ERROR) {
  251.                         result = (buf[0] << 16) | buf[1];
  252.                 }
  253.         }

  254.         return result;
  255. }

  256. SHT3XD_RegisterStatus ClosedCube_SHT3XD::readStatusRegister()
  257. {
  258.         SHT3XD_RegisterStatus result;

  259.         SHT3XD_ErrorCode error = writeCommand(CMD_READ_STATUS);
  260.         if (error == NO_ERROR)
  261.                 error = read(&result.rawData, 1);

  262.         return result;
  263. }

  264. SHT3XD_ErrorCode ClosedCube_SHT3XD::clearAll() {
  265.         return writeCommand(CMD_CLEAR_STATUS);
  266. }


  267. SHT3XD ClosedCube_SHT3XD::readTemperatureAndHumidity()
  268. {
  269.         SHT3XD result;

  270.         result.t = 0;
  271.         result.rh = 0;

  272.         SHT3XD_ErrorCode error;
  273.         uint16_t buf[2];

  274.         if (error == NO_ERROR)
  275.                 error = read(buf, 2);

  276.         if (error == NO_ERROR) {
  277.                 result.t = calculateTemperature(buf[0]);
  278.                 result.rh = calculateHumidity(buf[1]);
  279.         }
  280.         result.error = error;

  281.         return result;
  282. }

  283. SHT3XD ClosedCube_SHT3XD::readAlertData(SHT3XD_Commands command)
  284. {
  285.         SHT3XD result;

  286.         result.t = 0;
  287.         result.rh = 0;

  288.         SHT3XD_ErrorCode error;
  289.         uint16_t buf[1];

  290.         error = writeCommand(command);

  291.         if (error == NO_ERROR)
  292.                 error = read(buf, 1);

  293.         if (error == NO_ERROR) {
  294.                 result.rh = calculateHumidity(buf[0] << 7);
  295.                 result.t = calculateTemperature(buf[0] & 0xFE00);
  296.         }

  297.         result.error = error;

  298.         return result;
  299. }

  300. SHT3XD_ErrorCode ClosedCube_SHT3XD::read(uint16_t* data, uint8_t numOfPair)
  301. {
  302.         uint8_t        buf[2];
  303.         uint8_t checksum;

  304.         const uint8_t numOfBytes = numOfPair * 3;

  305.         Wire.beginTransmission(_address);
  306.         Wire.requestFrom(_address, numOfBytes);

  307.         int counter = 0;
  308.         while (Wire.available() < numOfBytes)
  309.         {
  310.                 counter++;
  311.                 delay(50);
  312.                 if (counter > 100)
  313.                         return TIMEOUT_ERROR;
  314.         }

  315.         for (counter = 0; counter < numOfPair; counter++) {
  316.                 Wire.readBytes(buf, 2);
  317.                 checksum = Wire.read();

  318.                 if (checkCrc(buf, checksum) != 0)
  319.                         return CRC_ERROR;

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

  322.         Wire.endTransmission();

  323.         return NO_ERROR;
  324. }


  325. uint8_t ClosedCube_SHT3XD::checkCrc(uint8_t data[], uint8_t checksum)
  326. {
  327.         return calculateCrc(data) != checksum;
  328. }

  329. float ClosedCube_SHT3XD::calculateTemperature(uint16_t rawValue)
  330. {
  331.         return 175.0f * (float)rawValue / 65535.0f - 45.0f;
  332. }


  333. float ClosedCube_SHT3XD::calculateHumidity(uint16_t rawValue)
  334. {
  335.         return 100.0f * rawValue / 65535.0f;
  336. }

  337. uint16_t ClosedCube_SHT3XD::calculateRaWTemperature(float value)
  338. {
  339.         return (value + 45.0f) / 175.0f * 65535.0f;
  340. }

  341. uint16_t ClosedCube_SHT3XD::calculateRawHumidity(float value)
  342. {
  343.         return value / 100.0f * 65535.0f;
  344. }

  345. uint8_t ClosedCube_SHT3XD::calculateCrc(uint8_t data[])
  346. {
  347.         uint8_t bit;
  348.         uint8_t crc = 0xFF;
  349.         uint8_t dataCounter = 0;

  350.         for (; dataCounter < 2; dataCounter++)
  351.         {
  352.                 crc ^= (data[dataCounter]);
  353.                 for (bit = 8; bit > 0; --bit)
  354.                 {
  355.                         if (crc & 0x80)
  356.                                 crc = (crc << 1) ^ 0x131;
  357.                         else
  358.                                 crc = (crc << 1);
  359.                 }
  360.         }

  361.         return crc;
  362. }

  363. SHT3XD ClosedCube_SHT3XD::returnError(SHT3XD_ErrorCode error) {
  364.         SHT3XD result;
  365.         result.t = 0;
  366.         result.rh = 0;
  367.         result.error = error;
  368.         return result;
  369. }
复制代码

所有资料51hei提供下载:
SHT30-31-35全套资料.zip (3 MB, 下载次数: 3)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励!

查看全部评分

回复

使用道具 举报

jzhok 发表于 2019-12-23 19:56 | 显示全部楼层
谢谢分享!!!
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|单片机论坛 |51黑电子论坛技术交流 QQ 管理员QQ:125739409;技术交流QQ群636986012

Powered by 单片机教程网

快速回复 返回顶部 返回列表
妞干网免费观看频2018