STM32 TCS230 TCS3200 Nasıl Kullanılır Ocak 21st, 2021

TCS3200 Nedir ?

Merhabalar arkadaşlar bugün daha önceki günlerde bir öğrenci arkadaşımızdan gelen ve hayata geçirdiğim projeyi kaynak alacağım..

Konumuz TCS3200 Yada TCS230 Renk Sensörleri arkadaşlar bu renk tespit sensörleri piyasada çok ucuza bulup çok verimli çalışabilen sensörlerdir. özellikle TCS3200 Renk renksörü TCS230 a göre 2 katı algılama diyotuna sahip olduğu için çok daha başarılı sonuçlar vermektedir. Ancak 2 sensörde aynı prensip ile çalışmaktadır. Yani TCS3200 için yazdığınız program kalibrasyondan sonra muhtemelen TCS230 da da sağlıklı bir şekilde çalışacaktır.

TCS3200 Nasıl Çalışır ?

Tcs3200 yada TCS230 sensörü temel olarak çok basit bir çalışma prensibine sahiptir aslında genel olarak kafanızda bir yapı oluşması amacıyla şöyle yüzeysel bir anlatayım.. Sensörümüz rengini okumak istediğimiz nesneye yaklaştırdığımızda nesnenin renk durumuna göre ışın dalga boyu değiştiği için bu farkı okuyup bizlere %50 oranlı bir frekans çıktısı vermektedir yani kırmızıda farklı bir frekans mavide farklı bir frekans siyahta farklı bir frekans çıktısı almaktayız..

Bizlerde bu çıkıştan aldığımız frekansı doğru şekilde yorumladığımızda okunan renkleri hızlı bir şekilde belirleyebiliriz. Haydi Şimdi mevzuunun derinlerine inelim 😉

TCS3200’de 4 farklı filtreli bir dizi fotodiyot bulunur. Bir fotodiyot, ışığı akıma dönüştüren bir yarı iletken cihazdır. Sensörde şunlar bulunur:

Kırmızı filtreli 16 fotodiyot – kırmızı dalga boyuna duyarlı
Yeşil filtreli 16 fotodiyot – yeşil dalga boyuna duyarlı
Mavi filtreli 16 fotodiyot – mavi dalga boyuna duyarlı
Filtresiz 16 fotodiyot

TCS3200 yongasına daha yakından bakarsanız farklı filtreleri görebilirsiniz.

Fotodiyot filtresinin okumalarını seçerek seçerek farklı renklerin yoğunluğunu tespit edebilirsiniz. Sensör, fotodiyotların okumalarını seçilen rengin ışık yoğunluğu ile orantılı bir frekansla kare bir dalgaya dönüştüren bir akım-frekans dönüştürücüsüne sahiptir. Bu frekans daha sonra STM32 tarafından okunur – bu aşağıdaki şekilde gösterilmiştir.

Örnekleyelim ve çalışma mantığını ana dilimizde kafamıza yazalım aşağıdaki tabloda da göreceğiniz gibi örneğn kırmızıyı okumak istiyorsak S2 ve S3 bacağını 0 a çekeceğiz ve OUT bacağınki frekansı okuyacağız Sonra Maviyi Okumak istediğimizde S2 0 ve S3 bacağını 1 e çekeceğiz ve OUT çıkışındaki frekansı okuyacağız bu işlem bu şekilde sıralı olarak gerçekleştirildiğinde tüm renkleri aktif olarak okumuş olacağız. Sonrasında bu okuduğumuz değerleri bir değer tablosu oluşturacağız v bu tablo ile kıyaslayarak renk okuma işlemini gerçekleştireceğiz. Şimdi Detaylara devam edelim..

Pin yapısı

Sensör pin çıkışı:

Pin Adı	Açıklama
GND	STM32 GND bağlantısı
OE	Modülü Açıp kapatma çıkışı Low Durumunda Açıktır.
OUT	Çıkış frekansı
S0, S1	Çıkış frekansı ölçeklendirme seçim girişleri
S2, S3	Foto diyot ölçümleme için renk seçim bacakları
VDD (5)	Modül beslemesi 5V

TCS3200 >Bağlantı uçları açıklaması

Filtre seçimi

Fotodiyot tarafından okunan rengi filtrelemek için durum seçmek gereklidir S2 ve S3 kontrol pinlerini kullanarak Bu filtreleme işini gerçekleştirebilirsiniz aşağıdaki tablodaki Tüm Olasılıklar belirtilmiştir. Fotodiyotlar paralel bağlandığından, S2 ve S3 DÜŞÜK ve YÜKSEK’i farklı kombinasyonlarda ayarlamak farklı fotodidotları seçmenize olanak tanır. Aşağıdaki tabloya bir göz atın.

