Compartir tecnología

Renesas R7FA8D1BH (Cortex®-M85) controla DS18B20

2024-07-12

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

Tabla de contenido

Descripción general

1 Software y hardware

1.1 Información del entorno de software y hardware

1.2 Información de la placa de desarrollo

1.3 Información del depurador

Configuración de 2 FSP y KEIL

2.1 Circuito de interfaz de hardware

2.2 FSB configura el IO de DS18B20

2.3 Generar archivos de proyecto Keil

3 código de controlador DS18B20

3.1 Introducción a DS18B20

3.2 Implementación del controlador DS18B20

3.2.1 Definición del estado de IO

3.2.2 Función de lectura de estado de IO

3.2.3 Otras funciones

4 procedimientos de prueba

4.1 Diseño de aplicaciones

4.2 Pruebas

5 accesorios

Renesas R7FA8D1BH (Cortex®-M85) controla DS18B20 y ADC para lograr la función de salto de dos páginas

Descripción general

Este artículo presenta principalmente un caso de aplicación integral diseñado para Renesas R7FA8D1BH (Cortex®-M85): aplicar el IO de R7FA8D1BH para implementar un protocolo de bus único y realizar la función de controlar ds18b20. Principalmente completa la lectura del valor de temperatura y el formato del valor. visualización en el OLED de la pantalla. Los datos de temperatura también se envían al terminal del puerto serie a través del terminal del puerto serie.

1 Software y hardware

1.1 Información del entorno de software y hardware

Información de software y hardwareInformación de versión
MCU de RenesasR7FA8D1BH
QuillARM MDK 5.38
versión FSP5.3.0
Herramienta de depuración: N32G45XVL-STBEnlace DAP

1.2 Información de la placa de desarrollo

El autor optó por utilizar la placa de desarrollo Wildfire Yaoyang_Renesas RA8. La MCU de control principal de esta placa es R7FA8D1BHECBD, y el núcleo de 7FA8D1BHECBD es ARM Contex-M85.

1.3 Información del depurador

Para el chip R7FA8D1BHECBD, el núcleo utilizado es Cortex®-M85 Core, ST-LINK-V2 o J-LINK-V9 no admite funciones de descarga y depuración.Después de muchos intentos, el autor descubrió queN32G45XVL-STBEl DAP-LINK que viene con la placa puede descargar y depurar R7FA8D1BHECBD.

La siguiente imagen es una imagen física de la placa de desarrollo N32G45XVL-STB:

Configuración de 2 FSP y KEIL

2.1 Circuito de interfaz de hardware

El circuito de interfaz de DS18B20 ha sido diseñado en la placa de desarrollo Yaoyang_Renesas RA8, que utiliza la interfaz P809 como señal de control DQ de DS18B20.

2.2 FSB configura el IO de DS18B20

Configure P809 como una interfaz IO común y luego configure dinámicamente la salida o el estado de salida de IO en el código

2.3 Generar archivos de proyecto Keil

Después de completar la configuración de parámetros de FSP, puede Generar proyecto. Abra el archivo del proyecto, su estructura es la siguiente:

Cree el archivo ds18b20.c para implementar el código del controlador

3 código de controlador DS18B20

3.1 Introducción a DS18B20

El autor ya analizó en detalle el tiempo y la lógica de implementación de DS18B20 en su artículo anterior, por lo que no lo presentaré aquí.

Nota de aplicación DS18B20_Forma de onda de ds18b20 leyendo datos-CSDN Blog

3.2 Implementación del controlador DS18B20

3.2.1 Definición del estado de IO

Línea 14 del código: Defínenos la función de retardo de paso

Línea 15 del código: Definir la función de retardo de paso en ms

Línea 18 del código: Defina el PIN IO de DS18B20

Línea 21 de código: Configuración del puerto de entrada

Línea 22 de código: Configuración del puerto de salida

Línea 24 de código: Establecer nivel bajo de IO

Línea 25 de código: Establecer nivel alto de IO

3.2.2 Función de lectura de estado de IO

Línea 47 de código: leer el estado de IO en modo de entrada

3.2.3 Otras funciones

Función: ds18b20Init, detecta si DS18B20 está en línea

Función: ds18b20BlockModeProcess. Lea el 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 procedimientos de prueba

4.1 Diseño de aplicaciones

Línea 113 de código: Lea el valor de ds18b20

Línea 130 de código: Obtenga los datos del resultado de ds18b20

Línea 131 de código: datos de visualización formateados

Línea 132 de código: Mostrar datos en OLED

4.2 Pruebas

Compile el código y descárguelo en la placa. Los resultados de la ejecución son los siguientes:

5 accesorios

Código del controlador DS18B20

1) Cree el archivo ds18b20.c y escriba el siguiente 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) Cree el archivo ds18b20.h y escriba el siguiente 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 personal

Se ha dedicado a la investigación de tecnología durante más de 30 años y domina varios lenguajes como java, linux, javascript, php, css, etc. Ha realizado muchas contribuciones en el campo del código abierto. Estación de documentación para desarrolladores para compartir algunos problemas en el desarrollo de tecnología para referencia futura.

Mi informacion de contacto

Correo