Optimizasyon, kodunuzu derleyicinin daha verimli bir şekilde çalıştırmasını sağlamak için yaptığı değişikliklerdir. Örneğin, derleyici kodunuzdaki inanılmaz değişkenleri veya fonksiyonları sildiğinde veya değiştirdiğinde, kodunuzun çalışma hızını arttırabilir. Aynı şekilde, derleyici kodunuzdaki bellek kullanımını azaltmak için değişiklikler yapabilir.

“None” seçeneği, hiçbir optimizasyon yapılmaz. Bu seçenek, hata ayıklama işlemleri için en uygun olandır. “Low” seçeneği, düşük seviyede optimizasyon yapar. Bu seçenek, hata ayıklama işlemleri için uygun olsa da, kodun hızını arttırmak için yeterli olmayabilir.
“Medium” seçeneği, orta seviyede optimizasyon yapar. Bu seçenek, hata ayıklama işlemleri için uygun olsa da, kodun hızını arttırmak için daha etkilidir.
“High” seçeneği, yüksek seviyede optimizasyon yapar. Bu seçenek, kodun hızını arttırmak için daha etkilidir ancak hata ayıklama işlemleri için zor olabilir.
“Maximum” seçeneği, maksimum optimizasyon yapar. Bu seçenek, kodun hızını en yüksek seviyede arttırmak için kullanılır ancak hata ayıklama işlemleri için zor olabilir.

Optimizasyon seçeneği seçerken, kodunuzun çalışma hızı ve bellek kullanımı arasındaki dengeyi dikkate almalısınız. Ayrıca, hata ayıklama işlemleri için yeterli alanın olduğundan emin olmalısınız.

IAR (STM8) Optimizasyon Ayarları yazısı ilk önce N7A Teknik üzerinde ortaya çıktı.

[apvc_embed type=”customized” border_size=”2″ border_radius=”5″ background_color=”” font_size=”14″ font_style=”” font_color=”” counter_label=”Visits” today_cnt_label=”Today” global_cnt_label=”Total” border_color=”” border_style=”solid” padding=”5″ width=”200″ global=”false” today=”false” current=”true” icon_position=”” widget_template=”None” ]

ST-Link V2 Pozitif Besleme 3.3V ve 5V Sorunu yazısı ilk önce N7A Teknik üzerinde ortaya çıktı.

STM8S103 mikrodenetleyicisinde donanımsal olarak 10 Bit çözünürlükte ADC birimi bulunmaktadır.

/* Includes ------------------------------------------------------------------*/
#include "stm8s.h"
#include "stm8s_clk.h"
#include "stm8s_adc1.h"
#include "stm8s_gpio.h"

/* Private defines -----------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/

void main(void)
{
  
  CLK_DeInit();
  CLK_HSECmd(DISABLE);
  CLK_LSICmd(DISABLE);
  CLK_HSICmd(ENABLE);
  while(CLK_GetFlagStatus(CLK_FLAG_HSIRDY) == 0){}
  
  CLK_ClockSwitchCmd(ENABLE);
  CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV1);
  CLK_SYSCLKConfig(CLK_PRESCALER_CPUDIV1);
  
  GPIO_Init(GPIOD, GPIO_PIN_2, GPIO_MODE_IN_FL_NO_IT);
  
  ADC1_Init(ADC1_CONVERSIONMODE_CONTINUOUS,
            ADC1_CHANNEL_3,
            ADC1_PRESSEL_FCPU_D2,
            ADC1_EXTTRIG_TIM,
            DISABLE,
            ADC1_ALIGN_RIGHT,
            ADC1_SCHMITTTRIG_CHANNEL3,
            DISABLE);
  ADC1_ITConfig(ADC1_IT_EOCIE,ENABLE);
  
  enableInterrupts();
  
  ADC1_StartConversion();  
  
  while (1)
  {
  
  
  
  }
  
}

#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(u8* file, u32 line)
{ 
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

  /* Infinite loop */
  while (1)
  {
  }
}
#endif


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

Ayrıca dosyayı buradan indirebilirsiniz.

STM8 Programlama -IAR- #10 (ADC) (Analog Digital Converter) STM8S103F3 yazısı ilk önce N7A Teknik üzerinde ortaya çıktı.

Peki işin arka tarafında neler oluyor?
Öncelikle Beep blok diyagramını inceleyelim.

Görüldüğü gibi BEEP birimi osilatör kaynağı olarak iki seçenek kabul eder. Bunlardan birisi HSE diğeri ise LSI. Ne olacaktı yani harici kristal osilatör kullanmıyorsak düdük öttüremeyecekmiydik. Elbette öttürürüz. Bunun için LSI RC osilatör kaynağını kullanacağız. Reference Manuel LSI osilatör kaynağı kullanılacaksa düzgün bir frekans elde etmek için LSI kaynağının ölçülerek kalibre edilmesini tavsiye eder. Sebebi ise LSI 128KHz osilatör kaynağının çalışma sıcaklığı limitleri dahilinde çıkış frekansının +/-12,5% tölerans ile değişiklik gösterebilmesidir. Bu kalibre işlemi için kütüphanede var olan BEEP_LSICalibrationConfig fonksiyonunun içerisine harici olarak LSIMeasurment() fonksiyonunu kendimiz ekleyeceğiz ve iç içe döngü ile kalibrasyon olayını halletmiş olacağız. Aşağıda ekleyeceğimiz fonksiyonu paylaşacağım.
Değinmek istediğim bir diğer konu ise kalibrasyon işlemi sırasında bir TIMER kullanılıyor. Bunun ayrıntılarına bilmemize gerek yok fonksiyon olayı kendisi hallediyor fakat genede bunu bilmekte fayda var. Fonksiyon içerisinde kullanılan MCU’ya göre gerekli TIMER birimini aktif ediyor(STM8S103 için TIMER1) ve gerekli ölçümü yaptıktan sonra ilgili TIMER devre dışı bırakılıyor. Hangi TIMER’ı kullandığı hususuna uygulama videosunda değineceğim.
Dolayısıyla ileride projelerde TIMER1 ve Beep kullanacaksak LSI osilatör kaynağını kalibre ettikten sonra TIMER1’i kurma konusuna dikkat etmeliyiz. Kafaları fazla karıştırmadım umarım….
Kalibrasyon işleminden sonra kullanacağımız frekansı seçerek BEEPEN bitini SET ederek sinyal çıkışını elde ediyoruz.

Şimdi kütüphanedeki kodları inceleyelim.

#include "stm8s_beep.h"

ile kütüphaneyi dahil ettik.
Kullanacağımız osilatör kaynağına ek olarak CLK_LSICmd() fonksiyonunuda ENABLE ettik.

void BEEP_DeInit(void)

Fonksiyonunu resetleme işlemi için kullanıyoruz.

