EMPA Workshop

EMPA Workshop

EMPA Workshop’a hoşgeldiniz, bu yazıda SenseShield üzerinde bulunan sensörleri ve entegreleri nasıl kullanılacağı anlatılacaktır. Lütfen önceki yazımızdaki ( EMPA Workshop’a gelmeden önce yapılıcaklar) talimatlarını eksiksiz yaptığınızdan emin olunuz.

Proje Dosyasının İçe Aktarılması ve Gerekli Kütüphanelerin Yüklenmesi

SenseShield üzerinde bulunan sensörler başlatılmak için kendilerine özel yazılmış kütüphanelere ihtiyaç duymaktadır. Bu kütüphaneler proje içerisine eklendikten sonra çeşitli komutlar yardımıyla sensör başlatma ve okuma işlemleri gerçekleştirilecektir.

Öncelikle bu linkten SenseShield için gerekli olan klasörleri indiriniz.

Proje Dosyasının İçe Aktarılması

Öncelikle indirdiğiniz klasörün içerisinde bulunan First Template isimli klasörün içerisinde bulunan WS_DEMO klasörünün içerisine girin. Burada bulunan .project uzantılı dosyaya çift tıklayarak projeyi STM32CubeIDE içerisine aktarın. Örnek bir klasör görünümü aşağıda verilmiştir.

Bu işlemin ardından sizi STM32CubeIDE platformuna yönlendirecek ve projeyi IDE içerisine aktarmış olacaktır. Bunun için örnek görüntü aşağıda verilmiştir.

Ardından WS_DEMO.ioc dosyasına çift tıklayarak proje konfigürasyon sayfasına ilerleyin. Açılan sayfada sol üstte bulunan “Device Configuration Tool Code Generation” butonuna tıklayarak proje dosyalarını güncelleyin.

Kütüphane Dosyalarının Projeye Eklenmesi

Daha önceden indirmiş olduğunuz First Template klasörü içerisinde bulunan Libraries klasörü içerisine girin. İndirilmiş olan kütüphane dosyalarını proje dosyası içerisinde Core>Src ve Core>Inc klasörleri içerisine atıyoruz. İşlem sonucunda proje dosyası aşağıdaki şekilde olacaktır.

Bu aşamadan sonra main.c dosyasının içerisine girerek işlemlerimizi yürüteceğiz.

Öncelikle Sensor library include section start ve Sensor library include section end yorum satırlarının arasına aşağıdaki kod satırını ekleyin. Bu satır sensörler için gerekli olan komutları içeren kütüphanenin proje içerisine aktarılmasını sağlar.

#include "EMPA_Sensor.h"

Ardından sensörler için kullanılacak değişkenleri Sensor private variables section start ve Sensor private variables section end yorum satırlarının arasına yerleştiriyoruz. Bunun için aşağıdaki kod satırları uygun yorum satırları arasına ekleyin.

int32_t sensors[14] = { 0 };
uint32_t tof_result[64] = { 0 };



Bu aşamanın ardından printf komutu ile terminal kontrolünün sağlanması için gerekli fonksiyonun eklenmesi gerekmektedir. Bunun için Uart printf section start ve Uart printf section end yorum satırları arasına aşağıdaki kodu ekleyin.



#ifdef __GNUC__
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif
PUTCHAR_PROTOTYPE {
HAL_UART_Transmit(&huart3, (uint8_t*) &ch, 1, HAL_MAX_DELAY);
return ch;
}



Bu işlemin ardından sensörlerin başlatılması için ayarlanmış olan fonksiyonu yerine ekleyin. Bunun için Sensor init section start ve Sensor init section end yorum satırları arasına aşağıdaki kodu ekleyin.



HAL_GPIO_WritePin(GPIOA, GPIO_PIN_6, DISABLE);
HAL_Delay(2000);
while (EMPA_Sensor_Init() != EMPA_OK)
;



Bütün bu işlemler tamamlandığı takdirde sensörlerin başlatılması aşamasına geçilebilmektedir.



Sensörlerin Başlatılması



Sensörlerin başlatılması işlemine sıcaklık ve nem sensörü olan SHT40 sensörü ile başlıyoruz. Bunun için EMPA_Sensor.c dosyası içerisine girin. Bu dosya içerisinde bulunan SHT4X Start ve SHT4X end yorum satırları arasına aşağıdaki kodu ekleyin.



uint32_t sht4x_serialnumber;



Ardından EMPA_Sensor_Init fonksiyonu içerisinde bulunan SHT4X Initialization Section Start ve SHT4X Initialization Section End yorum satırları arasına aşağıdaki kodu ekleyin. Bu sayede SHT40 sensör içerisindeki seri numara okunabilmektedir.



if (sht4x_serial_number(&sht4x_serialnumber) == 1)
		return EMPA_SHT4X_ERROR;



Hemen ardından VoC sensörü olan SGP40 sensörünün başlatılması işlemine geçiyoruz. Bunun için EMPA_Sensor.c dosyası içerisinde bulunan SGP4X Start ve SGP4X End yorum satırları arasına aşağıdaki kodu ekleyin.



uint8_t sgp4x_serialnumber_size = 3;
uint16_t sgp4x_serialnumber[3];
GasIndexAlgorithmParams sgp4x_params;



