Stm32

TCS230 TCS3200 Nasıl Kullanılır

TCS3200 Renk Sensörü Kartı
TCS3200

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.

TCS3200 Entegre
TCS3200 Entegre

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..

Okuma İşlemi görseli
Okuma İşlemi görseli

Pin yapısı

Sensör pin çıkışı:

TC3200 Pin Çıkışları
TC3200 Pin Çıkışları
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 tipiS2S3
Kırmızı00
Mavi01
Filtre yok (temizle)10
Yeşil11
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çeklendirmeS0S1
Modülü Kapatır00
% 201
% 2010
100%11
Frekans Ölçeklendirme

Bağlantı Şeması

TCS3200 ve TCS230 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.

Yeni Projemizi Oluşturma Penceresi
Yeni Projemizi Oluşturma Penceresi
STM32 Mikrodenetleyici seçimi
STM32 Mikrodenetleyici seçimi

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.

STM32 Harici Osilatör seçimi
STM32 Harici Osilatör seçimi

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.
STM32 Serial Wire Seçimi
STM32 Serial Wire Seçimi

Ş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
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.

Stm32 Çıkış pinleri tanımlama

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.

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>© Copyright (c) 2020 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim3;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_TIM3_Init(void);
static void MX_TIM1_Init(void);
/* USER CODE BEGIN PFP */

uint32_t IC_deger1 = 0; //Yakalanan degerler
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;
uint32_t blue_freq=0;
uint32_t white_freq=0;
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.
		}
	}
}



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 */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
Etiketler

Onur NP

Arduino Stm32 gibi Mikrodenetleyici PLC Otomasyon sistemleri ve Genel elektronik projeleri üzerine örnek paylaşımlar yapmaktayım Endüstriyel ve Kişisel proejelerinize Ücretli olarak destek verebilirim.

İlgili Makaleler

Bir cevap yazın

E-posta hesabınız yayımlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

Göz Atın
Kapalı
Başa dön tuşu
Call Now ButtonAra
Kapalı
Kapalı