Compartilhamento de tecnologia

Renesas R7FA8D1BH (Cortex®-M85) controla DS18B20

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Índice

Visão geral

1Software e hardware

1.1 Informações sobre o ambiente de software e hardware

1.2 Informações do conselho de desenvolvimento

1.3 Informações do depurador

2 Configuração FSP e KEIL

2.1 Circuito de interface de hardware

2.2 FSB configura o IO do DS18B20

2.3 Gerar arquivos de projeto Keil

3 Código do driver DS18B20

3.1 Introdução ao DS18B20

3.2 Implementação do driver DS18B20

3.2.1 Definição de status de E/S

3.2.2 Função de leitura de status IO

3.2.3 Outras funções

4 Procedimentos de teste

4.1 Design do aplicativo

4.2 Teste

5 acessórios

Renesas R7FA8D1BH (Cortex®-M85) controla DS18B20 e ADC para alcançar a função de salto de duas páginas

Visão geral

Este artigo apresenta principalmente um caso de aplicação abrangente projetado para Renesas R7FA8D1BH (Cortex®-M85): aplicando o IO de R7FA8D1BH para implementar um protocolo de barramento único e realizando a função de acionar ds18b20. exibir em OLED na tela. Os dados de temperatura também são enviados para o terminal da porta serial através do terminal da porta serial.

1Software e hardware

1.1 Informações sobre o ambiente de software e hardware

Informações de software e hardwareVersão informação
Renesas MCUR7FA8D1BH
QuedaMDK ARM 5.38
Versão FSP5.3.0
Ferramenta de depuração: N32G45XVL-STBLink DAP

1.2 Informações do conselho de desenvolvimento

O autor optou por usar a placa de desenvolvimento Wildfire Yaoyang_Renesas RA8. O MCU de controle principal desta placa é R7FA8D1BHECBD, e o núcleo de 7FA8D1BHECBD é ARM Contex-M85.

1.3 Informações do depurador

Para o chip R7FA8D1BHECBD, o núcleo usado é Cortex®-M85 Core, ST-LINK-V2 ou J-LINK-V9 não suporta funções de download e depuração.Depois de muitas tentativas, o autor descobriu queN32G45XVL-STBO DAP-LINK que acompanha a placa pode baixar e depurar R7FA8D1BHECBD.

A imagem abaixo é uma imagem física da placa de desenvolvimento N32G45XVL-STB:

2 Configuração FSP e KEIL

2.1 Circuito de interface de hardware

O circuito de interface do DS18B20 foi projetado na placa de desenvolvimento Yaoyang_Renesas RA8, que usa a interface P809 como sinal de controle DQ do DS18B20.

2.2 FSB configura o IO do DS18B20

Configure P809 como uma interface IO comum e, em seguida, configure dinamicamente a saída ou status de saída do IO no código

2.3 Gerar arquivos de projeto Keil

Após concluir a configuração dos parâmetros do FSP, você pode Gerar Projeto. Abra o arquivo do projeto, sua estrutura é a seguinte:

Crie o arquivo ds18b20.c para implementar o código do driver

3 Código do driver DS18B20

3.1 Introdução ao DS18B20

No artigo anterior, o autor analisou detalhadamente o tempo e a lógica de implementação do DS18B20, portanto não irei apresentá-lo aqui.

DS18B20 Application Note_Waveform de ds18b20 lendo dados-Blog CSDN

3.2 Implementação do driver DS18B20

3.2.1 Definição de status de E/S

Linha 14 do código: Defina a função de atraso de passo

Linha 15 do código: Definir função de atraso de passo ms

Linha 18 do código: Defina o PIN IO do DS18B20

Linha 21 do código: Configuração da porta de entrada

Linha 22 do código: Configuração da porta de saída

Linha 24 do código: Definir nível baixo de IO

Linha 25 do código: Definir IO de alto nível

3.2.2 Função de leitura de status IO

Linha 47 do código: Leia o status do IO no modo de entrada

3.2.3 Outras funções