Ardından EMPA_Sensor_Init fonksiyonu içerisinde bulunan SGP4X Initialization Section Start ve SGP4X Initialization Section End yorum satırları arasına aşağıdaki kodu ekleyin. Bu aşama ile birlikte SGP40 VoC sensörü ölçüm için hazır olacaktır.



GasIndexAlgorithm_init(&sgp4x_params, GasIndexAlgorithm_ALGORITHM_TYPE_VOC);
if (sgp40_get_serial_number((uint16_t*) &sgp4x_serialnumber,
	sgp4x_serialnumber_size) == 1)
	return EMPA_SGP4X_ERROR;



Bu işlemin de ardından basınç sensörü olan LPS22 sensörünün başlatılma aşamasına geçiyoruz. Bunun için EMPA_Sensor.c dosyası içerisinde bulunan LPS22 Start ve LPS22 End yorum satırları arasına aşağıdaki kodu ekleyin.



LPS22DF_Capabilities_t LPS_Cap;
LPS22DF_IO_t LPS_Ctx;
LPS22DF_Object_t LPS22_obj_o;
uint8_t LPS_id;



Ardından EMPA_Sensor_Init fonksiyonu içerisinde bulunan LPS22 Initialization Section Start ve LPS22 Initialization Section End yorum satırları arasına aşağıdaki kodu ekleyin.



LPS_Ctx.BusType = LPS22DF_I2C_BUS;
LPS_Ctx.Address = LPS22DF_I2C_ADD_H;
LPS_Ctx.Init = BSP_I2C1_Init;
LPS_Ctx.DeInit = BSP_I2C1_DeInit;
LPS_Ctx.ReadReg = BSP_I2C1_ReadReg;
LPS_Ctx.WriteReg = BSP_I2C1_WriteReg;
LPS_Ctx.GetTick = BSP_GetTick;
 
if (LPS22DF_RegisterBusIO(&LPS22_obj_o, &LPS_Ctx) != LPS22DF_OK)
	return EMPA_LPS22_ERROR;
 
if (LPS22DF_ReadID(&LPS22_obj_o, &LPS_id) != LPS22DF_OK)
	return EMPA_LPS22_ERROR;
 
if (LPS_id != LPS22DF_ID)
	return EMPA_LPS22_ERROR;
 
LPS22DF_GetCapabilities(&LPS22_obj_o, &LPS_Cap);
 
if (LPS22DF_Init(&LPS22_obj_o) != LPS22DF_OK)
	return EMPA_LPS22_ERROR;
 
if (LPS22DF_PRESS_Enable(&LPS22_obj_o) != LPS22DF_OK)
	return EMPA_LPS22_ERROR;



Bu işlemin ardından ivme sensörü olan ISM330 sensörünün başlatılma işlemini gerçekleştiriyoruz. Bunun için ISM330 Start ve ISM330 End yorum satırları arasına aşağıdaki kodu ekleyin.



ISM330DHCX_Object_t ism_obj_o;
ISM330DHCX_IO_t ism_ctx;
uint8_t ism_id;
ISM330DHCX_Capabilities_t ism_cap;



Ardından EMPA_Sensor_Init fonksiyonu içerisinde bulunan ISM330 Initialization Section Start ve ISM330 Initialization Section End yorum satırları arasına aşağıdaki kodu ekleyin.



ism_ctx.BusType = ISM330DHCX_I2C_BUS;
ism_ctx.Address = ISM330DHCX_I2C_ADD_H;
ism_ctx.Init = BSP_I2C1_Init;
ism_ctx.DeInit = BSP_I2C1_DeInit;
ism_ctx.ReadReg = BSP_I2C1_ReadReg;
ism_ctx.WriteReg = BSP_I2C1_WriteReg;
ism_ctx.GetTick = BSP_GetTick;
 
if (ISM330DHCX_RegisterBusIO(&ism_obj_o, &ism_ctx) != ISM330DHCX_OK)
	return EMPA_ISM_ERROR;
 
if (ISM330DHCX_ReadID(&ism_obj_o, &ism_id) != ISM330DHCX_OK)
	return EMPA_ISM_ERROR;
 
if (ism_id != ISM330DHCX_ID)
	return EMPA_ISM_ERROR;
 
if (ISM330DHCX_Init(&ism_obj_o) != ISM330DHCX_OK)
	return EMPA_ISM_ERROR;
 
if (ISM330DHCX_ACC_Enable(&ism_obj_o) != ISM330DHCX_OK)
	return EMPA_ISM_ERROR;



Ardından renk algılama sensörü olan AL8844 sensörü için gerekli işlemlere geçiyoruz. Bunun için AL8844 Start ve AL8844 End yorum satırları arasına aşağıdaki kodu ekleyin.



al8844_handle_t al_handle = { .i2c_handle = &hi2c1, .device_address =
AL8844_DEFAULT_I2C_ADDRESS };
uint8_t al_id = 0;



Bunun sonrasında EMPA_Sensor_Init fonksiyonu içerisinde bulunan AL8844 Initialization Section Start ve AL8844 Initialization Section End yorum satırları arasına aşağıdaki kodu ekleyin.



if (al8844_power_on(&al_handle) == 1)
	return EMPA_AL8844_ERROR;
	HAL_Delay(2000);
if (al8844_read_id(&al_handle, &al_id) == 1)
	return EMPA_AL8844_ERROR;
if (al8844_sensor_enable(&al_handle) == 1)
	return EMPA_AL8844_ERROR;