void BEEP_Init(BEEP_Frequency_TypeDef BEEP_Frequency)

Fonksiyonu ile kullanacağımız frekansı aşağıdaki parametreleri kullanarak seçiyoruz.

typedef enum {
  BEEP_FREQUENCY_1KHZ = (uint8_t)0x00,  /*!< Beep signal output frequency equals to 1 KHz */
  BEEP_FREQUENCY_2KHZ = (uint8_t)0x40,  /*!< Beep signal output frequency equals to 2 KHz */
  BEEP_FREQUENCY_4KHZ = (uint8_t)0x80   /*!< Beep signal output frequency equals to 4 KHz */
} BEEP_Frequency_TypeDef;

void BEEP_LSICalibrationConfig(uint32_t LSIFreqHz)

Fonksiyonu LSI kaynağını kalibre için 32 bitlik tam sayı girilmesini ister. Bizim ekleme yapacağımız LSIMeasurment() fonksiyonu bu 32 bitlik parametrenin yerine gelecektir.

/**
  * @brief  Measure the LSI frequency using timer IC1 and update the calibration registers.
  * @note   It is recommended to use a timer clock frequency of at least 10MHz in order 
	*         to obtain a better in the LSI frequency measurement.
  * @param  None
  * @retval None
  */
uint32_t LSIMeasurment(void)
{

  uint32_t lsi_freq_hz = 0x0;
  uint32_t fmaster = 0x0;
  uint16_t ICValue1 = 0x0;
  uint16_t ICValue2 = 0x0;

  /* Get master frequency */
  fmaster = CLK_GetClockFreq();

  /* Enable the LSI measurement: LSI clock connected to timer Input Capture 1 */
  AWU->CSR |= AWU_CSR_MSR;

#if defined (STM8S903) || defined (STM8S103) || defined (STM8S003) || defined (STM8S001)
  /* Measure the LSI frequency with TIMER Input Capture 1 */
  
  /* Capture only every 8 events!!! */
  /* Enable capture of TI1 */
	TIM1_ICInit(TIM1_CHANNEL_1, TIM1_ICPOLARITY_RISING, TIM1_ICSELECTION_DIRECTTI, TIM1_ICPSC_DIV8, 0);
	
  /* Enable TIM1 */
  TIM1_Cmd(ENABLE);
  
  /* wait a capture on cc1 */
  while((TIM1->SR1 & TIM1_FLAG_CC1) != TIM1_FLAG_CC1);
  /* Get CCR1 value*/
  ICValue1 = TIM1_GetCapture1();
  TIM1_ClearFlag(TIM1_FLAG_CC1);
  
  /* wait a capture on cc1 */
  while((TIM1->SR1 & TIM1_FLAG_CC1) != TIM1_FLAG_CC1);
  /* Get CCR1 value*/
  ICValue2 = TIM1_GetCapture1();
  TIM1_ClearFlag(TIM1_FLAG_CC1);
  
  /* Disable IC1 input capture */
  TIM1->CCER1 &= (uint8_t)(~TIM1_CCER1_CC1E);
  /* Disable timer2 */
  TIM1_Cmd(DISABLE);
  
#else  
  /* Measure the LSI frequency with TIMER Input Capture 1 */
  
  /* Capture only every 8 events!!! */
  /* Enable capture of TI1 */
  TIM3_ICInit(TIM3_CHANNEL_1, TIM3_ICPOLARITY_RISING, TIM3_ICSELECTION_DIRECTTI, TIM3_ICPSC_DIV8, 0);

  /* Enable TIM3 */
  TIM3_Cmd(ENABLE);

	/* wait a capture on cc1 */
  while ((TIM3->SR1 & TIM3_FLAG_CC1) != TIM3_FLAG_CC1);
	/* Get CCR1 value*/
  ICValue1 = TIM3_GetCapture1();
  TIM3_ClearFlag(TIM3_FLAG_CC1);

  /* wait a capture on cc1 */
  while ((TIM3->SR1 & TIM3_FLAG_CC1) != TIM3_FLAG_CC1);
    /* Get CCR1 value*/
  ICValue2 = TIM3_GetCapture1();
	TIM3_ClearFlag(TIM3_FLAG_CC1);

  /* Disable IC1 input capture */
  TIM3->CCER1 &= (uint8_t)(~TIM3_CCER1_CC1E);
  /* Disable timer3 */
  TIM3_Cmd(DISABLE);
#endif /* (STM8S903) || (STM8S103) || (STM8S003) || (STM8S001) */

  /* Compute LSI clock frequency */
  lsi_freq_hz = (8 * fmaster) / (ICValue2 - ICValue1);
  
  /* Disable the LSI measurement: LSI clock disconnected from timer Input Capture 1 */
  AWU->CSR &= (uint8_t)(~AWU_CSR_MSR);

 return (lsi_freq_hz);
}

Buradan sonra kullandığımız buzzerın datasheetine göre kullanadığımız frekansı seçmek. Benim uygulama kullanacağım buzzer için bilgiler şu şekilde.

Ayrıca dosyayı buradan indirebilirsiniz.

/**
  ******************************************************************************
  * @file    Project/main.c 
  * @author  N7A TECHNIC
  * @brief   Main program body
   ******************************************************************************
  *        www.n7a.web.tr
  ******************************************************************************
  */ 