Fotodiyot tipi	S2	S3
Kırmızı	0	0
Mavi	0	1
Filtre yok (temizle)	1	0
Yeşil	1	1

Filtre Tablosu

Frekans ölçeklendirme

S0 ve S1 pinleri çıkış frekansını ölçeklemek için kullanılır. Aşağıdaki ön ayar değerlerine ölçeklendirilebilir: % 100, %20 veya %2. Çıkış frekansının ölçeklendirilmesi, çeşitli frekans sayaçları veya mikrodenetleyiciler için sensör okumalarını optimize etmek için kullanılır Okuyacağınız frekansın hızı sizin örnekleme kalitenizi belirlemektedir ancak ben genellikle %2 kullanıyorum ve yeterli geliyor daha hassas işlem yapacağım ara renkleri daha iyi gözlemleyeceğim diyorsanız hızı birazda yükseltmeniz faydalı olabilmektedir. Aşağıdaki tabloya bir göz atın.

Çıkış frekansı ölçeklendirme	S0	S1
Modülü Kapatır	0	0
% 2	0	1
% 20	1	0
100%	1	1

Frekans Ölçeklendirme

Bağlantı Şeması

GND = GND bağlanır.
VDD = 5V beslemesine bağlanır.
OE = GND bağlayabilirsiniz.
LED = Led Bacağı burada görünmüyor ancak onuda 3.3 V bağlayabilirsiniz.
S0 = PA0
S1 = PA1
S2 = PA2
S3 = PA3
OUT = PA6

TCS230 yada TCS3200 de bağlantılarınızı aynı şekilde gerçekleştirebilirsiniz. Bağlantılarımızı gerçekleştirdik ve artık kodlama kısmına geçebiliriz.

Kodlama

Arkadaşlar şimdi modülümüzü kullanmak için STM32 herhangi bir sürümünü kullanabilirsiniz. Ben burada STM32F407VGT6 Kullanacağım ancak kullanacağımız fonksiyonlar tüm STM32 versionları ile uyumludur. Ufak tefek değişiklikler ile istediğiniz versiyona port edebilirsiniz.

Şimdi CubeMX programınızı açın ve new Project diyerek mikrodenetleyicinizi seçin.

Artık denetleyicimizi seçip çift tıkladığımızda Açılan ayar ekranından öncelikle RCC bölümüne girip harici kristalimizi aktif edelim.

Sonrasında SYS bölümüne gelip burdan programlayıcıı bacaklarımızı tanımlamamız gerekiyor Serial Wire seçiyoruz.

STM32F4 gibi serilerde bunu seçmesekte problem olmuyor ancak M3 serisi yani STM32F103 gibi mikrodenetleyicilerde bu bölümü seçmezseniz tekrar program atmanız malesef mümkün olmuyor bu yüzden bu bölümü seçmeniz önemlidir.

Şimdi de clock ayarlarımızı yapacağız Clock ayarları frekans ölçmede önemli rol oynamaktadır. Ben Timer hesaplamalarımı daha önceden 45 MHZ hızına göre ayarladığım için hızımı 45 MHZ yapıyorum. Sisde işaretli bölüme 45MHZ yazıp enterlayın Eğer 45 MHZ ayarlayamazsanızda çok önemli değil 3 aşağı 5 yukarı yakın olsun yeterli.

Clock ayarlarımızıda yaptığımıza göre Artık Pinout & Configuration bölümümüze geri dönebiliriz. Şimdi Kilit ayarımız olan Timer Ayarımızı yapacağız. Ben Timer3 Seçtim 1. kanal İnput Capture seçtim ve aşağıdaki ayarlarından ARR Yani Counter Period 65535 yaptım Hex olarak 0XFFFF yaptım. Sonrasında ise NVIC kesme global servisini açtım frekans saydığımız için Herhangi bir işemde duraksama istemiyoruz.

Stm32 NVIC Global kesme servisi aktivasyon

Timer Hız ayarı Şu Şekilde işler Sistem Hızımız 45 MHZ Timer hızımızda 45 MHZ bu durumda İstediğimiz frekansı elde etmenin formülü şudur ;

İstenen frekans = Sistem Timer Hızı / (ARR*PSC)

Eğer Frekans değil de period ile hesaplamak isterseniz ;

