기술나눔

Renesas R7FA8D1BH(Cortex®-M85)는 DS18B20을 제어합니다.

2024-07-12

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

목차

개요

1 소프트웨어 및 하드웨어

1.1 소프트웨어 및 하드웨어 환경 정보

1.2 개발 보드 정보

1.3 디버거 정보

2 FSP 및 KEIL 구성

2.1 하드웨어 인터페이스 회로

2.2 FSB는 DS18B20의 IO를 구성합니다.

2.3 Keil 프로젝트 파일 생성

3 DS18B20 드라이버 코드

3.1 DS18B20 소개

3.2 DS18B20 드라이버 구현

3.2.1 IO 상태 정의

3.2.2 IO 상태 읽기 기능

3.2.3 기타 기능

4 테스트 절차

4.1 애플리케이션 디자인

4.2 테스트

액세서리 5개

Renesas R7FA8D1BH(Cortex®-M85)는 DS18B20 및 ADC를 제어하여 두 페이지의 점프 기능을 달성합니다.

개요

이 기사에서는 주로 Renesas R7FA8D1BH(Cortex®-M85)용으로 설계된 포괄적인 응용 사례를 소개합니다. R7FA8D1BH의 IO를 적용하여 단일 버스 프로토콜을 구현하고 ds18b20을 구동하는 기능을 실현합니다. 주로 온도 값을 읽고 값을 형식화하는 작업을 완료합니다. 화면의 OLED에 표시됩니다. 온도 데이터도 직렬 포트 터미널을 통해 직렬 포트 터미널로 전송됩니다.

1 소프트웨어 및 하드웨어

1.1 소프트웨어 및 하드웨어 환경 정보

소프트웨어 및 하드웨어 정보버전 정보
르네사스 MCUR7FA8D1BH
케일ARM 5.38 버전
FSP 버전5.3.0
디버깅 도구: N32G45XVL-STBDAP-링크

1.2 개발 보드 정보

저자는 Wildfire Yaoyang 개발 보드_Renesas RA8을 사용하기로 결정했습니다. 이 보드의 주요 제어 MCU는 R7FA8D1BHECBD이고, 7FA8D1BHECBD의 핵심은 ARM Contex-M85입니다.

1.3 디버거 정보

R7FA8D1BHECBD 칩의 경우 사용되는 코어는 Cortex®-M85 Core, ST-LINK-V2 또는 J-LINK-V9는 다운로드 및 디버깅 기능을 지원하지 않습니다.여러번 시도한 끝에 저자는 그 사실을 깨달았다.N32G45XVL-STB보드와 함께 제공되는 DAP-LINK는 R7FA8D1BHECBD를 다운로드하고 디버깅할 수 있습니다.

아래 그림은 N32G45XVL-STB 개발 보드의 실제 사진입니다.

2 FSP 및 KEIL 구성

2.1 하드웨어 인터페이스 회로

DS18B20의 인터페이스 회로는 P809 인터페이스를 DS18B20의 DQ 제어 신호로 사용하는 Yaoyang Development Board_Renesas RA8에 설계되었습니다.

2.2 FSB는 DS18B20의 IO를 구성합니다.

P809를 공통 IO 인터페이스로 구성한 다음 코드에서 IO의 출력 또는 출력 상태를 동적으로 구성합니다.

2.3 Keil 프로젝트 파일 생성

FSP의 매개변수 구성을 완료한 후 프로젝트 생성을 할 수 있습니다. 프로젝트 파일을 열면 그 구조는 다음과 같습니다.

드라이버 코드를 구현하기 위해 ds18b20.c 파일을 생성합니다.

3 DS18B20 드라이버 코드

3.1 DS18B20 소개

저자는 이미 이전 글에서 DS18B20의 타이밍과 구현 로직을 자세히 분석한 바 있으므로 여기서는 소개하지 않겠다.

DS18B20 애플리케이션 노트_ds18b20 읽기 데이터의 파형-CSDN 블로그

3.2 DS18B20 드라이버 구현

3.2.1 IO 상태 정의

코드 14행: 단계 지연 함수 정의

코드 15행: ms 단계 지연 함수 정의

코드 18행: DS18B20의 IO PIN을 정의합니다.

코드 21번째 줄: 입력 포트 구성

코드 22번째 줄: 출력 포트 구성

코드 24번째 줄: IO 낮은 수준 설정

코드 25번째 줄: IO를 높은 수준으로 설정

3.2.2 IO 상태 읽기 기능

코드 47행: 입력 모드에서 IO 상태를 읽습니다.

3.2.3 기타 기능

기능: ds18b20Init, DS18B20이 온라인인지 감지

기능: ds18b20BlockModeProcess. 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 테스트 절차

4.1 애플리케이션 디자인

코드 113행: ds18b20의 값을 읽습니다.

코드 130번째 줄: ds18b20의 결과 데이터를 얻습니다.

코드 131번째 줄: 형식화된 표시 데이터

코드 132번째 줄: OLED에 데이터 표시

4.2 테스트

코드를 컴파일하고 보드에 다운로드하면 실행 결과는 다음과 같습니다.

액세서리 5개

DS18B20 드라이버 코드

1) ds18b20.c 파일을 생성하고 다음 코드를 작성합니다.

  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) ds18b20.h 파일을 생성하고 다음 코드를 작성합니다.

  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.

개인 프로필

그는 30년 이상 기술 연구에 전념해 왔으며, java, linux, javascript, php, css 등 다양한 언어에 능숙하며, 오픈 소스 분야에 많은 공헌을 했습니다. 나중에 참조할 수 있도록 기술 개발의 일부 문제를 공유하는 개발자 문서 스테이션입니다.

내 연락처 정보

우편