/*
PD4->Devresiz Buzzer
PD5->Devreli Buzzer
PD3->1KHz Butonu
PD2->2KHz Butonu
PD1->4KHz Butonu
PC7->Devreli Buzzer Butonu
*/
/* Includes ------------------------------------------------------------------*/
#include "stm8s.h"
#include "stm8s_clk.h"
#include "stm8s_gpio.h"
#include "stm8s_beep.h"
/* Private defines -----------------------------------------------------------*/
#define beepOut GPIOD,GPIO_PIN_4
#define dBuzzerOut GPIOD,GPIO_PIN_5
#define b1KHz GPIOD,GPIO_PIN_3
#define b2KHz GPIOD,GPIO_PIN_2
#define b4KHz GPIOD,GPIO_PIN_1
#define bDevBuzzer GPIOC,GPIO_PIN_7
#define LED GPIOB,GPIO_PIN_5
/* Private function prototypes -----------------------------------------------*/
uint32_t LSIMeasurment(void);
/* Private functions ---------------------------------------------------------*/
void main(void)
{
  /* Infinite loop */
  CLK_DeInit();
  CLK_HSECmd(DISABLE);
  CLK_LSICmd(ENABLE);
  CLK_HSICmd(ENABLE);
  while(CLK_GetFlagStatus(CLK_FLAG_HSIRDY)==0);
  CLK_ClockSwitchCmd(ENABLE);
  CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV1);
  CLK_SYSCLKConfig(CLK_PRESCALER_CPUDIV1);
  
  GPIO_Init(dBuzzerOut,GPIO_MODE_OUT_PP_LOW_FAST);
  GPIO_Init(b1KHz,GPIO_MODE_IN_PU_NO_IT);
  GPIO_Init(b2KHz,GPIO_MODE_IN_PU_NO_IT);
  GPIO_Init(b4KHz,GPIO_MODE_IN_PU_NO_IT);
  GPIO_Init(bDevBuzzer,GPIO_MODE_IN_PU_NO_IT);
  GPIO_Init(LED,GPIO_MODE_OUT_OD_HIZ_FAST);
  
  BEEP_DeInit();
  BEEP_LSICalibrationConfig(LSIMeasurment());
  BEEP_Cmd(DISABLE);
  while (1)
  {
    if(GPIO_ReadInputPin(b1KHz)==0)
    {
      GPIO_WriteLow(dBuzzerOut);
      BEEP_Init(BEEP_FREQUENCY_1KHZ);
      BEEP_Cmd(ENABLE);
      GPIO_WriteLow(LED);
    }
    else
    {
      if(GPIO_ReadInputPin(b2KHz)==0)
      {
        GPIO_WriteLow(dBuzzerOut);
        BEEP_Init(BEEP_FREQUENCY_2KHZ);
        BEEP_Cmd(ENABLE);
        GPIO_WriteLow(LED);
      }
      else
      {
        if(GPIO_ReadInputPin(b4KHz)==0)
        {
          GPIO_WriteLow(dBuzzerOut);
          BEEP_Init(BEEP_FREQUENCY_4KHZ);
          BEEP_Cmd(ENABLE);
          GPIO_WriteLow(LED);
        }
        else
        {
          if(GPIO_ReadInputPin(bDevBuzzer)==0)
          {
            BEEP_Cmd(DISABLE);
            GPIO_WriteHigh(dBuzzerOut);
            GPIO_WriteLow(LED);
          }
          else
          {
            GPIO_WriteHigh(LED);
          }
        }
      }
    }
  }
}
/**
  * @brief  Measure the LSI frequency using timer IC1 and update the calibration registers.
  * @note   It is recommended to use a timer clock frequency of at least 10MHz in order 
	*         to obtain a better in the LSI frequency measurement.
  * @param  None
  * @retval None
  */
uint32_t LSIMeasurment(void)
{
  uint32_t lsi_freq_hz = 0x0;
  uint32_t fmaster = 0x0;
  uint16_t ICValue1 = 0x0;
  uint16_t ICValue2 = 0x0;
  /* Get master frequency */
  fmaster = CLK_GetClockFreq();
  /* Enable the LSI measurement: LSI clock connected to timer Input Capture 1 */
  AWU->CSR |= AWU_CSR_MSR;
#if defined (STM8S903) || defined (STM8S103) || defined (STM8S003) || defined (STM8S001)
  /* Measure the LSI frequency with TIMER Input Capture 1 */
  
  /* Capture only every 8 events!!! */
  /* Enable capture of TI1 */
	TIM1_ICInit(TIM1_CHANNEL_1, TIM1_ICPOLARITY_RISING, TIM1_ICSELECTION_DIRECTTI, TIM1_ICPSC_DIV8, 0);
	
  /* Enable TIM1 */
  TIM1_Cmd(ENABLE);
  
  /* wait a capture on cc1 */
  while((TIM1->SR1 & TIM1_FLAG_CC1) != TIM1_FLAG_CC1);
  /* Get CCR1 value*/
  ICValue1 = TIM1_GetCapture1();
  TIM1_ClearFlag(TIM1_FLAG_CC1);
  
  /* wait a capture on cc1 */
  while((TIM1->SR1 & TIM1_FLAG_CC1) != TIM1_FLAG_CC1);
  /* Get CCR1 value*/
  ICValue2 = TIM1_GetCapture1();
  TIM1_ClearFlag(TIM1_FLAG_CC1);
  
  /* Disable IC1 input capture */
  TIM1->CCER1 &= (uint8_t)(~TIM1_CCER1_CC1E);
  /* Disable timer2 */
  TIM1_Cmd(DISABLE);
  
#else  
  /* Measure the LSI frequency with TIMER Input Capture 1 */
  
  /* Capture only every 8 events!!! */
  /* Enable capture of TI1 */
  TIM3_ICInit(TIM3_CHANNEL_1, TIM3_ICPOLARITY_RISING, TIM3_ICSELECTION_DIRECTTI, TIM3_ICPSC_DIV8, 0);
  /* Enable TIM3 */
  TIM3_Cmd(ENABLE);
	/* wait a capture on cc1 */
  while ((TIM3->SR1 & TIM3_FLAG_CC1) != TIM3_FLAG_CC1);
	/* Get CCR1 value*/
  ICValue1 = TIM3_GetCapture1();
  TIM3_ClearFlag(TIM3_FLAG_CC1);
  /* wait a capture on cc1 */
  while ((TIM3->SR1 & TIM3_FLAG_CC1) != TIM3_FLAG_CC1);
    /* Get CCR1 value*/
  ICValue2 = TIM3_GetCapture1();
	TIM3_ClearFlag(TIM3_FLAG_CC1);
  /* Disable IC1 input capture */
  TIM3->CCER1 &= (uint8_t)(~TIM3_CCER1_CC1E);
  /* Disable timer3 */
  TIM3_Cmd(DISABLE);
#endif /* (STM8S903) || (STM8S103) || (STM8S003) || (STM8S001) */
  /* Compute LSI clock frequency */
  lsi_freq_hz = (8 * fmaster) / (ICValue2 - ICValue1);
  
  /* Disable the LSI measurement: LSI clock disconnected from timer Input Capture 1 */
  AWU->CSR &= (uint8_t)(~AWU_CSR_MSR);
 return (lsi_freq_hz);
}
#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(u8* file, u32 line)
{ 
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* Infinite loop */
  while (1)
  {
  }
}
#endif
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

STM8 Programlama -IAR- #8 (BEEPER) yazısı ilk önce N7A Teknik üzerinde ortaya çıktı.

GPIO General-Purpose Input/Output türkçesi Genel Amaçlı Giriş/Çıkış kontrol edilebilir dijital sinyal pinleridir. Bu pinleri giriş ve çıkış olmak üzere iki durum için ayarlayarak kullanabiliriz.

Output için 2 pin konfigürasyonu mevcuttur bunlar;

• OD Open Drain
• PP Push-Pull
• PB4 ve PB5 Pini için True Open-Drain

Yukarıda GPIO Blok Diyagramı bulunmakta. Diyagramdaki kesik çizgili alanın içerisi GPIO pininin iç taraftaki bağlantı şeklini göstermektedir. OD,PP ve T (True Open-Drain) durumlarını açıklayalım;