Função: ds18b20Init, detecta se DS18B20 está online

Função: ds18b20BlockModeProcess. Leia o valor de DS18B20

  1. /**
  2.   * @brief  reset DS18B20
  3.   * @note   if reset ds18b20 sucess, the return value is TRUE
  4.   * @param  None
  5.   * @retval True or Flalse
  6.   */
  7. static uint8_t ds18b20Init( void )
  8. {
  9.     uint16_t tempCnt = 0;
  10.     bsp_io_level_t status;
  11.    
  12.     // Set PIN mode output
  13.     DS_Mode_Out_PP();
  14.     
  15.     // Master pin is high 
  16.     DQ_SET_HIGH;
  17.     timeDelayUS(10);
  18.     
  19.     // Master pin is low 
  20.     DQ_SET_LOW;
  21.     // wait for 600 us 
  22.     timeDelayUS(750);
  23.     
  24.     // Set PIN mode input
  25.     DS_Mode_IN_PUT();
  26.     
  27.     while(1)
  28.     {
  29.         status = DQ_RAD_PIN();
  30.         if( status == 0)
  31.         {
  32.             tempCnt = 0;
  33.             return TRUE;
  34.         }
  35.         else
  36.         {
  37.           timeDelayUS(1);
  38.           tempCnt++;
  39.           if( tempCnt > 480 )
  40.               return FALSE;
  41.         }
  42.     }
  43. }
  44.  
  45.  
  46. static uint8_t readBit( void )
  47. {
  48.     uint8_t readCnt = 2;
  49.     uint8_t bitVal = 1;
  50.  
  51.     DQ_SET_LOW;
  52.     timeDelayUS(3);
  53.     DQ_SET_HIGH;
  54.     
  55.     timeDelayUS(5); // 15 us 
  56.     
  57.     while(readCnt-- )
  58.     {
  59.         //read DQ value 
  60.         if( DQ_RAD_PIN() == 0)
  61.         {
  62.            bitVal = 0;
  63.         }
  64.         timeDelayUS(2);  // 15 us 
  65.     }
  66.     
  67.     timeDelayUS(30);      // 15 us 
  68.  
  69.     return  bitVal;
  70. }
  71.  
  72. static uint8_t ds18b20ReadByte( void )
  73. {
  74.    uint8_t byteVal = 0;
  75.     
  76.    for ( uint8_t i = 0; i < 8; i++ )
  77.    {
  78.         byteVal >>= 1;
  79.        
  80.         uint8_t bitVal = readBit(); 
  81.         if( bitVal > 0)
  82.         {
  83.             byteVal |= 0x80;
  84.         }
  85.     }
  86.    
  87.     return  byteVal;
  88. }
  89.  
  90.  
  91. /**
  92.   * @brief  write one byte to DS18B20
  93.   * @note   
  94.   * @param  byte: the data that is sended to ds18b20
  95.   * @retval None
  96.   */
  97. void ds18b20WriteByte( uint8_t byte)
  98. {
  99.     unsigned char k;
  100.     
  101.     // Set PIN mode output
  102.     DS_Mode_Out_PP();
  103.     
  104.     for ( k = 0; k < 8; k++ )
  105.     {
  106.         if (byte & (1<<k))
  107.         {
  108.             DQ_SET_LOW;
  109.             timeDelayUS(2); 
  110.  
  111.             DQ_SET_HIGH;
  112.             timeDelayUS(65); 
  113.         }
  114.         else
  115.         {
  116.             DQ_SET_LOW;
  117.             timeDelayUS(65); 
  118.  
  119.             DQ_SET_HIGH;
  120.             timeDelayUS(2); 
  121.         }
  122.     }
  123. }
  124.  
  125. uint8_t ds18b20BlockModeProcess( void )
  126. {
  127.     uint16_t tempValue;
  128.     uint8_t tempL, tempH;
  129.  
  130.     if (ds18b20Init() == FALSE)
  131.     {
  132.         return FALSE;
  133.     }
  134.  
  135.     // wait for 600 us 
  136.     timeDelayUS(600);
  137.     
  138.     ds18b20WriteByte(0xcc);
  139.     ds18b20WriteByte(0x44);  // start convert temperature 
  140.  
  141.     if (ds18b20Init() == FALSE)
  142.     {
  143.         return FALSE;
  144.     }
  145.     // wait for 600 us 
  146.     timeDelayUS(600);
  147.  
  148.     ds18b20WriteByte(0xcc);
  149.     ds18b20WriteByte(0xbe);  // read temperature data register
  150.  
  151.     tempL = ds18b20ReadByte();
  152.     tempH = ds18b20ReadByte();
  153.     
  154.     if (tempH > 0x7f) 
  155.     {
  156.         tempL    = ~tempL;
  157.         tempH    = ~tempH+1; 
  158.         st_ds1b20val.sign = 1;
  159.     }
  160.  
  161.     tempValue = (uint16_t)((tempH << 8) | tempL);
  162.  
  163.     st_ds1b20val.temperatureVal = (float)(tempValue * 0.0625);
  164.     
  165.     return TRUE;
  166. }
  167.  
  168.  
  169. // NO blocking mode operate ds18b20 
  170. uint8_t ds18b20NoBlockingProcess( void )
  171. {
  172.     uint16_t tempValue;
  173.     static uint16_t waitCnt = 0;
  174.     uint8_t tempL, tempH;
  175.     static  uint8_t runState = 0;
  176.     
  177.     switch( runState )
  178.     {
  179.         default:
  180.         case INIT_DQ:
  181.             if (ds18b20Init() == FALSE)
  182.             {
  183.                 return FALSE;
  184.             }
  185.             runState = WAIT_READY;
  186.             break;
  187.             
  188.         case WAIT_READY:
  189.             timeDelayUS(2);       // IDEL 
  190.             runState = SKIDROM_CMD;
  191.             break;
  192.            
  193.        case SKIDROM_CMD:
  194.             ds18b20WriteByte(0xcc);
  195.             ds18b20WriteByte(0x44);  // begin to convert temperature data
  196.             waitCnt = 0;
  197.             runState = WAIT_CONVERT;
  198.             break;
  199.        
  200.        case WAIT_CONVERT:
  201.            waitCnt++;
  202.            if( waitCnt > WAIT_CNT_CONVERT)
  203.            {
  204.                waitCnt = 0;
  205.                runState = RESET_CMD;
  206.            }
  207.            break;
  208.         
  209.         case RESET_CMD:
  210.             if (ds18b20Init() == FALSE)
  211.             {
  212.                 return FALSE;
  213.             }
  214.             runState = WAIT_DATA_READY;
  215.             break;
  216.             
  217.         case WAIT_DATA_READY: 
  218.             timeDelayUS(2);     // IDEL 
  219.             runState = READ_CMD;
  220.             break;
  221.             
  222.         case READ_CMD:
  223.             ds18b20WriteByte(0xcc);
  224.             ds18b20WriteByte(0xbe);  // read temperature data register
  225.             runState = GET_VALUE;
  226.             break;
  227.             
  228.         case GET_VALUE:
  229.  
  230.             tempL = ds18b20ReadByte();
  231.             tempH = ds18b20ReadByte();
  232.  
  233.             if (tempH > 0x7f) 
  234.             {
  235.                 tempL    = ~tempL;
  236.                 tempH    = ~tempH+1; 
  237.                 st_ds1b20val.sign = 1;
  238.             }
  239.  
  240.             tempValue = (uint16_t)((tempH << 8) | tempL);
  241.  
  242.             st_ds1b20val.temperatureVal = (float)(tempValue * 0.0625);
  243.             runState = INIT_DQ;
  244.             return TRUE;
  245.     }
  246.     
  247.     return FALSE;
  248. }

