欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標題: SHT30溫濕度傳感器 STM32F103 IIC程序源碼 [打印本頁]
作者: cetcnav    時間: 2018-12-26 16:33
標題: SHT30溫濕度傳感器 STM32F103 IIC程序源碼


1、程序功能


       程序成功讀取到SHT30的溫濕度數據后，通過單片機的 串口1 將測得的溫濕度數據打印出來。(注：程序中有4個warning，無需理會)




2、硬件連接

                         單片機                 SHT30模塊


                          PB14    ----------     SDA

                          PB13    ----------     SCL



聲明：程序是在 原子哥的例程--實驗4 串口實驗 基礎上修改的，感謝原子哥為大家提供了諸多stm32教程和例程。

單片機源程序如下:
  1. //=============================================================================
  2. //    S E N S I R I O N   AG,  Laubisruetistr. 50, CH-8712 Staefa, Switzerland
  3. //=============================================================================
  4. // Project   :  SHT3x Sample Code (V1.1)
  5. // File      :  sht3x.c (V1.1)
  6. // Author    :  RFU
  7. // Date      :  6-Mai-2015
  8. // Controller:  STM32F100RB
  9. // IDE       :  礦ision V5.12.0.0
  10. // Compiler  :  Armcc
  11. // Brief     :  Sensor Layer: Implementation of functions for sensor access.
  12. //=============================================================================

  14. //-- Includes -----------------------------------------------------------------
  15. #include "sht3x.h"
  16. #include "i2c_hal.h"

  18. //-- Defines ------------------------------------------------------------------
  19. // Generator polynomial for CRC
  20. #define POLYNOMIAL  0x131 // P(x) = x^8 + x^5 + x^4 + 1 = 100110001

  22. //=============================================================================
  23. // IO-Pins                            /* -- adapt the defines for your uC -- */
  24. //-----------------------------------------------------------------------------
  25. // Reset on port B, bit 12
  26. #define RESET_LOW()  (GPIOB->BSRR = 0x10000000) // set Reset to low
  27. #define RESET_HIGH() (GPIOB->BSRR = 0x00001000) // set Reset to high

  29. // Alert on port B, bit 10
  30. #define ALERT_READ   (GPIOB->IDR  & 0x0400)     // read Alert
  31. //=============================================================================

  33. //-- Global variables ---------------------------------------------------------
  34. static u8t _i2cAddress; // I2C Address

  36. //-- Static function prototypes -----------------------------------------------
  37. static etError SHT3X_WriteAlertLimitData(ft humidity, ft temperature);
  38. static etError SHT3X_ReadAlertLimitData(ft* humidity, ft* temperature);
  39. static etError SHT3X_StartWriteAccess(void);
  40. static etError SHT3X_StartReadAccess(void);
  41. static void SHT3X_StopAccess(void);
  42. static etError SHT3X_WriteCommand(etCommands command);
  43. static etError SHT3X_Read2BytesAndCrc(u16t* data, etI2cAck finaleAckNack,
  44.                                       u8t timeout);
  45. static etError SHT3X_Write2BytesAndCrc(u16t data);
  46. static u8t SHT3X_CalcCrc(u8t data[], u8t nbrOfBytes);
  47. static etError SHT3X_CheckCrc(u8t data[], u8t nbrOfBytes, u8t checksum);
  48. static ft SHT3X_CalcTemperature(u16t rawValue);
  49. static ft SHT3X_CalcHumidity(u16t rawValue);
  50. static u16t SHT3X_CalcRawTemperature(ft temperature);
  51. static u16t SHT3X_CalcRawHumidity(ft humidity);

  53. //-----------------------------------------------------------------------------
  54. void SHT3X_Init(u8t i2cAddress)          /* -- adapt the init for your uC -- */
  55. {
  56.   // init I/O-pins
  57.   RCC->APB2ENR |= 0x00000008;  // I/O port B clock enabled
  58.   
  59.   // Alert on port B, bit 10
  60.   GPIOB->CRH   &= 0xFFFFF0FF;  // set floating input for Alert-Pin
  61.   GPIOB->CRH   |= 0x00000400;  //
  62.   
  63.   // Reset on port B, bit 12
  64.   GPIOB->CRH   &= 0xFFF0FFFF;  // set push-pull output for Reset pin
  65.   GPIOB->CRH   |= 0x00010000;  //
  66.   RESET_LOW();
  67.   
  68.   I2c_Init(); // init I2C
  69.   SHT3X_SetI2cAdr(i2cAddress);
  70.   
  71.   // release reset
  72.   RESET_HIGH();
  73. }

  75. //-----------------------------------------------------------------------------
  76. void SHT3X_SetI2cAdr(u8t i2cAddress)
  77. {
  78.   _i2cAddress = i2cAddress;
  79. }

  81. //-----------------------------------------------------------------------------
  82. etError SHT3x_ReadSerialNumber(u32t* serialNumber)
  83. {
  84.   etError error; // error code
  85.   u16t serialNumWords[2];
  86.   
  87.   error = SHT3X_StartWriteAccess();
  88.   
  89.   // write "read serial number" command
  90.   error |= SHT3X_WriteCommand(CMD_READ_SERIALNBR);
  91.   // if no error, start read access
  92.   if(error == NO_ERROR) error = SHT3X_StartReadAccess();
  93.   // if no error, read first serial number word
  94.   if(error == NO_ERROR) error = SHT3X_Read2BytesAndCrc(&serialNumWords[0], ACK, 100);
  95.   // if no error, read second serial number word
  96.   if(error == NO_ERROR) error = SHT3X_Read2BytesAndCrc(&serialNumWords[1], NACK, 0);
  97.   
  98.   SHT3X_StopAccess();
  99.   
  100.   // if no error, calc serial number as 32-bit integer
  101.   if(error == NO_ERROR)
  102.   {
  103.     *serialNumber = (serialNumWords[0] << 16) | serialNumWords[1];
  104.   }
  105.   
  106.   return error;
  107. }

  109. //-----------------------------------------------------------------------------
  110. etError SHT3X_ReadStatus(u16t* status)
  111. {
  112.   etError error; // error code
  113.   
  114.   error = SHT3X_StartWriteAccess();
  115.   
  116.   // if no error, write "read status" command
  117.   if(error == NO_ERROR) error = SHT3X_WriteCommand(CMD_READ_STATUS);
  118.   // if no error, start read access
  119.   if(error == NO_ERROR) error = SHT3X_StartReadAccess();
  120.   // if no error, read status
  121.   if(error == NO_ERROR) error = SHT3X_Read2BytesAndCrc(status, NACK, 0);
  122.   
  123.   SHT3X_StopAccess();
  124.   
  125.   return error;
  126. }

  128. //-----------------------------------------------------------------------------
  129. etError SHT3X_ClearAllAlertFlags(void)
  130. {
  131.   etError error; // error code
  132.   
  133.   error = SHT3X_StartWriteAccess();
  134.   
  135.   // if no error, write clear status register command
  136.   if(error == NO_ERROR) error = SHT3X_WriteCommand(CMD_CLEAR_STATUS);
  137.   
  138.   SHT3X_StopAccess();
  139.   
  140.   return error;
  141. }

  143. //-----------------------------------------------------------------------------
  144. etError SHT3X_GetTempAndHumi(ft* temperature, ft* humidity,
  145.                              etRepeatability repeatability, etMode mode,
  146.                              u8t timeout)
  147. {
  148.   etError error;
  149.                               
  150.   switch(mode)
  151.   {   
  152.     case MODE_CLKSTRETCH: // get temperature with clock stretching mode
  153.       error = SHT3X_GetTempAndHumiClkStretch(temperature, humidity,
  154.                                              repeatability, timeout);
  155.       break;
  156.     case MODE_POLLING:    // get temperature with polling mode
  157.       error = SHT3X_GetTempAndHumiPolling(temperature, humidity,
  158.                                           repeatability, timeout);
  159.       break;
  160.     default:              
  161.       error = PARM_ERROR;
  162.       break;
  163.   }
  164.   
  165.   return error;
  166. }


  169. //-----------------------------------------------------------------------------
  170. etError SHT3X_GetTempAndHumiClkStretch(ft* temperature, ft* humidity,
  171.                                        etRepeatability repeatability,
  172.                                        u8t timeout)
  173. {
  174.   etError error;        // error code
  175.   u16t    rawValueTemp; // temperature raw value from sensor
  176.   u16t    rawValueHumi; // humidity raw value from sensor
  177.   
  178.   error = SHT3X_StartWriteAccess();
  179.   
  180.   // if no error ...
  181.   if(error == NO_ERROR)
  182.   {
  183.     // start measurement in clock stretching mode
  184.     // use depending on the required repeatability, the corresponding command
  185.     switch(repeatability)
  186.     {
  187.       case REPEATAB_LOW:
  188.         error = SHT3X_WriteCommand(CMD_MEAS_CLOCKSTR_L);
  189.         break;
  190.       case REPEATAB_MEDIUM:
  191.         error = SHT3X_WriteCommand(CMD_MEAS_CLOCKSTR_M);
  192.         break;
  193.       case REPEATAB_HIGH:
  194.         error = SHT3X_WriteCommand(CMD_MEAS_CLOCKSTR_H);
  195.         break;
  196.       default:
  197.         error = PARM_ERROR;
  198.         break;
  199.     }
  200.   }

  202.   // if no error, start read access
  203.   if(error == NO_ERROR) error = SHT3X_StartReadAccess();
  204.   // if no error, read temperature raw values
  205.   if(error == NO_ERROR) error = SHT3X_Read2BytesAndCrc(&rawValueTemp, ACK, timeout);
  206.   // if no error, read humidity raw values
  207.   if(error == NO_ERROR) error = SHT3X_Read2BytesAndCrc(&rawValueHumi, NACK, 0);
  208.   
  209.   SHT3X_StopAccess();
  210.   
  211.   // if no error, calculate temperature in 癈 and humidity in %RH
  212.   if(error == NO_ERROR)
  213.   {
  214.     *temperature = SHT3X_CalcTemperature(rawValueTemp);
  215.     *humidity = SHT3X_CalcHumidity(rawValueHumi);
  216.   }
  217.   
  218.   return error;
  219. }

  221. //-----------------------------------------------------------------------------
  222. etError SHT3X_GetTempAndHumiPolling(ft* temperature, ft* humidity,
  223.                                     etRepeatability repeatability,
  224.                                     u8t timeout)
  225. {
  226.   etError error;           // error code
  227.   u16t    rawValueTemp;    // temperature raw value from sensor
  228.   u16t    rawValueHumi;    // humidity raw value from sensor
  229.   
  230.   error  = SHT3X_StartWriteAccess();
  231.   
  232.   // if no error ...
  233.   if(error == NO_ERROR)
  234.   {
  235.     // start measurement in polling mode
  236.     // use depending on the required repeatability, the corresponding command
  237.     switch(repeatability)
  238.     {
  239.       case REPEATAB_LOW:
  240.         error = SHT3X_WriteCommand(CMD_MEAS_POLLING_L);
  241.         break;
  242.       case REPEATAB_MEDIUM:
  243.         error = SHT3X_WriteCommand(CMD_MEAS_POLLING_M);
  244.         break;
  245.       case REPEATAB_HIGH:
  246.         error = SHT3X_WriteCommand(CMD_MEAS_POLLING_H);
  247.         break;
  248.       default:
  249.         error = PARM_ERROR;
  250.         break;
  251.     }
  252.   }
  253.   
  254.   // if no error, wait until measurement ready
  255.   if(error == NO_ERROR)
  256.   {
  257.     // poll every 1ms for measurement ready until timeout
  258.     while(timeout--)
  259.     {
  260.       // check if the measurement has finished
  261.       error = SHT3X_StartReadAccess();
  262.   
  263.       // if measurement has finished -> exit loop
  264.       if(error == NO_ERROR) break;
  265.   
  266.       // delay 1ms
  267.       DelayMicroSeconds(1000);
  268.     }
  269.    
  270.     // check for timeout error
  271.     if(timeout == 0) error = TIMEOUT_ERROR;
  272.   }
  273.   
  274.   // if no error, read temperature and humidity raw values
  275.   if(error == NO_ERROR)
  276.   {
  277.     error |= SHT3X_Read2BytesAndCrc(&rawValueTemp, ACK, 0);
  278.     error |= SHT3X_Read2BytesAndCrc(&rawValueHumi, NACK, 0);
  279.   }
  280.   
  281.   SHT3X_StopAccess();
  282.   
  283.   // if no error, calculate temperature in 癈 and humidity in %RH
  284.   if(error == NO_ERROR)
  285.   {
  286.     *temperature = SHT3X_CalcTemperature(rawValueTemp);
  287.     *humidity = SHT3X_CalcHumidity(rawValueHumi);
  288.   }
  289.   
  290.   return error;
  291. }

  293. //-----------------------------------------------------------------------------
  294. etError SHT3X_StartPeriodicMeasurment(etRepeatability repeatability,
  295.                                       etFrequency frequency)
  296. {
  297.   etError error;        // error code
  298.   
  299.   error = SHT3X_StartWriteAccess();
  300.   
  301.   // if no error, start periodic measurement
  302.   if(error == NO_ERROR)
  303.   {
  304.     // use depending on the required repeatability and frequency,
  305.     // the corresponding command
  306.     switch(repeatability)
  307.     {
  308.       case REPEATAB_LOW: // low repeatability
  309.         switch(frequency)
  310.         {
  311.           case FREQUENCY_HZ5:  // low repeatability,  0.5 Hz
  312.             error |= SHT3X_WriteCommand(CMD_MEAS_PERI_05_L);
  313.             break;         
  314.           case FREQUENCY_1HZ:  // low repeatability,  1.0 Hz
  315.             error |= SHT3X_WriteCommand(CMD_MEAS_PERI_1_L);
  316.             break;         
  317.           case FREQUENCY_2HZ:  // low repeatability,  2.0 Hz
  318.             error |= SHT3X_WriteCommand(CMD_MEAS_PERI_2_L);
  319.             break;         
  320.           case FREQUENCY_4HZ:  // low repeatability,  4.0 Hz
  321.             error |= SHT3X_WriteCommand(CMD_MEAS_PERI_4_L);
  322.             break;         
  323.           case FREQUENCY_10HZ: // low repeatability, 10.0 Hz
  324.             error |= SHT3X_WriteCommand(CMD_MEAS_PERI_10_L);
  325.             break;         
  326.           default:
  327.             error |= PARM_ERROR;
  328.             break;
  329.         }
  330.         break;
  331.         
  332.       case REPEATAB_MEDIUM: // medium repeatability
  333.         switch(frequency)
  334.         {
  335.           case FREQUENCY_HZ5:  // medium repeatability,  0.5 Hz
  336.             error |= SHT3X_WriteCommand(CMD_MEAS_PERI_05_M);
  337.                         break;
  338.           case FREQUENCY_1HZ:  // medium repeatability,  1.0 Hz
  339.             error |= SHT3X_WriteCommand(CMD_MEAS_PERI_1_M);
  340.                         break;        
  341.           case FREQUENCY_2HZ:  // medium repeatability,  2.0 Hz
  342.             error |= SHT3X_WriteCommand(CMD_MEAS_PERI_2_M);
  343.                         break;        
  344.           case FREQUENCY_4HZ:  // medium repeatability,  4.0 Hz
  345.             error |= SHT3X_WriteCommand(CMD_MEAS_PERI_4_M);
  346.                         break;      
  347.           case FREQUENCY_10HZ: // medium repeatability, 10.0 Hz
  348.             error |= SHT3X_WriteCommand(CMD_MEAS_PERI_10_M);
  349.                         break;
  350.           default:
  351.             error |= PARM_ERROR;
  352.                         break;
  353.         }
  354.         break;
  355.         
  356.       case REPEATAB_HIGH: // high repeatability
  357.         switch(frequency)
  358.         {
  359.           case FREQUENCY_HZ5:  // high repeatability,  0.5 Hz
  360.             error |= SHT3X_WriteCommand(CMD_MEAS_PERI_05_H);
  361.             break;
  362.           case FREQUENCY_1HZ:  // high repeatability,  1.0 Hz
  363.             error |= SHT3X_WriteCommand(CMD_MEAS_PERI_1_H);
  364.             break;
  365.           case FREQUENCY_2HZ:  // high repeatability,  2.0 Hz
  366.             error |= SHT3X_WriteCommand(CMD_MEAS_PERI_2_H);
  367.             break;
  368.           case FREQUENCY_4HZ:  // high repeatability,  4.0 Hz
  369.             error |= SHT3X_WriteCommand(CMD_MEAS_PERI_4_H);
  370.             break;
  371.           case FREQUENCY_10HZ: // high repeatability, 10.0 Hz
  372.             error |= SHT3X_WriteCommand(CMD_MEAS_PERI_10_H);
  373.             break;
  374.           default:
  375.             error |= PARM_ERROR;
  376.             break;
  377.         }
  378.         break;
  379.       default:
  380.         error |= PARM_ERROR;
  381.         break;
  382.     }
  383.   }

  385.   SHT3X_StopAccess();

  387.   return error;
  388. }

  390. //-----------------------------------------------------------------------------
  391. etError SHT3X_ReadMeasurementBuffer(ft* temperature, ft* humidity)
  392. {
  393.   etError  error;        // error code
  394.   u16t     rawValueTemp; // temperature raw value from sensor
  395.   u16t     rawValueHumi; // humidity raw value from sensor

  397.   error = SHT3X_StartWriteAccess();

  399.   // if no error, read measurements
  400.   if(error == NO_ERROR) error = SHT3X_WriteCommand(CMD_FETCH_DATA);
  401.   if(error == NO_ERROR) error = SHT3X_StartReadAccess();  
  402.   if(error == NO_ERROR) error = SHT3X_Read2BytesAndCrc(&rawValueTemp, ACK, 0);
  403.   if(error == NO_ERROR) error = SHT3X_Read2BytesAndCrc(&rawValueHumi, NACK, 0);

  405.   // if no error, calculate temperature in 癈 and humidity in %RH
  406.   if(error == NO_ERROR)
  407.   {
  408.     *temperature = SHT3X_CalcTemperature(rawValueTemp);
  409.     *humidity = SHT3X_CalcHumidity(rawValueHumi);
  410.   }

  412.   SHT3X_StopAccess();

  414.   return error;
  415. }

  417. //-----------------------------------------------------------------------------
  418. etError SHT3X_EnableHeater(void)
  419. {
  420.   etError error; // error code

  422.   error = SHT3X_StartWriteAccess();

  424.   // if no error, write heater enable command
  425.   if(error == NO_ERROR) error = SHT3X_WriteCommand(CMD_HEATER_ENABLE);

  427.   SHT3X_StopAccess();

  429.   return error;
  430. }

  432. //-----------------------------------------------------------------------------
  433. etError SHT3X_DisableHeater(void)
  434. {
  435.   etError error; // error code

  437.   error = SHT3X_StartWriteAccess();

  439.   // if no error, write heater disable command
  440.   if(error == NO_ERROR) error = SHT3X_WriteCommand(CMD_HEATER_DISABLE);

  442.   SHT3X_StopAccess();

  444.   return error;
  445. }


  448. //-----------------------------------------------------------------------------
  449. etError SHT3X_SetAlertLimits(ft humidityHighSet,   ft temperatureHighSet,
  450.                              ft humidityHighClear, ft temperatureHighClear,
  451.                              ft humidityLowClear,  ft temperatureLowClear,
  452.                              ft humidityLowSet,    ft temperatureLowSet)
  453. {
  454.   etError  error;  // error code
  455.   
  456.   // write humidity & temperature alter limits, high set
  457.   error = SHT3X_StartWriteAccess();
  458.   if(error == NO_ERROR) error = SHT3X_WriteCommand(CMD_W_AL_LIM_HS);
  459.   if(error == NO_ERROR) error = SHT3X_WriteAlertLimitData(humidityHighSet,
  460.                                                           temperatureHighSet);
  461.   SHT3X_StopAccess();

  463.   if(error == NO_ERROR)
  464.   {
  465.     // write humidity & temperature alter limits, high clear
  466.     error = SHT3X_StartWriteAccess();
  467.     if(error == NO_ERROR) error = SHT3X_WriteCommand(CMD_W_AL_LIM_HC);
  468.     if(error == NO_ERROR) error = SHT3X_WriteAlertLimitData(humidityHighClear,
  469.                                                             temperatureHighClear);
  470.     SHT3X_StopAccess();
  471.   }

  473.   if(error == NO_ERROR)
  474.   {
  475.     // write humidity & temperature alter limits, low clear
  476.     error = SHT3X_StartWriteAccess();
  477.     if(error == NO_ERROR) error = SHT3X_WriteCommand(CMD_W_AL_LIM_LC);
  478.     if(error == NO_ERROR) error = SHT3X_WriteAlertLimitData(humidityLowClear,
  479.                                                             temperatureLowClear);
  480.     SHT3X_StopAccess();
  481.   }
  482.   
  483.   if(error == NO_ERROR)
  484.   {
  485.     // write humidity & temperature alter limits, low set
  486.     error = SHT3X_StartWriteAccess();
  487.     if(error == NO_ERROR) error = SHT3X_WriteCommand(CMD_W_AL_LIM_LS);
  488.     if(error == NO_ERROR) error = SHT3X_WriteAlertLimitData(humidityLowSet,
  489.                                                             temperatureLowSet);
  490.     SHT3X_StopAccess();
  491.   }

  493.   return error;
  494. }

  496. //-----------------------------------------------------------------------------
  497. etError SHT3X_GetAlertLimits(ft* humidityHighSet,   ft* temperatureHighSet,
  498.                              ft* humidityHighClear, ft* temperatureHighClear,
  499.                              ft* humidityLowClear,  ft* temperatureLowClear,
  500.                              ft* humidityLowSet,    ft* temperatureLowSet)
  501. {
  502.   etError  error;  // error code
  503.   
  504.   // read humidity & temperature alter limits, high set
  505.   error = SHT3X_StartWriteAccess();
  506.   if(error == NO_ERROR) error = SHT3X_WriteCommand(CMD_R_AL_LIM_HS);
  507.   if(error == NO_ERROR) error = SHT3X_StartReadAccess();
  508.   if(error == NO_ERROR) error = SHT3X_ReadAlertLimitData(humidityHighSet,
  509.                                                          temperatureHighSet);
  510.   SHT3X_StopAccess();

  512.   if(error == NO_ERROR)
  513.   {
  514.     // read humidity & temperature alter limits, high clear
  515.     error = SHT3X_StartWriteAccess();
  516.     if(error == NO_ERROR) error = SHT3X_WriteCommand(CMD_R_AL_LIM_HC);
  517.     if(error == NO_ERROR) error = SHT3X_StartReadAccess();
  518.     if(error == NO_ERROR) error = SHT3X_ReadAlertLimitData(humidityHighClear,
  519.                                                            temperatureHighClear);
  520.     SHT3X_StopAccess();
  521.   }

  523.   if(error == NO_ERROR)
  524.   {
  525.     // read humidity & temperature alter limits, low clear
  526.     error = SHT3X_StartWriteAccess();
  527.     if(error == NO_ERROR) error = SHT3X_WriteCommand(CMD_R_AL_LIM_LC);
  528.     if(error == NO_ERROR) error = SHT3X_StartReadAccess();
  529.     if(error == NO_ERROR) error = SHT3X_ReadAlertLimitData(humidityLowClear,
  530.                                                            temperatureLowClear);
  531.     SHT3X_StopAccess();
  532.   }

  534.   if(error == NO_ERROR)
  535.   {
  536.     // read humidity & temperature alter limits, low set
  537.     error = SHT3X_StartWriteAccess();
  538.     if(error == NO_ERROR) error = SHT3X_WriteCommand(CMD_R_AL_LIM_LS);
  539.     if(error == NO_ERROR) error = SHT3X_StartReadAccess();
  540.     if(error == NO_ERROR) error = SHT3X_ReadAlertLimitData(humidityLowSet,
  541.                                                            temperatureLowSet);
  542.     SHT3X_StopAccess();
  543.   }

  545.   return error;
  546. }
  547.                              
  548. //-----------------------------------------------------------------------------
  549. bt SHT3X_ReadAlert(void)
  550. {
  551.   // read alert pin
  552.   return (ALERT_READ != 0) ? TRUE : FALSE;
  553. }

  555. //-----------------------------------------------------------------------------
  556. etError SHT3X_SoftReset(void)
  557. {
  558.   etError error; // error code

  560.   error = SHT3X_StartWriteAccess();

  562.   // write reset command
  563.   error |= SHT3X_WriteCommand(CMD_SOFT_RESET);

  565.   SHT3X_StopAccess();
  566.   
  567.   // if no error, wait 50 ms after reset
  568.   if(error == NO_ERROR) DelayMicroSeconds(50000);

  570.   return error;
  571. }

  573. //-----------------------------------------------------------------------------
  574. void SHT3X_HardReset(void)
  575. {
  576.   // set reset low
  577.   RESET_LOW();

  579.   // wait 100 ms
  580.   DelayMicroSeconds(100000);
  581.   
  582.   // release reset
  583.   RESET_HIGH();
  584.   
  585.   // wait 50 ms after reset
  586.   DelayMicroSeconds(50000);
  587. }

  589.                              
  590. //-----------------------------------------------------------------------------
  591. static etError SHT3X_WriteAlertLimitData(ft humidity, ft temperature)
  592. {
  593.   etError  error;           // error code
  594.   
  595.   i16t rawHumidity;
  596.   i16t rawTemperature;
  597.   
  598.   if((humidity < 0.0f) || (humidity > 100.0f)
  599.   || (temperature < -45.0f) || (temperature > 130.0f))
  600.   {
  601.     error = PARM_ERROR;
  602.   }
  603.   else
  604.   {
  605.     rawHumidity    = SHT3X_CalcRawHumidity(humidity);
  606.     rawTemperature = SHT3X_CalcRawTemperature(temperature);

  608.     error = SHT3X_Write2BytesAndCrc((rawHumidity & 0xFE00) | ((rawTemperature >> 7) & 0x001FF));
  609.   }
  610.   
  611.   return error;
  612. }

  614. //-----------------------------------------------------------------------------
  615. static etError SHT3X_ReadAlertLimitData(ft* humidity, ft* temperature)
  616. {
  617.   etError  error;           // error code
  618.   u16t     data;
  619.   
  620.   error = SHT3X_Read2BytesAndCrc(&data, NACK, 0);
  621.   
  622.   if(error == NO_ERROR)
  623.   {
  624.     *humidity = SHT3X_CalcHumidity(data & 0xFE00);
  625.     *temperature = SHT3X_CalcTemperature(data << 7);
  626.   }
  627.   
  628.   return error;
  629. }

  631. //-----------------------------------------------------------------------------
  632. static etError SHT3X_StartWriteAccess(void)
  633. {
  634.   etError error; // error code

  636.   // write a start condition
  637.   I2c_StartCondition();

  639.   // write the sensor I2C address with the write flag
  640.   error = I2c_WriteByte(_i2cAddress << 1);

  642.   return error;
  643. }

  645. //-----------------------------------------------------------------------------
  646. static etError SHT3X_StartReadAccess(void)
  647. {
  648.   etError error; // error code

  650.   // write a start condition
  651.   I2c_StartCondition();

  653.   // write the sensor I2C address with the read flag
  654.   error = I2c_WriteByte(_i2cAddress << 1 | 0x01);

  656.   return error;
  657. }

  659. //-----------------------------------------------------------------------------
  660. static void SHT3X_StopAccess(void)
  661. {
  662.   // write a stop condition
  663.   I2c_StopCondition();
  664. }

  666. //-----------------------------------------------------------------------------
  667. static etError SHT3X_WriteCommand(etCommands command)
  668. {
  669.   etError error; // error code

  671.   // write the upper 8 bits of the command to the sensor
  672.   error  = I2c_WriteByte(command >> 8);

  674.   // write the lower 8 bits of the command to the sensor
  675.   error |= I2c_WriteByte(command & 0xFF);

  677.   return error;
  678. }

  680. //-----------------------------------------------------------------------------
  681. static etError SHT3X_Read2BytesAndCrc(u16t* data, etI2cAck finaleAckNack,
  682.                                       u8t timeout)
  683. {
  684.   etError error;    // error code
  685.   u8t     bytes[2]; // read data array
  686.   u8t     checksum; // checksum byte

  688.   // read two data bytes and one checksum byte
  689.                         error = I2c_ReadByte(&bytes[0], ACK, timeout);
  690.   if(error == NO_ERROR) error = I2c_ReadByte(&bytes[1], ACK, 0);
  691.   if(error == NO_ERROR) error = I2c_ReadByte(&checksum, finaleAckNack, 0);
  692.   
  693.   // verify checksum
  694.   if(error == NO_ERROR) error = SHT3X_CheckCrc(bytes, 2, checksum);
  695.   
  696.   // combine the two bytes to a 16-bit value
  697.   *data = (bytes[0] << 8) | bytes[1];
  698.   
  699.   return error;
  700. }

  702. //-----------------------------------------------------------------------------
  703. static etError SHT3X_Write2BytesAndCrc(u16t data)
  704. {
  705. ……………………

  707. …………限于本文篇幅 余下代碼請從51黑下載附件…………
復制代碼

所有資料51hei提供下載:
SHT3x STM32F103.rar (300.74 KB, 下載次數: 182)




作者: qq876947610    時間: 2021-4-6 15:27
請問你看過傳感的手冊嗎？
不用等待ACK嗎？
不用配置IIC的方向嗎
作者: luong5490spkt    時間: 2021-5-11 00:42
這篇文章很詳細，很容易理解
謝謝！



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