• OD (Open Drain) ve T (True Open-Drain): pini OD olarak seçecek olursak pin alt taraftaki mosfetin drain ucuna bağlı olacak ve yukarıdaki mosfet devre dışı bırakılacaktır. Aslında yukarıdaki mosfet var fakat sanal olarak yoktur.
  True Open-Drainde ise üst taraftaki mosfet ve Pull-Ip direnci gerçekten yoktur. Dolayısıyla bu (T) pinlerinde Push-Pull ve Pull-Up seçenekleri seçilse bile fiziki olarak orada o malzemeler olmadığı için isteğimiz gerçekleşmeyecek (T) pinleri diğer GPIO pinleri gibi çalışmayacaktır. Her iki durumda da yük pine seri bağlanmalıdır. Bir LED çalıştıracağımızı var sayalım, pinin katodunu pine anodunu direnç ile + beslemeye bağlamalıyız. Yeterince açıklayıcı olduğu düşünerek PP’ye geçiyorum.

• PP (Push-Pull): Bu seçenekte ise pin çıkışı her iki mosfetin arasına bağlıdır. Dolayısıyla pinden Lojik 1 ve Lojik 0 sinyalini doğrudan alabiliriz. PP’u da aşağıdaki resim gibi düşünebiliriz.

Input için 2 pin konfigürasyonu mevcuttur bunlar;

• Floating
• WPU (Wake Pul-Up)

Pin input olarak kullanılacaksa blok diyagramdaki iki mosfet pasif konuma geçer ve pin doğrudan IDR(Input Data Register)’a gider. Aslında schmitt trigger’dan geçer fakat pin analog giriş olarak kullanılacağında schmitt trigger devreye alınabilir.

• Floating : İlgili pin float olarak konfigüre edilirse giriş sinyali doğrudan IDR’ye ulaşır. Bu durum daha pin analog giriş olarak kullanılacaksa ve girişin kararlı olduğu durumlarda kullanılır.
  Mesela ilgili pin bir entegre ile haberleşiyor olsun. Entegre çıkışı için iki durum olduğu için (Lojik 0 veya Lojik 1) bu pini float olarak kullanmakta bir sakınca yoktur.
• WPU :İlgili pinde blok diyagramda görünen pull-up direnci aktif edilir. Buda girişten okuyacağımız durumlar arasında kararsızlık varsa pini boşta bırakmamış olur.
  Mesela girişe bir buton bağlıysa bu seçenek kullanıldığında herhangi bir pul up direncine gerek kalmadan butonu pin ve GND arasına bağlayabiliriz.
  
  Ayrıca Giriş için ilgili pinde özellik mevut ise External Interrupt kullanmak mümkündür. Ext.Interruptı kısaca şöyle bilelim: İlgili pinde bu özellik aktif edilirse pinin lojik seviye değişim anlarında program stm8s_it.c dosyasındaki ilgili rutine yönlenir ve ilgili kodları işleyip ana döngüde kaldığı yerden devam eder.

Evet Çıkış durumlarını anladığımıza göre artık kod kısmına geçebiliriz.
Her zamanki gibi ilgili kütüphaneyi dahil etmeliyiz.

#include "stm8s_gpio.h"

Dahil ettikten sonra kullanacağımız portu GPIO_DeInit(GPIOx); fonksiyonu ile sıfırlayalım. GPIOx parametresinde x yerine MCU’da var olan herhangi bir port ismi olabilir bunlar; GPIOA,GPIOB,GPIOC,GPIOD.

GPIO_DeInit(GPIOA);

Şimdi GPIO_Init(); fonksiyonu ve parametrelerini inceleyelim.

GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef GPIO_Pin, GPIO_Mode_TypeDef GPIO_Mode);
// I.Parametre Değerleri GPIO_TypeDef* (GPIOx)
GPIOA
GPIOB
GPIOC
GPIOD

// II.Parametre Değerleri GPIO_Pin_TypeDef (GPIO_Pin)
GPIO_PIN_0 = ((uint8_t)0x01), /*!< Pin 0 selected */
GPIO_PIN_1 = ((uint8_t)0x02), /*!< Pin 1 selected */
GPIO_PIN_2 = ((uint8_t)0x04), /*!< Pin 2 selected */
GPIO_PIN_3 = ((uint8_t)0x08), /*!< Pin 3 selected */
GPIO_PIN_4 = ((uint8_t)0x10), /*!< Pin 4 selected */
GPIO_PIN_5 = ((uint8_t)0x20), /*!< Pin 5 selected */
GPIO_PIN_6 = ((uint8_t)0x40), /*!< Pin 6 selected */
GPIO_PIN_7 = ((uint8_t)0x80), /*!< Pin 7 selected */
GPIO_PIN_LNIB = ((uint8_t)0x0F), /*!< Low nibble pins selected */
GPIO_PIN_HNIB = ((uint8_t)0xF0), /*!< High nibble pins selected */
GPIO_PIN_ALL = ((uint8_t)0xFF) /*!< All pins selected */

// III.Parametre Değerleri GPIO_Mode_TypeDef; (GPIO_Mode)
GPIO_MODE_IN_FL_NO_IT      = (uint8_t)0x00,  /*!< Input floating, no external interrupt */
GPIO_MODE_IN_PU_NO_IT      = (uint8_t)0x40,  /*!< Input pull-up, no external interrupt */
GPIO_MODE_IN_FL_IT         = (uint8_t)0x20,  /*!< Input floating, external interrupt */
GPIO_MODE_IN_PU_IT         = (uint8_t)0x60,  /*!< Input pull-up, external interrupt */
GPIO_MODE_OUT_OD_LOW_FAST  = (uint8_t)0xA0,  /*!< Output open-drain, low level, 10MHz */
GPIO_MODE_OUT_PP_LOW_FAST  = (uint8_t)0xE0,  /*!< Output push-pull, low level, 10MHz */
GPIO_MODE_OUT_OD_LOW_SLOW  = (uint8_t)0x80,  /*!< Output open-drain, low level, 2MHz */
GPIO_MODE_OUT_PP_LOW_SLOW  = (uint8_t)0xC0,  /*!< Output push-pull, low level, 2MHz */
GPIO_MODE_OUT_OD_HIZ_FAST  = (uint8_t)0xB0,  /*!< Output open-drain, high-impedance level,10MHz */
GPIO_MODE_OUT_PP_HIGH_FAST = (uint8_t)0xF0,  /*!< Output push-pull, high level, 10MHz */
GPIO_MODE_OUT_OD_HIZ_SLOW  = (uint8_t)0x90,  /*!< Output open-drain, high-impedance level, 2MHz */
GPIO_MODE_OUT_PP_HIGH_SLOW = (uint8_t)0xD0   /*!< Output push-pull, high level, 2MHz */
}GPIO_Mode_TypeDef;