Bu işlemin ardından kızılötesi sensörü olan STHS34PF80 sensörünü başlatmak için gerekli işlemleri yapıyoruz. Bunun için STHS Start ve STHS End yorum satırları arasına aşağıdaki kod satırını ekleyin.



STHS34PF80_IO_t STHS_ctx;
uint8_t STHS_id;
STHS34PF80_Object_t STHSObj;
STHS34PF80_Capabilities_t STHS_cap;



Ardından EMPA_Sensor_Init fonksiyonu içerisinde bulunan STHS Initialization Section Start ve STHS Initialization Section End yorum satırları arasına aşağıdaki kodu ekleyin.



STHS_ctx.Address = STHS34PF80_I2C_ADD;
STHS_ctx.Init = BSP_I2C1_Init;
STHS_ctx.DeInit = BSP_I2C1_DeInit;
STHS_ctx.ReadReg = BSP_I2C1_ReadReg;
STHS_ctx.WriteReg = BSP_I2C1_WriteReg;
STHS_ctx.GetTick = BSP_GetTick;
if (STHS34PF80_RegisterBusIO(&STHSObj, &STHS_ctx) != STHS34PF80_OK)
	return EMPA_STHS_ERROR;
if (STHS34PF80_ReadID(&STHSObj, &STHS_id) != STHS34PF80_OK)
	return EMPA_STHS_ERROR;
if (STHS_id != STHS34PF80_ID)
	return EMPA_STHS_ERROR;
if (STHS34PF80_GetCapabilities(&STHSObj, &STHS_cap) != STHS34PF80_OK)
	return EMPA_STHS_ERROR;
if (STHS34PF80_Init(&STHSObj) != STHS34PF80_OK)
	return EMPA_STHS_ERROR;
if (STHS34PF80_TEMP_Enable(&STHSObj) != STHS34PF80_OK)
	return EMPA_STHS_ERROR;



Son olarak yakınlık sensörü olan VL53L8A1 sensörü için gerekli işlemleri yapıyoruz. Bunun için VL53L8A1 Start ve VL53L8A1 End yorum satırları arasına aşağıdaki kodu ekleyin.



VL53L8CX_IO_t vl_ctx;
uint32_t vl_id;
VL53L8CX_Object_t VL53L8CXObj[RANGING_SENSOR_INSTANCES_NBR];
RANGING_SENSOR_Drv_t *VL53_Drv;
void *VL53_CompObj[RANGING_SENSOR_INSTANCES_NBR];
RANGING_SENSOR_Capabilities_t VL53_Cap;
RANGING_SENSOR_ProfileConfig_t VL53_Profile;
RANGING_SENSOR_Result_t VL53_Result;



Ardından EMPA_Sensor_Init fonksiyonu içerisinde bulunan VL53 Initialization Section Start ve VL53 Initialization Section End yorum satırları arasına aşağıdaki kodu ekleyin.



HAL_GPIO_WritePin(GPIOA, GPIO_PIN_6, ENABLE);
 
vl_ctx.Address = RANGING_SENSOR_VL53L8CX_ADDRESS;
vl_ctx.Init = VL53L8A1_I2C_Init;
vl_ctx.DeInit = VL53L8A1_I2C_DeInit;
vl_ctx.WriteReg = VL53L8A1_I2C_WriteReg;
vl_ctx.ReadReg = VL53L8A1_I2C_ReadReg;
vl_ctx.GetTick = VL53L8A1_GetTick;
 
if (VL53L8CX_RegisterBusIO(&(VL53L8CXObj[VL53L8A1_DEV_CENTER]), &vl_ctx)
		!= 0)
	return EMPA_VL53_ERROR;
 
VL53_Drv = (RANGING_SENSOR_Drv_t*) &VL53L8CX_RANGING_SENSOR_Driver;
 
VL53_CompObj[VL53L8A1_DEV_CENTER] = &(VL53L8CXObj[VL53L8A1_DEV_CENTER]);
 
if (VL53L8CX_ReadID(&(VL53L8CXObj[VL53L8A1_DEV_CENTER]),
		&vl_id) != VL53L8CX_OK)
	return EMPA_VL53_ERROR;
 
if (vl_id != VL53L8CX_ID)
	return EMPA_VL53_ERROR;
 
if (VL53_Drv->Init(VL53_CompObj[VL53L8A1_DEV_CENTER]) != 0)
		return EMPA_VL53_ERROR;
 
	if (VL53_Drv->GetCapabilities(VL53_CompObj[VL53L8A1_DEV_CENTER], &VL53_Cap)
		!= 0)
	return EMPA_VL53_ERROR;
 
VL53_Profile.RangingProfile = RS_PROFILE_8x8_CONTINUOUS;
VL53_Profile.TimingBudget = 10;
VL53_Profile.Frequency = 5;
VL53_Profile.EnableAmbient = 1;
VL53_Profile.EnableSignal = 0;
 
if (VL53_Drv->ConfigProfile(VL53_CompObj[VL53L8A1_DEV_CENTER],
		&VL53_Profile) < 0)
	return EMPA_VL53_ERROR;
 
if (VL53_Drv->Start(VL53_CompObj[VL53L8A1_DEV_CENTER],
RS_MODE_BLOCKING_CONTINUOUS) < 0)
	return EMPA_VL53_ERROR;



Bütün bu işlemlerin ardından sensörlerin tamamı başlatılmıştır. Bu aşamanın ardından sensörlerden nasıl veri alabileceğimizi ve nasıl terminal ekranında gösterebileceğimizi göreceğiz.



