TI bq21040 Charging Profile With Thermal Regulation (데이터시트 p.10)
- 차저는 세가지 충전 단계를 갖는다 - 완방된 배터리를 복구하기 위한 프리차지, 벅 차지를 안전하게 공급하는 패스트차지 정전류,
안전하게 풀 용량에 도달하기 위한 볼티지 레귤레이션
- 차저는 온도 센싱 스탠다드, 오버 볼티지 프로텍션(OVP), DPM-IN, 세이프티 타이머, ISET 쇼트 보호 등의 안전 기능 세트를 가지고 있다 - 만약 배터리 전압이 LOWV 쓰레스홀드(2.5V) 보다 낮다면 배터리는 방전된 것으로 여겨지고 프리컨디셔닝 사이클이 시작된다. 이 페이즈에서 배터리로 흘러가는 전류량은 프리 차지 전류라고 불리고 패스트 차지 전류의 20%로 고정되어 있다 - 배터리 전압이 VLOWV 쓰레스홀드까지 충전되면 패스트차지가 시작되고 패스트차지 전류가 적용된다
- 패스트차지 정전류는 ISET 터미널을 사용해 프로그램된다 - 충전의 대부분은 정전류에 의해 이뤄진다 - IC내의 전력 소모는 배터리 전압이 최저일 때 극대가 된다 - 만약 IC가 125℃에 도달해 IC가 써멀 레귤레이션에 들어가면 타이머 클럭이 절반으로 느려지고온도를 더 이상 상승시키지 않기 위해 필요한만큼 충전 전류를 줄인다 - 배터리 셀이 레귤레이션 전압만큼 충전되면 전압 루프 제어를 취하고 전류가 종단 쓰레스홀드에 가까워질 때까지 배터리를 레귤레이션 전압으로 유지한다 - 종단 전류는 패스트차지 전류의 10%로 설정된다 - CHG 터미널은 첫번째 충전 사이클일 때만 LOW (LED ON)이고 충전 전류에 대한 종단이 활성, 비활성이든 관계없이 종단 쓰레스홀드에 도달하면 턴 오프된다 - (데이터시트 p.8 내용 발췌)
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
//count : 버튼이 눌려있던 시간을 저장하는 변수
//lower_limit : 버튼이 눌러졌다고 인식되기 위해 필요한 최소 시간(ms)
int count=0, lower_limit=80;
//타이머-채널에 설정된 듀티 사이클을 저장하는 변수 선언 및 현재 듀티 사이클 읽어와서 저장
uint8_t current_dutyCycle=HAL_TIM_ReadCapturedValue(&htim2, TIM_CHANNEL_1);
//사용자가 누른 버튼이 1번 버튼일 때
if(GPIO_Pin==B1_Pin)
{
//버튼 디바운스 함수를 통해 사용자가 버튼을 누르고 있던 시간을 측정
count=button_debounce(B1_GPIO_Port,B1_Pin);
//하한을 넘어가는 시간동안 버튼을 누르고 있었다면 듀티 사이클 조절 실행
if(lower_limit < count)
{
if(10<=current_dutyCycle)
{
//현재 설정된 듀티 사이클을 저장한 변수에 -10값을 새로운 듀티 사이클로 설정
__HAL_TIM_SET_COMPARE(&htim2,TIM_CHANNEL_1,dutyCycle-10);
//위의 HAL 드라이버 대신 직접 타이머-채널 레지스터에 접근해 듀티 사이클 설정도 가능
// TIM2->CCR1-=10;
}
else
{
__HAL_TIM_SET_COMPARE(&htim2,TIM_CHANNEL_1,0);
// TIM2->CCR1=0;
}
}
}
//사용자가 누른 버튼이 2번 버튼일 때
else if(GPIO_Pin==B2_Pin)
{
count=button_debounce(B2_GPIO_Port,B2_Pin);
if(lower_limit < count)
{
if(120<=current_dutyCycle)
{
__HAL_TIM_SET_COMPARE(&htim2,TIM_CHANNEL_1,128);
// TIM2->CCR1=128;
}
else
{
__HAL_TIM_SET_COMPARE(&htim2,TIM_CHANNEL_1,dutyCycle+10);
// TIM2->CCR1+=10;
}
}
}
//사용자가 누른 버튼이 3번 버튼일 때
else if(GPIO_Pin==B3_Pin)
{
count=button_debounce(B3_GPIO_Port,B3_Pin);
if(lower_limit < count)
{
//RPM 측정 함수 호출
rpm_calculation(&htim2,TIM_CHANNEL_1);
}
}
else
{
}
printf("PWM : %ld\r\n",HAL_TIM_ReadCapturedValue(&htim2, TIM_CHANNEL_1));
// printf("PWM : %ld\r\n",TIM2->CCR1);
}
- 버튼 입력을 통해 PWM 듀티 사이클을 조절하므로 HAL_GPIO_EXTI_Callback() (GPIO 인터럽트 콜백 함수) 사용
- HAL_TIM_ReadCapturedValue() 함수를 통해 변경하려는 PWM 채널의 현재 듀티 사이클 읽어옴
- ((&htim2, TIM_CHANNEL_1) : Timer 2의 채널 1)
- B1 (버튼1) : 듀티 사이클 감소, B2 (버튼2) : 듀티 사이클 증가, B2 (버튼3) : RPM 측정
- 콜백 함수가 호출되고 전달된 매개변수 GPIO_Pin을 통해 인터럽트가 발생한 GPIO 핀이 어떤 핀인지 확인
- if~else 문을 통해 핀에 따라 듀티 사이클 감소, 증가 or RPM 측정 실행
- button_debounce() 함수를 통해 버튼이 몇 ms동안 눌려졌는지 측정하고 그 값을 count 변수에 저장
- 설정한 하한(lower_limit 변수)을 넘어가는 시간만큼(ms, count변수) 버튼이 눌렸을 경우에만 듀티 사이클 조절 실행
- __HAL_TIM_SET_COMPARE() 함수를 통해 듀티 사이클을 변경하려는 타이머, 채널 및 듀티 사이클 값을 입력
- (HAL_TIM_ReadCapturedValue() 함수를 통해 읽어 온 현재 듀티 사이클 값을 기반으로 ±10 가감)
- 듀티 사이클 최대값은 CubeMX에서 설정한 Counter Period 값 +1 이다
- HAL_TIM_ReadCapturedValue(), __HAL_TIM_SET_COMPARE() 같은 HAL 드라이버를 사용하지 않고 TIMx->CCRn 로 직접 레지스터에 접근해 현재 설정된 듀티 사이클을 읽어오거나 설정할 수도 있다
<버튼 Debounce 함수>
/* @ 버튼 디바운스 함수
* gpio_port : 버튼과 연결된 GPIO 핀이 속한 GPIO Port
* gpio_pin : 버튼과 연결된 GPIO 핀
*/
int button_debounce(GPIO_TypeDef* gpio_port, uint16_t gpio_pin)
{
//count : 버튼을 누르고 있던 시간을 저장할 변수
//start_time, end_time : 버튼을 누르고 있던 시간을 측정하기 위해 사용할 변수
int count, start_time, end_time;
//버튼과 연결된 GPIO 핀 상태를 저장할 변수 선언 및 현재 핀 상태 저장
GPIO_PinState pin_stat=HAL_GPIO_ReadPin(gpio_port,gpio_pin);
//HAL_GetTick() 함수를 통해 측정 시작하는 시간을 start_time 변수에 저장
start_time=HAL_GetTick();
while(pin_stat==GPIO_PIN_RESET)
{
//버튼 GPIO 핀 상태 읽어와 저장
pin_stat=HAL_GPIO_ReadPin(gpio_port,gpio_pin);
}
//버튼에서 손을 떼 측정이 종료된 시간을 end_time 변수에 저장
end_time=HAL_GetTick();
//종료 시간-시작 시간으로 버튼이 눌려있던 시간을 계산해 저장 후 반환
count=end_time-start_time;
return count;
}
- 버튼 디바운스 함수
- Nordic사의 App button 에서 따옴
- HAL_GetTick() 함수를 사용해 버튼이 눌린 시각과 버튼에서 손을 뗀 시각을 저장한 후 이를 이용해 버튼이 눌려져있던 시간을 측정
- 버튼 인터럽트 발생 직후에 호출되어 버튼에 연결된 GPIO 핀이 RESET(Low) 상태일 동안 while()문이 반복
- GPIO 핀이 SET(High) 상태가 되면 while()문 종료 및 눌린 상태로 존재하던 시간 계산 후 반환
<RPM 측정 함수>
void rpm_calculation(TIM_HandleTypeDef *tim_pwm, uint32_t tim_channel)
{
//start_time : 측정 시작 시간 저장
//end_time : 측정 종료 시간 저장
int start_time=0, end_time=0, rpm=0;
//측정된 주기를 바탕으로 계산한 주파수를 저장할 변수
long double freq=0;
//현재 듀티 사이클을 읽어와 저장
uint8_t current_dutyCycle=HAL_TIM_ReadCapturedValue(tim_pwm, tim_channel);
if(current_dutyCycle==0)
{
printf("RPM : 0\r\n");
return;
}
GPIO_PinState pin_stat=HAL_GPIO_ReadPin(FAN_IN_GPIO_Port,FAN_IN_Pin);
//현재 Tachometer 핀이 Low 상태일 때
if(HAL_GPIO_ReadPin(FAN_IN_GPIO_Port,FAN_IN_Pin)==GPIO_PIN_RESET)
{
while(pin_stat==GPIO_PIN_RESET)
{
pin_stat=HAL_GPIO_ReadPin(FAN_IN_GPIO_Port,FAN_IN_Pin);
}
//측정 시작 시간 저장
start_time=HAL_GetTick();
while(pin_stat==GPIO_PIN_SET)
{
pin_stat=HAL_GPIO_ReadPin(FAN_IN_GPIO_Port,FAN_IN_Pin);
}
while(pin_stat==GPIO_PIN_RESET)
{
pin_stat=HAL_GPIO_ReadPin(FAN_IN_GPIO_Port,FAN_IN_Pin);
}
//측정 종료 시간 저장
end_time=HAL_GetTick();
}
//현재 Tachometer 핀이 High 상태일 때
else if(HAL_GPIO_ReadPin(FAN_IN_GPIO_Port,FAN_IN_Pin)==GPIO_PIN_SET)
{
while(pin_stat==GPIO_PIN_SET)
{
pin_stat=HAL_GPIO_ReadPin(FAN_IN_GPIO_Port,FAN_IN_Pin);
}
//측정 시작 시간 저장
start_time=HAL_GetTick();
while(pin_stat==GPIO_PIN_RESET)
{
pin_stat=HAL_GPIO_ReadPin(FAN_IN_GPIO_Port,FAN_IN_Pin);
}
while(pin_stat==GPIO_PIN_SET)
{
pin_stat=HAL_GPIO_ReadPin(FAN_IN_GPIO_Port,FAN_IN_Pin);
}
//측정 종료 시간 저장
end_time=HAL_GetTick();
}
else
{
}
//측정된 주기를 바탕으로 주파수 계산 (측정된 시간은 ms 단위이므로 *1000)
freq=(1.0/(end_time-start_time))*1000;
printf("Freq : %Lf\r\n",freq);
//변환된 주파수를 주어진 RPM 계산 공식에 대입해 현재 RPM 계산
rpm=(int)((freq*60.0/2.0));
printf("RPM : %d\r\n",rpm);
}
- 팬의 Tachometer 핀에 연결된 GPIO 핀 (Input)의 상태를 측정해 RPM 계산
- 먼저 현재 듀티 사이클을 읽어와 0일 경우, 함수 종료 (RPM이 0일 때, Tachometer 핀은 Low 고정이므로)
- 팬 Tachometer 핀에 연결된 GPIO 핀 (Input)의 현재 상태를 측정한 뒤 두 가지 상황으로 나누어 진행
- 1. Tachometer 핀이 Reset (Low) 상태일 때
- Tachometer 핀이 Low 상태 중간부터 측정이 시작됐다고 가정해 일단 Low 상태가 끝날 때까지 while()문으로 대기
- 핀이 High로 전환되어 첫번째 while()문이 종료된 직후, HAL_GetTick() 함수를 사용해 Low 상태가 끝나고
High 상태가 시작되는 시간을 start_time 변수에 저장 (ms 단위)
- while()문을 통해 Tachometer 핀 High -> Low 한 주기가 지난 뒤, HAL_GetTick() 를 사용해 end_time 변수에
한 주기가 끝나는 시간을 저장
- 2. Tachometer 핀이 Set (High) 상태일 때
- Tachometer 핀이 High 상태 중간부터 측정이 시작됐다고 가정해 일단 High 상태가 끝날 때까지 while()문으로 대기
- 핀이 Low로 전환되어 첫번째 while()문이 종료된 직후, HAL_GetTick() 함수를 사용해 High 상태가 끝나고
Low 상태가 시작되는 시간을 start_time 변수에 저장 (ms 단위)
- while()문을 통해 Tachometer 핀 Low -> High 한 주기가 지난 뒤,HAL_GetTick() 를 사용해 end_time 변수에
한 주기가 끝나는 시간을 저장
- end_time-start_time을 통해 한 주기를 계산하고 이 값을 주파수로 변환한 뒤(f=1/T) 주어진 공식을 사용해 RPM 계산
- 사용한 LCD 모듈의 경우, Memory Data Access Control(MADCTL) 레지스터의 RGB 비트 설정이 0임에도 불구하고 BGR 순으로 반대로 디스플레이에 데이터가 표현됨. 따라서 MADCTL 레지스터의 RGB 순서 설정 비트를 1로 변경함으로 전송한 RGB 데이터 순서대로 디스플레이 출력이 되게끔 설정.
- RGB BIT 설정으로 인해 변경된 RGB 출력 순서는 좌우, 상하 반전을 하더라도 변하지 않는다
*디스플레이 반전
Display Inversion On 명령어
RGB 픽셀 0xFC, 0x00, 0x00 전송, MADCTL RGB BIT=1 / (왼쪽) Inversion Off (오른쪽) Inversion On
- 사용한 LCD 모듈의 경우, Inversion Off 일 때 RGB값 0x00에서 최대 밝기, 0xFC에서 최소 밝기가 된다
- 예) R=0xFC, G=0x00, B=0x00 이라면 해당 픽셀은 Red=off / Green, Blue=최대 밝기가 된다
- Inversion On 명령어를 전송해 전송하는 R/G/B 값의 크기가 디스플레이 픽셀 밝기에 그대로 반영되게 한다
- st7735_write_cmd(), st7735_write_cmd_param() 함수를 ST7735에 명령어와 명령어+매개변수를 전송하는 기본 툴로 사용
- Sleep Out -> Display On -> Memory Data Access Control (행열 교환 및 열 방향 반전) -> Address Pointer 설정 (Window) -> Display Inversion On 순서로 ST7735 드라이버 초기화 (데이터 시트에 초기화 과정 없기에 임의 설정)
- 열과 행의 주소는 각각 2 byte의 길이를 가지는데 열과 행의 주소 둘 다 255를 넘어가지 않으므로 명령어 매개변수의 두번째, 네번째 배열에 원하는 주소를 입력해 전송
- st7735_write_cmd(), st7735_write_cmd_param() 함수는 우선적으로 SPI 사용 가능 때까지 while()문을 통해 대기
- SPI가 Ready 상태가 되면 CS(Low, SPI 통신 활성화) -> D/C (Data/Command) -> IT 통해 SPI 통신 개시 -> 통신 완료까지 while()문 사용해 대기 -> CS(High, SPI 통신 비활성화)
- 전달받은 문자열의 첫번째 문자부터 순차적으로 하나씩 st7735_write_char() 함수에 전달
- 매 전송 이후, 폰트 가로 너비만큼 열 주소를 증가
- 열의 남은 공간이 폰트의 가로 너비 보다 작을 경우 전송 중단
(필요한 경우 else 란에 row_start+폰트 높이, col_start=0 을 입력해 다음 행의 0번째 열부터 나머지 문자가 출력되게끔 설정)
*stm32wbxx_it.c
stm32wbxx_it.c 위치 (CUBEMX 기준)
void DMA1_Channel1_IRQHandler(void)
{
/* USER CODE BEGIN DMA1_Channel1_IRQn 0 */
/* USER CODE END DMA1_Channel1_IRQn 0 */
HAL_DMA_IRQHandler(&hdma_spi1_tx);
/* USER CODE BEGIN DMA1_Channel1_IRQn 1 */
if(HAL_DMA_GetState(&hdma_spi1_tx)==HAL_DMA_STATE_READY)
{
HAL_GPIO_WritePin(SPI1_CS_GPIO_Port, SPI1_CS_Pin, SET);
free(hspi1.pTxBuffPtr);
}
/* USER CODE END DMA1_Channel1_IRQn 1 */
}
- stm32wbxx_it.c 소스 파일에 위치한 DMA 인터럽트 핸들러
- 사용한 SPI의 TX에 할당한 DMA 채널을 찾아 코드 입력
- DMA를 통한 전송이 완료되어 DMA 채널이 Ready 상태라면 CS 핀을 High (SPI 통신 비활성화)로 설정하고 전송에 사용된 디스플레이 데이터의 메모리 할당을 해제함
- RGBC 레지스터에 저장된 측정값을 읽어 오는 태스크가 vTaskDelay() 간격으로 상시 실행
- RGBC 측정값 수신 완료 후, 읽어 온 RGBC 값을 다룰 콜백 함수가 호출됨
- 콜백 함수에서 RGBC 값을 가공한 뒤에 큐에 등록하고 RGBC 값을 BLE를 통해 전송하는 태스크에 xTaskNotify() 함수를 사용해 알림 전달
- RGBC 데이터 BLE 전송 태스크에서 알림 수신 및 큐에 등록된 RGBC 데이터값을 받아와 BLE 통신을 통해 RGBC값을 전송
[명령어 실행]
- BLE 통신을 통해 데이터를 수신하면 명령어 부분과 데이터 부분으로 나눈 뒤에 큐에 등록 및 명령어를 처리하는 태스크에 알림 전달
- 명령어 처리 태스크는 알림 및 큐에 등록된 명령어 데이터를 받아와 명령어와 일치하는 TCS34725 레지스터에 액세스해 명령어 함께 수신된 데이터를 입력하고 다시 해당 레지스터에 액세스해 저장된 데이터를 읽어 옴 (데이터 입력 확인)
- 레지스터로부터 데이터를 읽어 온 직후, 콜백 함수가 호출되고 이 콜백 함수에서 데이터를 가공해 큐에 등록 및 BLE 통신을 통해 레지스터 데이터를 전송하는 태스크에 알림 전달
- 레지스터 데이터를 전송하는 태스크에서 알림 수신 및 큐에 등록된 데이터를 받아와 BLE 통신을 통해 전송
[코드]
<TCS34725 RGBC Read 태스크>
static void tcs_read_rgbc_thread(void *arg)
{
//스택 사이즈 확인용. 할당된 스택 크기에서 사용되고 남은 크기를 알려준다
#ifdef STACK_SIZE_CHK
configSTACK_DEPTH_TYPE uxHighWaterMark2;
uxHighWaterMark2=uxTaskGetStackHighWaterMark(NULL);
uint8_t stack_left=255;
#endif
//TCS34725로부터 읽어 온 RGBC 데이터를 저장할 구조체 변수
tcs34725_rgbc_data_t tcs_rgbc_thread;
while(1)
{
//TCS34725 RGBC 레지스터에 접근해 저장된 측정값을 읽어 오는 함수 호출
//측정값 수신 완료 후, 콜백 함수 호출
tcs34725_read_rgbc(&tcs34725_instance,&tcs_rgbc_thread,tcs34725_rgbc_cb);
vTaskDelay(200);
//잔여 스택 크기를 지속적으로 갱신
#ifdef STACK_SIZE_CHK
uxHighWaterMark2=uxTaskGetStackHighWaterMark(NULL);
if(uxHighWaterMark2<stack_left)
{
stack_left=uxHighWaterMark2;
printf("Available stack size of RGBC read thread : %d\r\n",uxHighWaterMark2);
}
#endif
}
}
<TCS34725 RGBC 콜백 함수>
void tcs34725_rgbc_cb(ret_code_t result, tcs34725_rgbc_data_t * p_raw_data)
{
if(result!=NRF_SUCCESS)
{
NRF_LOG_INFO("tcs rgbc callback failed");
return;
}
//가공한 RGB 데이터를 저장할 구조체 변수
tcs34725_rgbc_data_t tcs_rgbc_cb_str;
//읽어 온 RGB 데이터 가공 후, 선언한 구조체 변수에 저장
tcs_rgbc_cb_str.clear=p_raw_data->clear;
tcs_rgbc_cb_str.red=(int)((double)p_raw_data->red/p_raw_data->clear*255);
tcs_rgbc_cb_str.green=(int)((double)p_raw_data->green/p_raw_data->clear*255);
tcs_rgbc_cb_str.blue=(int)((double)p_raw_data->blue/p_raw_data->clear*255);
//가공한 RGBC 데이터를 저장한 구조체 변수를 큐에 전송
//큐에 남은 자리가 있다면 RGBC 구조체 변수 큐에 등록 후 BLE 전송 태스크에 알림 전달
if(uxQueueSpacesAvailable(m_tcs_rgb_data_queue)!=0)
{
if(pdTRUE!=xQueueSend(m_tcs_rgb_data_queue, &tcs_rgbc_cb_str, 10))
{
NRF_LOG_INFO("TCS34725 RGBC CB : Queue send fail\r\n");
}
xTaskNotifyGive(m_ble_tcs_rgbc_send_thread);
}
//큐가 Full 이라면 큐에 RGBC 구조체 변수를 덮어쓰기 하고 알림 전달 X
else
{
if(pdTRUE!=xQueueOverwrite(m_tcs_rgb_data_queue, &tcs_rgbc_cb_str))
{
NRF_LOG_INFO("TCS34725 RGBC CB : Queue overwrite fail\r\n");
}
}
//BLE 통신을 통해 RGBC 데이터를 전송하는 태스크에 알림 전달
xTaskNotifyGive(m_ble_tcs_rgbc_send_thread);
}
<TCS34725 RGBC BLE 전송 태스크>
static void ble_tcs_rgbc_send_thread(void *arg)
{
ret_code_t err_code;
//큐에 등록된 RGBC 구조체 변수 데이터를 받아 올 RGBC 구조체 변수 선언
tcs34725_rgbc_data_t ble_tcs_send_rgb;
//BLE 통신을 통해 전송될 문자열을 저장할 캐릭터 배열
char data_array[18]={};
//BLE 통신을 통해 전송될 문자열의 길이를 저장할 변수
uint16_t length=sizeof(data_array);
while(1)
{
/*
전달 받은 알림이 있는지 확인 (알림이 없다면 0, 있다면 !=0)
&& 큐에서 BLE 통신을 통해 전송할 RGBC 구조체 변수 읽어 옴
*/
if((ulTaskNotifyTake(pdTRUE,10)!=0)&&
(pdPASS==xQueueReceive(m_tcs_rgb_data_queue, &ble_tcs_send_rgb, 10)))
{
//sprintf 함수를 통해 BLE 통신을 통해 전송될 문자열 생성
//RGB((3)명령어)+Clear(5)+Red(3)+Green(3)+Blue(3)=17+"\n"
sprintf(data_array,"RGB%5d%3d%3d%3d",ble_tcs_send_rgb.clear,ble_tcs_send_rgb.red,ble_tcs_send_rgb.green,
ble_tcs_send_rgb.blue);
if(m_conn_handle!=BLE_CONN_HANDLE_INVALID)
{
err_code=ble_nus_data_send(&m_nus, data_array, &length, m_conn_handle);
if ((err_code != NRF_ERROR_INVALID_STATE) &&
(err_code != NRF_ERROR_RESOURCES) &&
(err_code != NRF_ERROR_NOT_FOUND))
{
APP_ERROR_CHECK(err_code);
}
}
}
}
}
<BLE 통신을 통해 수신한 UART 데이터 처리 함수>
/*
- BLE 통신을 통해 수신된 문자열 (명령어(3)+레지스터 데이터(3) or 쓰레스홀드 데이터(5))을
저장하기 위한 구조체
*/
typedef struct{
char cmd[4],data[6];
}tcs34725_cmd_t;
static void nus_data_handler(ble_nus_evt_t * p_evt)
{
if (p_evt->type == BLE_NUS_EVT_RX_DATA)
{
uint32_t err_code;
//수신한 문자열을 명령어, 데이터 부분으로 나누어 저장할 구조체 변수 선언
tcs34725_cmd_t nus_cmd_str={0};
NRF_LOG_DEBUG("Received data from BLE NUS. Writing data on UART.");
NRF_LOG_HEXDUMP_DEBUG(p_evt->params.rx_data.p_data, p_evt->params.rx_data.length);
//수신한 문자열 UART 출력
for (uint32_t i = 0; i < p_evt->params.rx_data.length; i++)
{
do
{
err_code = app_uart_put(p_evt->params.rx_data.p_data[i]);
if ((err_code != NRF_SUCCESS) && (err_code != NRF_ERROR_BUSY))
{
NRF_LOG_ERROR("Failed receiving NUS message. Error 0x%x. ", err_code);
APP_ERROR_CHECK(err_code);
}
} while (err_code == NRF_ERROR_BUSY);
}
if (p_evt->params.rx_data.p_data[p_evt->params.rx_data.length - 1] == '\r')
{
while (app_uart_put('\n') == NRF_ERROR_BUSY);
}
//수신한 문자열의 1~3번째 문자를 구조체 변수의 명령어 부분에 저장
memcpy(nus_cmd_str.cmd, p_evt->params.rx_data.p_data, 3);
/*
일반 레지스터 설정은 최대 255까지 입력 가능하므로 세 자리의 문자 길이,
쓰레스홀드는 최대 65535까지 입력 가능하므로 다섯 자리의 문자 길이를 갖는다
*/
/*
- 일반 레지스터 설정
수신한 문자열의 4~6번째 문자를 구조체 변수의 데이터 부분에 저장
*/
if((4<p_evt->params.rx_data.length)&&(p_evt->params.rx_data.length<8))
{
memcpy(nus_cmd_str.data, &p_evt->params.rx_data.p_data[3], 3);
}
/*
- 쓰레스홀드 설정
수신한 문자열의 4~8번째 문자를 구조체 변수의 데이터 부분에 저장
*/
else if(7<p_evt->params.rx_data.length)
{
memcpy(nus_cmd_str.data,&p_evt->params.rx_data.p_data[3],5);
}
//큐 잔여량을 확인해 잔여 상황에 따라 큐 전송을 다르게 처리함
if(uxQueueSpacesAvailable(m_tcs_cmd_queue)!=0)
{
//큐에 남은 공간이 있을 경우, 구조체 변수를 큐에 등록 후 명령어 처리 태스크에 알림 전달
if(pdPASS!=xQueueSend(m_tcs_cmd_queue,&nus_cmd_str,10))
{
NRF_LOG_INFO("NUS DATA HANLDER : Queue send fail");
}
xTaskNotifyGive(m_tcs_wr_reg_thread);
}
else
{
//큐에 남은 공간이 없는 경우, 덮어쓰기로 큐에 구조체 변수를 등록하고 알림은 전달하지 않음
if(pdPASS!=xQueueOverwrite(m_tcs_cmd_queue,&nus_cmd_str));
{
NRF_LOG_INFO("NUS DATA HANLDER : Queue overwrite fail");
}
}
}
}
- SDK - BLE_APP_UART 예제에 나와있는 함수를 사용
- 큐에 남은 공간이 없을 때 구조체 변수를 덮어쓰기하면서 알림을 전달하지 않는 이유는 기존에 등록된 큐에 새로운 데이터를 덮어쓰는 행동은 처리해야 할 큐의 양을 증가 시키는 것이 아니기 때문
<수신 명령어 처리 태스크 및 함수>
static void tcs_wr_reg_thread(void *arg)
{
ret_code_t err_code;
tcs34725_cmd_t wr_cmd_str;
while(1)
{
/*
전달된 알림이 있고 큐에 등록된 데이터를 성공적으로 읽어 왔다면
TCS34725 명령어 처리 함수에 읽어 온 명령어 구조체 변수 전달
*/
if((ulTaskNotifyTake(pdTRUE,10)!=0)&&(pdPASS==xQueueReceive(m_tcs_cmd_queue,&wr_cmd_str,10)))
{
tcs34725_cmd_func(&wr_cmd_str);
}
vTaskDelay(100);
}
}
/*
전달된 명령어에 따라 해당 레지스터에 액세스해 명령어와 함께 수신된 데이터를 입력하고
다시 해당 레지스터에 액세스해 설정된 데이터를 읽어 온 뒤 BLE 통신을 통해 전송
*/
void tcs34725_cmd_func(tcs34725_cmd_t *cmd_func_str)
{
ret_code_t err_code;
//수신한 명령어가 쓰레스홀드 명령어일 경우
if((strcmp(cmd_func_str->cmd,"THL")==0)||(strcmp(cmd_func_str->cmd,"THH")==0))
{
//TCS34725로부터 쓰레스홀드 설정값을 수신할 쓰레스홀드 구조체 포인터 변수 메모리 할당
tcs34725_threshold_data_t *tcs_cmd_thr=(tcs34725_threshold_data_t*)pvPortMalloc(sizeof(tcs34725_threshold_data_t));
//쓰레스홀드 하한 설정
if(strcmp(cmd_func_str->cmd,"THL")==0)
{
NRF_LOG_INFO("Set Threshold Low");
err_code=tcs34725_set_threshold(&tcs34725_instance,TCS34725_THRESHOLD_LOW,chartoint(cmd_func_str->data,5));
if(err_code!=NRF_SUCCESS)
{
NRF_LOG_INFO("Set Threshold Low fail");
return;
}
tcs_cmd_thr->reg_addr=TCS34725_REG_THRESHOLD_LOW_L;
err_code=tcs34725_read_threshold(&tcs34725_instance, tcs_cmd_thr, tcs34725_read_thr_cb);
if(err_code!=NRF_SUCCESS)
{
NRF_LOG_INFO("Read Threshold Low fail");
return;
}
}
//쓰레스홀드 상한 설정
else if(strcmp(cmd_func_str->cmd,"THH")==0)
{
NRF_LOG_INFO("Set Threshold High");
err_code=tcs34725_set_threshold(&tcs34725_instance,TCS34725_THRESHOLD_HIGH,chartoint(cmd_func_str->data,5));
if(err_code!=NRF_SUCCESS)
{
NRF_LOG_INFO("Set Threshold High fail");
return;
}
tcs_cmd_thr->reg_addr=TCS34725_REG_THRESHOLD_HIGH_L;
err_code=tcs34725_read_threshold(&tcs34725_instance, tcs_cmd_thr, tcs34725_read_thr_cb);
if(err_code!=NRF_SUCCESS)
{
NRF_LOG_INFO("Read Threshold High fail");
return;
}
}
}
//쓰레스홀드 외에 명령어일 때
else
{
//TCS34725 레지스터값을 수신할 구조체 포이터 변수 메모리 할당
tcs34725_reg_data_t *tcs_cmd_str=(tcs34725_reg_data_t*)pvPortMalloc(sizeof(tcs34725_reg_data_t));
//TCS34725 각 레지스터에 설정된 데이터를 읽어 온 후 BLE 통신을 통해 전송하는 명령어
if(strcmp(cmd_func_str->cmd,"RAR")==0)
{
/*
TCS34725의 각종 레지스터에 설정된 데이터를 읽어오는 태스크 생성 (ex:인터럽트 활성화 여부, 쓰레스홀드값 등등)
읽어 온 데이터는 콜백 함수를 통해 가공된 후 BLE 통신을 통해 전송
*/
if(pdPASS!=xTaskCreate(tcs_read_all_reg_thread, "TCS_READ_ALL_REG", configMINIMAL_STACK_SIZE+30,
NULL, 3, &m_tcs_reg_all_send_thread))
{
APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
}
}
//타이밍값 설정
else if(strcmp(cmd_func_str->cmd,"TIM")==0)
{
NRF_LOG_INFO("Set Timming");
err_code=tcs34725_set_timing(&tcs34725_instance,chartoint(cmd_func_str->data,3));
if(err_code!=NRF_SUCCESS)
{
NRF_LOG_INFO("Set timing fail");
return;
}
tcs_cmd_str->reg_addr=TCS34725_REG_TIMING;
err_code=tcs34725_read_reg(&tcs34725_instance,tcs_cmd_str,tcs34725_read_reg_cb);
if(err_code!=NRF_SUCCESS)
{
NRF_LOG_INFO("Read timing fail");
return;
}
}
//대기 시간 설정
else if(strcmp(cmd_func_str->cmd,"WAT")==0)
{
NRF_LOG_INFO("Set Wait Time");
err_code=tcs34725_set_wait_time(&tcs34725_instance,chartoint(cmd_func_str->data,3));
if(err_code!=NRF_SUCCESS)
{
NRF_LOG_INFO("Set wait time fail");
return;
}
tcs_cmd_str->reg_addr=TCS34725_REG_WAIT_TIME;
err_code=tcs34725_read_reg(&tcs34725_instance,tcs_cmd_str,tcs34725_read_reg_cb);
if(err_code!=NRF_SUCCESS)
{
NRF_LOG_INFO("Read wait time fail");
return;
}
}
//게인값 설정
else if(strcmp(cmd_func_str->cmd,"GIN")==0)
{
NRF_LOG_INFO("Set gain");
err_code=tcs34725_set_gain(&tcs34725_instance,chartoint(cmd_func_str->data,3));
if(err_code!=NRF_SUCCESS)
{
NRF_LOG_INFO("Set gain fail");
return;
}
tcs_cmd_str->reg_addr=TCS34725_REG_CONTROL;
err_code=tcs34725_read_reg(&tcs34725_instance,tcs_cmd_str,tcs34725_read_reg_cb);
if(err_code!=NRF_SUCCESS)
{
NRF_LOG_INFO("Read gain fail");
return;
}
}
//인터럽트 활성화 설정
else if(strcmp(cmd_func_str->cmd,"ENA")==0)
{
NRF_LOG_INFO("Set interrupt");
err_code=tcs34725_set_interrupt(&tcs34725_instance,chartoint(cmd_func_str->data,3));
if(err_code!=NRF_SUCCESS)
{
NRF_LOG_INFO("Set interrupt fail");
return;
}
tcs_cmd_str->reg_addr=TCS34725_REG_ENABLE;
err_code=tcs34725_read_reg(&tcs34725_instance,tcs_cmd_str,tcs34725_read_reg_cb);
if(err_code!=NRF_SUCCESS)
{
NRF_LOG_INFO("Read interrupt fail");
return;
}
}
//Wait Long 활성화 설정 (활성화시 대기 시간이 설정된 대기 시간 x12가 된다)
else if(strcmp(cmd_func_str->cmd,"WLO")==0)
{
NRF_LOG_INFO("Set wait long");
err_code=tcs34725_set_wait_long(&tcs34725_instance,chartoint(cmd_func_str->data,3));
if(err_code!=NRF_SUCCESS)
{
NRF_LOG_INFO("Set wait long fail");
return;
}
tcs_cmd_str->reg_addr=TCS34725_REG_CONFIG;
err_code=tcs34725_read_reg(&tcs34725_instance,tcs_cmd_str,tcs34725_read_reg_cb);
if(err_code!=NRF_SUCCESS)
{
NRF_LOG_INFO("Read wait long fail");
return;
}
}
/*
- 인터럽트가 발생하기까지 필요한 쓰레스홀드값을 벗어나는 Clear 값의 연속 측정 횟수 설정
Persistence 값은 다른 레지스터 데이터와는 다르게 10진수값과 1:1 매칭이 되지 않는다
따라서 설정값에 해당하는 2진수 데이터로 변환하는 과정이 필요하다
*/
else if(strcmp(cmd_func_str->cmd,"PER")==0)
{
//2진수 데이터로 변환된 Persistence 값을 저장할 변수
uint8_t persistence_val;
NRF_LOG_INFO("Set Persistence");
//BLE 통신을 통해 수신된 Persistence 데이터는 문자열이므로 상수로 변환
persistence_val=chartoint(cmd_func_str->data,3);
//설정값에 해당하는 2진수값으로 변환 (ex: 5 = 0100, 60 = 1111)
persistence_val=tcs34725_per_dectobin(persistence_val);
err_code=tcs34725_set_persistence(&tcs34725_instance,persistence_val);
if(err_code!=NRF_SUCCESS)
{
NRF_LOG_INFO("Set Persistence fail");
return;
}
tcs_cmd_str->reg_addr=TCS34725_REG_PERSISTENCE;
err_code=tcs34725_read_reg(&tcs34725_instance,tcs_cmd_str,tcs34725_read_reg_cb);
if(err_code!=NRF_SUCCESS)
{
NRF_LOG_INFO("Read Persistence fail");
return;
}
}
else
{
return;
}
}
}
- 명령어에 해당하는 레지스터에 데이터를 입력하고 다시 액세스해 저장된 데이터를 읽어 온 뒤 BLE 통신을 통해 전송함으로써 명령어와 데이터가 제대로 입력되었는지 확인
<TCS34725 레지스터 Read 콜백 함수>
/*
- BLE 전송 태스크에서 전송될 데이터를 저장하기 위한 구조체
- 명령어(3)+레지스터 데이터(3)
- or 명령어(3)+쓰레스홀드 레지스터 데이터(5)
- +'\n'
*/
typedef struct{
char send_data[9];
}tcs34725_ble_reg_t;
void tcs34725_read_reg_cb(ret_code_t result, tcs34725_reg_data_t * p_raw_data)
{
if(result!=NRF_SUCCESS)
{
NRF_LOG_INFO("TCS34725 register read fail");
return;
}
//명령어 부분을 저장할 캐릭터 배열
char read_reg_cb_cmd[]="CMD";
//2진수 Persistence 값을 10진수로 변환하는데 사용할 변수
uint8_t persistence_value;
//Timing, Wait Time 레지스터 값이 0인 경우(설정값=256),
//tcs34725_reg_data_t 구조체의 레지스터 값을 저장하는 변수 자료형은 uint8_t라
//오버플로우 발생하므로 uint16_t 변수를 이용해 따로 저장
uint16_t reg_value;
/*
TCS34725 레지스터에 액세스하기 위해서 레지스터 주소=레지스터 주소+커맨드 레지스터(0x80)를 사용하므로
레지스터 주소 & 0x1F 를 사용해 커맨드 레지스터 부분을 제거해 레지스터 주소만 남긴다
*/
p_raw_data->reg_addr&=0x1F;
//레지스터 주소에 해당하는 명령어를 앞서 선언한 캐릭터 배열에 저장
switch(p_raw_data->reg_addr)
{
//Enable 레지스터 (인터럽트 활성화 여부 확인)
case TCS34725_REG_ENABLE :
NRF_LOG_INFO("Enable register : %X",p_raw_data->reg_data);
strcpy(read_reg_cb_cmd,"ENA");
break;
//타이밍 레지스터
case TCS34725_REG_TIMING :
NRF_LOG_INFO("Timing register : %X",p_raw_data->reg_data);
strcpy(read_reg_cb_cmd,"TIM");
reg_value=256-p_raw_data->reg_data;
break;
//Wait Time 레지스터(Wait Time 활성화 여부 확인)
case TCS34725_REG_WAIT_TIME :
NRF_LOG_INFO("Wait time register : %X",p_raw_data->reg_data);
strcpy(read_reg_cb_cmd,"WAT");
reg_value=256-p_raw_data->reg_data;
break;
/*
- Persistence 레지스터
Persistence 값은 다른 레지스터 데이터와는 다르게 10진수 값이 아닌 2진수값이므로 10진수로 변환
*/
case TCS34725_REG_PERSISTENCE :
NRF_LOG_INFO("Persistence register : %X",p_raw_data->reg_data);
strcpy(read_reg_cb_cmd,"PER");
persistence_value=p_raw_data->reg_data;
persistence_value=tcs34725_per_bintodec(persistence_value);
p_raw_data->reg_data=persistence_value;
break;
//Configuration 레지스터 (Wait Long 활성화 여부 확인)
case TCS34725_REG_CONFIG :
NRF_LOG_INFO("Configuration register : %X",p_raw_data->reg_data);
strcpy(read_reg_cb_cmd,"WLO");
break;
//컨트롤 레지스터 (게인 설정)
case TCS34725_REG_CONTROL :
NRF_LOG_INFO("Control register : %X",p_raw_data->reg_data);
strcpy(read_reg_cb_cmd,"GIN");
break;
// ID 레지스터 (센서 모델명 확인)
case TCS34725_REG_ID :
NRF_LOG_INFO("ID register : %X",p_raw_data->reg_data);
strcpy(read_reg_cb_cmd,"IDR");
break;
//Status 레지스터 (인터럽트 활성화 여부 및 RGBC 유효한지 확인(integration cycle 완료 여부))
case TCS34725_REG_STATUS :
NRF_LOG_INFO("Status register : %X",p_raw_data->reg_data);
strcpy(read_reg_cb_cmd,"STA");
break;
default :
break;
}
//BLE 통신을 통해 레지스터 데이터를 전송하는 태스크에 전달될 구조체 변수 생성
tcs34725_ble_reg_t tcs_ble_send_str;
//구조체 변수에 명령어+데이터로 구성된 문자열 입력
if((p_raw_data->reg_addr==TCS34725_REG_TIMING)||(p_raw_data->reg_addr==TCS34725_REG_WAIT_TIME))
{
sprintf(tcs_ble_send_str.send_data,"%s%3d",read_reg_cb_cmd,reg_value);
}
else
{
sprintf(tcs_ble_send_str.send_data,"%s%3d",read_reg_cb_cmd,p_raw_data->reg_data);
}
//콜백 함수가 호출됐다는 건, TCS34725 레지스터로부터 데이터 수신이 완료됐다는 뜻이므로
//레지스터 Read에 사용했던 구조체 포인터 변수에 할당된 메모리를 해제
vPortFree(p_raw_data);
//큐에 잔여 공간이 남아있다면 구조체 변수를 큐에 등록한 뒤 BLE 전송 태스크에 알림 전달
if(uxQueueSpacesAvailable(m_tcs_reg_data_queue)!=0)
{
if(pdPASS!=xQueueSend(m_tcs_reg_data_queue,&tcs_ble_send_str,10))
{
NRF_LOG_INFO("TCS34725 READ REG CB : Queue send fail");
}
xTaskNotifyGive(m_ble_tcs_reg_send_thread);
}
//큐가 꽉찬 경우, 구조체 변수를 덮어쓰기로 큐에 등록하고 알림 전달은 하지 않음
else
{
if(pdPASS!=xQueueOverwrite(m_tcs_reg_data_queue,&tcs_ble_send_str))
{
NRF_LOG_INFO("TCS34725 READ REG CB : Queue overwrite fail");
}
}
}
- p_raw_data->reg_addr는 tsc34725_reg_read() 함수를 통해 전달된 구조체 변수의 레지스터 주소를 가리킨다
- 이 레지스터 주소와 Switch문을 통해 레지스터 주소에 해당하는 명령어를 선택한다
- 명령어+읽어 온 데이터를 큐에 등록한 뒤 BLE 전송 태스크에 알림을 전달
<TCS34725 레지스터 데이터 BLE 전송 태스크>
static void ble_tcs_reg_send_thread(void *arg)
{
ret_code_t err_code;
//큐에 등록된 명령어+레지스터 데이터로 구성된 데이터를 받아올 구조체 변수
tcs34725_ble_reg_t ble_tcs_send_reg;
//구조체 변수의 길이 (BLE 전송에 필요)
uint16_t length=sizeof(ble_tcs_send_reg);
while(1)
{
/*
- 전달된 알림이 있는 경우, BLE 전송 시작
- xTaskNotifyGive()는 해당 태스크에 알림값을 1씩 증가 시킨다
(xTaskNotify는 32bit내 임의의 값을 전달 가능)
- ulTaskNotifyTake() 매개변수
- pdTRUE의 경우, 알림을 획득하면서 알림값을 초기화 시킨다
- pdFALSE의 경우, 알림을 획득하면서 현재 누적된 알림값을 1만큼 감소 시킨다
- 큐에 데이터를 등록하면서 xTaskNotifyGive()를 통해 알림값을 1씩 누적 시키므로
큐에 등록된 데이터 숫자만큼 순차적으로 데이터를 전송한다
*/
if((ulTaskNotifyTake(pdFALSE,10)!=0)&&
(pdPASS==xQueueReceive(m_tcs_reg_data_queue, &ble_tcs_send_reg, 10)))
{
if(m_conn_handle!=BLE_CONN_HANDLE_INVALID)
{
err_code=ble_nus_data_send(&m_nus, ble_tcs_send_reg.send_data, &length, m_conn_handle);
if ((err_code != NRF_ERROR_INVALID_STATE) &&
(err_code != NRF_ERROR_RESOURCES) &&
(err_code != NRF_ERROR_NOT_FOUND))
{
APP_ERROR_CHECK(err_code);
}
}
}
}
}
- TCS34725 레지스터 Read 콜백 함수에서 BLE 통신을 통해 전송될 구조체 변수를 큐에 등록하면서 xTaskNotifyGive()를 통해 알림도 함께 전달하는데 이 알림값은 1씩 누적되는 값이다
- 그리고 ulTaskNotifyTake의 매개변수를 pdFALSE로 설정할 경우, 알림을 획득하면서 누적된 알림값을 1씩 감소 시키므로 누적된 알림값만큼 BLE 전송이 실행된다
- (pdTRUE의 경우, 알림 획득하며 알림값을 초기화하기 때문에 큐에 누적된 데이터를 처리하기에 부적합)
- 따라서 큐에 등록된 데이터를 처리하는 속도보다 큐에 등록되는 데이터의 속도가 더 빨라 큐가 Full이 되더라도 순차적으로 먼저 큐에 등록된 데이터부터 처리하며 큐를 비움
<쓰레스홀드 콜백 함수>
void tcs34725_read_thr_cb(ret_code_t result, tcs34725_threshold_data_t * p_reg_data)
{
if(result!=NRF_SUCCESS)
{
NRF_LOG_INFO("TCS34725 Threshold register read fail");
return;
}
char read_thr_cb_cmd[]="CMD";
if(p_reg_data->reg_addr==TCS34725_REG_THRESHOLD_LOW_L)
{
NRF_LOG_INFO("Threshold Low value : %d",p_reg_data->threshold_data);
strcpy(read_thr_cb_cmd,"THL");
}
else
{
NRF_LOG_INFO("Threshold High value : %d",p_reg_data->threshold_data);
strcpy(read_thr_cb_cmd,"THH");
}
tcs34725_ble_reg_t tcs_ble_send_str;
sprintf(tcs_ble_send_str.send_data,"%s%5d",read_thr_cb_cmd,p_reg_data->threshold_data);
vPortFree(p_reg_data);
if(uxQueueSpacesAvailable(m_tcs_reg_data_queue)!=0) //The number of free spaces available in the queue.
{
if(pdPASS!=xQueueSend(m_tcs_reg_data_queue,&tcs_ble_send_str,10))
{
NRF_LOG_INFO("TCS34725 THRESHOLD CB : Queue send fail");
}
}
else
{
if(pdPASS!=xQueueOverwrite(m_tcs_reg_data_queue,&tcs_ble_send_str))
{
NRF_LOG_INFO("TCS34725 THRESHOLD CB : Queue overwrite fail");
}
}
xTaskNotifyGive(m_ble_tcs_reg_send_thread);
}
- 쓰레스홀드 레지스터 데이터는 16bit로 구성되어 있으므로 레지스터 Read 콜백 함수에서 처리하는게 아니라 따로 쓰레스홀드 콜백 함수를 만들어 처리
- 데이터 길이가 5인 것을 제외하면 레지스터 Read 콜백 함수와 동일
- BLE 전송은 레지스터 Read 태스크와 동일하게 TCS34725 레지스터 데이터 BLE 전송 태스크 이용
void in_pin_handler(nrf_drv_gpiote_pin_t pin, nrf_gpiote_polarity_t action)
{
if(pin==TCS34725_INT_PIN)
{
ret_code_t err_code;
//BLE 통신을 통해 전송될 구조체 변수 생성 및 명령어 부분을 인터럽트 발생 명령어로 설정
static tcs34725_ble_reg_t tcs_int_alarm={0};
strcpy(tcs_int_alarm.send_data,"INT");
NRF_LOG_INFO("TCS34725 RGBC Interrupt occured");
//인터럽트 클리어 (인터럽트 클리어 명령어를 사용하지 않을 경우, 더 이상의 인터럽트 발생 X)
err_code=tcs34725_int_clear(&tcs34725_instance);
APP_ERROR_CHECK(err_code);
if(err_code==NRF_SUCCESS)
{
NRF_LOG_INFO("TCS34725 Clear channel interrupt clear");
}
//큐에 빈 자리가 있을 경우, 큐에 구조체 변수 등록 및 알림 전달
if(uxQueueSpacesAvailable(m_tcs_reg_data_queue)!=0)
{
if(pdPASS!=xQueueSend(m_tcs_reg_data_queue,&tcs_int_alarm,10))
{
NRF_LOG_INFO("Interrupt queue send fail");
}
xTaskNotifyGive(m_ble_tcs_reg_send_thread);
}
//큐에 빈 자리가 없을 경우, 구조체 변수를 덮어쓰기로 큐에 등록하고 알림 전달 X
else
{
if(pdPASS!=xQueueOverwrite(m_tcs_reg_data_queue,&tcs_int_alarm))
{
NRF_LOG_INFO("Interrupt queue overwrite fail");
}
}
}
}
//GPIO 초기화
static void gpio_init(void)
{
ret_code_t err_code;
err_code = nrf_drv_gpiote_init();
APP_ERROR_CHECK(err_code);
//GPIO 핀이 HIGH -> LOW 로 전환되는 것을 감지
nrf_drv_gpiote_in_config_t in_config = GPIOTE_CONFIG_IN_SENSE_HITOLO(true);
//풀업 설정
in_config.pull = NRF_GPIO_PIN_PULLUP;
//TCS34725 인터럽트 핀에 연결된 GPIO 핀, 핀 환경설정, 핀 변화 감지시 호출될 핸들러 함수
err_code = nrf_drv_gpiote_in_init(TCS34725_INT_PIN, &in_config, in_pin_handler);
APP_ERROR_CHECK(err_code);
//GPIO Input 핀 감지 활성화
nrf_drv_gpiote_in_event_enable(TCS34725_INT_PIN, true);
}
- TCS34725 인터럽트 발생시 인터럽트 핀이 HIGH->LOW로 전환되므로 TCS34725 인터럽트 핀에 연결된 GPIO Input 핀이 HIGH->LOW로 전환될 때, 이벤트 핸들러가 호출되도록 설정
- 인터럽트 발생했을 경우, TCS34725 레지스터 데이터 BLE 전송 태스크를 통해 인터럽트 발생 명령어 전송
- 활성화되어 있다면 RGBC 기능(AEN 비트)이 활성화 되기 전까지 아이들 상태를 유지한다
- RGBC 기능이 활성화되면 디바이스는 대기 및 RGBC 감지를 순서대로 실행한다
- (대기 시간(Wait Time)이 길어질 수록 색상 감지 간격이 길어지므로 빠른 색상 감지를 위해서는 낮은 대기 시간을 설정할 필요가 있다)
- 완료되면 아이들 상태로 돌아오고 PON, AEN 비트가 활성화 되어있는 한 디바이스는 자동으로 Wait-RGBC 주기를 반복한다
<RGBC 작동>
- RGBC 엔진은 RGBC 게인 컨트롤(AGAIN)과 RGBC 포토 다이오드를 위한 네 개의 통합 ADC를 갖는다
- RGBC 통합 시간(ATIME)은 RGBC의 해상도 및 감도에 영향을 준다
- 네 개 채널의 통합이 동시에 이뤄지며 변환이 완료되면 결과값은 컬러 데이터 레지스터로 전송된다
- 전송 중 인식 불가능한 데이터가 읽히는 것을 막기 위해 더블 버퍼링 된다
- 전송 이후, 디바이스는 설정된 상태 머신에 따라 다음 상태로 자동으로 이동한다
<인터럽트>
- 인터럽트 기능은 사용자가 설정한 범위를 벗어나는 빛의 세기에 대해 센서를 폴링할 필요를 없앰으로써 시스템을 간소화하고 효율을 상승시킨다.
- 인터럽트 기능이 활성화 되어있는 동안 스테이터스 레지스터(0x13)에서 인터럽트 상태를 확인 가능하다
- 인터럽트 아웃풋 상태는 Enable 레지스터(0x00)의 RGBC 인터럽트 활성화(AIEN) 영역을 사용해 활성화 할 수 있다
- 사용자는 두개의 16비트 인터럽트 쓰레스홀드 레지스터를 통해 원하는 빛의 세기의 하한 및 상한 제한을 설정할 수 있다
- 인터럽트는 클리어 데이터(CDATA)가 클리어 인터럽트 로우 쓰레스홀드(AILTx) 보다 낮거나 클리어 인터럽트 하이 쓰레스홀드(AITHx) 보다 클 때 발생된다
- 쓰레스홀드는 로우 쓰레스홀드, 하이 쓰레스홀드순으로 비교되므로 만약, 로우 쓰레스홀드가 하이 쓰레스홀드 보다 높은 쓰레스홀드 값이 설정되있다면 하이 쓰레스홀드는 무시되고 로우 쓰레스홀드만이 비교된다
- 인터럽트 발생 시기를 추가 제어하기 위해 디바이스는 지속성 필터를 제공한다
- 지속성 필터를 통해 사용자는 인터럽트 발생까지의 클리어 쓰레스홀드 범위를 벗어나는 측정값의 연속 발생 횟수를 지정 할 수 있다
- 지속성 필터 레지스터(0x0C)를 통해 사용자는 Clear 지속성 필터(APERS) 값을 지정할 수 있다
- 지속성 필터가 인터럽트를 발생시킨 이후, 스페셜 펑션 인터럽트 클리어 커맨드를 받기 전까지는 인터럽트 핀의 LOW 상태가 유지된다 (인터럽트 핀이 HIGH->LOW 로 전환되며 인터럽트 발생)
<시스템 타이밍>
TCS34725 데이터 시트내 다이어그램
- 시스템 상태 머신은 상태 개요 및 시스템의 디바이스 컨트롤을 제공하는 상태로의 전환을 제공한다
- 전원 관리 기능(WEN(Wait time Enable))이 활성화 되어있을 때, 상태 머신은 대기 상태로 전환된다
- 대기 시간은 WTIME과 대기 시간을 12배로 연장하는 WLONG에 의해 결정된다
- RGBC(AEN) 기능이 활성화 되어있을 때, 상태 머신은 RGBC 초기화 및 RGBC ADC 상태를 통해 전환된다
- RGBC 초기화 상태는 2.4ms 가 걸리고 RGBC ADC 시간은 통합 시간(ATIME)에 의존한다
- RGBC 주기의 결과로 인터럽트가 발생하면 RGBC ADC 끝에 실행된다
<전원 관리>
데이터시트 내 전류 소비 예시
- 전력 소비는 대기 상태를 통해 관리 가능
- 대기 상태는 일반적으로 64uA 를 소모
- 최악의 전류 소모는 대기 상태를 사용하지 않는 것
[TWI 통신]
데이터시트 내 I2C(TWI) 통신 프로토콜 예시
- Write 가능한 모든 레지스터(커맨드 레지스터 제외)는 전원 재인가시 설정값이 초기화된다
- Wait Time 레지스터만 0xFF의 초기값을 갖고 나머지 레지스터는 0x00의 초기값을 갖는다
<커맨드 레지스터 (레지스터 주소 X)>
데이터시트 - 커맨드 레지스터
- 읽거나 쓸 타겟 레지스터 주소를 특정화하는데 사용됨
- 타겟 레지스터 주소 + CMD 명령어가 장치 주소를 제외한 첫번째 바이트에 와야 한다
- 7번 비트 CMD는 특정 레지스터 접근이던 인터럽트 클리어를 위한 목적이던 1이여야 한다
- 5, 6번 비트는 레지스터 주소 접근 방식 및 인터럽트 클리어 명령어를 사용하는데 쓰이는 비트
00일 경우 : 지정한 레지스터만 반복해서 읽거나 쓴다
(예 : 0x00 번지로부터 3바이트 Read를 실행한 경우, 0x00 번지만 세 번 읽는다)
01일 경우 : 지정한 레지스터 주소 사용 이후, 자동으로 레지스터 주소값이 1 증가된다
(예 : 0x00 번지로부터 3바이트 Read를 실행한 경우, 0x00, 0x01, 0x02 레지스터 주소에 저장된 데이터를 읽어 온다)
11일 경우 : 4~0 번 비트에 00110를 함께 설정 및 전송해 인터럽트 클리어를 실행한다
(인터럽트 후 인터럽트 핀은 LOW 상태가 되는데 클리어를 실행하면 다시 HIGH로 전환되어 인터럽트 재실행 가능)
<Enable 레지스터 0x00>
데이터시트 - 인에이블 레지스터
- 주로 TCS34725 전원 ON, OFF 에 사용되는 레지스터
- BIT 4 (AIEN) : 인터럽트 활성화 비트
- BIT 3 (WEN) : 대기 활성화 비트
- BIT 1 (AEN) : RGBC 활성화 비트. 2채널 ADC를 활성화 한다
- BIT 0 (PON) : 타이머와 ADC채널이 작동되도록 내부 오실레이터를 활성화하는 비트
<타이밍 레지스터 0x01>
데이터 시트 - 타이밍 레지스터
- RGBC 클리어와 IR 채널 ADC들의 내부 통합 시간을 2.4ms 단위로 조절
- 최대 RGBC 카운트 = (256-ATIME)*1024 (최대 65535)
- 카운트가 늘어날 수록 RGBC 검출 시간이 증가하지만 해상도 및 감도도 증가해 더 정확한 색상 검출이 가능해진다
- 설정값은 1~256을 갖는데 실제 레지스터에 입력되는 값은 256-설정값이 되어야 한다
<대기 시간 레지스터 0x03>
데이터 시트 - Wait Time 레지스터
- 대기 시간을 12배로 늘리는 WLONG 비트가 활성화되지 않는한 2.4ms 단위로 대기 시간을 설정한다
- WTIME은 2의 보수로 프로그램된다
- 설정값은 1~256을 갖는데 실제 레지스터에 입력되는 값은 256-설정값이 되어야 한다
<RGBC 인터럽트 쓰레스홀드 레지스터 0x04~0x07>
데이터시트 - 쓰레스홀드 레지스터
- 측정되는 빛의 세기 (Clear)의 상한 및 하한을 설정하는 레지스터
- 하한 및 상한은 각각 2바이트로 별도의 값 변환없이 10진수 입력 (0~65535까지 설정 가능)
- 레지스터 주소는 하위 8비트, 상위 8비트 순으로 입력할 16비트 데이터를 8비트씩 나누어 하위 8비트 먼저 전송
- 하한 보다 더 낮은 값, 상한 보다 더 높은 값이 측정됐을 때만 인터럽트가 실행된다
(인터럽트 발생 시기는 지속 레지스터(0x0C)에 설정된 값에 영향을 받는다)
- 인터럽트 핀은 기본적으로 HIGH 상태를 유지하다 인터럽트가 발생하며 LOW로 전환된다
- 인터럽트 핀은 LOW상태를 유지하므로 인터럽트 클리어를 실행하기 전까진 더 이상의 인터럽트가 발생하지 않는다
<지속 레지스터 0x0C>
데이터시트 - 지속 레지스터
- 디바이스의 필터링 인터럽트 기능을 제어하는데 사용되는 레지스터
- 각 통합 주기마다 인터럽트를 발생시킬지 아니면 쓰레스홀드 레지스터에 지정된 값을 벗어나는 결과를 지정한 횟수만큼 측정한 이후에 인터럽트를 발생시킬지를 결정
- 예) 쓰레스홀드 Low=10,000 / High=50,000 이고 APERS=1111일 때,
60번 연속으로 0~9,999 / 50,001~65535 범위의 Clear 값이 측정된다면 인터럽트가 발생된다
APERS=0000 이라면 매 RGBC 측정 때마다 인터럽트가 발생한다
<환경설정 레지스터 0x0D>
데이터시트 - 환경설정 레지스터
- Wait long 타임 설정 레지스터
- 2번 비트인 WLONG을 활성화할 경우, 대기 시간이 프로그램된 WTIME 시간의 12배가 된다
<컨트롤 레지스터 0x0F>
데이터시트 - 컨트롤 레지스터
- RGBC 측정값 증폭에 사용되는 레지스터
- 측정값은 게인값에 정비례하지 않는다 (1x gain*4 != 4x gain)
<ID 레지스터 0x12>
데이터시트 - ID 레지스터
- 사용하는 센서가 TCS34725인지 아니면 TCS34727인지를 알려주는 레지스터
- 읽기 전용
<스테이터스 레지스터 0x13>
데이터시트 - 스테이터스 레지스터
- 디바이스 내부 상태를 제공해주는 레지스터
- BIT 5 (AINT) : 인터럽트 활성화 여부 (1-인터럽트 활성화)
- BIT 0 (AVALID) : RGBC 활성화 여부
<RGBC 채널 데이터 레지스터 0x14~0x1B>
데이터시트 - RGBC 데이터 레지스터
- 측정된 RGBC 데이터를 저장하는 레지스터
- 각 색상은 16비트 데이터로 상하 각 8비트로 나누어 저장된다
- 값을 읽어올 때 추가로 10진수 변환할 필요는 없다
- 연속으로 데이터를 읽어와야 하므로 커맨드 레지스터의 값이 0xA0 (CMD : 1, TYPE : 01 (자동 주소 증가))여야 한다
- 예) 0x14 번지부터 0x1B까지 8바이트를 읽어와야 한다면 슬레이드 주소를 제외한 첫 전송 바이트는 (0x14 | 0xA0)가 되어야 한다
- 하위 데이터 레지스터를 읽을 때, 상위 8비트는 섀도우 레지스터에 저장되어 연속으로 읽어진다
- 따라서 하위 바이트와 상위 바이트를 읽는 사이에 추가적인 ADC 통합 주기가 끝나더라도 옳바른 값을 읽어 온다
[코드]
<매크로>
/*
main.c
*/
//TCS34725 센서 주소
#define TCS34725_ADDR 0x29
//TWI PIN
#define TCS34725_SDA_PIN 28
#define TCS34725_SCL_PIN 29
//TSC34725와의 통신에 사용할 TWI 인스턴스 ID
#define TWI_INSTANCE_ID 0
//TWI trasaction manager 인스턴스 Queue 최대 크기 (대기 전송 갯수)
#define MAX_PENDING_TRANSACTIONS 20
/*
- TWI transaction manager 인스턴스 정의 매크로
생성할 TWI transaction manager 인스턴스 이름, 트랜잭션 Queue 크기, 사용할 TWI 인스턴스
*/
NRF_TWI_MNGR_DEF(m_nrf_twi_mngr, MAX_PENDING_TRANSACTIONS, TWI_INSTANCE_ID);
/*
- 공통 TWI 센서 인스턴스 생성 매크로
공통 센서 인스턴스 이름, 사용할 TWI transaction manager 인스턴스, 버퍼 크기
(버퍼 크기의 경우 TWI manager Queue 크기보다 작거나 같아야 한다)
*/
NRF_TWI_SENSOR_DEF(sensor_instance, &m_nrf_twi_mngr, MAX_PENDING_TRANSACTIONS);
/*
- 센서 인스턴스 생성 매크로
센서 인스턴스 이름, 사용할 공통 TWI 센서 인스턴스, 센서 주소
*/
TCS34725_INSTANCE_DEF(tcs34725_instance, &sensor_instance, TCS34725_ADDR);
<TWI 설정>
static void twi_config(void)
{
uint32_t err_code;
/*
-TCS34725와의 TWI 통신 설정
-SDA, SCL핀, 통신속도, 인터럽트 우선순위 설정 뒤 twi 초기화
*/
nrf_drv_twi_config_t const config={
.scl=TCS34725_SCL_PIN,
.sda=TCS34725_SDA_PIN,
.frequency=NRF_DRV_TWI_FREQ_400K,
.interrupt_priority=APP_IRQ_PRIORITY_MID,
};
err_code=nrf_twi_mngr_init(&m_nrf_twi_mngr,&config);
APP_ERROR_CHECK(err_code);
}
<TCS34725 레지스터 구조체 및 Read 함수>
/*
-TCS34725 레지스터로부터 데이터를 읽어오거나 데이터를 쓸 때 사용할 구조체
reg_data : TCS34752 레지스터로부터 읽어 온 데이터 저장 or 레지스터에 쓸 데이터 저장
reg_addr : 액세스 할 레지스터 주소
*/
typedef struct
{
uint8_t reg_data;
uint8_t reg_addr;
} tcs34725_reg_data_t;
/*
-TCS34725의 특정 레지스터로부터 데이터를 읽어 오는 함수
-TCS34725_INSTANCE_DEF을 통해 생성한 TCS34725 센서 인스턴스
-p_reg_data : 액세스 할 레지스터 주소와 읽어 온 데이터를 저장하는데 사용할 구조체 변수
-user_cb : TCS34725로부터 데이터를 수신한 직후 호출된 콜백 함수
(TWI Manager에 큐를 등록한 직후가 아님)
*/
ret_code_t tcs34725_read_reg(tcs34725_instance_t const * p_instance,
tcs34725_reg_data_t * p_reg_data,
tcs34725_data_callback_t user_cb
)
{
/*
p_instance->p_sensor_data : NRF_TWI_SENSOR_DEF을 통해 설정된 공통 센서 인스턴스
p_instance->sensor_addr : TCS34725 센서 인스턴스에 설정된 TCS34725 센서 주소
p_reg_data->reg_addr|0x80 : 전달받은 구조체에 저장된 레지스터 주소+커맨드 레지스터
해당 레지스터 주소에 접근해 데이터를 읽어온다
user_cb : 데이터 수신 완료 후 호출 할 콜백 함수
p_reg_data : 읽어 온 레지스터 데이터를 저장할 포인터 변수
TCS34725_REGISTER_SIZE : 읽어 올 데이터의 바이트 크기 (레지스터 하나의 크기는 8비트=1바이트)
*/
return nrf_twi_sensor_reg_read(p_instance->p_sensor_data,
p_instance->sensor_addr,
p_reg_data->reg_addr|0x80,
(nrf_twi_sensor_reg_cb_t) user_cb,
(uint8_t *) p_reg_data,
TCS34725_REGISTER_SIZE);
}
- 이 함수를 통해 TCS34725 레지스터로부터 데이터를 읽어 온다
- p_reg_data->reg_addr | 0x80 : 레지스터 주소 + 커맨드 레지스터 (CMD : 1, TYPE : 00 (Repeated byte)=0x80)
- 읽어 올 데이터 크기를 1바이트로 설정했으므로 TYPE : 01 (Auto-increment) 로 설정해도 상관없다
<TCS34725 Write 함수>
ret_code_t tcs34725_write_reg(tcs34725_instance_t const * p_instance,
tcs34725_reg_data_t * p_reg_data)
{
//&p_reg_data->reg_data : 레지스터에 입력할 데이터가 저장된 구조체 변수 주소
return nrf_twi_sensor_reg_write(p_instance->p_sensor_data,
p_instance->sensor_addr,
p_reg_data->reg_addr|0x80,
(uint8_t *)&p_reg_data->reg_data,
TCS34725_REGISTER_SIZE);
}
- 아래에 이어질 레지스터 설정 함수들이 이 함수를 통해 TCS34725 레지스터에 설정값을 전송한다
<TCS34725 초기화 함수>
/*
-TCS34752 초기화 함수
-인에이블 레지스터(0x00)에 설정 전송
-인터럽트 활성화, 대기 시간 활성화, RGBC 활성화, POWER ON/OFF 설정
*/
ret_code_t tcs34725_init(tcs34725_instance_t const * p_instance)
{
ret_code_t err_code;
//레지스터 데이터 구조체 선언 (레지스터 주소 및 인에이블 레지스터에 입력할 데이터 저장)
tcs34725_reg_data_t enable_reg;
enable_reg.reg_addr=TCS34725_REG_ENABLE;
//인에이블 설정 저장할 구조체 선언 및 각종 기능 활성화 설정
tcs34725_config_enable_t init_config;
init_config.rgbc_interrupt=false; //인터럽트 활성화
init_config.wait_enable=true; //대기 시간 활성화
init_config.rgbc_enable=true; //RGBC 측정 활성화
init_config.power_on=true; //Power ON/OFF
//설정값들 해당 위치로 비트 시프트
enable_reg.reg_data=(init_config.rgbc_interrupt << TCS34725_INT_POS)|
(init_config.wait_enable << TCS34725_WAIT_POS)|
(init_config.rgbc_enable << TCS34725_RGBC_ENABLE_POS)|
(init_config.power_on << TCS34725_POWER_ON_POS);
//TCS34725 인에이블 레지스터(0x00)로 데이터 전송
err_code=tcs34725_write_reg(&tcs34725_instance, &enable_reg);
return err_code;
}
<TCS34725 레지스터 Read 콜백 함수>
/*
- 레지스터 Read 콜백 함수
- 구조체 포인터 변수에 저장된 레지스터 주소를 스위치 문을 통해 확인 후 로그 출력
*/
void tcs34725_read_reg_cb(ret_code_t result, tcs34725_reg_data_t * p_raw_data)
{
if(result!=NRF_SUCCESS)
{
NRF_LOG_INFO("TCS34725 register read fail");
return;
}
p_raw_data->reg_addr&=0x1F;
switch(p_raw_data->reg_addr)
{
case TCS34725_REG_ENABLE :
NRF_LOG_INFO("Enable register : %X",p_raw_data->reg_data);
break;
case TCS34725_REG_TIMING :
NRF_LOG_INFO("Timing register : %X",p_raw_data->reg_data);
break;
case TCS34725_REG_WAIT_TIME :
NRF_LOG_INFO("Wait time register : %X",p_raw_data->reg_data);
break;
case TCS34725_REG_PERSISTENCE :
NRF_LOG_INFO("Persistence register : %X",p_raw_data->reg_data);
break;
case TCS34725_REG_CONFIG :
NRF_LOG_INFO("Configuration register : %X",p_raw_data->reg_data);
break;
case TCS34725_REG_CONTROL :
NRF_LOG_INFO("Control register : %X",p_raw_data->reg_data);
break;
case TCS34725_REG_ID :
NRF_LOG_INFO("ID register : %X",p_raw_data->reg_data);
break;
case TCS34725_REG_STATUS :
NRF_LOG_INFO("Status register : %X",p_raw_data->reg_data);
break;
default :
break;
}
//레지스터 데이터 수신에 사용된 구조체 포인터 변수 메모리 할당 해제
free(p_raw_data);
}
- Timing, Wait Time의 경우, 1~256 사이의 설정값을 갖는데 실제 레지스터에 설정값을 입력할 땐 [256-사용자 설정값]이 입력되어야 한다
- 예) Timing값을 1로 설정할 경우, 256-1=255의 값이 실제 레지스터에 입력되는 값이 되어야 한다
- 따라서 콜백 함수에서 Timing, Wait Time 설정값을 확인하려면 [256 - p_raw_data->reg_data = 설정값] 이 되어야 한다
<TCS34725 타이밍 설정 함수>
//타이밍 설정 함수 (2.4ms 단위)
//atime : RGBC 통합 주기
ret_code_t tcs34725_set_timing(tcs34725_instance_t const * p_instance,
uint16_t atime)
{
ret_code_t err_code;
//통합 시간이 최소 1*2.4ms 를 갖는다는 것을 명확히 하기 위해 1~256의 값을 입력해야하도록 설정
if((atime==0)||(256 < atime))
{
err_code=NRF_ERROR_INVALID_DATA;
return err_code;
}
//타이밍 레지스터에 전달될 타이밍 레지스터 데이터 구조체 선언 후 레지스터 주소 및 통합 시간 설정
tcs34725_reg_data_t timing_str;
timing_str.reg_addr=TCS34725_REG_TIMING;
//통합 시간은 2.4ms*(256-ATIME) 으로 결정된다. 즉, 레지스터에 입력되는 실제값이 낮을 수록 통합 시간 ↑
timing_str.reg_data=(256-atime);
//설정한 레지스터 구조체 변수 타이밍 레지스터로 전송
err_code=tcs34725_write_reg(p_instance,&timing_str);
return err_code;
}
- Timing 설정값은 1~256 사이의 값을 갖고 레지스터엔 [256-설정값]이 입력되어야 한다
<TCS34725 대기 시간 설정 함수>
//대기 시간 설정 함수 (2.4ms 단위)
//wait_val : 설정할 대기 시간 (wait_val * 2.4ms 가 대기 시간이 된다)
ret_code_t tcs34725_set_wait_time(tcs34725_instance_t const * p_instance,
uint8_t wait_val)
{
ret_code_t err_code;
//타이밍 설정 함수와 마찬가지로 최소 대기시간이 1*2.4ms임을 명확히 하기 위해 사용
if((wait_val==0)||(256 < wait_val))
{
err_code=NRF_ERROR_INVALID_DATA;
return err_code;
}
//대기 시간 레지스터에 입력될 구조체 변수 선언 후 대기 시간 레지스터 주소 및 데이터 입력
tcs34725_reg_data_t wait_time_str;
wait_time_str.reg_addr=TCS34725_REG_WAIT_TIME
//wait_val*2.4ms가 대기 시간이 된다 (WLONG=1일 경우, *12 추가)
//실제 레지스터 입력값은 (256 - WAIT TIME)이 되어야한다
wait_time_str.reg_data=(256-wait_val);
//대기 시간 레지스터(0x03)에 설정한 대기 시간 전송
err_code=tcs34725_write_reg(p_instance,&wait_time_str);
return err_code;
}
- Wait Time 설정값은 1~256 사이의 값을 갖고 레지스터엔 [256-설정값]이 입력되어야 한다.
<TCS34725 지속 레지스터 설정 함수>
//지속 설정 레지스터 설정 함수
//out_of_range_val : 인터럽트를 발생시키기 위해 필요한 쓰레스홀드 범위를 벗어나는 클리어 값 연속 측정 횟수
ret_code_t tcs34725_set_persistence(tcs34725_instance_t const * p_instance,
tcs34725_persistence_t out_of_range_val)
{
ret_code_t err_code;
//지속 레지스터에 전송할 구조체 변수 선언 후 지속 레지스터 주소 및 데이터 설정
tcs34725_reg_data_t persistence;
persistence.reg_addr=TCS34725_REG_PERSISTENCE;
persistence.reg_data=out_of_range_val;
err_code=tcs34725_write_reg(p_instance, &persistence);
return err_code;
}
<TCS34725 환경설정(Wait long) 레지스터 설정 함수>
//환경 설정 레지스터 설정 함수 (Wait long 외에 설정 가능한 데이터가 없다)
//wait_long_val : WLONG 비트 활성화 여부 결정
ret_code_t tcs34725_set_wait_long(tcs34725_instance_t const * p_instance,
tcs34725_wait_long_t wait_long_val)
{
ret_code_t err_code;
tcs34725_reg_data_t wait_long;
wait_long.reg_addr=TCS34725_REG_CONFIG;
//WLONG 비트는 1번 비트에 위치하므로 비트 시프트 사용
wait_long.reg_data=wait_long_val << TCS34725_WAIT_LONG_POS;
err_code=tcs34725_write_reg(p_instance, &wait_long);
return err_code;
}
<TCS34725 컨트롤(게인) 레지스터 설정 함수>
//컨트롤 레지스터 설정 함수 (게인값 외에 설정 가능한 데이터 없음)
//gain_val : 설정할 게인값. 0~1번 비트를 사용해 게인값을 1,4,16,60x 설정 가능
ret_code_t tcs34725_set_gain(tcs34725_instance_t const * p_instance,
tcs34725_gain_t gain_val)
{
ret_code_t err_code;
tcs34725_reg_data_t gain;
gain.reg_addr=TCS34725_REG_CONTROL;
gain.reg_data=gain_val;
err_code=tcs34725_write_reg(p_instance, &gain);
return err_code;
}
<TCS34725 쓰레스홀드 설정 함수>
/*
- 쓰레스홀드 데이터 구조체
- threshold_data : 전송 or 수신할 16비트 쓰레스홀드 데이터 (하위 8비트 먼저 전송 or 수신됨)
- reg_addr : 쓰레스홀드 레지스터 주소 (하한 : 0x04~0x05, 상한 0x06~0x07)
*/
typedef struct
{
uint16_t threshold_data;
uint8_t reg_addr;
} tcs34725_threshold_data_t;
/*
- 쓰레스홀드 설정 함수
- tcs34725_threshold_lh_t : 설정할 쓰레스홀드값이 쓰레스홀드 하한인지 상한인지 판단하는데 사용
- threshold_val : 설정할 쓰레스홀드 값
*/
ret_code_t tcs34725_set_threshold(tcs34725_instance_t const * p_instance,
tcs34725_threshold_lh_t threshold_low_high,
uint16_t threshold_val)
{
ret_code_t err_code;
//전송할 데이터를 저장할 쓰레스홀드 구조체 변수 선언 및 설정할 쓰레스홀드값 입력
tcs34725_threshold_data_t threshold_str;
threshold_str.threshold_data=threshold_val;
/*
- 설정할 쓰레스홀드값이 상한인지 하한인지에 따라 앞서 선언한 쓰레스홀드 구조체 변수의
레지스터 주소에 해당 레지스터 주소 입력
*/
if(threshold_low_high==TCS34725_THRESHOLD_LOW)
{
threshold_str.reg_addr=TCS34725_REG_THRESHOLD_LOW_L; //쓰레스홀드 Low - Low byte
}
else if(threshold_low_high==TCS34725_THRESHOLD_HIGH)
{
threshold_str.reg_addr=TCS34725_REG_THRESHOLD_HIGH_L; //쓰레스홀드 High - Low byte
}
else
{
err_code=NRF_ERROR_INVALID_ADDR;
return err_code;
}
/*
- threshold_str.reg_addr|0xA0 : 각 쓰레스홀드값은 하위 8비트+상위 8비트=16비트이므로
커맨드 레지스터 0xA0을 사용해 연속된 레지스터 주소에 데이터를 입력해야 한다
- TCS34725_THRESHOLD_BYTES : 각 쓰레스홀드 데이터는 2바이트로 구성되므로 2
*/
err_code=nrf_twi_sensor_reg_write(p_instance->p_sensor_data,
p_instance->sensor_addr,
threshold_str.reg_addr|0xA0,
(uint8_t *)&threshold_str,
TCS34725_THRESHOLD_BYTES);
}
<TCS34725 쓰레스홀드 Read 함수>
/*
- 쓰레스홀드 Read 함수
- thr_data_str : 읽어 온 쓰레스홀드 데이터가 저장될 구조체 포인터 변수
- user_cb : 쓰레스홀드 데이터 수신 완료 후 호출할 콜백 함수
*/
ret_code_t tcs34725_read_threshold(tcs34725_instance_t const * p_instance,
tcs34725_threshold_data_t * thr_data_str,
tcs34725_threshold_callback_t user_cb)
{
ret_code_t err_code;
//thr_data_str.reg_addr|0xA0 : 연이은 레지스터 주소에 접근해 데이터를 읽어야 하므로
//레지스터 주소에 0xA0 OR 연산 추가
err_code=nrf_twi_sensor_reg_read(p_instance->p_sensor_data,
p_instance->sensor_addr,
thr_data_str->reg_addr|0xA0,
(nrf_twi_sensor_reg_cb_t) user_cb,
(uint8_t *) thr_data_str,
TCS34725_THRESHOLD_BYTES);
return err_code;
}
<TCS34725 쓰레스홀드 콜백 함수>
void tcs34725_read_thr_cb(ret_code_t result,
tcs34725_threshold_data_t * p_reg_data)
{
if(result!=NRF_SUCCESS)
{
NRF_LOG_INFO("Reading threshold regiseter is failed");
return;
}
//쓰레스홀드 Low 데이터인지 High 데이터인지 구조체 포인터 변수에 저장된 레지스터 주소로 판단 후 출력
if(p_reg_data->reg_addr==TCS34725_REG_THRESHOLD_LOW_L)
{
NRF_LOG_INFO("Threshold Low value : %d",p_reg_data->threshold_data);
}
else
{
NRF_LOG_INFO("Threshold High value : %d",p_reg_data->threshold_data);
}
//쓰레스홀드 레지스터 데이터 수신에 사용된 구조체 포인터 변수 메모리 할당 해제
free(p_reg_data);
}
<TCS34725 RGBC Read 함수>
/*
- TCS34725 RGBC 측정값을 저장할 구조체
- 각 색상은 하위 8비트 + 상위 8비트 = 총 16비트 (0~65535)
- TWI 통신을 통해 데이터를 읽어 올 때, 각 색상 변수의 하위 8비트->상위 8비트 순으로 데이터가 채워짐
*/
typedef struct
{
uint16_t clear;
uint16_t red;
uint16_t green;
uint16_t blue;
} tcs34725_color_data_t;
/*
- TCS34725 RGBC Read 함수
- tcs34725_color_data_t : TCS34725 RGBC 구조체
- tcs34725_rgbc_callback_t : TCS34725 RGBC 콜백 함수, RGBC 값 수신 완료 후 호출
*/
ret_code_t tcs34725_read_rgbc(tcs34725_instance_t const * p_instance,
tcs34725_color_data_t * rgbc_str,
tcs34725_rgbc_callback_t user_cb)
{
ret_code_t err_code;
/*
- TCS34725_REG_CLEAR | 0xA0 : Clear data low byte(0x14)부터 Blue data high byte(0x1B)까지
연속으로 8바이트를 읽어와야 하므로 0xA0 (CMD :1, TYPE : 01 (Auto-increment)) 사용
- rgbc_str : 읽어온 RGBC 데이터를 저장할 구조체 포인터 변수
- TCS34725_RGBC_BYTES : 읽어 올 데이터는 총 8바이트이므로 8
*/
err_code=nrf_twi_sensor_reg_read(p_instance->p_sensor_data,
p_instance->sensor_addr,
(TCS34725_REG_CLEAR|0xA0),
(nrf_twi_sensor_reg_cb_t) user_cb,
(uint8_t *) rgbc_str,
TCS34725_RGBC_BYTES);
return err_code;
}
<TCS34725 RGBC Read 콜백 및 RGBC 수신 데이터 출력 함수>
//RGBC 콜백 함수, TCS34725로부터 RGBC 데이터 수신 완료 직후 호출됨
void tcs34725_rgbc_callback(ret_code_t result, tcs34725_color_data_t * p_raw_data)
{
if(result!=NRF_SUCCESS)
{
NRF_LOG_INFO("Reading RGBC registers is failed");
return;
}
//RGBC 출력 함수 호출
tcs34725_rgbc_print(p_raw_data);
//RGBC 데이터 수신에 사용된 구조체 포인터 변수 메모리 할당 해제
free(p_raw_data);
}
/*
- RGBC 측정값 출력 함수
- 구조체 포인터 변수에 저장된 RGB 데이터를 Clear 값으로 나누고 255를 곱한 뒤 출력
(RGB 값을 0~255 사이로 맞추기 위함)
*/
void tcs34725_rgbc_print(tcs34725_color_data_t * color_str)
{
uint16_t c_red,c_green,c_blue;
c_red=(int)((double)color_str->red/color_str->clear*255);
c_green=(int)((double)color_str->green/color_str->clear*255);
c_blue=(int)((double)color_str->blue/color_str->clear*255);
NRF_LOG_INFO("Clear : %d",color_str->clear);
NRF_LOG_INFO("Red : %d",c_red);
NRF_LOG_INFO("Green : %d",c_green);
NRF_LOG_INFO("Blue : %d",c_blue);
}
/*
- 인터럽트 설정(활성화) 함수
- 먼저 현재 TCS34725 Enable 레지스터에 저장된 데이터를 읽어 온다
그리고 그 데이터에 int_enable 값에 따라 BIT4 AIEN (인터럽트 인에이블)을 0 or 1로 설정
- 인터럽트 활성화 여부를 추가한 설정 데이터를 TCS34725 인에이블 레지스터에 다시 전송
- int_enable : 인터럽트 활성화 여부
*/
ret_code_t tcs34725_set_interrupt(tcs34725_instance_t const * p_instance,
tcs34725_int_enable_t int_enable)
{
ret_code_t err_code;
//TCS34725 인에이블 레지스터로부터 읽어 온 데이터를 저장하고 재전송할 구조체 변수 선언
tcs34725_reg_data_t enable_reg_str;
enable_reg_str.reg_addr=TCS34725_REG_ENABLE;
//인에이블 레지스터에 저장된 데이터를 읽어 와 구조체 변수에 저장
tcs34725_read_reg(p_instance,&enable_reg_str,NULL);
//TWI 매니저 큐에 대기된 전송이 없을 때까지(=인에이블 레지스터로부터 데이터 수신이 완료될 때까지)
//do~while문 반복
do
{
nrf_delay_us(10);
}while(nrf_twi_mngr_is_idle(&m_nrf_twi_mngr)!=true);
//읽어 온 인에이블 레지스터 데이터에 int_enable 값에 따라 BIT4 AIEN에 0 or 1 입력
if(int_enable==TCS34725_INTERRUPT_ENABLE)
{
enable_reg_str.reg_data=(enable_reg_str.reg_data|(TCS34725_INT_MASK));
}
else if(int_enable==TCS34725_INTERRUPT_DISABLE)
{
enable_reg_str.reg_data=(enable_reg_str.reg_data&~(TCS34725_INT_MASK));
}
else
{
err_code=NRF_ERROR_INVALID_PARAM;
return err_code;
}
//수정한 레지스터 설정값 전송
tcs34725_write_reg(p_instance, &enable_reg_str);
}
<TCS34725 인터럽트 클리어 함수>
/*
- 인터럽트 발생시 호출되는 핸들러
- Clear 쓰레스홀드값을 벗어나는 측정값들로 인해 인터럽트가 발생했음을 알리고
TCS34725에 인터럽트 클리어 명령을 전송해 인터럽트가 계속해서 발생할 수 있게 함
*/
void in_pin_handler(nrf_drv_gpiote_pin_t pin, nrf_gpiote_polarity_t action)
{
if(pin==TCS34725_INT_PIN)
{
ret_code_t err_code;
NRF_LOG_INFO("TCS34725 RGBC Interrupt occured");
//인터럽트 클리어 명령 전송
err_code=tcs34725_int_clear(&tcs34725_instance);
APP_ERROR_CHECK(err_code);
//성공적으로 전송 완료시 출력
if(err_code==NRF_SUCCESS)
{
NRF_LOG_INFO("TCS34725 Clear channel interrupt clear");
}
}
}
/*
- 인터럽트 클리어 함수
- 인터럽트 핀이 High->Low로 전환되며 인터럽트가 발생하는데 TCS34725에 인터럽트 클리어 명령어를
보내지 않는다면 인터럽트 핀이 Low 상태를 유지하므로 더 이상의 인터럽트가 발생하지 않는다
*/
ret_code_t tcs34725_int_clear(tcs34725_instance_t const * p_instance)
{
ret_code_t err_code;
/*
- 커맨드 레지스터 사용
- 0x66 : TYPE=11 (Special Function), ADDR/SF : 00110 (Clear channel interrupt clear)
- 0x80 : CMD=1
*/
uint8_t interrupt_cmd=0x66|0x80;
err_code=nrf_twi_sensor_write(p_instance->p_sensor_data, p_instance->sensor_addr, &interrupt_cmd,
TCS34725_REGISTER_SIZE, true);
return err_code;
}
- 상시 작동할 태스크는 3개 (보드 0번 LED 토글, MLX90614 온도 측정, 측정된 온도 BLE 통신 전송)
- 각 태스크 후미에 사용한 vTaskDelay()에 입력한 시간 간격마다 LED 토글 및 MLX90614 Object 1 Temperature 레지스터 Read 함수 호출
- MLX90614로부터 온도 데이터를 수신한 직후 호출되는 콜백 함수에서 측정한 온도값을 전송할 BLE 전송 태스크에 알림 및 읽어 온 온도 데이터 전달 (BLE 전송 태스크는 if문을 사용해 알림을 수신하기 전까지는 BLE 전송이 실행되지 않음)
- BLE 전송 태스크에서 알림 및 데이터를 획득한 뒤, 온도 데이터를 섭씨 온도로 변환 및 BLE 통해 전송
- BLE 통신을 통해 MLX90614를 제어하는데 사용할 각종 명령어 및 명령어 데이터 수신
- 방사율을 전송할 경우, 그에 필요한 태스크들을 생성한 뒤 삭제 (지속적으로 갱신할 필요가 없는 데이터이기 때문)
[코드]
<FreeRTOS 태스크 핸들 생성>
static TaskHandle_t m_led_toggle_thread; //nRF52840-DK LED0 토글
static TaskHandle_t m_mlx_rd_temp_thread; //MLX90614 온도 Read
static TaskHandle_t m_mlx_rd_emi_thread; //MLX90614 방사율 Read
static TaskHandle_t m_ble_mlx_temp_thread; //읽어 온 온도를 BLE 통신을 사용해 전송
static TaskHandle_t m_ble_mlx_emi_thread; //읽어 온 방사율을 BLE 통신을 사용해 전송
#if NRF_LOG_ENABLED
static TaskHandle_t m_logger_thread; //Log 확인
#endif
- 태스크 핸들 생성 (태스크 생성, 중단, 삭제 등 API 호출 시 태스크를 참조하는 데 사용)
- sdk_config.h 에서 NRF_LOG_ENABLED 1 로 설정했을 경우, nrf_log module configuration 내에 활성화한 각종 드라이버 및 라이브러리들의 로그가 출력됨 (J-Link RTT Viewer 사용해 확인 가능)
<태스크 생성 함수>
static void task_create_func(void)
{
if (pdPASS != xTaskCreate(mlx_rd_temp_thread, "MLX90614_RD_TEMP", configMINIMAL_STACK_SIZE+30, NULL, 2, &m_mlx_rd_temp_thread))
{
APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
}
if (pdPASS!=xTaskCreate(led_toggle_thread, "LED0", configMINIMAL_STACK_SIZE + 10, NULL, 2, &m_led_toggle_thread))
{
APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
}
if (pdPASS != xTaskCreate(ble_mlx_temp_thread, "BLE_MLX_TEMP", configMINIMAL_STACK_SIZE+30, NULL, 2, &m_ble_mlx_temp_thread))
{
APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
}
//sdkconfig.h - NRF_LOG_ENABLED 1 로 활성화했을 때, Log 출력 태스크 생성
#if NRF_LOG_ENABLED
if (pdPASS!=xTaskCreate(logger_thread, "LOGGER", 256, NULL, 1, &m_logger_thread))
{
APP_ERROR_HANDLER(NRF_ERROR_NO_MEM);
}
#endif
}
태스크 생성 예)
- mlx_rd_temp_thread : 태스크를 실행할 함수명
- MLX90614_RD_TEMP : 태스크 설명 이름 (디버깅용)
- configMINIMAL_STACK_SIZE+30 : 태스크에 할당할 스택 사이즈
(configMINIMAL_STACK_SIZE=60)
(byte가 아닌 word 기준 (32bit MCU의 경우, 1 word=32bit), 스택 사이즈 90=360 bytes)
- 센서로부터 온도 데이터를 읽어 오는데 사용할 구조체 변수 선언 및 Object 1 Temperature 레지스터 주소 설정
- MLX90614 레지스터 Read 함수 호출
- vTaskDelay(1000) : 1000ms 마다 태스크 실행
<MLX90614 온도 콜백 함수>
//MLX90614 - Object 1 레지스터 데이터 수신 완료 직후에 호출되는 함수
void mlx90614_read_temp_cb(ret_code_t result, mlx90614_reg_data_t * p_raw_data)
{
uint8_t crc_value;
if (result != NRF_SUCCESS)
{
NRF_LOG_WARNING("Read Temperature Callback Error : %d", (int)result);
return;
}
if(p_raw_data->pec!=mlx90614_crc_cal(p_raw_data,MLX90614_Read))
{
NRF_LOG_WARNING("MLX90614 Read temperature CRC doesn't match");
NRF_LOG_INFO("PEC : %X CRC : %X",p_raw_data->pec,mlx90614_crc_cal(p_raw_data,MLX90614_Read));
}
else
{
/*
TWI 통신을 통해 성공적으로 Object 1 레지스터에 저장된 온도 데이터를 수신 완료하고
CRC 계산을 통과하면 BLE 통신을 통해 온도값을 전송하는 태스크에 알림 및 읽어 온 온도 데이터 전송
m_ble_mlx_temp_thread : 알림을 수신할 태스크 생성에 사용된 태스크 핸들
p_raw_data->reg_data : 전달할 데이터 (최대 32bit까지만 가능)
eSetValueWithOverwrite : 전달될 데이터의 행동 설정 (무조건적으로 p_raw_data->reg_data 사용 설정)
*/
xTaskNotify(m_ble_mlx_temp_thread, p_raw_data->reg_data, eSetValueWithOverwrite);
}
}
- MLX90614의 온도 레지스터로부터 데이터를 읽어 온 직후 호출되는 함수
- 데이터 수신에 성공 및 CRC 계산값이 일치한다면 BLE 통신을 통해 온도값을 전송하는 태스크에 알림을 전송
- xTaskNotify의 경우, 최대 32bit의 데이터를 알림과 함께 전달 가능하므로 온도 데이터값을 가지고 있는 p_raw_data->reg_data의 값을 알림과 함께 전달
<BLE - 온도 전송 태스크>
/*
- xTaskNotify()를 통해 알림이 전달되었을 경우에만 전달된 데이터를 온도값으로 변환한 뒤
BLE 통신을 통해 온도값을 전송하는 태스크
*/
static void ble_mlx_temp_thread(void *arg)
{
ret_code_t err_code;
char data_array[6]={}; //변환된 온도 데이터를 BLE 통신을 통해 전송할 때 사용할 배열
//정수 세 자리 + '.'+ 소수점 두자리 = 6
double temperature; //변환한 온도를 저장할 변수
uint16_t temp; //xTaskNotify를 통해 알림과 같이 전달된 온도 데이터(p_raw_data->reg_data)를 저장할 변수
uint16_t length=sizeof(data_array); //BLE 통신을 통해 전송할 데이터의 길이
while(1)
{
/*
- xTaskNotify()를 통해 전달된 알림이 있을 경우에만 ulTaskNotifyTake()를 통해 획득한
데이터가 0이 아닌 값을 갖는다
- 알림을 수신할 때까지 최대 10ms동안 Blocked 상태로 대기
(Blocked 상태일 때 CPU 시간 소모 X)
*/
if((temp=ulTaskNotifyTake(pdTRUE,10))!=0)
{
temperature=mlx90614_temp_conversion(temp);
//UART 통신을 사용하므로 변환된 온도 데이터를 sprintf()함수를 이용해 문자열로 저장 후 전송
sprintf(data_array,"%3.2f",temperature);
//BLE 통신 연결이 된 상태 & MLX90614로부터 읽어 온 데이터가 유효할 때 온도값 전송
//(MLX90614가 유효한 데이터를 측정하기 전에 데이터를 읽어 올 경우 온도 데이터=-273.15)
if((m_conn_handle!=BLE_CONN_HANDLE_INVALID)&&(temperature!= -273.15))
{
err_code=ble_nus_data_send(&m_nus, data_array, &length, m_conn_handle);
if ((err_code != NRF_ERROR_INVALID_STATE) &&
(err_code != NRF_ERROR_RESOURCES) &&
(err_code != NRF_ERROR_NOT_FOUND))
{
APP_ERROR_CHECK(err_code);
}
}
}
}
}
static void nus_data_handler(ble_nus_evt_t * p_evt)
{
char str_cmd[]={"000"}; //수신한 명령어 저장
char str_data[]={"000"}; //수신한 데이터 저장 (명령어+명령어에 필요한 데이터 조합)
//BLE UART를 통해 데이터를 수신했을 때
if (p_evt->type == BLE_NUS_EVT_RX_DATA)
{
uint32_t err_code;
NRF_LOG_DEBUG("Received data from BLE NUS. Writing data on UART.");
NRF_LOG_HEXDUMP_DEBUG(p_evt->params.rx_data.p_data, p_evt->params.rx_data.length);
for (uint32_t i = 0; i < p_evt->params.rx_data.length; i++)
{
do
{
err_code = app_uart_put(p_evt->params.rx_data.p_data[i]);
if ((err_code != NRF_SUCCESS) && (err_code != NRF_ERROR_BUSY))
{
NRF_LOG_ERROR("Failed receiving NUS message. Error 0x%x. ", err_code);
APP_ERROR_CHECK(err_code);
}
} while (err_code == NRF_ERROR_BUSY);
}
if (p_evt->params.rx_data.p_data[p_evt->params.rx_data.length - 1] == '\r')
{
while (app_uart_put('\n') == NRF_ERROR_BUSY);
}
//수신한 데이터의 1~3번째 바이트를 명령어 배열(str_cmd)에 저장
memcpy(str_cmd,p_evt->params.rx_data.p_data,3);
//수신한 데이터의 4~6번째 바이트를 데이터 배열(str_data)에 저장
if(3<p_evt->params.rx_data.length)
{
memcpy(str_data,&p_evt->params.rx_data.p_data[3],3);
}
}
/*
- 수신한 명령어가 있을 때, MLX90614 명령어 실행 함수 호출
BLE 데이터 송신으로 핸들러 함수가 호출되었을 때는 str_cmd 배열의 값이 "000"을 유지하므로
MLX90614에 명령어를 실행하는 함수가 실행되지 않는다
*/
if(strcmp(str_cmd,"000")!=0)
{
mlx90614_cmd_func(str_cmd, str_data);
}
}
- BLE를 통해 UART 방식의 통신을 전송, 수신했을 때 호출되는 핸들러 함수
- MLX90614를 제어하는데 사용할 각종 명령어 및 데이터를 수신 및 배열에 저장한 뒤 제어 함수 호출
- FreeRTOSConfig.h 에서 INCLUDE_uxTaskGetStackHighWaterMark 1 로 설정 필요
- 태스크를 생성하며 할당한 스택 크기 중 태스크가 실행된 이후 측정된 사용 가능 스택 잔량의 최소 크기를 반환
- 반환값이 0에 근접할 수록 스택 오버 플로우에 가까워짐
<스마트폰을 통한 온도 및 방사율값 수신>
- nRF Toolbox 애플리케이션 사용
- nRF52840-DK와 연결된 직후부터 BLE 통신을 통해 온도값이 수신되기 시작
- 온도 측정 중 "REM"(방사율 측정 및 수신) 명령어를 전송해 MLX90614에 현재 설정된 방사율을 BLE 통신을 통해 수신
- MLX90614로부터 방사율을 읽어오는 TWI 통신은 TWI transaction manager 라이브러리의 nrf_twi_mngr_schedule() 함수를 사용해 TWI 전송 큐에 등록되므로 온도값을 읽어 오는 중간에 사용되어도 온도값 수신에 영향을 미치지 않는다
- MLX90614로부터 방사율을 읽어오는데 사용되는 mlx90614_rd_emi_thread() 태스크는 mlx90614_reg_read() 함수를 호출한 이후에 삭제되므로 MLX90614로부터 저장된 방사율 데이터를 읽어오는 TWI 통신에 영향을 미치지 않는다
- BLE 방사율 전송 태스크 또한 알림을 획득하고 BLE 전송을 완료한 이후에만 태스크 삭제가 실행되므로 BLE 통신을 통한 방사율값 전송에 영향을 미치지 않는다
- SDK 폴더 내 components\drivers_ext 에 위치한 CCS811, LPS22HB 드라이버 등을 바탕으로 작성됨
- mlx90614.c, mlx90614.h, mlx90614_internal.h 하나의 소스 파일, 두 개의 헤더 파일로 구성
- 매크로 선언
/*
main.c
*/
//MLX90614와의 통신에 사용할 TWI 인스턴스 ID
#define TWI_INSTANCE_ID_1 1
//TWI trasaction manager 인스턴스 Queue 최대 크기 (대기 전송 갯수)
#define MAX_PENDING_TRANSACTIONS 255
/*
- TWI transaction manager 인스턴스 정의 매크로
생성할 TWI transaction manager 인스턴스 이름, 트랜잭션 Queue 크기, 사용할 TWI 인스턴스
*/
NRF_TWI_MNGR_DEF(m_nrf_twi_mngr_1, MAX_PENDING_TRANSACTIONS, TWI_INSTANCE_ID_1);
/*
- 공통 TWI 센서 인스턴스 생성 매크로
공통 센서 인스턴스 이름, 사용할 TWI transaction manager 인스턴스, 버퍼 크기
(버퍼 크기의 경우 TWI manager Queue 크기보다 작거나 같아야 한다)
*/
NRF_TWI_SENSOR_DEF(sensor_instance_1, &m_nrf_twi_mngr_1, MAX_PENDING_TRANSACTIONS);
/*
- 센서 인스턴스 생성 매크로
센서 인스턴스 이름, 사용할 공통 TWI 센서 인스턴스, 센서 주소
*/
MLX90614_INSTANCE_DEF(mlx90614_instance, &sensor_instance_1, MLX90614_ADDR);
/*
mlx90614.h
*/
//MLX90614xCx 모델 사용하는 경우 주석 해제
//#define MLX90614xCx
//CRC-8 계산에 이용
#define MLX90614_Write 0
#define MLX90614_Read 1
//센서 주소
#define MLX90614_ADDR 0x5A
//통신에 사용할 TWI manager instance 에 요구하는 최소 Queue 크기
#define MLX90614_MIN_QUEUE_SIZE 4
//MLX90614 통신에 사용할 SDA, SCL PIN
#define MLX90614_SDA_PIN 28
#define MLX90614_SCL_PIN 29
//데이터 콜백 프로토타입
typedef void (* mlx90614_data_callback_t)(ret_code_t result, mlx90614_reg_data_t * p_raw_data);
//MLX90614 인스턴스 정의 매크로
#define MLX90614_INSTANCE_DEF(_mlx90614_inst_name, _p_twi_sensor, _sensor_address) \
MLX90614_INTERNAL_INSTANCE_DEF(_mlx90614_inst_name, _p_twi_sensor, _sensor_address)
/*
mlx90614_internal.h
*/
//전송할 데이터 바이트 크기 (송수신 동일. LSB+MSB+PEC)
#define MLX90614_REGISTER_BYTES 3
//MLX90614 RAM 및 EEPROM Register 주소
#define MLX90614_REG_AMBIENT_TEMP 0x06 //주변 온도
#define MLX90614_REG_OBJECT_1_TEMP 0x07 //물체 온도 1
#define MLX90614_REG_OBJECT_2_TEMP 0x08 //물체 온도 2
#define MLX90614_REG_EMISSIVITY_1 0x24 //방사율 주소
#define MLX90614_REG_EMISSIVITY_2 0x2F //MLX90614xCx 모델을 사용할 경우에만 이용할 추가 방사율 주소
#define MLX90614_REG_SLEEP 0xFF //슬립 모드 진입에 사용
/*
MLX90614 인스턴스 구조체
p_sensor_data : NRF_TWI_SENSOR_DEF을 통해 생성한 common twi sensor instance
sensor_addr : MLX90614_INSTANCE_DEF를 통해 MLX90614 인스턴스를 생성할 때 입력한 센서 주소
*/
typedef struct
{
nrf_twi_sensor_t * const p_sensor_data;
uint8_t const sensor_addr;
} mlx90614_instance_t;
/*
센서 인스턴스 생성 매크로
*/
#define MLX90614_INTERNAL_INSTANCE_DEF(_mlx90614_inst_name, _p_twi_sensor, _sensor_address)\
static mlx90614_instance_t _mlx90614_inst_name = \
{ \
.p_sensor_data = _p_twi_sensor, \
.sensor_addr = _sensor_address, \
}
- 구조체
/*
mlx90614.h
*/
/*
reg_data : MLX90614로부터 읽어 온 데이터를 저장하거나 MLX90614 EEPROM 레지스터에 입력할 데이터를 저장
RAM, EEPROM 의 각 레지스터는 16bit 크기를 갖는다
pec : MLX90614로부터 읽어 온 데이터가 제대로 전송이 됐는지 확인하기 위한 Packet Error Code
CRC-8 계산 필요
reg_addr : 해당 변수 구조체가 접근할 MLX90614의 레지스터 주소를 저장하는 변수
PEC 계산에도 이용된다 (단순 레지스터 주소 저장용일뿐. 데이터 전송에는 이용되지 않음)
구조체 변수를 통해 레지스터 데이터를 읽거나 쓸 때, reg_data의 LSB -> MSB -> pec 순으로 송수신 된다
MLX90614의 데이터 송수신은 LSB부터 시작되므로 reg_data 의 MSB, LSB 스왑은 필요없다
*/
typedef struct
{
uint16_t reg_data;
uint8_t pec;
uint8_t reg_addr;
} mlx90614_reg_data_t;
- TWI 설정 및 초기화 (main.c)
//MLX90614와의 통신에 사용할 TWI 통신 설정
static void twi_config(void)
{
uint32_t err_code;
//통신에 사용할 핀, 속도, 인터럽트 우선 순위 설정
nrf_drv_twi_config_t const config={
.scl=29,
.sda=28,
.frequency=NRF_DRV_TWI_FREQ_100K,
.interrupt_priority=APP_IRQ_PRIORITY_MID,
};
//앞서 생성한 설정을 바탕으로 TWI transaction manager instance 초기화
err_code=nrf_twi_mngr_init(&m_nrf_twi_mngr_1,&config);
APP_ERROR_CHECK(err_code);
}
- Register Data Read 함수
/*
mlx90614_instance_t : MLX90614_INSTANCE_DEF을 통해 생성한 MLX90614 센서 인스턴스
mlx90614_reg_data_t : 읽어 온 데이터를 저장할 센서 데이터 구조체
mlx90614_data_callback_t : 데이터 수신 완료 후 호출될 콜백 함수
*/
ret_code_t mlx90614_reg_read(mlx90614_instance_t const * p_instance,
mlx90614_reg_data_t * p_reg_data,
mlx90614_data_callback_t user_cb
)
{
ASSERT(p_instance != NULL);
ASSERT(p_reg_data != NULL);
/*
p_instance->p_sensor_data : NRF_TWI_SENSOR_DEF을 통해 설정된 공통 센서 인스턴스
p_instance->sensor_addr : MLX90614 센서 인스턴스에 설정된 MLX90614 센서 주소
p_reg_data->reg_addr : 전달받은 구조체에 저장된 레지스터 주소
해당 레지스터 주소에 접근해 데이터를 읽어온다
nrf_twi_sensor_reg_cb_t : 데이터 수신 완료 후 호출 할 콜백 함수
MLX90614_REGISTER_BYTES : 읽어 올 데이터의 바이트 크기 (uint8_t 기준)
(Data 16bit(LSB(8)+MSB(8)) + PEC(8bit)=24bit)
*/
return nrf_twi_sensor_reg_read(p_instance->p_sensor_data,
p_instance->sensor_addr,
p_reg_data->reg_addr,
(nrf_twi_sensor_reg_cb_t) user_cb,
(uint8_t *) p_reg_data,
MLX90614_REGISTER_BYTES);
}
MLX90614 RAM, EEPROM의 레지스터 주소에 액세스해 레지스터에 저장된 16bit 데이터를 읽어오는 함수
nrf_twi_sensor_reg_read 함수는 nrf_twi_mngr_schedule 함수를 이용하므로 수신이 완료될 때까지 대기하는게 아니라 TWI transaction manager instance의 transaction queue에 데이터 수신을 대기시킨다
transaction queue에 대기해있던 데이터 수신이 완료된 이후에 콜백 함수가 호출된다
(콜백 함수 호출이 필요없다면 NULL 값을 입력)
- 온도 데이터, 방사율 데이터 변환 함수
//읽어 온 16bit 방사율 데이터를 데이터 시트에 나와있는 식을 통해 실제 방사율값으로 변환
inline float mlx90614_emissivity_conversion(uint16_t emissivity_val)
{
return (emissivity_val+1)/65536.0;
}
//읽어 온 16bit 온도 데이터를 데이터 시트에 나와있는 식을 통해 실제 온도값으로 변환 (섭씨 기준)
inline double mlx90614_temp_conversion(uint16_t temperature_val)
{
return (temperature_val*0.02)-273.15;
}
(MLX90614 Address<<1+W(0)) + Register Address(Command) + (MLX90614 Address<<1+R(1)) + Register Data (LSB) + Register Data (MSB) 의 CRC-8 계산
MLX90614에 데이터를 쓸 때 함께 입력할 PEC는
(MLX90614 Address<<1+W(0)) + Register Address(Command) + Register Data (LSB) + Register Data (MSB) 의 CRC-8 계산
- 방사율 변경 함수
EEPROM으로부터 데이터를 읽어오거나 데이터를 쓸 경우엔 데이터 시트의 EEPROM 테이블에 나와있는 레지스터 주소에서 0x20 의 값을 더해 준 값을 사용해야 한다
ex) EEPROM 방사율 주소 = 0x04 번지, 실제 사용은 0x04 | 0x20 = 0x24 (CMD) 이용
MLX90614xCx 모델의 경우, EEPROM 0x0F 번지의 데이터도 변경해줘야 온도가 제대로 측정되는데 이 데이터는 0x04 번지의 데이터를 계산할 때와는 다르게 기존 0x0F 번지에 저장되어있던 값을 이용해 계산되므로 우선적으로 0x0F에 저장된 값을 따로 기록해 둘 것을 권장 (사용 모듈의 경우, 0x0F = 0x079A 인 상태였음)
EEPROM에 새로운 데이터를 입력하기 위해선 우선 해당 레지스터 주소에 0x0000 데이터를 입력해 기존 데이터를 지워줘야 한다
*
mlx90614_instance_t : MLX90614_INSTANCE_DEF을 통해 생성한 MLX90614 센서 인스턴스
new_emissivity : EEPROM에 입력할 새 방사율
*/
ret_code_t mlx90614_emissivity_write(mlx90614_instance_t const * p_instance,
float new_emissivity
)
{
ASSERT(p_instance != NULL);
//방사율은 0.1~1.0까지만 설정 가능
if(new_emissivity<0.10 || 1.0<new_emissivity)
{
NRF_LOG_WARNING("Invaild Emissivity Value");
return NRF_ERROR_INVALID_DATA;
}
//TWI transaction manager instance의 Queue 상태를 확인하기 위한 부울 변수
bool idle_chk=false;
//에러 코드 저장
ret_code_t err_code;
//레지스터에 새 방사율 데이터가 제대로 써졌는지 확인용
uint16_t emissivity_chk_data;
/*
새 방사율값을 저장할 구조체
reg_addr : 계산된 새 방사율값을 저장할 EEPROM 레지스터 주소 (0x04 | 0x20 = 0x24)
reg_data : 데이터 시트에 나와있는 식을 통해 계산된 16비트 데이터
pec : 데이터에 이어서 전송될 PEC 데이터
만약 제대로 계산된 PEC값이 전송되지 않는다면 EEPROM은 기존 데이터를 유지한다
*/
mlx90614_reg_data_t new_emissivity_1;
new_emissivity_1.reg_addr=MLX90614_REG_EMISSIVITY_1;
new_emissivity_1.reg_data=(int)(round(65536*(new_emissivity)-1.0));
new_emissivity_1.pec=mlx90614_crc_cal(&new_emissivity_1,MLX90614_Write);
//0x04 번지에 새 방사율 데이터가 제대로 저장이 됐는지 확인하기 위해 계산된 새 방사율 데이터 저장
emissivity_chk_data=new_emissivity_1.reg_data;
/*
EEPROM에 데이터를 쓰기 위해선 우선적으로 해당 레지스터에 0x0000 값을 갖는 16비트 데이터를 입력해야 한다
0x0000 의 값을 전송할 구조체 선언 후 레지스터 주소 입력, PEC 계산값 저장
*/
mlx90614_reg_data_t emissivity_zero;
emissivity_zero.reg_addr=MLX90614_REG_EMISSIVITY_1;
emissivity_zero.pec=mlx90614_crc_cal(&emissivity_zero,MLX90614_Write);
/*
- MLX90614xCx 모델을 사용하는 경우에만 실행되는 부분
현재 EEPROM 0x04 번지에 입력되어있는 방사율 데이터가 필요하다
*/
#ifdef MLX90614xCx
//현재 EEPROM에 저장되어있는 0x04 번지의 방사율 데이터를 저장할 구조체 변수 선언 및 레지스터 주소 입력
mlx90614_reg_data_t old_emissivity_1;
old_emissivity_1.reg_addr=MLX90614_REG_EMISSIVITY_1;
//old_emissivity_1 구조체에 EEPROM 0x04 (CMD 0x24) 번지에 저장된 현재 방사율값 읽어와 저장
err_code=nrf_twi_sensor_reg_read(p_instance->p_sensor_data,
p_instance->sensor_addr,
MLX90614_REG_EMISSIVITY_1,
(nrf_twi_sensor_reg_cb_t) NULL,
(uint8_t *) &old_emissivity_1,
MLX90614_REGISTER_BYTES);
//nrf_twi_sensor_reg_read 함수 실행 에러 발생시
if (err_code != NRF_SUCCESS)
{
NRF_LOG_WARNING("MLX90614xCx : Old emissivity 1 read failed.");
return err_code;
}
/*
데이터 송수신에 사용하는 TWI Sensor module 라이브러리는
TWI trasaction manager 라이브러리의 nrf_twi_mngr_schedule 함수를 이용해 데이터를 전송한다
때문에 old_emissivity_1 구조체에 레지스터로부터 읽어 온 데이터가 저장되기까지 대기를 한 후
(=TWI transaction manager queue==idle 상태)
CRC 값을 계산 및 읽어 온 PEC값과 비교한다
*/
do
{
idle_chk=nrf_twi_mngr_is_idle(p_instance->p_sensor_data->p_twi_mngr);
nrf_delay_us(10);
}while(idle_chk!=true);
//수신이 제대로 됐는지 확인을 위해 읽어 온 PEC 값과 CRC-8 계산 결과를 비교
if(old_emissivity_1.pec!=mlx90614_crc_cal(&old_emissivity_1,MLX90614_Read))
{
NRF_LOG_WARNING("MLX90614xCx : Old emissivity 1 CRC doesn't match");
return NRF_ERROR_INVALID_DATA;
}
#endif
//모델 상관없이 공통적으로 진행 시작
//0x0000의 데이터값을 먼저 전송해 방사율 레지스터 주소(0x04)의 데이터를 지운다
err_code=nrf_twi_sensor_reg_write(p_instance->p_sensor_data,
p_instance->sensor_addr,
MLX90614_REG_EMISSIVITY_1,
(uint8_t *)&emissivity_zero,
sizeof(emissivity_zero)/sizeof(uint8_t)
);
//nrf_twi_sensor_reg_write 함수 실행 에러 발생시
if (err_code != NRF_SUCCESS)
{
NRF_LOG_WARNING("MLX90614 : Emissivity 1 erase failed");
return err_code;
}
/*
0x0000 데이터 입력 후, 새 방사율 데이터를 전송하기 위해선 최소 5ms, 권장 10ms의
여유 시간이 필요하므로 0x0000 데이터 전송 완료까지 기다린 뒤에 딜레이 함수를 이용해 10ms 대기
*/
do
{
idle_chk=nrf_twi_mngr_is_idle(p_instance->p_sensor_data->p_twi_mngr);
nrf_delay_us(10);
}while(idle_chk!=true);
nrf_delay_ms(10);
//데이터 시트에 나와있는 식을 통해 계산된 새 방사율값 EEPROM 0x04 번지에 전송
err_code=nrf_twi_sensor_reg_write(p_instance->p_sensor_data,
p_instance->sensor_addr,
MLX90614_REG_EMISSIVITY_1,
(uint8_t*)&new_emissivity_1,
sizeof(new_emissivity_1)/sizeof(uint8_t)
);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_WARNING("MLX90614 : New emissivity 1 write failed");
return err_code;
}
do
{
idle_chk=nrf_twi_mngr_is_idle(p_instance->p_sensor_data->p_twi_mngr);
nrf_delay_us(10);
}while(idle_chk!=true);
//새 방사율 데이터를 레지스터에 쓴 이후에도 똑같이 최소 5ms, 권장 10ms의 대기가 필요하다
nrf_delay_ms(10);
/*
EEPROM 0x04 번지에 저장된 방사율 데이터를 읽어와 앞서 emissivity_chk_data에 저장한
새 방사율 데이터와 비교해 EEPROM에 새 방사율 데이터가 제대로 입력됐는지 확인
*/
err_code=nrf_twi_sensor_reg_read(p_instance->p_sensor_data,
p_instance->sensor_addr,
MLX90614_REG_EMISSIVITY_1,
(nrf_twi_sensor_reg_cb_t) NULL,
(uint8_t *) &new_emissivity_1,
MLX90614_REGISTER_BYTES);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_WARNING("MLX90614 : New emissivity 1 read failed", err_code);
return err_code;
}
/*
TWI transaction manager instance의 queue에 데이터 수신이 대기된 상태로 존재하기 때문에
수신 완료까지(Queue==0) 대기한 후에 데이터 비교를 진행한다
*/
do
{
idle_chk=nrf_twi_mngr_is_idle(p_instance->p_sensor_data->p_twi_mngr);
nrf_delay_us(10);
}while(idle_chk!=true);
//EEPROM 0x04 번지에 새 방사율 데이터가 제대로 입력됐는지 확인
if(new_emissivity_1.reg_data!=emissivity_chk_data)
{
NRF_LOG_INFO("New Emissivity 1 data doesn't match");
return NRF_ERROR_INVALID_DATA;
}
/*
- MLX90614xCx 모델을 사용하는 경우에만 실행되는 부분
MLX90614xCx 모델의 경우, 방사율 데이터를 변경할 때 EEPROM 0x04 번지의 데이터만 바꾸는 것이 아니라
0x0F 번지에 저장되어 있는 값도 데이터 시트에 나와있는 식을 통해 얻은 값으로 변경해야
방사율에 따른 옳바른 온도값이 측정된다
*/
#ifdef MLX90614xCx
/*
앞서 0x04 번지의 데이터를 지우기 위해 선언 및 사용한 0x0000 데이터를 가진 구조체 변수에
0x0F 주소 입력 및 PEC값 재계산해 저장
*/
emissivity_zero.reg_addr=MLX90614_REG_EMISSIVITY_2;
emissivity_zero.pec=mlx90614_crc_cal(&emissivity_zero, MLX90614_Write);
/*
new_emissivity_2 : EEPROM 0x0F 번지에 쓸 새 방사율 데이터를 저장할 구조체 변수
old_emissivity_2 : 현재 EEPROM 0x0F 번지에 저장된 방사율 데이터를 읽어와 저장할 구조체 변수
*/
mlx90614_reg_data_t new_emissivity_2, old_emissivity_2;
//EEPROM 0x0F 번지 주소 입력 (0x0F | 0x20 = 0x2F)
new_emissivity_2.reg_addr=MLX90614_REG_EMISSIVITY_2;
old_emissivity_2.reg_addr=MLX90614_REG_EMISSIVITY_2;
//현재 EEPROM 0x0F 번지에 입력되어있는 방사율 데이터를 읽어와 old_emissivity_2 구조체 변수에 저장
err_code=nrf_twi_sensor_reg_read(p_instance->p_sensor_data,
p_instance->sensor_addr,
MLX90614_REG_EMISSIVITY_2,
(nrf_twi_sensor_reg_cb_t) NULL,
(uint8_t *) &old_emissivity_2,
MLX90614_REGISTER_BYTES);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_WARNING("MLX90614xCx : Old emissivity 2 read failed");
return err_code;
}
do
{
idle_chk=nrf_twi_mngr_is_idle(p_instance->p_sensor_data->p_twi_mngr);
nrf_delay_us(10);
}while(idle_chk!=true);
if(old_emissivity_2.pec!=mlx90614_crc_cal(&old_emissivity_2,MLX90614_Read))
{
NRF_LOG_WARNING("Old emissivity 2 CRC doesn't match");
return NRF_ERROR_INVALID_DATA;
}
/*
기존에 저장되어있는 0x04 번지의 방사율 데이터(old_emissivity.reg_data)와 앞서 0x04 번지에 입력한
새로운 방사율 데이터(new_emissivity_1.reg_data) 그리고 0x0F 번지에 저장되어있던 데이터
(old_emissivity_2.reg_data)를 이용해 0x0F 번지에 입력될 새로운 데이터 값을 구한다
*/
//0x0F 번지에 입력할 새로운 데이터값 계산 후 저장
new_emissivity_2.reg_data=
(round(((double)old_emissivity_1.reg_data/new_emissivity_1.reg_data)*old_emissivity_2.reg_data));
//0x0F 번지에 전송될 PEC값을 CRC-8 계산 후 저장
new_emissivity_2.pec=mlx90614_crc_cal(&new_emissivity_2,MLX90614_Write);
//위에서 계산된 0x0F에 입력할 새 방사율 데이터를 데이터 확인용 변수에 저장
emissivity_chk_data=new_emissivity_2.reg_data;
//0x000 데이터를 먼저 전송해 0x0F 번지 데이터 지움
err_code=nrf_twi_sensor_reg_write(p_instance->p_sensor_data,
p_instance->sensor_addr,
MLX90614_REG_EMISSIVITY_2,
(uint8_t *)&emissivity_zero,
sizeof(emissivity_zero)/sizeof(uint8_t)
);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_WARNING("MLX90614xCx : Emissivity 2 erase failed", err_code);
return err_code;
}
do
{
idle_chk=nrf_twi_mngr_is_idle(p_instance->p_sensor_data->p_twi_mngr);
nrf_delay_us(10);
}while(idle_chk!=true);
nrf_delay_ms(10);
//0x0F 번지에 새롭게 계산된 방사율 데이터를 전송
err_code=nrf_twi_sensor_reg_write(p_instance->p_sensor_data,
p_instance->sensor_addr,
MLX90614_REG_EMISSIVITY_2,
(uint8_t *)&new_emissivity_2,
sizeof(new_emissivity_2)/sizeof(uint8_t)
);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_WARNING("MLX90614xCx : New emissivity 2 write failed");
return err_code;
}
do
{
idle_chk=nrf_twi_mngr_is_idle(p_instance->p_sensor_data->p_twi_mngr);
nrf_delay_us(10);
}while(idle_chk!=true);
nrf_delay_ms(10);
//새로운 방사율 데이터가 제대로 써졌는지 확인하기 위해 0x0F 번지에 저장된 데이터를 읽어 옴
err_code=nrf_twi_sensor_reg_read(p_instance->p_sensor_data,
p_instance->sensor_addr,
MLX90614_REG_EMISSIVITY_2,
(nrf_twi_sensor_reg_cb_t) NULL,
(uint8_t *) &new_emissivity_2,
MLX90614_REGISTER_BYTES);
if (err_code != NRF_SUCCESS)
{
NRF_LOG_WARNING("MLX90614xCx : New emissivity 2 read failed");
return err_code;
}
do
{
idle_chk=nrf_twi_mngr_is_idle(p_instance->p_sensor_data->p_twi_mngr);
nrf_delay_us(10);
}while(idle_chk!=true);
//0x0F 번지에 새 방사율 데이터가 제대로 써졌는지 확인
if(new_emissivity_2.reg_data=!emissivity_chk_data)
{
NRF_LOG_INFO("New emissivity 2 data doesn't match");
return NRF_ERROR_INVALID_DATA;
}
#endif
return NRF_SUCCESS;
}
- Sleep 함수
/*
슬립 모드에 진입하기 위해선 Command=0xFF, PEC=0xE8 2바이트를 전송하면 된다
Command는 nrf_twi_sensor_reg_write의 세번째 인자로 쓰인 MLX90614_REG_SLEEP가 사용되므로
실제 전송할 바이트 크기는 PEC 1바이트가 된다
*/
ret_code_t mlx90614_sleep_enter(mlx90614_instance_t const * p_instance)
{
uint8_t sleep_pec=0xE8;
return nrf_twi_sensor_reg_write(p_instance->p_sensor_data,
p_instance->sensor_addr,
MLX90614_REG_SLEEP,
(uint8_t*)&sleep_pec,
sizeof(sleep_pec)/sizeof(uint8_t)
);
}
/*
슬립 모드에서 빠져나오기 위해선 SDA 핀을 33ms를 초과하는 시간동안 LOW로 유지해야 한다
이를 위해 MLX90614 와의 통신에 사용하던 TWI를 해제하고 SDA핀을 LOW 출력 설정으로 바꾼 후
딜레이 함수를 통해 34ms 동안 LOW 상태를 유지함으로 슬립 모드에서 탈출
이후에 다시 twi_config() 함수를 실행해 통신에 사용할 TWI를 재초기화해줘야 한다
하지 않을 경우, 센서와의 통신 불가
*/
void mlx90614_sleep_exit(mlx90614_instance_t const * p_instance, uint8_t sda_pin)
{
bool idle_chk;
//현재 TWI manager instance Queue에 대기해있는 전송이 완료될 때까지 대기
do
{
idle_chk=nrf_twi_mngr_is_idle(p_instance->p_sensor_data->p_twi_mngr);
nrf_delay_us(10);
}while(idle_chk!=true);
//TWI manager instance 해제
nrf_twi_mngr_uninit(p_instance->p_sensor_data->p_twi_mngr);
//SDA 핀 Output 설정 및 LOW 출력으로 설정
nrf_gpio_cfg_output(sda_pin);
nrf_gpio_pin_write(sda_pin,0);
//34ms 동안 SDA=LOW 유지
nrf_delay_ms(34);
}
- Sleep 실행 예시
1. 방사율, Object 1 온도 읽음
2. 슬립 모드 진입
3. 다섯 번의 Object 1 Read 실행
4. 슬립 모드 탈출
5. twi_config() 실행
6. Object 1 Read 시작
슬립 모드 진입 후 다섯번의 Object 1 Temperature 레지스터 접근 시도가 있었지만 실패35ms 동안 SDA 핀 LOW 유지해 슬립 모드 탈출
- nrf_twi_sensor.h 내 NRF_TWI_SENSOR_SEND_BUF_SIZE 수정 (전송 가능한 최대 버퍼 크기)
/**
* @brief Internal write operation buffer length.
*
* Defines how many bytes can be stored internally.
* 16 bytes were selected so that nrf_twi_sensor_write_cmd_t size
* matches nrf_twi_sensor_read_cmd_t size.
*/
#define NRF_TWI_SENSOR_SEND_BUF_SIZE 255 //default 16
[코드]
- 정의 및 전역 변수
#define TWI_INSTANCE_ID 0 //TWI instance id used for driver
#define MAX_PENDING_TRANSACTIONS 20 //TWI transaction manager 최대 Queue 개수 (현재 진행 중 제외)
#define SSD1306_ADDR 0x3C //SSD1306 Slave Address
#define ssd1306_data_select 0x40 //SSD1306 Data 입력할 때 사용
#define ssd1306_cmd_select 0x00 //SSD1306 Command 입력할 때 사용
#define font_width 12 //사용할 폰트의 문자 너비
//Macro that simplifies defining a TWI transaction manager instance.
//생성할 인스턴스 이름, 트랜잭션 큐 크기(최대 보류 트랜잭션 개수), 사용할 하드웨어 TWI 인스턴스 색인
NRF_TWI_MNGR_DEF(m_nrf_twi_mngr, MAX_PENDING_TRANSACTIONS, TWI_INSTANCE_ID);
//Macro creating common twi sensor instance.
//TWI 공통 센서 인스턴스 이름, TWI Manager 인스턴스 포인터, 통신에 사용될 버퍼의 크기
NRF_TWI_SENSOR_DEF(twi_ssd1306, &m_nrf_twi_mngr, MAX_PENDING_TRANSACTIONS);
TWI Sensor module 라이브러리 사용은 TWI transaction manager 라이브러리 사용을 전제로 함
MAX_PENDING_TRANSACTIONS은 트랜잭션 매니저 큐에 최대 보류 가능한 트랜잭션 개수
NRF_TWI_SENSOR_DEF 에서 MAX_PENDING_TRANSACTIONS 은 TWI manager 큐 크기보다 작거나 같아야 함
데이터 송수신을 실행할 경우 트랜잭션 매니저 큐에 실행 순서대로 스케줄링 된 뒤 통신이 이루어진다
통신에 사용할 핀, 속도, 인터럽트 우선 순위 등을 설정한 뒤 이 환경 설정을 기반으로 TWI 트랜잭션 매니저 인스턴스 초기화
- SSD1306 Command 입력 함수
void ssd1306_write_cmd(uint8_t ssd1306_cmd)
{
//센서 인스턴스 포인터, 슬레이브 장치 주소, 레지스터 주소(슬레이브 내), 전송할 데이터 포인터, 전송할 바이트 크기
nrf_twi_sensor_reg_write(&twi_ssd1306, SSD1306_ADDR, ssd1306_cmd_select, &ssd1306_cmd, 1);
}
TWI 트랜잭션 매니저 라이브러리 내에도 데이터 전송 함수가 존재하지만 슬레이브 장치내 특정 레지스터 주소에 접근해서 데이터 송수신이 가능한 함수는 TWI 센서 모듈 라이브러리에만 존재한다
(SSD1306 사용의 경우, TWI sensor 라이브러리 전송 함수의 레지스터 주소 부분을 이용해 사용자가 전송할 데이터 버퍼가 명령어인지 아니면 디스플레이 데이터인지를 결정하는데 사용)
예) 명령어 0xA8을 전송하는 경우,
슬레이브 장치 주소, 컨트롤 바이트(커맨드 설정), 0xA8 (커맨드)
- SSD1306 초기화 함수
static void ssd1306_init(void)
{
ssd1306_W_Command(0xA8); //Set Mux Ratio
ssd1306_W_Command(0x3F); //64MUX
ssd1306_W_Command(0xD3); //Set Display Offset
ssd1306_W_Command(0x00); //COM0
ssd1306_W_Command(0x40); //Set Display Start Line
ssd1306_W_Command(0xA1); //Set Segment re-map, Default 0xA0
//column address 127 is mapped to SEG0 (좌우 반전)
ssd1306_W_Command(0xC8); //Set COM Output Scan Direction, default 0xC0
//remapped mode. Scan from COM[N-1] to COM0 (상하 반전)
ssd1306_W_Command(0xDA); //Set COM Pins hardware configuration
ssd1306_W_Command(0x12);
ssd1306_W_Command(0x20); //Set Memory Addressing Mode
ssd1306_W_Command(0x02); //Page Addressing Mode
ssd1306_W_Command(0x81); //Set Contrast Control
ssd1306_W_Command(0x7F); //1~256
ssd1306_W_Command(0xA4); //Disable Entire Display On
ssd1306_W_Command(0xA6); //Set Normal Display
ssd1306_W_Command(0xD5); //Set Osc Frequency
ssd1306_W_Command(0x80);
ssd1306_W_Command(0x8D); //Enable charge pump regulator
ssd1306_W_Command(0x14);
ssd1306_W_Command(0xAF); //Display ON
}
데이터 시트에 나와있는 초기화 예를 기반으로 작성
페이지 어드레싱 모드 사용
사용 모듈의 경우, 초기화 코드를 그대로 사용하면 노란색 영역이 하단에 위치 (Page 6,7)
노란색 영역을 상단으로 사용하기 위해 0xC8 명령어를 사용해 COM 출력 스캔 방향을 COM63 to COM0 으로 바꿔 상하 반전을 시키고 0xA1 명령어를 통해 127 열을 SEG0 으로 리맵핑 하여 좌우를 반전 시켜줌
Set COM Pins hardware configuration의 경우, COM0~COM63이 순차적으로 화면 최상단에서 최하단까지 이어지는 Sequential 핀 배열과 COM0~COM31, COM32~COM63 이 교차되어 나열되는 (COM0, COM31, COM2... / COM31, COM0, COM32...) Alternative 핀 배열의 두 방법이 있다
Sequential 배열을 사용하기 위해 데이터 시트를 참고해 0xDA+0x02 명령어를 사용했지만 실제 결과는 Alternative 배열처럼 COM0~COM31/COM32~COM63이 서로 교차되어 표시되는 결과를 얻음
0xDA+0x12(Alternative COM 핀 배열) 명령어를 사용한 결과, COM0~COM63 까지 화면에 순차적으로 표시됨
- SSD1306 데이터 전송 함수
static void ssd1306_write_data(uint8_t* data_buffer, int buf_length)
{
//센서 인스턴스 포인터, 센서 주소, 레지스터 주소, 전송할 데이터 버퍼 주소, 버퍼 길이
nrf_twi_sensor_reg_write(&twi_ssd1306,SSD1306_ADDR,ssd1306_data_select,&data_buffer[0],buf_length);
}
디스플레이에 표시될 데이터를 전송하는 함수 (GDDRAM에 저장될 데이터)
ssd1306_data_select의 값은 0x40 으로 센서에 전송되는 첫번째 바이트이며 뒤이어 전송될 데이터 버퍼가 디스플레이 표현에 사용될 데이터임을 나타낸다
전송 데이터 버퍼는 내부 버퍼로 복사된다 (nRF52 내)
버퍼 길이의 경우, nrf_twi_sensor.h 내 NRF_TWI_SENSOR_SEND_BUF_SIZE 의 값에 -1된 값이 전송 가능한 최대 길이가 된다. 따라서 전송할 버퍼의 길이는 NRF_TWI_SENSOR_SEND_BUF_SIZE 값보다 작아야 한다
- SSD1306 디스플레이 클리어 함수
static void ssd1306_clear(void)
{
static uint8_t clear_buffer[128]={0}; //GDDRAM에 전송할 데이터 버퍼
//데이터 입력이 시작될 열 주소를 0번째 열로 설정
ssd1306_write_cmd(0x00);
ssd1306_write_cmd(0x10);
for(int i=0;i<8;i++)
{
ssd1306_write_cmd(0xB0+i); //데이터를 입력할 페이지 설정
ssd1306_write_data(clear_buffer,sizeof(clear_buffer)/sizeof(uint8_t)); //데이터 버퍼 전송
}
}
디스플레이를 빈 화면으로 초기화하는 함수
0x00, 0x10 명령어를 먼저 전송해 시작 열을 0으로 설정
FOR문 - 0xB0 명령어를 입력해 시작 페이지를 0번째 페이지로 설정
0x00 값을 갖는 128 개의 데이버 버퍼를 데이터 전송 함수를 통해 SSD1306에 전송
전송 완료 후, 열의 위치는 0번째 열이 된다
(열에 데이터를 입력하고 나면 열 주소가 자동으로 1 증가되는데 마지막 127열의 경우에는 데이터를 입력하고 난 뒤에 첫번째 열로 주소가 변경됨)
7번째 페이지까지 반복해 GDDRAM에 저장된 디스플레이 데이터를 전부 0으로 설정해 화면을 비움
- SSD1306 화면 좌표 설정 함수
static void ssd1306_Set_Coord(uint8_t page, uint8_t col)
{
uint8_t col_low=0x0F,col_high=0x1F;
col_low=(col&0x0F); //열 주소 하위 4비트 계산
col_high=0x10|((col>>4)&0x0F); //열 주소 상위 4비트 계산
ssd1306_write_cmd(0xB0+page); //페이지 주소 전송
ssd1306_write_cmd(col_low); //열 주소 하위 4비트 전송
ssd1306_write_cmd(col_high); //열 주소 상위 4비트 전송
}
디스플레이 데이터를 쓰기 시작할 위치를 지정하는 함수
Page Addressing Mode의 경우 Horizontal, Vertical 모드와는 달리 페이지 및 열의 마지막 입력이 필요치 않으므로 시작 지점만을 입력한다
페이지 시작 주소 설정은 0xB0 + 원하는 페이지의 값(0~7)을 더해 전송하면 된다
열 시작 주소는 전달받은 열을 상위 4bit, 하위 4bit로 나누어 하위 4bit는 0x0F, 상위 4bit는 LSB 방향으로 4비트 시프트 한 뒤 0x1F와 AND 연산한 결과값을 전송
ex) 100번째 열을 시작 주소로 설정할 때 100 = 0x64
하위 4비트 : 0x64를 0x0F와 AND 연산해 하위 4비트 주소를 만듦 (0x64 & 0x0F = 0x04)
상위 4비트 : 0x64를 LSB 방향으로 4비트 시프트 한 뒤, 0x0F와 AND 연산해 4비트 주소값을 구하고 이 값에 0x10을 더해 상위 4비트 주소를 만듦
//문자와 입력 주소를 전달받아 디스플레이에 표현하는 함수
static void ssd1306_W_Char(uint8_t character_Code, uint8_t page, uint16_t column)
{
uint8_t char_Buffer[font_width*2]={0};
for(uint8_t i=0;i<font_width*2;i++)
{
char_Buffer[i]=ssd1306_Fonts[(character_Code-32)*(font_width*2)+i];
}
for(uint8_t i=0;i<2;i++)
{
ssd1306_Set_Coord(page+i,column);
ssd1306_write_data(&char_Buffer[i*font_width],font_width);
}
}
변환된 폰트의 너비*2만큼의 원소 개수를 갖는 배열 선언 (*2는 글자를 상/하 페이지로 나누어 저장하기 위함)
입력된 문자를 int 변수로 받아 ASCII 코드값을 기반으로 저장한 폰트 배열에서 매칭되는 문자를 찾는다
폰트 배열의 경우 아스키 코드 32번 space부터 시작하여 126번 ~ 까지 순서대로 변환, 저장해서 사용했다
space의 아스키 코드값(32)과 폰트 배열 0번의 차인 32가 폰트 배열에서 입력된 문자를 찾는 기준점이 된다
하나의 문자에서 다음 문자로 넘어가는데는 문자 너비*2 만큼의 수가 필요
(전달된 문자의 아스키 코드값-32)*(폰트 너비*2)를 하면 문자와 매칭되는 폰트 배열의 시작점이 나온다
해당 문자가 저장된 폰트 배열 시작점에서부터 순서대로 앞서 생성한 char_Buffer 배열에 폰트 데이터를 저장한다
페이지 및 열 포인터 시작 주소를 지정하고 우선 폰트 너비만큼의 데이터를 전송해 폰트의 상단 부분을 표시
페이지 주소 1 증가 및 열 시작 주소를 재지정한 뒤 남은 배열을 전송해 폰트 하단 부분을 완성
왼쪽 : 폰트 상단 부분 (0페이지), 오른쪽 : 폰트 상단 (0 페이지) + 하단 (1 페이지)
- SSD1306 문자열 전송 함수
//문자열과 입력 주소를 전달받아 디스플레이에 표현하는 함수
static void ssd1306_W_String(char *str, uint8_t page, uint8_t col)
{
while(*str)
{
//문자가 입력될 열 주소에 폰트 너비를 더한 값이 열의 최대 값인 127을 넘는 경우
//제대로 된 문자 표현이 불가능하므로 다음 페이지로 넘기거나 or 마지막 페이지일 경우, 전송 중단
if((127<col+font_width))
{
if(page==6)
{
break; //마지막 페이지일 경우, 전송 중단
}
page+=2; //다음 페이지에 이어서 문자 입력
col=0; //첫번째 열부터 문자 입력 시작
}
ssd1306_W_Char(*str,page,col); //문자 전송 함수에 문자 및 문자 입력 주소 전달
col+=font_width; //폰트 너비만큼 열 증가
str++; //문자열 주소 +1 (다음 문자로)
}
}
NULL 값이 나올 때까지 전달받은 문자열 주소 1씩 증가시키며 while 문 반복
문자 전송 함수를 사용해 입력 주소에 첫번째 문자부터 순차적으로 전송
문자 입력 위치에 문자열을 입력할 공간이 부족하다면 다음 페이지로 넘어가 첫번째 열부터 문자 입력 시작
마지막 페이지일 경우, 더 이상 문자를 입력할 공간이 없다면 전송 중단
- 전체 코드 및 간단한 반복 구동 예시 (twi_master_using_nrf_twi_mngr 예제 프로젝트 기반)
/**
* Copyright (c) 2015 - 2019, Nordic Semiconductor ASA
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form, except as embedded into a Nordic
* Semiconductor ASA integrated circuit in a product or a software update for
* such product, must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* 4. This software, with or without modification, must only be used with a
* Nordic Semiconductor ASA integrated circuit.
*
* 5. Any software provided in binary form under this license must not be reverse
* engineered, decompiled, modified and/or disassembled.
*
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/** @file
* @defgroup nrf_twi_master_example main.c
* @{
* @ingroup nrf_twi_example
* @brief TWI Example Application main file.
*
* This file contains the source code for a sample application using TWI.
*/
#include "boards.h"
#include "app_util_platform.h"
#include "nrf_drv_clock.h"
#include "bsp.h"
#include "app_error.h"
#include "nrf_twi_mngr.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "nrf_twi_sensor.h"
#include "fonts.h"
#include "nrf_delay.h"
#define TWI_INSTANCE_ID 0
#define MAX_PENDING_TRANSACTIONS 20
#define SSD1306_ADDR 0x3C
#define ssd1306_data_select 0x40
#define ssd1306_cmd_select 0x00
#define font_width 12
static uint8_t ssd1306_w_buffer[2]={0};
static uint8_t ssd1306_display_buf[128]={0};
//Macro that simplifies defining a TWI transaction manager instance.
NRF_TWI_MNGR_DEF(m_nrf_twi_mngr, MAX_PENDING_TRANSACTIONS, TWI_INSTANCE_ID);
//Macro creating common twi sensor instance.
NRF_TWI_SENSOR_DEF(twi_ssd1306,&m_nrf_twi_mngr,MAX_PENDING_TRANSACTIONS);
void log_init(void)
{
ret_code_t err_code;
err_code = NRF_LOG_INIT(NULL);
APP_ERROR_CHECK(err_code);
NRF_LOG_DEFAULT_BACKENDS_INIT();
}
static void twi_config(void)
{
uint32_t err_code;
nrf_drv_twi_config_t const config={
.scl=27,
.sda=26,
.frequency=NRF_DRV_TWI_FREQ_400K,
.interrupt_priority=APP_IRQ_PRIORITY_MID
};
err_code=nrf_twi_mngr_init(&m_nrf_twi_mngr,&config);
APP_ERROR_CHECK(err_code);
}
void ssd1306_write_cmd(uint8_t ssd1306_cmd)
{
nrf_twi_sensor_reg_write(&twi_ssd1306,SSD1306_ADDR,ssd1306_cmd_select,&ssd1306_cmd,1);
}
static void ssd1306_init(void)
{
ssd1306_write_cmd(0xA8);
ssd1306_write_cmd(0x3F);
ssd1306_write_cmd(0xD3);
ssd1306_write_cmd(0x00);
ssd1306_write_cmd(0x40);
ssd1306_write_cmd(0xA1);
ssd1306_write_cmd(0xC8);
ssd1306_write_cmd(0xDA);
ssd1306_write_cmd(0x12);
ssd1306_write_cmd(0x20);
ssd1306_write_cmd(0x02);
ssd1306_write_cmd(0x81);
ssd1306_write_cmd(0x7F);
ssd1306_write_cmd(0xA4);
ssd1306_write_cmd(0xA6);
ssd1306_write_cmd(0xD5);
ssd1306_write_cmd(0x80);
ssd1306_write_cmd(0x8D);
ssd1306_write_cmd(0x14);
ssd1306_write_cmd(0xAF);
}
void ssd1306_write_data(uint8_t* data_buffer, int buf_length)
{
nrf_twi_sensor_reg_write(&twi_ssd1306,SSD1306_ADDR,ssd1306_data_select,&data_buffer[0],buf_length);
}
void ssd1306_clear(void)
{
static uint8_t clear_buffer[128]={0};
ssd1306_write_cmd(0x00);
ssd1306_write_cmd(0x10);
for(int i=0;i<8;i++)
{
ssd1306_write_cmd(0xB0+i);
ssd1306_write_data(clear_buffer,sizeof(clear_buffer)/sizeof(uint8_t));
}
}
static void ssd1306_fill(void)
{
static uint8_t fill_buffer[128];
for(int i=0;i<128;i++)
{
fill_buffer[i]=0xff;
}
ssd1306_write_cmd(0x00);
ssd1306_write_cmd(0x10);
for(int i=0;i<8;i++)
{
ssd1306_write_cmd(0xB0+i);
ssd1306_write_data(fill_buffer,sizeof(fill_buffer)/sizeof(uint8_t));
}
}
static void ssd1306_Set_Coord(uint8_t page, uint8_t col)
{
uint8_t col_low=0x0F,col_high=0x1F;
col_low=(col&0x0F);
col_high=0x10|((col>>4)&0x0F);
ssd1306_write_cmd(0xB0+page);
ssd1306_write_cmd(col_low);
ssd1306_write_cmd(col_high);
}
static void ssd1306_W_Char(uint8_t character_Code, uint8_t page, uint16_t column)
{
uint8_t char_Buffer[font_width*2]={0};
for(uint8_t i=0;i<font_width*2;i++)
{
char_Buffer[i]=ssd1306_Fonts[(character_Code-32)*(font_width*2)+i];
}
for(uint8_t i=0;i<2;i++)
{
ssd1306_Set_Coord(page+i,column);
ssd1306_write_data(&char_Buffer[i*font_width],font_width);
}
}
static void ssd1306_W_String(char *str, uint8_t page, uint8_t col)
{
while(*str)
{
if((127<col+font_width))
{
if(page==6)
{
break;
}
page+=2;
col=0;
}
ssd1306_W_Char(*str,page,col);
col+=font_width;
str++;
}
}
int main(void)
{
ret_code_t err_code;
log_init();
NRF_LOG_RAW_INFO("\r\nTWI master example started. \r\n");
NRF_LOG_FLUSH();
twi_config();
err_code=nrf_twi_sensor_init(&twi_ssd1306);
APP_ERROR_CHECK(err_code);
ssd1306_init();
char number_str[48];
sprintf(number_str,"0123456789!@#$%^&*()0123456789!@#$%^&*()012345",sizeof(number_str));
while (true)
{
nrf_delay_ms(2000);
ssd1306_clear();
nrf_delay_ms(2000);
ssd1306_W_String("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz{|}~",0,0);
nrf_delay_ms(2000);
ssd1306_W_String(number_str,0,0);
nrf_delay_ms(2000);
ssd1306_fill();
NRF_LOG_FLUSH();
}
}
/** @} */
SSD1306 초기화
48개의 배열을 갖는 char 변수 선언 및 sprintf 함수를 사용해 숫자, 특수문자를 입력 (폰트 너비 12, 문자 4줄 입력)
디스플레이 빈 화면으로 초기화
문자열 입력 (첫번째 페이지, 0번째 열부터 마지막 페이지까지 순서대로 표현 가능한 부분까지만 입력)
앞서 선언 및 문자열을 입력한 char 변수를 SSD1306에 전송 (동일하게 첫 페이지, 0번째 열부터 마지막 페이지까지 표현 가능한 부분만 입력)
L, R 데이터가 번갈아가며 전송된다 (그래프의 경우엔 SWIDTH=8 Bit로 L, R 각각은 8비트 데이터를 갖는다)
(SK6812에 전송할 신호 설정은 위 그래프 설정에서 SWIDTH만 16 Bit로 바꾼 상태)
위의 설정(그래프 설정에서 SWIDTH만 16비트로 변경)에서 32 비트 신호를 전송하는 경우 15~0 비트가 LEFT, 31~16 비트가 RIGHT 채널에 해당한다
예를 들어, Red=97을 설정하는 경우에 0110 0001 의 데이터가 필요하고 이 데이터는 0x8CC8 888C 로 구성된다
그리고 이 데이터를 888C 8CC8 순서로 전송해야 제대로 된 밝기 단계가 설정된다
(만약 순서를 바꾸지 않고 전송한다면 R=22 로 설정된다)
- SK6812 내에서 데이터 처리
SK6812 LED에서 데이터를 받아들이는 방법
그래프에서처럼 3개의 SK6812 LED에 데이터를 전송하는 경우, 첫 32개의 데이터는 SDOUT이 연결된 첫번째 LED에 그 다음 32개의 데이터는 두번째 LED, 마지막 32개 데이터는 세번째 LED에 전송된다
(LED에 전송된 데이터의 MSB부터 32개의 데이터(128Bit)만 남기고 나머지 부분만 다음 LED에 전송)
때문에 특정 위치의 LED 색상을 바꾸기 위해 필요한 만큼의 데이터를 전송하는 것은 불가능하다
SK6812에 LED 데이터를 전송한 후, 다음 데이터를 전송하기 위해선 80us 시간 이상의 리셋 시간이 필요
[코드]
- 전역변수 및 정의
#define sk6812_led_num 1 //SK6812 LED 갯수 설정
#define sk6812_rst_buffer 8 //리셋, 32bit*8= 256bit = 0.3125us*256 = 80us
#define sk6812_buf_len sk6812_led_num*4+8 //리셋을 포함한 전송할 LED 데이터 총 길이(32비트 기준)
/*
하나의 색을 표현하는데 32비트 데이터가 필요하므로 unsigned 32bit integer 배열 선언
[0][0]=Green, [0][1]=Red, [0][2]=Blue, [0][3]=White 의 색상 정보를 저장
이중배열이지만 첫번째 행(sk6812_buffer[0][x])만 사용
*/
static uint32_t sk6812_buffer[2][sk6812_buf_len]={0};
static bool i2s_running=false; //데이터 중복 전송을 피하는데 사용
- 구조체
/*
LED 색상 정보를 저장하고 버퍼에 반영하는데 사용
*/
typedef struct sk6812_rgbw{
uint8_t red;
uint8_t green;
uint8_t blue;
uint8_t white;
}sk6812_rgbw_struct;
- I2S 데이터 핸들러
/*
I2S 초기화와 함께 설정된 데이터 핸들러는 전송 직후 및 전송 완료 후 호출된다
*/
static void i2s_data_handler(nrf_drv_i2s_buffers_t const * p_released,
uint32_t status)
{
static uint8_t transfer_chk=0;
/*
p_released - 이전에 드라이버에 전달된 버퍼에 대한 포인터
전송이 처음 실행되어 호출됐을 땐, 전송된 데이터가 없기 때문에 p_released->p_tx_buffer=0이다
전송 이후엔 p_released->p_tx_buffer엔 마지막으로 전송된 데이터 버퍼가 존재
*/
if(p_released->p_tx_buffer!=0) //전송이 이뤄진 뒤엔 p_tx_buffer엔 데이터가 존재하므로 실행됨
{
transfer_chk++; //데이터가 전송됐다면 값 증가해 데이터 전송이 일어났음을 표시
}
if(transfer_chk!=0) //데이터 전송이 일어난 이후
{
nrf_drv_i2s_stop(); //I2S 전송 중단
i2s_running=false; //I2S 전송 중이 아님을 표시
transfer_chk=0; //데이터 전송 여부
}
}
- I2S 데이터 전송 함수
/*
I2S를 통한 데이터 전송에 사용되는 함수. 데이터는 DMA를 통해 전송된다
*/
void sk6812_send_buffer()
{
uint32_t err_code = NRF_SUCCESS;
//I2S 구조체 변수 선언 및 전송 버퍼에 전송할 데이터가 있는 SK6812 버퍼 주소 입력
nrf_drv_i2s_buffers_t const i2s_buffers = {
.p_tx_buffer=sk6812_buffer[0],
};
//I2S 통신이 사용 중이 아니라면 전송 실행
if(i2s_running==false)
{
err_code = nrf_drv_i2s_start(&i2s_buffers, sk6812_buf_len, 0);
//sk6812_buffer[0]부터 sk6812_buf_len 길이만큼 전송 (32bit 기준)
APP_ERROR_CHECK(err_code);
i2s_running==true; //중복 전송이 일어나지 않게 하기 위해 전송 중임을 나타내는 true로 변경
}
}
- SK6812 색상 설정 함수
/*
전달받은 색상 구조체 변수와 LED 위치(index)를 기반으로
버퍼의 원하는 부분에 LED 색상 데이터를 설정함
*/
void sk6812_set_color(sk6812_rgbw_struct* set_color, uint8_t index)
{
uint32_t temp_g=0, temp_r=0, temp_b=0, temp_w=0;
//전달받은 구조체 색상값을 SK6812에서 인식하는 데이터로 변환 후 저장하는데 사용할 32비트 변수
/*
8비트 색상값의 MSB부터 0비트 자리로 비트 시프트 한 뒤에 0x1을 AND 연산
나온 값이 1이면 0xC, 0이면 0x8을 32비트 temp_ 변수의 MSB부터 차례대로 입력
*/
for(uint8_t i=0;i<8;i++) //Green
{
if((set_color->green>>(7-i))&0x1==1)
{
temp_g|=0xC<<(7-i)*4;
}
else
{
temp_g|=0x8<<(7-i)*4;
}
if((set_color->red>>(7-i))&0x1==1) //Red
{
temp_r|=0xC<<(7-i)*4;
}
else
{
temp_r|=0x8<<(7-i)*4;
}
if((set_color->blue>>(7-i))&0x1==1) //Blue
{
temp_b|=0xC<<(7-i)*4;
}
else
{
temp_b|=0x8<<(7-i)*4;
}
if((set_color->white>>(7-i))&0x1==1) //White
{
temp_w|=0xC<<(7-i)*4;
}
else
{
temp_w|=0x8<<(7-i)*4;
}
}
/*
I2S 통신은 L, R이 번갈아가면서 전송되고 L, R 각 크기는 SWIDTH 설정에 의해 결정됨
SWIDTH=16 Bit 로 설정해 사용하므로 16비트 간격으로 L, R이 나뉘어 전송된다
LEFT는 15~0비트, RIGHT는 31~16비트를 차지하는데 LEFT 먼저 전송이 시작되므로
제대로 된 전송을 위해선 LEFT<->RIGHT 비트 위치 전환을 해야 한다 (MSB->LSB 순으로 전송)
*/
sk6812_buffer[0][index*4]=((temp_g&0x0000FFFF)<<16)|((temp_g&0xFFFF0000)>>16);
sk6812_buffer[0][index*4+1]=((temp_r&0x0000FFFF)<<16)|((temp_r&0xFFFF0000)>>16);
sk6812_buffer[0][index*4+2]=((temp_b&0x0000FFFF)<<16)|((temp_b&0xFFFF0000)>>16);
sk6812_buffer[0][index*4+3]=((temp_w&0x0000FFFF)<<16)|((temp_w&0xFFFF0000)>>16);
sk6812_send_buffer(); //SK6812 버퍼 전송 함수 호출
nrf_delay_ms(1);
}
- 메인
/*
SDK Example 폴더 내 I2S 프로젝트 기반
*/
int main(void)
{
uint32_t err_code = NRF_SUCCESS;
APP_ERROR_CHECK(err_code);
//I2S 설정
nrf_drv_i2s_config_t config = NRF_DRV_I2S_DEFAULT_CONFIG; //I2S 환경설정 구조체 변수 선언
config.sdout_pin = I2S_SDOUT_PIN; //SDOUT PIN 설정 (예제 기준 P0.27)
config.mck_setup = NRF_I2S_MCK_32MDIV10; (MasterClock = 32Mhz / 10)
config.ratio = NRF_I2S_RATIO_32X;
config.sample_width=NRF_I2S_SWIDTH_16BIT; (L, R 각 채널이 갖는 데이터 비트 크기)
config.channels = NRF_I2S_CHANNELS_STEREO; (스테레오 설정)
//I2S 환경설정 변수와 데이터 핸들러를 기반으로 I2S 통신 초기화
err_code = nrf_drv_i2s_init(&config, i2s_data_handler);
APP_ERROR_CHECK(err_code);
while(true)
{
}
}
- 단순 사용 예시) 8개의 LED를 R->G->B->W->R 순서로 색상 변환 (각 색상의 밝기는 128 단계로 설정)
#define sk6812_led_num 8
int main(void)
{
uint32_t err_code = NRF_SUCCESS;
APP_ERROR_CHECK(err_code);
//I2S 설정
nrf_drv_i2s_config_t config = NRF_DRV_I2S_DEFAULT_CONFIG; //I2S 환경설정 구조체 변수 선언
config.sdout_pin = I2S_SDOUT_PIN; //SDOUT PIN 설정 (예제 기준 P0.27)
config.mck_setup = NRF_I2S_MCK_32MDIV10; (MasterClock = 32Mhz / 10)
config.ratio = NRF_I2S_RATIO_32X;
config.sample_width=NRF_I2S_SWIDTH_16BIT; (L, R 각 채널이 갖는 데이터 비트 크기)
config.channels = NRF_I2S_CHANNELS_STEREO; (스테레오 설정)
//I2S 환경설정 변수와 데이터 핸들러를 기반으로 I2S 통신 초기화
err_code = nrf_drv_i2s_init(&config, i2s_data_handler);
APP_ERROR_CHECK(err_code);
//SK6812 색상 설정에 사용할 색상 구조체 변수 선언
sk6812_rgbw_struct temp_rgbw;
//모든 색상에 대해 0의 값을 설정
temp_rgbw.red=0;
temp_rgbw.green=0;
temp_rgbw.blue=0;
temp_rgbw.white=0;
//모든 LED 버퍼에 0의 색상값 입력 후 전송, i=LED 순서(SDOUT이 연결된 LED가 시작점)
for(uint8_t i=0;i<sk6812_led_num;i++)
{
sk6812_set_color(&temp_rgbw,i);
}
int PAUSE_TIME=1000;
/*
모든 LED에 동일한 색상을 지정한 뒤 전송하고 PAUSE_TIME 시간동안 정지된 후
다음 색상으로 변환 (빨강 -> 초록 -> 파랑 -> 흰색 순으로 무한 루프)
*/
while(true)
{
temp_rgbw.red=128;
temp_rgbw.green=0;
temp_rgbw.blue=0;
temp_rgbw.white=0;
for(uint8_t i=0;i<sk6812_led_num;i++)
{
sk6812_set_color(&temp_rgbw,i);
}
nrf_delay_ms(PAUSE_TIME);
temp_rgbw.red=0;
temp_rgbw.green=128;
temp_rgbw.blue=0;
temp_rgbw.white=0;
for(uint8_t i=0;i<sk6812_led_num;i++)
{
sk6812_set_color(&temp_rgbw,i);
}
nrf_delay_ms(PAUSE_TIME);
temp_rgbw.red=0;
temp_rgbw.green=0;
temp_rgbw.blue=128;
temp_rgbw.white=0;
for(uint8_t i=0;i<sk6812_led_num;i++)
{
sk6812_set_color(&temp_rgbw,i);
}
nrf_delay_ms(PAUSE_TIME);
temp_rgbw.red=0;
temp_rgbw.green=0;
temp_rgbw.blue=0;
temp_rgbw.white=128;
for(uint8_t i=0;i<sk6812_led_num;i++)
{
sk6812_set_color(&temp_rgbw,i);
}
nrf_delay_ms(PAUSE_TIME);
}
}
FOR 문 하나에 해당하는 데이터 전송 신호 (8번의 LED 전체 색상 데이터 전송)8개의 LED 색상 데이터에 해당하는 데이터 신호 (32*4*8=1024 Bit)LED 8개의 색상 데이터 전송 중 첫번째 LED에 Blue=128가 입력
I2S 전송 함수(sk6812_send_buffer())를 색상 설정 함수(sk6812_set_color) 내부에 넣었기 때문에 하나의 FOR문이 실행될 때 LED 갯수인 8개만큼의 전체 버퍼 전송이 이루어진다
단순히 사용의 편의를 위해 I2S 전송 함수를 색상 설정 함수 내부에 넣은 것이므로 전송 함수를 색상 설정 함수에서 제외하고 LED 색상 버퍼의 데이터를 전부 바꾼 뒤에 따로 전송 함수를 호출하는 식으로 사용해도 된다
/*
사용 LED 4개, sk6812_set_color() 함수 내의 I2S 전송 함수 제외한 뒤 따로 사용 예
SK6812에 전송할 데이터 버퍼의 색상 정보 전체를 원하는 값으로 바꾼 후에 I2S 전송 함수 호출
첫번째 LED : Red 128, 두번째 LED : Green 128, 세번째 LED : Blue 128, 네번째 LED : White 128 의 값을 가짐
*/
temp_rgbw.red=128;
temp_rgbw.green=0;
temp_rgbw.blue=0;
temp_rgbw.white=0;
sk6812_set_color(&temp_rgbw,0); //첫번째 LED 색상 버퍼 변경
temp_rgbw.red=0;
temp_rgbw.green=128;
temp_rgbw.blue=0;
temp_rgbw.white=0;
sk6812_set_color(&temp_rgbw,1); //두번째 LED 색상 버퍼 변경
temp_rgbw.red=0;
temp_rgbw.green=0;
temp_rgbw.blue=128;
temp_rgbw.white=0;
sk6812_set_color(&temp_rgbw,2); //세번째 LED 색상 버퍼 변경
temp_rgbw.red=0;
temp_rgbw.green=0;
temp_rgbw.blue=0;
temp_rgbw.white=128;
sk6812_set_color(&temp_rgbw,3); //네번째 LED 색상 버퍼 변경
sk6812_send_buffer();