II. parametre değerlerinden GPIO_PIN_LNIB, GPIO_PIN_0……_1……_2……_3 pinlerini GPIO_PIN_HNIB, GPIO_PIN_4……_5……_6……_7 pinlerini, GPIO_PIN_ALL ise bütün pinleri seçeceğini söylemektedir.
III. parametrede dikkat etmemiz gerken bir durum SLOW ve FAST durumudur. Her pin bu özelliği taşımayabilir. Bu bilgiye datasheetden pin descriptions sayfasından ulaşılabilir. Sayfada Speed sütunu altında O1,O2….. gibi işaretler ilgili pinin hangi frekansa kadar çalışma sağlayabildiği hakkında geniş bilgiler vermektedir.
Diğer mikrodenetleyicelerde sıkça rastlanılmayan bir durum ise HIZ özelliğidir. Bu özellik ile pin yüksek empens konumuna alınır. Yerine göre oldukça kullanışlı olabiliyor.

Şimdi gpio kütüphanesindeki Output olarak seçtiğimiz pinler için kullanabileceğimiz fonksiyonlara göz atalım.

void GPIO_Write(GPIO_TypeDef* GPIOx, uint8_t PortVal);

void GPIO_WriteHigh(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef PortPins);
void GPIO_WriteLow(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef PortPins);
void GPIO_WriteReverse(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef PortPins);

PortPins yerine GPIO_PIN_0………..GPIO_PIN_7 parametrelerinden birisi gelmelidir.

Şimdi de gpio kütüphanesindeki Input olarak seçtiğimiz pinler için kullanabileceğimiz fonksiyonlara göz atalım.

uint8_t GPIO_ReadInputData(GPIO_TypeDef* GPIOx);
uint8_t GPIO_ReadOutputData(GPIO_TypeDef* GPIOx);
BitStatus GPIO_ReadInputPin(GPIO_TypeDef* GPIOx, GPIO_Pin_TypeDef GPIO_Pin);

GPIO_ReadInputData : GPIO giriş portunun tamamının verisini unsigned int değerinde geri döndüren foksiyon. Mesela mikrodenetleyicimizin A portunun tamamına giriş olarak seçili olsun(Zaten STM8S103F3’de A portuna ait 3 pin bulunmakta; PA1,PA2,PA3). Girişlerin tamamının Lojik 1 olduğunu varsayarsak GPIO_ReadInputData(GPIOA); fonksiyonu bize Hex Sayı sisteminde 0x0E değerini döndürecektir.
GPIO_ReadOutputData : Çıkışın Lojik seviye durumunu gösteren fonksiyon.
GPIO_ReadInputPin : Pinin okuma işlemini pin bazında geri döndüren fonksiyondur.

Aşağıdaki kod ile buton ile LED kontrol kodları bulunmaktadır. Kodların olduğu proje dosyasını buradan indirebilirsiniz. Umarım Faydalı olumuştur. Bir sonraki yazımızda görüşmek ümidiyle… Hoşçakalın.

/**
  ******************************************************************************
  * @file    Project/main.c 
  * @author  N7A TECHNIC
  * @brief   Main program body
   ******************************************************************************
  *        www.n7a.web.tr
  ******************************************************************************
  */ 


/* Includes ------------------------------------------------------------------*/
#include "stm8s.h"
#include "stm8s_clk.h"
#include "stm8s_gpio.h"
/* Private defines -----------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
void delay(uint32_t x);
/* Private functions ---------------------------------------------------------*/

void main(void)
{
  /* Infinite loop */

  CLK_DeInit();
  CLK_HSECmd(DISABLE);
  CLK_LSICmd(DISABLE);
  CLK_HSICmd(ENABLE);
  while(CLK_GetFlagStatus(CLK_FLAG_HSIRDY)==0);
  
  CLK_ClockSwitchCmd(ENABLE);
  CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV4);
  CLK_SYSCLKConfig(CLK_PRESCALER_CPUDIV1);
  
  GPIO_Init(GPIOB,GPIO_PIN_5,GPIO_MODE_OUT_OD_HIZ_FAST);
  GPIO_Init(GPIOD,GPIO_PIN_4,GPIO_MODE_OUT_PP_LOW_FAST);
  GPIO_Init(GPIOD,GPIO_PIN_5,GPIO_MODE_OUT_PP_LOW_FAST);
  
  GPIO_Init(GPIOA,GPIO_PIN_1,GPIO_MODE_IN_PU_NO_IT);
  while (1)
  {
    if(GPIO_ReadInputPin(GPIOA,GPIO_PIN_1) == 0)
    {
      GPIO_WriteHigh(GPIOD,GPIO_PIN_4);
      GPIO_WriteHigh(GPIOD,GPIO_PIN_5);
      GPIO_WriteLow(GPIOB,GPIO_PIN_5);
    }
    else
    {
      GPIO_WriteLow(GPIOD,GPIO_PIN_4);
      GPIO_WriteLow(GPIOD,GPIO_PIN_5);
      GPIO_WriteHigh(GPIOB,GPIO_PIN_5);
    }
  }
  
}

void delay(uint32_t x)
{
  while(x--);
}

#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(u8* file, u32 line)
{ 
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

  /* Infinite loop */
  while (1)
  {
  }
}
#endif


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

Teorik Eğitim:

Uygulama:

STM8 Programlama -IAR- #7 (GPIO-OD,PP,Float,WPU) yazısı ilk önce N7A Teknik üzerinde ortaya çıktı.

Mikrodenetleyicinin clock kaynağını (HSI) High-Speed dahili osilatör olarak seçeceğiz. Bu durumda Master Clock Switch f_HSIDIV olarak seçilmelidir. Bu kaynağın 4 adet ön bölücü değeri vardır. Bu değerler 16 MHz olan HSI osilatör kaynağını (/8/4/2/1) seçnekleri arasından seçeceğimiz değere böler ve bölünmüş clock f_MASTER hattına geçiş yapar. Şemadan da görüldüğü gibi TIMER,I2C,SPI,ADC,AWU,CAN,UART çevre birimleri bu hattan doğrudan beslenir. Dolayısıyla HSIDIV ön bölücü değerimizin sonucunda bu çevre birimlerinin clock kaynağının sağlandığını unutmayalım.
HSIDIV’i ayarladıktan sonra CPUDIV ön bölücü değeri için 8 seçenek mevcut (/1/2/4/8/16/32/64/128). CPUDIV ön bölücü değerine göre ise f_CPU frekansı belirlenmiş olur.

Örnek; Osilatör kaynağımız HSI (16MHz) olsun. HSIDIV=/2, CPUDIV=/4 olduğunu varsayalım.
O halde f_MASTER= 16/2 = 8 MHz olacaktır. Buda demek oluyor ki çevre birimlerinin çalışma frekansı ve CPUDIV giriş frekansı 8MHz’dir.