Sensörlerden Veri Alınması



Bu aşamada sensörlerden tek tek veri alıp terminal ekranında yazdıracağız. Bunun için EMPA_Sensor.c dosyası içerisine girerek işlemlerimizi gerçekleştireceğiz.



 Öncelikle terminal ekranının sürekli temizlenmesi için aşağıdaki kod satırın Process Start yorum satırının altına ekleyin.



printf("\e[1;1H\e[2J");



Ardından main.c dosyası içerisinde bulunan Sensor process section start ve Sensor process section end yorum satırları arasına aşağıdaki kodu ekleyin.



EMPA_Sensor_Process(sensors, tof_result);
EMPA_Sensor_Print(sensors, tof_result);
HAL_Delay(100);



Bütün okuma işlemlerinde alınan veriler ilk aşamalarda tanımladığımız sensors ve tof_result dizilerine kaydedilecektir. Buraya yazdıktan sonra istediğimiz gibi okuma-yazma işlemi yapabileceğiz.



Öncelikle SHT40 sensöründen veri alarak başlıyoruz. Bunun için EMPA_Sensor_Process fonksiyonu içerisinde bulunan SHT4X Process Start ve SHT4X Process End yorum satırları arasına aşağıdaki kodu ekleyin.



int32_t temperature;
int32_t humidity;
if (sht4x_measure_high_precision(&temperature, &humidity) == 0) {
	EMPA_Sensor_Process_List[0] = temperature;
	EMPA_Sensor_Process_List[1] = humidity;
} else {
	EMPA_Sensor_Process_List[0] = 0;
	EMPA_Sensor_Process_List[1] = 0;
}



Terminal ekranına yazdırma işleminden önce float değerlerin yazdırılabilmesi için proje ayarlarından "Use float with printf from newlib-nano(-u_printf_float) seçeneğini aktif hale getirin. Bunun için Project Explorer sekmesinde bulunan projenize sağ tıkayın ve açılan menüde Properties seçeneğine tıklayın. Ardından açılan pencerede sırasıyla C/C++ Build ve Settings butonlarına tıklayın. Karşınıza çıkan ekranda işaretlemeniz gereken kutucuğu görebilirsiniz. Örnek ekran görüntüsü aşağıda verilmiştir.







Bunun ardından terminal ekranına yazdırma işlemi için EMPA_Sensor_Print fonksiyonu içerisinde bulunan Print Start ve Print End yorumları arasına aşağıdaki kodu ekleyin.



printf("\t Temperature: %0.2f\r\n", EMPA_Sensor_Process_List[0] / 1000.0f);
printf("\t Humidity: %0.2f\r\n", EMPA_Sensor_Process_List[1] / 1000.0f);



Bu işlemin ardından terminal ekranında sıcaklık ve nem değerlerini görebilirsiniz. Örnek bir ölçüm sonucu aşağıda verilmiştir.














Ardından VoC sensörü olan SGP40 sensöründen veri alınması işlemine geçiyoruz. Bunun için EMPA_Sensor_Process fonksiyonu içerisinde bulunan SGP4X Process Start ve SGP4X Process End yorum satırları arasına aşağıdaki kodu ekleyin.



uint16_t compensation_t;
uint16_t compensation_rh;
int32_t voc_raw_value;
int32_t voc_index_value;
uint16_t sraw_voc = 0;
uint16_t sraw_voc_min = 50000;
 
if (sht4x_measure_high_precision_ticks(&compensation_t, &compensation_rh)
		== 0) {
	if (sgp40_measure_raw_signal(compensation_rh, compensation_t, &sraw_voc)
			== 0) {
		if (sraw_voc < sraw_voc_min) {
			sraw_voc_min = sraw_voc;
			sgp4x_params.mSraw_Minimum = GasIndexAlgorithm_VOC_SRAW_MINIMUM;
		}
		voc_raw_value = (int32_t) sraw_voc;
		GasIndexAlgorithm_process(&sgp4x_params, voc_raw_value,
				&voc_index_value);
		EMPA_Sensor_Process_List[2] = sraw_voc;
		EMPA_Sensor_Process_List[3] = voc_index_value;
	} else {
		EMPA_Sensor_Process_List[2] = 0;
		EMPA_Sensor_Process_List[3] = 0;
	}
} else {
	EMPA_Sensor_Process_List[2] = 0;
	EMPA_Sensor_Process_List[3] = 0;
}



Bu işlemin ardından terminal ekranına yazdırma işlemi için EMPA_Sensor_Print fonksiyonu içerisinde bulunan Print Start ve Print End yorumları arasında bulunan kodları silin ve aşağıdaki kodu ekleyin.



printf("\t SRaw VOC: %ld\r\n", EMPA_Sensor_Process_List[2]);
printf("\t VOC Index: %ld\r\n", EMPA_Sensor_Process_List[3]);



Bu işlemin ardından terminal ekranında VoC değerlerini görebilirsiniz. Örnek bir ölçüm sonucu aşağıda verilmiştir.







Ardından basınç sensörü olan LPS22 için gerekli veri alma işlemlerine geçiyoruz. Bunun için EMPA_Sensor_Process fonksiyonu içerisinde bulunan LPS22 Process Start ve LPS22 Process End yorum satırları arasına aşağıdaki kodu ekleyin.