4 Procedimentos de teste

4.1 Design do aplicativo

Linha 113 do código: Leia o valor de ds18b20

Linha 130 do código: Obtenha os dados do resultado de ds18b20

Linha 131 do código: Dados de exibição formatados

Linha 132 do código: Exibir dados em OLED

4.2 Teste

Compile o código e baixe-o para a placa. Os resultados da execução são os seguintes:

5 acessórios

Código do driver DS18B20

1) Crie o arquivo ds18b20.c e escreva o seguinte código

  1.  /*
  2.  FILE NAME  :  ds18b20.c
  3.  Description:  user ds18b20 interface 
  4.  Author     :  [email protected]
  5.  Date       :  2024/06/03
  6.  */
  7. #include "ds18b20.h" 
  8. #include "hal_data.h"
  9.  
  10. typedef enum{
  11.   INPUT = 0,
  12.   OUTPUT = 1,
  13. }IO_TYPE;
  14.  
  15. typedef enum{
  16.   FALSE = 0,
  17.   TRUE = 1,
  18. }RETURN_RESULT;
  19.  
  20. typedef enum{
  21.    INIT_DQ = 0,
  22.    WAIT_READY,
  23.    SKIDROM_CMD,
  24.     
  25.    WAIT_CONVERT,
  26.    RESET_CMD,
  27.    READ_CMD,
  28.  
  29.    WAIT_DATA_READY,
  30.    GET_VALUE,
  31.    IDLE_NULL
  32. }RUN_STATE;
  33.  
  34. ds18b20Struc st_ds1b20val;
  35.  
  36.  
  37. ds18b20Struc get_ds18b20_value( void )
  38. {
  39.     return st_ds1b20val;
  40. }
  41.  
  42. static bsp_io_level_t DQ_RAD_PIN(void)
  43. {
  44.     bsp_io_level_t state;
  45.  
  46.     // READ io
  47.     R_IOPORT_PinRead(&g_ioport_ctrl, DS_IO_PORT_PIN, &state);
  48.     
  49.     return state;
  50. }
  51.  
  52. /**
  53.   * @brief  reset DS18B20
  54.   * @note   if reset ds18b20 sucess, the return value is TRUE
  55.   * @param  None
  56.   * @retval True or Flalse
  57.   */
  58. static uint8_t ds18b20Init( void )
  59. {
  60.     uint16_t tempCnt = 0;
  61.     bsp_io_level_t status;
  62.    
  63.     // Set PIN mode output
  64.     DS_Mode_Out_PP();
  65.     
  66.     // Master pin is high 
  67.     DQ_SET_HIGH;
  68.     timeDelayUS(10);
  69.     
  70.     // Master pin is low 
  71.     DQ_SET_LOW;
  72.     // wait for 600 us 
  73.     timeDelayUS(750);
  74.     
  75.     // Set PIN mode input
  76.     DS_Mode_IN_PUT();
  77.     
  78.     while(1)
  79.     {
  80.         status = DQ_RAD_PIN();
  81.         if( status == 0)
  82.         {
  83.             tempCnt = 0;
  84.             return TRUE;
  85.         }
  86.         else
  87.         {
  88.           timeDelayUS(1);
  89.           tempCnt++;
  90.           if( tempCnt > 480 )
  91.               return FALSE;
  92.         }
  93.     }
  94. }
  95.  
  96.  
  97. static uint8_t readBit( void )
  98. {
  99.     uint8_t readCnt = 2;
  100.     uint8_t bitVal = 1;
  101.  
  102.     DQ_SET_LOW;
  103.     timeDelayUS(3);
  104.     DQ_SET_HIGH;
  105.     
  106.     timeDelayUS(5); // 15 us 
  107.     
  108.     while(readCnt-- )
  109.     {
  110.         //read DQ value 
  111.         if( DQ_RAD_PIN() == 0)
  112.         {
  113.            bitVal = 0;
  114.         }
  115.         timeDelayUS(2);  // 15 us 
  116.     }
  117.     
  118.     timeDelayUS(30);      // 15 us 
  119.  
  120.     return  bitVal;
  121. }
  122.  
  123. static uint8_t ds18b20ReadByte( void )
  124. {
  125.    uint8_t byteVal = 0;
  126.     
  127.    for ( uint8_t i = 0; i < 8; i++ )
  128.    {
  129.         byteVal >>= 1;
  130.        
  131.         uint8_t bitVal = readBit(); 
  132.         if( bitVal > 0)
  133.         {
  134.             byteVal |= 0x80;
  135.         }
  136.     }
  137.    
  138.     return  byteVal;
  139. }
  140.  
  141.  
  142. /**
  143.   * @brief  write one byte to DS18B20
  144.   * @note   
  145.   * @param  byte: the data that is sended to ds18b20
  146.   * @retval None
  147.   */
  148. void ds18b20WriteByte( uint8_t byte)
  149. {
  150.     unsigned char k;
  151.     
  152.     // Set PIN mode output
  153.     DS_Mode_Out_PP();
  154.     
  155.     for ( k = 0; k < 8; k++ )
  156.     {
  157.         if (byte & (1<<k))
  158.         {
  159.             DQ_SET_LOW;
  160.             timeDelayUS(2); 
  161.  
  162.             DQ_SET_HIGH;
  163.             timeDelayUS(65); 
  164.         }
  165.         else
  166.         {
  167.             DQ_SET_LOW;
  168.             timeDelayUS(65); 
  169.  
  170.             DQ_SET_HIGH;
  171.             timeDelayUS(2); 
  172.         }
  173.     }
  174. }
  175.  
  176. uint8_t ds18b20BlockModeProcess( void )
  177. {
  178.     uint16_t tempValue;
  179.     uint8_t tempL, tempH;
  180.  
  181.     if (ds18b20Init() == FALSE)
  182.     {
  183.         return FALSE;
  184.     }
  185.  
  186.     // wait for 600 us 
  187.     timeDelayUS(600);
  188.     
  189.     ds18b20WriteByte(0xcc);
  190.     ds18b20WriteByte(0x44);  // start convert temperature 
  191.  
  192.     if (ds18b20Init() == FALSE)
  193.     {
  194.         return FALSE;
  195.     }
  196.     // wait for 600 us 
  197.     timeDelayUS(600);
  198.  
  199.     ds18b20WriteByte(0xcc);
  200.     ds18b20WriteByte(0xbe);  // read temperature data register
  201.  
  202.     tempL = ds18b20ReadByte();
  203.     tempH = ds18b20ReadByte();
  204.     
  205.     if (tempH > 0x7f) 
  206.     {
  207.         tempL    = ~tempL;
  208.         tempH    = ~tempH+1; 
  209.         st_ds1b20val.sign = 1;
  210.     }
  211.  
  212.     tempValue = (uint16_t)((tempH << 8) | tempL);
  213.  
  214.     st_ds1b20val.temperatureVal = (float)(tempValue * 0.0625);
  215.     
  216.     return TRUE;
  217. }
  218.  
  219.  
  220. // NO blocking mode operate ds18b20 
  221. uint8_t ds18b20NoBlockingProcess( void )
  222. {
  223.     uint16_t tempValue;
  224.     static uint16_t waitCnt = 0;
  225.     uint8_t tempL, tempH;
  226.     static  uint8_t runState = 0;
  227.     
  228.     switch( runState )
  229.     {
  230.         default:
  231.         case INIT_DQ:
  232.             if (ds18b20Init() == FALSE)
  233.             {
  234.                 return FALSE;
  235.             }
  236.             runState = WAIT_READY;
  237.             break;
  238.             
  239.         case WAIT_READY:
  240.             timeDelayUS(2);       // IDEL 
  241.             runState = SKIDROM_CMD;
  242.             break;
  243.            
  244.        case SKIDROM_CMD:
  245.             ds18b20WriteByte(0xcc);
  246.             ds18b20WriteByte(0x44);  // begin to convert temperature data
  247.             waitCnt = 0;
  248.             runState = WAIT_CONVERT;
  249.             break;
  250.        
  251.        case WAIT_CONVERT:
  252.            waitCnt++;
  253.            if( waitCnt > WAIT_CNT_CONVERT)
  254.            {
  255.                waitCnt = 0;
  256.                runState = RESET_CMD;
  257.            }
  258.            break;
  259.         
  260.         case RESET_CMD:
  261.             if (ds18b20Init() == FALSE)
  262.             {
  263.                 return FALSE;
  264.             }
  265.             runState = WAIT_DATA_READY;
  266.             break;
  267.             
  268.         case WAIT_DATA_READY: 
  269.             timeDelayUS(2);     // IDEL 
  270.             runState = READ_CMD;
  271.             break;
  272.             
  273.         case READ_CMD:
  274.             ds18b20WriteByte(0xcc);
  275.             ds18b20WriteByte(0xbe);  // read temperature data register
  276.             runState = GET_VALUE;
  277.             break;
  278.             
  279.         case GET_VALUE:
  280.  
  281.             tempL = ds18b20ReadByte();
  282.             tempH = ds18b20ReadByte();
  283.  
  284.             if (tempH > 0x7f) 
  285.             {
  286.                 tempL    = ~tempL;
  287.                 tempH    = ~tempH+1; 
  288.                 st_ds1b20val.sign = 1;
  289.             }
  290.  
  291.             tempValue = (uint16_t)((tempH << 8) | tempL);
  292.  
  293.             st_ds1b20val.temperatureVal = (float)(tempValue * 0.0625);
  294.             runState = INIT_DQ;
  295.             return TRUE;
  296.     }
  297.     
  298.     return FALSE;
  299. }
  300.  
  301.  
  302.  
  303. /* End of this file */