f_CPU = 8/4 = 2MHz olacaktır. Buda mikrodenetleyimizin çekirdeği 2MHz ile koşacağı anlamına gelir. Saniyede 2 milyon işlem yapabilir diyebiliriz.

Şimdi kod IAR derleyicisi için kodlarımıza geçelim. Öncelikle main.c dosyamızda stm8s_clk.h kütüphanesini dahil etmeliyiz.

#include "stm8s_clk.h"

Daha sonra kullanacağımız osilatör kaynağını aktif etmeliyiz (HSI).

CLK_HSECmd(DISABLE);
CLK_LSICmd(DISABLE);
CLK_HSICmd(ENABLE);

Osilatör hazır olana kadar, ilgili osilatörün bayrağı SET olana kadar CLK_GetFlagStatus(); fonksiyonundan aldığımız cevaba göre while dönüsü ile bekleme yapıyoruz. Fonksiyonun parametreleri şu şekildedir;

typedef enum {
CLK_FLAG_LSIRDY = (uint16_t)0x0110, /*!< Low speed internal oscillator ready Flag */
CLK_FLAG_HSIRDY = (uint16_t)0x0102, /*!< High speed internal oscillator ready Flag */
CLK_FLAG_HSERDY = (uint16_t)0x0202, /*!< High speed external oscillator ready Flag */
CLK_FLAG_SWIF = (uint16_t)0x0308, /*!< Clock switch interrupt Flag */
CLK_FLAG_SWBSY = (uint16_t)0x0301, /*!< Switch busy Flag */
CLK_FLAG_CSSD = (uint16_t)0x0408, /*!< Clock security system detection Flag */
CLK_FLAG_AUX = (uint16_t)0x0402, /*!< Auxiliary oscillator connected to master clock */
CLK_FLAG_CCOBSY = (uint16_t)0x0504, /*!< Configurable clock output busy */
CLK_FLAG_CCORDY = (uint16_t)0x0502 /*!< Configurable clock output ready */
}CLK_Flag_TypeDef;

Osilatör kaynağımız HSI olduğu için CLK_FLAG_HSIRDY seçmeliyiz.

while(CLK_GetFlagStatus(CLK_FLAG_HSIRDY) == 0);

Yukarıda bahsettiğimiz ön bölücü değerlerini ayarlıyoruz. Parametrelerin sonlarındaki rakamı yukarıdaki ilgili değerlerle değiştirerek istediğimiz çalışma frekansını elde edebiliriz.

CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV1); //fMASTER
CLK_SYSCLKConfig(CLK_PRESCALER_CPUDIV1); //fCPU

Clock ayarlarmaları için bir diğer durum ise CLK_ClockSwitchConfig() fonkisyonudur. Bu özellik mikrodenetleyici çalışıyorken clock kaynağını manuel veya otomatik değiştirmeye olanak sağlar. İşlem otomatik olarak seçilir ise; ana osilatörde herhangi bir problem oluşursa seçeceğimiz alternatif osilatör kaynağı devreye alınacak ve istersek ana osilatörü pasif edebileceğiz. Örnek fonksiyon ve parametre açıklamaları;

CLK_ClockSwitchConfig(CLK_SWITCHMODE_AUTO, CLK_SOURCE_HSI,
DISABLE, CLK_CURRENTCLOCKSTATE_ENABLE);
/**
  * CLK_SWITCHMODE_AUTO/_MANUEL : işlemin otomatik veya ellemi seçileceğini
  * CLK_SOURCE_HSI/_LSI/_HSE    : Alterantif olarak seçilecek kaynağı(yedek)
  * DISABLE/ENABLE : Otomatik veya manuel farketmeksizin böyle bir işlem 
  *gerçekleştiğinde kesme oluşmasını istiyorsak ENABLE olması gerekir.
  * CLK_CURRENTCLOCKSTATE_ENABLE/DISABLE : İşlem gerçekleşirse ana kaynağı 
  *pasif konuma getireceksek DISABLE seçmeliyiz.
  */

Değinmek istediğim bir diğer nokta ise bu kütüphanedeki CCO (Configurable Clock Output) özelliğidir. Bu özelliklik ile birlikte mikrodenetleyicinin ilgili pininden (PC4/CLK_CCO) aşağıdaki seçeneklerden istediğimiz clock sinyalini elde edebiliriz. Geliştirdiğimiz sistemde herhangi bir osilatör kaynağına ihtiyaç duymamız halinde bu özelliği kullanabiliriz. Ayrıca ilgili osilatör kaynağı freknasını CCO ile gözlemlemek mümkündür.

typedef enum {
  CLK_OUTPUT_HSI      = (uint8_t)0x00, /*!< Clock Output HSI */
  CLK_OUTPUT_LSI      = (uint8_t)0x02, /*!< Clock Output LSI */
  CLK_OUTPUT_HSE      = (uint8_t)0x04, /*!< Clock Output HSE */
  CLK_OUTPUT_CPU      = (uint8_t)0x08, /*!< Clock Output CPU */
  CLK_OUTPUT_CPUDIV2  = (uint8_t)0x0A, /*!< Clock Output CPU/2 */
  CLK_OUTPUT_CPUDIV4  = (uint8_t)0x0C, /*!< Clock Output CPU/4 */
  CLK_OUTPUT_CPUDIV8  = (uint8_t)0x0E, /*!< Clock Output CPU/8 */
  CLK_OUTPUT_CPUDIV16 = (uint8_t)0x10, /*!< Clock Output CPU/16 */
  CLK_OUTPUT_CPUDIV32 = (uint8_t)0x12, /*!< Clock Output CPU/32 */
  CLK_OUTPUT_CPUDIV64 = (uint8_t)0x14, /*!< Clock Output CPU/64 */
  CLK_OUTPUT_HSIRC    = (uint8_t)0x16, /*!< Clock Output HSI RC */
  CLK_OUTPUT_MASTER   = (uint8_t)0x18, /*!< Clock Output Master */
  CLK_OUTPUT_OTHERS   = (uint8_t)0x1A  /*!< Clock Output OTHER */
} CLK_Output_TypeDef;

CCO’yu kullanabilmek için ilgili CLK_CCO pin konfigürasyonunu (STM8S103F3 için PC4 pini) input pull-up veya output push-pull moduna getirmeliyiz (push-pull,pull-up için buraya).

CLK_CCOConfig(CLK_OUTPUT_CPU);
CLK_CCOCmd(ENABLE);

PC4 pini için gerekli ayarlamayı yaptıktan sonra PC4 pininden CPU çalışma frekansındaki sinyali almış olacağız.