float pressure;
if (LPS22DF_PRESS_GetPressure(&LPS22_obj_o, &pressure) == 0) {
	EMPA_Sensor_Process_List[4] = pressure;
} else {
	EMPA_Sensor_Process_List[4] = 0;
}



Bu işlem ile birlikte terminal ekranına yazdırma işlemi için EMPA_Sensor_Print fonksiyonu içerisinde bulunan Print Start ve Print End yorumları arasında bulunan kodları silin ve aşağıdaki kodu ekleyin.



printf("\t Pressure: %ld \r\n", EMPA_Sensor_Process_List[4]);



Bu işlemin ardından terminal ekranında basınç değerlerini görebilirsiniz. Örnek bir ölçüm sonucu aşağıda verilmiştir.







Ardından ivme sensörü olan ISM330DHCX sensöründen veri alınması işlemine geçiyoruz. Bunun için EMPA_Sensor_Process fonksiyonu içerisinde bulunan ISM330 Process Start ve ISM330 Process End yorum satırları arasına aşağıdaki kodu ekleyin.



ISM330DHCX_Axes_t ism_axes;
 
if (ISM330DHCX_ACC_GetAxes(&ism_obj_o, &ism_axes) == 0) {
	EMPA_Sensor_Process_List[5] = ism_axes.x;
	EMPA_Sensor_Process_List[6] = ism_axes.y;
	EMPA_Sensor_Process_List[7] = ism_axes.z;
} else {
	EMPA_Sensor_Process_List[5] = 0;
	EMPA_Sensor_Process_List[6] = 0;
	EMPA_Sensor_Process_List[7] = 0;
}



Ardından terminal ekranına yazdırma işlemi için EMPA_Sensor_Print fonksiyonu içerisinde bulunan Print Start ve Print End yorumları arasında bulunan kodları silin ve aşağıdaki kodu ekleyin.



printf("\t Axis X: %ld\r\n", EMPA_Sensor_Process_List[5]);
printf("\t Axis Y: %ld\r\n", EMPA_Sensor_Process_List[6]);
printf("\t Axis Z: %ld\r\n", EMPA_Sensor_Process_List[7]);



Bu işlemin ardından terminal ekranında eksen değerlerini görebilirsiniz. Örnek bir ölçüm sonucu aşağıda verilmiştir.







Ardından renk sensörü olan AL8844 sensöründen veri alınması işlemine geçiyoruz. Bunun için EMPA_Sensor_Process fonksiyonu içerisinde bulunan AL8844 Process Start ve AL8844 Process End yorum satırları arasına aşağıdaki kodu ekleyin.



al8844_Data_t al_data;
uint16_t red, green, blue, infrared, cdata;
 
if (al8844_poll_new(&al_handle) == 0) {
	HAL_Delay(500);
	if (al8844_read_data(&al_handle, &al_data) == 0) {
		red = (uint16_t) (al_data.RDATAH << 8) | (uint16_t) al_data.RDATAL;
		EMPA_Sensor_Process_List[8] = red;
		green = (uint16_t) (al_data.GDATAH << 8)
				| (uint16_t) al_data.GDATAL;
		EMPA_Sensor_Process_List[9] = green;
		blue = (uint16_t) (al_data.BDATAH << 8) | (uint16_t) al_data.BDATAL;
		EMPA_Sensor_Process_List[10] = blue;
		infrared = (uint16_t) (al_data.IRDATAH << 8)
				| (uint16_t) al_data.IRDATAL;
		EMPA_Sensor_Process_List[11] = infrared;
		cdata = (uint16_t) (al_data.CDATAH << 8)
				| (uint16_t) al_data.CDATAL;
		EMPA_Sensor_Process_List[12] = cdata;
	} else {
		EMPA_Sensor_Process_List[8] = 0;
		EMPA_Sensor_Process_List[9] = 0;
		EMPA_Sensor_Process_List[10] = 0;
		EMPA_Sensor_Process_List[11] = 0;
		EMPA_Sensor_Process_List[12] = 0;
	}
}



Ardından terminal ekranına yazdırma işlemi için EMPA_Sensor_Print fonksiyonu içerisinde bulunan Print Start ve Print End yorumları arasında bulunan kodları silin ve aşağıdaki kodu ekleyin.



printf("\t Red: %ld\r\n", EMPA_Sensor_Process_List[8]);
printf("\t Green: %ld\r\n", EMPA_Sensor_Process_List[9]);
printf("\t Blue: %ld\r\n", EMPA_Sensor_Process_List[10]);
printf("\t Infrared: %ld\r\n", EMPA_Sensor_Process_List[11]);
printf("\t CData: %ld\r\n", EMPA_Sensor_Process_List[12]);



Bu işlemin ardından terminal ekranında renk ve kızılötesi değerlerini görebilirsiniz. Örnek bir ölçüm sonucu aşağıda verilmiştir.







Ardından kızılötesi sensör olan STHS34PF80 sensöründen veri alınması işlemine geçiyoruz. Bunun için EMPA_Sensor_Process fonksiyonu içerisinde bulunan STHS Process Start ve STHS Process End yorum satırları arasına aşağıdaki kodu ekleyin.



STHS34PF80_GetPresenceFlag(&STHSObj,
		(uint8_t*) &EMPA_Sensor_Process_List[13]);



Ardından terminal ekranına yazdırma işlemi için EMPA_Sensor_Print fonksiyonu içerisinde bulunan Print Start ve Print End yorumları arasında bulunan kodları silin ve aşağıdaki kodu ekleyin.