2) Crie o arquivo ds18b20.h e escreva o seguinte código

  1. /*
  2.     FILE NAME  :  ds18b20.h
  3.     Description:  user ds18b20 interface 
  4.     Author     :  [email protected]
  5.     Date       :  2024/06/03
  6. */
  7. #ifndef DS18B20_H
  8. #define DS18B20_H
  9. #include "hal_data.h"
  10.  
  11.  
  12. #define WAIT_CNT_CONVERT     500 
  13.  
  14. #define timeDelayUS(us)      R_BSP_SoftwareDelay(us, BSP_DELAY_UNITS_MICROSECONDS);
  15. #define DS_DELAY_MS(ms)      R_BSP_SoftwareDelay(ms, BSP_DELAY_UNITS_MILLISECONDS);
  16.  
  17.  
  18. #define DS_IO_PORT_PIN       BSP_IO_PORT_08_PIN_09
  19.  
  20.  
  21. #define DS_Mode_IN_PUT()     R_IOPORT_PinCfg(&g_ioport_ctrl, DS_IO_PORT_PIN, IOPORT_CFG_PORT_DIRECTION_INPUT)
  22. #define DS_Mode_Out_PP()     R_IOPORT_PinCfg(&g_ioport_ctrl, DS_IO_PORT_PIN, IOPORT_CFG_PORT_DIRECTION_OUTPUT)
  23.  
  24. #define DQ_SET_LOW           R_IOPORT_PinWrite(&g_ioport_ctrl, DS_IO_PORT_PIN, BSP_IO_LEVEL_LOW)
  25. #define DQ_SET_HIGH          R_IOPORT_PinWrite(&g_ioport_ctrl, DS_IO_PORT_PIN, BSP_IO_LEVEL_HIGH)
  26.  
  27.  
  28. typedef struct{
  29.     float  temperatureVal; 
  30.     bool sign;
  31. }ds18b20Struc;
  32.  
  33. uint8_t ds18b20BlockModeProcess( void );
  34. ds18b20Struc get_ds18b20_value( void );
  35.  
  36.  
  37. #endif   /* DS18B20_H */
  38.  
  39.

Perfil pessoal

Ele se dedica à pesquisa de tecnologia há mais de 30 anos e é proficiente em diversas linguagens como java, linux, javascript, php, css, etc. estação de documentação do desenvolvedor para compartilhar alguns problemas no desenvolvimento de tecnologia para referência futura.

minhas informações de contato

Correspondência