Konuyu şöyle bir toparlarsak….. Yapacağımız uygulamalarda kartımızın üzerinde harici bir kristal osilatör olmadığı için dahili HSI osilatörü kullanacağız. Bu osilatör kaynağı ile ilgili bir ön yargınız/şüpheniz olmasın bu birim gayet sağlıklı çalışmaktadır. Buna göre ilerideki uygulamalarda kullanabileceğimiz bir clock ayarı için kodumuz şöyle olur;

CLK_DeInit();	
CLK_HSECmd(DISABLE);
CLK_LSICmd(DISABLE);
CLK_HSICmd(ENABLE);
while(CLK_GetFlagStatus(CLK_FLAG_HSIRDY) == 0);

CLK_ClockSwitchCmd(ENABLE);
CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV2);
CLK_SYSCLKConfig(CLK_PRESCALER_CPUDIV1);

Bu kodu void main(void) döngüsünün hemen altına yazarak kullanabiliriz.

Aşağıda CLK_CCO ya ait uygulamanın kodları bulunmaktadır. Ayrıca proje dosyasını buradan indirebilirsiniz.

/**
  ******************************************************************************
  * @file    Project/main.c 
  * @author  N7A TECHNIC
  * @brief   Main program body
   ******************************************************************************
  *        www.n7a.web.tr
  ******************************************************************************
  */ 

/* Includes ------------------------------------------------------------------*/
#include "stm8s.h"
#include "stm8s_clk.h"
#include "stm8s_gpio.h"

/* Private defines -----------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/

void main(void)
{
  /* Infinite loop */
  CLK_DeInit();
  CLK_HSECmd(DISABLE);
  CLK_LSICmd(DISABLE);
  CLK_HSICmd(ENABLE);
  
  while(CLK_GetFlagStatus(CLK_FLAG_HSIRDY)==0);
  
  CLK_ClockSwitchCmd(ENABLE);
  CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV4);
  CLK_SYSCLKConfig(CLK_PRESCALER_CPUDIV2);
  
  GPIO_Init(GPIOC,GPIO_PIN_4,GPIO_MODE_OUT_PP_LOW_FAST);
  
  CLK_CCOConfig(CLK_OUTPUT_CPU);
  CLK_CCOCmd(ENABLE);
  
  while (1)
  {
  }
}

#ifdef USE_FULL_ASSERT

void assert_failed(u8* file, u32 line)
{ 
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

  /* Infinite loop */
  while (1)
  {
  }
}
#endif


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

Teorik Eğitim:

Uygulama:

STM8 Programlama -IAR- #6 (Clock Ayarları) yazısı ilk önce N7A Teknik üzerinde ortaya çıktı.

Özelliklere kısaca madde madde değinelim.

• Çekirdek çalışma frekansı 16 MHz olan olan MCU ‘nun 8KByte Flash belleği ile 640 Byte EEPROM(Electronically Erasable Programmable Read-Only Memory / Verileri kalıcı olarak saklayabildiğimiz depolama alanıdır) depolama alanı bulunuyor.
• RAM(Random Access Memory-Rastgele Erişimli Bellek): 1 Kbyte
• 2,95 — 5,5 V çalışma gerilimi.
• Harici kristal osilatör bağlantı seçeneğine ek olarak dahili RC(Resistor-Capacitor) osilatör bulunmaktadır.
  >1-16 MHz high-speed external crystal (HSE)
  >16 MHz high-speed internal RC oscillator (HSI)
  >128 kHz low-speed internal RC (LSI)
  >1-16 MHz high-speed external crystal (HSE)
• Düşük güç modları (wait, active-halt, halt)
• Çevre birimlerinin clocklarını ayrı ayrı kapatabilmek.
• Toplamda 6 vektörde 27 harici kesme;
  SPI,UART,ADC,GPIO portları, Timer….. gibi çevre birimleri için.
• 10 Bit ADC
• Donanımsal UART,SPI,I2C haberlerşme arayüzleri.
• Kullanacağımız MCU’nun 20 pinden 16’sı I/O olarak ayarlanabilmekte ve bu pinlerin 12’si HS(High Sink IO)’dur (20mA’e kadar).

TIMER-Zamanlayıcılar

• Zamanlayıcılar MCU’nun rutin bekleme işlem yüklerini azaltan yapılardır. 7Segment, PWM,Zaman gibi uygulamalarda kullanılır.
• TIM1 – 16-bit Gelişmiş Kontrollü Zamanlayıcı
• TIM2 – 16-bit Genel Amaçlı Zamanlayıcı
• TIM4 – 8-bit Temel Zamanlayıcı

• Şuanlık isimlerini ve tablodaki bilgilere aşina olmak bize fazlasıyla yetecektir.

Beeper

Sesli ikazlar için içerisinde rezonatör devresi olmayan buzzerları kullanmaya olanak sağlar. Hani şu 5V verince doğrudan öten kulakları tırmalayan buzzerlar varya, heehhhh işte, onların 5V’a bağlayınca çalışmayanlarını çalıştırmak için kullanıyoruz bu özelliği 🙂 .

ADC Analog-to-Digital Converter (ADC1)

• Analog sinyalleri MCU’nun anlayacağı bilgilere çeviren birimdir. Mesela NTC ile sıcaklık ölçmek istediğimizde kullancağız.
• Giriş gerilim aralığı 0–>VDD gerilimi kadardır.
• Veriyi 14 clock cycles çevirme zamanı vardır.

PINOUT

• HS High Sink kabiliyetli pinleri
• (T) True open drain (GPIO bölümünde açıklayacağım.)
• [ ] Alternatif pin seçeneği için kullanılır (remapping option)
  Bunu IAR’da MCU’nun ilgili AFR(Alternate Function Remap) bitlerini değiştirerek sağlayacağız. Olay kısaca şöyle; örnek olarak PD2 pinini alırsak normal pin tanımı AIN3(Analog in ch3)’tür. Biz bu pini TIM2_CH3 özelliği ile kullanacaksak ilgili AFR bitinin değerini değiştireceğiz.
• MCU çalışabilmesi için Vcap pinine bağlı bir kondansatöre ihtiyaç duyar. Kondansaörün sığa aralığı ise aşağıdaki gibidir.

Memory Map

Burada Hafıza Adreslerinin başlangıç ve bitiş değerleri yazmakta. Mesela EEPROM’un ilk Byte’ına veri yazmak için 0x004000 adresini kullanmalıyız.

Evet mikrodenetleyiciyi genel hatlarıyla tanıdık. Devamında IAR programını inceleyip proje yapısına göz attıktan sonra ilk kodumuzu yazacağız. Bir sonraki yazıda görümek üzere.

STM8 Programlama -IAR- #4 (Mikrodenetleyici ile Tanışıyoruz) yazısı ilk önce N7A Teknik üzerinde ortaya çıktı.

IAR Embedded Workbench