printf("\t Presence: %ld\r\n", EMPA_Sensor_Process_List[13]);



Bu işlemin ardından terminal ekranında varlık değerini görebilirsiniz. Örnek bir ölçüm sonucu aşağıda verilmiştir.







Ardından yakınlık sensörü olan VL53L8A1 sensöründen veri alınması işlemine geçiyoruz. Bunun için EMPA_Sensor_Process fonksiyonu içerisinde bulunan VL53 Process Start ve VL53 Process End yorum satırları arasına aşağıdaki kodu ekleyin.



if (VL53_Drv->GetDistance(VL53_CompObj[VL53L8A1_DEV_CENTER], &VL53_Result)
		< 0) {
	memset(EMPA_TOF_Result, 0, 64);
} else {
	for (int i = 0; i < 64; i++) {
		EMPA_TOF_Result[i] = VL53_Result.ZoneResult[i].Distance[0];
	}
}



Ardından terminal ekranına yazdırma işlemi için EMPA_Sensor_Print fonksiyonu içerisinde bulunan Print Start ve Print End yorumları arasında bulunan kodları silin ve aşağıdaki kodu ekleyin.



for (int i = 0; i < 8; i++) {
	for (int j = 0; j < 8; j++) {
		printf("%d:%ld  ", i + j, EMPA_TOF_Result[i + j]);
	}
	printf("\r\n");
}



Bu işlemin ardından terminal ekranında yakınlık değerlerini görebilirsiniz. Örnek bir ölçüm sonucu aşağıda verilmiştir.







Bütün bu işlemler ile birlikte sıfırdan projeyi oluşturulmuş, sensörler başlatılmış ve veri okuma işlemleri gerçekleştirilmiştir.



VL53L8A1 Ekstra Projeleri



Bu aşamada ise VL53L8A1 sensörü temel alınarak oluşturulmuş projelere yer verilecektir. Bu noktada ilk aşamalarda indirdiğiniz Python Projects isimli klasöre girin. Ardından EMPA_VL_DEMO klasörü içerisine girin. Bu aşamadan sonra .project uzantılı dosyaya çift tıklayarak projeyi STM32CubeIDE platformu içerisine aktarın. Ardından projeyi derleyerek kartınıza aktarın.



Bu aşamayla birlikte iki adet örnek projeyi çalıştırabilecek durumdasınızdır. Bunlardan ilki VL53L8A1 yakınlık sensörü ile bir odaya giren çıkan insan sayısını sayan VL53_Counter.py projesidir. Bunun için VL53_Counter.py dosyasını açın. Ardından aşağıda verilen fonksiyonun içerisinde olan seri port ismini kendi port isminize göre değiştirin. Burada örnek olarak /dev/ttyACM0 verilmiştir.







Bu işlemin ardından projeyi çalıştırdığınızda karşınıza aşağıdaki gibi bir ekran gelecektir ve oda içerisine giren çıkan kişiler tek tek sayılacaktır.






Diğer proje ise VL53L8A1 yakınlık sensörü ile 8x8 ısı haritası oluşturan projedir. Bunun için VL53_Heat.py dosyasını açın. Ardından aşağıda verilen fonksiyonun içerisinde olan seri port ismini kendi port isminize göre değiştirin. Burada örnek olarak /dev/ttyACM0 verilmiştir.



Bu işlemin ardından projeyi çalıştırdığınızda karşınıza aşağıdaki gibi bir ekran gelecektir ve ısı haritası şeklinde sensör verilerini görebileceksiniz.







ISM330DHCX Machine Learning Core



Bu Bölümde ISM330DHCX'in Machine learning Core ile denemeler yapılacaktır. Öncelikle indirdiğiniz dosyalarda "Machine Learning Core" klasörünün içerisindeki .project dosyasına çift tıklayarak örnek projeyi stmcubeide'ye aktarınız.



Main dosyasının içerisinde includeların altında commentlenmis #define'lar görüceksiniz.



/*
 * Uncomment one of them at a time
 *
 * */
#define ism_six_d_example
//#define ism_motion_intensity_example
//#define ism_vehicle_stationary_detection_example
//#define ism_vibration_monitoring_example




Bu commentleri tek tek açarak istediğiniz modelleri seçebilirsiniz.



6D position recognition



Bu örnek, akselerometre verilerinin farklı eksenlerindeki Ortalama özellikleri (işaretli/İşaretsiz) kullanarak gerçekleştirilen 6D konum tanıma örneğini sunmaktadır.



Bu örnekte, akselerometre verilerini analiz ederek tanımlanan konumları içermektedir. Tanınan konumlar şunlardır: Hiçbiri, X-ekseni yukarı yönlü, X-ekseni aşağı yönlü, Y-ekseni yukarı yönlü, Y-ekseni aşağı yönlü, Z-ekseni yukarı yönlü, Z-ekseni aşağı yönlü




0 = None



1 = X-axis pointing up



2 = X-axis pointing down



3 = Y-axis pointing up



4 = Y-axis pointing down



5 = Z-axis pointing up



6 = Z-axis pointing down




Motion intensity



İvmeölçer normu üzerinde varyans özelliği kullanılarak gerçekleştirilen hareket şiddeti tespiti basit bir örneği. Bu örnekte tanımlanan sınıflar, 0 ile 7 arasında değişen sekiz farklı şiddet seviyesidir.