1/Timer Frekansı örneğin 1/45MHz =22.22Ns

Sistem Timer Hızı : Genellikle sistem hızınızdır.
ARR = Auto Reload Register Yani CubeMX’te Counter Period
PSC = Prescaler Timer Hız bölücü kat sayısı

Timer ayarlarımızıda gerçekleştirdiğimize göre Artık S0,S1,S2,S3 çıkışlarımızı tanımlamamız gerekmekte bunun için istediğiniz harhangi bir pini seçip OUTPUT olarak Ayarlamanız dilerseniz etiket vererek kullanım kolaylığı sağlamanız mümkündür.

Artık CubeMX Kısmımız hazır Ben keil Kullandığım için burada MDK-Arm seçeneğini seçiyorum siz hangi derleyiciyi kullanıyorsanız onu seçip Generate Etmeniz yeterli sonrasında Open Project diyerek Keil Geçebiliriz.

Arkadaşlar ben herhangi bir ekran vs. eklemedim burada Çünkü debug üzerinden gözlem yapıyorum siz Dilerseniz LCD yada Oled gibi bir ekran ekleyebilirsiniz.

Şimdi Keil de Main satırının üzerine gelecek şekilde yani global satıra frekansımızı okumak için bir fonksiyon yazıyoruz. her komutun ve degiskenin islevini kolaylık olsun diye karşısına yazdım arkadaşlar.

uint32_t IC_deger1 = 0; //Yakalanan degerleri kaydettigimiz degiskenler
uint32_t IC_deger2 = 0;
uint32_t fark = 0; // Yakalanan frekans farki
uint32_t Frekans = 0; // frekans degiskeni
uint8_t ilk_deger = 0; // giris yakalandi mi ?
uint32_t red_freq=0; // renkte okunacak donuus frekanslarini kayit edecegimiz minik degiskenlerimiz
uint32_t green_freq=0;// yesil filtredeyken okudugumuz frekans
uint32_t blue_freq=0;// mavi filtredeyken okudugumuz frekans
uint32_t white_freq=0;// kirmizi filtredeyken okudugumuz frekans
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1)// Channel 1 yakalama varm? ?
{
if (ilk_deger==0) // yok ise yakalanan degeleri kyit edelim
{
IC_deger1 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);
ilk_deger =1; // yakalama artik var 2. degeri almak uzere ana donguye donelim
}    
else if (ilk_deger) // yakalanan deger varmi ? 
    {
        IC_deger2 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1); // Yakalanan ikinci degeri de kayit edelim

        if (IC_deger2 > IC_deger1) // degerler farkini alalim
        {
            fark = IC_deger2-IC_deger1;
        }

        else if (IC_deger2 < IC_deger1) // ters yonlu durum var ise oonunda farkini alalim
        {
            fark = ((0xffff-IC_deger1)+IC_deger2) +1;
        }

        else
        {
            Error_Handler();
        }

        Frekans = HAL_RCC_GetPCLK1Freq()/fark;// aldigimiz farki frekans degerine gore olceklendirelim
        ilk_deger = 0; // eski okuma durumumuzu sifirlayalim.
    }
}}

Frekans okuma fonksiyonunu da tanımladık bu fonksiyonumuzu herhangi bir yerde çağırmamıza gerek yok kesme servisini dahil ettiğimiz için her taşmada değeri otomatik olarak Frekans değişkeni içerisinde kendisi bize verecek.

Şimdi TCS3200 / TCS230 daha önce bahsettiğim çalışma hızını belirleyecek bir fonksiyon yazalım fonksiyon olarak yazmasakta olur ama fonksiyonlar ilerleyen zamanda işlerinizi yönetmenizde sizlere kolaylık sağlar anlaşılması kolay olur.

void Sensor_hiz_kontrol(int hiz){ // integer Hiz degiskeni verdigimiz fonksiyonumuzda verdigimiz degere gore hiz degisimini hizlica yapacagiz

if(hiz==0){// sensor cikisi kapatilir
HAL_GPIO_WritePin(GPIOA, S0_Pin|S1_Pin, GPIO_PIN_RESET);
}
if(hiz==1){  // sensor cikisi %2 hizla calisir
HAL_GPIO_WritePin(GPIOA, S0_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOA, S1_Pin, GPIO_PIN_SET);
}
if(hiz==2){ // sensor cikisi %20 hizla calisir
HAL_GPIO_WritePin(GPIOA, S0_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOA, S1_Pin, GPIO_PIN_RESET);
}
if(hiz==3){// sensor cikisi %100 hizla calisir
HAL_GPIO_WritePin(GPIOA, S0_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOA, S1_Pin, GPIO_PIN_SET);
}
}