Kodlarımızı IAR ile geliştireceğiz. Programın deneme sürümü olarak iki seçeneği mevcut. Birincisi 30 gün deneme süresi olan full versiyon diğeri ise 8 KByte kod limiti olan seçenektir. Bu tercihi kurulum esnasında seçiyoruz. Eğitim videomuzda kullanacağımız mikrodenetleyici 8KByte Flash belleğe sahip olduğu için bir sıkıntı olmayacaktır. Bu seçeneği seçerek kurulum yapmalıyız. 8 KByte’a takılmayınız başlangıç için çok iyi bir değer. 8 KByte ile neler yapılır neler…. 🙂
İlgili Programı indireceğiniz web sitesine buradan erişebilirsiniz.
Web sitesine giriş yaptığınızda STM8 e tıklayarak programı indirebilirsiniz.

STM8S/A Standard Peripheral Library

Kodlarımızı yazarken Standart Periphreal Library kullancağız. Dosyayı içerisinde örnek proje sayfası ve temel çevre birimleri için yazılmış kütüphane ve çevre birimlerinini çalıştırabileceğimiz taslak kodlar bulunmaktadır. Yeni örnek uygulamalar yazarken template proje dosyasını kopyala/yapıştır yöntemi ile çoğaltarak kullanacağız yani IAR ile proje dosyası oluşturma kısmına değinmeyeceğiz. Gerekirse programlama serisinin ilerleyen videolarında bu hususa değinebiliriz.
İlgili dosyaya buradan erişebilirsiniz.
Kütüphaneyi indirmek için ST’nin sayfasına üye olmanız gerekmetedir.

STM8 STUDIO

Yazdığımız kodları çalıştırırken içerideki değişkenlere neler olup bittiğini bilmek elbette hakkımız 🙂 Bu durum için Real-Time olarak verilere erişmemizin bir yolu bu programı edinmemizdir. Diğer seçenek ise IAR ile debug yaparak Live Watch gibi pencerelerden verileri takip etmektir. Her iki seçenekte de SWIM pinini (PD1) başka bir durum için kullanmayı önermiyorum.
İlgili dosyaya buradan erişebilirsiniz.
Programı indirmek için ST’nin sayfasına üye olmanız gerekmetedir.

Logic Analyzer

PWM/SPI/UART gibi çevre birimlerinin çıkışlarını inceleyebilmemiz için kullanacağızımız bu program oldukça başarılıdır. Kaydını yaptığımız verinin ıncığını cıncığını çıkartana kadar inceleme fırsatı sağlar (Timing, High/Low Sayıları vs…..) 🙂
İlgili dosyaya buradan erişebilirsiniz.

USB –> TTL

Daha evvel Arduino veya bu işler ile uğraştıysanız muhtemelen driver konusunda problem yaşamayacaksınızdır. Her ihtimale karşı indirme linklerini koyayım. USB TTL çeviriciyi PC’ye bağladığınızda ve aygıt yöneticisinden baktığınızda herhangi bir problem görünmesi durumunda IC’nize göre driver yüklemeniz gerekecektir.
Gerekirse ileride bu konuya da değinebiliriz.

CH340 USB to TTL driver için gerekli dosyayı buradan indirebilirsiniz.

FT232 USB to TTL driver için gerekli dosyayı buradan indirebilirsiniz.

PL2303 USB to TTL driver için gerekli dosyayı buradan indirebilirsiniz.

STM8 Programlama -IAR- #3 (Yazılımsal Araçlar) yazısı ilk önce N7A Teknik üzerinde ortaya çıktı.

STM8S103 Board

ST firmasının geliştirmiş olduğu 8 bitlik mikrodenetleyici ailesinin TSSOP 20 kılıfını barındıran boardın alt tarafında AMS117-3.3 LDO (Low Dropout LDO; besleme voltajı çıkış voltajına çok yakın olsa bile çıkış voltajını ayarlayabilen bir DC voltaj regülatörüdür) Regüle entegresi bulunmaktadır.

STM8S103F3 mikrodenetleyicisinin çalışma gerilimi 2.95 to 5.5 V aralığında olduğu için programlama pinlerindeki 3V3 yazan kısımdan 5V uygulanmasında bir sakınca yoktur. Fakat 5V pini Regüle Entegresinin giriş ucuna bağlı olduğu için bu pinden 5V uygulanması mikrodenetleyicinin 5V’da çalıştığı anlamına gelmez.

Board üzerinde iki adet LED bulunmaktadır. Bunlardan PWR olan besleme geriliminin varlığını, TEST ise GPIOB Pin4 (PB4) pininin çıkış durumunu temsil eder.

RST Butonu ise mikrodenetleyicinin NRST pinine bir Pull-Up direnci ile birlikte bağlıdır. Buda mikrodenetleyicinin resetlenmesi için Lojik 0 konuma gitmesi gerektiğini gösterir.
PB5 pininin sol tarafında D4 olarak görünen pin B4 pinidir. Sanırım çinli arkadaşlarda bir hata olmuş 🙂

ST-Link/V2

ST-Link/V2 vasıtasıyla yazdığımız kodları mikrodenetleyiciye yükleriz. İlgili ürünle hem STM32 hemde STM8 mikrodenetleyicilere yazılım yüklenebiliyor. Eğitim serimizde gerilim pinlerine ek olarak SWIM ve NRST pinlerini kullanacağız. Bu arada IAR (IAR EMbedded Workbench kodlarımızı yazacağımız program) kullanırken herhangi bir ayrı programa gerek duymaksızın derlenmiş kodlarımızı IAR içerisinden tek tuşla mikrodenetleyicimize yükleyebileceğiz.

USB-TTL

Mikrodenetleyicinin UART (Universal Asynchronous Receiver Transmitter-Evrensel asenkron alıcı-verici) pinlerinden PC’ye veri alış verişini sağlayan arkadaşımızdır. Hatta eğitimin ilerleyen aşamalarında kankamız bile olabilir 🙂

Logic Analyzer

Mikrodenetleyici çıkışlarının, standart multimetreler ile ölçemeyecek kadar hızlı lojik seviye değişimi esnasında olan bitenden haber olmak için kullanıyoruz. Ancak 0-5V aralığındaki lojik seviyeleri ölçer ve PC yazılımı vasıtasıyla analiz olanağı sağlar.

Evet kullanacağımız donanımlar hakkında kısaca bilgi edindiğimize göre bir sonraki yazımıza kullanacağımız yazılım araçları hakkında bilgi almak edinmek için geçebiliriz.

STM8 Programlama -IAR- #2 (Donanımsal Araçlar) yazısı ilk önce N7A Teknik üzerinde ortaya çıktı.

STM8 Programlama -IAR- #1 (Giriş) yazısı ilk önce N7A Teknik üzerinde ortaya çıktı.