0 = Intensity_0



1 = Intensity_1



2 = Intensity_2



3 = Intensity_3



4 = Intensity_4



5 = Intensity_5



6 = Intensity_6



7 = Intensity_7




Vehicle stationary detection



Bu örnekte açıklanan sabitlik tespit algoritması, tüm bu amaçlar için toplanan veri günlüklerinin cihazın bir aracın içinde bulunduğu durumlardan elde edilmiş olması nedeniyle araç uygulamaları için tasarlanmıştır.



Bu örnekte tanımlanan sınıflar şunlardır: Hareket ve Sabitlik.




0 = Motion



4 = Stationary




Vibration monitoring



Bu örnekte, basit bir titreşim izleme algoritması sunulmaktadır.



Bu örnekte tanımlanan sınıflar şunlardır: Titreşim1 (hiç titreşim yok), Titreşim2 (düşük titreşim), Titreşim3 (yüksek titreşim).




0 = vibration1 (no vibration)



1 = vibration2 (low vibration)



2 = vibration3 (high vibration)




Kendi Modellerinizi Oluşturmak



Kendi modelleriniz oluşturmak istiyorsanız, aşağıdaki linkler size yardımcı olacaktır.



STMems_machine_Learning Github



AN5392



Bu işleming akış diagramı aşağıdaki gibidir.







NFC Tag Üzerine Kaydedilmesi



NFC Tag yazma ve okuma işlemlerinde ST firmasının geliştirmiş olduğu ST Tap programı kullanılmaktadır. Bu uygulama sayesinde kart üzerinde bulunan entegre hakkında bilgilere ulaşabilir ve çeşitli verileri NFC Tag üzerine kayıt edebilir veya üzerinden okuma yapabiliriz. Uygulamanın kurulumu için aşağıdaki QR kodu taratın.







Bu aşamada ise sensörlerden ölçülen verilerden eksen verileri ve sıcaklık nem verileri NFC Tag üzerine kayıt edilecektir. Bu sayede NFC özelliğine sahip bir cihaz ile kaydedilen veriler okunabilecektir. 



Kayıt işlemlerinden önce NFC kütüphanelerinde yapılması gereken değişiklikler bulunmaktadır. 



1 - "NFC7->Target" klasöründe bulunan "lib_NDEF_config" dosyasını kontrol ediniz. Wrapper fonksiyonları aşağıdaki gibi olmalıdır:



int32_t NDEF_Wrapper_ReadData(uint8_t* pData, uint32_t offset, uint32_t length )
{
  /* USER CODE BEGIN NDEF_Wrapper_ReadData */
	  if(CUSTOM_NFCTAG_ReadData(CUSTOM_NFCTAG_INSTANCE, pData, offset, length ) != NFCTAG_OK)
	    return NDEF_ERROR;
	  return NDEF_OK;
  /* USER CODE END NDEF_Wrapper_ReadData */
  return NDEF_OK;
}




int32_t NDEF_Wrapper_WriteData(const uint8_t* pData, uint32_t offset, uint32_t length )
{
 /* USER CODE BEGIN NDEF_Wrapper_WriteData */
	  if(CUSTOM_NFCTAG_WriteData(CUSTOM_NFCTAG_INSTANCE, pData, offset, length ) != NFCTAG_OK)
	    return NDEF_ERROR;
  /* USER CODE END NDEF_Wrapper_WriteData */
  return NDEF_OK;
}




uint32_t NDEF_Wrapper_GetMemorySize(void)
{
 /* USER CODE BEGIN NDEF_Wrapper_GetMemorySize */
	 return CUSTOM_NFCTAG_GetByteSize(CUSTOM_NFCTAG_INSTANCE);
  /* USER CODE END NDEF_Wrapper_GetMemorySize */
  return NDEF_OK;
}




2 - NDEF maximum text'i ayarlamak için "Middlewares\ST\lib_nfc7\lib_NDEF\Core\inc" klasoründe bulunan "lib_NDEF_Text.h" dosyasının içerisindeki aşağıdaki satırı değiştiriniz



/** @brief NDEF Text buffer length. */
#define NDEF_TEXT_MAX_LENGTH 256




Öncelikle Sensor library include section start ve Sensor library include section end yorum satırları arasındaki kodu silin ve aşağıdaki kodu ekleyin.



#include "EMPA_NFC.h"
#include "EMPA_Sensor.h"
#include "EMPA_AT.h"



Ardından main.c dosyası içerisinde bulunan NFC init section start ve NFC init section end yorum satırları arasına aşağıdaki kodu ekleyin.



while (EMPA_NFC_Init() != EMPA_OK)
		;



Bu işlem ile birlikte NFC konfigürasyonları yapılmış olup kaydetme ve okuma işlemleri için hazır konuma getirilmiştir.



Ardından verilerin her 5 ölçümden sonra NFC Tag üzerine kayıt edilmesi için main.c dosyası içerisinde bulunan Sensor process section start ve Sensor process section end yorum satırları arasında kalan kodları silin ve ardından aşağıdaki kodu ekleyin.



EMPA_Sensor_Process(sensors, tof_result);
EMPA_Sensor_Print(sensors, tof_result);
EMPA_NFC_Sensor_Process(sensors);
HAL_Delay(100);



Bu işlemlerin ardından her 5 ölçümde bir olacak şekilde NFC Tag üzerine sensör verileri kaydedilmiştir. ST Tap uygulamasını kullanarak NFC Tag üzerindeki verileri okuyabilirsiniz.