Hız ayarlama fonksiyonumuzu da tamamladık şimdi Filtreleme fonksiyonumuzu tanımlıycaz bu sayede 3 rengi de basitçe filtreliycez.

void Sensor_renk_kontrol(int renk){
if(renk==0){// Kirmizi okuma
HAL_GPIO_WritePin(GPIOA, S2_Pin|S3_Pin, GPIO_PIN_RESET);
}
if(renk==1){  // Mavi okuma
HAL_GPIO_WritePin(GPIOA, S2_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOA, S3_Pin, GPIO_PIN_SET);
}
if(renk==2){ // Beyaz yani toplamda okuma
HAL_GPIO_WritePin(GPIOA, S2_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOA, S3_Pin, GPIO_PIN_RESET);
}
if(renk==3){// Yesil okuma
HAL_GPIO_WritePin(GPIOA, S2_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOA, S3_Pin, GPIO_PIN_SET);
}
}

Evet fonksiyonlarımızı tanımladık şimdi artık çalıştırılması için kodlamaya devam edelim.

İlk olarak Main içi While üstüne Timer 3 Channel 1 İnput capture Kesme servisli zamanlayıcımızı çalıştıralım. Ardından Tanımladığımız hız fonksiyonumuzuda çalıştıralım.

HAL_TIM_IC_Start_IT(&htim3, TIM_CHANNEL_1);// Timer3 Baslattik
Sensor_hiz_kontrol(1); // Sensor cikis hizimizi %2 ayarladik

Ardından While içerisine renkleri filtreleyerek sırasıyla her renkte aldığımız frekansları okutalım.

Sensor_renk_kontrol(0); // kirmizi okuma
		HAL_Delay(200);
		red_freq=Frekans;

Sensor_renk_kontrol(1);// Mavi Okuma    
		HAL_Delay(200);
		blue_freq=Frekans;

Sensor_renk_kontrol(2);// beyaz okuma
		HAL_Delay(200);
		white_freq=Frekans;

Sensor_renk_kontrol(3);// yesil okuma
		HAL_Delay(200);
		green_freq=Frekans;
				
	if(red_freq<1800 && red_freq> 2000){
		
		}
		
	if(blue_freq<280 && blue_freq> 480){
		
		}
		
	if(green_freq<280 && green_freq> 480){
		
		}*/

Arkadaşlar şimdi kodlarımız tamamlandı Şuan debug yapınca her koyduğunuz renkte okuma işlemi yapıldığını göreceksiniz gördüğünüz gibi ben kendi sensörüne göre kalibre edilmiş if koşullarını koydum sizde okuduğunuz değerr aralıklarını buralara girerek kalibrasyon yapabilirsiniz if koşullarının içerisine komutlar yerleştirerek dilediğiniz işlemi hızlıca yaptırabilirsiniz. Kolaya kaçan hazırcı arkadaşlar için kodların tamamını aşağıya ekliyorum.

Takıldığınız yerlerde iletişime geçebilirsiniz. İyi Çalışmalar.

		}

			else
			{
				Error_Handler();
			}

			Frekans = HAL_RCC_GetPCLK1Freq()/fark;// aldigimiz farki frekans degerine gore olceklendirelim
			ilk_deger = 0; // eski okuma durumumuzu sifirlayalim.
		}
	}
}



void Sensor_hiz_kontrol(int hiz){
if(hiz==0){// sensor cikisi kapatilir
HAL_GPIO_WritePin(GPIOA, S0_Pin|S1_Pin, GPIO_PIN_RESET);
}
if(hiz==1){  // sensor cikisi %2 hizla calisir
HAL_GPIO_WritePin(GPIOA, S0_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOA, S1_Pin, GPIO_PIN_SET);
}
if(hiz==2){ // sensor cikisi %20 hizla calisir
HAL_GPIO_WritePin(GPIOA, S0_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOA, S1_Pin, GPIO_PIN_RESET);
}
if(hiz==3){// sensor cikisi %100 hizla calisir
HAL_GPIO_WritePin(GPIOA, S0_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOA, S1_Pin, GPIO_PIN_SET);
}

}

void Sensor_renk_kontrol(int renk){
if(renk==0){// Kirmizi okuma
HAL_GPIO_WritePin(GPIOA, S2_Pin|S3_Pin, GPIO_PIN_RESET);
}
if(renk==1){  // Mavi okuma
HAL_GPIO_WritePin(GPIOA, S2_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(GPIOA, S3_Pin, GPIO_PIN_SET);
}
if(renk==2){ // Beyaz yani toplamda okuma
HAL_GPIO_WritePin(GPIOA, S2_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOA, S3_Pin, GPIO_PIN_RESET);
}
if(renk==3){// Yesil okuma
HAL_GPIO_WritePin(GPIOA, S2_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOA, S3_Pin, GPIO_PIN_SET);
}

}

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();
	
  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM3_Init();
  MX_TIM1_Init();
  /* USER CODE BEGIN 2 */
 HAL_TIM_IC_Start_IT(&htim3, TIM_CHANNEL_1); // Renk dedektorumuzun frekans cikisini okumak uzere input capture kesmeli timer3 1. kanalimi baslatalim

  /* USER CODE END 2 */

  /* Infinite loop */
	Sensor_hiz_kontrol(1); // Sensor cikis hizimizi %2 ayarladik
	volatile int k=0;
  /* USER CODE BEGIN WHILE */
  while (1)
  { 
		

    /*

		Sensor_renk_kontrol(0); // kirmizi okuma
		HAL_Delay(200);
		red_freq=Frekans;
		Sensor_renk_kontrol(1);// Mavi Okuma    
			HAL_Delay(200);
		blue_freq=Frekans;
		Sensor_renk_kontrol(2);// beyaz okuma
		HAL_Delay(200);
		white_freq=Frekans;
		Sensor_renk_kontrol(3);// yesil okuma
		HAL_Delay(200);
		green_freq=Frekans;
				
		if(red_freq<1800 && red_freq> 2000){
		
		}
		
		if(blue_freq<280 && blue_freq> 480){
		
		}
		
				if(green_freq<280 && green_freq> 480){
		
		}*/
				
		
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage 
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
  /** Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 8;
  RCC_OscInitStruct.PLL.PLLN = 90;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV2;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief TIM1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM1_Init(void)
{

  /* USER CODE BEGIN TIM1_Init 0 */

  /* USER CODE END TIM1_Init 0 */

  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_OC_InitTypeDef sConfigOC = {0};
  TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};

  /* USER CODE BEGIN TIM1_Init 1 */

  /* USER CODE END TIM1_Init 1 */
  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 900-1;
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim1.Init.Period = 1000-1;
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim1.Init.RepetitionCounter = 0;
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_PWM_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 0;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
  if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)
  {
    Error_Handler();
  }
  sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
  sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
  sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
  sBreakDeadTimeConfig.DeadTime = 0;
  sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
  sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
  sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
  if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM1_Init 2 */

  /* USER CODE END TIM1_Init 2 */
  HAL_TIM_MspPostInit(&htim1);

}

/**
  * @brief TIM3 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM3_Init(void)
{

  /* USER CODE BEGIN TIM3_Init 0 */

  /* USER CODE END TIM3_Init 0 */

  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_IC_InitTypeDef sConfigIC = {0};

  /* USER CODE BEGIN TIM3_Init 1 */

  /* USER CODE END TIM3_Init 1 */
  htim3.Instance = TIM3;
  htim3.Init.Prescaler = 0;
  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim3.Init.Period = 0xffff;
  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_IC_Init(&htim3) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigIC.ICPolarity = TIM_INPUTCHANNELPOLARITY_RISING;
  sConfigIC.ICSelection = TIM_ICSELECTION_DIRECTTI;
  sConfigIC.ICPrescaler = TIM_ICPSC_DIV1;
  sConfigIC.ICFilter = 0;
  if (HAL_TIM_IC_ConfigChannel(&htim3, &sConfigIC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM3_Init 2 */

  /* USER CODE END TIM3_Init 2 */

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOE_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, S0_Pin|S1_Pin|S2_Pin|S3_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pins : S0_Pin S1_Pin S2_Pin S3_Pin */
  GPIO_InitStruct.Pin = S0_Pin|S1_Pin|S2_Pin|S3_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */

  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{ 
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

STM32 TCS230 TCS3200 Nasıl Kullanılır

TCS3200 Nedir ?

TCS3200 Nasıl Çalışır ?

Pin yapısı

Filtre seçimi

Frekans ölçeklendirme

Bağlantı Şeması

Kodlama

2020 Transistör nedir?

0 Arduino Rtos Kullanımı Nasıl Yapılır ?

You may also like

Yorum bırak İptal