WiFi ve NFC Uygulaması



NFC Kayıt işlemiyle birlikte son olarak NFC üzerinden WiFi Provisioning ve hemen ardından Cloud Provisioning işlemleri yapılacaktır. Bu uygulamada ilk olarak NFC üzerine kayıt edilen WiFi ve cihaz bilgileri okunulacaktır. Ardından bu bilgiler ile EmpaCloud sistemine cihaz kaydı yapılacak ve sensör verileri bu EmpaCloud bulut sistemine iletilecektir.



Bu aşamada WiFi ve NFC Provisioning işlemleri için Empa Elektronik tarafından geliştirilen EmpaCloud Connect uygulaması kullanılacaktır. Bu uygulama sayesinde hem provisioning işlemleri yapılacak olup, bu işlemlerin ardından sensör verilerini incelenebilmektedir. Uygulamayı IOS veya Android seçeneği ile indirmek için aşağıdaki QR kodu taratın.







Bu işlemler için öncelikle değişkenleri tanımlıyoruz. Bunun için main.c dosyası içerisinde bulunan Provision private variables section start ve Provision private variables section end yorum satırları arasına aşağıdaki kodu yapıştırın ve hemen ardından kullanmak istediğiniz cihaz ismini DEV_ID değişkenine yerleştirin.



 
char rx1_char;
char rx2_char;
char rx2_buffer[4096] = { 0 };
uint16_t rx2_index = 0;
uint8_t rx2_flag = 0;
 
uint8_t nfc_flag = 0;
uint8_t wifi_flag = 0;
 
char EMPA_WIFI[128] = { 0 };
char EMPA_PASS[128] = { 0 };
char APP_ID[256] = { 0 };
char DEV_ID[128] = "workshop";



Bu işlemin ardından NFC init section start ve NFC init section end yorum satırları arasındaki kodları silin ve aşağıdaki kodları ekleyin.



while (EMPA_NFC_Process(EMPA_WIFI, EMPA_PASS, APP_ID) != EMPA_OK)
{
	HAL_Delay(2000);
	nfc_flag = 0;
}
nfc_flag = 1;



Bu işlem ile birlikte WiFi bilgileri NFC Tag üzerine kaydedilmiştir. Ardından bu WiFi bilgilerini kullanarak EmpaCloud'a bağlanabilmek için gerekli işlemleri yapıyoruz. Bunun için Provision section start ve Provision section end yorum satırları arasına aşağıdaki kodu ekleyin.



while(EMPA_AT_Provision(&hlpuart1, EMPA_WIFI, EMPA_PASS, DEV_ID, APP_ID) != EMPA_OK)
{
	wifi_flag = 0;
	HAL_Delay(2000);
}
wifi_flag = 1;



Bu işlemin ardından SenseShield kartımız EmpaCloud sistemine bağlanmaya çalışacaktır. Bu ortalama bir süre içerisinde gerçekleşecektir. Bu işlemin ardından verilerin bulut sistemine aktarılması için Sensor process section start ve Sensor process section end yorum satırları arasındaki kodları silin ve aşağıdaki kodları ekleyin.



EMPA_Sensor_Process(sensors, tof_result);
EMPA_Sensor_Print(sensors, tof_result);
EMPA_AT_Pub(&hlpuart1, DEV_ID, APP_ID, sensors, tof_result);
HAL_Delay(100);



Bu işlemlerin ardından son adımda stm32h5xx_it.c dosyası içerisinde bulunan USER CODE BEGIN PV ve USER CODE END PV yorum satırları arasına aşağıdaki kodu ekleyin.



extern uint8_t nfc_flag;
extern uint8_t wifi_flag;
int count = 0;



Son olarak USER CODE BEGIN TIM2_IRQn 1 ve USER CODE END TIM2_IRQn 1 yorum satırları arasına aşağıdaki kodu ekleyin.



count++;
if(count == 2)
{
          if(nfc_flag == 0)
	  {
		  HAL_GPIO_TogglePin(LED_1_GPIO_Port, LED_1_Pin);
		  count = 0;
	  }
	  else if(nfc_flag == 1)
	  {
		  HAL_GPIO_WritePin(LED_1_GPIO_Port, LED_1_Pin, ENABLE);
		  count = 0;
	  }
 
	  if(wifi_flag == 0)
	  {
		  HAL_GPIO_TogglePin(LED_2_GPIO_Port, LED_2_Pin);
		  count = 0;
	  }
	  else if(wifi_flag == 1)
	  {
		  HAL_GPIO_WritePin(LED_2_GPIO_Port, LED_2_Pin, ENABLE);
		  count = 0;
	  }
  }



Provisioning işlemleri sırasında iki adet kullanıcı LEDi yanıp sönmektedir. Bunlardan ilki NFC üzerinden WiFi bilgilerinin alındığını kontrol ederken diğer LED ise WiFi ve EmpaCloud bağlantınızı kontrol etmektedir. İlk aşamada yanıp sönme hareketi yaparken olumlu sonuçlanan her aşamada sabit bir şekilde yanmaktadır.



Bütün bu işlemlerin ardından sensörlerden veriler ölçülüp bu ölçülen değerler EmpaCloud bulut sistemine aktarılmıştır. EmpaCloud Connect uygulaması kullanarak sensör verilerinizi görebilirsiniz.