Arkadaşlar STM32F107 ile led yakıp söndürmeye çalışıyorum. Uğraşa uğraşa öğreneceğim.
Bu işlemcide giriş çıkış işlemlerinin nasıl yapılacağını çözemedim.
STM32F107 de GPIO işlemleri için birçok register var.
GPIOX_CRL
GPIOX_CRH
GPIOX_IDR
GPIOX_ODR
GPIO_BSSR
GPIO_BRR
Bu registerlerin her bri farklı bir amaca hizmet ediyor. Bunlar nelerdir. Hangi durumlarda kullanıması gerekiyor
Alışmışız tabi Piclere, Bi TrisX Birde PORTX ile işi bitiriyorduk. Bunları inceleyince epeyce bi afalldım. :o
Ben sağdan soldan kopya çekerek PE8 'e bağlı ledi yakıp söndürecek bir bir program hazırladım.
/******************************************************************************/
#include <stm32f10x_cl.h>
int main (void) {
int d;
SystemInit();
/* Setup GPIO for LEDs */
RCC->APB2ENR |= 1 << 6; /* Enable GPIOE clock */
GPIOE->CRH = 0x33333333; /* Configure the GPIO for LEDs */
while (1)
{
GPIOE->BSRR = 0x0100;
for (d = 0; d < 1000000; d++);
GPIOE->BSRR = 0x0000;
for (d = 0; d < 1000000; d++);
}
}
Burada yanmasını isediğim led yanıyor fakat sönmüyor. Acaba Söndürmek için PE8'e 0 yüklemek yetmiyormu, Başka neler yapmam gerekiyor. Açıklarsanız sevinirim.
IDR -> PORT
ODR -> LAT
CRL ve CRH da giriş (analog, dijital, vs.) ve çıkış (push-pull, open drain, vs.) ayarlamaları için. Reference manual'da 156. sayfada bir tablo var. BSRR ve BRR'yi şimdilik boşverin. Reference manual sürekli yanınızda olsun; ikinci monitor varsa orada, yoksa çıktı alıp masada dursun :).
BSRR yerine ODR kullan.
STM32F107 nin manualini 3 cilt olarak çıktı aldım. Devamlı masamda duruyor.
Galiba çözdüm sorun düzelti. Şimdi çalışıyor
GPIOX_BSSR Registeri 32 bitlik, ilk 16 bit Herhangi bir pini set etmek için kullanılıyor, Diğer yüksek 16 bit ise herhangi bir pini resetlemek için kullanılıyor. Yüksek 16bitte resetlenmesini istediğin pine 1 yazıyorsun. 0 yazmanın bir etkisi yokmuş
Klein hocam ODR ye baktım şimdi. Bu daha kolaymış. Set etmek istediğin pine 1 yazman yeterli, Resetlemek için 0 yazılması gerekiyor
Arakdaşlar Keilde Daha önce yapılmış bir projeyi açtığımda kodlar ekrana gelmiyor. Ama bu halde iken Kodu derleyebiliyor hatta mcu ya yükleyebiliyorum. Yazılan kodlar neden editöre gelmiyor?
Sol taraftaki "Project" penceresinde dosyalar gözükmüyor mu?
Her seferinde Project sekmesinden open project diyip klasörü bulup editöre getirmem gerekiyor.
Arkadaşlar Tekrardan merhaba.
Bugün birikmiş sorularımı sizlere sormak istiyorum
Ara Ara yine ARM ye bakıyorum. Şimdiye kadar hep yazılmış programlar üzerinde oynama yaparak istediğim Yapıyordum. Şimdi birazdaha farklı şeyler yapmak istiyorum ama başlamadan önce bazı bilmek istediklerim var.
Programcılık mantığında çok eksiğim var daha ARM üzerinde çalışırken bu işi nasıl yaparsın dediklerinde şimdilik pek bir cevap veremiyorum. Zamanla olacak bir iş.
Benim anlamadığım konular var. Şimdi Elimde 2 adet deney kartı var. Bu deney setleri üzerinde çalışıyorum. Bi tanesi EX33DS Diğeri İse MCBSTM32C deney kartı.
İki Deney kartınında örnek kodları var. Fakat yazım şekilleri farklı.
Şöyle benim yapmak istediğim şey Mikroişlemcinin Datasheedini açayım bana hangi register lazımsa o register üzerine direk erişebilmek istiyorum. Aynen Piclerde Pinleri giriş çıkış yapmak gibi düşünün (trisa=0x00 gibisinden)
Mesela STM32C deney kartında öyle yapılıyor.
Örnek bir kod mesela.
#include <stm32f10x_cl.h>
int main (void) {
int d;
/* Setup GPIO for LEDs */
RCC->APB2ENR |= 1 << 6; /* Enable GPIOE clock */
GPIOE->CRH = 0x33333333; /* Configure the GPIO for LEDs */
GPIOA->CRL = 0X33333333;
while (1)
{
GPIOA->ODR = 0x0001;
for (d = 0; d < 1000000; d++);
GPIOA->ODR = 0x0000 ;
for (d = 0; d < 1000000; d++);
}
}
Diğer Yandan EX33DS Deney kiti için örnek programları incelediğimde biraz farklı tarafları var.
Bu kodları Coşkun Bey hazırlamış
#include "main.h"
#include "lcd.h"
/******************************************************************************/
u8 i=0,j=10,animasyon=0;
static vu32 TimingDelay;
void RCC_Configuration(void);
void NVIC_Configuration(void);
void DelayMs(vu32 nTime);
/*******************************************************************************/
int main(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
/* System Clocks Configuration */
RCC_Configuration();
/* TIM1 clock enable */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
/* GPIO clock Configuration */
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA|
RCC_APB2Periph_GPIOB|
RCC_APB2Periph_GPIOC|
RCC_APB2Periph_GPIOD|
RCC_APB2Periph_GPIOE, ENABLE);
/* NVIC Configuration */
NVIC_Configuration();
/* GPIO Pin Configuration */
GPIO_InitStructure.GPIO_Pin = 0xFFFF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_Init(GPIOD, &GPIO_InitStructure);
GPIO_Init(GPIOE, &GPIO_InitStructure);
/* TIM1 ayarlari */
TIM_TimeBaseStructure.TIM_Period = 65535;
TIM_TimeBaseStructure.TIM_Prescaler = 0;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);
/* TIM1 güncelleme kesmesi aktif */
TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE);
/* TIM1 sayici aktif */
TIM_Cmd(TIM1, ENABLE);
/* SysTick clock 1ms için 4MHz (HCLK/8, default) */
SysTick_SetReload(4000);
/* SysTick Kesmesi Aktif */
SysTick_ITConfig(ENABLE);
lcd_init();
lcd_yaz(" LED Uygulaması");
lcd_gotoxy(2,1);
lcd_yaz("www.ExpKits.com");
while (1)
{
while(!i);
GPIO_Write(GPIOD,0x00FF);
DelayMs(2*i);
GPIO_Write(GPIOD,0x0000);
GPIO_Write(GPIOE,0x00FF);
DelayMs(2*i);
GPIO_Write(GPIOE,0xFF00);
DelayMs(2*i);
lcd_gotoxy(2,17);
GPIO_Write(GPIOE,0x0000);
GPIO_Write(GPIOD,0xFF00);
DelayMs(2*i);
GPIO_Write(GPIOD,0x0000);
GPIO_Write(GPIOA,0x00FF);
DelayMs(2*i);
GPIO_Write(GPIOA,0xFF00);
GPIO_Write(GPIOB,0x00FF);
DelayMs(2*i);
GPIO_Write(GPIOA,0x0000);
GPIO_Write(GPIOB,0xFF00);
DelayMs(2*i);
GPIO_Write(GPIOB,0x0000);
GPIO_Write(GPIOC,0x00FF);
DelayMs(2*i);
GPIO_Write(GPIOC,0x0000);
}
}
/*******************************************************************************/
void RCC_Configuration(void)
{
/* RCC system reset(for debug purpose) */
RCC_DeInit();
/* HSE kapali */
RCC_HSEConfig(RCC_HSE_OFF);
/* Prefetch Buffer aktif */
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
/* Flash ulasimi 2 clock */
FLASH_SetLatency(FLASH_Latency_2);
/* HCLK = SYSCLK */
RCC_HCLKConfig(RCC_SYSCLK_Div1);
/* PCLK2 = HCLK */
RCC_PCLK2Config(RCC_HCLK_Div1);
/* PCLK1 = HCLK/2 */
RCC_PCLK1Config(RCC_HCLK_Div2);
/* PLLCLK = (8MHz(internal osc)/2) * 8 = 32 MHz */
RCC_PLLConfig(RCC_PLLSource_HSI_Div2, RCC_PLLMul_8);
/* PLL Aktif */
RCC_PLLCmd(ENABLE);
/* PLL hazir olmasini bekle */
while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
/* System clock kaynagi PLL cikisi secildi */
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
/* System clock kaynagi hazir olmasini bekle */
while(RCC_GetSYSCLKSource() != 0x08);
}
/*******************************************************************************/
void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
#ifdef VECT_TAB_RAM
/* Vectör kaynagi adresi: 0x20000000 */
NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
#else /* VECT_TAB_FLASH */
/* Vektör kaynagi adresi: 0x08000000 */
NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);
#endif
/* TIM1 güncellenme kesmesi tanitildi */
NVIC_InitStructure.NVIC_IRQChannel = TIM1_UP_IRQChannel;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
/*******************************************************************************/
void Timer1_Kesmesi(void)
{
if(j==10){
/* led animasyonu degisiyor */
animasyon++;
switch(animasyon){
case 1:i=50;j=0;break;
case 2:i=1; j=3;break;
case 3:i=0; j=9;break;
case 4:i=1; j=9;break;
case 5:i=0; j=9;break;
case 6:i=1; j=9;break;
case 7:i=0; j=9;break;
case 8:i=2; j=0;break;
case 9:i=0; j=9;break;
default:animasyon=0;break;
}
}
else j++;
}
/*******************************************************************************/
void DelayMs(u32 nTime)
{
/* SysTick Counter aktif */
SysTick_CounterCmd(SysTick_Counter_Enable);
TimingDelay = nTime;
while(TimingDelay != 0);
/* SysTick Counter Pasif */
SysTick_CounterCmd(SysTick_Counter_Disable);
/* SysTick Counter temizlenir */
SysTick_CounterCmd(SysTick_Counter_Clear);
}
/*******************************************************************************/
void TimingDelay_Decrement(void)
{
if (TimingDelay != 0x00)
{
TimingDelay--;
}
}
/*******************************************************************************/
Bu Benim kafamı çok karıştırdı açıkçası. Burada bilmediğim birçok şey var. İkisi arasında fark nedir acaba bilmek istiyorum.
Birde şunu öğrenmek istiyorum.
Basit bir led yak söndür programı için İşlemcinin configürasyon ayarlarını nasıl yapacağımı bilmiyorum. Özellikle bunu öğrenmeye çok ihtiyacım var. Mesela MCBSTM32C deney seti üzerinde 25Mhz kare kristal var. EX33DS üzerinde ise 8 mhz. Bu frekanslarda işlemcileri düzgün çalıştırmam için hangi ayarları yapmam gerekiyor.
Son bir sorum daha var.
Dediğim gibi daha önce hep başkasının yazdığı programlar üzerinde oynayara en azından işin nasıl işlediğini örenmeye çalışıyordum. Şimdi ben kendim yeni bir proje oluşturmak istiyorum. Basit bir led yak söndür programı yazmak için Proje dosyasını nasıl oluşturacağım Programa hangi dosyaları ekliyecem bunları bilmiyorum. Bu konularda beni aydınlatırsanız sevinirim. Girdik bir yola dönüş yok. Öğrenicem bu işi :)
Hocam İlk kodta ( STM32C deney kartın ) her seyi kullanıcı kendi yapıyor.
Yani Datasheeti acıp bakarak yazıyor. ( Bunalmış hocamızın STM32F407 Discovery kartında yaptıgı gibi )
Diğer EXD33 ( Coşkunun ) kodu ise hazır kutuphane kullanılarak yazılmıştır.
Hazır kutuphane derkende st'nin kendi kutuphanesi
İlgili link:
http://www.st.com/internet/mcu/product/221020.jsp (http://www.st.com/internet/mcu/product/221020.jsp)
FIRMWARE başlığı altındaki
STM32F10x standard peripheral library
dosya
dosya icinde orneklerde mevcut.
Hangisini kullanayım dersen kişiye göre değişir.
Bende STM32F107 ve STM32F407 Discovery kart uzerinde calışmalar yapıyorum. Şimdilik ben firmware kullanıyorum.
Peki hocam ileriye dönük konuşursak hangisi iyidir. Kütüphane kullanarak hazır komutlar yardımıylamı yazmak iyidir. Yoksa Herşeyi datasheede bakarak direk registerler ile iletişim halinde yürütmekmi iyidir. Şuanda ben hangisi iyi olduğuna bakmıyorum aslında hangisi daha çabuk öğrenirim daha çabuk alışırım Hangisinde kod yazmak daha kolay ona bakıyorum.
Hocam birde dediğiniz STM32F107 kütüphanesini indirdim. Bunu eklememmi gerekiyor keil klasörünün içinemi atacağım. Tam olarak ne yapmam gerekiyor.
Firmware ile yapılan kodlar da geliştirme ürünü piyasaya sürme süreci hızlıdır. Zaten firmalar bu süreci hızlandırmak için register lar ile kullanıcıları boğmamak için bu yazılımları üretirler. Bu firmware lerin yaptığı zaten sizin için register lara ulaşır ve gereken kodları yüklerler. Bu bir harmoni içinde gerçekleşir. Örneklerde yeralan herşeyi firmware kullanarak yaptınız kolcayca oldu kesme, pwm, dma,gpio,adc, dac her örneği denediniz anladınız. Bu örneklerden hareketler yeni birşeyler yapabilirsiniz. lcd sürersiniz kontrol pid birçok şeyi hızlıca yaparsınız. Ancak örneklerde olmayan spesifik bir kod yazmak gerektiğinde parçaları birleştirmek zorunluğu ortaya çıkar bazan bu birleştirme işlemini sadece firmware ler üzerinden yapamayabilirsiniz.
Örneğin bir 3 faz motor kontrol uygulaması yapacaksınız firmware de yer alan hazr örnekler yeterli olmayacak register lara dalıp onlarca kontrol seçeneğinden en uygununu seçmeye zorlanacaksınız...
Çinliler ilk stm32 serileri çıktığında register larla uğraşarak kodlar yazardı. O tip kodlar bug üretmeye ve sorun çıkarmaya daha çok adaydır uzun kodlarda muhakkak gözden kaçan birşeyler vardır. Sonra onlarda firmware tabanlı kodlarla çalışmayı standart haline getirdiler.
Alıntı yapılan: Mucit23 - 05 Nisan 2012, 11:24:27
Peki hocam ileriye dönük konuşursak hangisi iyidir. Kütüphane kullanarak hazır komutlar yardımıylamı yazmak iyidir. Yoksa Herşeyi datasheede bakarak direk registerler ile iletişim halinde yürütmekmi iyidir. Şuanda ben hangisi iyi olduğuna bakmıyorum aslında hangisi daha çabuk öğrenirim daha çabuk alışırım Hangisinde kod yazmak daha kolay ona bakıyorum.
Zaman ve cabuk öğrenme olarak bakarsak bence hazır firmware kutuphanesini kullanmak gerekir.
İlerde belli bir seviyeye geldin mi kendin de kendi kutuphaneni yazarsın. Bu benim düşüncem.
Çünkü zaman önemli ve bir an önce öğrenmek lazım.
Alıntı yapılan: Mucit23 - 05 Nisan 2012, 11:24:27
Hocam birde dediğiniz STM32F107 kütüphanesini indirdim. Bunu eklememmi gerekiyor keil klasörünün içinemi atacağım. Tam olarak ne yapmam gerekiyor.
Hocam burası biraz karısık ;) Keilin icine aktarmayacaksınız.
Her projede yapmanız gereken.
STM32F10x_StdPeriph_Lib_V3.5.0
klasoru icine girip icindeki klasorleri kendi yapacagınız proje klasoru icine bire bir kopyalamak olacaktır.
Ornek: LedYak diye klasor actınız
LedYak\ klasoru icine
Libraries
Projects
Utilities klasorlerini kopyalayın.
Sonra
Projects\STM32F10x_StdPeriph_Template\icine kendi main dosyanızı kopyalayın.
daha sonrada MDK-ARM klasor icine girip keil proje dosyanızı calıstırın. Ve derleyin.
Bu şekilde sample icindeki basit ornegi deneyin olmazsa ben kendi kalıbı mı veririm kullanırsınız.
Umarım anlatabildim.
Anladığım kadarıyla Firmware işleri kolaylaştırıyor. Bende ozaman Fİrmaware ile yola devam ederim. Yeterki firmware yardımıyla basit bir program yazabileyim.
Şimdi aklımda şu sorular kaldı. Şu firmware işini açıklık kazandırmak istiyorum
Birde hazır kütüphanede configürasyon ayarlarının daha doğrusu işlemcinin çalışması için gereken minimun ayarların nasıl yapılacağını bilmiyorum. Şu library nin manuali veya başka bir kitapcık gibi birşey bulsam çok güzel olacak.
Hocam proje oluşturma işine tekrar bir bakayım. Anladım galiba
firmware icinde
Yardım dosyası ( stm32f10x_stdperiph_lib_um.chm )var.
İnceleyin.
Birde EX33 teki kodları da inceleyin. Bazılarında Türkce açıklamalar var.
Merhabalar M_B hocam.
Hocam araya vizeler girince pek ilgilenemedim. En son yaptıkların şunlar oldu.
Dediğiniz gibi bir proje masaüstünde Bir proje klasörü açıp İndirdiğim library dosyası içerisinden Libraries Projects ve Utilities klasörlerini kopyaladım. Daha sonra project>>STM32F10x_StdPeriph_Template>>MDK-ARM klasörü içerisindeki project dosyasını açıp derleyebiliyorum. Buraya kadar tamam. Ama işin mantığı hala tam olarak oturmadı.
Vaktiniz varsa eğer şöyle birşey yapabilirmiyiz.
STM32F107 için Sıfırdan bir led yak söndür programı yazalım.
Bu sayede ben hem sıfırdan bir proje dosyası kütüphane ile birlikte nasıl hazırlanır, Clock Ayarları, OSC ayarları, GPIO ayarları nasıl yapılır öğrenmiş olacağım. Başka türlü birçok atladığım şey oluyor ve hazır programların üzerine en ufak birşey ekleyemiyorum.
Hocam led yak söndür basit ama config ayarları biraz uğrastıcı osilatör pll vs vs. Çok iyi bir yere değinmişsiniz bu osc cal ayarlarını anlayarak yapmak lazım . Bu konu altında bunların geniş bir açıklamasını yaparsak çok iyi olur. Ben şimdi stm32f4discovery'de timerlarla falan ugrasıyorum ama hala osilatör ayarlarını falan tam olarak çözdüğüm söylenemez.
Merhaba Hocam;
altta ornek bir main iceriği var onu alıp derleyip kodları bir inceleyin.
Anlaşılmayan noktaları soyleyin beraber bakalım.
Clok ayarı
system_stm32f10x.c
driveri icinde
#if defined (STM32F10X_LD_VL) || (defined STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
/* #define SYSCLK_FREQ_HSE HSE_VALUE */
#define SYSCLK_FREQ_24MHz 24000000
#else
/* #define SYSCLK_FREQ_HSE HSE_VALUE */
/* #define SYSCLK_FREQ_24MHz 24000000 */
/* #define SYSCLK_FREQ_36MHz 36000000 */
/* #define SYSCLK_FREQ_48MHz 48000000 */
/* #define SYSCLK_FREQ_56MHz 56000000 */
#define SYSCLK_FREQ_72MHz 72000000
#endif
ornek Led programı Sadece main var. Diğer driverları daha onceki gibi eklediğiniz varsayılmıstır.
/* Includes ------------------------------------------------------------------*/
#include "stm32f10x.h"
#include <stdio.h>
#define RCC_GPIO_LED RCC_APB2Periph_GPIOD
#define GPIO_LED_PORT GPIOD
#define GPIO_LED1 GPIO_Pin_2
#define GPIO_LED2 GPIO_Pin_3
#define GPIO_LED3 GPIO_Pin_4
#define GPIO_LED4 GPIO_Pin_7
#define GPIO_LED_ALL GPIO_LED1 |GPIO_LED2 |GPIO_LED3 |GPIO_LED4
///////////////////////////////////////LED//////////////////////////////////////
void LED_config(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIOB, GPIOC and AFIO clock */
RCC_APB2PeriphClockCmd(RCC_GPIO_LED | RCC_APB2Periph_AFIO , ENABLE); //RCC_APB2Periph_AFIO
/* LEDs pins configuration */
GPIO_InitStructure.GPIO_Pin = GPIO_LED_ALL;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIO_LED_PORT, &GPIO_InitStructure);
}
void Led_Turn_on_all(void)
{
/* Turn On All LEDs */
GPIO_ResetBits(GPIO_LED_PORT, GPIO_LED_ALL);
}
void Led_Turn_on_1(void)
{
/* Turn On LED1 */
GPIO_ResetBits(GPIO_LED_PORT, GPIO_LED1);
}
void Led_Turn_on_2(void)
{
/* Turn On LED2 */
GPIO_ResetBits(GPIO_LED_PORT, GPIO_LED2 );
}
void Led_Turn_on_3(void)
{
/* Turn On LED3 */
GPIO_ResetBits(GPIO_LED_PORT, GPIO_LED3);
}
void Led_Turn_on_4(void)
{
/* Turn On LED3 */
GPIO_ResetBits(GPIO_LED_PORT, GPIO_LED4);
}
void Led_Turn_off_all(void)
{
/* Turn Off All LEDs */
GPIO_SetBits(GPIO_LED_PORT, GPIO_LED_ALL);
}
void Led_Turn_on(u8 led)
{
Led_Turn_off_all();
/* Turn Off Select LED */
switch(led)
{
case 0:
Led_Turn_on_1();
break;
case 1:
Led_Turn_on_2();
break;
case 2:
Led_Turn_on_3();
break;
case 3:
Led_Turn_on_4();
break;
default:
Led_Turn_on_all();
break;
}
}
static void Delay(__IO uint32_t nCount)
{
for (; nCount != 0; nCount--);
}
int main(void)
{
u8 KeyNum = 0;
LED_config();
Led_Turn_on_all();
Delay(6000000);
Led_Turn_off_all();
Delay(6000000);
Led_Turn_on_all();
Delay(6000000);
Led_Turn_off_all();
Delay(6000000);
Led_Turn_on_all();
Delay(6000000);
Led_Turn_off_all();
Delay(6000000);
KeyNum=0;
/* Main loop */
while (1)
{
//Led_Turn_on_Hex(KeyNum);
Led_Turn_off_all();
Led_Turn_on(KeyNum%4);
KeyNum++;
Delay(1000000);
}
}
GPIO ayarlarına ornek:
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIOB, GPIOC and AFIO clock */
RCC_APB2PeriphClockCmd(RCC_GPIO_LED | RCC_APB2Periph_AFIO , ENABLE); //RCC_APB2Periph_AFIO
/* LEDs pins configuration */
GPIO_InitStructure.GPIO_Pin = GPIO_LED_ALL;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIO_LED_PORT, &GPIO_InitStructure);
GPIO_ResetBits Hazır fonksiyon.
İstenen biti reset yapıyor.
İcerigi:
void GPIO_ResetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
{
/* Check the parameters */
assert_param(IS_GPIO_ALL_PERIPH(GPIOx));
assert_param(IS_GPIO_PIN(GPIO_Pin));
GPIOx->BRR = GPIO_Pin;
}
Kullanımı
GPIO_ResetBits(GPIOx, GPIO_Pin);
GPIOx ; x yerine ilgili Port Adı: A,B,E gibi.
GPIO_Pin yerinede ilgili pin nosu. GPIO_pin_6 gibi
Hocam yazdığınız için teşekkür ederim.
Dediğiniz gibi verdiğiniz main kalıbını project klasröünün içine kopyalaladım. Sonra keil ile açıp derledim. Şimdi üzerinde oynamalar yapabiliyorum.
GPIO ayarlarını anladım. Bir bitin nasıl giriş veya çıkış olacağını çözdüm.
Fakat şu clock ayarlarını hala tam olarak anlayamadım.
system_stm32f10x.c dosyasının içerisinde gösterdiğiniz clock ayarları yazıyor.
Ben bunları main programıma mı taşıyacağım yoksa oradan aktif veya pasifmi yapacağım. Bu kısmı anlayamadım. Benim deney kartları üzerinde 8 Mhz kristal var. Bu kristal frekansına göre hangi ayarları yapmam gerekiyor. PLL ayarları nasıl olacak (Farzedelim işlemci 32Mips hızda çalışacak)
Birde hocam delay fonksiyonunu tanımlamak gerekiyor. Yoksa program derlenmiyor
Böyle birşey yaptım.
/* Includes ------------------------------------------------------------------*/
#include "stm32f10x.h"
#include <stdio.h>
/*#define RCC_GPIO_LED RCC_APB2Periph_GPIOD
#define GPIO_LED_PORT GPIOD
#define GPIO_LED1 GPIO_Pin_2
#define GPIO_LED2 GPIO_Pin_3
#define GPIO_LED3 GPIO_Pin_4
#define GPIO_LED4 GPIO_Pin_7
#define GPIO_LED_ALL GPIO_LED1 |GPIO_LED2 |GPIO_LED3 |GPIO_LED4 */
///////////////////////////////////////LED//////////////////////////////////////
int main(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIOB, GPIOC and AFIO clock */
/* GPIO clock Configuration */
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA|
RCC_APB2Periph_GPIOB|
RCC_APB2Periph_GPIOC|
RCC_APB2Periph_GPIOD|
RCC_APB2Periph_GPIOE, ENABLE);
/* LEDs pins configuration */
/* GPIO Pin Configuration */
GPIO_InitStructure.GPIO_Pin = 0xFFFF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_Init(GPIOD, &GPIO_InitStructure);
GPIO_Init(GPIOE, &GPIO_InitStructure);
while (1)
{
GPIO_Write(GPIOA,0x00FF);
Delay(6000000);
GPIO_Write(GPIOA,0x0000);
Delay(6000000);
}
}
Delaylar olmadan derleniyor Yoksa delaylarda hata veriyor. Bunu nasıl yapıcam. Ayrıca sonsuz döngüde delaylar olmadan sadece GPIO_Write(GPIOA,0x00FF); yaptığım zaman program derleniyor ama gerçekte çalışmıyor. Oda zaten sanırım configürasyon ayarları ile alakalı.
Birde şunu sorayım yeri gelmişken.
Diyelim sıfırdan bir program yazıcaksınız. Siz her seferinde main fonksiyonun sıfırdanmı yazıyorsunuz. Yoksa seferinde bunun gibi bir kalıp kullanıp bu kalıp üzerindemi programınızı geliştiriyorsunuz.
Merhaba Mucit hocam;
Clokc ayarlarını kendiniz yapmak isterseniz. oncelikle
"stm32f10x_rcc.h " ve "stm32f10x_rcc.c "kutuphanesi ekli olması lazım.
<< Firmware icinde
stm32f10x_stdperiph_lib_um adında yardım dosyası var. Tum kutuphaneleri nasıl kullanacagını anlatmış.
Arada sırada inceleyin.>>
Kullanımı ise:
Programın basında
void RCC_Configuration(void);
tanımlı olmalı.
void RCC_Configuration(void)
{
/* RCC system reset(for debug purpose) */
RCC_DeInit();
/* HSE kapali */
RCC_HSEConfig(RCC_HSE_OFF);
/* Prefetch Buffer aktif */
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
/* Flash ulasimi 2 clock */
FLASH_SetLatency(FLASH_Latency_2);
/* HCLK = SYSCLK */
RCC_HCLKConfig(RCC_SYSCLK_Div1);
/* PCLK2 = HCLK */
RCC_PCLK2Config(RCC_HCLK_Div1);
/* PCLK1 = HCLK/2 */
RCC_PCLK1Config(RCC_HCLK_Div2);
/* PLLCLK = (8MHz(internal osc)/2) * 8 = 32 MHz */
RCC_PLLConfig(RCC_PLLSource_HSI_Div2, RCC_PLLMul_8);
/* PLL Aktif */
RCC_PLLCmd(ENABLE);
/* PLL hazir olmasini bekle */
while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
/* System clock kaynagi PLL cikisi secildi */
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
/* System clock kaynagi hazir olmasini bekle */
while(RCC_GetSYSCLKSource() != 0x08);
}
Eger ben yapmayım derseniz hersey otomatik olsun derseniz
system_stm32f10x.c
driveri icinde ki tanımlamayı aktif veya pasif yapacaksınız.
Ornek:
#define SYSCLK_FREQ_36MHz 36000000 */
Delay fonksiyonu nu kendiniz yazacaksınız. Kendi icinde gomulu olarak delay fonksiyonu yok
ornegin.
static void Delay(__IO uint32_t nCount)
{
for (; nCount != 0; nCount--);
}
Kullanımı da
Delay(10000); gibi.
Sıfırdan program yazacagım zaman ben onceden hazırlamıs oldugum kalıbı kullanıyorum.
Project kısımda tum kutuphaneler eklı. Kullanmam gerekenler olursa main.c veya main.h ekliyorum.
Boyle daha kolay oluyor. Hem her uygulama icin kutuphane ayrı ayrı oluyor. Bir birlerine karışmıyor. Kutuphanelerde bozulma olmuyor.
Kolay gelsin.
Çok Teşekkür ederim Hocam Şimdi herşey birazdaha yerine oturdu.
Ben pazartesi çalışmalara devam edeyim.
Daha önceki iletilerde yazıldı mı bilmiyorum ama belirteyim dedim: Bilgisayarınızda atıyorum D sürücüsünde bi klasörde tüm kütüphaneleri saklayıp
Flas->Configure Flash Tools->C/C++sekmesinden include paths yazan yerden bu klasörü belirterek o kütüphanelere erişebilirsiniz.Yani her projede yeniden kullancağınız kütüphaneleir proje klasörüne kopyalamanız gerekmez.
Hocam tekrardan merhaba.
İndirdiğim Firmware içerisinde stm32f10x_stdperiph_lib_um adındaki yardım dosyasını bulamadım. Yanlış yeremi bakıyorum acaba. Vaktiniz var ise buraya eklemenizi rica ediyorum.
Hocam Ne yazıkki hala çalıştıramadım ledleri. Anlamıyorum. Program derleniyor işlemciyede yüklüyorum ama çalışmıyor. Amacım GPIOE deki tüm ledleri yakmak.
Şu yardım dosyasında GPIO ların nasıl giriş ve çıkış olacağı ayarlanacağı yazıyordur. Belkide orada hata yapıyorum ama bende expkits örnek kodlarına bakıyorum henüz.
Kodlar bu şekilde
[noae]
/* Includes ------------------------------------------------------------------*/
#include "stm32f10x.h"
#include <stdio.h>
/*#define RCC_GPIO_LED RCC_APB2Periph_GPIOD
#define GPIO_LED_PORT GPIOD
#define GPIO_LED1 GPIO_Pin_2
#define GPIO_LED2 GPIO_Pin_3
#define GPIO_LED3 GPIO_Pin_4
#define GPIO_LED4 GPIO_Pin_7
#define GPIO_LED_ALL GPIO_LED1 |GPIO_LED2 |GPIO_LED3 |GPIO_LED4 */
void RCC_Configuration(void);
void NVIC_Configuration(void);
///////////////////////////////////////LED//////////////////////////////////////
int main(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIOB, GPIOC and AFIO clock */
/* System Clocks Configuration */
RCC_Configuration();
/* GPIO clock Configuration */
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA|
RCC_APB2Periph_GPIOB|
RCC_APB2Periph_GPIOC|
RCC_APB2Periph_GPIOD|
RCC_APB2Periph_GPIOE, ENABLE);
/* NVIC Configuration */
NVIC_Configuration();
/* LEDs pins configuration */
/* GPIO Pin Configuration */
GPIO_InitStructure.GPIO_Pin = 0x00FF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_Init(GPIOD, &GPIO_InitStructure);
GPIO_Init(GPIOE, &GPIO_InitStructure);
while (1)
{
GPIO_Write(GPIOE,0x00FF);
}
}
void RCC_Configuration(void)
{
/* RCC system reset(for debug purpose) */
RCC_DeInit();
/* HSE kapali */
RCC_HSEConfig(RCC_HSE_OFF);
/* Prefetch Buffer aktif */
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
/* Flash ulasimi 2 clock */
FLASH_SetLatency(FLASH_Latency_2);
/* HCLK = SYSCLK */
RCC_HCLKConfig(RCC_SYSCLK_Div1);
/* PCLK2 = HCLK */
RCC_PCLK2Config(RCC_HCLK_Div1);
/* PCLK1 = HCLK/2 */
RCC_PCLK1Config(RCC_HCLK_Div2);
/* PLLCLK = (8MHz(internal osc)/2) * 8 = 32 MHz */
RCC_PLLConfig(RCC_PLLSource_HSI_Div2, RCC_PLLMul_8);
/* PLL Aktif */
RCC_PLLCmd(ENABLE);
/* PLL hazir olmasini bekle */
while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
/* System clock kaynagi PLL cikisi secildi */
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
/* System clock kaynagi hazir olmasini bekle */
while(RCC_GetSYSCLKSource() != 0x08);
}
void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
#ifdef VECT_TAB_RAM
/* Vectör kaynagi adresi: 0x20000000 */
NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
#else /* VECT_TAB_FLASH */
/* Vektör kaynagi adresi: 0x08000000 */
NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);
#endif
NVIC_Init(&NVIC_InitStructure);
}
Buda System_STM32F10X.c dosyası
[noae]/**
******************************************************************************
* @file system_stm32f10x.c
* @author MCD Application Team
* @version V3.5.0
* @date 08-April-2011
* @brief CMSIS Cortex-M3 Device Peripheral Access Layer System Source File.
*
* 1. This file provides two functions and one global variable to be called from
* user application:
* - SystemInit(): Setups the system clock (System clock source, PLL Multiplier
* factors, AHB/APBx prescalers and Flash settings).
* This function is called at startup just after reset and
* before branch to main program. This call is made inside
* the "startup_stm32f10x_xx.s" file.
*
* - SystemCoreClock variable: Contains the core clock (HCLK), it can be used
* by the user application to setup the SysTick
* timer or configure other parameters.
*
* - SystemCoreClockUpdate(): Updates the variable SystemCoreClock and must
* be called whenever the core clock is changed
* during program execution.
*
* 2. After each device reset the HSI (8 MHz) is used as system clock source.
* Then SystemInit() function is called, in "startup_stm32f10x_xx.s" file, to
* configure the system clock before to branch to main program.
*
* 3. If the system clock source selected by user fails to startup, the SystemInit()
* function will do nothing and HSI still used as system clock source. User can
* add some code to deal with this issue inside the SetSysClock() function.
*
* 4. The default value of HSE crystal is set to 8 MHz (or 25 MHz, depedning on
* the product used), refer to "HSE_VALUE" define in "stm32f10x.h" file.
* When HSE is used as system clock source, directly or through PLL, and you
* are using different crystal you have to adapt the HSE value to your own
* configuration.
*
******************************************************************************
* @attention
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2>
******************************************************************************
*/
/** @addtogroup CMSIS
* @{
*/
/** @addtogroup stm32f10x_system
* @{
*/
/** @addtogroup STM32F10x_System_Private_Includes
* @{
*/
#include "stm32f10x.h"
/**
* @}
*/
/** @addtogroup STM32F10x_System_Private_TypesDefinitions
* @{
*/
/**
* @}
*/
/** @addtogroup STM32F10x_System_Private_Defines
* @{
*/
/*!< Uncomment the line corresponding to the desired System clock (SYSCLK)
frequency (after reset the HSI is used as SYSCLK source)
IMPORTANT NOTE:
==============
1. After each device reset the HSI is used as System clock source.
2. Please make sure that the selected System clock doesn't exceed your device's
maximum frequency.
3. If none of the define below is enabled, the HSI is used as System clock
source.
4. The System clock configuration functions provided within this file assume that:
- For Low, Medium and High density Value line devices an external 8MHz
crystal is used to drive the System clock.
- For Low, Medium and High density devices an external 8MHz crystal is
used to drive the System clock.
- For Connectivity line devices an external 25MHz crystal is used to drive
the System clock.
If you are using different crystal you have to adapt those functions accordingly.
*/
#if defined (STM32F10X_LD_VL) || (defined STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
/* #define SYSCLK_FREQ_HSE HSE_VALUE */
#define SYSCLK_FREQ_24MHz 24000000
#else
/* #define SYSCLK_FREQ_HSE HSE_VALUE */
/* #define SYSCLK_FREQ_24MHz 24000000 */
/* #define SYSCLK_FREQ_36MHz 36000000 */
/* #define SYSCLK_FREQ_48MHz 48000000 */
/* #define SYSCLK_FREQ_56MHz 56000000 */
#define SYSCLK_FREQ_72MHz 72000000
#endif
/*!< Uncomment the following line if you need to use external SRAM mounted
on STM3210E-EVAL board (STM32 High density and XL-density devices) or on
STM32100E-EVAL board (STM32 High-density value line devices) as data memory */
#if defined (STM32F10X_HD) || (defined STM32F10X_XL) || (defined STM32F10X_HD_VL)
/* #define DATA_IN_ExtSRAM */
#endif
/*!< Uncomment the following line if you need to relocate your vector Table in
Internal SRAM. */
/* #define VECT_TAB_SRAM */
#define VECT_TAB_OFFSET 0x0 /*!< Vector Table base offset field.
This value must be a multiple of 0x200. */
/**
* @}
*/
/** @addtogroup STM32F10x_System_Private_Macros
* @{
*/
/**
* @}
*/
/** @addtogroup STM32F10x_System_Private_Variables
* @{
*/
/*******************************************************************************
* Clock Definitions
*******************************************************************************/
#ifdef SYSCLK_FREQ_HSE
uint32_t SystemCoreClock = SYSCLK_FREQ_HSE; /*!< System Clock Frequency (Core Clock) */
#elif defined SYSCLK_FREQ_24MHz
uint32_t SystemCoreClock = SYSCLK_FREQ_24MHz; /*!< System Clock Frequency (Core Clock) */
#elif defined SYSCLK_FREQ_36MHz
uint32_t SystemCoreClock = SYSCLK_FREQ_36MHz; /*!< System Clock Frequency (Core Clock) */
#elif defined SYSCLK_FREQ_48MHz
uint32_t SystemCoreClock = SYSCLK_FREQ_48MHz; /*!< System Clock Frequency (Core Clock) */
#elif defined SYSCLK_FREQ_56MHz
uint32_t SystemCoreClock = SYSCLK_FREQ_56MHz; /*!< System Clock Frequency (Core Clock) */
#elif defined SYSCLK_FREQ_72MHz
uint32_t SystemCoreClock = SYSCLK_FREQ_72MHz; /*!< System Clock Frequency (Core Clock) */
#else /*!< HSI Selected as System Clock source */
uint32_t SystemCoreClock = HSI_VALUE; /*!< System Clock Frequency (Core Clock) */
#endif
__I uint8_t AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9};
/**
* @}
*/
/** @addtogroup STM32F10x_System_Private_FunctionPrototypes
* @{
*/
static void SetSysClock(void);
#ifdef SYSCLK_FREQ_HSE
static void SetSysClockToHSE(void);
#elif defined SYSCLK_FREQ_24MHz
static void SetSysClockTo24(void);
#elif defined SYSCLK_FREQ_36MHz
static void SetSysClockTo36(void);
#elif defined SYSCLK_FREQ_48MHz
static void SetSysClockTo48(void);
#elif defined SYSCLK_FREQ_56MHz
static void SetSysClockTo56(void);
#elif defined SYSCLK_FREQ_72MHz
static void SetSysClockTo72(void);
#endif
#ifdef DATA_IN_ExtSRAM
static void SystemInit_ExtMemCtl(void);
#endif /* DATA_IN_ExtSRAM */
/**
* @}
*/
/** @addtogroup STM32F10x_System_Private_Functions
* @{
*/
/**
* @brief Setup the microcontroller system
* Initialize the Embedded Flash Interface, the PLL and update the
* SystemCoreClock variable.
* @note This function should be used only after reset.
* @param None
* @retval None
*/
void SystemInit (void)
{
/* Reset the RCC clock configuration to the default reset state(for debug purpose) */
/* Set HSION bit */
RCC->CR |= (uint32_t)0x00000001;
/* Reset SW, HPRE, PPRE1, PPRE2, ADCPRE and MCO bits */
#ifndef STM32F10X_CL
RCC->CFGR &= (uint32_t)0xF8FF0000;
#else
RCC->CFGR &= (uint32_t)0xF0FF0000;
#endif /* STM32F10X_CL */
/* Reset HSEON, CSSON and PLLON bits */
RCC->CR &= (uint32_t)0xFEF6FFFF;
/* Reset HSEBYP bit */
RCC->CR &= (uint32_t)0xFFFBFFFF;
/* Reset PLLSRC, PLLXTPRE, PLLMUL and USBPRE/OTGFSPRE bits */
RCC->CFGR &= (uint32_t)0xFF80FFFF;
#ifdef STM32F10X_CL
/* Reset PLL2ON and PLL3ON bits */
RCC->CR &= (uint32_t)0xEBFFFFFF;
/* Disable all interrupts and clear pending bits */
RCC->CIR = 0x00FF0000;
/* Reset CFGR2 register */
RCC->CFGR2 = 0x00000000;
#elif defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
/* Disable all interrupts and clear pending bits */
RCC->CIR = 0x009F0000;
/* Reset CFGR2 register */
RCC->CFGR2 = 0x00000000;
#else
/* Disable all interrupts and clear pending bits */
RCC->CIR = 0x009F0000;
#endif /* STM32F10X_CL */
#if defined (STM32F10X_HD) || (defined STM32F10X_XL) || (defined STM32F10X_HD_VL)
#ifdef DATA_IN_ExtSRAM
SystemInit_ExtMemCtl();
#endif /* DATA_IN_ExtSRAM */
#endif
/* Configure the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers */
/* Configure the Flash Latency cycles and enable prefetch buffer */
SetSysClock();
#ifdef VECT_TAB_SRAM
SCB->VTOR = SRAM_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal SRAM. */
#else
SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal FLASH. */
#endif
}
/**
* @brief Update SystemCoreClock variable according to Clock Register Values.
* The SystemCoreClock variable contains the core clock (HCLK), it can
* be used by the user application to setup the SysTick timer or configure
* other parameters.
*
* @note Each time the core clock (HCLK) changes, this function must be called
* to update SystemCoreClock variable value. Otherwise, any configuration
* based on this variable will be incorrect.
*
* @note - The system frequency computed by this function is not the real
* frequency in the chip. It is calculated based on the predefined
* constant and the selected clock source:
*
* - If SYSCLK source is HSI, SystemCoreClock will contain the HSI_VALUE(*)
*
* - If SYSCLK source is HSE, SystemCoreClock will contain the HSE_VALUE(**)
*
* - If SYSCLK source is PLL, SystemCoreClock will contain the HSE_VALUE(**)
* or HSI_VALUE(*) multiplied by the PLL factors.
*
* (*) HSI_VALUE is a constant defined in stm32f1xx.h file (default value
* 8 MHz) but the real value may vary depending on the variations
* in voltage and temperature.
*
* (**) HSE_VALUE is a constant defined in stm32f1xx.h file (default value
* 8 MHz or 25 MHz, depedning on the product used), user has to ensure
* that HSE_VALUE is same as the real frequency of the crystal used.
* Otherwise, this function may have wrong result.
*
* - The result of this function could be not correct when using fractional
* value for HSE crystal.
* @param None
* @retval None
*/
void SystemCoreClockUpdate (void)
{
uint32_t tmp = 0, pllmull = 0, pllsource = 0;
#ifdef STM32F10X_CL
uint32_t prediv1source = 0, prediv1factor = 0, prediv2factor = 0, pll2mull = 0;
#endif /* STM32F10X_CL */
#if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
uint32_t prediv1factor = 0;
#endif /* STM32F10X_LD_VL or STM32F10X_MD_VL or STM32F10X_HD_VL */
/* Get SYSCLK source -------------------------------------------------------*/
tmp = RCC->CFGR & RCC_CFGR_SWS;
switch (tmp)
{
case 0x00: /* HSI used as system clock */
SystemCoreClock = HSI_VALUE;
break;
case 0x04: /* HSE used as system clock */
SystemCoreClock = HSE_VALUE;
break;
case 0x08: /* PLL used as system clock */
/* Get PLL clock source and multiplication factor ----------------------*/
pllmull = RCC->CFGR & RCC_CFGR_PLLMULL;
pllsource = RCC->CFGR & RCC_CFGR_PLLSRC;
#ifndef STM32F10X_CL
pllmull = ( pllmull >> 18) + 2;
if (pllsource == 0x00)
{
/* HSI oscillator clock divided by 2 selected as PLL clock entry */
SystemCoreClock = (HSI_VALUE >> 1) * pllmull;
}
else
{
#if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + 1;
/* HSE oscillator clock selected as PREDIV1 clock entry */
SystemCoreClock = (HSE_VALUE / prediv1factor) * pllmull;
#else
/* HSE selected as PLL clock entry */
if ((RCC->CFGR & RCC_CFGR_PLLXTPRE) != (uint32_t)RESET)
{/* HSE oscillator clock divided by 2 */
SystemCoreClock = (HSE_VALUE >> 1) * pllmull;
}
else
{
SystemCoreClock = HSE_VALUE * pllmull;
}
#endif
}
#else
pllmull = pllmull >> 18;
if (pllmull != 0x0D)
{
pllmull += 2;
}
else
{ /* PLL multiplication factor = PLL input clock * 6.5 */
pllmull = 13 / 2;
}
if (pllsource == 0x00)
{
/* HSI oscillator clock divided by 2 selected as PLL clock entry */
SystemCoreClock = (HSI_VALUE >> 1) * pllmull;
}
else
{/* PREDIV1 selected as PLL clock entry */
/* Get PREDIV1 clock source and division factor */
prediv1source = RCC->CFGR2 & RCC_CFGR2_PREDIV1SRC;
prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + 1;
if (prediv1source == 0)
{
/* HSE oscillator clock selected as PREDIV1 clock entry */
SystemCoreClock = (HSE_VALUE / prediv1factor) * pllmull;
}
else
{/* PLL2 clock selected as PREDIV1 clock entry */
/* Get PREDIV2 division factor and PLL2 multiplication factor */
prediv2factor = ((RCC->CFGR2 & RCC_CFGR2_PREDIV2) >> 4) + 1;
pll2mull = ((RCC->CFGR2 & RCC_CFGR2_PLL2MUL) >> 8 ) + 2;
SystemCoreClock = (((HSE_VALUE / prediv2factor) * pll2mull) / prediv1factor) * pllmull;
}
}
#endif /* STM32F10X_CL */
break;
default:
SystemCoreClock = HSI_VALUE;
break;
}
/* Compute HCLK clock frequency ----------------*/
/* Get HCLK prescaler */
tmp = AHBPrescTable[((RCC->CFGR & RCC_CFGR_HPRE) >> 4)];
/* HCLK clock frequency */
SystemCoreClock >>= tmp;
}
/**
* @brief Configures the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers.
* @param None
* @retval None
*/
static void SetSysClock(void)
{
#ifdef SYSCLK_FREQ_HSE
SetSysClockToHSE();
#elif defined SYSCLK_FREQ_24MHz
SetSysClockTo24();
#elif defined SYSCLK_FREQ_36MHz
SetSysClockTo36();
#elif defined SYSCLK_FREQ_48MHz
SetSysClockTo48();
#elif defined SYSCLK_FREQ_56MHz
SetSysClockTo56();
#elif defined SYSCLK_FREQ_72MHz
SetSysClockTo72();
#endif
/* If none of the define above is enabled, the HSI is used as System clock
source (default after reset) */
}
/**
* @brief Setup the external memory controller. Called in startup_stm32f10x.s
* before jump to __main
* @param None
* @retval None
*/
#ifdef DATA_IN_ExtSRAM
/**
* @brief Setup the external memory controller.
* Called in startup_stm32f10x_xx.s/.c before jump to main.
* This function configures the external SRAM mounted on STM3210E-EVAL
* board (STM32 High density devices). This SRAM will be used as program
* data memory (including heap and stack).
* @param None
* @retval None
*/
void SystemInit_ExtMemCtl(void)
{
/*!< FSMC Bank1 NOR/SRAM3 is used for the STM3210E-EVAL, if another Bank is
required, then adjust the Register Addresses */
/* Enable FSMC clock */
RCC->AHBENR = 0x00000114;
/* Enable GPIOD, GPIOE, GPIOF and GPIOG clocks */
RCC->APB2ENR = 0x000001E0;
/* --------------- SRAM Data lines, NOE and NWE configuration ---------------*/
/*---------------- SRAM Address lines configuration -------------------------*/
/*---------------- NOE and NWE configuration --------------------------------*/
/*---------------- NE3 configuration ----------------------------------------*/
/*---------------- NBL0, NBL1 configuration ---------------------------------*/
GPIOD->CRL = 0x44BB44BB;
GPIOD->CRH = 0xBBBBBBBB;
GPIOE->CRL = 0xB44444BB;
GPIOE->CRH = 0xBBBBBBBB;
GPIOF->CRL = 0x44BBBBBB;
GPIOF->CRH = 0xBBBB4444;
GPIOG->CRL = 0x44BBBBBB;
GPIOG->CRH = 0x44444B44;
/*---------------- FSMC Configuration ---------------------------------------*/
/*---------------- Enable FSMC Bank1_SRAM Bank ------------------------------*/
FSMC_Bank1->BTCR[4] = 0x00001011;
FSMC_Bank1->BTCR[5] = 0x00000200;
}
#endif /* DATA_IN_ExtSRAM */
#ifdef SYSCLK_FREQ_HSE
/**
* @brief Selects HSE as System clock source and configure HCLK, PCLK2
* and PCLK1 prescalers.
* @note This function should be used only after reset.
* @param None
* @retval None
*/
static void SetSysClockToHSE(void)
{
__IO uint32_t StartUpCounter = 0, HSEStatus = 0;
/* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/
/* Enable HSE */
RCC->CR |= ((uint32_t)RCC_CR_HSEON);
/* Wait till HSE is ready and if Time out is reached exit */
do
{
HSEStatus = RCC->CR & RCC_CR_HSERDY;
StartUpCounter++;
} while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
if ((RCC->CR & RCC_CR_HSERDY) != RESET)
{
HSEStatus = (uint32_t)0x01;
}
else
{
HSEStatus = (uint32_t)0x00;
}
if (HSEStatus == (uint32_t)0x01)
{
#if !defined STM32F10X_LD_VL && !defined STM32F10X_MD_VL && !defined STM32F10X_HD_VL
/* Enable Prefetch Buffer */
FLASH->ACR |= FLASH_ACR_PRFTBE;
/* Flash 0 wait state */
FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
#ifndef STM32F10X_CL
FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_0;
#else
if (HSE_VALUE <= 24000000)
{
FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_0;
}
else
{
FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_1;
}
#endif /* STM32F10X_CL */
#endif
/* HCLK = SYSCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
/* PCLK2 = HCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
/* PCLK1 = HCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV1;
/* Select HSE as system clock source */
RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
RCC->CFGR |= (uint32_t)RCC_CFGR_SW_HSE;
/* Wait till HSE is used as system clock source */
while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x04)
{
}
}
else
{ /* If HSE fails to start-up, the application will have wrong clock
configuration. User can add here some code to deal with this error */
}
}
#elif defined SYSCLK_FREQ_24MHz
/**
* @brief Sets System clock frequency to 24MHz and configure HCLK, PCLK2
* and PCLK1 prescalers.
* @note This function should be used only after reset.
* @param None
* @retval None
*/
static void SetSysClockTo24(void)
{
__IO uint32_t StartUpCounter = 0, HSEStatus = 0;
/* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/
/* Enable HSE */
RCC->CR |= ((uint32_t)RCC_CR_HSEON);
/* Wait till HSE is ready and if Time out is reached exit */
do
{
HSEStatus = RCC->CR & RCC_CR_HSERDY;
StartUpCounter++;
} while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
if ((RCC->CR & RCC_CR_HSERDY) != RESET)
{
HSEStatus = (uint32_t)0x01;
}
else
{
HSEStatus = (uint32_t)0x00;
}
if (HSEStatus == (uint32_t)0x01)
{
#if !defined STM32F10X_LD_VL && !defined STM32F10X_MD_VL && !defined STM32F10X_HD_VL
/* Enable Prefetch Buffer */
FLASH->ACR |= FLASH_ACR_PRFTBE;
/* Flash 0 wait state */
FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_0;
#endif
/* HCLK = SYSCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
/* PCLK2 = HCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
/* PCLK1 = HCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV1;
#ifdef STM32F10X_CL
/* Configure PLLs ------------------------------------------------------*/
/* PLL configuration: PLLCLK = PREDIV1 * 6 = 24 MHz */
RCC->CFGR &= (uint32_t)~(RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLSRC | RCC_CFGR_PLLMULL);
RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLXTPRE_PREDIV1 | RCC_CFGR_PLLSRC_PREDIV1 |
RCC_CFGR_PLLMULL6);
/* PLL2 configuration: PLL2CLK = (HSE / 5) * 8 = 40 MHz */
/* PREDIV1 configuration: PREDIV1CLK = PLL2 / 10 = 4 MHz */
RCC->CFGR2 &= (uint32_t)~(RCC_CFGR2_PREDIV2 | RCC_CFGR2_PLL2MUL |
RCC_CFGR2_PREDIV1 | RCC_CFGR2_PREDIV1SRC);
RCC->CFGR2 |= (uint32_t)(RCC_CFGR2_PREDIV2_DIV5 | RCC_CFGR2_PLL2MUL8 |
RCC_CFGR2_PREDIV1SRC_PLL2 | RCC_CFGR2_PREDIV1_DIV10);
/* Enable PLL2 */
RCC->CR |= RCC_CR_PLL2ON;
/* Wait till PLL2 is ready */
while((RCC->CR & RCC_CR_PLL2RDY) == 0)
{
}
#elif defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL)
/* PLL configuration: = (HSE / 2) * 6 = 24 MHz */
RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLMULL));
RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_PREDIV1 | RCC_CFGR_PLLXTPRE_PREDIV1_Div2 | RCC_CFGR_PLLMULL6);
#else
/* PLL configuration: = (HSE / 2) * 6 = 24 MHz */
RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLMULL));
RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLXTPRE_HSE_Div2 | RCC_CFGR_PLLMULL6);
#endif /* STM32F10X_CL */
/* Enable PLL */
RCC->CR |= RCC_CR_PLLON;
/* Wait till PLL is ready */
while((RCC->CR & RCC_CR_PLLRDY) == 0)
{
}
/* Select PLL as system clock source */
RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;
/* Wait till PLL is used as system clock source */
while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08)
{
}
}
else
{ /* If HSE fails to start-up, the application will have wrong clock
configuration. User can add here some code to deal with this error */
}
}
#elif defined SYSCLK_FREQ_36MHz
/**
* @brief Sets System clock frequency to 36MHz and configure HCLK, PCLK2
* and PCLK1 prescalers.
* @note This function should be used only after reset.
* @param None
* @retval None
*/
static void SetSysClockTo36(void)
{
__IO uint32_t StartUpCounter = 0, HSEStatus = 0;
/* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/
/* Enable HSE */
RCC->CR |= ((uint32_t)RCC_CR_HSEON);
/* Wait till HSE is ready and if Time out is reached exit */
do
{
HSEStatus = RCC->CR & RCC_CR_HSERDY;
StartUpCounter++;
} while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
if ((RCC->CR & RCC_CR_HSERDY) != RESET)
{
HSEStatus = (uint32_t)0x01;
}
else
{
HSEStatus = (uint32_t)0x00;
}
if (HSEStatus == (uint32_t)0x01)
{
/* Enable Prefetch Buffer */
FLASH->ACR |= FLASH_ACR_PRFTBE;
/* Flash 1 wait state */
FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_1;
/* HCLK = SYSCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
/* PCLK2 = HCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
/* PCLK1 = HCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV1;
#ifdef STM32F10X_CL
/* Configure PLLs ------------------------------------------------------*/
/* PLL configuration: PLLCLK = PREDIV1 * 9 = 36 MHz */
RCC->CFGR &= (uint32_t)~(RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLSRC | RCC_CFGR_PLLMULL);
RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLXTPRE_PREDIV1 | RCC_CFGR_PLLSRC_PREDIV1 |
RCC_CFGR_PLLMULL9);
/*!< PLL2 configuration: PLL2CLK = (HSE / 5) * 8 = 40 MHz */
/* PREDIV1 configuration: PREDIV1CLK = PLL2 / 10 = 4 MHz */
RCC->CFGR2 &= (uint32_t)~(RCC_CFGR2_PREDIV2 | RCC_CFGR2_PLL2MUL |
RCC_CFGR2_PREDIV1 | RCC_CFGR2_PREDIV1SRC);
RCC->CFGR2 |= (uint32_t)(RCC_CFGR2_PREDIV2_DIV5 | RCC_CFGR2_PLL2MUL8 |
RCC_CFGR2_PREDIV1SRC_PLL2 | RCC_CFGR2_PREDIV1_DIV10);
/* Enable PLL2 */
RCC->CR |= RCC_CR_PLL2ON;
/* Wait till PLL2 is ready */
while((RCC->CR & RCC_CR_PLL2RDY) == 0)
{
}
#else
/* PLL configuration: PLLCLK = (HSE / 2) * 9 = 36 MHz */
RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLMULL));
RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLXTPRE_HSE_Div2 | RCC_CFGR_PLLMULL9);
#endif /* STM32F10X_CL */
/* Enable PLL */
RCC->CR |= RCC_CR_PLLON;
/* Wait till PLL is ready */
while((RCC->CR & RCC_CR_PLLRDY) == 0)
{
}
/* Select PLL as system clock source */
RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;
/* Wait till PLL is used as system clock source */
while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08)
{
}
}
else
{ /* If HSE fails to start-up, the application will have wrong clock
configuration. User can add here some code to deal with this error */
}
}
#elif defined SYSCLK_FREQ_48MHz
/**
* @brief Sets System clock frequency to 48MHz and configure HCLK, PCLK2
* and PCLK1 prescalers.
* @note This function should be used only after reset.
* @param None
* @retval None
*/
static void SetSysClockTo48(void)
{
__IO uint32_t StartUpCounter = 0, HSEStatus = 0;
/* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/
/* Enable HSE */
RCC->CR |= ((uint32_t)RCC_CR_HSEON);
/* Wait till HSE is ready and if Time out is reached exit */
do
{
HSEStatus = RCC->CR & RCC_CR_HSERDY;
StartUpCounter++;
} while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
if ((RCC->CR & RCC_CR_HSERDY) != RESET)
{
HSEStatus = (uint32_t)0x01;
}
else
{
HSEStatus = (uint32_t)0x00;
}
if (HSEStatus == (uint32_t)0x01)
{
/* Enable Prefetch Buffer */
FLASH->ACR |= FLASH_ACR_PRFTBE;
/* Flash 1 wait state */
FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_1;
/* HCLK = SYSCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
/* PCLK2 = HCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
/* PCLK1 = HCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV2;
#ifdef STM32F10X_CL
/* Configure PLLs ------------------------------------------------------*/
/* PLL2 configuration: PLL2CLK = (HSE / 5) * 8 = 40 MHz */
/* PREDIV1 configuration: PREDIV1CLK = PLL2 / 5 = 8 MHz */
RCC->CFGR2 &= (uint32_t)~(RCC_CFGR2_PREDIV2 | RCC_CFGR2_PLL2MUL |
RCC_CFGR2_PREDIV1 | RCC_CFGR2_PREDIV1SRC);
RCC->CFGR2 |= (uint32_t)(RCC_CFGR2_PREDIV2_DIV5 | RCC_CFGR2_PLL2MUL8 |
RCC_CFGR2_PREDIV1SRC_PLL2 | RCC_CFGR2_PREDIV1_DIV5);
/* Enable PLL2 */
RCC->CR |= RCC_CR_PLL2ON;
/* Wait till PLL2 is ready */
while((RCC->CR & RCC_CR_PLL2RDY) == 0)
{
}
/* PLL configuration: PLLCLK = PREDIV1 * 6 = 48 MHz */
RCC->CFGR &= (uint32_t)~(RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLSRC | RCC_CFGR_PLLMULL);
RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLXTPRE_PREDIV1 | RCC_CFGR_PLLSRC_PREDIV1 |
RCC_CFGR_PLLMULL6);
#else
/* PLL configuration: PLLCLK = HSE * 6 = 48 MHz */
RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLMULL));
RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMULL6);
#endif /* STM32F10X_CL */
/* Enable PLL */
RCC->CR |= RCC_CR_PLLON;
/* Wait till PLL is ready */
while((RCC->CR & RCC_CR_PLLRDY) == 0)
{
}
/* Select PLL as system clock source */
RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;
/* Wait till PLL is used as system clock source */
while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08)
{
}
}
else
{ /* If HSE fails to start-up, the application will have wrong clock
configuration. User can add here some code to deal with this error */
}
}
#elif defined SYSCLK_FREQ_56MHz
/**
* @brief Sets System clock frequency to 56MHz and configure HCLK, PCLK2
* and PCLK1 prescalers.
* @note This function should be used only after reset.
* @param None
* @retval None
*/
static void SetSysClockTo56(void)
{
__IO uint32_t StartUpCounter = 0, HSEStatus = 0;
/* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/
/* Enable HSE */
RCC->CR |= ((uint32_t)RCC_CR_HSEON);
/* Wait till HSE is ready and if Time out is reached exit */
do
{
HSEStatus = RCC->CR & RCC_CR_HSERDY;
StartUpCounter++;
} while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
if ((RCC->CR & RCC_CR_HSERDY) != RESET)
{
HSEStatus = (uint32_t)0x01;
}
else
{
HSEStatus = (uint32_t)0x00;
}
if (HSEStatus == (uint32_t)0x01)
{
/* Enable Prefetch Buffer */
FLASH->ACR |= FLASH_ACR_PRFTBE;
/* Flash 2 wait state */
FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_2;
/* HCLK = SYSCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
/* PCLK2 = HCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
/* PCLK1 = HCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV2;
#ifdef STM32F10X_CL
/* Configure PLLs ------------------------------------------------------*/
/* PLL2 configuration: PLL2CLK = (HSE / 5) * 8 = 40 MHz */
/* PREDIV1 configuration: PREDIV1CLK = PLL2 / 5 = 8 MHz */
RCC->CFGR2 &= (uint32_t)~(RCC_CFGR2_PREDIV2 | RCC_CFGR2_PLL2MUL |
RCC_CFGR2_PREDIV1 | RCC_CFGR2_PREDIV1SRC);
RCC->CFGR2 |= (uint32_t)(RCC_CFGR2_PREDIV2_DIV5 | RCC_CFGR2_PLL2MUL8 |
RCC_CFGR2_PREDIV1SRC_PLL2 | RCC_CFGR2_PREDIV1_DIV5);
/* Enable PLL2 */
RCC->CR |= RCC_CR_PLL2ON;
/* Wait till PLL2 is ready */
while((RCC->CR & RCC_CR_PLL2RDY) == 0)
{
}
/* PLL configuration: PLLCLK = PREDIV1 * 7 = 56 MHz */
RCC->CFGR &= (uint32_t)~(RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLSRC | RCC_CFGR_PLLMULL);
RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLXTPRE_PREDIV1 | RCC_CFGR_PLLSRC_PREDIV1 |
RCC_CFGR_PLLMULL7);
#else
/* PLL configuration: PLLCLK = HSE * 7 = 56 MHz */
RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLMULL));
RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMULL7);
#endif /* STM32F10X_CL */
/* Enable PLL */
RCC->CR |= RCC_CR_PLLON;
/* Wait till PLL is ready */
while((RCC->CR & RCC_CR_PLLRDY) == 0)
{
}
/* Select PLL as system clock source */
RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;
/* Wait till PLL is used as system clock source */
while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08)
{
}
}
else
{ /* If HSE fails to start-up, the application will have wrong clock
configuration. User can add here some code to deal with this error */
}
}
#elif defined SYSCLK_FREQ_72MHz
/**
* @brief Sets System clock frequency to 72MHz and configure HCLK, PCLK2
* and PCLK1 prescalers.
* @note This function should be used only after reset.
* @param None
* @retval None
*/
static void SetSysClockTo72(void)
{
__IO uint32_t StartUpCounter = 0, HSEStatus = 0;
/* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/
/* Enable HSE */
RCC->CR |= ((uint32_t)RCC_CR_HSEON);
/* Wait till HSE is ready and if Time out is reached exit */
do
{
HSEStatus = RCC->CR & RCC_CR_HSERDY;
StartUpCounter++;
} while((HSEStatus == 0) && (StartUpCounter != HSE_STARTUP_TIMEOUT));
if ((RCC->CR & RCC_CR_HSERDY) != RESET)
{
HSEStatus = (uint32_t)0x01;
}
else
{
HSEStatus = (uint32_t)0x00;
}
if (HSEStatus == (uint32_t)0x01)
{
/* Enable Prefetch Buffer */
FLASH->ACR |= FLASH_ACR_PRFTBE;
/* Flash 2 wait state */
FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_2;
/* HCLK = SYSCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;
/* PCLK2 = HCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
/* PCLK1 = HCLK */
RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV2;
#ifdef STM32F10X_CL
/* Configure PLLs ------------------------------------------------------*/
/* PLL2 configuration: PLL2CLK = (HSE / 5) * 8 = 40 MHz */
/* PREDIV1 configuration: PREDIV1CLK = PLL2 / 5 = 8 MHz */
RCC->CFGR2 &= (uint32_t)~(RCC_CFGR2_PREDIV2 | RCC_CFGR2_PLL2MUL |
RCC_CFGR2_PREDIV1 | RCC_CFGR2_PREDIV1SRC);
RCC->CFGR2 |= (uint32_t)(RCC_CFGR2_PREDIV2_DIV5 | RCC_CFGR2_PLL2MUL8 |
RCC_CFGR2_PREDIV1SRC_PLL2 | RCC_CFGR2_PREDIV1_DIV5);
/* Enable PLL2 */
RCC->CR |= RCC_CR_PLL2ON;
/* Wait till PLL2 is ready */
while((RCC->CR & RCC_CR_PLL2RDY) == 0)
{
}
/* PLL configuration: PLLCLK = PREDIV1 * 9 = 72 MHz */
RCC->CFGR &= (uint32_t)~(RCC_CFGR_PLLXTPRE | RCC_CFGR_PLLSRC | RCC_CFGR_PLLMULL);
RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLXTPRE_PREDIV1 | RCC_CFGR_PLLSRC_PREDIV1 |
RCC_CFGR_PLLMULL9);
#else
/* PLL configuration: PLLCLK = HSE * 9 = 72 MHz */
RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE |
RCC_CFGR_PLLMULL));
RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMULL9);
#endif /* STM32F10X_CL */
/* Enable PLL */
RCC->CR |= RCC_CR_PLLON;
/* Wait till PLL is ready */
while((RCC->CR & RCC_CR_PLLRDY) == 0)
{
}
/* Select PLL as system clock source */
RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;
/* Wait till PLL is used as system clock source */
while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08)
{
}
}
else
{ /* If HSE fails to start-up, the application will have wrong clock
configuration. User can add here some code to deal with this error */
}
}
#endif
/**
* @}
*/
/**
* @}
*/
/**
* @}
*/
/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
[/noae]
Hocam ne yapacağımı bilmiyorum nerelerde hata yapıyorum gerçekten öğrenmek istiyorum.
Arkadaşlar yardımınıza ihtyacım var. Nerede hata yapıyorum? Neden gerçekte çalışmıyor.
Şöyle bir baktığım kadarıyla bir hata görünmüyor ama keil altında debug yap. Hatayı bulursun.
Hocam debug işine baktım sürekli programı bi adım ilerletiyorum ama nedense hiç While döngüsü içine girmedi
mucit hocam
http://www.st.com/internet/mcu/product/221020.jsp (http://www.st.com/internet/mcu/product/221020.jsp)
linkten
FIRMWARE kısmından
STM32F10x standard peripheral library
zipli dosyayı indirirseniz icerisinde help dosyası mevcut. Az once ben denedim herhangi bir sorun yok.
Mucit23 hocam altaki programı derleyip kitinize bir yukleyin bakalım ne olacak.
E portundaki 4 Ledler yanıp sonmesi gerekiyor.
Sonucu bildirin devam edelim.
/* Includes ------------------------------------------------------------------*/
#include "stm32f10x.h"
#include <stdio.h>
#define RCC_GPIO_LED RCC_APB2Periph_GPIOE
#define GPIO_LED_PORT GPIOE
#define GPIO_LED1 GPIO_Pin_2
#define GPIO_LED2 GPIO_Pin_3
#define GPIO_LED3 GPIO_Pin_4
#define GPIO_LED4 GPIO_Pin_7
#define GPIO_LED_ALL GPIO_LED1 |GPIO_LED2 |GPIO_LED3 |GPIO_LED4
///////////////////////////////////////LED//////////////////////////////////////
void LED_config(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable GPIOB, GPIOC and AFIO clock */
RCC_APB2PeriphClockCmd(RCC_GPIO_LED | RCC_APB2Periph_AFIO , ENABLE); //RCC_APB2Periph_AFIO
/* LEDs pins configuration */
GPIO_InitStructure.GPIO_Pin = GPIO_LED_ALL;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIO_LED_PORT, &GPIO_InitStructure);
}
void Led_Turn_on_all(void)
{
/* Turn On All LEDs */
GPIO_ResetBits(GPIO_LED_PORT, GPIO_LED_ALL);
}
void Led_Turn_on_1(void)
{
/* Turn On LED1 */
GPIO_ResetBits(GPIO_LED_PORT, GPIO_LED1);
}
void Led_Turn_on_2(void)
{
/* Turn On LED2 */
GPIO_ResetBits(GPIO_LED_PORT, GPIO_LED2 );
}
void Led_Turn_on_3(void)
{
/* Turn On LED3 */
GPIO_ResetBits(GPIO_LED_PORT, GPIO_LED3);
}
void Led_Turn_on_4(void)
{
/* Turn On LED3 */
GPIO_ResetBits(GPIO_LED_PORT, GPIO_LED4);
}
void Led_Turn_off_all(void)
{
/* Turn Off All LEDs */
GPIO_SetBits(GPIO_LED_PORT, GPIO_LED_ALL);
}
void Led_Turn_on(u8 led)
{
Led_Turn_off_all();
/* Turn Off Select LED */
switch(led)
{
case 0:
Led_Turn_on_1();
break;
case 1:
Led_Turn_on_2();
break;
case 2:
Led_Turn_on_3();
break;
case 3:
Led_Turn_on_4();
break;
default:
Led_Turn_on_all();
break;
}
}
static void Delay(__IO uint32_t nCount)
{
for (; nCount != 0; nCount--);
}
int main(void)
{
u8 KeyNum = 0;
LED_config();
Led_Turn_on_all();
Delay(6000000);
Led_Turn_off_all();
Delay(6000000);
Led_Turn_on_all();
Delay(6000000);
Led_Turn_off_all();
Delay(6000000);
Led_Turn_on_all();
Delay(6000000);
Led_Turn_off_all();
Delay(6000000);
KeyNum=0;
/* Main loop */
while (1)
{
//Led_Turn_on_Hex(KeyNum);
Led_Turn_off_all();
Led_Turn_on(KeyNum%4);
KeyNum++;
Delay(1000000);
}
}
@mucit23 hocam ne durumdasınız Deneyebildiniz mi ?
Yok hocam İşten dolayı vakit bulup kite yükleyemedim yazılımı. Bu aralar bayağı sıkıştırıyorlar :( Kart şirkette. Ama yarın mutlaka deniyeceğim. Yoğunluktan dolayı Çok yavaş ilerliyorum.
Hocam merhabalar.
Yazılımı yükledim. Çalışıyor. Şimdilik EX33Ds üzerinde deniyorum.İlk enerji verdiğimde İşlemcinin PE.2, PE.3, PE.4 ve PE.7 bitlerindeki ledler 3 defa yanıp söndü. Ardından 2,3 ve 4. bitler yürüyen ışık efekti oluşturuyor. Ayrıca PE7 de sürekli yanıp sönüyor. Şimdi farklı birşeyler deniyeyim. En azından şu GPIO işini tamamiyle çözmem gerekiyor.
Hocam bundan sonra ne yapmamı tavsiye edersiniz.
hocam iyice pin yonlendirme tanımlamalarını ogrendikten sonra Lcd ekran kullanımı hatta TFT ekran surmeye
sonrada diğer donanımları oğrenmeye çalışın derim.
Arkadaşlar STM32F107 de usart kullanımı ve usart kesmesinin kullanıldığı örnek bir program gösterebilirmisiniz. Seri haberleşme ile uğraşıyorum. Seri yolla bilgisayara veri göndermeme rağmen bir türlü veri alamadım.
Yardımcı olursanız sevinirim.
Arkadaşlar Mehaba Daha önce hep Expkits'in boardında çalışıyordum. Şimdi aynı işlemcili başka bir boarda geçtim. Eski kodlarımı bu boardda çalıştıramadım bir türlü. İşlemcinin sistem ayarlarıyla ilgili bir problem var.
Önceki çalıştığım boardda OSC olarak 8Mhz kullanılmıştı. Yeni boardımda ise 25Mhz osc var.
İşlemcinin sistem ayarlarını buradan yapıyorum.
////////////////////////////////////////////////////////////////////////////////
// Author : [FERHAT YOL]
// Notice : Copyright (c) 2012
// : All Rights Reserved
// Date :
// Version : 1.0.0
// MCU : STM32F107VC
// Notes : DEFAULT AYARLAMALAR
////////////////////////////////////////////////////////////////////////////////
#include "stm32f10x_lib.h"
#include "port.h"
#include "main.h"
//#include "ks0108.h"
#include "com.h"
#include "adc.h"
#include "stdio.h"
//#include "ds18b20.h"
//#include "ds1302.h"
//#include "keypad.h"
void SystemInit(int clockMull);
void RCC_Configuration(int clockMull);
void NVIC_Configuration(void);
void setTimer1(u32 period,u32 prescaler,u32 clockdivision);
void delayMs(vu32 ms);
static vu32 TimingDelay;
/********************************SYSTEMINIT************************************/
void SystemInit(int clockMull){//clockMull clock carpani 1 veya 2 olabilir=> 2 olursa 64 mhz, 1 olursa 32 mhz de calisir
/* System Clocks Configuration */
RCC_Configuration(clockMull);
/* NVIC Configuration */
NVIC_Configuration();
/* SysTick clock 1ms için 4MHz (HCLK/8, default) */
SysTick_SetReload(4000);
/* SysTick Kesmesi Aktif */
SysTick_ITConfig(ENABLE);
}
/*******************************************************************************/
void setTimer1(u32 period,u32 prescaler,u32 clockdivision){
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
/* TIM1 clock enable */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
/* TIM1 ayarlari */
TIM_TimeBaseStructure.TIM_Period = period;
TIM_TimeBaseStructure.TIM_Prescaler = prescaler;
TIM_TimeBaseStructure.TIM_ClockDivision = clockdivision;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);
/* TIM1 güncelleme kesmesi aktif */
TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE);
/* TIM1 sayici aktif */
TIM_Cmd(TIM1, ENABLE);
//GPIO_Write(GPIOB,0x00FF);
}
/*******************************************************************************/
void RCC_Configuration(int clokMull)
{
/* RCC system reset(for debug purpose) */
RCC_DeInit();
/* HSE kapali */
RCC_HSEConfig(RCC_HSE_OFF);
/* Prefetch Buffer aktif */
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
/* Flash ulasimi 2 clock */
FLASH_SetLatency(FLASH_Latency_2);
/* HCLK = SYSCLK */
RCC_HCLKConfig(RCC_SYSCLK_Div1);
/* PCLK2 = HCLK */
RCC_PCLK2Config(RCC_HCLK_Div1);
/* PCLK1 = HCLK/2 */
RCC_PCLK1Config(RCC_HCLK_Div2);
/* PLLCLK = (8MHz(internal osc)/2) * 8 = 32 MHz */
RCC_PLLConfig(RCC_PLLSource_HSI_Div2, clokMull*RCC_PLLMul_8);
/* PLL Aktif */
RCC_PLLCmd(ENABLE);
/* PLL hazir olmasini bekle */
while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
/* System clock kaynagi PLL cikisi secildi */
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
/* System clock kaynagi hazir olmasini bekle */
while(RCC_GetSYSCLKSource() != 0x08);
}
/*******************************************************************************/
/*******************************************************************************/
void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
#ifdef VECT_TAB_RAM
/* Vectör kaynagi adresi: 0x20000000 */
NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
#else /* VECT_TAB_FLASH */
/* Vektör kaynagi adresi: 0x08000000 */
NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);
#endif
/* TIM1 güncellenme kesmesi tanitildi */
NVIC_InitStructure.NVIC_IRQChannel = TIM1_UP_IRQChannel;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
/***********************************delayMs**************************************/
void delayMs(u32 ms)
{
/* SysTick Counter aktif */
SysTick_CounterCmd(SysTick_Counter_Enable);
TimingDelay = ms;
while(TimingDelay != 0);
/* SysTick Counter Pasif */
SysTick_CounterCmd(SysTick_Counter_Disable);
/* SysTick Counter temizlenir */
SysTick_CounterCmd(SysTick_Counter_Clear);
}
/*******************************************************************************/
/*******************************************************************************/
void TimingDelay_Decrement(void)
{
if (TimingDelay != 0x00)
{
TimingDelay--;
}
}
/*******************************************************************************/
Burada en çok şu konuda sıkıntı çekiyorum açıkçası. Daha önce hep piclerle uğraştığım için İşlemcinin yapısını biliyordum. Yani ne nereden ayarlanır ilgili registerler hangisi olduğu hiç bilmesem bile datasheeti 10 dk incelesem çözüyordum işi.
ARM de öyle değil.
Hepsi beni ilgilendirmemekle birlikte datasheet 1000sf. Sırf bir clock ayarlarını yapmak için 5-6 tane register ile boğuşmak gerekiyor. Tabi bunları kütüphane yapıyor ama ben kütüphaneye yapması için ne söylemem gerektiğini bilmiyorum.
Bu konuda beni bilgilendirseniz sevinirim. Sormak istediklerim OSC frekansını değiştirmek için neler yapılması gerekli? CPU hızını değiştirmek için Hangi PLL çarpanıyla oynamalıyım?
Mucit
çalışacağın İşlemci Hangisi ?
aynı işlemci hocam STM32F107VC
ilk etapta Datasını indirelim..
Ben sürekli bu işlemci ile oynadığım için datasını 3 cilt halinde bastırtmıştım. Yanımda duruyor.
Bu DataSheet
http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/DATASHEET/CD00220364.pdf (http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/DATASHEET/CD00220364.pdf)
buda referans man
http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/REFERENCE_MANUAL/CD00171190.pdf (http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/REFERENCE_MANUAL/CD00171190.pdf)
refman da Figure 8. Clock tree (syf90) arat burada nereye ne yazman gerektiğini anlayacağız.
mesaj birleştirme:: 15 Kasım 2012, 18:38:25
Burada ilk kontrol edeceğimiz yer
RCC_CFGR deki Bit 17 PLLXTPRE
(RefMan sayfa 99)
Bu işi hakkıyla öğrenmek istiyorum.
karşıma bu çıktı verdiğiniz adreste
(http://s19.postimg.cc/5vw8uo2qr/Ekran_Al_nt_s.png) (http://postimg.cc/)
photo sharing (http://postimg.cc/)
Bayağı karmaşık görünüyor.
Şimdi buradan anladığım kadarıyla OSC1 girişine max. 16Mhz kristal bağlanabilir.
Benim elimdeki boardda 25mhz takılı. Bu problem olmuyormu? Yani elimdeki boardda öyle dandik dündük birşey değil. Keil'in MCBSTM32C boardı.
Dediğiniz bite baktım sanırsam giriş frekansını 2 ye bölüp bölmeyeceğimizi ayarlıyor.
Bundan sonra adım adım gidersek PLLSRC ve PLLMULL
aynen, PLLXTPRE biti girişi 2 ye bölmeyi yada doğrudan vermeyi ayarlıyor. (bu arada bu işlemciyi ben hiç kullanmadım)
sonrasında PLLSRC ile PLL ünitesinin girişi seçiliyor (HSI , HSE seçimi). PLLMUL ile çarpan ayarlanarak max 72mhz e çıkartılıyor.
Sonrasında AHB ile Bus hızları ayarlanıyor.(AHB için datasheet syf12 bakınız)
APB1 ve APB2 ye bağlı olan Pripheral lar için buralarda bölmeler yapılıyor.
Anladım dediklerinizi
25Mhz konusuna takıldım birtek. Acaba internal OSC yi mi aktif edeyim.
Şimdi bu dediklerinizi uygulamaya gelince biraz durmam gerekiyor. Kütüphanenin nasıl kullanılacağını iyice öğrenmem gerekiyor.
Bu tür ayarlar burda yapılıyor
/* RCC system reset(for debug purpose) */
RCC_DeInit();
/* HSE kapali */
RCC_HSEConfig(RCC_HSE_OFF);
/* Prefetch Buffer aktif */
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
/* Flash ulasimi 2 clock */
FLASH_SetLatency(FLASH_Latency_2);
/* HCLK = SYSCLK */
RCC_HCLKConfig(RCC_SYSCLK_Div1);
/* PCLK2 = HCLK */
RCC_PCLK2Config(RCC_HCLK_Div1);
/* PCLK1 = HCLK/2 */
RCC_PCLK1Config(RCC_HCLK_Div2);
/* PLLCLK = (8MHz(internal osc)/2) * 8 = 32 MHz */
RCC_PLLConfig(RCC_PLLSource_HSI_Div2, clokMull*RCC_PLLMul_8);
/* PLL Aktif */
RCC_PLLCmd(ENABLE);
/* PLL hazir olmasini bekle */
while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
/* System clock kaynagi PLL cikisi secildi */
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
/* System clock kaynagi hazir olmasini bekle */
while(RCC_GetSYSCLKSource() != 0x08);
Burada biraz sıkıntı çekiyorum.
mesaj birleştirme:: 15 Kasım 2012, 19:19:39
Bi sn;
HSE kapalı olarak ayarlanmış Bu durumda internal OSC aktif olmazmı?
evet
mesaj birleştirme:: 15 Kasım 2012, 19:30:43
CooCox örneği..
/**
*****************************************************************************
* @title RCC_Exp.c
* @author CooCox
* @date 31 Oct 2012
* @brief This example shows how to configure the System clock(SYSCLK) to
* have different
* frequencies: 24MHz, 36MHz, 48MHz, 56MHz and 72MH
* z (common frequencies that covers
* the major of the applications
* ).
*******************************************************************************
*/
////// The above comment is automatically generated by CoIDE ///////////////////
#include "stm32f10x.h"
#include "stm32f10x_flash.h"
#include "stm32f10x_gpio.h"
#include "stm32f10x_rcc.h"
#include "misc.h"
/* Uncomment the line corresponding to the desired System clock (SYSCLK)
frequency (after reset the HSI is used as SYSCLK source) */
//#define SYSCLK_HSE
#define SYSCLK_FREQ_24MHz
#define LED_PORT GPIOB
//#define SYSCLK_FREQ_36MHz
//#define SYSCLK_FREQ_48MHz
//#define SYSCLK_FREQ_56MHz
//#define SYSCLK_FREQ_72MHz
#define DELAY_COUNT 0x3FFFF
/***************************************************************************//**
* Global variables
******************************************************************************/
GPIO_InitTypeDef GPIO_InitStructure;
RCC_ClocksTypeDef RCC_ClockFreq;
ErrorStatus HSEStartUpStatus;
/***************************************************************************//**
* Declare function prototype
******************************************************************************/
void NVIC_Configuration(void);
void Delay(__IO uint32_t nCount);
void SetSysClock(void);
#ifdef SYSCLK_HSE
void SetSysClockToHSE(void);
#elif defined SYSCLK_FREQ_24MHz
void SetSysClockTo24(void);
#elif defined SYSCLK_FREQ_36MHz
void SetSysClockTo36(void);
#elif defined SYSCLK_FREQ_48MHz
void SetSysClockTo48(void);
#elif defined SYSCLK_FREQ_56MHz
void SetSysClockTo56(void);
#elif defined SYSCLK_FREQ_72MHz
void SetSysClockTo72(void);
#endif
/***************************************************************************//**
* @brief RCC example.This example shows how to configure the System clock(SYSCLK)
* to have different frequencies: 24MHz, 36MHz, 48MHz, 56MHz and 72MHz.
* You will see the LED PB8 PB9 PB10 blink successively.
******************************************************************************/
void RCC_Exp(void)
{
/* Configure the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers */
SetSysClock();
/* This function fills the RCC_ClockFreq structure with the current
frequencies of different on chip clocks (for debug purpose) */
RCC_GetClocksFreq(&RCC_ClockFreq);
/* Enable Clock Security System(CSS): this will generate an NMI exception
when HSE clock fails */
RCC_ClockSecuritySystemCmd( ENABLE);
/* NVIC configuration ------------------------------------------------------*/
NVIC_Configuration();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* Output HSE clock on MCO pin ---------------------------------------------*/
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
RCC_MCOConfig( RCC_MCO_HSE);
while (1)
{
/* Blink LED PB8 */
GPIO_WriteBit(LED_PORT, GPIO_Pin_8, Bit_SET);
/* Insert delay */
Delay(DELAY_COUNT);
GPIO_WriteBit(LED_PORT, GPIO_Pin_8, Bit_RESET);
Delay(DELAY_COUNT);
/* Blink LED PB9 */
GPIO_WriteBit(LED_PORT, GPIO_Pin_9, Bit_SET);
/* Insert delay */
Delay(DELAY_COUNT);
GPIO_WriteBit(LED_PORT, GPIO_Pin_9, Bit_RESET);
Delay(DELAY_COUNT);
/* Blink LED PB10 */
GPIO_WriteBit(LED_PORT, GPIO_Pin_10, Bit_SET);
/* Insert delay */
Delay(DELAY_COUNT);
GPIO_WriteBit(LED_PORT, GPIO_Pin_10, Bit_RESET);
Delay(DELAY_COUNT);
}
}
/***************************************************************************//**
* @brief Configures the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers.
******************************************************************************/
void SetSysClock(void) {
/* The System clock configuration functions defined below assume that:
- For Low, Medium and High density devices an external 8MHz crystal is
used to drive the System clock.
- For Connectivity line devices an external 25MHz crystal is used to drive
the System clock.
If you are using different crystal you have to adapt those functions accordingly.*/
#if defined SYSCLK_HSE
SetSysClockToHSE();
#elif defined SYSCLK_FREQ_24MHz
SetSysClockTo24();
#elif defined SYSCLK_FREQ_36MHz
SetSysClockTo36();
#elif defined SYSCLK_FREQ_48MHz
SetSysClockTo48();
#elif defined SYSCLK_FREQ_56MHz
SetSysClockTo56();
#elif defined SYSCLK_FREQ_72MHz
SetSysClockTo72();
#endif
/* If none of the define above is enabled, the HSI is used as System clock
source (default after reset) */
}
/***************************************************************************//**
* @brief Selects HSE as System clock source and configure HCLK, PCLK2 and PCLK1 prescalers.
******************************************************************************/
void SetSysClockToHSE(void)
{
/* SYSCLK, HCLK, PCLK2 and PCLK1 configuration -----------------------------*/
/* RCC system reset(for debug purpose) */
RCC_DeInit();
/* Enable HSE */
RCC_HSEConfig( RCC_HSE_ON);
/* Wait till HSE is ready */
HSEStartUpStatus = RCC_WaitForHSEStartUp();
if (HSEStartUpStatus == SUCCESS)
{
/* Enable Prefetch Buffer */
FLASH_PrefetchBufferCmd( FLASH_PrefetchBuffer_Enable);
/* Flash 0 wait state */
FLASH_SetLatency( FLASH_Latency_0);
/* HCLK = SYSCLK */
RCC_HCLKConfig( RCC_SYSCLK_Div1);
/* PCLK2 = HCLK */
RCC_PCLK2Config( RCC_HCLK_Div1);
/* PCLK1 = HCLK */
RCC_PCLK1Config(RCC_HCLK_Div1);
/* Select HSE as system clock source */
RCC_SYSCLKConfig( RCC_SYSCLKSource_HSE);
/* Wait till PLL is used as system clock source */
while (RCC_GetSYSCLKSource() != 0x04)
{
}
}
else
{ /* If HSE fails to start-up, the application will have wrong clock configuration.
User can add here some code to deal with this error */
/* Go to infinite loop */
while (1)
{
}
}
}
/***************************************************************************//**
* @brief Sets System clock frequency to 24MHz and configure HCLK, PCLK2 and PCLK1 prescalers.
******************************************************************************/
void SetSysClockTo24(void)
{
/* SYSCLK, HCLK, PCLK2 and PCLK1 configuration -----------------------------*/
/* RCC system reset(for debug purpose) */
RCC_DeInit();
/* Enable HSE */
RCC_HSEConfig( RCC_HSE_ON);
/* Wait till HSE is ready */
HSEStartUpStatus = RCC_WaitForHSEStartUp();
if (HSEStartUpStatus == SUCCESS)
{
/* Enable Prefetch Buffer */
FLASH_PrefetchBufferCmd( FLASH_PrefetchBuffer_Enable);
/* Flash 0 wait state */
FLASH_SetLatency( FLASH_Latency_0);
/* HCLK = SYSCLK */
RCC_HCLKConfig( RCC_SYSCLK_Div1);
/* PCLK2 = HCLK */
RCC_PCLK2Config( RCC_HCLK_Div1);
/* PCLK1 = HCLK */
RCC_PCLK1Config(RCC_HCLK_Div1);
/* PLLCLK = 8MHz * 3 = 24 MHz */
RCC_PLLConfig(0x00010000, 0x00040000);
/* Enable PLL */
RCC_PLLCmd( ENABLE);
/* Wait till PLL is ready */
while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
{
}
/* Select PLL as system clock source */
RCC_SYSCLKConfig( RCC_SYSCLKSource_PLLCLK);
/* Wait till PLL is used as system clock source */
while (RCC_GetSYSCLKSource() != 0x08)
{
}
}
else
{ /* If HSE fails to start-up, the application will have wrong clock configuration.
User can add here some code to deal with this error */
/* Go to infinite loop */
while (1)
{
}
}
}
/***************************************************************************//**
* @brief Sets System clock frequency to 36MHz and configure HCLK, PCLK2 and PCLK1 prescalers.
******************************************************************************/
void SetSysClockTo36(void)
{
/* SYSCLK, HCLK, PCLK2 and PCLK1 configuration -----------------------------*/
/* RCC system reset(for debug purpose) */
RCC_DeInit();
/* Enable HSE */
RCC_HSEConfig( RCC_HSE_ON);
/* Wait till HSE is ready */
HSEStartUpStatus = RCC_WaitForHSEStartUp();
if (HSEStartUpStatus == SUCCESS)
{
/* Enable Prefetch Buffer */
FLASH_PrefetchBufferCmd( FLASH_PrefetchBuffer_Enable);
/* Flash 1 wait state */
FLASH_SetLatency( FLASH_Latency_1);
/* HCLK = SYSCLK */
RCC_HCLKConfig( RCC_SYSCLK_Div1);
/* PCLK2 = HCLK */
RCC_PCLK2Config( RCC_HCLK_Div1);
/* PCLK1 = HCLK */
RCC_PCLK1Config(RCC_HCLK_Div1);
/* PLLCLK = (8MHz / 2) * 9 = 36 MHz */
RCC_PLLConfig(0x00030000, RCC_PLLMul_9);
/* Enable PLL */
RCC_PLLCmd( ENABLE);
/* Wait till PLL is ready */
while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
{
}
/* Select PLL as system clock source */
RCC_SYSCLKConfig( RCC_SYSCLKSource_PLLCLK);
/* Wait till PLL is used as system clock source */
while (RCC_GetSYSCLKSource() != 0x08)
{
}
}
else
{ /* If HSE fails to start-up, the application will have wrong clock configuration.
User can add here some code to deal with this error */
/* Go to infinite loop */
while (1)
{
}
}
}
/***************************************************************************//**
* @brief Sets System clock frequency to 48MHz and configure HCLK, PCLK2 and PCLK1 prescalers.
******************************************************************************/
void SetSysClockTo48(void)
{
/* SYSCLK, HCLK, PCLK2 and PCLK1 configuration -----------------------------*/
/* RCC system reset(for debug purpose) */
RCC_DeInit();
/* Enable HSE */
RCC_HSEConfig( RCC_HSE_ON);
/* Wait till HSE is ready */
HSEStartUpStatus = RCC_WaitForHSEStartUp();
if (HSEStartUpStatus == SUCCESS)
{
/* Enable Prefetch Buffer */
FLASH_PrefetchBufferCmd( FLASH_PrefetchBuffer_Enable);
/* Flash 1 wait state */
FLASH_SetLatency( FLASH_Latency_1);
/* HCLK = SYSCLK */
RCC_HCLKConfig( RCC_SYSCLK_Div1);
/* PCLK2 = HCLK */
RCC_PCLK2Config( RCC_HCLK_Div1);
/* PCLK1 = HCLK/2 */
RCC_PCLK1Config( RCC_HCLK_Div2);
/* PLLCLK = 8MHz * 6 = 48 MHz */
RCC_PLLConfig(0x00010000, RCC_PLLMul_6);
/* Enable PLL */
RCC_PLLCmd( ENABLE);
/* Wait till PLL is ready */
while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
{
}
/* Select PLL as system clock source */
RCC_SYSCLKConfig( RCC_SYSCLKSource_PLLCLK);
/* Wait till PLL is used as system clock source */
while (RCC_GetSYSCLKSource() != 0x08)
{
}
}
else
{ /* If HSE fails to start-up, the application will have wrong clock configuration.
User can add here some code to deal with this error */
/* Go to infinite loop */
while (1)
{
}
}
}
/***************************************************************************//**
* @brief Sets System clock frequency to 56MHz and configure HCLK, PCLK2 and PCLK1 prescalers.
******************************************************************************/
void SetSysClockTo56(void)
{
/* SYSCLK, HCLK, PCLK2 and PCLK1 configuration -----------------------------*/
/* RCC system reset(for debug purpose) */
RCC_DeInit();
/* Enable HSE */
RCC_HSEConfig( RCC_HSE_ON);
/* Wait till HSE is ready */
HSEStartUpStatus = RCC_WaitForHSEStartUp();
if (HSEStartUpStatus == SUCCESS)
{
/* Enable Prefetch Buffer */
FLASH_PrefetchBufferCmd( FLASH_PrefetchBuffer_Enable);
/* Flash 2 wait state */
FLASH_SetLatency( FLASH_Latency_2);
/* HCLK = SYSCLK */
RCC_HCLKConfig( RCC_SYSCLK_Div1);
/* PCLK2 = HCLK */
RCC_PCLK2Config( RCC_HCLK_Div1);
/* PCLK1 = HCLK/2 */
RCC_PCLK1Config( RCC_HCLK_Div2);
/* PLLCLK = 8MHz * 7 = 56 MHz */
RCC_PLLConfig(0x00010000, RCC_PLLMul_7);
/* Enable PLL */
RCC_PLLCmd( ENABLE);
/* Wait till PLL is ready */
while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
{
}
/* Select PLL as system clock source */
RCC_SYSCLKConfig( RCC_SYSCLKSource_PLLCLK);
/* Wait till PLL is used as system clock source */
while (RCC_GetSYSCLKSource() != 0x08)
{
}
}
else
{ /* If HSE fails to start-up, the application will have wrong clock configuration.
User can add here some code to deal with this error */
/* Go to infinite loop */
while (1)
{
}
}
}
/***************************************************************************//**
* @brief Sets System clock frequency to 72MHz and configure HCLK, PCLK2 and PCLK1 prescalers.
******************************************************************************/
void SetSysClockTo72(void)
{
/* SYSCLK, HCLK, PCLK2 and PCLK1 configuration -----------------------------*/
/* RCC system reset(for debug purpose) */
RCC_DeInit();
/* Enable HSE */
RCC_HSEConfig( RCC_HSE_ON);
/* Wait till HSE is ready */
HSEStartUpStatus = RCC_WaitForHSEStartUp();
if (HSEStartUpStatus == SUCCESS)
{
/* Enable Prefetch Buffer */
FLASH_PrefetchBufferCmd( FLASH_PrefetchBuffer_Enable);
/* Flash 2 wait state */
FLASH_SetLatency( FLASH_Latency_2);
/* HCLK = SYSCLK */
RCC_HCLKConfig( RCC_SYSCLK_Div1);
/* PCLK2 = HCLK */
RCC_PCLK2Config( RCC_HCLK_Div1);
/* PCLK1 = HCLK/2 */
RCC_PCLK1Config( RCC_HCLK_Div2);
/* PLLCLK = 8MHz * 9 = 72 MHz */
RCC_PLLConfig(0x00010000, RCC_PLLMul_9);
/* Enable PLL */
RCC_PLLCmd( ENABLE);
/* Wait till PLL is ready */
while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
{
}
/* Select PLL as system clock source */
RCC_SYSCLKConfig( RCC_SYSCLKSource_PLLCLK);
/* Wait till PLL is used as system clock source */
while (RCC_GetSYSCLKSource() != 0x08)
{
}
}
else
{ /* If HSE fails to start-up, the application will have wrong clock configuration.
User can add here some code to deal with this error */
/* Go to infinite loop */
while (1)
{
}
}
}
/***************************************************************************//**
* @brief Configures Vector Table base location.
******************************************************************************/
void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
/* Enable and configure RCC global IRQ channel */
NVIC_InitStructure.NVIC_IRQChannel = RCC_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
/**
* @brief Inserts a delay time.
* @param nCount: specifies the delay time length.
* @retval None
*/
void Delay(__IO uint32_t nCount)
{
for(; nCount!= 0;nCount--);
}
/***************************************************************************//**
* @brief This function handles RCC interrupt request.
******************************************************************************/
void RCC_IRQHandler(void)
{
if (RCC_GetITStatus(RCC_IT_HSERDY) != RESET)
{
/* Clear HSERDY interrupt pending bit */
RCC_ClearITPendingBit( RCC_IT_HSERDY);
/* Check if the HSE clock is still available */
if (RCC_GetFlagStatus(RCC_FLAG_HSERDY) != RESET)
{
/* Enable PLL: once the PLL is ready the PLLRDY interrupt is generated */
RCC_PLLCmd( ENABLE);
}
}
if (RCC_GetITStatus(RCC_IT_PLLRDY) != RESET)
{
/* Clear PLLRDY interrupt pending bit */
RCC_ClearITPendingBit( RCC_IT_PLLRDY);
/* Check if the PLL is still locked */
if (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) != RESET)
{
/* Select PLL as system clock source */
RCC_SYSCLKConfig( RCC_SYSCLKSource_PLLCLK);
}
}
}
/***************************************************************************//**
* @brief This function handles NMI exception.
******************************************************************************/
void NMI_Handler(void)
{
/* This interrupt is generated when HSE clock fails */
if (RCC_GetITStatus(RCC_IT_CSS) != RESET)
{
/* At this stage: HSE, PLL are disabled (but no change on PLL config) and HSI
is selected as system clock source */
/* Enable HSE */
RCC_HSEConfig( RCC_HSE_ON);
/* Enable HSE Ready interrupt */
RCC_ITConfig(RCC_IT_HSERDY, ENABLE);
/* Enable PLL Ready interrupt */
RCC_ITConfig(RCC_IT_PLLRDY, ENABLE);
/* Clear Clock Security System interrupt pending bit */
RCC_ClearITPendingBit( RCC_IT_CSS);
/* Once HSE clock recover, the HSERDY interrupt is generated and in the RCC ISR
routine the system clock will be reconfigured to its previous state (before
HSE clock failure) */
}
}
Şuan kart yanımda değil yarın tekrar deneyeceğim.
CooCox ile Keil arasında kullanım açısından fark varmı? Kod yapısı aynı herhalde, Neden CooCox kullanıyorsunuz
Kod tamamlama var. tek sebebim bu. Eklediğim kütüphane içerisindeki fonksiyonları kod yazarken görebiliyorsun. Unutmadan Bedava
Eclipse Tabanlı bir derleyici.
Code Red e de bakacağım.
Hocam I2C ile uğraşıyorum. Keil library si içerisindeki stm32f10x_i2c.h dosyası içerisindeki aşağıdaki foksiyonlar nerede icra edilir
void I2C_DeInit(I2C_TypeDef* I2Cx);
void I2C_Init(I2C_TypeDef* I2Cx, I2C_InitTypeDef* I2C_InitStruct);
void I2C_StructInit(I2C_InitTypeDef* I2C_InitStruct);
void I2C_Cmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_DMACmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_DMALastTransferCmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_GenerateSTART(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_GenerateSTOP(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_AcknowledgeConfig(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_OwnAddress2Config(I2C_TypeDef* I2Cx, u8 Address);
void I2C_DualAddressCmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_GeneralCallCmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_ITConfig(I2C_TypeDef* I2Cx, u16 I2C_IT, FunctionalState NewState);
void I2C_SendData(I2C_TypeDef* I2Cx, u8 Data);
u8 I2C_ReceiveData(I2C_TypeDef* I2Cx);
void I2C_Send7bitAddress(I2C_TypeDef* I2Cx, u8 Address, u8 I2C_Direction);
u16 I2C_ReadRegister(I2C_TypeDef* I2Cx, u8 I2C_Register);
void I2C_SoftwareResetCmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_SMBusAlertConfig(I2C_TypeDef* I2Cx, u16 I2C_SMBusAlert);
void I2C_TransmitPEC(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_PECPositionConfig(I2C_TypeDef* I2Cx, u16 I2C_PECPosition);
void I2C_CalculatePEC(I2C_TypeDef* I2Cx, FunctionalState NewState);
u8 I2C_GetPEC(I2C_TypeDef* I2Cx);
void I2C_ARPCmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_StretchClockCmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_FastModeDutyCycleConfig(I2C_TypeDef* I2Cx, u16 I2C_DutyCycle);
u32 I2C_GetLastEvent(I2C_TypeDef* I2Cx);
ErrorStatus I2C_CheckEvent(I2C_TypeDef* I2Cx, u32 I2C_EVENT);
FlagStatus I2C_GetFlagStatus(I2C_TypeDef* I2Cx, u32 I2C_FLAG);
void I2C_ClearFlag(I2C_TypeDef* I2Cx, u32 I2C_FLAG);
ITStatus I2C_GetITStatus(I2C_TypeDef* I2Cx, u32 I2C_IT);
void I2C_ClearITPendingBit(I2C_TypeDef* I2Cx, u32 I2C_IT);
Bu fonsiyonları bulamadım bir türlü..
Önce kütüpaneyi derle sonra fonksiyona çift tıklayıp "Go To definition of " a tıkla fonksiyon karşına gelir.
stm32f10x_i2c.c nin içinde olacak muhtemelen.
Hocam dediğiniz yöntem benim hazırladığım fonksiyonlarda çalışıyor. Ama kayıp fonskiyonları ararken çalışmadı.
keil bana bunu söylüyor
(http://s19.postimg.cc/anatknxlv/Ekran_Al_nt_s.png) (http://postimg.cc/)
photo uploader (http://postimg.cc/)
Sanırım tarayıcıda tanımlanmamış diyor. ilginç :o :o
kütüpanenin C uzantısını bulun C/C++ menüsünden adresini görebileceği biyere yapıştırın veya bulunduğu adresi gösterin sonra derleyin go to komutu çalışacaktır.
Anlamadımki bende :o
Kütüphane içerisindeki stm32f10x_i2c.h dosyasının içeriği bu şekilde
/******************** (C) COPYRIGHT 2008 STMicroelectronics ********************
* File Name : stm32f10x_i2c.h
* Author : MCD Application Team
* Version : V2.0.1
* Date : 06/13/2008
* Description : This file contains all the functions prototypes for the
* I2C firmware library.
********************************************************************************
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
* AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
* INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
* CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
* INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*******************************************************************************/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __STM32F10x_I2C_H
#define __STM32F10x_I2C_H
/* Includes ------------------------------------------------------------------*/
#include "stm32f10x_map.h"
/* Exported types ------------------------------------------------------------*/
/* I2C Init structure definition */
typedef struct
{
u16 I2C_Mode;
u16 I2C_DutyCycle;
u16 I2C_OwnAddress1;
u16 I2C_Ack;
u16 I2C_AcknowledgedAddress;
u32 I2C_ClockSpeed;
}I2C_InitTypeDef;
/* Exported constants --------------------------------------------------------*/
#define IS_I2C_ALL_PERIPH(PERIPH) (((*(u32*)&(PERIPH)) == I2C1_BASE) || \
((*(u32*)&(PERIPH)) == I2C2_BASE))
/* I2C modes */
#define I2C_Mode_I2C ((u16)0x0000)
#define I2C_Mode_SMBusDevice ((u16)0x0002)
#define I2C_Mode_SMBusHost ((u16)0x000A)
#define IS_I2C_MODE(MODE) (((MODE) == I2C_Mode_I2C) || \
((MODE) == I2C_Mode_SMBusDevice) || \
((MODE) == I2C_Mode_SMBusHost))
/* I2C duty cycle in fast mode */
#define I2C_DutyCycle_16_9 ((u16)0x4000)
#define I2C_DutyCycle_2 ((u16)0xBFFF)
#define IS_I2C_DUTY_CYCLE(CYCLE) (((CYCLE) == I2C_DutyCycle_16_9) || \
((CYCLE) == I2C_DutyCycle_2))
/* I2C cknowledgementy */
#define I2C_Ack_Enable ((u16)0x0400)
#define I2C_Ack_Disable ((u16)0x0000)
#define IS_I2C_ACK_STATE(STATE) (((STATE) == I2C_Ack_Enable) || \
((STATE) == I2C_Ack_Disable))
/* I2C transfer direction */
#define I2C_Direction_Transmitter ((u8)0x00)
#define I2C_Direction_Receiver ((u8)0x01)
#define IS_I2C_DIRECTION(DIRECTION) (((DIRECTION) == I2C_Direction_Transmitter) || \
((DIRECTION) == I2C_Direction_Receiver))
/* I2C acknowledged address defines */
#define I2C_AcknowledgedAddress_7bit ((u16)0x4000)
#define I2C_AcknowledgedAddress_10bit ((u16)0xC000)
#define IS_I2C_ACKNOWLEDGE_ADDRESS(ADDRESS) (((ADDRESS) == I2C_AcknowledgedAddress_7bit) || \
((ADDRESS) == I2C_AcknowledgedAddress_10bit))
/* I2C registers */
#define I2C_Register_CR1 ((u8)0x00)
#define I2C_Register_CR2 ((u8)0x04)
#define I2C_Register_OAR1 ((u8)0x08)
#define I2C_Register_OAR2 ((u8)0x0C)
#define I2C_Register_DR ((u8)0x10)
#define I2C_Register_SR1 ((u8)0x14)
#define I2C_Register_SR2 ((u8)0x18)
#define I2C_Register_CCR ((u8)0x1C)
#define I2C_Register_TRISE ((u8)0x20)
#define IS_I2C_REGISTER(REGISTER) (((REGISTER) == I2C_Register_CR1) || \
((REGISTER) == I2C_Register_CR2) || \
((REGISTER) == I2C_Register_OAR1) || \
((REGISTER) == I2C_Register_OAR2) || \
((REGISTER) == I2C_Register_DR) || \
((REGISTER) == I2C_Register_SR1) || \
((REGISTER) == I2C_Register_SR2) || \
((REGISTER) == I2C_Register_CCR) || \
((REGISTER) == I2C_Register_TRISE))
/* I2C SMBus alert pin level */
#define I2C_SMBusAlert_Low ((u16)0x2000)
#define I2C_SMBusAlert_High ((u16)0xDFFF)
#define IS_I2C_SMBUS_ALERT(ALERT) (((ALERT) == I2C_SMBusAlert_Low) || \
((ALERT) == I2C_SMBusAlert_High))
/* I2C PEC position */
#define I2C_PECPosition_Next ((u16)0x0800)
#define I2C_PECPosition_Current ((u16)0xF7FF)
#define IS_I2C_PEC_POSITION(POSITION) (((POSITION) == I2C_PECPosition_Next) || \
((POSITION) == I2C_PECPosition_Current))
/* I2C interrupts definition */
#define I2C_IT_BUF ((u16)0x0400)
#define I2C_IT_EVT ((u16)0x0200)
#define I2C_IT_ERR ((u16)0x0100)
#define IS_I2C_CONFIG_IT(IT) ((((IT) & (u16)0xF8FF) == 0x00) && ((IT) != 0x00))
/* I2C interrupts definition */
#define I2C_IT_SMBALERT ((u32)0x10008000)
#define I2C_IT_TIMEOUT ((u32)0x10004000)
#define I2C_IT_PECERR ((u32)0x10001000)
#define I2C_IT_OVR ((u32)0x10000800)
#define I2C_IT_AF ((u32)0x10000400)
#define I2C_IT_ARLO ((u32)0x10000200)
#define I2C_IT_BERR ((u32)0x10000100)
#define I2C_IT_TXE ((u32)0x00000080)
#define I2C_IT_RXNE ((u32)0x00000040)
#define I2C_IT_STOPF ((u32)0x60000010)
#define I2C_IT_ADD10 ((u32)0x20000008)
#define I2C_IT_BTF ((u32)0x60000004)
#define I2C_IT_ADDR ((u32)0xA0000002)
#define I2C_IT_SB ((u32)0x20000001)
#define IS_I2C_CLEAR_IT(IT) (((IT) == I2C_IT_SMBALERT) || ((IT) == I2C_IT_TIMEOUT) || \
((IT) == I2C_IT_PECERR) || ((IT) == I2C_IT_OVR) || \
((IT) == I2C_IT_AF) || ((IT) == I2C_IT_ARLO) || \
((IT) == I2C_IT_BERR) || ((IT) == I2C_IT_STOPF) || \
((IT) == I2C_IT_ADD10) || ((IT) == I2C_IT_BTF) || \
((IT) == I2C_IT_ADDR) || ((IT) == I2C_IT_SB))
#define IS_I2C_GET_IT(IT) (((IT) == I2C_IT_SMBALERT) || ((IT) == I2C_IT_TIMEOUT) || \
((IT) == I2C_IT_PECERR) || ((IT) == I2C_IT_OVR) || \
((IT) == I2C_IT_AF) || ((IT) == I2C_IT_ARLO) || \
((IT) == I2C_IT_BERR) || ((IT) == I2C_IT_TXE) || \
((IT) == I2C_IT_RXNE) || ((IT) == I2C_IT_STOPF) || \
((IT) == I2C_IT_ADD10) || ((IT) == I2C_IT_BTF) || \
((IT) == I2C_IT_ADDR) || ((IT) == I2C_IT_SB))
/* I2C flags definition */
#define I2C_FLAG_DUALF ((u32)0x00800000)
#define I2C_FLAG_SMBHOST ((u32)0x00400000)
#define I2C_FLAG_SMBDEFAULT ((u32)0x00200000)
#define I2C_FLAG_GENCALL ((u32)0x00100000)
#define I2C_FLAG_TRA ((u32)0x00040000)
#define I2C_FLAG_BUSY ((u32)0x00020000)
#define I2C_FLAG_MSL ((u32)0x00010000)
#define I2C_FLAG_SMBALERT ((u32)0x10008000)
#define I2C_FLAG_TIMEOUT ((u32)0x10004000)
#define I2C_FLAG_PECERR ((u32)0x10001000)
#define I2C_FLAG_OVR ((u32)0x10000800)
#define I2C_FLAG_AF ((u32)0x10000400)
#define I2C_FLAG_ARLO ((u32)0x10000200)
#define I2C_FLAG_BERR ((u32)0x10000100)
#define I2C_FLAG_TXE ((u32)0x00000080)
#define I2C_FLAG_RXNE ((u32)0x00000040)
#define I2C_FLAG_STOPF ((u32)0x60000010)
#define I2C_FLAG_ADD10 ((u32)0x20000008)
#define I2C_FLAG_BTF ((u32)0x60000004)
#define I2C_FLAG_ADDR ((u32)0xA0000002)
#define I2C_FLAG_SB ((u32)0x20000001)
#define IS_I2C_CLEAR_FLAG(FLAG) (((FLAG) == I2C_FLAG_SMBALERT) || ((FLAG) == I2C_FLAG_TIMEOUT) || \
((FLAG) == I2C_FLAG_PECERR) || ((FLAG) == I2C_FLAG_OVR) || \
((FLAG) == I2C_FLAG_AF) || ((FLAG) == I2C_FLAG_ARLO) || \
((FLAG) == I2C_FLAG_BERR) || ((FLAG) == I2C_FLAG_STOPF) || \
((FLAG) == I2C_FLAG_ADD10) || ((FLAG) == I2C_FLAG_BTF) || \
((FLAG) == I2C_FLAG_ADDR) || ((FLAG) == I2C_FLAG_SB))
#define IS_I2C_GET_FLAG(FLAG) (((FLAG) == I2C_FLAG_DUALF) || ((FLAG) == I2C_FLAG_SMBHOST) || \
((FLAG) == I2C_FLAG_SMBDEFAULT) || ((FLAG) == I2C_FLAG_GENCALL) || \
((FLAG) == I2C_FLAG_TRA) || ((FLAG) == I2C_FLAG_BUSY) || \
((FLAG) == I2C_FLAG_MSL) || ((FLAG) == I2C_FLAG_SMBALERT) || \
((FLAG) == I2C_FLAG_TIMEOUT) || ((FLAG) == I2C_FLAG_PECERR) || \
((FLAG) == I2C_FLAG_OVR) || ((FLAG) == I2C_FLAG_AF) || \
((FLAG) == I2C_FLAG_ARLO) || ((FLAG) == I2C_FLAG_BERR) || \
((FLAG) == I2C_FLAG_TXE) || ((FLAG) == I2C_FLAG_RXNE) || \
((FLAG) == I2C_FLAG_STOPF) || ((FLAG) == I2C_FLAG_ADD10) || \
((FLAG) == I2C_FLAG_BTF) || ((FLAG) == I2C_FLAG_ADDR) || \
((FLAG) == I2C_FLAG_SB))
/* I2C Events */
/* EV1 */
#define I2C_EVENT_SLAVE_TRANSMITTER_ADDRESS_MATCHED ((u32)0x00060082) /* TRA, BUSY, TXE and ADDR flags */
#define I2C_EVENT_SLAVE_RECEIVER_ADDRESS_MATCHED ((u32)0x00020002) /* BUSY and ADDR flags */
#define I2C_EVENT_SLAVE_TRANSMITTER_SECONDADDRESS_MATCHED ((u32)0x00860080) /* DUALF, TRA, BUSY and TXE flags */
#define I2C_EVENT_SLAVE_RECEIVER_SECONDADDRESS_MATCHED ((u32)0x00820000) /* DUALF and BUSY flags */
#define I2C_EVENT_SLAVE_GENERALCALLADDRESS_MATCHED ((u32)0x00120000) /* GENCALL and BUSY flags */
/* EV2 */
#define I2C_EVENT_SLAVE_BYTE_RECEIVED ((u32)0x00020040) /* BUSY and RXNE flags */
/* EV3 */
#define I2C_EVENT_SLAVE_BYTE_TRANSMITTED ((u32)0x00060084) /* TRA, BUSY, TXE and BTF flags */
/* EV4 */
#define I2C_EVENT_SLAVE_STOP_DETECTED ((u32)0x00000010) /* STOPF flag */
/* EV5 */
#define I2C_EVENT_MASTER_MODE_SELECT ((u32)0x00030001) /* BUSY, MSL and SB flag */
/* EV6 */
#define I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED ((u32)0x00070082) /* BUSY, MSL, ADDR, TXE and TRA flags */
#define I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED ((u32)0x00030002) /* BUSY, MSL and ADDR flags */
/* EV7 */
#define I2C_EVENT_MASTER_BYTE_RECEIVED ((u32)0x00030040) /* BUSY, MSL and RXNE flags */
/* EV8 */
#define I2C_EVENT_MASTER_BYTE_TRANSMITTED ((u32)0x00070084) /* TRA, BUSY, MSL, TXE and BTF flags */
/* EV9 */
#define I2C_EVENT_MASTER_MODE_ADDRESS10 ((u32)0x00030008) /* BUSY, MSL and ADD10 flags */
/* EV3_2 */
#define I2C_EVENT_SLAVE_ACK_FAILURE ((u32)0x00000400) /* AF flag */
#define IS_I2C_EVENT(EVENT) (((EVENT) == I2C_EVENT_SLAVE_TRANSMITTER_ADDRESS_MATCHED) || \
((EVENT) == I2C_EVENT_SLAVE_RECEIVER_ADDRESS_MATCHED) || \
((EVENT) == I2C_EVENT_SLAVE_TRANSMITTER_SECONDADDRESS_MATCHED) || \
((EVENT) == I2C_EVENT_SLAVE_RECEIVER_SECONDADDRESS_MATCHED) || \
((EVENT) == I2C_EVENT_SLAVE_GENERALCALLADDRESS_MATCHED) || \
((EVENT) == I2C_EVENT_SLAVE_BYTE_RECEIVED) || \
((EVENT) == (I2C_EVENT_SLAVE_BYTE_RECEIVED | I2C_FLAG_DUALF)) || \
((EVENT) == (I2C_EVENT_SLAVE_BYTE_RECEIVED | I2C_FLAG_GENCALL)) || \
((EVENT) == I2C_EVENT_SLAVE_BYTE_TRANSMITTED) || \
((EVENT) == (I2C_EVENT_SLAVE_BYTE_TRANSMITTED | I2C_FLAG_DUALF)) || \
((EVENT) == (I2C_EVENT_SLAVE_BYTE_TRANSMITTED | I2C_FLAG_GENCALL)) || \
((EVENT) == I2C_EVENT_SLAVE_STOP_DETECTED) || \
((EVENT) == I2C_EVENT_MASTER_MODE_SELECT) || \
((EVENT) == I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) || \
((EVENT) == I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) || \
((EVENT) == I2C_EVENT_MASTER_BYTE_RECEIVED) || \
((EVENT) == I2C_EVENT_MASTER_BYTE_TRANSMITTED) || \
((EVENT) == I2C_EVENT_MASTER_MODE_ADDRESS10) || \
((EVENT) == I2C_EVENT_SLAVE_ACK_FAILURE))
/* I2C own address1 -----------------------------------------------------------*/
#define IS_I2C_OWN_ADDRESS1(ADDRESS1) ((ADDRESS1) <= 0x3FF)
/* I2C clock speed ------------------------------------------------------------*/
#define IS_I2C_CLOCK_SPEED(SPEED) (((SPEED) >= 0x1) && ((SPEED) <= 400000))
/* Exported macro ------------------------------------------------------------*/
/* Exported functions ------------------------------------------------------- */
void I2C_DeInit(I2C_TypeDef* I2Cx);
void I2C_Init(I2C_TypeDef* I2Cx, I2C_InitTypeDef* I2C_InitStruct);
void I2C_StructInit(I2C_InitTypeDef* I2C_InitStruct);
void I2C_Cmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_DMACmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_DMALastTransferCmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_GenerateSTART(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_GenerateSTOP(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_AcknowledgeConfig(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_OwnAddress2Config(I2C_TypeDef* I2Cx, u8 Address);
void I2C_DualAddressCmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_GeneralCallCmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_ITConfig(I2C_TypeDef* I2Cx, u16 I2C_IT, FunctionalState NewState);
void I2C_SendData(I2C_TypeDef* I2Cx, u8 Data);
u8 I2C_ReceiveData(I2C_TypeDef* I2Cx);
void I2C_Send7bitAddress(I2C_TypeDef* I2Cx, u8 Address, u8 I2C_Direction);
u16 I2C_ReadRegister(I2C_TypeDef* I2Cx, u8 I2C_Register);
void I2C_SoftwareResetCmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_SMBusAlertConfig(I2C_TypeDef* I2Cx, u16 I2C_SMBusAlert);
void I2C_TransmitPEC(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_PECPositionConfig(I2C_TypeDef* I2Cx, u16 I2C_PECPosition);
void I2C_CalculatePEC(I2C_TypeDef* I2Cx, FunctionalState NewState);
u8 I2C_GetPEC(I2C_TypeDef* I2Cx);
void I2C_ARPCmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_StretchClockCmd(I2C_TypeDef* I2Cx, FunctionalState NewState);
void I2C_FastModeDutyCycleConfig(I2C_TypeDef* I2Cx, u16 I2C_DutyCycle);
u32 I2C_GetLastEvent(I2C_TypeDef* I2Cx);
ErrorStatus I2C_CheckEvent(I2C_TypeDef* I2Cx, u32 I2C_EVENT);
FlagStatus I2C_GetFlagStatus(I2C_TypeDef* I2Cx, u32 I2C_FLAG);
void I2C_ClearFlag(I2C_TypeDef* I2Cx, u32 I2C_FLAG);
ITStatus I2C_GetITStatus(I2C_TypeDef* I2Cx, u32 I2C_IT);
void I2C_ClearITPendingBit(I2C_TypeDef* I2Cx, u32 I2C_IT);
#endif /*__STM32F10x_I2C_H */
/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
Bu dosyanın .c uzantılı olanını bulamıyorum. Muhtemelen burada tanımlanmış fonksiyonlar orada icra ediliyor. Onu bulamıyorum.
http://s2.dosya.tc/server21/WtEanu/stm32f10x_i2c.rar.html (http://s2.dosya.tc/server21/WtEanu/stm32f10x_i2c.rar.html)
Hocam verdiğiniz için teşekkür ederim.
Ben Şunu merak ediyorum aslında. Bu verdiğim kütüphanelerin .c dosyaları kullanılmıyormu? Kullanılmıyorsa eğer nasıl program çalılışıyor. Bu sorumun cevabını arıyorum. Kütüphanenin gösterdiği .h dosyalarında hepsi tanımlı.
kullanılmaz olur mu? kullanılıyor tabi ki.
.H dosyada fonksiyonların prototipleri tanımlı.
.C dosyasında ise, fonksiyonun kendisi.
Derleyici önce .C dosyalarını ayrı ayrı derliyor. Diyelim ki sizin main.c derlenirken, read_i2c(...) diye bir fonksiyon gördü. Amca bu fonksiyonu çağıracak kodu oluşturacak ama, fonksiyonun parametreleri nelerdir? parametre tipleri nedir?, dönüş tipi nedir? bunları bilmiyor. bunu bilmek için gidip .H dosyasından bunlara bakıyor. O an gerçekte fonksiyonun ne iş yaptığını bilmiyor, sadece parametrelerini vs... öğreniyor. ilgili .C dosyası da aynı şekilde derleniyor. Derleme sonunda bir dosya oluşuyor , bu dosyada çağırılacak fonksiyonlar , bunların parametreleri vs.. sembolik. Sonra link aşamasına geçiliyor. Link aşamasında bütün bu sembolik tanımlar gerçek tanımlarla çevriliyor, ona göre adres ayarlamaları vs.. yapılıp hex kod üretiliyor.
Bulamadığım gizli .c dosyaları derlenirken mi ortaya çıkıyor? Bu kısmı tam olarak anlayamadım.
https://www.picproje.org/index.php/topic,43088.0.html (https://www.picproje.org/index.php/topic,43088.0.html)
bu mesajdaki gibi proje ağacının olduğu kısmın ve project components bölümünün resimlerini yükleyebilirmisin.
Soldaki proje ağacında .C dosyalar görünmüyor mu?
Derlenmiş kütüphane ile mi çalışıyorsun acaba?
Hocam Proje ağacı resimdeki gibi.
(http://s19.postimg.cc/fuvwp4e77/Ekran_Al_nt_s.png) (http://postimg.cc/image/j1qg8qyn3/full/)
image hosting sites (http://postimg.cc/)
Proje ağacında benim hazırlamış olduğum kütüphaneler görünüyor. ama keilin kütüphanesine ait olanlardan sadece .h olanlar görünüyor.
proje ağacında main.c altına baktığımda dosyalar aşağıdaki gibi.
(http://s19.postimg.cc/idhlpszxf/Ekran_Al_nt_s_2.png) (http://postimg.cc/image/mzdpy5lgf/full/)
images (http://postimg.cc/)
Derlenmiş kütüphane ile çalıştığın için göremiyorsun. Proje ağacında "STM32F10xR.Lib" var.
Bütün kütüphane derlenip .LIB dosyası haline getirilmiş.
Kaynak kodları görmek istiyorsan, ST'nin sitesinden kütüphaneyi indirip, kullanacaklarını projeye dahil etmen gerek.
Anladım demek istediğinizi. Teşekkür ederim.
Arkadaşlar 20ms de bir kesme oluşmasını istiyorum. Bu iş için timer bölücü ayarlarını nasıl yapmalıyım. Hesaplamaları nasıl oluyor
systick kullanabilirsin.
SysTick_Config(SystemCoreClock/20000);
Timer kullanacaksan
InitStruct.TIM_Prescaler =72 ;
InitStruct.TIM_Period =19999;
Hocam timer ile kullanarak yapayım diyorum. Yanlız bu verdiğiniz değerleri nasıl hesapladınız. OSC frekansına göre değişmezmi bu?
Değişir tabiki. STM32F103 için, 72Mhz kullanıldığı ve APB bölücüsünün 1 olduğunu varsaydım. Genellikle hep en yüksek hızda kullanmaya meyilliyizdir diye.
Hesap basit.
Timer kesme süresi = (PSC * (ARR+1)) / APB frekansı.
APB Frekansı = 72MHz olsun
PSC =72
ARR = 19999
Önce 72000000 Hz frekansımız Prescaler tarafından 72 ye bölünür.
Timer girişine uygulanacak saat frekansı 1MHz olacak demekki.
Yani Counter bir saniyede 1 Milyon sayacak. Veya 1 mikrosaniyede bir sayacak.
Counter değeri ARR değerine geldiğinde kesme üretilecek.
20mS istediğimize göre ve 1 mikrosaniyede 1 arttığımıza göre, 20000 kez sayarsa 20mS edecek.
Neden 1 eksik değer verdik?
Sayıcı ARR değerine ulaştığında kesme üretilir. Ancak sayıcının sıfırlanması bir sonraki saat darbesinde gerçekleşir. Yani fazladan 1 saat darbesi süre geçer. İşte bu süreyi ARR değerinden çıkarıyoruz.
Hocam Sizin Hesap Benim ölçümlerime uymuyor
İşlemciyi Harici 8Mhz osc ile Çalıştırdım. Sonra PLLMull değerini 9 yaptımki PLLCLK Değeri 72Mhz Olsun. Sonra AHB ve ABP2 Bölücüsünün değerinide 1 yaptım Dolayısıyla Timer1 giriş Frekansı 72 Mhz olması gerekir.
Bu durumda Timer1 Taşma değerini ve Bölücüsünü sizin verdiğiniz değerlerde yapınca yaklaşık 500ms de bir kesme oluşuyor. Bi yerde hata yapıyorum mutlaka.
Kesme frekansını anlamak için kesme içerisinde 1 pini sürekli toggle yapıp osiloskopla çıkış frekansına bakıyorum.
Nerde hata yapıyor olabilirim.
Main.C programım bu şekilde
#include "stm32f107.h"
#include "stdio.h"
#include <rtl.h>
#define arraySize(array) (sizeof(array)/sizeof(*array))
#define ServoPin 11
#define Servo(x) ((x) ? (GPIO_SetBits(portC,(1<<ServoPin))) : (GPIO_ResetBits(portC,(1<<ServoPin))) );
void sendUSART1(char *array);
int tx_c=0;
BOOL i=0;
int main()
{
/***********BASLANGIC AYARLARI************/
SystemInit(1);
// initADC1();
setTimer1(19999,72,1);
//initRS232(9600);
/***************KS0108 INIT********************/
setOutMode(portD,0xFFFF);//glcd data pinleri PortD nin agirlikli ilk 8 bitine bagli
setOutMode(portE,0xFFFF);
setOutMode(portC,0xFFFF);
/**********************************************/
while(1)
{
//DelayUs(500);
}
}
void sendUSART1(char *array){
int size=strlen(array);
for(tx_c=0;tx_c<=size;tx_c++){
rs232SendData(array,size);
//delayMs(1);
}
}
void Timer1_Interrupt()
{
i=1-i;
Servo(i);
}
Buda İşlemcinin genel ayarlarını yaptığım stm32F107.h dosyası
////////////////////////////////////////////////////////////////////////////////
// Author : [FERHAT YOL]
// Notice : Copyright (c) 2012
// : All Rights Reserved
// Date :
// Version : 1.0.0
// MCU : STM32F107VC
// Notes : DEFAULT AYARLAMALAR
////////////////////////////////////////////////////////////////////////////////
#include "stm32f10x_lib.h"
#include "port.h"
#include "main.h"
//#include "ks0108.h"
#include "com.h"
#include "adc.h"
#include "stdio.h"
//#include "ds18b20.h"
//#include "ds1302.h"
//#include "keypad.h"
//#define arraySize(array) (sizeof(array)/sizeof(*array))
void SystemInit(int clockMull);
void RCC_Configuration(int clockMull);
void NVIC_Configuration(void);
void setTimer1(u32 period,u32 prescaler,u32 clockdivision);
void delayMs(vu32 ms);
static vu32 TimingDelay;
/********************************SYSTEMINIT************************************/
void SystemInit(int clockMull){//clockMull clock carpani 1 veya 2 olabilir=> 2 olursa 64 mhz, 1 olursa 32 mhz de calisir
/* System Clocks Configuration */
RCC_Configuration(clockMull);
/* NVIC Configuration */
NVIC_Configuration();
/* SysTick clock 1ms için 4MHz (HCLK/8, default) */
SysTick_SetReload(4000);
/* SysTick Kesmesi Aktif */
SysTick_ITConfig(ENABLE);
}
/*******************************************************************************/
void setTimer1(u32 period,u32 prescaler,u32 clockdivision){
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
/* TIM1 clock enable */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
/* TIM1 ayarlari */
TIM_TimeBaseStructure.TIM_Period = period;
TIM_TimeBaseStructure.TIM_Prescaler = prescaler;
TIM_TimeBaseStructure.TIM_ClockDivision = clockdivision;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);
/* TIM1 güncelleme kesmesi aktif */
TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE);
/* TIM1 sayici aktif */
TIM_Cmd(TIM1, ENABLE);
//GPIO_Write(GPIOB,0x00FF);
}
/*******************************************************************************/
void RCC_Configuration(int clokMull)
{
/* RCC system reset(for debug purpose) */
RCC_DeInit();
/*Osilatör Seçimi buradan Yapilir. */
RCC_HSEConfig(RCC_HSE_ON);
/* Prefetch Buffer aktif */
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
/* Flash ulasimi 2 clock */
FLASH_SetLatency(FLASH_Latency_2);
/* AHB Clock Divided*/
RCC_HCLKConfig(RCC_SYSCLK_Div1);
/* ABP2 Clock Divided */
RCC_PCLK2Config(RCC_HCLK_Div1);
/* ABP1 Clock Divided */
RCC_PCLK1Config(RCC_HCLK_Div2);
/* PLLCLK = (8MHz External OSC) * 8 = 72 MHz */
RCC_PLLConfig(RCC_PLLSource_HSE_Div1, clokMull*RCC_PLLMul_9);
/* PLL Aktif */
RCC_PLLCmd(ENABLE);
/* PLL hazir olmasini bekle */
while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
/* System clock kaynagi PLL cikisi secildi */
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
/* System clock kaynagi hazir olmasini bekle */
while(RCC_GetSYSCLKSource() != 0x08);
}
/*******************************************************************************/
/*******************************************************************************/
void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
#ifdef VECT_TAB_RAM
/* Vectör kaynagi adresi: 0x20000000 */
NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
#else /* VECT_TAB_FLASH */
/* Vektör kaynagi adresi: 0x08000000 */
NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);
#endif
/* TIM1 güncellenme kesmesi tanitildi */
NVIC_InitStructure.NVIC_IRQChannel = TIM1_UP_IRQChannel;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
/***********************************delayMs**************************************/
void delayMs(u32 ms)
{
/* SysTick Counter aktif */
SysTick_CounterCmd(SysTick_Counter_Enable);
TimingDelay = ms;
while(TimingDelay != 0);
/* SysTick Counter Pasif */
SysTick_CounterCmd(SysTick_Counter_Disable);
/* SysTick Counter temizlenir */
SysTick_CounterCmd(SysTick_Counter_Clear);
}
/*******************************************************************************/
/*******************************************************************************/
void TimingDelay_Decrement(void)
{
if (TimingDelay != 0x00)
{
TimingDelay--;
}
}
/*******************************************************************************/
Servo süremeye çalışıyorum aslında Bir türlü 20ms lik kesme süresini tutturamadık.
Birde Kesme içerisinde beklersem ne olur? Dediğim gibi Servo sürmeye çalışıyorum 20ms de bir 1-2ms arası clock palsi çıkarmam lazım.
Muhtemelen 72MHz hızına çıkamıyorsunuz. 8MHz'de kalıyorsa 180 milisaniyede bir kesme gelir.
Kesme içerisinde beklemek (Hatta kesme dışında herhangi bir yerde beklemek) hiç bir zaman yapmadığım, kimseye de yap demeyeceğim bir uygulama.
Eğer 20 milisaniyede bir darbe ihtiyacınız varsa , Zamanlayıcıyı PWM modunda çalıştırıp darbe genişliğini istediğiniz gibi ayarlarsınız.
Sistemin clock ayarlarını ben yapmıyorum. Kütüphanedeki start kodları yapıyor. STM32F4 denemelerinde de hep @bunalmıs hocanın ayarlarını kullandım. Dolayısıyla bu işlemcide RCC konusuna hiç bir zaman hakim olamadım. Bu sebeple Clock ayarlarınızda hata olup olmadığını anlayamıyorum.
sitedeki örneklerde muhakkak bununla ilgili bir şeyler vardır.
TIMER NVIC ayarlarında da bir sorun var sanırım. (Kullandığımız kütüphaneden kaynaklı bir fark olabilir)
NVIC_InitStructure.NVIC_IRQChannel = TIM1_UP_IRQChannel;
satırı şu şekilde olmalıydı.
NVIC_InitStruct.NVIC_IRQChannel = TIM2_IRQn;
Benim konfigürasyonum bu.
TIM_TBInitStruct.TIM_Prescaler =72 ;
TIM_TBInitStruct.TIM_Period =20000;
TIM_TimeBaseInit(TIM2,&TIM_TBInitStruct);
TIM_ITConfig(TIM2,TIM_IT_Update,ENABLE);
NVIC_InitStruct.NVIC_IRQChannel = TIM2_IRQn;
NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStruct);
TIM_Cmd(TIM2, ENABLE);
void TIM2_IRQHandler(void)
{
TIM_ClearITPendingBit(TIM2,TIM_IT_Update);
GPIOA->ODR ^= 0x100;
}
1-2 yıl kadar önce Bir arkadaş getirtirken yanında 50 Adet STM32F103C8T6 getirtmiştim. Adet fiyatı 1.6 Dolara gelmişti.
Aliexpres'ten baktım 1.6$ civarı bulunabiliyor. Buraya maliyeti 2 doları bulur.
tekrar, kendi adıma ,mçip e boşuna öpülmüşüz
@Gerbay,
Hocam Çinden alışveriş yapıyorsanız inanın herşey olabilir. Aliexpress den ise bende alıveriş yapmıştım. Ürünün gelip gelmemesinde bir problem olmuyor. Ürünün Problemli gelmesi düşük bir ihtimal ama olabilir sonuçta. Güvenilen satıcılardan ürün alınmalı.
Bu işlemcilerde Hazır Kütüphane kullanırken Bende dediğiniz gibi zorluk çekiyorum işlerin nasıl yürüdüğünü gerçekten anlayamıyorum. En son internetten RCC ayarlarının yapıldığı stm32f10x_rcc.c dosyasını indirip neyin ne işe yaradığını hangi bölücünün neyi böldüğünü öğrendim. Bundan sonra gerekli ayarları yaptığımda işler dahada berbatlaştı. Olmadı Bülent Hocamızın yaptığı yöntemle yapacağım. Eğer işlemci 72Mhz de çalışıyorsa yukarıda verdiğim kodlarda timer içerisinde yaptığım işlemi main içerisinde yaparsam kaç Khz lik bir çıkış sinyali almam gerekir?
Servo sürmek için önerebileceğiniz iyi bir yöntem varmı? PWM ile yapabileceğimi düşünüyorum. Öyle olursa hem pwm donanımını öğrenirim hemde işimi görürüm.
Normalde Piclerde yaklaşık 4mhz osc için CCP donanımında 250Hz den düşük pwm frekansı alınamıyor. ARM de bu durum nasıl? 50Hz pwm sinyali alabilirmiyim? Bu konuyu öğrenmek istiyorum. Yol gösterirseniz sevinirim.
mesaj birleştirme:: 22 Kasım 2012, 18:47:17
Alıntı yapılan: muhittin_kaplan - 22 Kasım 2012, 18:42:21
tekrar, kendi adıma ,mçip e boşuna öpülmüşüz
Hocam Doğru söylüyorsunuzda bu ARM nin de bin türlü derdi var. :o :o
1 haftadır pcb ye monte (ki lehimlemek de sıkıntı yarattı) mcu ya stlink üzerinden prog atmaya çalışıyorum. neyse benim iş halloldu, sıra bunda bilinky.
mesaj birleştirme:: 22 Kasım 2012, 18:56:09
ben olsam PWM ile hallederim
Alıntı YapServo sürmek için önerebileceğiniz iyi bir yöntem varmı? PWM ile yapabileceğimi düşünüyorum. Öyle olursa hem pwm donanımını öğrenirim hemde işimi görürüm.
Normalde Piclerde yaklaşık 4mhz osc için CCP donanımında 250Hz den düşük pwm frekansı alınamıyor. ARM de bu durum nasıl? 50Hz pwm sinyali alabilirmiyim? Bu konuyu öğrenmek istiyorum. Yol gösterirseniz sevinirim.
APB frekansın max = 72MHz. olsun.
Bölücümüz 16 bit = max 65535 olabilir. (Bölme ile ilgili bir kısıtlama görmedim)
Reload değerimiz 16 bit = max 65535 olabilir. (Yeniden yükleme için de bir kısıtlamaya rastlamadım)
Saatimizi bölücüden geçirelim.
72000000 / 65535 = 1098 Sayıcımız saniyede 1098 kez sayacak ve ARR değerine ulaştığında sıfırlanacak.
1098 / 65535 = yaklaşık 0.017 Yani PWM frekansımız en düşük 0.017Hz olabiliyormuş. neredeyse 1 dakika süren darbe uzunluğu mümkün. 50 Hertzin lafı bile olmaz.
Bundan sonra gerekli ayarları yaptığımda işler dahada berbatlaştı. Olmadı Bülent Hocamızın yaptığı yöntemle yapacağım. Bu kod CooCox ile gelen Startup dosyasındaki SystemInit() fonksiyonu.
void SystemInit (void)
{
/* Reset the RCC clock configuration to the default reset state(for debug purpose) */
/* Set HSION bit */
RCC->CR |= (uint32_t)0x00000001;
/* Reset SW, HPRE, PPRE1, PPRE2, ADCPRE and MCO bits */
#ifndef STM32F10X_CL
RCC->CFGR &= (uint32_t)0xF8FF0000;
#else
RCC->CFGR &= (uint32_t)0xF0FF0000;
#endif /* STM32F10X_CL */
/* Reset HSEON, CSSON and PLLON bits */
RCC->CR &= (uint32_t)0xFEF6FFFF;
/* Reset HSEBYP bit */
RCC->CR &= (uint32_t)0xFFFBFFFF;
/* Reset PLLSRC, PLLXTPRE, PLLMUL and USBPRE/OTGFSPRE bits */
RCC->CFGR &= (uint32_t)0xFF80FFFF;
#ifdef STM32F10X_CL
/* Reset PLL2ON and PLL3ON bits */
RCC->CR &= (uint32_t)0xEBFFFFFF;
/* Disable all interrupts and clear pending bits */
RCC->CIR = 0x00FF0000;
/* Reset CFGR2 register */
RCC->CFGR2 = 0x00000000;
#elif defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || (defined STM32F10X_HD_VL)
/* Disable all interrupts and clear pending bits */
RCC->CIR = 0x009F0000;
/* Reset CFGR2 register */
RCC->CFGR2 = 0x00000000;
#else
/* Disable all interrupts and clear pending bits */
RCC->CIR = 0x009F0000;
#endif /* STM32F10X_CL */
#if defined (STM32F10X_HD) || (defined STM32F10X_XL) || (defined STM32F10X_HD_VL)
#ifdef DATA_IN_ExtSRAM
SystemInit_ExtMemCtl();
#endif /* DATA_IN_ExtSRAM */
#endif
/* Configure the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers */
/* Configure the Flash Latency cycles and enable prefetch buffer */
SetSysClock();
#ifdef VECT_TAB_SRAM
SCB->VTOR = SRAM_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal SRAM. */
#else
SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal FLASH. */
#endif
}
Bu da 4 kanallı pwm
void init_rcc(void){
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2 | RCC_APB1Periph_TIM3 | \
RCC_APB1Periph_TIM4 | RCC_APB1Periph_USART3,ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB |\
RCC_APB2Periph_GPIOC | RCC_APB2Periph_AFIO,ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1 | RCC_AHBPeriph_CRC,ENABLE);
}
void init_tim2(void){
TIM_TimeBaseInitTypeDef TIM_TBInitStruct;
TIM_OCInitTypeDef TIM_OCInitStruct;
TIM_TBInitStruct.TIM_Period = 7200;
TIM_TBInitStruct.TIM_Prescaler =199;
TIM_TBInitStruct.TIM_ClockDivision = 0;
TIM_TBInitStruct.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM3, &TIM_TBInitStruct);
TIM_OCInitStruct.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStruct.TIM_OCPolarity = TIM_OCPolarity_Low;
TIM_OCInitStruct.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStruct.TIM_Pulse = 0;
TIM_OC1Init(TIM3, &TIM_OCInitStruct);
TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Enable);
TIM_OCInitStruct.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStruct.TIM_Pulse = 0;
TIM_OC2Init(TIM3, &TIM_OCInitStruct);
TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Enable);
TIM_OCInitStruct.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStruct.TIM_Pulse = 0;
TIM_OC3Init(TIM3, &TIM_OCInitStruct);
TIM_OC3PreloadConfig(TIM3, TIM_OCPreload_Enable);
TIM_OCInitStruct.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStruct.TIM_Pulse = 0;
TIM_OC4Init(TIM3, &TIM_OCInitStruct);
TIM_OC4PreloadConfig(TIM3, TIM_OCPreload_Enable);
TIM_ARRPreloadConfig(TIM3, ENABLE);
TIM_Cmd(TIM3,ENABLE);
}
/********* PWM Duty oranını değiştirmek ************************************/
// Burada kütüphane fonksiyonlarını kullanmadım.
TIM3->CCR4 = 126;
TIM3->CCR3 = 185;
TIM3->CCR2 = 99;
TIM3->CCR1 = 36;
Yarın Hocam PWM üzerine bir çalışma yapacağım. Pek Zor Görünmüyor.
mesaj birleştirme:: 23 Kasım 2012, 09:40:39
Bu işlemci 72Mhz ve üzerinde de çalışıyor
OSC ye bağlı Kristal 8mhz. Bu frekansı hiç bölmeden 14 ile çarptım. Normalde 112 Mhz de çalışması gerekir. Bunu tam doğrulayamıyorum ama Mail içerisinde Aşağıdak kodu çalıştırdığımda
while(1)
{
i=1-i;
Servo(i);
}
Çıkış pininde 1,790Mhz sinyal alıyorum. 72Mhz de çalıştırdığımda aynı pinden aldığım sinyal 757.94 Khz Alıyorum.
Klein Hocam bence sizin timer hesaplamalarında bir problem var. Çünkü Dediğiniz gibi yapınca pwm frekansı Timerden aldığım frekans çok çok düşük değerler.
Timer hesaplamalarında bir hata yok.emin olabilirsin. Verdiğim kodu birisi çalıştıramadığı zaman muhakkak denerim.
Netekim denedim ve verdiğim hesaplamalarda bir hata olmadığını gördüm.
İlginç bir durum. Geriye birtek soru işareti kalıyor. Oda Timer bölücüsünde. Acaba onumu yanlış yapıyoruz? Gerçi sizin verdiğiniz gibi bir değerde yaptım ama olmuyor.
Sizin verdiğiniz Timer Hesabında PSC değeri Timer bölücüsü değilmi? Bu konuda birtek bu takıldı aklıma.
Neyse Artık bu konuda uğraşmayacağım.
Servoyu çalıştırdım ama main içerisinde sadece 50Hz sinyali çıkardım. kesme içerisidede buton vs okudum. Pek iyi bir yöntem olmadı.
Son olarak 2 soru daha sormak isterim.
PWM'i tekrar deneyeceğim ama aklıma takıldı. Datasheette direk belirtilmemiş. Bu işlemcide PWM çıkışları hangisi?
Birde Systick donanımında ms cinsinden bekleme yapabiliyorum. us cinsinden bekleme yapabilmek için işlemciyi boş döndüren bir fonksiyon kullanıyorum ama nedense ondada lineerliği yakalayamadım. Çok garip bir durum.
Mesela 32Mhz için 100us bekleme için aldığım delay değerini 6 ile çarpıp elde edilen değer kadar işlemciyi boşta döndürüyorum. Osiloskopla baktığımda tam istediğim gibi .
Ama Diyelim işlemcinin hızını 64Mhz ye çıkardığımda 100us için bekleme yukarıda verdiğim delay katsayılarınıda iki katına çıkardığımda bu sefer işlemci 100 bekleyecekse 150 bekliyor. Bu konuda çok saçma geldi bana.
Gerçekten işlemciye hakim olmadan program yazmak zor birşey. Heleki ARM de
Hem uS cinsinden Hemde Ms cinsinden bekleme yapmak için SyStick donanımı kullanılabilirmi?
İşlemcide PWM çıkışları, Timer çıkışları.
TIM4_CH1 , TIM3CH2, TIM2_CH2 gibi pinler var. Bunlar timer çıkışları. Aynı zamanda PWM çıkışları. Her Timerin 4 tane çıkış ya da girişi var.
Evet PSC değeri bölücü değeri. Bölücü değerinin hesaplamasında da sorun yok. 50Hz için denedim.
SysTick ile 1uS elde edemiyorsun. Girişi 9Mhz 9'a bölünce 1uS elde etmek lazım. Ama 10 mikrosaniyenin altına inmedi. Datasheetlere bakmak lazım. Ama diğer Timerler oraya iniyor. Tim2 için denedim sorun yok. İnebiliyor. Ama 1uS oldukça iddialı bir değer. Başka kesmeler içerisinde yapılan işler 1uS'den uzunsürüyorsa, stabil bir değer alması oldukça zor.
Eğer başka kesmeler içerisinde Timer kesmesini bekletecek bir şey yosa şöyle yapabilirsin.
volatile uint32_t delay_counter;
void init_tim2(void)
{
NVIC_InitTypeDef NVIC_InitStruct;
TIM_TimeBaseInitTypeDef TIM_TBInitStruct;
TIM_OCInitTypeDef TIM_OCInitStruct;
TIM_TBInitStruct.TIM_Prescaler =34;
TIM_TBInitStruct.TIM_Period =1;
TIM_TimeBaseInit(TIM2,&TIM_TBInitStruct);
TIM_ITConfig(TIM2,TIM_IT_Update,ENABLE);
NVIC_InitStruct.NVIC_IRQChannel = TIM2_IRQn;
NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStruct);
TIM_Cmd(TIM2, ENABLE);
}
void TIM2_IRQHandler(void)
{
delay_counter--;
TIM_ClearITPendingBit(TIM2,TIM_IT_Update);
}
void delay(uint32_t delay)
{
delay_counter = delay;
while(delay_counter);
}
//**************** çağırma *************************
delay(10); // 10uS + çağırma, geri dönme vs.. zamanı
delay(100); //100uS + "
Hocam birşey sormak isterim. Keil ile birlikte gelen örnek kodları deney kitine yükediğim zaman program otomatikmen çalışmaya başlıyor. Fakat benim yazdığım programları yükledikten sonra elle reset atmam gerekiyor. Keilde bunun bir ayarı olması lazım. Bende otomatikmen başlamasını istiyorum. Nasıl yapabilirim?
Ayarların içerisinde var.
U-Link kullanıyorsanız : utilities sekmesinden, U-Link ayarları butonu ile açılan pencereden "Flash Download" sekmesine.
orada "Reset and Run" kutucuğunun tikini kaldırmak gerek.
ST-Link için
omut satırına girdiğimiz parametrelerin en sonundaki "-Rst -Run " komutlarını kaldırmak gerek.
(hiç denemedim.)
Teşekkürler hocam. Oldu şimdi.
mesaj birleştirme:: 26 Kasım 2012, 17:20:38
Hocam Sayenizde PWM, Timer ve SPİ gibi donanımların kullanımını öğrendim. Sıra Geldi I2C ye.
Hedefim I2C ile Deney kiti üzerindeki ivme sensörünü okumak. İvme sensörü olarak LIS302DL kullanılmış. Discovery kitlerin üzerindekilerle aynı fakat discovery kitlerde işlemciye SPİ ile bağlanmış. Bendekinde I2C hattına bağlanmış. I2C ile ilgili örnek bir uygulama gösterebilirmisiniz
Arkadaşlar Merhaba ARM ye devam..
DS1302 için kullandığınız önerebileceğiniz bir kütüphane varmı?
Arkadaşlar merhaba
bugün eskiden başka bir bilgisayarda çalıştığım bir keil projesini açıp derlemeye çalıştım. Fakat bazı hatalar alıyorum.
(http://s2.postimg.cc/rl865bc2x/Ekran_Al_nt_s.png) (http://postimg.cc/image/ettzyt2at/full/)
pic upload (http://postimg.cc/)
Projeyi derlerken ilk başta resimde gördüğünüz hatanın aynısını verip stm32f10x_lib.h dosyası yok diyordu. Bu dosyayı internetten bulup Keil>>ARM>>INC>>ST>>STM32F10X klasörü içerisine kopyaladım. Derlemeye çalıştığımda bu sefer stm32f10x_lib.c dosyası yok dedi. Aynı işlemleri bu dosya içinde yapıp derlediğimde bu sefer map.h dosyası yok dedi. Bunuda bulup aynı yere kopyaladım. Bu sefer resimdeki gibi stm32f10x_conf.h yok diyor. Bu böyle sonsuza kadar gidecek diye düşünmeye başladım. Acaba problem ne olabilir?
Geçenlerde keili güncellemiştim. 4.60 versiyonuna yükselttim ama eski versiyonu silmeden üzerine yüklemiştim.
edit; Sorun çözülmüştür. Sanırım güncelleme ile birlikte tüm kütüphane dosyaları silinmiş..
Merhaba,
Eski dosyalarınızı backup dosyasının içinden çekebilirsiniz.
Güncelleme esnasında Keil, Keil klasörüne Backup.001 şeklinde klasör oluşturup içine atmakta..
Arkadaşlar STM32F107 de dahili eepromu nasıl kullanırım. Bu konuda fazla örnek yok malesef
eeproma 16 bitlik datalar yazıp okumak istiyorum
Dahili EEPROM yok diye hatırlıyorum , sadece low power modellerde vardı
Hocam eepromun bulunmaması çok kötü benim için Flash hafızayı kullanmam gerekiyor. Bu konuda bilginiz varmı? harici eeprom kullanmadan ramdeki bazı değerleri nasıl saklarım?
Bir de battery backup memory olacaktı , pil olduğu sürece canlı tutulan bir RAM alanı var. Yazma/okuma sınırsız.
Alıntı yapılan: gerbay - 22 Ocak 2013, 14:07:06
hocam "mesela" şöyle bir yol izleyebilirsiniz;
MCU nun kendi flash ının en üst bölgesindeki ihtiyacınızı görecek kadar alanı bu iş için ayırın, flash ın boyutu o kadar daha az gibi düşünüp programlarken o kısmın üzerinde yazılmasına izin vermeyin. Kendi yazılımınızda flash ınızın o bölgesine istediğiniz gibi yazıp çizin..
Normal MCU nun içindeki NOR flash dan bahsediyorum.
ST nin AN3226 sına bir göz atın..
Hocam bakayım dediğinize
Sistemde CR2032 saat pili var. Bu pili Vbat girişine bağlarsam değişkeler silinirmi? Silinmemesi için ne yapmalıyım?
Timer1 konusunda anlamadığım bazı terimler var.
Timer1 kesmesini kurmak için timer 1 sayacını aşağıdaki kodlarla set ediyorum.
void setTimer1(u32 period,u32 prescaler,u32 clockdivision){
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
/* TIM1 clock enable */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
/* TIM1 ayarlari */
TIM_TimeBaseStructure.TIM_Period = period;
TIM_TimeBaseStructure.TIM_Prescaler = prescaler;
TIM_TimeBaseStructure.TIM_ClockDivision = clockdivision;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure);
/* TIM1 güncelleme kesmesi aktif */
TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE);
/* TIM1 sayici aktif */
TIM_Cmd(TIM1, ENABLE);
}
Timer1 Periyot ve prescaller terimleri anlayamadım. Bu terimlerle neyi değitiryorum. Mesela 1 saniyede oluşacak timer1 kesmesi sayısını arttırmam için ne yapmam gerekir?
Merhabalar hocam.
STM32F107 nin usartında problem yaşıyorum. Usart Donanımı yanlış fakat Benim Data gönderme fonksiyonumda terslik var.
Data göndermek için basitçe şöyle bir fonksiyon hazırlamıştım
void Send_Data(char data){
USART_ITConfig(USART1, USART_IT_TXE, ENABLE);
//USART1 kanali reset durumunda degilse
if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET)
{
USART_SendData(USART1, data);
USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
}
}
1 Byte datayı bu şekilde problem olmadan gönderiyorum. Ama mesela bir diziyi gönderecem Dizinin her bir elemanını gönderdikten sonra araya delya koymasam dizideki datalar yarım yamalak gidiyor. Mesela şöyle birşey yaptım.
while(1){
Send_Data(char_data1[x]);
x++;if (x>149){x=0;}
delayMs(1);
}
1ms delay koymasam usart modülü sanırsam işlemci hızına yetişemiyor olacakki dataların bazılarını gönderemiyor yani saçmalıyor.
Bu arada 115200 baudrate ile haberleşiyorum
Benim Tahminim şöyle. Usartın bir adet TX bufferi var.
USART_SendData(USART1, data);
Biz bu komutla elimizdeki datayı bu buffere yerleştiriyoruz ama demekki buffer boşalmadan bizim main programımız buraya bir data daha yerleştiriryor. Dolayısıyla program saçmalamaya başlıyor.
Bu iş için Data gönderme fonksiyonuna bir Status biti koymalıyım. Usart Bufferi boşalmadığı sürece bu fonksiyon bana 0 gönderecek. boşaldığı zaman status bitini 1 yapıp bana geri dönecek. Bende böylece gönderme işleminin tamamlandığını anlayıp bir sonraki paketi göndereceğim.
Bu işlemi nasıl yaparım?
Bu işi dmaya ihale etsen?Bak bir şey buldum işine yarar mı bilmem :)
http://www.st.com/st-web-ui/static/active/en/resource/technical/document/reference_manual/CD00171190.pdf (http://www.st.com/st-web-ui/static/active/en/resource/technical/document/reference_manual/CD00171190.pdf)
Sayfa 784 den itibaren bir şeyler anlatıyor ama sana yarayacak mı?
Ekleme:İleriki sayfalara baktım da şimdi.Bir de transmit data registery empty kesmesi var?
Bir de aşağılarda bir tablo var.Dma usart5 ile kullanılamıyor sanırım.Ben mi yanlış anladım..
Alıntı YapBu iş için Data gönderme fonksiyonuna bir Status biti koymalıyım. Usart Bufferi boşalmadığı sürece bu fonksiyon bana 0 gönderecek. boşaldığı zaman status bitini 1 yapıp bana geri dönecek. Bende böylece gönderme işleminin tamamlandığını anlayıp bir sonraki paketi göndereceğim.
Bu işi yapabileceğini hissettiğim status reg var (usart_sr) 7. bitini sorgulayınca tx bufferın durumunu görüntüleyebiliyormuşsun.
6. bitte ise aktarımın durumunu sorgulayabiliyormuşsun.Metinleri çok okumadım belki de yanılıyorumdur.İdare et artık.
Bak kurcaladıkça çıkıyor arkadaş :) Dma daha ileriki kontrol reglerde.Onlara da bakabilirsin aslında.Neyse faydalı olur inşallah.Beni de bilgilendirirsen ben de hatalarımı göreyim..
USART register'lerinde status register'inde (USART_SR) TC biti transfer bittiğinde 1 değerini alıyor. Transfer sürerken 0 değerinde.
Sıralı gönderirken , gönderimin arakasına aşağıdaki eklenebilir. Registeri belirtmek için USART->SR->TC yazdım keilde karşılığı nedir onu eklersiniz.
Send_Data(char_data1 [ x ] ) ;
While(USART->SR->TC); //transfer bitene kadar bekle
@Mucit23 usartın Tx interrupt enable özelliği vardır. Bunu kurarak her bir byte gönderiminde sana ben bir byte veri gönderdim diyerek kesme oluşturur. @Klein hocamın forumda bir örneği mevcut. https://www.picproje.org/index.php/topic,43436.msg316773.html#msg316773 (https://www.picproje.org/index.php/topic,43436.msg316773.html#msg316773) Buradan daha detaylı öğrenebilirsin.
Şimdilik status registerine bakarak hallederim ama Dma kullansam super olacak. Usart ın yanında dma kullanımını da öğrenmiş olurum. Yarın bunun üzerine çalışayım biraz.
Hocam USART->SR->TC ye ulaşamıyorum.
while (!USART->SR->TC){} Bu şekilde bir kullanım yanlışmı?
SRC\main.c(104): error: #20: identifier "USART" is undefined
USART diye birşey tanımlı değil diyor. Bu registerin TC bitine nasıl ulaşırım
Eğer tek karakter göndereceksen TC bitini bekleyebilrsin. Peşpeşe birden fazla karakter göndereceksen TXE bitini beklemen gerek. Eğer RS485 kullanmıyorsan TC bitini beklemene gerek yok. RS485 kullanacaksan eğer karakter aralarında TXE bitini , tüm karakterlerin gönderimi bittikten sonra , RS485 çipini alma moduna getirmek için TC bitini beklemen gerek.
while(!(USART3->SR&0x80)); //TXE biti.
TC bitinin hangi bit olduğunu hatırlamıyorum.
https://www.picproje.org/index.php/topic,43180.0.html (https://www.picproje.org/index.php/topic,43180.0.html)
Eğer kütüphane kullanıyorsan
USART_GetFlagStatus(USART3,USART_Flags_TXE)
USART_GetFlagStatus(USART3,USART_Flags_TC)
Ekleme:
TC biti SR registerinin 6. biti imiş.
while(!(USART3->SR&0x40)); //TC biti.
Klein Hocam Merhabalar.
Bugün Sizin STM32F4 DMA+ADC örneğinizden yola çıkarak Aynısını stm32f1x de iki kanal için yapmaya çalıştım.
Yaptığım ayarlamalar şöyle.
#include "stm32f10x_lib.h"
void initADC1(void);
void ADC1_DMAConfig(void);
void adc_channel_config(void);
u16 readADC1(u8 channel);
u8 ADC1H(u8 channel); /*Okunan ADC kanalinin yuksek degerlikli 8 bitini donderir*/
u8 ADC1L(u8 channel); /*Okunan ADC kanalinin dusuk degerlikli 8 bitini donderir*/
u16 ADC_DMAValue[2];
/*ADC baslanagic ayarlari yuklenme islemini yapar */
void initADC1(){
ADC_InitTypeDef ADC_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOA, ENABLE);
/* ADC pin analog input yapiliyor */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(GPIOA, &GPIO_InitStructure);
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_InitStructure.ADC_ScanConvMode = ENABLE;
ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_NbrOfChannel = 2;
ADC_Init(ADC1, &ADC_InitStructure);
ADC_Cmd(ADC1, ENABLE);
/* ADC1 Reset Kalibrasyonu yapilacak */
ADC_ResetCalibration(ADC1);
/* Kalibrasyon bekleniyor */
while(ADC_GetResetCalibrationStatus(ADC1));
/* ADC1 calibrasyonu yapilacak */
ADC_StartCalibration(ADC1);
/* Kalibrasyon bekleniyor */
while(ADC_GetCalibrationStatus(ADC1));
}
//1. Adc Modülü DMA Ayarlari...
void ADC1_DMAConfig(void){
DMA_InitTypeDef DMA_InitStructure;
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE); //DMA Saat girisi Aktif Ediliyor..
DMA_Cmd(DMA1_Channel1,DISABLE);
DMA_DeInit ( DMA1_Channel1);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)0x4001244C; // ADC->DR Adresi
DMA_InitStructure.DMA_MemoryBaseAddr = (u32) ADC_DMAValue; // hedef adresimiz
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; // ADC kaynak. Veri yönü ADC -> Hafiza
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; // ADC adresi sabit kalacak
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; // Her deger alindigina memory adresi 1 artirilacak
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord; // Kaynaktan alinacak veri 16 bit
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord; // Hedef büyüklügü 16 bit
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular; // 8 veri alindiktan sonra basa dönülecek.
DMA_InitStructure.DMA_Priority = DMA_Priority_High ; // Kanal Önceligi yüksek. ( bu bize kalmis)
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; // hafizadan hafizaya transfer kapali.
DMA_InitStructure.DMA_BufferSize = 2; // Alacagimiz verisayisi 2 ( 2 kanal adc okuyacagiz)
DMA_Init(DMA1_Channel1, &DMA_InitStructure);
DMA_Cmd(DMA1_Channel1,ENABLE);
}
void adc_channel_config(void){
ADC_RegularChannelConfig(ADC1,ADC_Channel_0, 1, ADC_SampleTime_239Cycles5);
ADC_RegularChannelConfig(ADC1,ADC_Channel_1, 2, ADC_SampleTime_239Cycles5);
}
u16 readADC1(u8 channel){
u16 adc=0;
ADC_RegularChannelConfig(ADC1, channel, 1, ADC_SampleTime_55Cycles5);
/* Adc dönüsümü baslatiliyor */
ADC_SoftwareStartConvCmd(ADC1, ENABLE);
/* Adc dönüsümü bekleniyor */
while(ADC_GetSoftwareStartConvStatus(ADC1));
/* Adc sonucu okunuyor */
adc=ADC_GetConversionValue(ADC1);
return adc;
}
u8 ADC1L(u8 channel){
u8 adc_low=0xFF&readADC1(channel);
return adc_low;
}
u8 ADC1H(u8 channel){
u16 temp=0xFF00&readADC1(channel);
u8 adc_high=temp>>8;
return adc_high;
}
Normalde readADC1 fonksiyonu ile adc değerini okuyabiliyorum ama DMA ile bu iş olmadı. Oluşturduğumuz diziden sürekli 2-3-4 değerleri geliyor.
Main içerisinde tüm ayarlamaları yapıyorum.
adc_channel_config();
initADC1();
ADC1_DMAConfig();
ADC_DMACmd(ADC1,ENABLE);
ADC_SoftwareStartConvCmd(ADC1,ENABLE);
okurkende ADC_degeri=ADC_DMAValue[0]; gibi bir komutla dizideki değeri alıyorum.
Şunda şüpheleniyorum Acaba ADC_DR değerimi yanlış. Normalde siz ADC_Dr için 0x4001244C değerini vermiştiniz. STM32F107 nin datasheetinde ADC DR ofset değeri 0x4C olarak belirtilmiş.
Sıkıntı nerde olabilir?
Yok onunla ilgili değil. DR registerinin offseti 4C doğru. Verdiğim adresin sonuna bakarsan 4C olduğunu görürsün. Gerisi ADC1'in base adresi.
Yayınladığım örnek zaten STM32F1x için. Hiç değişiklik yapmadan,sadece kanal sayısını düşürerek çalıştırabilirsin.
örnek uygulamada
main içerisinde init_gpio() ve init_rcc() görünmüyor. Muhtemelen başka bir yerde init ettiğim için veya buraya aktarırken yanlışlıkla kestiğim için görünmüyor. Önce GPIO ve RCC init ediliyor. sonra ADCve DMA initleri yapılıyor.
Senin uygulamada RCC ve GPIO initleri "initADC1()" rutiniiçerisinden yapılıyor. Ancak bu rutini çağırmadan önce "adc_channel_config()" rutinini çağırdığın için , muhtemelen bu registerlere yazma yapamıyorsun. ikisinin yerini değiştirirsen veya, RCC ve GPIO initlerini başka bir rutine alıp nceden çağırırsan sorun çözülecektir.
Örneği de düzeltiyorum.
Klein Hocam merhaba.
Kaç gündür yazamıyordum. Sorun dediğiniz gibiymiş.
Yapmak istediğim birşey daha var. Sizin fikrinizi almak isterim.
Normalde ADC den aldığım değerlerin aritmetik ortalamasını alıyorum. Her bir seferinde n kadar ADC değerine bakıp aldığım değerleri toplayıp n' e bölüyorum. Bu işlem vaktimi alıyor.
DMA modülü, diyelim aynı adc kanalından N kadar örnek alıp bu örnekleri bir diziye yerleştirebilirmi? Ben main içerisinde sadece bu dizideki değerleri toplayıp örnek sayısına bölerek ham adc değerini elde edeyim.
ADC'yi tek kanal kullanırsan olur
DMA_InitStructure.DMA_BufferSize = 2;
Bu rakamı kullanmak istediğin tamponun büyüklüğü kadar yaparsan olur.
Bunun yerine, Özellikle çok kanal kullanıyorsan; moving averaj kullanmanı öneririm. Daha az zaman harcarsın, verin daha hızlı güncellenir.
Örnek:
#define ADC_COUNT 8
#define FILTERSIZE 512
typedef struct{
uint16_t Buf[FILTERSIZE];
uint32_t Total;
uint16_t FilterIndex;
float Value;
}AdFilter_TypeDef;
AdFilter_TypeDef AdFilter[ADC_COUNT];
uint16_t FilterIndex;
uint16_t volatile adc_values[ADC_COUNT]; // ADC değerlerinin alındığı tampon.
uint16_t volatile AdcConverted=0;
void ADCCalculate(void){
uint16_t temp2;
static uint16_t index=0;
/*********************** Kayan ortalama **************************************************/
AdFilter[index].Total -= AdFilter[index].Buf[AdFilter[index].FilterIndex];
AdFilter[index].Total += adc_values[index];
AdFilter[index].Buf[FilterIndex]=adc_values[index];
temp2 = AdFilter[index].Total / (FILTERSIZE);
/***************************************************************************************/
if(++AdFilter[index].FilterIndex == FILTERSIZE)
{
AdFilter[index].FilterIndex=0;
}
if(++index == ADC_COUNT)
{
index=0;
AdcConverted=0;
if(++FilterIndex == FILTERSIZE)
{
FilterIndex=0;
}
}
}
int main(void)
{
..
..
..
while (1)
{
if(AdcConverted) ADCCalculate();
..
..
}
}
Arkadaşlar Merhaba
keil de bool tipi bir değişken tanımlayıp bu değişkene 1 veya 0 bitlik bir değer atadığım zaman aşağıdaki uyarıyı alıyorum.
SRC\main.c(91): warning: #188-D: enumerated type mixed with another type
Ayrıca Yine Sprintf, ABS, memcpy gibi fonksiyonları kullandığım zaman aşağıdaki yarılardan alıyorum.
SRC\main.c(52): warning: #223-D: function "sprintf" declared implicitly
Kodun çalışmasına engel olmuyorlar ama neden böyle bir uyarı veriyor.
bool değişkeni için ansi c için aşağıdaki kütüphaneyi kullanabilirsiniz
içeriği gerbay hocamın verdiği kodların benzeri şekilde
#include <stdbool.h>
içeriğine bakmak isterseniz adresi ..\Keil\ARM\ARMCC\include\
ayrıca başka bir çözüm olarak;
http://www.eosgarden.com/en/articles/bool/ (http://www.eosgarden.com/en/articles/bool/)
#define FALSE 0
#define TRUE (!FALSE)
hocam Teşekkür ederim. Uyarıların büyük çoğunluğunu hallettim. Sadece ABS fonksiyonu için bir uyarı veriyor.
Stdio.h ekli durumda
SRC\main.c(84): warning: #223-D: function "abs" declared implicitly
oda math.h içinde olması lazım
yok hocam denedim math.h da yok.
stdlib.h mış
math içindeki fabs (float abs) mış
http://www.csse.uwa.edu.au/programming/ansic-library.html (http://www.csse.uwa.edu.au/programming/ansic-library.html)
Ersin Hocam Teşekkür ederim.
Bu kütüphane dosyasını eklemeden neden sadece uyarı alıyorum. Hata almam gerekmezmi?
o konuyu bilmiyorum otomatik ekleme tarzı birşeyler olabilir
gerbay hocayı yakalayınca sormak lazım cevabını büyük ihtimal biliyordur diye umuyorum
Merhaba Arkadaşlar.
STM32F107 de usart2 pinleri dışarıda iki adet görünüyor. Mesela 1. Usart2 in RX ve TX pinleri hem porta nın 2 ve 3 nolu bitlerinde çıkarılmış Hemde portD nin 5 ve 6. bitlerinden çıkarılmış.
Aynı Durum Usart1 ve Usart2 içinde geçerli. Neden böyle yapıyorlar?
Usartı ayarlamak için aşağıdaki kodları kullanıyorum.
void initRS232(int baud){
USART_InitTypeDef USART_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
// Configure USART2 Tx (PA.2) as alternate function push-pull
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// Configure USART2 Rx (PA.3) as input floating
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOA, &GPIO_InitStructure);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
USART_InitStructure.USART_BaudRate = baud;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_Init(USART2, &USART_InitStructure);
/*USART2 alim-gönderim kesmeleri aktif*/
USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
USART_ITConfig(USART2, USART_IT_TXE, ENABLE);
/* USART2 Aktif*/
USART_Cmd(USART2, ENABLE);
}
Bu şekilde Usart2 nin A portundan data çıkışı alıyorum. Ama pinleri oraya yönlendirmeme rağmen D portundan data alamadım.
Bunun Sebebi Nedir?
Mucit alternate function olarak kullanmışsın. buda usart2 yi PA ya yönlendiriyor. onun yerine remap yapman gerekir.
GPIO_PinRemapConfig(GPIO_Remap_USART2, ENABLE);
Muhittin Hocam Sağolun. Öğrendiğim iyi oldu 8)
Oldu mu ?
Evet hocam sağolun. Dediğiniz gibi yapınca PortD den almaya başladım. Sıkıntı yok şuanda..
Bu işlemci max kaç Mhz hızda çalışır?
Elimdeki boardda işlemciye 25Mhz Xtal OSC bağlanmış(Kare olanlardan) Normade datasheette 4 ile 16Mhz arası takılır demiş.
Neyse Ben HSE osilatör Ön bölücüsünü 1 yapıp ardından PLLMul çarpanını 4 yaptığımda işlemci teoride 100Mhz ile çalışır. 4 Sınır bir değer. Bu çarpanı 5 yaptığımda bu sefer çevre donanımları sapıtıyor(TFT ekran gibi)
Datasheette max 72 Mhz diyorlar. Bu kriter neye göre ayarlanıyor.
Ayrıca sürekli bu hızda çalıştırırsam ne olur.
Arkadaşlar Merhaba
Keil bugün çok saçmalamaya başladı. Benle dalga geçiyor resmen
Çözümünü bildiğim bir uyarıyı ısararla bana vermeye devam ediyor
Graphic_Data\Size1_Selected.c(54): warning: #1-D: last line of file ends without a newline
Burada dosyanın son satırında 1 satır boşluk olması gerektiğini söylüyor. Daha önceleri bu şekilde dosyanın son satırına boşluk ekleyerek bu uyarıdan kurtuluyordum. Şimdi kurtulamıyorum. Acaba bana başka birşeymi söylüyor.
Birde şunu sorayım.
TFT ye resim basmak için elimdeki BMP resmi c koduna çevirip işlemciye gömüyorum.
Yahu bendemi problem var anlamıyorum. Resmi bir program ile c koduna çevirdikten sonra, const unsigned short Resim[]{.......} şeklinde dizide saklıyorum. Resimde Renkli şekiller var. TFT resmi bastığımda bu şekillerin Yerleri farklı oluyor.
Resimleri dönüştürmek için kullandığım programdamı sorun var yahu deli olacam.
Acaba elimdeki Resim datalarını bilgisayar ortamında tekrar resime çevirip doğruluğunu sağlayabilirmiyim.
Bu uyarılar Canımı sıkıyor.
Neden bu tip uyarılar alıyorum. Çözümü nedir.
Uyarı aldığım örnek bir C Resim Dosyası
const unsigned short Resim5[] =
{
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xFFFF,
0x0000,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0xFFFF,0x0000,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xFFFF,
0x0000,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,
0xC618,0xC618,0x430C,0x830C,0x830C,0x830C,0x830C,0x830C,
0x830C,0x830C,0xC618,0xFFFF,0x0000,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0xC618,0xC618,0x4208,0xF7DF,0xF7DF,
0xF7DF,0xC618,0xC618,0xC618,0x830C,0x830C,0xC618,0xFFFF,
0x0000,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,
0x4208,0xF7DF,0xF7DF,0xF7DF,0xC618,0xC618,0xC618,0x8410,
0xA514,0x430C,0xC618,0xFFFF,0x0000,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0x4208,0xF7DF,0xF7DF,0xF7DF,0xC618,
0xC618,0xC618,0x8410,0xA514,0x830C,0xA514,0xC618,0xFFFF,
0x0000,0xC618,0xC618,0xC618,0xC618,0xC618,0x4208,0xF7DF,
0xF7DF,0xF7DF,0xF7DF,0xC618,0xC618,0x8410,0xA514,0x8410,
0x830C,0xC618,0xC618,0xFFFF,0x0000,0xC618,0xC618,0xC618,
0xC618,0x4208,0xF7DF,0xF7DF,0xF7DF,0xF7DF,0xC618,0xC618,
0x430C,0xA514,0xA514,0x4208,0xC618,0xC618,0xC618,0xFFFF,
0x0000,0xC618,0xC618,0xC618,0x830C,0xA514,0x8410,0x8410,
0x8410,0x830C,0x430C,0x4208,0x8410,0xA514,0x4104,0xA514,
0xC618,0xC618,0xC618,0xFFFF,0x0000,0xC618,0xC618,0x830C,
0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0x830C,
0x8410,0x4104,0xA514,0xC618,0xC618,0xC618,0xC618,0xFFFF,
0x0000,0xC618,0xC618,0xA514,0xF7DF,0xF7DF,0xF7DF,0xF7DF,
0xF7DF,0xF7DF,0xA514,0x8410,0x4104,0xA514,0xC618,0xC618,
0xC618,0xC618,0xC618,0xFFFF,0x0000,0xC618,0x8410,0xF7DF,
0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xF7DF,0x830C,0x4104,
0xA514,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xFFFF,
0x0000,0xC618,0x4208,0x4208,0x4208,0x4208,0x4208,0x4208,
0x4208,0x4208,0x0000,0xA514,0xC618,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0xFFFF,0x0000,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xFFFF,
0x0000,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0xFFFF,0x0000,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xFFFF,
0x0000,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,0xC618,
0xC618,0xC618,0xC618,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,
0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,
0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF
};
Hocam alıyordum ben de bu uyarıdan , son süslü parantezden sonra birkaç kez enter'a basıp yeni satır ekler misin , Keil dosya sonunda boş satır görmek istiyor sanırım.
Hocam Var hocam En sonki parantezden sonra en az 10 Tane boşluk koydum. Başka birşey diyor sanki..
Dün bana kafayı yedirtti keil. Ekrana Resim basıyorum. Basım resimdeki Butonların Renkleri Farklı çıkıyor. İstediğim Renkler çıkıyor Ama Diyelim 1. Buton kırmızı olması gerekirken 5. Buton Kırmızı olup 1. Butonada 5. Butonun Rengi Basılıyor. Başka Düz bir Manzara Resmi Basıyorum Sıkıntı yok..
Varmı böyle bir Saçmalık Gönderdiğim Resim Elimde
Alıntı yapılan: Mucit23 - 26 Mart 2013, 09:47:56
Hocam Var hocam En sonki parantezden sonra en az 10 Tane boşluk koydum. Başka birşey diyor sanki..
Dün bana kafayı yedirtti keil. Ekrana Resim basıyorum. Basım resimdeki Butonların Renkleri Farklı çıkıyor. İstediğim Renkler çıkıyor Ama Diyelim 1. Buton kırmızı olması gerekirken 5. Buton Kırmızı olup 1. Butonada 5. Butonun Rengi Basılıyor. Başka Düz bir Manzara Resmi Basıyorum Sıkıntı yok..
Varmı böyle bir Saçmalık Gönderdiğim Resim Elimde
o uyarıyı önemseme hocam şimdilik. Sanırım dememin sebebi de oydu , oluyordu bende de , nasıl çözüldü hatırlamıyorum. Sen butonların yazılımına odaklan.
Pes ettim. Dün akşam Tam 2 Saat bunu çözmek için oyalandım. Butonların Yerleri Değişmiyor. Sadece Renklerini değiştiriyor.
Bu yüzden Resim Kodlarını Tekrar Resime çevirmek için bir program bulsam iyi olacak. Belki Resimleri çevirdiğim programda sıkıntı vardır. Başka ne olaki?
Arkadaşlar Merhaba,
Aynen Çeviri yaptığım programda problem varmış. Başka bir tane buldum düzeldi. Önceki Resim programı neye göre bunu yapıyor anlamadım.
Kullandığım program budur.
http://www.fujitsu.com/emea/services/microelectronics/gdc/swtools/bitmap-converter.html (http://www.fujitsu.com/emea/services/microelectronics/gdc/swtools/bitmap-converter.html)
Neyse
Bir problem var.
320X240 çözünürlüğe sahip iki tane resim var. Resmin Boyutu bayağı yüksek. Bu resimleri işlemcinin hafızasına gömmekte sıkıntı yaşamıyorum.Kullandığım veri tipi şöyle
const unsigned short Giris[76800] = {
0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,
0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,
0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,
0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,
0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,
0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,
0xFFFF,0xFFFF,0xFFFF,....................}
Gibi.
Bu Resimleri ekrana basmak için GLCD_Bitmap Şeklinde fonksiyonum var. X,Y kordinatları ve Resim ile birlikte resmin boyutunu belirtmek yetiyor.
Söyle bir sorun var.
İki adet Resim ard arda basmak istersem Aşağıdaki gibi bir hata alıyorum.
linking...
New_Proje.axf: Error: L6406E: No space in execution regions with .ANY selector matching giris.o(.constdata).
New_Proje.axf: Error: L6407E: Sections of aggregate size 0x25800 bytes could not fit into .ANY selector(s).
Target not created
İki Resim arasında bir while döngüsü kurarak programın akışını engellesem hata almıyorum. Ama mesela koşullu olarak break deyimi ile while içerisinden kurtulayım diyorum yine aynı hatayı alıyorum.
Keil Bana ne demek istiyor bu hata ile. Nasıl çözerim?
Sanırım Resim Datalarını yalnış şekilde saklıyorum. C de Const array sınırları neler acaba?
Hocam kusura bakma öncelikle galiba resimleri çevirme programında sıkıntı olmuş? sıkıntının tam olarak neden kaynaklandığını öğrenmek isterim. (Şimdiden teşekkürler)
Keil de aynı hatayı bende aldıydım.. Ram alanı yetersiz geliyor anlamında yorumlamıştık biz. Çevirdiğin resimlerin size ne kadar lık? ram alanını aşıyr olabilir. İyi çalışmalar.
Hocam bu sorunu hemen çözmem lazım
Diğer bitmap çevirici program saçma sapan çalışıyordu.
Renklerin yerlerini değiştiriyor. Kırmızı yapılacak yere mavi, mavi yapılacak yere kırmızı çiziyordu.
Programı değiştirince bu sorun düzeldi.
Şimdide dediğinize göre renk sıkıntım var.
Ben bu kodları ram'e değilde program hafızasına yazıp oradan çekmek istiyorum. Aslında mantıkende öyle olması gerekir çünkü ben const unsigned short diye diziyi oluşturuyorum. Normalde const arraylar program hafızasına yazılmazmı?
Edit:
Resimlerin birini kullanmıyorum hiç
derleme sonucu program boyutu şöyle
Program Size: Code=12860 RO-data=172228 RW-data=88 ZI-data=2144
Bence Resimle ilgili bir sıkıntı yok çünkü tüm resimler programla birlikte derleniyor.
Sorun Resimleri bir yerde, mesela ekrana basmak için kullanmak istersem başlıyor
GLCD_Bitmap(0,0,320,240,image_1);
Bundan iki tane kullandığım zaman hata alıyorum
Bir image bastım. 100x69 boyutundaki bir image için 6900 adet 16bit bilgi gerekli oldu
Doğrudan img basmak pek mantıklı gelmiyor bana (13Kb mi oluyor yoksa beynim mi bulanıyor)
mesaj birleştirme:: 27 Mart 2013, 20:44:59
"ST's STM32F100RB operates at a maximum speed of 24 MHz and features 128 Kbytes of Flash and 8 Kbytes of SRAM."
sadece tam ekran (240x320) bir img 150kb ediyor :D
Hocam Yok Benim Acilen SD kart işini çözmem lazım. Direk Resim Basmak akıl karı değil. Çok masraflı oluyor böyle, 2. Resimde şiştim kaldım..
Ben şunu anlamıyorum.
Programda 2 adet 320x240 çözünürlüğe sahip resim var. Bunun yanı sıra 14 tanede 20x20 resim var. Bunların hepsi derleniyor program çalışıyor.
Programımın sadece 2 yerinde 320x240 resim ekrana basıyorum. 1. Resmi bassam sıkıntı olmuyor ama mesela programın başka yerinde 2. resmi bassam yukarıdaki hataları veriyor
Program hafızasına sığmasa ozaman neden tek resim kullanılırken derlensin, Sığıyorsa neden bu hatayı veriyor.
Bence Ram ile felan ilgisi yok.
Çünkü iki resimide ve diğer 14 ufak resminde programa dahil edip derliyebiliyorum.
Acaba bitmap resim basma rutinimdemi sıkıntı var bi baksanız çok iyi olacak
void GLCD_Bitmap (unsigned int x, unsigned int y, unsigned int w, unsigned int h, unsigned char *bitmap) {
int i;
unsigned short *bitmap_ptr = (unsigned short *)bitmap;
int size = (w * h);
GLCD_SetWindow (x, y, w, h);
wr_cmd(0x22);
wr_dat_start();
for(i=0;i<size;i++)
{
wr_dat_only (*bitmap_ptr++);
}
wr_dat_stop();
bitmap_ptr=0;
}
:'( :'( :'( :'(
Konunun sadece son sayfasını okuyarak daldım. Eğer doğru anladıysam size resim pixellerini okuyan program lazım galiba. Kendiniz yaparsanız istediğiniz gibi bir dosyaya her türlü formatta yazabilirsiniz. Ben daha önce pixel okuyup ekranda tablolayan birşey yazmıştım c# ile. İsterseniz yollayabilirim.
meftun durduğun hata hemen alalım. bende başladım öyle bir programa hatta benimki fontu img çeviriyor oradan getpixel ile hex kodlarını alıyorum.
şimdi renk kodlarınıda alacağım get pixel ile
mesaj birleştirme:: 27 Mart 2013, 21:39:15
@ mucit
unsigned char LCD_DrawPicture2(unsigned char startX, unsigned int startY,unsigned char sizeX, unsigned char sizeY)
{
unsigned int i,j,veri,adr=0;
LCD_CS(0);
LCD_Set_Window(0,0,68,99);
LCD_WR_REG8(0x22);
for (j = 0; j<100; j++)
{
for(i = 0; i<69; i++)
{
veri=gImage_resim[adr++];
LCD_WR_DATA16(veri);
}
}
LCD_CS(1);
return 0;
}
ben yukardakini kullandım. Ama iki adet değil bir adet bile 240x320 img kullanamadım. küçük img ları düzgün basıyor. yukardaki algoritma ile senin ki aynı mantıkta.
bilgi basacak alanı hazırla (GLCD_SetWindow (x, y, w, h);)
img arraydan renk bilgisini oku ve ardışık olarak hazırlanmış alana pixel pixel bas
http://www59.zippyshare.com/v/72181283/file.html (http://www59.zippyshare.com/v/72181283/file.html)
buyrun hocam
Meftun program için teşekkürler.
Hocam bu problemin mantıklı bir açıklamasını arıyorum.
Gerbay Hocam, Klein Hocam nerelerdesiniz :-X :-X
Edit;
Ramle ilgili kısım şurası olabilir.
Normalde Resimleri main programında kullanabilmem için şöyle tanıtıyorum
extern unsigned char Ana_Res[];
extern unsigned char image_1[];
Bununla ilgili olabilirmi?
Arkadaşlar Bu resimler başka nasıl saklarım.
Bildiğiniz başka bir yöntem varmı?
@Mucit23 hocam;
SD kart veya w25q16bv model SPi Flash kullansanız olmaz mı ?
Hocam bugün bu işi halletmem lazım.
Aslında En çok SD karttan okumak isterdim ama vaktim yok. SD karttan yapmak çok zor. Başka bir çaresini bulmam lazım.
Bazı tespitlerim var sorunun sebebini anlamamıza yardımcı olabilir.
Şimdi hocam iki adet 320X240 çözünürlüğe sahip resim var. Bunun yanı sıra 14 tanede ufak (20x20) Resim var.
Proje ağacım aşağıdaki gibi.
(http://s24.postimg.cc/thmubb6qd/Ekran_Al_nt_s.png) (http://postimg.cc/)
image hoster (http://postimg.cc/)
Bu resimlerin hepsi resimdeki gibi programa dahil edip derliyorum. Ufak resimlerin hepsi programda kullanılıyor çalışmasında sıkıntı yok. Ana_Res ve image_1 320x240 çözünürlüğe sahip. Şimdi bu resimlerin ikiside programa dahil edip derleyebiliyorum.
Şuanda sıkıntısız olarak Resimlerin birini GLCD_Bitmap ile ekrana basıyorum.
Sorun şurada başlıyor.
Programın başka bir yerinde ikinci resmi ekrana basmak istersem yukarıda bahsettiğim uyarıları alıyorum. Program nedense sadece iki resmin kullanımına izin vermiyor.
Bunu anlam vermiyorum. Dizinin kullanıma izin vermiyor. Resim dizisini kullanmazsam yine program yok..
Alıntı YapProgramın başka bir yerinde ikinci resmi ekrana basmak istersem yukarıda bahsettiğim uyarıları alıyorum. Program nedense sadece iki resmin kullanımına izin vermiyor.
Bunu anlam vermiyorum. Dizinin kullanıma izin vermiyor. Resim dizisini kullanmazsam yine program yok..
Peki hocam ikinci resmi birinci resim olarak basıp denediniz mi ?
Yani
ikinci resmi bastığınız yerde tekrardan Ana_Res resmi basmak
Not: Her iki resim dosyasıda yuklu olsun.
Birde hocam aklıma geldi. Test icin 2. resmin cozunurlugunu (Boyutunu ) dusurup denediniz mi ? Ornek 240x320 değilde. 120x180 gibi.
bu resimleri basarken resim hexlerini rame alıp basmıyor mu? 2 resim size ram taşırıyor olabilir? Direk flashtan okuyup basmaya kalksa hızı yetişmeyebilir.(zaten yetiştiremez ekranda kasmalar meydana geliyor) şimdi stm'in ahb bus ı nasıl çalışıyor bilmiyorum ama benim kullandığım işlemcide sdram(32mb) takılı o yüzden usb den sdrame adresliyorum resimleri oradan da işlemci lcd_dma kullanarak ekrana basıyor..
Alıntı yapılan: buzkırıcı - 28 Mart 2013, 11:20:59
bu resimleri basarken resim hexlerini rame alıp basmıyor mu? 2 resim size ram taşırıyor olabilir? Direk flashtan okuyup basmaya kalksa hızı yetişmeyebilir.(zaten yetiştiremez ekranda kasmalar meydana geliyor) şimdi stm'in ahb bus ı nasıl çalışıyor bilmiyorum ama benim kullandığım işlemcide sdram(32mb) takılı o yüzden usb den sdrame adresliyorum resimleri oradan da işlemci lcd_dma kullanarak ekrana basıyor..
Hocam iki Resmide Tek tek basıyorum. Sıkıntı olmuyor. Yani Resim datalarında sıkıntı olmaması gerekir.
Programın bir yerinde 1. resmi başka bir yerinde ikinci resmi basmak istersem sıkıntı yaratıyor. İsterse komut hiç çalışmasın farketmiyor.. GLCD_Bitmap(0,0,320,240,image_1);
İki tane bu komuttan olsun program hataya düşüyor. İsterse ikiside çalışmasın. Bitmap fonksiyonunu önceki mesajlarımda vermiştim. Orada alınan dizi komple ram'e atılıyor sanırım.
void GLCD_Bitmap (unsigned int x, unsigned int y, unsigned int w, unsigned int h, unsigned char *bitmap) {
int i;
unsigned short *bitmap_ptr = (unsigned short *)bitmap;
Şöyle bir komut var.
İki resimde ayrı ayrı basılıyor hocam. Belki Ramin gerekli bölgelerini temizlersem eğer taşma veya sığmama gibi bir problem olursa çözülebilir. Bundan umutluyum.
Önerebileceğiniz birşey varmı?
hocam şurda birisi aynı sorunla karşılaşmış
http://www.keil.com/forum/19067/ (http://www.keil.com/forum/19067/)
ve IRAM1'i arttırınca düzeldi filan demiş. Sen de bi denesen?
Hocam bu değeri nereden değiştireceğim.
keil->poject->options for target ...
açılan pencerede sağ altta görürsün zaten..
yok hocam çözüm olmadı malesef
Anlam veremiyorum.
mucit 107 nin hangi serisini kullanıyorsun ?
STM32F107VCT6
Kendimi Annesi istediği oyuncağı almadığı için ağlayan çoçuklar gibi hissediyorum :-X
iki image ı nasıl derliyorki
240x320=76800 pixel
sen bu her pixelin renk kodu için 2byte saklıyorsun ROM a
76800*2=153600 byte ve 150kb eder
senin makine 256kb rom a sahip
bu iki img ı 300kb ediyor zaten
Atladığım Nokta mı Var ?
startup.s dosyasında Stack_Size'ı arttırsan?
Bir farklı resim basayım dedim. Bilgisayarın bir başka yerinde yine 320x240 çözünürlüğe sahip bir resim bastım. Yine iki adet 320x240 çözünürlüğe sahip resim olmuş oluyor. İkisini bastırabiliyorum fakat şöyle bir problem var.
GLCD_Bitmap(0,0,320,240,image_1);
while(1)
{
}
GLCD_Bitmap(0,0,320,240,Ana_Res);
Şöyle bir kod ekledim. Bu şekilde image_1 basılıyor. ilk olarak İmage_1 Yerine Ana_Res yazsam oda basılıyor.
Programın akışına göre program while içerisinden kurtulsa hemen Ekrana Ana_Res basacak.
öyle olmuyor malesef.
While içerisinden kurtulmak için break deyimini yazarsam program aynı hataya düşüyor.
Muhittin Hocam bende anlam veremiyorum. İki resim zaten program boyutunu aşıyor. Ama buna rağmen derlenip işlemciye yükleniyor.
Sanırım iki resim boyutu hafızayı aştığı için keil resimlere bakıp hangisi kullanılıyorsa onu derliyor diğerini derleyip işlemciye atmıyor. İkisinide kullanmak isersem hafızan yeterli değil diyor.
Başkada bir açıklama bulamıyorum ben
Demek ki derleyici while(1)'den sonrasını kaale almıyor dolayısıyla da hata vermiyor. Ama while'ı atlayacak bir komut geldiğinde hata veriyor.
Zaten hata mesajındaki
"L6407E: Sections of aggregate size 0x25800 bytes could not fit into .ANY selector(s)."
0x25800 byte Muhittin Hoca'nın hesabındaki 153600 rakamına denk geliyor ki mesajın anlamı: "senin resimler'i bir yere sığdıramıyorum" demek oluyor.
O zaman yapacağın şey resimleri 8 bpp'ye düşürmek. Yani bir piksel 8-bit olacak şekilde. Ya da jpg gibi bir formatta çalışmak.
Anladım Hocam
8bpp için hangi değişiklikleri yapmam gerekir? Resim bahsettiğiniz formata çevirmek kolay.
İşin yazılım kısmında kullandığım lcd ye resim formatını nasıl bildireceğim.
Mucit Debug damı yapıyorsun programı Yüklüyormusun. Yani Demek istediğim DEBUG IN RAM da çalışma durumuna dikkat et.
Yok hocam direk derle yükle gör şeklinde çalışıyorum.
Debug da da deniyeyim.
Akşam üzeri birde 8bpp resim basmayı deneyeceğim. Oldu oldu olmazsa bırakırım uğraşmayı.
keilin MCBSTM32C için yazılmış örnek kodları içerisinde bitmap basmak için şöyle bir kod var.
void GLCD_Bitmap (unsigned int x, unsigned int y, unsigned int w, unsigned int h, unsigned char *bitmap) {
int i, j;
unsigned short *bitmap_ptr = (unsigned short *)bitmap;
GLCD_SetWindow (x, y, w, h);
wr_cmd(0x22);
wr_dat_start();
for (i = (h-1)*w; i > -1; i -= w) {
for (j = 0; j < w; j++) {
wr_dat_only (bitmap_ptr[i+j]);
}
}
wr_dat_stop();
}
Ben bu kodlar üzerinde oynama yaparak kendi bitmap basma fonksiyomu hazırlamıştım
Bu kodlar ile 8bpp resim basılıyor.
Bu kodun çalışma mantığı nasıl kullanırken hep şöyle kullanılmış
GLCD_Bitmap ( 0, 0, 320, 69, Bg_16bpp_t+70);
Neden resime 70 eklenmiş?
img daki başlangıcı yakalamak içindir.
Bir Düzgün görüntü alamadım.
resim 8bpp formatına çevirdim. yine 320x240 çözünürlüğe sahip.
Elimde ki kodlar şu şekilde
/****************************************************************/
/* FUJITSU MICROELECTRONICS EUROPE - BITMAP CONVERTER (V2.20) */
/* BITMAP FILE "demomap1" */
/* BITMAP SIZE : X=320 Y=240 PIXEL */
/* CREATED 28.03.2013 15:47:17 */
/* OUTPUT FORMAT : CREMSON/CORAL/CARMINE/LIME 8BPP */
/****************************************************************/
const unsigned char demomap1[76800] = {
0xE7,0x58,0x58,0x58,0x58,0x55,0x55,0x55,0x55,0x58,
0x58,0x58,0x58,0xEC,0xE4,0xE9,0xE4,0xE7,0xE7,0xE7,
0xE4,0xE4,0xEC,0xE4,0xEC,0xE4,0xE4,0xE7,0xE7,0xE4,
0x00,0x00,0xFF,0x00,0xFF,0x00,0x00,0xCE,0xF7,0xF1,
0x84,0x00,0xCE,0xFC,0xC6,0xF9,0x00,0x10,0x00,0x10,
0x00,0x00,0x10,0xF7,0xFF,0x00,0x00,0xFF,0xFF,0xF9,
0xBD,0x8C,0x63,0x00,0x8C,0xF9,0xFF,0x00,0x00,0xFF,
0xC6,0xF9,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0xFF,
0xFF,0x00,0x00,0xFF,0xFF,0xF9,0xFF,0x00,0x00,0xFF,
0xB5,0xEF,0x00,0x00,0xFF,0xE1,0xCE,0x00,0xAF,0xE7,
0x00,0x00,0xFF,0xFF,0x00,0x00,0xFF,0xFF,0xF9,0xFF,
0xF7,0xFF,0x00,0x00,0xFF,0xFF,0xF9,0x00,0x00,0xFF,
0xFF,0xF9,0xFF,0xF7,0xFF,0xFF,0xF9,0xFF,0xFF,0xF7,
0xFF,0xF9,0xFF,0xFC,0xF9,0xFF,0xC6,0xC0,0xFC,0xFF,
0xAA,0xAA,0xAA,0xF9,0xF9,0xFF,0xF9,0xF9,0xC5,0xC6,
0xC0,0xFF,0xF9,0xFF,0xFF,0xF7,0xFF,0xFF,0xF9,0xFF,
0xFF,0xF9,0xFF,0xF9,0xFC,0xFF,0xF9,0xFF,0xFF,0xF9,
0xFF,0xFF,0xF7,0xFF,0xFF,0xF9,0xFF,0xFF,0xF9,0xFF,
0xF9,0xFC,0xFF,0xF9,0xFF,0x58,0x58,0x55,0x55,0x55,
0x55,0x55,0x55,0x55,0x55,0x55,0x55,0xF1,0xFF,0x58,
0x58,0xC6,0xC8,0xFF,0xFF,0xF9,0xFF,0xC6,0xC0,0xC6,
0xC5,0xC6,0xC0,0xC6,0xC6,0xA4,0xAD,0xA4,0xA4,0xA4,
0xA4,0xA4,0xA4,0xA4,0xA4,0xAD,0xA4,0xAD,0xA4,0xA4,
0xAD,0xC0,0xC6,0xC6,0xFF,0xF9,0xC6,0xC6,0xA4,0xA4,
0xA4,0xAD,0xA4,0xA4,0xA4,0xA4,0xA4,0xA4,0xA4,0xA4,
};
kodların hepsini buraya eklemedim.
Ben bu kod yapısına göre nasıl bir algooritma kurayımki resim düzgün bir şekilde basılsın. Şuanda bir önceki mesajımda verdiğim Bitmap fonksiyonunu kullanıyorum fakat her seferinde yarım yamalak saçma sapan bozuk görüntü alıyorum
img ı çevirdin ama ekran hala 16bit beklemesin
Hocam öyle sanırım.
Ekranda berbat bir şekilde resim çıkıyor ama tam değil. Ekranın sadece üst yarısına 2 adet resim basılıyor.
basit birde döngü kurdum..
void GLCD_Bitmap_8bpp (unsigned int x, unsigned int y, unsigned int w, unsigned int h, unsigned char *bitmap) {
int i;//, j;
int size= (w*h);
unsigned short *bitmap_ptr = (unsigned short *)bitmap;
GLCD_SetWindow (x, y, w, h);
wr_cmd(0x22);
wr_dat_start();
for (i = 0;i<size;i++) {
wr_dat_only (bitmap_ptr[i]);
}
wr_dat_stop();
}
Bu arada bu şekilde iki resimde derlenip çalışıtırılabiliyor. hafıza sorunu yok artık. Resmi düzgün bir şekilde bassam mükemmel olacak
Yalnız keilin örnek programlarını aynen kullanıyorum. LCD sürücü çipi ayarlarıyla hiç oynamadım.
geçici bir çözüm
datayı göndermeden MSB olarak 0x00 koy
yani
int ZData;
for (i = 0;i<size;i++) {
ZData=0x00;
ZData=ZData<<8;
ZData |=bitmap_ptr;
wr_dat_only (Zdata);
}
Olarak Devamlı 16bit gönderirsin tabi başında 0x00 olur.
Hocam lcd 16 bit bekledikten sonra msb yi 0 yapmak anlamsız olur hocam. 16 bitin yüksek 8 biti 0 olacağına göre kırmızı ve yeşilin bir kısmı çıkmaz.
Lcd init kodlarinda ayarlanmış. 0x17 registerine 0x55 yüklenmiş. Açıklama dada 16bit interface yazıyor. SPFD 5408in Datasheet te böyle bir register bulamadım. Benmi göremedim?
bende baktım ili nin datasına. Sanırım o radan kasın 6 bit iletişim 16 bit iletişim ve 18 bit iletişim. açıklamasında rengi oluşturmak için üç adet 6 bit yapmak gerektiğini yazıyor. sonuçta bize img ı oluşturmak için 16 yada 18 bitlik bilgi gerek. Bakakalım neler öğreneceğiz daha..
Hocam datayı ayrıntılı olarak inceleyelim.Mutlaka bu konuda bilgi vardır. Oldu oldu olmazsa bırakırım bu kitle uğraşmayı.
Aslında baştan beri diğer deney kitinde uğraşsaymışım daha iyi olacaktı. Onda Stm 32f103ve var. Hafızası 512k
Bir sonraki hedefim de kesinlikle Sd ram kullanımı ve Sd kart kullanımı olacak.
BMP resimlerini oradan okuyacam.
Mucit Senin TFT controller ne idi ?
Spfd5408 hocam
ili9325 ile çalışıyorum
Display Control 1 (R07h) registeri nde CL biti var değiştirdim ama birşey değişmedi.
Hocam boşverin bırakın uğraşmayı. Ben vazgeçtim. Vaktim kalmadı artık bu şekilde bırakacağım.
Geniş bir zamanda yine ayrıntılı bir şekilde bakarım.
Zaten ilk hedefim touch panel kullanımını çözmekti. Iyi kötü başardım.
Bundan sonra dediğim gibi Sd kart işine ve Sd ram işine bakacağım
Şu programı dener misin?
http://s3.dosya.tc/server2/0zWlb3/Image2LcdV3.2.zip.html (http://s3.dosya.tc/server2/0zWlb3/Image2LcdV3.2.zip.html)
Bu programla bpp'yi, yatay/düşey taramayı MSB'yi vs hepsini ayarlayabiliyorsun.
Bir de; program 16-bit renk beklediğine göre, 8bitlik piksel bilgisinin başına 0 koyarak değil de şöyle bir makro ile RGB-565 formatına çevirmek gerek sanırım:
#define RGB(red, green, blue) ((unsigned int)( (( red >> 3 ) << 11 ) | \
(( green >> 2 ) << 5 ) | \
( blue >> 3 )))
Tabii 8 bitlik piksel bilgisini önce red, green, blue diye ayırmak gerek.
Mesela 8bpp'lik data RGB-332 diye ayrılmışsa,
red = data >> 5;
green = (data & 0x1F) >> 3;
blue = (data & 0x03);
olabilir. Denemek lazım.
Selamlar.
Stm32f103 ile eeprom kullanmak istiyorum.Bu konuda yönlendirebilir misiniz?
Alıntı yapılan: yldzelektronik - 01 Nisan 2013, 17:06:12
Selamlar.
Stm32f103 ile eeprom kullanmak istiyorum.Bu konuda yönlendirebilir misiniz?
Hocam Ben eeprom için bu iki dosyayı kullanıyorum.
eeprom.c
/**
******************************************************************************
* @file EEPROM_Emulation/src/eeprom.c
* @author MCD Application Team
* @version V3.1.0
* @date 07/27/2009
* @brief This file provides all the EEPROM emulation firmware functions.
******************************************************************************
* @copy
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* <h2><center>© COPYRIGHT 2009 STMicroelectronics</center></h2>
*/
/** @addtogroup EEPROM_Emulation
* @{
*/
/* Includes ------------------------------------------------------------------*/
#include "eeprom.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Global variable used to store variable value in read sequence */
uint16_t DataVar = 0;
//#define PAGE_SIZE (uint16_t)0x400 /* Page size = 1KByte */
/* Virtual address defined by the user: 0xFFFF value is prohibited */
extern uint16_t VirtAddVarTab[NumbOfVar];
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
static FLASH_Status EE_Format(void);
static uint16_t EE_FindValidPage(uint8_t Operation);
static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data);
static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data);
/**
* @brief Restore the pages to a known good state in case of page's status
* corruption after a power loss.
* @param None.
* @retval - Flash error code: on write Flash error
* - FLASH_COMPLETE: on success
*/
uint16_t EE_Init(void)
{
uint16_t PageStatus0 = 6, PageStatus1 = 6;
uint16_t VarIdx = 0;
uint16_t EepromStatus = 0, ReadStatus = 0;
int16_t x = -1;
uint16_t FlashStatus;
/* Get Page0 status */
PageStatus0 = (*(__IO uint16_t*)PAGE0_BASE_ADDRESS);
/* Get Page1 status */
PageStatus1 = (*(__IO uint16_t*)PAGE1_BASE_ADDRESS);
/* Check for invalid header states and repair if necessary */
switch (PageStatus0)
{
case ERASED:
if (PageStatus1 == VALID_PAGE) /* Page0 erased, Page1 valid */
{
/* Erase Page0 */
FlashStatus = FLASH_ErasePage(PAGE0_BASE_ADDRESS);
/* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
}
else if (PageStatus1 == RECEIVE_DATA) /* Page0 erased, Page1 receive */
{
/* Erase Page0 */
FlashStatus = FLASH_ErasePage(PAGE0_BASE_ADDRESS);
/* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
/* Mark Page1 as valid */
FlashStatus = FLASH_ProgramHalfWord(PAGE1_BASE_ADDRESS, VALID_PAGE);
/* If program operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
}
else /* First EEPROM access (Page0&1 are erased) or invalid state -> format EEPROM */
{
/* Erase both Page0 and Page1 and set Page0 as valid page */
FlashStatus = EE_Format();
/* If erase/program operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
}
break;
case RECEIVE_DATA:
if (PageStatus1 == VALID_PAGE) /* Page0 receive, Page1 valid */
{
/* Transfer data from Page1 to Page0 */
for (VarIdx = 0; VarIdx < NumbOfVar; VarIdx++)
{
if (( *(__IO uint16_t*)(PAGE0_BASE_ADDRESS + 6)) == VirtAddVarTab[VarIdx])
{
x = VarIdx;
}
if (VarIdx != x)
{
/* Read the last variables' updates */
ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar);
/* In case variable corresponding to the virtual address was found */
if (ReadStatus != 0x1)
{
/* Transfer the variable to the Page0 */
EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar);
/* If program operation was failed, a Flash error code is returned */
if (EepromStatus != FLASH_COMPLETE)
{
return EepromStatus;
}
}
}
}
/* Mark Page0 as valid */
FlashStatus = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE);
/* If program operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
/* Erase Page1 */
FlashStatus = FLASH_ErasePage(PAGE1_BASE_ADDRESS);
/* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
}
else if (PageStatus1 == ERASED) /* Page0 receive, Page1 erased */
{
/* Erase Page1 */
FlashStatus = FLASH_ErasePage(PAGE1_BASE_ADDRESS);
/* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
/* Mark Page0 as valid */
FlashStatus = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE);
/* If program operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
}
else /* Invalid state -> format eeprom */
{
/* Erase both Page0 and Page1 and set Page0 as valid page */
FlashStatus = EE_Format();
/* If erase/program operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
}
break;
case VALID_PAGE:
if (PageStatus1 == VALID_PAGE) /* Invalid state -> format eeprom */
{
/* Erase both Page0 and Page1 and set Page0 as valid page */
FlashStatus = EE_Format();
/* If erase/program operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
}
else if (PageStatus1 == ERASED) /* Page0 valid, Page1 erased */
{
/* Erase Page1 */
FlashStatus = FLASH_ErasePage(PAGE1_BASE_ADDRESS);
/* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
}
else /* Page0 valid, Page1 receive */
{
/* Transfer data from Page0 to Page1 */
for (VarIdx = 0; VarIdx < NumbOfVar; VarIdx++)
{
if ((*(__IO uint16_t*)(PAGE1_BASE_ADDRESS + 6)) == VirtAddVarTab[VarIdx])
{
x = VarIdx;
}
if (VarIdx != x)
{
/* Read the last variables' updates */
ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar);
/* In case variable corresponding to the virtual address was found */
if (ReadStatus != 0x1)
{
/* Transfer the variable to the Page1 */
EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar);
/* If program operation was failed, a Flash error code is returned */
if (EepromStatus != FLASH_COMPLETE)
{
return EepromStatus;
}
}
}
}
/* Mark Page1 as valid */
FlashStatus = FLASH_ProgramHalfWord(PAGE1_BASE_ADDRESS, VALID_PAGE);
/* If program operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
/* Erase Page0 */
FlashStatus = FLASH_ErasePage(PAGE0_BASE_ADDRESS);
/* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
}
break;
default: /* Any other state -> format eeprom */
/* Erase both Page0 and Page1 and set Page0 as valid page */
FlashStatus = EE_Format();
/* If erase/program operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
break;
}
return FLASH_COMPLETE;
}
/**
* @brief Returns the last stored variable data, if found, which correspond to
* the passed virtual address
* @param VirtAddress: Variable virtual address
* @param Data: Global variable contains the read variable value
* @retval Success or error status:
* - 0: if variable was found
* - 1: if the variable was not found
* - NO_VALID_PAGE: if no valid page was found.
*/
uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data)
{
uint16_t ValidPage = PAGE0;
uint16_t AddressValue = 0x5555, ReadStatus = 1;
uint32_t Address = 0x08010000, PageStartAddress = 0x08010000;
/* Get active Page for read operation */
ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE);
/* Check if there is no valid page */
if (ValidPage == NO_VALID_PAGE)
{
return NO_VALID_PAGE;
}
/* Get the valid Page start Address */
PageStartAddress = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE));
/* Get the valid Page end Address */
Address = (uint32_t)((EEPROM_START_ADDRESS - 2) + (uint32_t)((1 + ValidPage) * PAGE_SIZE));
/* Check each active page address starting from end */
while (Address > (PageStartAddress + 2))
{
/* Get the current location content to be compared with virtual address */
AddressValue = (*(__IO uint16_t*)Address);
/* Compare the read address with the virtual address */
if (AddressValue == VirtAddress)
{
/* Get content of Address-2 which is variable value */
*Data = (*(__IO uint16_t*)(Address - 2));
/* In case variable value is read, reset ReadStatus flag */
ReadStatus = 0;
break;
}
else
{
/* Next address location */
Address = Address - 4;
}
}
/* Return ReadStatus value: (0: variable exist, 1: variable doesn't exist) */
return ReadStatus;
}
/**
* @brief Writes/upadtes variable data in EEPROM.
* @param VirtAddress: Variable virtual address
* @param Data: 16 bit data to be written
* @retval Success or error status:
* - FLASH_COMPLETE: on success
* - PAGE_FULL: if valid page is full
* - NO_VALID_PAGE: if no valid page was found
* - Flash error code: on write Flash error
*/
uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data)
{
uint16_t Status = 0;
/* Write the variable virtual address and value in the EEPROM */
Status = EE_VerifyPageFullWriteVariable(VirtAddress, Data);
/* In case the EEPROM active page is full */
if (Status == PAGE_FULL)
{
/* Perform Page transfer */
Status = EE_PageTransfer(VirtAddress, Data);
}
/* Return last operation status */
return Status;
}
/**
* @brief Erases PAGE0 and PAGE1 and writes VALID_PAGE header to PAGE0
* @param None
* @retval Status of the last operation (Flash write or erase) done during
* EEPROM formating
*/
static FLASH_Status EE_Format(void)
{
FLASH_Status FlashStatus = FLASH_COMPLETE;
/* Erase Page0 */
FlashStatus = FLASH_ErasePage(PAGE0_BASE_ADDRESS);
/* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
/* Set Page0 as valid page: Write VALID_PAGE at Page0 base address */
FlashStatus = FLASH_ProgramHalfWord(PAGE0_BASE_ADDRESS, VALID_PAGE);
/* If program operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
/* Erase Page1 */
FlashStatus = FLASH_ErasePage(PAGE1_BASE_ADDRESS);
/* Return Page1 erase operation status */
return FlashStatus;
}
/**
* @brief Find valid Page for write or read operation
* @param Operation: operation to achieve on the valid page.
* This parameter can be one of the following values:
* @arg READ_FROM_VALID_PAGE: read operation from valid page
* @arg WRITE_IN_VALID_PAGE: write operation from valid page
* @retval Valid page number (PAGE0 or PAGE1) or NO_VALID_PAGE in case
* of no valid page was found
*/
static uint16_t EE_FindValidPage(uint8_t Operation)
{
uint16_t PageStatus0 = 6, PageStatus1 = 6;
/* Get Page0 actual status */
PageStatus0 = (*(__IO uint16_t*)PAGE0_BASE_ADDRESS);
/* Get Page1 actual status */
PageStatus1 = (*(__IO uint16_t*)PAGE1_BASE_ADDRESS);
/* Write or read operation */
switch (Operation)
{
case WRITE_IN_VALID_PAGE: /* ---- Write operation ---- */
if (PageStatus1 == VALID_PAGE)
{
/* Page0 receiving data */
if (PageStatus0 == RECEIVE_DATA)
{
return PAGE0; /* Page0 valid */
}
else
{
return PAGE1; /* Page1 valid */
}
}
else if (PageStatus0 == VALID_PAGE)
{
/* Page1 receiving data */
if (PageStatus1 == RECEIVE_DATA)
{
return PAGE1; /* Page1 valid */
}
else
{
return PAGE0; /* Page0 valid */
}
}
else
{
return NO_VALID_PAGE; /* No valid Page */
}
case READ_FROM_VALID_PAGE: /* ---- Read operation ---- */
if (PageStatus0 == VALID_PAGE)
{
return PAGE0; /* Page0 valid */
}
else if (PageStatus1 == VALID_PAGE)
{
return PAGE1; /* Page1 valid */
}
else
{
return NO_VALID_PAGE ; /* No valid Page */
}
default:
return PAGE0; /* Page0 valid */
}
}
/**
* @brief Verify if active page is full and Writes variable in EEPROM.
* @param VirtAddress: 16 bit virtual address of the variable
* @param Data: 16 bit data to be written as variable value
* @retval Success or error status:
* - FLASH_COMPLETE: on success
* - PAGE_FULL: if valid page is full
* - NO_VALID_PAGE: if no valid page was found
* - Flash error code: on write Flash error
*/
static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data)
{
FLASH_Status FlashStatus = FLASH_COMPLETE;
uint16_t ValidPage = PAGE0;
uint32_t Address = 0x08010000, PageEndAddress = 0x080107FF;
/* Get valid Page for write operation */
ValidPage = EE_FindValidPage(WRITE_IN_VALID_PAGE);
/* Check if there is no valid page */
if (ValidPage == NO_VALID_PAGE)
{
return NO_VALID_PAGE;
}
/* Get the valid Page start Address */
Address = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE));
/* Get the valid Page end Address */
PageEndAddress = (uint32_t)((EEPROM_START_ADDRESS - 2) + (uint32_t)((1 + ValidPage) * PAGE_SIZE));
/* Check each active page address starting from begining */
while (Address < PageEndAddress)
{
/* Verify if Address and Address+2 contents are 0xFFFFFFFF */
if ((*(__IO uint32_t*)Address) == 0xFFFFFFFF)
{
/* Set variable data */
FlashStatus = FLASH_ProgramHalfWord(Address, Data);
/* If program operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
/* Set variable virtual address */
FlashStatus = FLASH_ProgramHalfWord(Address + 2, VirtAddress);
/* Return program operation status */
return FlashStatus;
}
else
{
/* Next address location */
Address = Address + 4;
}
}
/* Return PAGE_FULL in case the valid page is full */
return PAGE_FULL;
}
/**
* @brief Transfers last updated variables data from the full Page to
* an empty one.
* @param VirtAddress: 16 bit virtual address of the variable
* @param Data: 16 bit data to be written as variable value
* @retval Success or error status:
* - FLASH_COMPLETE: on success
* - PAGE_FULL: if valid page is full
* - NO_VALID_PAGE: if no valid page was found
* - Flash error code: on write Flash error
*/
static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data)
{
FLASH_Status FlashStatus = FLASH_COMPLETE;
uint32_t NewPageAddress = 0x080103FF, OldPageAddress = 0x08010000;
uint16_t ValidPage = PAGE0, VarIdx = 0;
uint16_t EepromStatus = 0, ReadStatus = 0;
/* Get active Page for read operation */
ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE);
if (ValidPage == PAGE1) /* Page1 valid */
{
/* New page address where variable will be moved to */
NewPageAddress = PAGE0_BASE_ADDRESS;
/* Old page address where variable will be taken from */
OldPageAddress = PAGE1_BASE_ADDRESS;
}
else if (ValidPage == PAGE0) /* Page0 valid */
{
/* New page address where variable will be moved to */
NewPageAddress = PAGE1_BASE_ADDRESS;
/* Old page address where variable will be taken from */
OldPageAddress = PAGE0_BASE_ADDRESS;
}
else
{
return NO_VALID_PAGE; /* No valid Page */
}
/* Set the new Page status to RECEIVE_DATA status */
FlashStatus = FLASH_ProgramHalfWord(NewPageAddress, RECEIVE_DATA);
/* If program operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
/* Write the variable passed as parameter in the new active page */
EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddress, Data);
/* If program operation was failed, a Flash error code is returned */
if (EepromStatus != FLASH_COMPLETE)
{
return EepromStatus;
}
/* Transfer process: transfer variables from old to the new active page */
for (VarIdx = 0; VarIdx < NumbOfVar; VarIdx++)
{
if (VirtAddVarTab[VarIdx] != VirtAddress) /* Check each variable except the one passed as parameter */
{
/* Read the other last variable updates */
ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar);
/* In case variable corresponding to the virtual address was found */
if (ReadStatus != 0x1)
{
/* Transfer the variable to the new active page */
EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar);
/* If program operation was failed, a Flash error code is returned */
if (EepromStatus != FLASH_COMPLETE)
{
return EepromStatus;
}
}
}
}
/* Erase the old Page: Set old Page status to ERASED status */
FlashStatus = FLASH_ErasePage(OldPageAddress);
/* If erase operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
/* Set new Page status to VALID_PAGE status */
FlashStatus = FLASH_ProgramHalfWord(NewPageAddress, VALID_PAGE);
/* If program operation was failed, a Flash error code is returned */
if (FlashStatus != FLASH_COMPLETE)
{
return FlashStatus;
}
/* Return last operation flash status */
return FlashStatus;
}
/**
* @}
*/
/******************* (C) COPYRIGHT 2009 STMicroelectronics *****END OF FILE****/
eeprom.h
/**
******************************************************************************
* @file EEPROM_Emulation/inc/eeprom.h
* @author MCD Application Team
* @version V3.1.0
* @date 07/27/2009
* @brief This file contains all the functions prototypes for the EEPROM
* emulation firmware library.
******************************************************************************
* @copy
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
* <h2><center>© COPYRIGHT 2009 STMicroelectronics</center></h2>
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __EEPROM_H
#define __EEPROM_H
/* Includes ------------------------------------------------------------------*/
#include <stdint.h>
#include "stm32f10x_lib.h"
#define __IO volatile /*!< defines 'read / write' permissions */
//#include "stm32f10x.h"
/* Exported constants --------------------------------------------------------*/
/* Define the STM32F10Xxx Flash page size depending on the used STM32 device */
#if defined (STM32F10X_LD) || defined (STM32F10X_MD)
#define PAGE_SIZE (uint16_t)0x400 /* Page size = 1KByte */
#elif defined (STM32F10X_HD) || defined (STM32F10X_CL)
#define PAGE_SIZE (uint16_t)0x800 /* Page size = 2KByte */
#endif
/* EEPROM start address in Flash */
#define EEPROM_START_ADDRESS ((uint32_t)0x0803F000) /* EEPROM emulation start address:
after 64KByte of used Flash memory */
/* Pages 0 and 1 base and end addresses */
#define PAGE0_BASE_ADDRESS ((uint32_t)(EEPROM_START_ADDRESS + 0x000))
#define PAGE0_END_ADDRESS ((uint32_t)(EEPROM_START_ADDRESS + (PAGE_SIZE - 1)))
#define PAGE1_BASE_ADDRESS ((uint32_t)(EEPROM_START_ADDRESS + PAGE_SIZE))
#define PAGE1_END_ADDRESS ((uint32_t)(EEPROM_START_ADDRESS + (2 * PAGE_SIZE - 1)))
/* Used Flash pages for EEPROM emulation */
#define PAGE0 ((uint16_t)0x0000)
#define PAGE1 ((uint16_t)0x0001)
/* No valid page define */
#define NO_VALID_PAGE ((uint16_t)0x00AB)
/* Page status definitions */
#define ERASED ((uint16_t)0xFFFF) /* PAGE is empty */
#define RECEIVE_DATA ((uint16_t)0xEEEE) /* PAGE is marked to receive data */
#define VALID_PAGE ((uint16_t)0x0000) /* PAGE containing valid data */
/* Valid pages in read and write defines */
#define READ_FROM_VALID_PAGE ((uint8_t)0x00)
#define WRITE_IN_VALID_PAGE ((uint8_t)0x01)
/* Page full define */
#define PAGE_FULL ((uint8_t)0x80)
/* Variables' number */
#define NumbOfVar ((uint8_t)0x20) //32 Adet Degisken var...
/* Exported types ------------------------------------------------------------*/
/* Exported macro ------------------------------------------------------------*/
/* Exported functions ------------------------------------------------------- */
uint16_t EE_Init(void);
uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data);
uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data);
#endif /* __EEPROM_H */
/******************* (C) COPYRIGHT 2009 STMicroelectronics *****END OF FILE****/
Bu kütüphaneyi programınıza dahil edin.
Klein hocam söylemişti. Bundan sonra yapmanız gereken şey bi anlamda işlemci sınıfını keil'e tanıtmak gerekiyor. STM32F103'ün artık hangi serisini kullanıyorsanız ona göre LD, HD, MD şeklinde tanımlama yapmak gerekiyor. Örneğin STM32F103VC serisi için STM32F10X_HD yazmak lazım. Bu değeri Keil Target Options dan c++ tap ına gelin orada processor symbols kutucuğuna gerekli tanımlamayı yapın.
Sonrasında Bir sanal Adres tablosu tanımlamanız gerekiyor. Burada ki adresler sizin eeproma yazacağınız değerleri temsil edecek. Örneğin ben böyle bir tablo kullanımıştım.. Unutmadan burada tanımladığınız değer kadar eepromda değer yazabileceğiniz adresiniz olur. Ayrıca buradaki tanımladığınız değer sayısı kadar eeprom.h içerisindeki numbOfVar Değişkenine değer atamalısınız.
const uint16_t VirtAddVarTab[] = { //Sanal Adres Tablosu
0x5500, 0x5501, 0x5502, 0x5503, 0x5504, 0x5505, 0x5506, 0x5507,
0x5508, 0x5509, 0x550A, 0x550B, 0x550C, 0x550D, 0x550E, 0x550F,
0x5510, 0x5511, 0x5512, 0x5513, 0x5514, 0x5515, 0x5516, 0x5517,
0x5518, 0x5519, 0x551A, 0x551B, 0x551C, 0x551D, 0x551E, 0x551F,
0x5520, 0x5521, 0x5522, 0x5523, 0x5524, 0x5525, 0x5526, 0x5527,
0x5528, 0x5529, 0x552A, 0x552B, 0x552C, 0X552D, 0x552E, 0X552F
}; Bunları yaptıktan sonra read ve write fonksiyonlar ile belirttiğiniz sanal adreslere yazma yapabilirsiniz.
Arkadaşlar Dün akşam elimde bulunan 320x240 çözünürlüğe sahip ili9325 çipli bir tft ile uğraşayım dedim. TFT yi daha çinden satın almış olduğum arm kartıyla gelen kodlarla çalıştırdım. Şuanda tft ye 16 bit paralel olarak data gönderip kullanabiliyorum fakat kullandığım kütüphane çok sıkıntılı. Doğru düzgün çalışan birtek string basma fonksiyonları.
Kodlar ise resmen çince yazılmış işin içinden çıkamıyorum. :-X
Bana kullandığınız en azından pixel basma ve string komutları düzgün çalışan bir kütüphane verirseniz sevinirim gerçekten. Line, Circle, Rec. vb. Fonksiyonlar olmasada olabilir. Daha önce spfd5408 için eklemiştim bunada yapabilirim.
TFT Kütüphanemi adam ettim. Sadece Resim basmada sıkıntı var resim ters çıkıyor. Oda ekran yapısıyla ilgili. Normalde ekranın 0,0 noktası ekranın sol üst köşesi olması gerekirken bunda sağ üst köşe. Yani ekran sağdan sola doğru döşeniyor.
Bunu halledebilirim.
Şimdi PWM olayına daldım. İşlemcinin Timer hesaplamalarının nasıl yapıldığını öğrenmem gerekiyor. örneğin Bana 100Khz ve %50 duty oranında sabit bir pwm sinyali lazım. Yada Mesela 1Khz Sabit frekans ve 0-%100 arasında değişen bir sinyal lazım. Timer Bölücü ve prescaller değerlerini nasıl hesaplayacağım bu durumda.
http://muhittinkaplan.com/2012/11/coocox-ile-adc-ve-pwm/ (http://muhittinkaplan.com/2012/11/coocox-ile-adc-ve-pwm/)
mesaj birleştirme:: 05 Temmuz 2013, 17:20:43
Yada Bir yerde Kullandığım
void TIM_PWMOutput(void)
{
PrescalerValue = (uint16_t) (SystemCoreClock / 64000000) - 1; //sistem frekansına göre ön bölme işlemi yapalım
/* Time base configuration */
TIM_TimeBaseStructure.TIM_Period = 64000; //Periyot belirleniyor 64000000/64000=1000 hz
TIM_TimeBaseStructure.TIM_Prescaler = 0; //PrescalerValue;//Ön bölücü değeri
TIM_TimeBaseStructure.TIM_ClockDivision = 0; //
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; //Timer Yukarı saysın
TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure); //Yukardaki ayarlamalar Timer3 için uygulansın
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
//TIM_OCInitStructure.TIM_Pulse = 4800;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
//TIM_OC1Init(TIM3, &TIM_OCInitStructure);
TIM_OC1PreloadConfig(TIM3, TIM_OCPreload_Enable);
/* PWM1 Kanal2 Eğer Kullanılırsa PwmConfigChannel1 fonksiyonundan çoğaltılacak*/
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 4800;//;CCR2_Val; KANALLAR AYARLANDIĞINDA DEĞERLER AYARLANACAK
TIM_OC2Init(TIM3, &TIM_OCInitStructure);
TIM_OC2PreloadConfig(TIM3, TIM_OCPreload_Enable);
/* PWM1 Kanal3 Eğer Kullanılırsa PwmConfigChannel1 fonksiyonundan çoğaltılacak*/
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 4800;//CCR3_Val;
TIM_OC3Init(TIM3, &TIM_OCInitStructure);
TIM_OC3PreloadConfig(TIM3, TIM_OCPreload_Enable);
/* PWM1 Kanal4 Eğer Kullanılırsa PwmConfigChannel1 fonksiyonundan çoğaltılacak*/
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 4800;//CCR4_Val;
TIM_OC4Init(TIM3, &TIM_OCInitStructure);
TIM_OC4PreloadConfig(TIM3, TIM_OCPreload_Enable);
TIM_ARRPreloadConfig(TIM3, ENABLE);
TIM_Cmd(TIM3, ENABLE);
}
Muhittin abi periyot işini anladım sanırım.
Timer modulunun giriş frekansi ne ise sanırım burada systemcoreclock bu degeri temsil ediyor. Çünkü bildigim kadariyla timer1 ve 8 max 36mhz giris frekansı na sahipti.
Periyot bizim direk pwm frekansı nı belirliyor. İstediğimiz çıkış frekansına göre burada bir bölücü degeri belirliyoruz.
Yalnız duty belirlemede anlamadıklarım var.
Pwm frekansimiz ne olursa olsun duty degeri hep sabit aralıktamıdır. Yani buraya vereceğimiz deger araligi nedir?
mucit systemcoreclock MCU nun çalışma frekansı ben 64 ile çalıştırmışım sanırım.
bak bir fonksiyon yapmışım Periyot (Pwm freq) ne olursa olsun Yüzdelik değer ile değer ile DUTY CYCLE oranını ayarlıyor.
void PwmConfigChannel1(float PwmPercent)
{
int Period;
Period=TIM_TimeBaseStructure.TIM_Period; //Peryot değeri alınıyor
int PWMOran;
PWMOran=(Period*PwmPercent)/100; //CCR1 Value hesaplanıyor
TIM_OCInitStructure.TIM_Pulse = PWMOran; //DUTY değeri buradanayarlanıyor
TIM_OC1Init(TIM3, &TIM_OCInitStructure);
}
Alıntı yapılan: muhittin_kaplan - 06 Temmuz 2013, 00:19:20
mucit systemcoreclock MCU nun çalışma frekansı ben 64 ile çalıştırmışım sanırım.
bak bir fonksiyon yapmışım Periyot (Pwm freq) ne olursa olsun Yüzdelik değer ile değer ile DUTY CYCLE oranını ayarlıyor.
void PwmConfigChannel1(float PwmPercent)
{
int Period;
Period=TIM_TimeBaseStructure.TIM_Period; //Peryot değeri alınıyor
int PWMOran;
PWMOran=(Period*PwmPercent)/100; //CCR1 Value hesaplanıyor
TIM_OCInitStructure.TIM_Pulse = PWMOran; //DUTY değeri buradanayarlanıyor
TIM_OC1Init(TIM3, &TIM_OCInitStructure);
}
Hocam OC ilklendirme daha uzun sürer. Sürekli PWM ayarlayacaksanız en iyisi doğrudan register'a müdahele yöntemi. TIM3->CCR1 = PWMOran yaparsanız çıkışta hiçbir kesinti olmaksızın pwm değeri değişir...
Hocam işi çözdüm galiba.
Dün akşam denemelerimde olumlu sonuçlar alabildim.
Denemerimde 2khz pwm frekansı almak için periyot degerini 999 yapıp presacaller degerinide 35 yaptım. Bu sayede 2khz sinyal aldım
CCR1 degerine ise 0-1000 arası bir deger vererek duty ayarlıyorum.
Simdi potla tft ekran ledinin açıp kapatıyorum
Arkadaşlar Merhaba.
STM32F103 de Spi donanımını kullanıyorum. Sormak istediğim bir konu var. SPİ donanımını En yüksek hızda çalıştırdığımda Clock sinyalindeki datalar kare dalgadan sinüse benzemeye başlıyor. Yani Kare dalganın köşeleri yumuşuyor. Bu normalmidir
Arkadaşlar Merhaba.
STM32F103 de Spi donanımını kullanıyorum. Sormak istediğim bir konu var. SPİ donanımını En yüksek hızda çalıştırdığımda Clock sinyalindeki datalar kare dalgadan sinüse benzemeye başlıyor. Yani Kare dalganın köşeleri yumuşuyor. Bu normalmidir
Alıntı yapılan: OrhanYaman - 22 Temmuz 2013, 22:31:08
Arkadaşlar Merhaba.
STM32F103 de Spi donanımını kullanıyorum. Sormak istediğim bir konu var. SPİ donanımını En yüksek hızda çalıştırdığımda Clock sinyalindeki datalar kare dalgadan sinüse benzemeye başlıyor. Yani Kare dalganın köşeleri yumuşuyor. Bu normalmidir
normaldir.
Aslında kare dalga yine kare ama osiloskop ölçüm problarımız 10Mhz kadar oluyor genellikle.
10mhz yaklaşırken sinüse banzer olarak ölçmeye başlıyor sinyalı.
tam olarak görmek istiyorsan yüksek frekans probları var. textronic' de falan vardı...
Alıntı yapılan: OrhanYaman - 22 Temmuz 2013, 22:31:08
Arkadaşlar Merhaba.
STM32F103 de Spi donanımını kullanıyorum. Sormak istediğim bir konu var. SPİ donanımını En yüksek hızda çalıştırdığımda Clock sinyalindeki datalar kare dalgadan sinüse benzemeye başlıyor. Yani Kare dalganın köşeleri yumuşuyor. Bu normalmidir
Aslında kusursuz kare dalga diye bir şey yoktur.
Bakabiliyorsanız MCO ile system clock sinyalini inceleyin. 72 MHz sinüs gibi bir şey göreceksiniz.
Alıntı yapılan: camby - 23 Temmuz 2013, 00:30:06
Aslında kusursuz kare dalga diye bir şey yoktur.
Bakabiliyorsanız MCO ile system clock sinyalini inceleyin. 72 MHz sinüs gibi bir şey göreceksiniz.
Biraz da iç kapasitelerden kaynaklanıyor hocam...
Köşelerin yumuşak olması bazen iyidir.
Ör: PIC'lerde zaten max io hızı (clock değil) 10MHz'i geçemeyecek IC'ler bile io pinlerinde 1.2ns rise time'a sahip olabiliyorlar.
Yüksek empedanslı yükleri sürdüklerinde çeşit çeşit sorunlara neden olabiliyorlar. Bunları ıslah etmek gerekiyor.
Ama kullandığım LPC1000 serisinde 5ns civarında
Anladım arkadaşlar.
Teşekkür ler
STM32 GPIO hızı ayarlama biraz bu işe yarıyor. Eğer portt çıkış hızını max yaparsanız , köşeler biraz daha sivrilir.
Hocam en yüksek hızla bu durum oluyor.Gpio hizi en yüksek. Yarın bir resim çekeyim daha net anlaşılır
Kullandığınız probe 1X mi ?
Sinyal resimlerini vereyim
Bu Spi1 den aldığım clk sinyali.
(http://s24.postimg.cc/gnwk5w5ph/spi1.png) (http://postimg.cc/)
ücretsiz resim barındırma (http://postimg.cc/index.php?lang=turkish)
Buda Spi2 den çıkan clk sinyali.
(http://s10.postimg.cc/c9apkfaop/spi2.png) (http://postimg.cc/)
çoklu resim yükle (http://postimg.cc/index.php?lang=turkish)
Kullandığım prob 1x de, Ama benim aklıma yine yatmıyor.
Alıntı yapılan: Mucit23 - 24 Temmuz 2013, 13:13:14
Kullandığım prob 1x de, Ama benim aklıma yine yatmıyor.
1X probun yaklaşık kapasitesi 100pF/m'dir. Çıkışa çok büyük bir kapasitif yük bağlamış oluyorsunuz
Anlıyorum sanırım tamamen probla ilgili bir durum
200MHz Scope, 300Mhz X10 Probe
Not: overshot ve ringing'in nedeni biraz uzun bıraktığım ground kablosu
(http://i41.tinypic.com/2yuc9hs.jpg)
(http://i40.tinypic.com/30vmye1.jpg)
Merhaba arkadaşlar.
P10 paneller ile uğraşırken ekran parlaklığını ayarlamak için display enable sinyalini 10khz pwm sinyali ile module edip öyle kullanıyordum. Bunu pic ile yapabilmek için enable sinyali ve pwm sinyalini ve kapısıyla üst üste bindirip display'e gönderiyorum.
Aynı işlemi stm32de harici kapı kullanmadan direk donanımsal olarak yapabilirmiyim. Pwm sinyali zaten alabiliyorum. Şimdi istedigim zaman çok hızlı bir şekilde bu sinyali açıp kapamam lazım. Bu nasıl olur?
DGS araya girince unuttum.
Bir örnekte gördüm. PWM sinyalini açıp kapamak için ilgili pini giriş yapıyordu. Tekrar açmak içinse Çıkış yapıyordu.
Benim gerektiğinde 10uS Hatta daha kısa aralıklarla açıp kapamam gerekecek. Bu mantığı uygulayabilirmiyim?
Hocam tam anlamamis olabilirim ama pwm i acip kapatmaya mi calisiyorsun? Bunun icin pwm in timer ini durdurabilirsin
(http://s22.postimg.cc/s3sv9ozi9/images_1.jpg) (http://postimg.cc/)
gif upload (http://postimg.cc/index.php?lang=turkish)
Bana böyle bir sinyal lazım. Normalde Pic ile Bu sinyali alabilmek için Sabit 10Khz pwm sinyali ile jojik durumunu açıp kapayabileceğim başka bir bini 7408 VE kapı sı ile birleştirip kullanıyordum. Şimdi VE kapısı kullanmayayım diyorum.
Sizin dediğinizide bir deniyeyim. PWM frekansını 10Khz ye ayarlayıp Timeri veya RCC den Timerin Clock Kaynağını kapatıp açayım.
Hocam rcc den kapamana gerek yok. Sadece start stop yapsan yeterli. Bu start stop islemini istersen baska bir timerin kesmesinde kodla kendin yapabilirsin.
Hatta timerlari master slave calistirma imkanimiz var.
Tabi uygulamanizda start stop yapmak daha pratik olur.
@camby,
Hocam Timeri durdurmak işe çözüm olmadı. Yaptığım işlem çalışıyor fakat kontrolsüz bir şekilde açma kapama işlemi gerçekleşiyor.
Ben PWMi kapattığım zaman çıkışın lojik0 da kalmasını istiyorum ama gerçekte öyle olmuyor. Ben Timeri Durdurduğum zaman, O anda Gpio Çıkışı hangi konumdaysa orda kalıyor. Bu olmaması gerekir.
Aldığım sonuç böyle.
(http://s10.postimg.cc/691d6ce4p/DS1_EB133304861_0.png) (http://postimg.cc/)
resİm yÜkleme (http://postimg.cc/index.php?lang=turkish)
rm0008 sf.340
Ersin Hocam Teşekkür ederim.
Referance Manual'in 340. sayfasında Output State ile ilgili birçok bilgi var. Std_Lib'de Timer Output State ile ilgili bazı tanımlamalar yapılmış. Ama bu iş içinmi emin değilim. Tam olarak ne yapmam gerekiyor?
Bir Sorum daha olacak.
STM32 de bir donanımı ilgili pinlere nasıl yönlendiriyoruz. Örnek vermek gerekirse, Şuanda istediğim PWM sinyalini Tim4'ün 2. Kanalından alıyorum (PB7). Bu pinde Ayrıca I2C donanımı var. I2C lazım olursa engel olabilir diye Tim4 ün 3. Kanalından(PB8) veya 4. Kanaldan alayım. (PB9)
PWM i Ayarlamak için aşağıdaki kodları kullanıyorum.
TIM_OCInitTypeDef TIM_OCInitStructure;
void PWM_init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
/* TIM4 clock enable */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_APB2Periph_AFIO, ENABLE );
/* GPIOB Configuration:TIM4 Channel 2 as alternate function push-pull */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7; // PB7
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* Time base configuration */
/* PWM frequency = 72MHz / [Period*(Prescaler+1)] */
TIM_TimeBaseStructure.TIM_Period = 999;
TIM_TimeBaseStructure.TIM_Prescaler = 35;
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);
/* PWM1 Mode configuration: Channel2 */
TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
TIM_OCInitStructure.TIM_Pulse = 500; //CCR2 Value; duty cycle = CCR/Period
TIM_OC2Init(TIM4, &TIM_OCInitStructure);
TIM_OC2PreloadConfig(TIM4, TIM_OCPreload_Enable);
TIM_ARRPreloadConfig(TIM4, ENABLE);
/* TIM4 enable counter */
TIM_Cmd(TIM4, ENABLE);
}
Burada kodları incelediğimde İlk Önce GPIO'un Timer4 Kanal2 ye denk gelen pini(PB7) AF_PP moduna sokuluyor. Bunun dışında PWM sinyalinin PB7 den çıkmasını sağlayacak Herhangi bir Yönlendirme göremiyorum.
Bu durumda Ben GPIO_Pin7 Yerine Pin8 için aynı işlemi yaptığımda PWM sinyali 8. Pinden çıkmıyor. Bu durumda Başka bir yerden yönlendirme yapıldığını düşünüyorum ama bulamıyorum.
ARM uğraşırken Bu çok fazla karşıma çıkıyor. Sadece pwm için değil bu başka bir donanımda olabilir.
Bu konuyu açıklarsanız gerçekten sevinirim. Özellikle bunu öğrenmem lazım.
Alıntı yapılan: Mucit23 - 04 Ağustos 2013, 13:59:03
(http://s22.postimg.cc/s3sv9ozi9/images_1.jpg) (http://postimg.cc/)
gif upload (http://postimg.cc/index.php?lang=turkish)
Bana böyle bir sinyal lazım. Normalde Pic ile Bu sinyali alabilmek için Sabit 10Khz pwm sinyali ile jojik durumunu açıp kapayabileceğim başka bir bini 7408 VE kapı sı ile birleştirip kullanıyordum. Şimdi VE kapısı kullanmayayım diyorum.
Sizin dediğinizide bir deniyeyim. PWM frekansını 10Khz ye ayarlayıp Timeri veya RCC den Timerin Clock Kaynağını kapatıp açayım.
Pic ile bu sinyali pic dışında herhangi bir şey kullanmadan elde etmek gayet kolay. Microchip motor control ve power control pwm diye iki uygulama yerleştirdi chiplerine.
Alıntı yapılan: blacklogic - 04 Ağustos 2013, 19:37:38
Pic ile bu sinyali pic dışında herhangi bir şey kullanmadan elde etmek gayet kolay. Microchip motor control ve power control pwm diye iki uygulama yerleştirdi chiplerine.
picte nasil oluyor bu is peki ?
Pwm kapatıldıktan sonra lojik durumu o yapmak için ilgili pin registerden 0 çeksen olmuyormu?
@mucit hocam,
evet öyle bir durum var,
Timer'ı kapattıktan sonra pin'i 0'a çekmeniz gerekli.
Yada timer'ı hiç kapatmayın sürekli olarak açık kalsın , kapatmak yada açmak istediğinizi sırada pinin durumunu AF modundan normale geçirip logic 0 yapın , açmak istediğiniz sırada da tekrar AF moduna döndürün.
TIM_CCxCmd(TIM4, TIM_Channel_2, TIM_CCxN_Enable);
TIM_CCxCmd(TIM4, TIM_Channel_2, TIM_CCxN_Disable);
komutları direk istediğinizi yapar,
diğer sorunuz için aynı pdf 154. ve 174. sayfasını inceleyin remapping olarak geçiyor.
stm32f4xx_tim.c yi incelerseniz detaylara ulaşmış olursunuz.
Teşekkür ederim Arkadaşlar bakayım
Alıntı yapılan: camby - 04 Ağustos 2013, 20:23:15
picte nasil oluyor bu is peki ?
https://www.picproje.org/index.php/topic,48144.0.html (https://www.picproje.org/index.php/topic,48144.0.html)
Alıntı yapılan: blacklogic - 04 Ağustos 2013, 23:07:58
https://www.picproje.org/index.php/topic,48144.0.html (https://www.picproje.org/index.php/topic,48144.0.html)
donanimsal olarak cikiyor mu peki bu sinyal ? Sadece register datasi girerek yani.
Yoksa pwm sinyali olusturup yazilimsal olarak acip kapatiyor musunuz
Alıntı yapılan: camby - 05 Ağustos 2013, 00:03:00
donanimsal olarak cikiyor mu peki bu sinyal ? Sadece register datasi girerek yani.
Yoksa pwm sinyali olusturup yazilimsal olarak acip kapatiyor musunuz
Donanımsal, sadece register'e bilgi yaz yeter.
Ersin Hocam Merhaba,
Remapping işini çözdüm. Fakat bir sıkıntım daha var. Şuanda Tim4'ün 2. Kanalından(ch2) pwm sinyali alıyor. Ben bu pwm sinyalini Tim4 ün 2. kanalı yerine 3 veya 4. kanalından almak için hangi işlemleri yapmalıyım. Sadece gpio tanımlamalarını bu pinlere yapmak yetmiyor. (Aslında anlatmaya çalıştığım şey buydu:))
Yahu Çözdüm işi :D Tamam Şimdi Herşey yerine oturdu.
Her kanal için farklı Tim_OC init fonksiyonları varmış. 2.Kanal için TIM_OC2Init, 3. Kanal için TIM_OC3Init vs. Bunların değişmesi gerekiyormuş.
Arkadaşlar Birkaç Problemim var. Spi hız konusunda sıkıntı çekiyorum.
Sırayla Problemlerimi yazayım
1-) Spi BaudratePrescaller değerini 4 den farklı bir değer yapınca spi saçmalamaya başlıyor. Spi le 74595 sürüyorum. Baudrate değerini 4 yaptığım zaman ,SPI clock frekansı 17-18 mhz'e yaklaşıyor. Bu frekansta 74595 çalışıyor ama bazen 74595 çıkışları milisaniyelik olarak açılıp kapanıyor. Bunun Hızla ilgili olduğunu düşünüyorum. Hızı biraz düşürmek istedim. Baudrate değerini 8 veya daha farklı bir değer yaparsam clock frekansı anlamsız oluyor. Örneğin 1Byte gönderildiği zaman 8 clock palsi olması gerekirken Saymadım ama 16 dan fazla clock palsi oluşuyor. (1 Byte için) Bu Neden olabilir?
SPI ayarlarım bu şekilde.
/* SPI1 configuration */
SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPI1, &SPI_InitStructure);
2-) Global Değişken nasıl tanımlanır. Bu tanımladığım değişkeni hem main programında hemde hemde main programına dahil ettiğim diğer kütüphanelerde (Örneğin SPI.c) kullanayım. Böyle bir durum mümkünmü?
3-)Timer Kesmesi oluştuğunda Spi ile hızlı bir şekilde 32 byte data göndermem gerekiyor. Her kesme oluştuğunda döngü içerisinde spi den 32 byte data gönderiyorum. Fakat SPİ data gönderme fonksiyonuna her geldiğimde program spi bufferinin boşalmasını bekliyor.
SPİ Gönderme Fonksiyonum böyle.
void SPI1_WriteByte(unsigned char writedat)
{
/* Loop while DR register in not emplty */
while (SPI_GetFlagStatus(SPI1, SPI_FLAG_TXE) == RESET);
/* Send byte through the SPI1 peripheral */
SPI_I2S_SendData(SPI1, writedat);
}
SPİ>DR registerinin boşalması beklenince bu sefer işlemci donuyor. Aslında timer kesmesi içerisindeki en ufak bir bekleme işlemciyi donduruyor. Buradaki durumda benzer.
while (SPI_GetFlagStatus(SPI1, SPI_FLAG_TXE) == RESET);
Bu satırı kapatınca program çalışıyor. Datalar görünüşte düzgünde gidiyor. Ama emin değilim. Burada beklemek nekadar önemli?
mucit CoIDE nin örneği.
/**
*****************************************************************************
* @title SPI_Exp.c
* @author CooCox
* @date 15 Mar 2011
* @brief This example provides a description of how to set a communicatio
* n between two
* SPIs in simplex mode and performs a data buffer t
* ransfer from SPI_MASTER to
* SPI_SLAVE.
* SPI_MASTER and SPI_SLAVE
* can be SPI1 and SPI2 or SPI3 and SPI2, depending on
* the STMicr
* oelectronics EVAL board you are using.
* This example poll some f
* lags to transmit or receive data other than using
* interrupts.
*******************************************************************************
*/
////// The above comment is automatically generated by CoIDE ///////////////////
#include "stm32f10x_gpio.h"
#include "stm32f10x_rcc.h"
#include "stm32f10x_spi.h"
typedef enum {FAILED = 0, PASSED = !FAILED} TestStatus;
#define BufferSize 32
SPI_InitTypeDef SPI_InitStructure;
uint8_t SPI1_Buffer_Tx[BufferSize] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12,
0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E,
0x1F, 0x20 };
uint8_t SPI2_Buffer_Tx[BufferSize] = { 0x51, 0x52, 0x53, 0x54, 0x55, 0x56,
0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62,
0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E,
0x6F, 0x70 };
uint8_t SPI1_Buffer_Rx[BufferSize], SPI2_Buffer_Rx[BufferSize];
uint8_t Tx_Idx = 0, Rx_Idx = 0;
uint32_t k;
volatile TestStatus TransferStatus1 = FAILED, TransferStatus2 = FAILED;
volatile TestStatus TransferStatus3 = FAILED, TransferStatus4 = FAILED;
ErrorStatus HSEStartUpStatus;
/***************************************************************************//**
* Declare function prototypes
******************************************************************************/
void RCC_Configuration(void);
void GPIO_Configuration(void);
void NVIC_Configuration(void);
TestStatus Buffercmp(u8* pBuffer1, u8* pBuffer2, u16 BufferLength);
/***************************************************************************//**
* @brief
*******************************************************************************/
void SPI_Exp(void)
{
/* System clocks configuration -------------------------------------------*/
RCC_Configuration();
/* GPIO configuration ----------------------------------------------------*/
GPIO_Configuration();
GPIO_ResetBits(GPIOC, GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_6 | GPIO_Pin_7);
/* Just delay some time */
for (k = 0; k < 1000000; k++)
{;}
/* 1st phase: SPI1 Master and SPI2 Slave */
/* SPI1 Configuration ----------------------------------------------------*/
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_LSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPI1, &SPI_InitStructure);
/* SPI2 Configuration ----------------------------------------------------*/
SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
SPI_Init(SPI2, &SPI_InitStructure);
/* Enable SPI1 */
SPI_Cmd(SPI1, ENABLE);
/* Enable SPI2 */
SPI_Cmd(SPI2, ENABLE);
/* Transfer procedure */
while (Tx_Idx < BufferSize)
{
/* Wait for SPI1 Tx buffer empty */
while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
/* Send SPI2 data */
SPI_I2S_SendData(SPI2, SPI2_Buffer_Tx[Tx_Idx]);
/* Send SPI1 data */
SPI_I2S_SendData(SPI1, SPI1_Buffer_Tx[Tx_Idx++]);
/* Wait for SPI2 data reception */
while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET);
/* Read SPI2 received data */
SPI2_Buffer_Rx[Rx_Idx] = SPI_I2S_ReceiveData(SPI2);
/* Wait for SPI1 data reception */
while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
/* Read SPI1 received data */
SPI1_Buffer_Rx[Rx_Idx++] = SPI_I2S_ReceiveData(SPI1);
}
/* Check the correctness of written data */
TransferStatus1 = Buffercmp(SPI2_Buffer_Rx, SPI1_Buffer_Tx, BufferSize);
TransferStatus2 = Buffercmp(SPI1_Buffer_Rx, SPI2_Buffer_Tx, BufferSize);
/* TransferStatus1, TransferStatus2 = PASSED, if the transmitted and
* received data are equal */
/* TransferStatus1, TransferStatus2 = FAILED, if the transmitted and
* received data are different */
if (TransferStatus1 == PASSED)
GPIO_SetBits(GPIOC, GPIO_Pin_6);
if (TransferStatus2 == PASSED)
GPIO_SetBits(GPIOC, GPIO_Pin_7);
/* Just delay some time */
for (k = 0; k < 1000000; k++)
{;}
/* 2nd phase: SPI1 Slave and SPI2 Master */
/* SPI1 Re-configuration -------------------------------------------------*/
SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
SPI_Init(SPI1, &SPI_InitStructure);
/* SPI2 Re-configuration -------------------------------------------------*/
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_Init(SPI2, &SPI_InitStructure);
/* Reset Tx_Idx, Rx_Idx indexes and receive tables values */
Tx_Idx = 0;
Rx_Idx = 0;
for (k = 0; k < BufferSize; k++)
SPI2_Buffer_Rx[k] = 0;
for (k = 0; k < BufferSize; k++)
SPI1_Buffer_Rx[k] = 0;
/* Transfer procedure */
while (Tx_Idx < BufferSize)
{
/* Wait for SPI2 Tx buffer empty */
while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET);
/* Send SPI1 data */
SPI_I2S_SendData(SPI1, SPI1_Buffer_Tx[Tx_Idx]);
/* Send SPI2 data */
SPI_I2S_SendData(SPI2, SPI2_Buffer_Tx[Tx_Idx++]);
/* Wait for SPI1 data reception */
while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);
/* Read SPI1 received data */
SPI1_Buffer_Rx[Rx_Idx] = SPI_I2S_ReceiveData(SPI1);
/* Wait for SPI2 data reception */
while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET);
/* Read SPI2 received data */
SPI2_Buffer_Rx[Rx_Idx++] = SPI_I2S_ReceiveData(SPI2);
}
/* Check the correctness of written data */
TransferStatus3 = Buffercmp(SPI2_Buffer_Rx, SPI1_Buffer_Tx, BufferSize);
TransferStatus4 = Buffercmp(SPI1_Buffer_Rx, SPI2_Buffer_Tx, BufferSize);
/* TransferStatus3, TransferStatus4 = PASSED, if the transmitted and
received data are equal */
/* TransferStatus3, TransferStatus4 = FAILED, if the transmitted and
received data are different */
if (TransferStatus3 == PASSED)
GPIO_SetBits(GPIOC, GPIO_Pin_8);
if (TransferStatus4 == PASSED)
GPIO_SetBits(GPIOC, GPIO_Pin_9);
}
/***************************************************************************//**
*@brief
******************************************************************************/
void RCC_Configuration(void)
{
/* RCC system reset(for debug purpose) */
RCC_DeInit();
/* Enable HSE */
RCC_HSEConfig(RCC_HSE_ON);
/* Wait till HSE is ready */
HSEStartUpStatus = RCC_WaitForHSEStartUp();
if (HSEStartUpStatus == SUCCESS)
{
/* HCLK = SYSCLK */
RCC_HCLKConfig(RCC_SYSCLK_Div1);
/* PCLK2 = HCLK/2 */
RCC_PCLK2Config(RCC_HCLK_Div2);
/* PCLK1 = HCLK/2 */
RCC_PCLK1Config(RCC_HCLK_Div2);
/* PLLCLK = 8MHz * 9 = 72 MHz */
RCC_PLLConfig(0x00010000, RCC_PLLMul_9);
/* Enable PLL */
RCC_PLLCmd(ENABLE);
/* Wait till PLL is ready */
while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET) {}
/* Select PLL as system clock source */
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
/* Wait till PLL is used as system clock source */
while (RCC_GetSYSCLKSource() != 0x08) {}
}
/* Enable peripheral clocks ----------------------------------------------*/
/* GPIOA, GPIOB and SPI1 clock enable */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC
| RCC_APB2Periph_SPI1, ENABLE);
/* SPI2 Peripheral clock enable */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
}
/***************************************************************************//**
@brief Configure GPIO settings
******************************************************************************/
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Configure SPI1 pins: SCK, MISO and MOSI -------------------------------*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* Configure SPI2 pins: SCK, MISO and MOSI -------------------------------*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* Configure PC6~PC9 ----------------------------------------------------*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_6
| GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOC, &GPIO_InitStructure);
}
/***************************************************************************//**
@brief
******************************************************************************/
TestStatus Buffercmp(u8* pBuffer1, u8* pBuffer2, u16 BufferLength)
{
while (BufferLength--)
{
if (*pBuffer1 != *pBuffer2)
{
return FAILED;
}
pBuffer1++;
pBuffer2++;
}
return PASSED;
}
Alıntı yapılan: Mucit23 - 12 Ağustos 2013, 12:43:44
Arkadaşlar Birkaç Problemim var. Spi hız konusunda sıkıntı çekiyorum.
Sırayla Problemlerimi yazayım
1-) Spi BaudratePrescaller değerini 4 den farklı bir değer yapınca spi saçmalamaya başlıyor. Spi le 74595 sürüyorum. Baudrate değerini 4 yaptığım zaman ,SPI clock frekansı 17-18 mhz'e yaklaşıyor. Bu frekansta 74595 çalışıyor ama bazen 74595 çıkışları milisaniyelik olarak açılıp kapanıyor. Bunun Hızla ilgili olduğunu düşünüyorum. Hızı biraz düşürmek istedim. Baudrate değerini 8 veya daha farklı bir değer yaparsam clock frekansı anlamsız oluyor. Örneğin 1Byte gönderildiği zaman 8 clock palsi olması gerekirken Saymadım ama 16 dan fazla clock palsi oluşuyor. (1 Byte için) Bu Neden olabilir?
SPI ayarlarım bu şekilde.
/* SPI1 configuration */
SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPI1, &SPI_InitStructure);
2-) Global Değişken nasıl tanımlanır. Bu tanımladığım değişkeni hem main programında hemde hemde main programına dahil ettiğim diğer kütüphanelerde (Örneğin SPI.c) kullanayım. Böyle bir durum mümkünmü?
3-)Timer Kesmesi oluştuğunda Spi ile hızlı bir şekilde 32 byte data göndermem gerekiyor. Her kesme oluştuğunda döngü içerisinde spi den 32 byte data gönderiyorum. Fakat SPİ data gönderme fonksiyonuna her geldiğimde program spi bufferinin boşalmasını bekliyor.
SPİ Gönderme Fonksiyonum böyle.
void SPI1_WriteByte(unsigned char writedat)
{
/* Loop while DR register in not emplty */
while (SPI_GetFlagStatus(SPI1, SPI_FLAG_TXE) == RESET);
/* Send byte through the SPI1 peripheral */
SPI_I2S_SendData(SPI1, writedat);
}
SPİ>DR registerinin boşalması beklenince bu sefer işlemci donuyor. Aslında timer kesmesi içerisindeki en ufak bir bekleme işlemciyi donduruyor. Buradaki durumda benzer.
while (SPI_GetFlagStatus(SPI1, SPI_FLAG_TXE) == RESET);
Bu satırı kapatınca program çalışıyor. Datalar görünüşte düzgünde gidiyor. Ama emin değilim. Burada beklemek nekadar önemli?
1-) rm0008 sf:675 -> BR[2:0] -> sf:715
2-) extern static volatile int foo; // spi.h dosyasına konulacak, spi.h istediğin yerde çağrılacak
static volatile int foo; //spi.c dosyasına konulacak
3-) spi->dr'nin boşalması için okunması lazım, her hangi bir yere aktarabilirsin
Hocam Spi Flagını anlayamadım birtek.
Sizin dediğiniz sanırım spi->dr registerini kendimiz boşaltmak istersek geçerli
Peşi sıra spi den data gönderirken spi dr registerinin boşalmasını beklemek gerekirmi? Bunu anlayamadım.
Birde Timer kesmesinde çok ufak sürelerde bile delay koymak işlemcinin donmasına sebeb oluyor. Birtek delay değil, işlemciyi bağlayacak herhangi birşey. Bunu önlemek mümkünmü?
spi bilgi gönderirken bilgi alan bir yapı bir bit giderken aynı anda bir bit gelir. 8 bit veya 16 bit veri aktarımı tamamlandığında flag aktif olur.
içeriği okuyup flag sıfırlanır. spi sonraki gönderime hazır olur
sf:676 da basit görsel yapısı mevcut
DMA, SPI interrupt kullanılabilir beklememek için
Stm32f107 de timer2 ile 1 saniyelik kesme oluşturuyorum. Ama anlamadığım bir nokta var.
Kesme oluşma süresi = (PSC*(ARR+1)) / APB
Timer2 APB1 hattına bağlı en yüksek hızda çalıştırıyorum 36MHz.
Aşağıdaki kod ile kesme içerisinde C portunun 3. pinine bağlı ledi 1 saniye aralıklarla yakıp söndürüyorum.
Timer 2 nin Counter Register ını (CNT) okuyorum ve lcd displayde gösteriyorum.
Problem:
Program başladığında CNT register ının içerisinde 7199 var. Her kesme geldiğinde içerik 1 azalıyor. Neden azalıyor ?
Birde dikkat ettim Yukarı sayıcı olarak ayarladığımda içerik azalıyor. Aşağı sayıcı olarak ayarladığımda içerik artıyor neden böyle ?
STM32 datasheetleri bana çok "yavan" geldi. LPC1769 da her bişeyin açıklamasını register satırının karşısında buluyordum.
NVIC_InitTypeDef NVIC_InitStructure;
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); //Timer2 clock aktif
TIM_TimeBaseStructure.TIM_Period = 7199; //ARR degeri. Buraya yazilan degere gelince timer kesme olusturur.
TIM_TimeBaseStructure.TIM_Prescaler=10000; //On bölücü degeri
TIM_TimeBaseStructure.TIM_ClockDivision=0; //Saat bölücü
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; //Timer modu. Yukari sayici.
TIM_TimeBaseInit(TIM2,&TIM_TimeBaseStructure); //Timer yapisi init.
NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn; //Kesme adresi
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 5;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 5;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
TIM_ITConfig(TIM2,TIM_IT_Update,ENABLE); // Timer güncellendiginde kesme olustur. timer sayici = ARR
TIM_ARRPreloadConfig(TIM2, ENABLE);
TIM_Cmd(TIM2, ENABLE); // Timer aktif
Hocam,
...
7197
7198
0
1
2
....
şeklinde sayması lazım sanırım , bu şekilde değil mi ?
Alıntı yapılan: camby - 25 Ağustos 2013, 21:55:39
Hocam,
...
7197
7198
0
1
2
....
şeklinde sayması lazım sanırım , bu şekilde değil mi ?
Evet CNT registerını her kesme sonunda okuyorum bu şekilde azalarak sıfıra gidiyor.
artarak aslında , up sayıyor.
Sorun yok o zaman bu şekilde ise , bir dahaki kesme 7197'de iken mi oluşuyor ?
Alıntı yapılan: camby - 25 Ağustos 2013, 22:07:36
artarak aslında , up sayıyor.
Sorun yok o zaman bu şekilde ise , bir dahaki kesme 7197'de iken mi oluşuyor ?
Evet hocam.
2. kesme 7198 değil de 7197'de geliyor diyorsunuz o zaman .
peki bu nereye kadar devam ediyor ? 3. kesme de 7196'da mı geliyor ?
Hocam kritik zaman tutmuyorum ama ledin durumuna göre sönmeye yakın veya yanmadan hemen önce displaydeki değer değişiyor. Referans alacağım bi yöntem söylerseniz hemen deneyip sonucu yazabilirim.
Edit:
Evet yukarı sayıyormuş kesmenin süresini uzattım ARR değerinden 1 çıkarıp yazmayı atlamışım buyüzden kayıyor gibi gözüküyor(?). Peki APB1 frekansına göre değilde AHB frekansına göre sayıyor bunun nedeni nedir?
Bu kadar detaya göre kritik zaman yapıyorsunuz diye düşündüm , zaman çok kritik olmasa bile kesmeli çalışmaların tam kesinlikte olmasını isteriz ama zaten.
Gözle kesinlikle anlayamazsınız 1/7198 sn farkları. 50 herz çalıştırınca bile göz algılamıyor.
Timer'dan emin olmanızın tek yolu skop kullanmak , kesmeyi 1ms yada daha az 10us ayarlayın ve çıkışa verin ( boş projede yada handler ın bölünmediğinden emin olun).
skopla hesabınızın tutması lazım. Tutarsa işlem tamam.
Timer'larda istisna var , eğer peripheral bus bölücüsü 1'den farklı ise clock hızı bus x2 olur.
referans manuel'den bak bu ayrıntıya. Clock şemasında gösterir , başka bir yerlerde de yazıyordu.
Zamanlama çok kritik değilde donanım nasıl işliyor diye bakıyorum. stm32f105-107 ye ait 103 sayfalık dökümanda 2.3overview kısmında block diyagramını inceledim orada APB1 max 36MHz gösteriyor sizin dediğiniz datasheet te nerede yazıyor hocam RCC altında mı yoksa TIM mi? Baştan aşağı okuyorum datasheeti ama kaçırdım sanırım orayı.
Şu şekilde kesme süresi 1 saniye oldu. Displayde her 9999 da led durum değiştiriyor yukarı sayıyor.
AHB ve APB1 durumunuda öğrenirsem bu gece rahat uyuyabilirim. :)
-----------
Benim kafam hep LPC1769 donanım yapısına gidiyor o yüzden çelişkide kalıyorum. Hepsi Timer da olsa birebir benzerlik olmuyor değil mi donanımlarda?
TIM_TimeBaseStructure.TIM_Period = 9999; //ARR degeri. Buraya yazilan degere gelince timer kesme olusturur.
TIM_TimeBaseStructure.TIM_Prescaler=7200; //On bölücü degeri
TIM_TimeBaseStructure.TIM_ClockDivision=0; //Saat bölücü
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; //Timer modu. Yukari sayici.
TIM_TimeBaseInit(TIM2,&TIM_TimeBaseStructure); //Timer yapisi init.
Edit:
Dediğiniz yeri buldum hocam RM008 dökümanda Sayfa 90. Clock tree şeklinde gösteriyormuş ben hiç oraya dikkat etmemiştim çok teşekkürler.
Evet cevresel bloklari istedikleri gibi yapabiliyorlar , cekirdek ve bus yapisi ayni ama
Osiloskopta pine baktım.
Period = 9999 ve prescaler=72 iken kesme içerisinde bir pini toggle ediyorum. Pin frekansı=49.32Hz.
Period = 999 ve prescaler = 72 iken Pin frekansı= 493.2Hz
Normal mi hocam?
Normal degil tam olmazi lazim, tesleri yuksek frekansta yaparsaniz hem olcum acisindan hem frekans kaymasi bakimindan daha saglikli yapin.
Ama oncelikle 72000-1 yapip deneyin
Alıntı yapılan: camby - 25 Ağustos 2013, 23:42:10
Normal değil tam olmazi lazim, tesleri yuksek frekansta yaparsaniz hem olcum acisindan hem frekans kaymasi bakimindan daha saglikli yapin.
Ama oncelikle 72000-1 yapip deneyin
Period=7199
Prescaler=0;
Pin Frekansı=5.000kHz
Hatamıda yazayım:
Düşük frekanstaki değerler içinde doğru çalışıyormuş ancak ben kod içerisinde systick timer kullanmıştım kapatmayı unuttum kesme bölünüyormuş.
tebrikler,
internal osilator %4 'e kadar kayması vardır , ama büyük ihtimal oda sıcaklığına kalibre edilmiştir , bu da aklınızda olsun.
Alıntı yapılan: camby - 25 Ağustos 2013, 23:55:57
tebrikler,
internal osilator %4 'e kadar kayması vardır , ama büyük ihtimal oda sıcaklığına kalibre edilmiştir , bu da aklınızda olsun.
Hocam genelde kristal kullanıyorum. Ama bunuda öğrendiğim iyi oldu çok teşekkürler.
Kesme oluşma süresi = (PSC*(ARR+1)) / APB
Bu şekilde değil.
Kesme oluşma süresi = (PSC+1)*(ARR+1) / APB olacak.
Bir Sorum olacak. STM32f103 ün RTC sini çalıştırdım. RTC Counteri Çalışıyor. Saat Dakika ve Saniye bilgisini alıyorum. Sormak istediğim şudur. Bana Aynı zamanda Gün(1-30) Hafta Günü (pztesi salı vs) Ay ve yıl bilgiside lazım. Bunu programda saat ve dakikaye göre kendim yürütebilirim ancak elektrik gittimi bilgilerde gider. Bu duruma nasıl çözüm getirebilirim?
Saat dakika saniye bilgilerini zaten Counter'den almıyor musunuz?
Counter saniyede 1 artıyorsa 136 yıllık counter demek.
Hocam Evet RTC counterinden alıyorum bilgileri fakat rtc saniye kesmesinde saat 23:59:59'u geçtiği anda counter sıfırlanıyor. Bende bir örnekten almıştım kodu.
if (RTC_GetCounter() == 0x00015180)
{
RTC_SetCounter(0x00000000);
/* Wait until last write operation on RTC registers has finished */
RTC_WaitForLastTask();
}
Eğer saat bilgisini sıfırlamazsam diğer gün ay ve yıl parametreleri bu counter içerisinde otomatik artacakmı? Counter'dan bunları nasıl ayırt edeceğim? Çok Kafam karıştı açıkçası?
Saniye = Counter % 60;
Dakika = (Counter / 60) % 60;
Saat = (Counter / 3600) % 24;
Gün = (Counter / 86400);
Günden de ayı , yılı , haftanın gününü hesaplarsın.
mesaj birleştirme:: 31 Ağustos 2013, 20:13:09
Haftanın günü = Gün % 7;
Ayların sabit olmaması ve Yıllık 6 ssatlik fazlalık nedeniyle nedeniyle Yıl ve ay ve ayın günü hesabı biraz daha teferruatlı.
biraz sonra onu da anlatacağım.
Yıl = ((Gün) - ((Gün/1461)+1) / 365
Not: 1461 4 yıldaki gün sayısı. Buradan o zaman kadar kaç artık yıl olduğunu hesaplıyoruz.
mesaj birleştirme:: 31 Ağustos 2013, 21:35:32
Yılın günü =Gün- (((yıl +1) *365) + Artık yıl sayısı);
Gerisi basit gün -ay hesaplamaları.
mesaj birleştirme:: 31 Ağustos 2013, 21:40:56
Saati kurarken önce günü bulacağız.
Gün = ylın günü + ( (yıl * 365)+ artık yıl sayısı)
Counter = (Gün * 86400) + (saat * 3600) + (dakika * 60) + saniye;
Hocam Teşekkürler bayağı bi açıklayıcı oldu.
Bazı parametreleri anlamadım.
Yılın Günü ve Artık yıl sayısı parametreleri nedir. İçeriği nasil değişiyor?
Aklıma takılan birkaç nokta daha var. Rtc saniye kesmesinde saat 23:59:59 u geçtiği anda counteri sıfırlamaya gerek varmıdır? Bu işlem nasıl olacak?
artık yıl sayısı = ((Gün/1461)+1) / 365;
Bu kadar işlemi , counter'i sıfırlamayalım diye yapıyoruz.
Anladım hocam deneyeyim anlattıklarınızı. Adam akıllı bir rtc kütüphanesi olusturmam lazım
Hocam Bazı sıkıntılar var adım adım gitmem gerekiyor.
Saat, Dakika ve Saniyede sıkıntı yok.
Bulmam gereken Parametreler şunlar.
Ayın Günü (1-31 arası değer alacak)
Haftanın günü (1-7 arası değer alacak. pztesi salı vs..)
Ay(1-12 arası değer alacak)
ve yıl değeri
Counter/86400 yaparak 0-6 arası değer alıyorum. Demekki Bu Haftanın günü oluyor. O halde Ayın gününü nasıl bulacağım? Böyle bir sonuca varınca herşey karıştı açıkçası. Bu işi adım adım yapmam gerekiyor
Counterdeki artış sırası nasıl oluyor bunuda anlamak lazım.
Örneğin saat 23:59:59 u aştığı anda gördüğüm kadarıyla Haftanın günü artıyor. Bundan sonra nasıl bir sıralama var?
Amacım stm32f4 rtc kütüphanesindeki gibi bir yapı oluşturmak
RTC_DateStructure.RTC_Year = 0x13;
RTC_DateStructure.RTC_Month = RTC_Month_January;
RTC_DateStructure.RTC_Date = 0x11;
RTC_DateStructure.RTC_WeekDay = RTC_Weekday_Saturday;
RTC_SetDate(RTC_Format_BCD, &RTC_DateStructure);
/* Set the time to 05h 20mn 00s AM */
RTC_TimeStructure.RTC_H12 = RTC_H12_AM;
RTC_TimeStructure.RTC_Hours = 0x05;
RTC_TimeStructure.RTC_Minutes = 0x20;
RTC_TimeStructure.RTC_Seconds = 0x00;
RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);
counter/86400 yapınca 0...6 arası değer almazsın. 0...n değer alırsın. bu sana Counter başladığından beri kaç gün geçtiğini verir.
kalan kısmını da yukarıda yazdım zaten. tekrar oku.
Haklısınız Hocam. Orada bir işlem hatası yapmışım. Normalde 0 ile n arası bir değer alıyor. Yani Diyelim günü 31'e set ettiğimde saat 23:59:59 u aştığı anda gün 32 oluyor. Sürekli Artıyor.
verdiğiniz hesapları daha uygulayamadım. Akşam uğraşacağım. Sadece AY hesaplamayı anlayamadım. Biz gün bilgisinden giderekmi ayı hesaplayacağız. En karışık olanı ay herhalde çünkü sürekli aydaki gün sayısı değişiyor. 4 yılda bir şubatın 28 çekmeside var. Bunlar hepsini ayırt edebilirmiyiz?
Birde şöyle bir sorun var. Deney bordunda çalışıyorum stm32 usb den besleniyor. Program açılırken ilk başta saati ayarladığımda saat donuyor. Resetlesem bile saat çalışmaya devam etmiyor. Ancak usb den enerjiyi kesip tekrar vermemle ayarladığım yeni değerle birlikte saat çalışmaya başlıyor. Sürekli usb yi tak çıkar yaparsam bilgisayarın usb portu bozulacak. Bu neden kaynaklanır?
STM32 RTC ile hiç uğraşmadım.Sorun hakkında hiç fikrim yok.
Ay hesaplaması üzerine biaz çalışayım.
Hocam ben rtc den biraz soğudum açıkçası. Saat neysede tarih hesaplamanın bu denli karmaşık olduğunu pek sanmıyordum. Ds1307 gibi i2c ile çalışan bir rtc kullanmayı düşünüyorum. Benim için uğraşacaksanız hiç uğraşmayın. Vaktinize Yazık
Hocam M3 core için rtc kullanımını aşağıdaki şekilde yapıyorum, istediğim bir harihin haftanın hangi gününe geldiğini hesaplama fonksiyonuda kodlara dahil belki yardımı dokunur iyi çalışmalar.
const uint8_t Week_Day_List[12] = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
RTC_TimeTypeDef RTC_TimeStructure;
RTC_DateTypeDef RTC_DateStructure;
RTC_AlarmTypeDef RTC_AlarmStructure;
/****************************************************************************************************/
// timeStamp Oku
void Date_Load(uint32_t * reg)
{
RTC_GetTime(RTC_Format_BIN, &RTC_TimeStructure);
RTC_GetDate(RTC_Format_BIN, &RTC_DateStructure);
*reg= RTC_TimeStructure.RTC_Minutes;
*reg|= RTC_TimeStructure.RTC_Hours<<8;
*reg|=(((RTC_DateStructure.RTC_Year&0x07)<<5)+RTC_DateStructure.RTC_Date)<<16;
*reg|=(((RTC_DateStructure.RTC_Year&0xF8)<<1)+RTC_DateStructure.RTC_Month)<<24;
}
/****************************************************************************************************/
uint8_t Week_Day_Search(uint8_t Year, uint8_t Month, uint8_t Day)
{
if(Month<3)
Year-=1;
return (Year + Year/4 - Year/100 + Year/400 + Week_Day_List[Month-1] + Day) % 7;
}
/****************************************************************************************************/
// Rtc kurulumunu yap
void RTC_Config(void)
{
/* Enable the PWR clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
/* Allow access to RTC */
PWR_RTCAccessCmd(ENABLE);
/* Reset RTC Domain */
RCC_RTCResetCmd(ENABLE);
RCC_RTCResetCmd(DISABLE);
/* Enable the LSE OSC */
RCC_LSEConfig(RCC_LSE_ON);
Lcd_Str (Alt1,"Waiting !!! ");
Lcd_Str (Alt2,"RTC NOT READY");
/* Wait till LSE is ready */
while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
{
}
/* Select the RTC Clock Source */
RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
/* Configure the RTC data register and RTC prescaler */
RTC_InitStructure.RTC_AsynchPrediv = 0x7F;
RTC_InitStructure.RTC_SynchPrediv = 0xFF;
RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
RTC_Init(&RTC_InitStructure);
/* Enable the RTC Clock */
RCC_RTCCLKCmd(ENABLE);
/* Wait for RTC APB registers synchronisation */
RTC_WaitForSynchro();
}
/****************************************************************************************************/
// alarmı bir sonraki saat geçişine kur
void Rtc_Alarm_Hour(void)
{
uint8_t kont;
RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
(void)RTC->DR;
RTC_GetTime(RTC_Format_BIN, &RTC_TimeStructure);
kont=RTC_TimeStructure.RTC_Hours;
kont+=1;
if(kont==24)kont=0;
//RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_H12_AM;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = kont;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = 0;
/* Set the Alarm A */
RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay; //| RTC_AlarmMask_Seconds;
/* Configure the RTC Alarm A register */
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure);
/* Enable the alarm A */
RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
RTC_ClearFlag(RTC_FLAG_ALRAF);
}
// Yeni baglanti için alarmi en erken güne kurar
void Rtc_Alarm_Day(void)
{
RTC_AlarmCmd(RTC_Alarm_B, DISABLE);
// RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_H12_AM;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = Alarm_Day_hour;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = Alarm_Day_Min;
RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = 0;
/* Set the Alarm B */
RTC_AlarmStructure.RTC_AlarmDateWeekDay = Alarm_Day_WeekDay;
RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_WeekDay;
RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_None; //| RTC_AlarmMask_Seconds;
/* Configure the RTC Alarm B register */
RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_B, &RTC_AlarmStructure);
/* Enable the alarm B */
RTC_AlarmCmd(RTC_Alarm_B, ENABLE);
RTC_ClearFlag(RTC_FLAG_ALRBF);
}
stm32 ye ait birkaç döküman inceledim hepsinde RTC biriminin gün, ay, yıl desteklediğini anlatmış ve bunun üzerinden örnekler vermiş. Ancak stm32f10x de RTC sadece saniye sayıyor.
X-Fi hocam stm32f10x std_lib de bu kodlar yok hangi işlemci ile çalışıyorsunuz?
Alıntı yapılan: mistek - 03 Eylül 2013, 08:20:47
X-Fi hocam stm32f10x std_lib de bu kodlar yok hangi işlemci ile çalışıyorsunuz?
STM32L152 ile çalışıyorum hocam farklılık olabileceğini düşünmemiştim. STM32F4 serisinde donanım desteği varmış sadece STM32F1 serilerinde bulunmuyor galiba.
Arkadaşlar ds1307 yi stm32 ile kullanacağım. Ds1307'nin ana beslemesine 5V verip SCL ve SDA pinlerini 3.3V ile pull-up yapsam iletişimde sıkıntı olurmu? Bildiğim kadarıyla SDA ve SCL Pinleri open collektör durumunda. Dolayısıyla 3.3V ile pull-up yaparsam lojik 1 voltajı 3.3v olur. Yanlışmı düşünüyorum?
Alıntı yapılan: Mucit23 - 10 Eylül 2013, 15:42:28
Arkadaşlar ds1307 yi stm32 ile kullanacağım. Ds1307'nin ana beslemesine 5V verip SCL ve SDA pinlerini 3.3V ile pull-up yapsam iletişimde sıkıntı olurmu? Bildiğim kadarıyla SDA ve SCL Pinleri open collektör durumunda. Dolayısıyla 3.3V ile pull-up yaparsam lojik 1 voltajı 3.3v olur. Yanlışmı düşünüyorum?
Daha önce 18f452 ve ds1307 ye aynı şekilde kullandım problem yok. Zaten stm32 nin bütün IO pinleri 5v toleranslı isterseniz 5v ile Pull Up yapın.
Alıntı yapılan: mistek - 10 Eylül 2013, 15:56:41
Daha önce 18f452 ve ds1307 ye aynı şekilde kullandım problem yok. Zaten stm32 nin bütün IO pinleri 5v toleranslı isterseniz 5v ile Pull Up yapın.
Teşekkür Ederim.
I2C de problem yaşıyorum.
Kullandığım kütüphaneyi vereyim.
/******************************************************************************/
/* I2C_STM32.c: STM32 low level I2C routines */
/******************************************************************************/
/* This file is part of the uVision/ARM development tools. */
/* Copyright (c) 2005-2009 Keil Software. All rights reserved. */
/* This software may only be used under the terms of a valid, current, */
/* end user licence from KEIL for a compatible version of KEIL software */
/* development tools. Nothing else gives you the right to use this software. */
/******************************************************************************/
#include "stm32f10x.h"
#include "I2C.h"
/************************ Local auxiliary functions ***************************/
/*******************************************************************************
* I2C communication status *
* Parameter: *
* Return: status *
*******************************************************************************/
static __inline unsigned int I2C_sr (void) {
unsigned int sr;
sr = I2C1->SR1;
sr |= I2C1->SR2 << 16;
return (sr);
}
/************************ Exported functions **********************************/
/*******************************************************************************
* Initialize I2C interface in master mode *
* Parameter: *
* Return: *
*******************************************************************************/
void I2C_Setup (void) {
unsigned int tout;
/* Enable clock for I2C1, GPIOB and AFIO */
RCC->APB2ENR |= (1 << 3) | (1 << 0); //
RCC->APB1ENR |= (1 << 21);
// /* I2C1 pins remapped, use PB6, PB7 */
// AFIO->MAPR |= 0x00000000; // Remap=1: (SCL/PB8, SDA/PB9)
GPIOB->CRL |= 0xFF000000; // Alternate IO PB8 and PB9
I2C1->CR1 = 0x8000; /* Reset I2C peripheral */
for (tout = 1000000; tout; tout--);
I2C1->CR1 = 0x0000;
/* Configure I2C peripheral */
I2C1->CR1 = 0x0001; // PE - Peripheral Enable
I2C1->CR2 = 0x0024; // Freq 36 MHz
I2C1->CR1 = 0x0000; // PE Disable
I2C1->TRISE = 0x0025; // Time Rise - program when PE=0
I2C1->CCR = 0x00B4; // 0x005A = 400 KHz (36MHz / 90) 0x00B4 = 200 KHz
I2C1->CR1 |= 0x0401;
I2C1->OAR1 = 0x40A0;
}
/*******************************************************************************
* Generate start condition on I2C bus *
* Parameter: *
* Return: *
*******************************************************************************/
void I2C_Start (void) {
if ( I2C1->CR1 & ( 1 << 10 ) ) {
I2C1->CR1 &= ~(1 << 10 );
}
I2C1->CR1 |= 0x0100; //start genneration when bus free
while (!(I2C_sr() & 0x0001));
}
/*******************************************************************************
* Generate stop condition on I2C bus *
* Parameter: *
* Return: *
*******************************************************************************/
void I2C_Stop (void) {
I2C1->CR1 |= 0x0200;
while (I2C_sr() & 0x00020000); /* Wait until BUSY bit reset */
}
/*******************************************************************************
* Write address on I2C interface *
* Parameter: adr: address to be written *
* Return: *
*******************************************************************************/
void I2C_Addr (unsigned char adr) {
I2C1->DR = adr;
while (!(I2C_sr() & 0x0002)); //Addr sent
}
/*******************************************************************************
* Write a byte to I2C interface *
* Parameter: c: data to be written *
* Return: *
*******************************************************************************/
void I2C_Write (unsigned char c) {
I2C1->DR = c;
while (!(I2C_sr() & 0x00000004)); /* Wait until BTF bit set */
}
/*******************************************************************************
* Read a byte from I2C interface *
* Parameter: *
* Return: read data *
*******************************************************************************/
unsigned char I2C_Read (int ack) {
/* Enable/disable Master acknowledge */
if (ack) I2C1->CR1 |= 0x0400;
else I2C1->CR1 &= ~0x0400;
while (!(I2C_sr() & 0x00000040)); /* Wait until RxNE bit set */
return (I2C1->DR);
}
/******************************************************************************/
unsigned char I2C_getbyte(unsigned char address, unsigned char cmd) {
unsigned char uc;
I2C_Start(); // Initial Start bit sequence
I2C_Addr(address); // Address I2C Device. (Base address is Write Address)
I2C_Write(cmd); // Transfer Command to I2C Device (Register to be Read)
I2C_Start(); // Repeated start bit sequence
I2C_Addr(address+1); // Address I2C Device. (Base address + 1 is Read Address)
uc = I2C_Read(0); // Read 1 byte without Acknowledge
I2C_Stop(); // Stop I2C transfer
return( uc );
}
unsigned short int I2C_getword(unsigned char address, unsigned char cmd) {
unsigned short int uw;
//unsigned short int uw2;
I2C_Start(); // Initial Start bit sequence
I2C_Addr(address); // Address I2C Device. (Base address is Write Address)
I2C_Write(cmd); // Transfer Command to I2C Device (Register to be Read)
I2C_Start(); // Repeated start bit sequence
I2C_Addr(address+1); // Address I2C Device. (Base address + 1 is Read Address)
uw = I2C_Read(1) << 8; // Read MSB without Acknowledge
uw |= I2C_Read(0); // Read LSB with Acknowledge
I2C_Stop(); // Stop I2C transfer
return( uw );
}
void I2C_putbyte(unsigned char address, unsigned char cmd, unsigned char data) {
I2C_Start(); // Initial Start bit sequence
I2C_Addr(address); // Address I2C Device. (Base address is Write Address)
I2C_Write(cmd); // Transfer Command to I2C Device (Register to be Read)
I2C_Write(data); // Transfer Data to I2C device
I2C_Stop(); // Stop I2C transfer
}
int I2C_getbytearray(unsigned char address, unsigned char cmd, int number, unsigned char *data) {
int count;
I2C_Start(); // Initial Start bit sequence
I2C_Addr(address); // Address I2C Device. (Base address is Write Address)
I2C_Write(cmd); // Transfer Command to I2C Device (Register to be Read)
I2C_Start(); // Repeated start bit sequence
I2C_Addr(address+1); // Address I2C Device. (Base address + 1 is Read Address)
// Read number - 1 bytes with Acknowledge
for ( count=0; count < number - 2; count++ ) {
data[count] = I2C_Read(1); // Read with Acknowledge
}
data[count] = I2C_Read(0); // Last byte without Acknowledge
I2C_Stop(); // Stop I2C transfer
return( count+1 );
}
Bu kütüphanede I2C_Write fonksiyonu ile I2C den data göndermek istediğimde i2c modülü datayı göndermiyor. Ben fonksiyona data gönderiyorum ama I2C1->DR regsiterine data yazılıyor fakat BTF(Byte Transfer Finished) Biti set edilmediği için işlemci orada takılıp kalıyor. Zaten I2C Data hattındada hiç hareket yok.
Ama I2C Start ve Stop fonksiyonları çalışıyor.Fonksiyonları çağırdığımda da i2c hattında bu bitlerin oluştuğunu görebiliyorum.
Bu neden kaynaklanabilir? Kafayı yedirtecek bana... :-X
Dünden beri uğraşıyorum ne yaptıysam ds1307 den bilgi okuyamadım.
DS1307 nin SQW bacağına led bağladım. Eğer İlk kurulumu düzgün yaparsam bu led 1 sn aralıklarla yanıp sönmesi gerekiyor. DS1307 ye hiç yazma yapamıyorum. Zaten kristal bacaklarındada hiç salınım göremiyorum. Osilatör kapalı.
I2C Donanımını Test ediyorum Ondada sıkıntı yok gibi osiloskop ile hattı izlediğimde Start, Stop, ACK ve Data bitlerini görebiliyorum.
RTC için CCS de kulandığım kütüphaneyi kullandım. Keil de derlenecek şekilde düzenledim.
#include "stm32f10x.h"
#include "systick.h"
#include "RTC.h"
#include "I2C.h"
void RTC_init(){
uint8_t seconds = 0;
I2C_Start();
I2C_Addr(0xD0); // WR to RTC
I2C_Write(0x00); // REG 0
I2C_Start();
I2C_Addr(0xD1); // RD from RTC
seconds = bcd2bin(I2C_Read(0)); // Read current "seconds" in DS1307
I2C_Stop();
seconds &= 0x7F;
delay_us(3);
I2C_Start();
I2C_Addr(0xD0); // WR to RTC
I2C_Write(0x00); // REG 0
I2C_Write(bin2bcd(seconds)); // Start oscillator with current "seconds value
I2C_Start();
I2C_Addr(0xD0); // WR to RTC
I2C_Write(0x07); // Control Register
I2C_Write(0x10); // Enable squarewave output pin
I2C_Stop();
}
void RTC_Set_Date_Time(uint8_t day, uint8_t mth, uint8_t year, uint8_t dow, uint8_t hr, uint8_t min, uint8_t sec)
{
sec &= 0x7F;
hr &= 0x3F;
I2C_Start();
I2C_Addr(0xD0); // I2C write address
I2C_Write(0x00); // Start at REG 0 - Seconds
I2C_Write(bin2bcd(sec)); // REG 0
I2C_Write(bin2bcd(min)); // REG 1
I2C_Write(bin2bcd(hr)); // REG 2
I2C_Write(bin2bcd(dow)); // REG 3
I2C_Write(bin2bcd(day)); // REG 4
I2C_Write(bin2bcd(mth)); // REG 5
I2C_Write(bin2bcd(year)); // REG 6
I2C_Write(0x80); // REG 7 - Disable squarewave output pin
I2C_Stop();
}
unsigned int RTC_Get_Date()
{
unsigned char Day=0, WeekDay=0, Month=0, Year=0;
unsigned int Time=0;
I2C_Start();
I2C_Addr(0xD0);
I2C_Write(0x03); // Start at REG 3 - Day of week
I2C_Start();
I2C_Addr(0xD1);
WeekDay = bcd2bin(I2C_Read(1) & 0x7f); // REG 3
Day = bcd2bin(I2C_Read(1) & 0x3f); // REG 4
Month = bcd2bin(I2C_Read(1) & 0x1f); // REG 5
Year = bcd2bin(I2C_Read(0)); // REG 6
I2C_Stop();
Time=(Year*100000)+(Month*1000)+(Day*10)+WeekDay;
return Time;
}
unsigned int RTC_Get_Time()
{
unsigned char Sec=0,Min=0,Hour=0;
unsigned int Time=0;
I2C_Start();
I2C_Addr(0xD0);
I2C_Write(0x00); // Start at REG 0 - Seconds
I2C_Start();
I2C_Addr(0xD1);
Sec = bcd2bin(I2C_Read(1) & 0x7f);
Min = bcd2bin(I2C_Read(1) & 0x7f);
Hour = bcd2bin(I2C_Read(0) & 0x3f);
I2C_Stop();
Time = (Hour*10000)+(Min*100)+Sec;
return Time;
}
unsigned char bin2bcd(unsigned char binary_value)
{
unsigned char temp;
unsigned char retval;
temp = binary_value;
retval = 0;
while(1)
{
// Get the tens digit by doing multiple subtraction
// of 10 from the binary value.
if(temp >= 10)
{
temp -= 10;
retval += 0x10;
}
else // Get the ones digit by adding the remainder.
{
retval += temp;
break;
}
}
return(retval);
}
// Input range - 00 to 99.
unsigned char bcd2bin(unsigned char bcd_value)
{
unsigned char temp;
temp = bcd_value;
// Shifting upper digit right by 1 is same as multiplying by 8.
temp >>= 1;
// Isolate the bits for the upper digit.
temp &= 0x78;
// Now return: (Tens * 8) + (Tens * 2) + Ones
return(temp + (temp >> 2) + (bcd_value & 0x0f));
}
Bi yardım lütfen.
Edit;
Çok Şükür Çalıştırdım. Sorun şurdaymış.
Ben RTC kütüphanesini hazırlarken Hem adres Yazma hemde data göndermek için I2C_Write Fonksiyonunu kullanıyordum. Osiloskop ile I2C Data hattını incelerken baktımki I2C_Write İle ard arda veri gönderirken I2C_Start bititnden sonra sadece ilk gönderdiğim data yollanıyor. Ondan sonra Tekrar Start biti gelene kadar hatta birşey gönderilmiyor. Çözüm ise I2C aygıtına adres bilgisi gönderilirken I2C kütüphanesinindeki I2C_Addr fonksiyonunu kullanmakmış. Onları değiştirince düzeldi.
Bir önceki mesajımdaki BTF bitinin set edilmemesi sorunuda burdan kaynaklanıyormuş. Oda düzeldi.
Akşam akşam ilginç bir sorunla karşı karşıya kaldım ???
Stm32F103 ün PA.1 bacağından aldığım bir sinyal aynı anda PA.6 danda çıkıyor. Yani bu iki pin kısa devreymiş gibi davranıyor. Gerçekte öyle birşey görmüyorum.
Yaptıklarımı söyliyeyim.
#define Set GPIOA->BSRR = 0x00000002;
#define Clr GPIOA->BRR = 0x00000002;
Main döngüsünde bu iki makroyu kullanarak sürekli kare sağlıyorum. Fakat Her nedense buradan aldığım sinyal PA6 danda çıkıyor. Arada fiziksel bir bağlantı yok. Yazılımıda inceledim buna sebeb verecek birşey göremiyorum. Bu yüzden PA5,PA6 ve PA7 dek spi donanımıda düzgün çalışmıyor.
Acaba işlemcimi bozuldu?
Edit;
Uğraştıkça çözülüyor.
Sorun Keildenmiş.
Şuanki proje dosyasını 2 hafta önce bilgisayarın başka bir bölümüne yedeklemiştim. Proje dosyası ismi vs herşey aynı olduğu için keil oradaki proje dosyasındaki kodlarla şuan uğraştığım proje dosyasındaki kodları harmanlayıp işlemciye gömüyor. Bende yukarıda anlattığım sorunlarla karşılaşıyorum. Akşam akşam deli etti beni >:( >:(
Alıntı yapılan: Mucit23 - 05 Ağustos 2013, 13:29:05
Yahu Çözdüm işi :D Tamam Şimdi Herşey yerine oturdu.
Her kanal için farklı Tim_OC init fonksiyonları varmış. 2.Kanal için TIM_OC2Init, 3. Kanal için TIM_OC3Init vs. Bunların değişmesi gerekiyormuş.
@Mucit23
Bende PWM sinyali aldığım pini kapatmak(isteğime göre 0 veya 1) istiyorum.
İlgili pini AF moddan çıkarıp Normal Out moda alıyorum ama arada PWM sinyali kaçırıyor.
Siz nasıl çözmüştünüz?
Hocam I2C dede benim başıma Geldi. GPIO AF modundan çıkırınca rastgele sinyal çıkıyor. Yani konumu lojik 1 de ise anlık olarak lojik 0'a inip tekrar lojik 1 çıkıyor gibi.
Ben STM32F10x'de P10 Panelin parlaklığını ayarlamak için modüleli pwm sinyali almaya çalışıyordum. Gerçekte Timeri Durdurup Ardından çıkışı lojik 0 a çekmek işe yarıyordu sanırım. Ama ben öyle yapmadım. Harici olarak VE kapısı kullanıp iki adet sinyali üst üste bindirdim.
Bu başlıkta Sayfa 13 ve 14'e bak istersen
belki karşılaşmışsınızdır. DMA ile DAC yi sürmek istiyorum. bu arada osc ekranında pir peryot boyunca istediğim, tamda tanımlı bilgileri alıyorum ama araya yine tam bir periyotluk başka bir sinyal giriyor. yani bir periyot benim sinyalim, bir periyot kare dalga benzeri bir sinyal alıyorum. mantıksal olarak böyle bir şeye ne sebep olabilir. kodları sadeleştirmek istemedim arkadaşlar biraz uzun ama tamamını paylaşmak istiyorum. program mikroc.
(http://i.hizliresim.com/Kg0ar2.jpg)
/ DAC Test for STM32F407VG STM32F4-Discovery Board
// default options of HSE osc 168MHz
// DAC1 outputs on PA4 - you will need an oscilloscope to see the output waveform
// DAC2 outputs on PA5 - not used here
// DAC1 requires access to DMA1 Stream 5, Channel 7
// DAC_DHR8R1bits absolute 0x40007410;
// DAC_DHR8R2bits absolute 0x4000741C;
// DAC_DHR12R1bits absolute 0x40007408; // PA4
// DAC_DHR12R2bits absolute 0x40007414; // PA5
// DAC_DHR12L1bits absolute 0x4000740C;
// DAC_DHR12L2bits absolute 0x40007418;
unsigned int *pointer;
unsigned short int x;
// sine wave look up table
const Sine12bit[181] = {
1927,1992,2056,2121,2185,2249,2312,2375,2437,2499,2559,2619,2678,2736,2793,2848,
2903,2956,3008,3059,3108,3155,3201,3245,3288,3329,3368,3405,3441,3474,3506,3535,
3563,3588,3611,3633,3652,3668,3683,3695,3706,3713,3719,3723,3724,3723,3719,3713,
3706,3695,3683,3668,3652,3633,3611,3588,3563,3535,3506,3474,3441,3405,3368,3329,
3288,3245,3201,3155,3108,3059,3008,2956,2903,2848,2793,2736,2678,2619,2559,2499,
2437,2375,2312,2249,2185,2121,2056,1992,1927,1862,1797,1732,1667,1603,1539,1475,
1411,1349,1286,1225,1164,1105,1046,988,931,875,821,767,716,665,616,568,523,478,
436,395,356,318,283,249,218,188,161,136,112,91,72,55,41,28,18,10,5,1,0,1,5,10,
18,28,41,55,72,91,112,136,161,188,218,249,283,318,356,395,436,478,523,568,616,
665,716,767,821,875,931,988,1046,1105,1164,1225,1286,1349,1411,1475,1539,1603,
1667,1732,1797,1862,1862};
// *****************************************************************************
// Timer 6 Configure Subroutine
// *****************************************************************************
void Timer6_Configure(void) {
CEN_TIM6_CR1_bit = 0; // Disable timer before configuring it
/* Time base configuration */
// Bits 15:8 Reserved, must be kept at reset value
// Bits 6:4 Reserved, must be kept at reset value
// Bit 2 URS: Update request source 1: Only counter overflow/underflow generates an update interrupt or DMA request if enabled.
ARPE_TIM6_CR1_bit = 1; // Bit 7 ARPE: Auto-reload preload enable = 1
OPM_TIM6_CR1_bit = 0; // One-pulse mode -0: Counter is not stopped at update event
URS_TIM6_CR1_bit = 0;
UDIS_TIM6_CR1_bit = 0; // Bit 1 UDIS: Update disable
// TIM6_CR2bits
// Bits 15:7 Reserved, must be kept at reset value
// Bits 6:4 MMS: Master mode selection
MMS2_TIM6_CR2_bit = 0; // Bits 6:4MMS: Master mode selection
MMS1_TIM6_CR2_bit = 1; // Update - The update event is selected as a trigger output (TRGO).
MMS0_TIM6_CR2_bit = 0; // For instance a master timer can then be used as a prescaler for a slave timer
// Bits 3:0 Reserved, must be kept at reset value
//TIM6 DIER bits
// Bit 15:9 Reserved, must be kept at reset value
// Bit 7:1 Reserved, must be kept at reset value
// Bits 3:0 Reserved, must be kept at reset value
TIM6_DIER.UDE = 0; //dma kesmesi istemiyor // Bit 8 UDE: Update DMA request enable
TIM6_DIER.UIE = 0; //dma kesmesi sitemiyor // Bit 0 UIE: Update interrupt enable
// Auto-Reload Register (TIMx_ARR)
// Auto load register 65522 (32 bit register) count down to zero
// TIM6_ARR = 631; // 631 = 2200 Hz @64 steps
TIM6_ARR = 1157; // 1157 = 1200 Hz @64 steps
TIM6_PSC =0; // Set timer prescaler
}
// *****************************************************************************
// DAC Channel 1 Configure Subroutine
// *****************************************************************************
void DAC_Ch1_Config(void) {
EN2_bit = 0;
EN1_bit = 0;
// // Bits 31:30 Reserved must be kept at default value
DMAUDRIE2_bit = 0; // Bits 29 DMAUDRIE2 DAC channel2 DMA underrun interrupt enable
DMAEN2_bit = 1; // Bit 28 DMAEN2 DAC channel2 DMA enable
MAMP23_bit = 0; // Bit 27 MAMP2 3 DAC channel2 mask/amplitude selector
MAMP22_bit = 0; // Bit 26 MAMP2 2 DAC channel2 mask/amplitude selector
MAMP21_bit = 0; // Bit 25 MAMP2 1 DAC channel2 mask/amplitude selector
MAMP20_bit = 0; // Bit 24 MAMP2 0 DAC channel2 mask/amplitude selector
WAVE21_bit = 0; // Bit 23 WAVE2 1 DAC channel2 noise/triangle wave generation enable
WAVE20_bit = 0; // Bit 22 WAVE2 0 DAC channel2 noise/triangle wave generation enable
TSEL22_bit = 0; // Bit 21 TSEL2 2 DAC channel1 trigger selection
TSEL21_bit = 0; // Bit 20 TSEL2 1 DAC channel1 trigger selection
TSEL20_bit = 0; // Bit 19 TSEL2 0 DAC channel1 trigger selection
TEN2_bit = 1; // Bit 18 TEN2: DAC channel 2 trigger enable
BOFF2_bit = 0; // Bit 17 BOFF2: DAC channel 2 output buffer disable
// // Bits 15:14 Reserved must be kept at default value
DMAUDRIE1_bit = 0;// DMAUDRIE1_bit = 0; // Bit 13 DMAUDRIE1 DAC channel 1 DMA Underrun Interrupt enable
DMAEN1_bit = 1;// DMAEN1_bit = 1; // Bit 12 DMAEN1 DAC channel 1 DMA enable - DMA Mode Enabled
MAMP13_bit = 0; // Bit 11 MAMP1 3 - DAC channel 1 mask/amplitude selector
MAMP12_bit = 0; // Bit 10 MAMP1 2 - DAC channel 1 mask/amplitude selector
MAMP11_bit = 0; // Bit 9 MAMP1 1 - DAC channel 1 mask/amplitude selector
MAMP10_bit = 0; // Bit 8 MAMP1 0 - DAC channel 1 mask/amplitude selector
WAVE11_bit = 0; // Bit 7 WAVE1 1 DAC channel 1 noise/triangle wave generation enable
WAVE10_bit = 0; // Bit 6 WAVE1 0 DAC channel 1 noise/triangle wave generation enable
TSEL12_bit = 0;// TSEL12_bit = 0; // Bit 5 TSEL bit 2 - DAC channel 1 trigger selection - TIMR6 Output Event
TSEL11_bit = 0; //TSEL11_bit = 0; // Bit 4 TSEL bit 1 - Note: Only used if bit TEN1 = 1 (DAC channel1 trigger enabled)
TSEL10_bit = 0; // Bit 3 TSEL bit 0
TEN1_bit = 1; // Bit 2 TEN 1: DAC channel 1 trigger enable
BOFF1_bit = 0;//BOFF1_bit = 0; // Bit 1 BOFF 1: DAC channel 1 output buffer disable - 0 = Enabled
}
/* ************************************************************************* */
/* DMA1_Stream 5 channel 7 configuration */
/* ************************************************************************* */
void DMA1_Stream5_Ch7_Config(void) {
// DMA_Cmd(DMA1_Stream5, DISABLE);
EN_DMA1_S5CR_bit = 0; // disable audio stream
while (EN_DMA1_S5CR_bit==1) { // wait for audio stream to be disabled
} // before changing DMA settings
// All Stream5 Status dedicated registers to be cleared
CTCIF5_DMA1_HIFCR_bit = 1; // Channel 5 transfer complete clear
CHTIF5_DMA1_HIFCR_bit = 1; // Channel 5 half transfer clear
CTEIF5_DMA1_HIFCR_bit = 1; // Channel 5 transfer error clear
CDMEIF5_DMA1_HIFCR_bit = 1;
CFEIF5_DMA1_HIFCR_bit = 1;
// DMA1_LIFCR = 0x00000F40; // clear DMA IRQ flags
// DMA_InitStructure.DMA_PeripheralBaseAddr (uint32_t)DAC_DHR12R2_ADDRESS;
// DMA1_S5PAR = &DAC_DHR12R2; //DAC_DHR12R2_ADDRESS = 0x40007414 - PA5
DMA1_S5PAR = &DAC_DHR12R1; //DAC_DHR12R2_ADDRESS = 0x40007408 - PA4
// DMA_InitStructure.DMA_Memory0BaseAddr (uint32_t)&Sine12bit;
// M0AR is the address register used for circular mode
DMA1_S5M0AR = &Sine12bit; // Bit 31: Memory 0 address
// DMA_InitStructure.DMA_BufferSize = 64;
DMA1_S5NDTR = 181;
// DMA_InitStructure.DMA_Channel = DMA_Channel_7;
// #define DMA_Channel_7 ((uint32_t)0x0E000000)
CHSEL2_DMA1_S5CR_bit=1; // Bit 27 Channel selection
CHSEL1_DMA1_S5CR_bit=1; // Bit 26 Channel selection
CHSEL0_DMA1_S5CR_bit=1; // Bit 27 Channel selection
// DMA_MemoryBurst Single ((uint32_t)0x00000000)0
MBURST1_DMA1_S5CR_bit=0; // Bit 24 Memory burst transfer configuration
MBURST0_DMA1_S5CR_bit=0; // Bit 23 Memory burst transfer configuration
// DMA_PeripheralBurst Single ((uint32_t)0x00000000)
PBURST1_DMA1_S5CR_bit=0; // Bit 22 Peripheral burst transfer configuration
PBURST0_DMA1_S5CR_bit=0; // Bit 21 Peripheral burst transfer configuration
// ACK
ACK_DMA1_S5CR_bit = 0; // DMA1_S5CR.B20;
// CT
CT_DMA1_S5CR_bit = 0; // Bit 19 DMA1_S5CR.B19;
// DBM
DBM_DMA1_S5CR_bit = 0; // Bit 18 DMA1_S5CR.B18;
// #define DMA_Priority_High ((uint32_t)0x00020000)
PL1_DMA1_S5CR_bit=1; // Bit 17 Priority level (HIGH)
PL0_DMA1_S5CR_bit=0; // Bit 16 Priority level (HIGH)
// PINCOS
PINCOS_DMA1_S5CR_bit = 0; //
// #define DMA_MemoryDataSize_HalfWord ((uint32_t)0x00002000)
MSIZE1_DMA1_S5CR_bit=0; // Bits 14 = 0 Memory data size
MSIZE0_DMA1_S5CR_bit=1; // Bits 13 = 1 Memory data size
// #define DMA_PeripheralDataSize_HalfWord ((uint32_t)0x00000800)
PSIZE1_DMA1_S5CR_bit=1; // Bit 12 Peripheral data size
PSIZE0_DMA1_S5CR_bit=0; // Bit 11 Peripheral data size
// DMA_MemoryInc Enabled ((uint32_t)0x00000400)
MINC_DMA1_S5CR_bit = 1; // Bit 10 MINC: Memory increment mode
// DMA_PeripheralInc Disabled ((uint32_t)0x00000000)
PINC_DMA1_S5CR_bit = 0; // Bit 9 PINC: Peripheral increment mode
// DMA_Mode_Circular enabled ((uint32_t)0x00000100)
CIRC_DMA1_S5CR_bit = 1;//CIRC_DMA1_S5CR_bit = 1; // Bit 8 CIRC: Circular mode
// DMA_DIR MemoryToPeripheral ((uint32_t)0x00000040)
DIR1_DMA1_S5CR_bit=0; // Bits 7 DIR[1:0]: Data transfer direction
DIR0_DMA1_S5CR_bit=1; // Bits 6 DIR[1:0]: Data transfer direction
PFCTRL_DMA1_S5CR_bit = 0; // Peripheral Control: Bit 5
TCIE_DMA1_S5CR_bit = 0; // Transfer complete interrupt enable
HTIE_DMA1_S5CR_bit = 0; // Half transfer interrupt enbale
TEIE_DMA1_S5CR_bit = 0; // Transfer error interrupt enable
DMEIE_DMA1_S5CR_bit = 0; // direct error interrupt enable
// #define DMA_FIFOMode_Disable ((uint32_t)0x00000000)
DMDIS_DMA1_S5FCR_bit = 0; // Bit 2 DMDIS: Direct mode disable
// #define DMA_FIFOThreshold_HalfFull ((uint32_t)0x00000001)
FTH1_DMA1_S5FCR_bit = 0; // Bit 1 FIFO threshold selection
FTH0_DMA1_S5FCR_bit = 1; // Bit 0 FIFO threshold selection
}
void main() {
// Turn on the DAC and GPIO clocks before configuring the peripherals
RCC_AHB1ENR.DMA1EN = 1; // Enable DMA1 clock
RCC_AHB1ENR.GPIOAEN = 1; // Enable GPIO A clock
RCC_AHB1ENR.GPIOBEN = 1; // Enable GPIO D clock
RCC_APB1ENR.DACEN = 1; // Enable DAC clock
RCC_APB1ENR.TIM6EN = 1; // Enable TIM6 clock
RCC_APB1ENR.PWREN = 1; //
SYSCFGEN_bit = 1; //
// Set GPIO_PORTD pins 12 through 15 as digital output
GPIO_Digital_Output(&GPIOB_ODR,_GPIO_PINMASK_3|_GPIO_PINMASK_4);
GPIO_Digital_Output(&GPIOG_ODR,_GPIO_PINMASK_15);
// GPIO_Digital_Output(&GPIOD_BASE, _GPIO_PINMASK_0 | _GPIO_PINMASK_13);
// GPIO_Digital_Output(&GPIOD_BASE, _GPIO_PINMASK_0 | _GPIO_PINMASK_14);
// GPIO_Digital_Output(&GPIOD_BASE, _GPIO_PINMASK_0 | _GPIO_PINMASK_15);
Timer6_Configure(); // Configure Timer 6
DAC_Ch1_Config(void); // Configure the DAC
DMA1_Stream5_Ch7_Config(void); // Configure the DMA
EN_DMA1_S5CR_bit = 1; // Enable DMA Stream 5
EN1_bit = 1; // Bit 0 EN1: DAC channel 1 enable
EN2_bit = 1; // Bit 16 EN2: DAC channel 2 enable
TIM6_CR1.CEN = 1; // Enable timer
GPIOB_ODR.B4=1; // Toggle Green on Port D13
Delay_ms(100);
// START MAIN PROGRAM LOOP
while(1){ // endless loop {
GPIOB_ODR.B4=!GPIOB_ODR.B4; // Toggle LED2 (Yellow)on Port D13
//if(GPIOB_ODR.B4==0) { // alternate tones
// TIM6_ARR = 1157; // transmit 1200 Hz tone
//}
//else {
// TIM6_ARR = 631; // Transmit 2200 Hz Tone
//}
Delay_ms(500); // Blink LED 12 at 1 Hz rate
}
}
Z hocama teşekkür ediyorum yardımı ile arkadaşlar sorun halloldu.
önceki kodda bulunan
const Sine12bit[181] = {
1927,1992,2056,2121,2185,2249,2312,2375,2437,2499,2559,2619,2678,2736,2793,2848,
2903,2956,3008,3059,3108,3155,3201,3245,3288,3329,3368,3405,3441,3474,3506,3535,
3563,3588,3611,3633,3652,3668,3683,3695,3706,3713,3719,3723,3724,3723,3719,3713,
3706,3695,3683,3668,3652,3633,3611,3588,3563,3535,3506,3474,3441,3405,3368,3329,
3288,3245,3201,3155,3108,3059,3008,2956,2903,2848,2793,2736,2678,2619,2559,2499,
2437,2375,2312,2249,2185,2121,2056,1992,1927,1862,1797,1732,1667,1603,1539,1475,
1411,1349,1286,1225,1164,1105,1046,988,931,875,821,767,716,665,616,568,523,478,
436,395,356,318,283,249,218,188,161,136,112,91,72,55,41,28,18,10,5,1,0,1,5,10,
18,28,41,55,72,91,112,136,161,188,218,249,283,318,356,395,436,478,523,568,616,
665,716,767,821,875,931,988,1046,1105,1164,1225,1286,1349,1411,1475,1539,1603,
1667,1732,1797,1862,1862};
kısmını iki katına çıkardım
const Sine12bit[362] = {
1927,1992,2056,2121,2185,2249,2312,2375,2437,2499,2559,2619,2678,2736,2793,2848,
2903,2956,3008,3059,3108,3155,3201,3245,3288,3329,3368,3405,3441,3474,3506,3535,
3563,3588,3611,3633,3652,3668,3683,3695,3706,3713,3719,3723,3724,3723,3719,3713,
3706,3695,3683,3668,3652,3633,3611,3588,3563,3535,3506,3474,3441,3405,3368,3329,
3288,3245,3201,3155,3108,3059,3008,2956,2903,2848,2793,2736,2678,2619,2559,2499,
2437,2375,2312,2249,2185,2121,2056,1992,1927,1862,1797,1732,1667,1603,1539,1475,
1411,1349,1286,1225,1164,1105,1046,988,931,875,821,767,716,665,616,568,523,478,
436,395,356,318,283,249,218,188,161,136,112,91,72,55,41,28,18,10,5,1,0,1,5,10,
18,28,41,55,72,91,112,136,161,188,218,249,283,318,356,395,436,478,523,568,616,
665,716,767,821,875,931,988,1046,1105,1164,1225,1286,1349,1411,1475,1539,1603,
1667,1732,1797,1862,1862,
1927,1992,2056,2121,2185,2249,2312,2375,2437,2499,2559,2619,2678,2736,2793,2848,
2903,2956,3008,3059,3108,3155,3201,3245,3288,3329,3368,3405,3441,3474,3506,3535,
3563,3588,3611,3633,3652,3668,3683,3695,3706,3713,3719,3723,3724,3723,3719,3713,
3706,3695,3683,3668,3652,3633,3611,3588,3563,3535,3506,3474,3441,3405,3368,3329,
3288,3245,3201,3155,3108,3059,3008,2956,2903,2848,2793,2736,2678,2619,2559,2499,
2437,2375,2312,2249,2185,2121,2056,1992,1927,1862,1797,1732,1667,1603,1539,1475,
1411,1349,1286,1225,1164,1105,1046,988,931,875,821,767,716,665,616,568,523,478,
436,395,356,318,283,249,218,188,161,136,112,91,72,55,41,28,18,10,5,1,0,1,5,10,
18,28,41,55,72,91,112,136,161,188,218,249,283,318,356,395,436,478,523,568,616,
665,716,767,821,875,931,988,1046,1105,1164,1225,1286,1349,1411,1475,1539,1603,
1667,1732,1797,1862,1862};[/code]
şeklinde değiştirdim. programda sadece bu değişiklik yapılarak cihaz çalıştı.
Ama dedigim gibi sorunu cozmedik. Sadece bu ihtimali dusunup hatayi bulma adina deney yaptik.
Simdi DMA neden iki kati uzunlukta veri tasimaya zorlaniyor onu arastirmak lazim.
doğru yaklaşım hocam. inşallah sorunu tam olarak çözersem paylaşacağım.
hocam osilaskoptan bakınca sinyalde olması gereken örnek sayısının yarısını görüyorum. yani 64 örnek noktası varsa sinyal 32 örnek noktasından oluşuyor. bu da bana dma tablodan verileri 1-3-5-7 şeklinde çekiyormuş gibi geldi.
DMA, Tablodan integer (32 bit) deger cekip, hedefe aktarirken short (16 bit) deger yaziliyor olabilirmi? Bu durumda 2 tane 16 bit okunur, ust 16 cope gider alt 16 da hedefe yazilir.
Sanki target ve destination icin veri uzunluklarinin tanimlarinin yapildigi registerlar vardi diye hatirliyorum. Dokumani bir kurcala istersen.
// #define DMA_PeripheralDataSize_HalfWord ((uint32_t)0x00000800)
PSIZE1_DMA1_S5CR_bit=1; // Bit 12 Peripheral data size
PSIZE0_DMA1_S5CR_bit=0; // Bit 11 Peripheral data size
Senin ilk (eski) programin yukaridaki gibi
Bu satirlari bulup asagidaki gibi degistirmeyi denermisin?
// #define DMA_PeripheralDataSize_HalfWord ((uint32_t)0x00000800)
PSIZE1_DMA1_S5CR_bit=0; // Bit 12 Peripheral data size
PSIZE0_DMA1_S5CR_bit=1; // Bit 11 Peripheral data size
Alıntı yapılan: Mucit23 - 08 Mart 2014, 14:18:43
Hocam I2C dede benim başıma Geldi. GPIO AF modundan çıkırınca rastgele sinyal çıkıyor. Yani konumu lojik 1 de ise anlık olarak lojik 0'a inip tekrar lojik 1 çıkıyor gibi.
Gerçekte Timeri Durdurup Ardından çıkışı lojik 0 a çekmek işe yarıyordu sanırım.
Timer'ı durdurmadan yaptığımda sinyal kaçıyor Timer diğer işler için lazım olduğundan bende PWM output pinini enable/disable yaptım. Sonra pini normal moda alıp istediğim kontrolü yapıyorum.
Alıntı Yap
const Sine12bit[181] = {.......
Veri tipi bildirilmemiş. derleyici bunu 32 bit olarak yerletirecek muhtemelen.
16 bit veri transferi yaptığın için dalga şeklinde bozulma olur. Ama beklediğim bozulma osilaskopta gördüğümüz gibi değil.
sayın z ve klein hocam, yardımlarınız için teşekkür ederim. elimde şu an osilaskop yok ama sinüs sinyalin bir periyodunu 5 saniyeye gelecek şekilde ayarladım ve sinyali 0-3V aralığında çıkarttım. z hocamın dediği ayarları yapınca 0-3V aralığında 5 saniyeye yayılan düzenli bir sinyali ölçü aleti ile gözlemleyebildim. ama dediğim gibi şimdilik sadece avometre ile ölçüm yaptım. ama daha önce hatalı programda avometre ile ölçümde resimde gösterdiğim dalgalanmaları gözlemleyebilmiştim şimdi olmadı. bu arada tanımladığım yapıda 180 değişken var ve programda da DMA'ya tanımlı aynı şekilde 180 değişken mevcut. aşağıda çalışan kodu paylaşıyorum. Saygılarımla...
#include "dac_objects.h"
//denemenin yapıldığı cihaz mikromedia plus for stm32
//KULLANILAN PROGRAM mikroc pro for arm
// kristal ayarı 150MHz
// timer 6 kesme 27.7 msn ayarlandı bu sayede 180 örnek noktası ile oluşturulan bir peryodun süresi de 180 x 27.7msn den 5 saniye oldu
// DAC1 outputs on PA4 - you will need an oscilloscope to see the output waveform
// DAC2 outputs on PA5 - not used here
// DAC1 requires access to DMA1 Stream 5, Channel 7
// DAC_DHR8R1bits absolute 0x40007410;
// DAC_DHR8R2bits absolute 0x4000741C;
// DAC_DHR12R1bits absolute 0x40007408; // PA4
// DAC_DHR12R2bits absolute 0x40007414; // PA5
// DAC_DHR12L1bits absolute 0x4000740C;
// DAC_DHR12L2bits absolute 0x40007418;
unsigned int *pointer;
unsigned short int x;
// sine wave look up table
const Sine12bit[180] = {1881,1945,2008,2071,2133,2196,2258,2319,2379,2439,2499,
2557,2615,2671,2727,2781,2834,2886,2937,2986,3034,3080,3125,3169,3210,3250,3288,
3325,3359,3392,3423,3452,3478,3503,3526,3547,3565,3582,3596,3608,3618,3626,3631,
3634,3636,3634,3631,3626,3618,3608,3596,3582,3565,3547,3526,3503,3478,3452,3423,
3392,3359,3325,3288,3250,3210,3169,3125,3080,3034,2986,2937,2886,2834,2781,2727,
2671,2615,2557,2499,2439,2379,2319,2258,2196,2133,2071,2008,1945,1881,1818,1754,
1691,1628,1565,1502,1440,1378,1317,1256,1196,1137,1078,1021,964,909,854,801,749,
699,649,601,555,510,467,425,385,347,311,276,244,213,184,157,132,110,89,70,54,40,
28,18,10,4,1,0,1,4,10,18,28,40,54,70,89,110,132,157,184,213,244,276,311,347,385,
425,467,510,555,601,649,699,749,801,854,909,964,1021,1078,1137,1196,1256,1317,
1378,1440,1502,1565,1628,1691,1754,1818};
// *****************************************************************************
// Timer 6 Configure Subroutine
// *****************************************************************************
void Timer6_Configure(void) {
CEN_TIM6_CR1_bit = 0; // Disable timer before configuring it
/* Time base configuration */
// Bits 15:8 Reserved, must be kept at reset value
// Bits 6:4 Reserved, must be kept at reset value
// Bit 2 URS: Update request source 1: Only counter overflow/underflow generates an update interrupt or DMA request if enabled.
ARPE_TIM6_CR1_bit = 1; // Bit 7 ARPE: Auto-reload preload enable = 1
OPM_TIM6_CR1_bit = 0; // One-pulse mode -0: Counter is not stopped at update event
URS_TIM6_CR1_bit = 0;
UDIS_TIM6_CR1_bit = 0; // Bit 1 UDIS: Update disable
// TIM6_CR2bits
// Bits 15:7 Reserved, must be kept at reset value
// Bits 6:4 MMS: Master mode selection
MMS2_TIM6_CR2_bit = 0; // Bits 6:4MMS: Master mode selection
MMS1_TIM6_CR2_bit = 1; // Update - The update event is selected as a trigger output (TRGO).
MMS0_TIM6_CR2_bit = 0; // For instance a master timer can then be used as a prescaler for a slave timer
// Bits 3:0 Reserved, must be kept at reset value
//TIM6 DIER bits
// Bit 15:9 Reserved, must be kept at reset value
// Bit 7:1 Reserved, must be kept at reset value
// Bits 3:0 Reserved, must be kept at reset value
TIM6_DIER.UDE = 0; // Bit 8 UDE: Update DMA request enable
TIM6_DIER.UIE = 0; // Bit 0 UIE: Update interrupt enable
// Auto-Reload Register (TIMx_ARR)
// Auto load register 65522 (32 bit register) count down to zero
// TIM6_ARR = 631; //
TIM6_ARR = 61274; //
TIM6_PSC = 67; // Set timer prescaler
}
// *****************************************************************************
// DAC Channel 1 Configure Subroutine
// *****************************************************************************
void DAC_Ch1_Config(void) {
EN2_bit = 0;
EN1_bit = 0;
// // Bits 31:30 Reserved must be kept at default value
DMAUDRIE2_bit = 0; // Bits 29 DMAUDRIE2 DAC channel2 DMA underrun interrupt enable
DMAEN2_bit = 1; // Bit 28 DMAEN2 DAC channel2 DMA enable
MAMP23_bit = 0; // Bit 27 MAMP2 3 DAC channel2 mask/amplitude selector
MAMP22_bit = 0; // Bit 26 MAMP2 2 DAC channel2 mask/amplitude selector
MAMP21_bit = 0; // Bit 25 MAMP2 1 DAC channel2 mask/amplitude selector
MAMP20_bit = 0; // Bit 24 MAMP2 0 DAC channel2 mask/amplitude selector
WAVE21_bit = 0; // Bit 23 WAVE2 1 DAC channel2 noise/triangle wave generation enable
WAVE20_bit = 0; // Bit 22 WAVE2 0 DAC channel2 noise/triangle wave generation enable
TSEL22_bit = 0; // Bit 21 TSEL2 2 DAC channel1 trigger selection
TSEL21_bit = 0; // Bit 20 TSEL2 1 DAC channel1 trigger selection
TSEL20_bit = 0; // Bit 19 TSEL2 0 DAC channel1 trigger selection
TEN2_bit = 1; // Bit 18 TEN2: DAC channel 2 trigger enable
BOFF2_bit = 0; // Bit 17 BOFF2: DAC channel 2 output buffer disable
// // Bits 15:14 Reserved must be kept at default value
DMAUDRIE1_bit = 0; // Bit 13 DMAUDRIE1 DAC channel 1 DMA Underrun Interrupt enable
DMAEN1_bit = 1; // Bit 12 DMAEN1 DAC channel 1 DMA enable - DMA Mode Enabled
MAMP13_bit = 0; // Bit 11 MAMP1 3 - DAC channel 1 mask/amplitude selector
MAMP12_bit = 0; // Bit 10 MAMP1 2 - DAC channel 1 mask/amplitude selector
MAMP11_bit = 0; // Bit 9 MAMP1 1 - DAC channel 1 mask/amplitude selector
MAMP10_bit = 0; // Bit 8 MAMP1 0 - DAC channel 1 mask/amplitude selector
WAVE11_bit = 0; // Bit 7 WAVE1 1 DAC channel 1 noise/triangle wave generation enable
WAVE10_bit = 0; // Bit 6 WAVE1 0 DAC channel 1 noise/triangle wave generation enable
TSEL12_bit = 0; // Bit 5 TSEL bit 2 - DAC channel 1 trigger selection - TIMR6 Output Event
TSEL11_bit = 0; // Bit 4 TSEL bit 1 - Note: Only used if bit TEN1 = 1 (DAC channel1 trigger enabled)
TSEL10_bit = 0; // Bit 3 TSEL bit 0
TEN1_bit = 1; // Bit 2 TEN 1: DAC channel 1 trigger enable
BOFF1_bit = 0; // Bit 1 BOFF 1: DAC channel 1 output buffer disable - 0 = Enabled
}
/* ************************************************************************* */
/* DMA1_Stream 5 channel 7 configuration */
/* ************************************************************************* */
void DMA1_Stream5_Ch7_Config(void) {
// DMA_Cmd(DMA1_Stream5, DISABLE);
EN_DMA1_S5CR_bit = 0; // disable audio stream
while (EN_DMA1_S5CR_bit==1) { // wait for audio stream to be disabled
} // before changing DMA settings
// All Stream5 Status dedicated registers to be cleared
CTCIF5_DMA1_HIFCR_bit = 1; // Channel 5 transfer complete clear
CHTIF5_DMA1_HIFCR_bit = 1; // Channel 5 half transfer clear
CTEIF5_DMA1_HIFCR_bit = 1; // Channel 5 transfer error clear
CDMEIF5_DMA1_HIFCR_bit = 1;
CFEIF5_DMA1_HIFCR_bit = 1;
// DMA1_LIFCR = 0x00000F40; // clear DMA IRQ flags
// DMA_InitStructure.DMA_PeripheralBaseAddr (uint32_t)DAC_DHR12R2_ADDRESS;
// DMA1_S5PAR = &DAC_DHR12R2; //DAC_DHR12R2_ADDRESS = 0x40007414 - PA5
DMA1_S5PAR = &DAC_DHR12R1; //DAC_DHR12R2_ADDRESS = 0x40007408 - PA4
// DMA_InitStructure.DMA_Memory0BaseAddr (uint32_t)&Sine12bit;
// M0AR is the address register used for circular mode
DMA1_S5M0AR = &Sine12bit; // Bit 31: Memory 0 address
// DMA_InitStructure.DMA_BufferSize = 64;
DMA1_S5NDTR = 180;
// DMA_InitStructure.DMA_Channel = DMA_Channel_7;
// #define DMA_Channel_7 ((uint32_t)0x0E000000)
CHSEL2_DMA1_S5CR_bit=1; // Bit 27 Channel selection
CHSEL1_DMA1_S5CR_bit=1; // Bit 26 Channel selection
CHSEL0_DMA1_S5CR_bit=1; // Bit 27 Channel selection
// DMA_MemoryBurst Single ((uint32_t)0x00000000)0
MBURST1_DMA1_S5CR_bit=0; // Bit 24 Memory burst transfer configuration
MBURST0_DMA1_S5CR_bit=0; // Bit 23 Memory burst transfer configuration
// DMA_PeripheralBurst Single ((uint32_t)0x00000000)
PBURST1_DMA1_S5CR_bit=0; // Bit 22 Peripheral burst transfer configuration
PBURST0_DMA1_S5CR_bit=0; // Bit 21 Peripheral burst transfer configuration
// ACK
ACK_DMA1_S5CR_bit = 0; // DMA1_S5CR.B20;
// CT
CT_DMA1_S5CR_bit = 0; // Bit 19 DMA1_S5CR.B19;
// DBM
DBM_DMA1_S5CR_bit = 0; // Bit 18 DMA1_S5CR.B18;
// #define DMA_Priority_High ((uint32_t)0x00020000)
PL1_DMA1_S5CR_bit=1; // Bit 17 Priority level (HIGH)
PL0_DMA1_S5CR_bit=0; // Bit 16 Priority level (HIGH)
// PINCOS
PINCOS_DMA1_S5CR_bit = 0; //
// #define DMA_MemoryDataSize_HalfWord ((uint32_t)0x00002000)
MSIZE1_DMA1_S5CR_bit=0; // Bits 14 = 0 Memory data size
MSIZE0_DMA1_S5CR_bit=1; // Bits 13 = 1 Memory data size
// #define DMA_PeripheralDataSize_HalfWord ((uint32_t)0x00000800)
PSIZE1_DMA1_S5CR_bit=0; // Bit 12 Peripheral data size
PSIZE0_DMA1_S5CR_bit=1; // Bit 11 Peripheral data size
// DMA_MemoryInc Enabled ((uint32_t)0x00000400)
MINC_DMA1_S5CR_bit = 1; // Bit 10 MINC: Memory increment mode
// DMA_PeripheralInc Disabled ((uint32_t)0x00000000)
PINC_DMA1_S5CR_bit = 0; // Bit 9 PINC: Peripheral increment mode
// DMA_Mode_Circular enabled ((uint32_t)0x00000100)
CIRC_DMA1_S5CR_bit = 1; // Bit 8 CIRC: Circular mode
// DMA_DIR MemoryToPeripheral ((uint32_t)0x00000040)
DIR1_DMA1_S5CR_bit=0; // Bits 7 DIR[1:0]: Data transfer direction
DIR0_DMA1_S5CR_bit=1; // Bits 6 DIR[1:0]: Data transfer direction
PFCTRL_DMA1_S5CR_bit = 0; // Peripheral Control: Bit 5
TCIE_DMA1_S5CR_bit = 0; // Transfer complete interrupt enable
HTIE_DMA1_S5CR_bit = 0; // Half transfer interrupt enbale
TEIE_DMA1_S5CR_bit = 0; // Transfer error interrupt enable
DMEIE_DMA1_S5CR_bit = 0; // direct error interrupt enable
// #define DMA_FIFOMode_Disable ((uint32_t)0x00000000)
DMDIS_DMA1_S5FCR_bit = 0; // Bit 2 DMDIS: Direct mode disable
// #define DMA_FIFOThreshold_HalfFull ((uint32_t)0x00000001)
FTH1_DMA1_S5FCR_bit = 0; // Bit 1 FIFO threshold selection
FTH0_DMA1_S5FCR_bit = 1; // Bit 0 FIFO threshold selection
}
void main() {
start_TP();
// Turn on the DAC and GPIO clocks before configuring the peripherals
RCC_AHB1ENR.DMA1EN = 1; // Enable DMA1 clock
RCC_AHB1ENR.GPIOAEN = 1; // Enable GPIO A clock
RCC_AHB1ENR.GPIODEN = 1; // Enable GPIO D clock
RCC_APB1ENR.DACEN = 1; // Enable DAC clock
RCC_APB1ENR.TIM6EN = 1; // Enable TIM6 clock
RCC_APB1ENR.PWREN = 1; //
SYSCFGEN_bit = 1; //
Timer6_Configure(); // Configure Timer 6
DAC_Ch1_Config(void); // Configure the DAC
DMA1_Stream5_Ch7_Config(void); // Configure the DMA
EN_DMA1_S5CR_bit = 1; // Enable DMA Stream 5
EN1_bit = 1; // Bit 0 EN1: DAC channel 1 enable
EN2_bit = 1; // Bit 16 EN2: DAC channel 2 enable
TIM6_CR1.CEN = 1; // Enable timer
Delay_ms(1000);
// START MAIN PROGRAM LOOP
while(1)
{ // endless loop / Blink LED 12 at 1 Hz rate
}
}
mesaj birleştirme:: 11 Mart 2014, 21:25:38
bu da lazım olursa diye kullanılan h dosyası
typedef struct Screen TScreen;
typedef struct {
unsigned int X_Min;
unsigned int X_Max;
unsigned int Y_Min;
unsigned int Y_Max;
char Rotate;
} TTPConstants;
struct Screen {
unsigned int Color;
unsigned int Width;
unsigned int Height;
unsigned int ObjectsCount;
};
extern TScreen Screen1;
/////////////////////////
// Events Code Declarations
/////////////////////////
/////////////////////////////////
// Caption variables Declarations
/////////////////////////////////
void DrawScreen(TScreen *aScreen);
void Check_TP();
void Start_TP();
bu konu ile yine bir problemle karşılaştım. şimdi sinyali tam olarak alıyorum. yanlız frekans benim belirlediğimin tam yarısı çıkıyor. örnek hesaplamam şöyle
sinyal frekansı = 1 khz
bir peryottaki örnek sayısı = 20
1000Hz x 20 = 20Khz lik frekansta kesme üretmek üzere dma'yı çalıştıran timer6 yı kuruyorum ancak üretilen frekans değeri 500Hz çıkıyor. yani hesapladığımın tam yarısı. acaba nerede hata yapıyorum? timer hesaplamaları için mikroelektroika nın timer calculator programını kullanıyorum.
düzeltme : apb1 veri yolunun hızını 168Mhz olarak hesapladığımdan olmuş hata. frekans 84MHZ olarak hesaplanınca düzeldi.
Merhaba arkadaşlar,
320x240 lcd ekranda osiloskoplardaki gibi çizgi grafiği göstermek istiyorum. Bunun mantığı tam olarak nasıl işliyor, Fikir yürütemedim bir türlü.
Fikri olan yokmu?
Amacım ekranda hareketli olarak aşağıdaki gibi bir grafik çizdirmek.
(http://s27.postimg.cc/nvnxj7j9v/Ads_z.png)
Arka taraftaki ızgaranın olmasına gerek yok. Çizgi çizerek grafiği oluştursam yeter, nasıl yapacağımı bilmiyorum. Bu iş için hazır bir kütüphanede olur.
Bu işin mantığı nedir? Kayar bir grafik nasıl oluştururum? Fikir verirseniz sevinirim.
Eğer LCD üzerinde iki nokta arasına çizgi çekebiliyorsan, hareketlisi kolay. Ama yok, yolun başındayım , çizgi nasıl çizilir diyorsan, o iş biraz karışık.
mesaj birleştirme:: 29 Mayıs 2014, 23:26:38
Eğer hazır kütüphane bulamazsan, şöyle bir başlangı önerebilirim.
Çizgi çizmekten önce nokta koymakla başlayabilirsin. Eğer istediğin yere nokta koyabiliyorsan izgi de çizebilirsin.
bir tane 320 elemanlı tablo yap. Bu tablonun her elemanı 0-240 arasında değer içersin. Bu deperlerin her biri bir satırı temsil edecek. Eğer bu satırlara noktaları yerleştirebilirsen, ve bunları grafik hızına uygun bir şekilde silip yeniden koyabiliyorsan, çizgi çizmeye hazırsın demektir.
Alıntı yapılan: Mucit23 - 29 Mayıs 2014, 23:08:28
Fikri olan yokmu?
Amacım ekranda hareketli olarak aşağıdaki gibi bir grafik çizdirmek.
(http://s27.postimg.cc/nvnxj7j9v/Ads_z.png)
Arka taraftaki ızgaranın olmasına gerek yok. Çizgi çizerek grafiği oluştursam yeter, nasıl yapacağımı bilmiyorum. Bu iş için hazır bir kütüphanede olur.
Bu işin mantığı nedir? Kayar bir grafik nasıl oluştururum? Fikir verirseniz sevinirim.
Sample ları bir biri ile birleştireceksin o kadar..
320x240 lcd n var. 32 tane sample al.
X ekseninde,
1-10-20-30-40-50-60......
pixellere,
Y ekseninde ise, grafiğin değerine göre noktasal yerleşimlerini yap. Sonra noktalar arasında çizgi çiz. Çözünürlük ne kadar artasa, grafik o kadar güzel, kıvrımlı, düzgün görünür.
Hocam yok çizgi çizmede nokta koymada sıkıntım yok. LCD kütüphanemde bununla ilgili fonksiyonlarım çalışıyorlar.
Grafiği kaydırırken her seferinde yeni bir değer gönderirim büyük ihtimal. Her seferinde grafiği kaydırdığımdada Ekranın tümünü silmek hiç mantıklı gelmiyor bana. Bu durum görüntüde muhtemelen titremeler oluşturacak.
Belki ekrandaki noktalara çizgiler çekerek grafik çizebilirim ama kaydırırıp yeni değerleri basarken dediğim gibi ekranın tümünü silmek gerekecek. Bunu yapmak istemiyorum. Daha efektif bir yöntem oluşturmam gerekiyor. Bu konuda önerisi olan varmı?
ekranın tümünü silmenize gerek yok çizdiğiniz kordinatları bir buffer da toplayın silmek istediğiniz kadarını ters renkde üzerine çizin kaybolacaktır. Daha sonrada yenisini koyu renkde çizdirin. Böylece ekran yenilenmiş olur.
Bol miktarda RAM' e ihtiyacın var. En az 320*240*2 byte kadar. Frame buffer kullanıp, katman katman çizim yapıp sonra bu bufferı ekrana basacaksın.
Alıntı yapılan: ByteMaster - 30 Mayıs 2014, 00:18:23
Bol miktarda RAM' e ihtiyacın var. En az 320*240*2 byte kadar. Frame buffer kullanıp, katman katman çizim yapıp sonra bu bufferı ekrana basacaksın.
Hocam siz farklı bir yöntemden bahsediyorsunuz herhalde, Çizgi çizerek bukadar büyük bir alana ihtiyaç olmuyor. Sizin bahsettiğiniz yöntemin aslı nedir?
@Mucit23 hocam öylesine keyif için deneysel çalışma yapıyorsan tavsiyem linkteki kiti temin etmen:
http://market.cizgi.com.tr/product/education/stm-stm32F429I-discovery (http://market.cizgi.com.tr/product/education/stm-stm32F429I-discovery)
İçerinde 8 MByte SDRAM var. MCU'da donanımsal LCD sürücüsü mevcut. LCD layer buffer'lar SDRAM da tanımlı.
Şimsek hızında grafikler çizdiriliyor. RAM gani.
Şurada da bu kitle hazırlanmış bir scop örneği mevcut.
http://www.coocox.org/forum/topic.php?id=4052 (http://www.coocox.org/forum/topic.php?id=4052)
Kodları detaylı incelemedim ama ekran fonksiyonları yeterince optimize edilmemiş olabilir bu proje için.
Normalde bu kitteki ekrana double buffer kullanırak çok yüksek hızda ve yumuşak bir şekilde frame basmak mümkün. Double buffer kullanılmaz ise ekrana yazma sırasında kullanıcıyı rahatsız eden kırpışmalar oluşabiliyor.
Ekrani tamamen silmene gerek yok.
yatay eksen x=0,1,2,3,4 seklinde ilerlerken diyelim ki x=7 icin y degerini ekrana basacaksin.
Once x=7 icin y=0 dan, x=7 y=ymax dikey cizgisi ciz. Bunun rengi zemin rengi olsun.
Boylece x=7 deki eski pixel silinecektir. Daha sonra x=7 icin asil koyman gereken pixeli cizersin.
Yada tek boyutlu bir aray tanimlarsin. boyu ekranin xmax degerine esit olur.
Sen ekrana pixel koymadan once o x degeri icin saklanmis eski y degerini okur ve ardindan bu pixeli silersin.
ardindan asil koyman gereken pixeli koyarken y degerini arrayde de saklarsin.
Ilk yontem array istemez fakat yavas calisir. Ikinci yontem ram ister ama hizli calisir.
Pikseli silmek tek başına işe yaramaz ki hocam. Bir önceki y noktasından tazeleyeceğimiz y noktasına kadar çizilmiş bir doğru var. bu doğrunun da silinmesi gerekecek. Tabi bir de ekran kayacağı için, önceki noktaların hepsi bir sola kayacak. Bunun için tüm çizgilerin silinmesi gerekecek. Silme yazma esnasında kırpışma olabilir. Ekranı komple tazelemek daha temiz bir çözüm gibi geliyor bana.
Double buffer de gerekmeyebilir. Veri yine tek boyutlu diziye atılır. Circular buffer kullanılıp, her tazelemede dizinin başlangıç adresi bir artırılır.
Bir onceki y ile simdiki y arasinda sadece 1 pixel fark var. Degisen bir sey yok. Bir pixel onunde ne var ne yok sil yeni pixeli yada egriyi koy.
Edit: Evet Klein bahsettigin durum line grafik cizildiyse her x icin 1 y degeri saklayan buffer metodunda sorun olusturur. Line metodunda sorun yok.
Çizgi çizerek nasıl yapacağımı anladım ama buffer kullanarak nasıl yapıldığını anlayamadım. Ben boş ekranda biraz çalışma yapayım. 320 genişlik için en az 160 noktalı bir grafik oluşturmaya çalışacağım.
@Elektroemre, Hocam o kitten bendede var. Ama onu kullanmak istemiyorum. Yapabilirsem STM32F10x de yapmam lazım.
Şu EMWIN içimi kemiriyor yeminle. Kendi içerisinde bu işler için Graph Widget var.
Hocam hiç uğraşma Emwin kullan. :)
TFT kullanma methodolojiniz hatalı demek istiyorum. Bahsettiğim yöntemi kullanmazsanız Flicker dediğimiz etkinin önüne geçemezsiniz. @Elektroemre' nin verdiği linkteki kitte kullanılan MCU' ya EMC (External Memory Controller) koyulmuş olmasının en önemli sebeplerinden biri de bu zaten.
Frame buffer niye kullanılır ?
Double buffer, Tripple Buffer nedir ? Ne işe yarar ?
Görüntü yırtılması nedir ?
Flicker nedir nasıl engellenir ?
Eski CRT sistemlerde Vertical Retrace nedir ? Günümüz sistemlerinde bunun karşılığı nedir ?
Bresenham, Wu v.b. çizim algoritmaları nasıl işler ? Aralarındaki farklar nedir ?
Supersampling, Antialiasing, Oversampling, Halftoning Nedir ?
Partikül sistemleri nasıl çalışır ?
ve bunlar gibi grafik işleme algoritmalarını ve yöntemlerini bir araştırın bence.
Yada hiç uğraşmayın gidip @yamak' ın bahsettiği gibi bir hazır bir grafik işleme kütüphanesi kullanın.
Dediğiniz gibi çizgi çizerek olacak gibi bir iş değil. Çok yavaş çalışır. Uğraşmama değmez. Daha önce proton ve pic ile böyle bir uygulama yapmıştım ama yavaş çalışıyordu tabiki.
ADC_Grafik (http://www.youtube.com/watch?v=LiwIwc6KRik#)
Belki Farklı bir fikir gelir diye düşünmüştüm. @ByteMaster'ın dediklerine bakayım.
Aslında amacım şuydu, ADC den okuduğum değerin odak noktasını arttırıp ekranda grafik olarak çizebilmekti. EMG kas kasılma sensörü var. Ondan çıkan ADC değerini incelemeye çalışıyorum. Kas kasılmalarında çıkışta voltaj değişimi oluyor. Fakat oluşan değişiklikler çok küçük. Ancak osiloskop ile görünüyor.
Simdilik okuduğum değeri seri porttan bilgisayara aktarıp, bilgisayar üzerinde grafik çizdireceğim.
Emwin'i f429'da kullanmayı öğrenebilsem mükemmel olacak. Bu yaz EmWin üzerinde ciddi ciddi uğraşacağım. Sıfırdan nasıl kurulur, nasıl kullanılır vs çözmem gerekiyor. Tam ramazanlık...
Hocam aşağıda basit bi uygulama üzerinde açıklamıştım zamanında belki işinize yarayabilir.
http://www.yusufyamak.com/stm32f429i-disco-emwin-uygulamasi/ (http://www.yusufyamak.com/stm32f429i-disco-emwin-uygulamasi/)
Alıntı yapılan: Mucit23 - 30 Mayıs 2014, 11:35:21
Dediğiniz gibi çizgi çizerek olacak gibi bir iş değil. Çok yavaş çalışır. Uğraşmama değmez. Daha önce proton ve pic ile böyle bir uygulama yapmıştım ama yavaş çalışıyordu tabiki.
ADC_Grafik (http://www.youtube.com/watch?v=LiwIwc6KRik#)
Belki Farklı bir fikir gelir diye düşünmüştüm. @ByteMaster'ın dediklerine bakayım.
Aslında amacım şuydu, ADC den okuduğum değerin odak noktasını arttırıp ekranda grafik olarak çizebilmekti. EMG kas kasılma sensörü var. Ondan çıkan ADC değerini incelemeye çalışıyorum. Kas kasılmalarında çıkışta voltaj değişimi oluyor. Fakat oluşan değişiklikler çok küçük. Ancak osiloskop ile görünüyor.
Simdilik okuduğum değeri seri porttan bilgisayara aktarıp, bilgisayar üzerinde grafik çizdireceğim.
Emwin'i f429'da kullanmayı öğrenebilsem mükemmel olacak. Bu yaz EmWin üzerinde ciddi ciddi uğraşacağım. Sıfırdan nasıl kurulur, nasıl kullanılır vs çözmem gerekiyor. Tam ramazanlık...
Bu yöntemi EKG cihazlarında kullanıyorduk. Ama farkımız grafik rutinleri de dahil herşeyi ASM ile yazmamız.
Alıntı yapılan: z - 30 Mayıs 2014, 12:08:10
Bu yöntemi EKG cihazlarında kullanıyorduk. Ama farkımız grafik rutinleri de dahil herşeyi ASM ile yazmamız.
Yapmayın hocam ya, Ben C ile mutluyum :D
Şöyle kullanacağın MCU STM32F1 ailesinden ise bu iş için yeterli olmayabilir. Ancak FSMC+DMA ile yapacaksan sana bir performans artısı getirebilir bu MCU ile. Yoksa en az STM32F2 veya STM32F4 MCU kullan derim. Diğer yandan bu mcularda SDRAM kullanımı biraz kısıtlı. Kullanılacak kılıfa göre değişiklik gösteriyor. SRAM satın alabilirim dersen yeterli kapasitede bir SRAM kullanabilirsin. SRAM' ler pahalıdır SDRAM' e göre.
Sorun olan nokta şurası frame buffer kullanacaksan bu büyüklükteki veriyi ekrana ne hızda taşıyabiliyorsun/basabiliyorsun ? Buna göre MCU seçmelisin. Aksi halde frame buffer kullansan bile ekranda flicker görme ihtimalin var.
Aslında senin yapacağın uygulamada daha etkili bir yöntemde kullanılabilir bunun için partikül sistemi oluşturup bu partikül sistemini yaptığın örneklemeye göre güncellemelisin. Böylece veri yükün azalacaktır. 320x240 bir LCD kullanıyor olsan yatay eksende sana 320 adet partikül yetiyor demektir. Her partikül için sürekli okuma ve yazma yapacak bir task ile bu işi yapabilirsin. Okuma pikselin altındaki eski bilgiyi okuyacak ve saklayacak yazma yeni bilgiyi yazacak. Bu partiküle yapılacak bir sonraki güncellemede eski bilgi yerine yazılacak ve yeni konumdaki bilgi saklanacak.
Bu iş böyle sürekli devam edecek.
Alıntı yapılan: Mucit23 - 30 Mayıs 2014, 12:22:35
Yapmayın hocam ya, Ben C ile mutluyum :D
Grafik rutinleri hız isteyen rutinlerdir. C kullanıyor olmak çözüm değil. Kodlamayı mükemmel yapmak zorundasın.
Gerekiyorsa C içerisinde inline ASM kullanabilirsin.
Şuanda STM32F103 ile yapmaktan ciddi manada vazgeçtim. Hız çok düşük, Ram yok, Kullandığım kitte LCD bağlantıları FSMC olmadan yapılmış. vs vs.. Ben Verimi Usart ile bilgisayara aktarıp orda grafiğe aktaracağım.
Grafik çizmek için Harcayacağım zamanı EmWin'e harcamayı tercih ederim.
Üstelik ARM'nin ASM komut seti hakkındada bilgim yok, Birazcık pic assembly biliyorum okadar(Aslında Z hocaya buradan iş çıkar)
ASM kullan demiyorum ama C'yi efektif kullanmak lazım. Forumda sorulan yada cevap verilen farklı konulardaki kodları açıkcası hiç beğenmiyorum.
Tamam hız istemeyen uygulamalar için uzun uzun kodla ama grafik gibi hız isteyen uygulamalarda C kodlama çok iyi yapılmalı.
Hız optimizasyonu maksimuma ayarlamakla olmaz bu işler. Bizzat kodlamayı yapanın optimize kod yazması lazım.
Aynı durum ASM yazımda da geçerli. Grafik rutinlerini ASM ile yazdık diye yan gelip yatamayız. ASM yazımın da çok optimize olması gerekiyor. Bunun için de kullanılan grafik algoritmalarını iyi anlamak şart.
Eğer LCD ile işlemci arasındaki veri iletişim hızı düşükse zaten yapacak bir şey yok. Eğer hızı düşükse o LCD durağan görüntü uygulamaları için tasarlanmış demektir.
Dediğim ADC datalarını gibi Seri porttan bilgisayara aktarıp meseleyi çözdüm. Ama içimde ukte kaldı. Boş bir vakitte efektif bir şekilde grafik oluşturmaya çalışacağım.
Başka bir konuya geçmek istiyorum
STM32F103'üme Optik Rotary Encoder bağlayıp timer ile konum ölçmeye çalışacağım. Bu sayede Timer'in Encoder modunuda öğrenmiş olurum.
Enkoder' 5V ile çalışıyor dolayısıyla A ve B çıkışlarıda 5V.
MCU'nun girişleri input_floating modunda, direk 5V giriş sinyali uygulayamam girişlerim bozulur. Gelirim bölücü veya 74LS244 gibi bir tampon kullanmak gerekir.
Siz olsaydınız hangisini kullanırdınız. Reelde ne gibi bir farklar yaratır?
Eğer hızın düşükse ve mcu girişi schmitt trigger ise reelde hiç fark yok.
Ama hız artınca işler değişir. Eğer gerilim bölücü yaparsan, direnç ve pinin iç kapasitesi alçak geiren filtre gibi davranacaktır. Direnç değerine göre kesim frekansı aşağılara doğru düşecektir.
Eğer kodlayıcı çıkış frekansın MHz seviyelerinde değilse, bir sıkıntı yaşayacağını düşünmüyorum. 2-3KOhm değerinde bir bölücü ile 250KHz civarında sorun yaşamadım.
Klein Hocam merhaba,
Hocam encoderim Mhz seviyesinde sinyal çıkartacak kadar yüksek çözünürlüklü değil ama ben işimi sağlama bağlayayım deyip 74LS244 kullandım. 5V -> 3V3 Dönüşümü problemsiz çalışıyor.
Şimdi Encoder okuması için ufak bir kütüphane yazdım.
STM32F103'de Timer3'ün CH1 ve CH2 kanallarını Encoder interface için yönlendirme yaptım. Encoderden gelen palsler ile Timer Değeri Artıp azalıyor. Yani timerin çalışmasında sıkıntı yok. Ama şunu merak ediyorum. Açıkçası Referance manual'dede bu konuda yeterli bilgi edinemedim.
Timerin Encoder interface modu ile yapılabilecekler sadece bu kadarmı? Örneğin Donanımsal olarak yön tespiti yapılamıyormu? Yada BLDC motor sürmek istersek Quadrature encoderi, PWM modülü ile ilişkilendirebiliyormuyuz? Referance manual'de hall sensörlerle ilgili bilgi var ama quadrature encoderler ile ilgili bilgi bulamadım.
Fikriniz varmı?
"RM008 Reference manual" dokümanının 337. Sayfasında incrimental encoder için dönüş yönüne göre counter'in hangi yöne sayacağı gösterilmiş. Hız bilgisi ile birlikte yön bilgisine mi ihtiyacın var?
Hocam 337. sayfada TIMx_CCMR2 Registeri var. Ama siz galiba 316. Registerdeki aşağıdaki tablodan bahsediyorsunuz.
(http://s24.postimg.cc/lvsv5e6lx/Ekran_Al_nt_s.jpg)
Bu tabloda anlatılanlar gerçekleşiyor. Yani şuanda timerin değeri artıp veya azalıyor.
Encoderin Ne tarafa döndüğünü donanımsal olarak nasıl tespit ederim diyordum. Denemedim ama galiba TIMx_CR1 registerinin 4. biti DIR(Direction) ile tespit ediliyor. Hatta açıklamada not düşmüşler, Bu bit Center-Aligned veya Encoder modundayken sadece okunur demişler.
Benim asıl merak ettiğim aslında şuydu, Diyelim BLDC motor süreceğiz. Motor miline incremental encoder bağlayabiliyoruz. Bu durumda STM32'nin encoder ile birlikte donanımsal olarak faz sinyallerini oluşturması mümkünmü?
Hall sensörlerle ilgili şöyle bir resim var datasheette.
http://s1.postimg.cc/uul3evqxr/Ekran_Al_nt_s.jpg (http://s1.postimg.cc/uul3evqxr/Ekran_Al_nt_s.jpg)
Burada yapı gayet net bir şekilde açıklanmış.
Hocam STM32'lerde galiba rotary encoderler kullanarak galiba BLDC motor duğrudan süremiyoruz galiba. Yada bir yolu var ben bilmiyorum.
Bu konuda frescalenin AN notlarına baktım.
http://www.freescale.com/files/dsp/doc/app_note/AN1915.pdf (http://www.freescale.com/files/dsp/doc/app_note/AN1915.pdf)
Burada vektörel kontrol konusunda çok fazla bilgi var. Anlatılmış aslında. Normalde olması gereken enkoderden gelen puls'lar sayılıp istenilen değere ulaştığında bir sonraki faz devreye alınıyor.
(http://s27.postimg.cc/yf86qhztf/Ekran_Al_nt_s.jpg)
Ben şu dakika stm32'de bunu yapmaya kalksam kesmelerle felan yaparım. Acaba Frescalenin DSP'leri nasıl yapıyor bu işi?
Çözdüm gibi konuyu. En az iki adet Timer kullanmak gerekiyor. Timer'lerden bir tanesi encoder ile uğraşırken diğer Timer motor control işleriyle uğraşıyor. Timerler arasındaki iletişim Trigger ile gerçekleşiyor. Encoder ile uğraşan timerin değeri istenen değere ulaştığında triggerden diğer timere sinyal gönderiyor ve diğer timer bir sonraki komutayı veriyor. Kabaca böyle olması lazım.
Açıkçası bu konuyu çok merak ediyorum. Biraz araştırmam lazım çünkü çok kapsamlı bir konu.
Mucit hocam
http://www22.brinkster.com/anotherbrick/index12.htm (http://www22.brinkster.com/anotherbrick/index12.htm)
ben de sizin gibi STM32F103 ile servo sürücü yapmaya çalıştım (resmi yukardaki linkte )
1 sene uğraştım herşey güzeldi motoru 2500 devire kadar çıkardım
ama motorun IPM sinin ( inteligent power module) PWM kenarlarında enkoderde hatalı okumalar oluyordu
bu da motor dönerken tık tık ses gelip hatalı pozisyonlamasına neden oluyordu ( 3 - 5 puls kadar )
ne yaptıysam bu sorunu çözemedim
projeyi bıraktım
neden bu mesajı yazıyorum
siz enkoderi 2 timerla okutucam demişsiniz
ben tek timer da çözmüştüm - yani tek timerla oluyor
nasıl oluyor
timerin ilk 2 channel'iyle enkoderi okutuyorsunuz
kalan 2 channel ( channel 3 ve 4 ) compare şeklinde set ediyorsunuz
hem enkoder pozisyonunu okuyor hem de faz geçişlerinde CC3 ve CC4 interrupt oluşturup
burada IPM ye giden PWM lerin faz sırasını değiştiriyorsunuz
bunun için bir faz geçişleri tablosu oluşturuyorsunuz - yani enkoder 10000 e kadar sayıyor ya
24 tane de olabilecek faz geçişi var çünkü statorda 24 sargı var
işte 24 tane enkoder pozisyon sayısıyla interrupt içinde karşılaştırıp
faz sırasını değiştiriyorsunuz
yani demek istediğim tek timer la oluyor
kolay gelsin
bir de nacizane bir şey söyliyim
ben çiftyüzlü baskı devreyle yaptım - GND_plane yoktu
ama yukarda bahsettiğim problemle karşılaştım
yani böyle sorunlar çıkabiliyor - çok katlı PCB yapmanız gerekebilir
Hocam Tek Timer ile nasıl yaptınız anlayamadım. Normalde IPM Modülüne MCU'dan 6 Adet sinyal gider
PWM1H
PWM1L
PWM2H
PWM2L
PWM3H
PWM3L
Şuanda Tek bir Timerin ilk iki kanalı ile zaten enkoder okuması yapıyorum. Bunda sıkıntı yok. Geriye kalan 2 kanal (CH3-CH4)ile nasıl PWM sinyallerini üretiyorsunuz? ???
Olmaz
yani donanımsal olarak olmaz. Kesmeyle felan yapılır. Sizde mutlaka böyle birşey yapmışsınız.
Benim amacım oluyorsa eğer tüm işlemi donanımsal olarak yapmak. Ben sadece oturup çayımı içerken duty oranıyla oynayarak motorun devrini ayarlayacam. Tek hedefim budur.
Bu konuda da henüz anlayamadığım nokta şudur. Diyelim enkoderimiz tur başına 1024 pals üretiyor ve motorumuzda 8 ayrı adımda 360 derecelik turunu tamamlıyor. Dolayısıyla 1024/8'den her 128 pals'de bir sonraki faz'a geçilmesi gerekir. Bu işlem nasıl yapılacak onu anlamış değilim. Birisi arka planda işlerin nasıl yürüdüğünü anlatsa çok iyi olurdu valla ::)
Ben aslında bir dikiş makinası kartında STM32f103 ve Quadrature encoder kullanılarak Fırçasız dikiş makinası motoru süren bir kart görmüştüm. Keşke kodunu inceleme fırsatım olsaydı.
Elimde güçlü bir fırçasız motor var. Yani katalog bilgilerine göre 48'voltda 100A gibi bir akım çekebiliyor. Motorun orjinalinde encoder yok. Ben kendim bağlayacağım. Encoder olmadanda Motoru ESC ile çalıştırmıştım. Amacım bu motor için sürücü yapmak. Hazır sürücüler çok pahalı...
Sizin encoder probleminiz kafamı karıştırdı. STM32'nin donanımsal olarak böyle bir sorun yaratacağını sanmıyorum. Muhtemelen sizin encoderinizde problem vardı. Eğer çok yüksek pals'lı ise yüksek devirlerde artık encoder düzgün çalışmayabilir, puls kaçırabilir. Veya Encoder sinyallerini taşıyan hatlarda problem olabilir. Osiloskop ile bakmak lazım.
Mucit hocam
PWM' i TIM8 ile ürettim
enkoderi TIM4 ile okudum ve TIM4' ün kalan iki channel ile
stator faz geçişlerinin enkoder değerlerinde CC3 ve CC4 interrupt oluşturdum
ordan TIM8'in COM interruptunu çağırdım
TIM_GenerateEvent(TIM8, TIM_EventSource_COM);
ve COM interrupt içinde fazları açıp kapadım
Şu STM32f103 ile 2x16 LCD çalıştırmak istiyorum.
LCD'yi 5V ile besledim.
Bağlantılarımı yazılımını felan hallettim fakat çalıştıramadım bir türlü. Hızdanmı kaynaklanıyor yoksa Data seviyesinin 3.3V olmasındanmı emin değilim.
Kullandığım LCD kütüphanesi budur.
/*----------------------------------------------------------------------------
* Name: LCD_4bit.c
* Purpose: Functions for 2 line 16 character Text LCD (4-bit interface)
* connected on MCBSTM32 evaluation board
* Version: V1.10
*----------------------------------------------------------------------------
* This file is part of the uVision/ARM development tools.
* This software may only be used under the terms of a valid, current,
* end user licence from KEIL for a compatible version of KEIL software
* development tools. Nothing else gives you the right to use this software.
*
* Copyright (c) 2005-2007 Keil Software. All rights reserved.
*---------------------------------------------------------------------------*/
#include "STM32F10x.h"
#include "LCD_4bit.h" /* STM32F10x Library Definitions */
/*********************** Hardware specific configuration **********************/
/*------------------------- Speed dependant settings -------------------------*/
/* If processor works on high frequency delay has to be increased, it can be
increased by factor 2^N by this constant */
#define DELAY_2N 0
/*------------------------- Text LCD size definitions ------------------------*/
#define LineLen 16 /* Width (in characters) */
#define NumLines 2 /* Hight (in lines) */
/*-------------------- LCD interface hardware definitions --------------------*/
#define LCD_RS GPIO_Pin_10
#define LCD_RW GPIO_Pin_5
#define LCD_En GPIO_Pin_11
#define LCD_D4 GPIO_Pin_12
#define LCD_D5 GPIO_Pin_13
#define LCD_D6 GPIO_Pin_14
#define LCD_D7 GPIO_Pin_15
/******************************************************************************/
/* 8 user defined characters to be loaded into CGRAM (used for bargraph) */
const char UserFont[8][8] = {
{ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
{ 0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10 },
{ 0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18 },
{ 0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C },
{ 0x1E,0x1E,0x1E,0x1E,0x1E,0x1E,0x1E,0x1E },
{ 0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F },
{ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 },
{ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }
};
/************************ Global function definitions *************************/
/*******************************************************************************
* Delay in while loop cycles *
* Parameter: cnt: number of while cycles to delay *
* Return: *
*******************************************************************************/
static void delay (int cnt)
{
cnt <<= DELAY_2N;
while (cnt--);
}
/*******************************************************************************
* LCD Data Out *
* Parameter: c: command to be written *
* Return: *
*******************************************************************************/
void lcd_data_out(unsigned char c)
{
if((c & 0x01)==1){GPIO_SetBits(GPIOB,LCD_D4);}else{GPIO_ResetBits(GPIOB,LCD_D4);}
if((c & 0x02)>>1==1){GPIO_SetBits(GPIOB,LCD_D5);}else{GPIO_ResetBits(GPIOB,LCD_D5);}
if((c & 0x04)>>2==1){GPIO_SetBits(GPIOB,LCD_D6);}else{GPIO_ResetBits(GPIOB,LCD_D6);}
if((c & 0x08)>>3==1){GPIO_SetBits(GPIOB,LCD_D7);}else{GPIO_ResetBits(GPIOB,LCD_D7);}
}
/*******************************************************************************
* LCD Data in *
* Parameter: *
* Return: lcd_data *
*******************************************************************************/
unsigned char lcd_data_in(void)
{
unsigned char temp=0;
temp |= ((unsigned char)3<<GPIO_ReadInputDataBit(GPIOB,LCD_D7));
temp |= ((unsigned char)2<<GPIO_ReadInputDataBit(GPIOB,LCD_D6));
temp |= ((unsigned char)1<<GPIO_ReadInputDataBit(GPIOB,LCD_D5));
temp |= (unsigned char)GPIO_ReadInputDataBit(GPIOB,LCD_D4);
return temp;
}
void lcd_dir_in(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
}
void lcd_dir_out(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
}
/*******************************************************************************
* Read status of LCD controller *
* Parameter: none *
* Return: Status byte contains busy flag and address pointer *
*******************************************************************************/
static unsigned char lcd_read_status (void)
{
unsigned char status;
GPIO_ResetBits(GPIOB,LCD_RS);
GPIO_SetBits(GPIOB,LCD_RW);
delay(10);
GPIO_SetBits(GPIOB,LCD_En);
delay(10);
status = (unsigned char)lcd_data_in() << 4;
GPIO_ResetBits(GPIOB,LCD_En);
delay(10);
GPIO_SetBits(GPIOB,LCD_En);
delay(10);
status |= lcd_data_in();
GPIO_ResetBits(GPIOB,LCD_En);
lcd_dir_out();
return (status);
}
/*******************************************************************************
* Wait until LCD controller busy flag is 0 *
* Parameter: *
* Return: Status byte of LCD controller (busy + address) *
*******************************************************************************/
static unsigned char wait_while_busy (void)
{
unsigned char status;
do{
status = lcd_read_status();
}
while (status & 0x80); /* Wait for busy flag */
return (status);
}
/*******************************************************************************
* Write 4-bits to LCD controller *
* Parameter: c: command to be written *
* Return: *
*******************************************************************************/
void lcd_write_4bit (unsigned char c)
{
GPIO_ResetBits(GPIOB,LCD_RW);
GPIO_SetBits(GPIOB,LCD_En);
lcd_data_out(c);
delay(10);
GPIO_ResetBits(GPIOB,LCD_En);
delay(10);
}
/*******************************************************************************
* Write command to LCD controller *
* Parameter: c: command to be written *
* Return: *
*******************************************************************************/
void lcd_write_cmd (unsigned char c)
{
wait_while_busy();
GPIO_ResetBits(GPIOB,LCD_RS);
lcd_write_4bit (c>>4);
lcd_write_4bit (c);
}
/*******************************************************************************
* Write data to LCD controller *
* Parameter: c: data to be written *
* Return: *
*******************************************************************************/
static void lcd_write_data (unsigned char c)
{
wait_while_busy();
GPIO_SetBits(GPIOB,LCD_RS);
lcd_write_4bit (c>>4);
lcd_write_4bit (c);
}
/*******************************************************************************
* Print Character to current cursor position *
* Parameter: c: character to be printed *
* Return: *
*******************************************************************************/
void lcd_putchar (char c)
{
lcd_write_data (c);
}
/*******************************************************************************
* Initialize the LCD controller *
* Parameter: *
* Return: *
*******************************************************************************/
void lcd_init (void)
{
int i;
char const *p;
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB , ENABLE);
GPIO_InitStructure.GPIO_Pin = LCD_RS | LCD_RW | LCD_En |LCD_D4 | LCD_D5 | LCD_D6 | LCD_D7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* Set all pins for LCD as outputs */
lcd_dir_out();
delay (15000);
GPIO_ResetBits(GPIOB,LCD_RS);
lcd_write_4bit (0x03); /* Select 4-bit interface */
delay (4100);
lcd_write_4bit (0x03);
delay (100);
lcd_write_4bit (0x03);
lcd_write_4bit (0x02);
lcd_write_cmd (0x28); /* 2 lines, 5x8 character matrix */
lcd_write_cmd (0x0C); /* Display ctrl:Disp=ON,Curs/Blnk=OFF */
lcd_write_cmd (0x06); /* Entry mode: Move right, no shift */
/* Load user-specific characters into CGRAM */
lcd_write_cmd(0x40); /* Set CGRAM address counter to 0 */
p = &UserFont[0][0];
for (i = 0; i < sizeof(UserFont); i++, p++)
lcd_putchar (*p);
lcd_write_cmd(0x80); /* Set DDRAM address counter to 0 */
}
/*******************************************************************************
* Set cursor position on LCD display *
* Parameter: column: column position *
* line: line position *
* Return: *
*******************************************************************************/
void set_cursor (int column, int line)
{
unsigned char address;
address = (line * 40) + column;
address = 0x80 + (address & 0x7F);
lcd_write_cmd(address); /* Set DDRAM address counter to 0 */
}
/*******************************************************************************
* Clear the LCD display *
* Parameter: *
* Return: *
*******************************************************************************/
void lcd_clear (void)
{
lcd_write_cmd(0x01); /* Display clear */
set_cursor (0, 0);
}
/*******************************************************************************
* Print sting to LCD display *
* Parameter: string: pointer to output string *
* Return: *
*******************************************************************************/
void lcd_print (char *string)
{
while (*string) {
lcd_putchar (*string++);
}
}
/*******************************************************************************
* Print a bargraph to LCD display *
* Parameter: val: value 0..100 % *
* size: size of bargraph 1..16 *
* Return: *
*******************************************************************************/
void lcd_bargraph (int value, int size) {
int i;
value = value * size / 20; /* Display matrix 5 x 8 pixels */
for (i = 0; i < size; i++) {
if (value > 5) {
lcd_putchar (0x05);
value -= 5;
}
else {
lcd_putchar (value);
break;
}
}
}
/*******************************************************************************
* Display bargraph on LCD display *
* Parameter: pos_x: horizontal position of bargraph start *
* pos_y: vertical position of bargraph *
* value: size of bargraph active field (in pixels) *
* Return: *
*******************************************************************************/
void lcd_bargraphXY (int pos_x, int pos_y, int value) {
int i;
set_cursor (pos_x, pos_y);
for (i = 0; i < 16; i++) {
if (value > 5) {
lcd_putchar (0x05);
value -= 5;
} else {
lcd_putchar (value);
while (i++ < 16) lcd_putchar (0);
}
}
}
/******************************************************************************/
Kütüphaneyi keilin kendi örnekleri içerisinden aldım sonradan giriş çıkışlar üzerinde biraz oynadım. Data gönderme ve alma rutinlerini STD library fonksiyonları ile yaptım. Epeyce bi inceledim problem göremedim ama emin değilim. Neden olabilir? Kütüphaneyi inceleyebilirmisiniz?
STM32F10X in CAN Controller modülü hakkında sormak istediğim birkaç soru var.
Elimde CanBus ile ilgili deney kartlarıyla gelen ve internetten topladığım birkaç örnek program var. Bu örnek programlara bakarak kendime göre temiz bir Can kütüphanesi oluşturmaya çalışıyorum.
Can RX interruptunu kullanmak istiyorum. Bir yerden mesaj geldiği zaman kesme oluşsun. stm32f10x_it.c içerisinde gelen mesajlarla ilgili iki adet kesme vektörü gördüm biraz kafam karıştı.
/*******************************************************************************
* Function Name : USB_LP_CAN_RX0_IRQHandler
* Description : This function handles USB Low Priority or CAN RX0 interrupts
* requests.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void USB_LP_CAN_RX0_IRQHandler(void)
{
}
/*******************************************************************************
* Function Name : CAN_RX1_IRQHandler
* Description : This function handles CAN RX1 interrupt request.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void CAN_RX1_IRQHandler(void)
{
}
Bu ikisi arasındaki fark nedir? Birde Neden USB ile Can interruptları tek bir kesme vektörüne aktarılmış?
Ben Can interruptunu kurarken aşağıdaki gibi bir kurulum yapıyorum.
CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE); //Enable FIFO 0 message pending interrupt*/
Yukarıdaki gibi bir kurulumla kesme hangi kesme vektörüne düşer?
Teşekkürler
STM32F103 te USB ve CAN aynı anda kullanılamıyor diye aklımda kalmış.
Evet USB ve Can Meselesi öyleymiş.
RM0008 Sayfa:629
Note: In low, medium-, high- and XL-density devices the USB and CAN share a dedicated 512-
byte SRAM memory for data transmission and reception, and so they cannot be used
concurrently (the shared SRAM is accessed through CAN and USB exclusively). The USB
and CAN can be used in the same application but not at the same time.
Sanırım USB ile CAN'ın tek interruptlarının tek vektörde birleştirilmesinin sebebi budur.
Ben birde STM32'nin Can Modülündeki Filtre olayını anlayamadım. Anladığım kadarıyla Sadece belirtilen idlerden gelen mesajları alması sağlanıyor fakat nasıl kurulduğunu anlayamadım.
Örneğin benim id'im 0x123 olsun. Can modülü sadece bu id'den gelen mesajlar için kesme oluştursun. Filtreyi nasıl ayarlamam gerekiyor?
/* CAN filter init */
CAN_FilterInitStructure.CAN_FilterNumber=0;
CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;
CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
CAN_FilterInitStructure.CAN_FilterFIFOAssignment=0;
CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
CAN_FilterInit(&CAN_FilterInitStructure);
Maske ve Filtre konusu sadece STM32 CAN'e ait değil.
Genel olarak netten bulduğum örneklem :
Example 1. we wish to accept only frames with ID of 00001567 (hexadecimal values)
set filter to 00001567
set mask to 1FFFFFFF
when a frame arrives its ID is compared with the filter and all bits must match; any frame that does not match ID 00001567 is rejected
Example 2. we wish to accept only frames with IDs of 00001560 thru to 0000156F
set filter to 00001560
set mask to 1FFFFFF0
when a frame arrives its ID is compared with the filter and all bits except bits 0 to 3 must match; any frame other frame is rejected
Example 3. we wish to accept only frames with IDs of 00001560 thru to 00001567
set filter to 00001560
set mask to 1FFFFFF8
when a frame arrives its ID is compared with the filter and all bits except bits 0 to 2 must match; any frame other frame is rejected
Example 4. we wish to accept any frame
set filter to 0
set mask to 0
all frames are accepted
Anladığım kadarıyla maske ve filtre 0 verilince bütün gelen mesajlar kabul ediliyor. Ben şimdilik çalışmalarımı böyle yapacam ama anlamadığım şey şu maske konusu. Tamam kabul edilecek adres filtre kısmına yazılıyor. peki maske ne işe yarıyor onu bir türlü anlayamadım.
Bu konuyu biraz açıklayayım, gerisini sen getir.
Stm32 can interface konusunda oldukça flexible bir işlemcidir, muhteşem filtre özellikleri var mesela 4 tane filtreleme çeşiti var.
1) 32bit Idmask
2) 32bit idlist
3) 16bit idmask
4) 16bit idlist
32 bit olanlar extended id(29bit) ve standart id(11bit) ile haberleşilirken kullanılıyor
16bit olanlar ise(16bite kadar extended) veya 11bit std id olarak kullanılabilir.
Filtre ve mask kısmına gelince
Filtre ile maske bit bit karşılaştırılır
maske biti 0 ise fitrede ne varsa geçer yani don't care durumu
maske biti 1 ise filtre biti ile gelen mesajdaki ilgili bit aynı olmak zorundadır, aynı değilse stm32 filtre donanımı bu mesajı reddeder.
Mesaj geçerse filtre için tanımladığın can fifoya mesaj yerleştirilir ve fifonun flag'i set olur. İnterrupt kurduysan ki mutlaka kur, int içinde mesajı oku
Bir örnek vereyim
Can bustan sadece ID'si 0x12345678 olan mesajı almak istiyorsam
Filtre Registeri içeriği : 0x12345678
Mask register : 0xFFFFFFFFF
can bustan ID'leri 0x12345670,0x12345671,0x12345672......0x1234567F olan mesajı almak istiyorsam yani 16 farklı id
Filtre Registeri içeriği : 0x12345670
Mask register : 0xFFFFFFFF0
Daha çok çeşitli varyasyon ve durum var ama bu kadarı senin işini çözecektir,
Filtre ve mask 0 yaparsan donanım herşeyi içeri alır, multislave olan yerlerde işlemci mesajlara yetişemez zaten filtrenin var olma amacı budur, gereksiz mesajlarla uğraşmasın diye
Olay bundan ibaret
Tamamdır hocam çaktım meseleyi. Bu açıklama iyi oldu. Teşekkürler.
mesaj birleştirme:: 11 Ağustos 2014, 23:43:37
@CLR Hocam Can ile ilgili ilk testimi yaptım fakat haberleşmeyi sağlayamadım.
Bir tarafta STM32 ve SN65HVD230 ikilisi karşı tarafta ise MCP2515 ve 2551 ikilisi var. MCP2515'i kontrol etmek içinde pic var 100ms aralıklarla MCP2515'e mesaj gönderiyor. Burada CCS'nin standart MCP2515 kütüphanesini kullandım.
STM32 ilede sürekli veri basıyorum fakat CAN_TX de herhangi bir hareketlenme görmüyorum. . Henüz neden kaynaklandığını çözemedim.
Ama şunu gözlemledim. MCP2515 Transmit görevini yapıyor gibi. Osiloskop ile STM32'nin CAN RX ucuna baktığımda sürekli birşeyler geldiğini görebiliyorum. Demekki MCP birleyler gönderiyor. Fakat STM32'nin CAN TX inde birşey yok.
STM32'de Can için kullandığım kütüphane budur.
/*******************************************************************************
* @file can.c
* @author Arectron
* @version V1.0.0
* @date 10/08/2014
********************************************************************************/
/*-------------------------------Includes------------------------------------*/
#include "STM32F10x.h"
#include "CAN.h"
/* Private variables ---------------------------------------------------------*/
CanRxMsg RxMessage;
uint8_t CanFlag=0;
/* Private Functions ---------------------------------------------------------*/
/*******************************************************************************
* Function Name : NVIC_Configuration
* Description : Configures the nested vectored interrupt controller.
* Input : None
* Output : None
* Return : None
* Attention : None
*******************************************************************************/
void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
/* Enable CAN1 RX0 interrupt IRQ channel */
NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
/*******************************************************************************
* Function Name : GPIO_Configuration
* Description : Configures the CAN GPIO ports.
* Input : None
* Output : None
* Return : None
* Attention : None
*******************************************************************************/
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* CAN Periph clock enable */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_APB2Periph_AFIO ,ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
/* Configure CAN pin: RX */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* Configure CAN pin: TX */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_PinRemapConfig(GPIO_Remap1_CAN1,ENABLE);
}
/*******************************************************************************
* Function Name : CAN_init
* Description : Configures the CAN
* Input : None
* Output : None
* Return : None
* Attention : None
*******************************************************************************/
void Can_init(void)
{
CAN_InitTypeDef CAN_InitStructure;
CAN_FilterInitTypeDef CAN_FilterInitStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
NVIC_Configuration();
GPIO_Configuration();
CAN_DeInit(CAN1);
CAN_StructInit(&CAN_InitStructure);
/* CAN cell init */
CAN_InitStructure.CAN_TTCM=DISABLE;
CAN_InitStructure.CAN_ABOM=DISABLE;
CAN_InitStructure.CAN_AWUM=DISABLE;
CAN_InitStructure.CAN_NART=DISABLE;
CAN_InitStructure.CAN_RFLM=DISABLE;
CAN_InitStructure.CAN_TXFP=DISABLE;
CAN_InitStructure.CAN_Mode=CAN_Mode_Normal;
CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;
CAN_InitStructure.CAN_BS1=CAN_BS1_8tq;
CAN_InitStructure.CAN_BS2=CAN_BS2_7tq;
CAN_InitStructure.CAN_Prescaler=5;
CAN_Init(CAN1,&CAN_InitStructure);
/* CAN filter init */
CAN_FilterInitStructure.CAN_FilterNumber=0;
CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;
CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
CAN_FilterInitStructure.CAN_FilterFIFOAssignment=0;
CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
CAN_FilterInit(&CAN_FilterInitStructure);
CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);
}
/*******************************************************************************
* Function Name : CanSendMessage
* Description : Can Write Date to CAN-BUS
* Input : None
* Output : None
* Return : None
* Attention : None
*******************************************************************************/
void CanSendMessage(uint32_t CanTxId, uint8_t CanTxBufSize, uint8_t* CanTxData)
{
CanTxMsg TxMessage;
uint8_t i=0;
/* transmit */
TxMessage.StdId = CanTxId;
TxMessage.RTR = CAN_RTR_DATA;
TxMessage.IDE = CAN_ID_STD;
TxMessage.DLC = CanTxBufSize;
for(i=0;i<CanTxBufSize;i++)
{
TxMessage.Data[i]=CanTxData[i];
}
CAN_Transmit(CAN1,&TxMessage);
}
/*******************************************************************************
* Function Name : USB_LP_CAN1_RX0_IRQHandler
* Description : This function handles USB Low Priority or CAN RX0 interrupts
* Input : None
* Output : None
* Return : None
* Attention : None
*******************************************************************************/
void USB_LP_CAN_RX0_IRQHandler(void)
{
CAN_Receive(CAN1,CAN_FIFO0, &RxMessage);
CAN_ClearITPendingBit(CAN1,CAN_IT_FMP0);
CanFlag=ENABLE;
}
Sağdan soldan toparladığım kodları düzenleyerek oluşturdum. Ben bir tek CanSendMessage Fonksiyonunu yazdım. Ana programda bu fonksiyonu çağırıyorum. Örneğin aşağıdaki gibi.
CanSendMessage(0x202,1,&buff[0]);
Program bu fonksiyona gidip geliyor fakat CAN_TX de hiçbir hareketlenme olmuyor. Neden kaynaklanıyor bilmiyorum. CAN ile ilk kez uğraşıyorum. konu hakkında fazla tecrübem yok. Kodları bi inceleyip varsa eksiklerim söylerseniz memnun olurum.
Birde Şu CAN_Baudrate konusunda biraz bilgi verirseniz sevinirim. Baudrate ayarını yapmak için CCS de fonksiyon var fakat STM32'de bu konuda pek birşey bulamadım. İlgili olabilecek Birtek CAN_Prescaller var onuda nasıl ayarlayacağım bilmiyorum.
Yardım ederseniz çok memnun olurum.
mesaj birleştirme:: 12 Ağustos 2014, 00:43:47
@CLR Hocam Can ile ilgili ilk testimi yaptım fakat haberleşmeyi sağlayamadım.
Bir tarafta STM32 ve SN65HVD230 ikilisi karşı tarafta ise MCP2515 ve 2551 ikilisi var. MCP2515'i kontrol etmek içinde pic var 100ms aralıklarla MCP2515'e mesaj gönderiyor. Burada CCS'nin standart MCP2515 kütüphanesini kullandım.
STM32 ilede sürekli veri basıyorum fakat CAN_TX de herhangi bir hareketlenme görmüyorum. . Henüz neden kaynaklandığını çözemedim.
Ama şunu gözlemledim. MCP2515 Transmit görevini yapıyor gibi. Osiloskop ile STM32'nin CAN RX ucuna baktığımda sürekli birşeyler geldiğini görebiliyorum. Demekki MCP birleyler gönderiyor. Fakat STM32'nin CAN TX inde birşey yok.
STM32'de Can için kullandığım kütüphane budur.
/*******************************************************************************
* @file can.c
* @author Arectron
* @version V1.0.0
* @date 10/08/2014
********************************************************************************/
/*-------------------------------Includes------------------------------------*/
#include "STM32F10x.h"
#include "CAN.h"
/* Private variables ---------------------------------------------------------*/
CanRxMsg RxMessage;
uint8_t CanFlag=0;
/* Private Functions ---------------------------------------------------------*/
/*******************************************************************************
* Function Name : NVIC_Configuration
* Description : Configures the nested vectored interrupt controller.
* Input : None
* Output : None
* Return : None
* Attention : None
*******************************************************************************/
void NVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
/* Enable CAN1 RX0 interrupt IRQ channel */
NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
}
/*******************************************************************************
* Function Name : GPIO_Configuration
* Description : Configures the CAN GPIO ports.
* Input : None
* Output : None
* Return : None
* Attention : None
*******************************************************************************/
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* CAN Periph clock enable */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_APB2Periph_AFIO ,ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
/* Configure CAN pin: RX */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/* Configure CAN pin: TX */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_PinRemapConfig(GPIO_Remap1_CAN1,ENABLE);
}
/*******************************************************************************
* Function Name : CAN_init
* Description : Configures the CAN
* Input : None
* Output : None
* Return : None
* Attention : None
*******************************************************************************/
void Can_init(void)
{
CAN_InitTypeDef CAN_InitStructure;
CAN_FilterInitTypeDef CAN_FilterInitStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
NVIC_Configuration();
GPIO_Configuration();
CAN_DeInit(CAN1);
CAN_StructInit(&CAN_InitStructure);
/* CAN cell init */
CAN_InitStructure.CAN_TTCM=DISABLE;
CAN_InitStructure.CAN_ABOM=DISABLE;
CAN_InitStructure.CAN_AWUM=DISABLE;
CAN_InitStructure.CAN_NART=DISABLE;
CAN_InitStructure.CAN_RFLM=DISABLE;
CAN_InitStructure.CAN_TXFP=DISABLE;
CAN_InitStructure.CAN_Mode=CAN_Mode_Normal;
CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;
CAN_InitStructure.CAN_BS1=CAN_BS1_8tq;
CAN_InitStructure.CAN_BS2=CAN_BS2_7tq;
CAN_InitStructure.CAN_Prescaler=5;
CAN_Init(CAN1,&CAN_InitStructure);
/* CAN filter init */
CAN_FilterInitStructure.CAN_FilterNumber=0;
CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;
CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;
CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
CAN_FilterInitStructure.CAN_FilterFIFOAssignment=0;
CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
CAN_FilterInit(&CAN_FilterInitStructure);
CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);
}
/*******************************************************************************
* Function Name : CanSendMessage
* Description : Can Write Date to CAN-BUS
* Input : None
* Output : None
* Return : None
* Attention : None
*******************************************************************************/
void CanSendMessage(uint32_t CanTxId, uint8_t CanTxBufSize, uint8_t* CanTxData)
{
CanTxMsg TxMessage;
uint8_t i=0;
/* transmit */
TxMessage.StdId = CanTxId;
TxMessage.RTR = CAN_RTR_DATA;
TxMessage.IDE = CAN_ID_STD;
TxMessage.DLC = CanTxBufSize;
for(i=0;i<CanTxBufSize;i++)
{
TxMessage.Data[i]=CanTxData[i];
}
CAN_Transmit(CAN1,&TxMessage);
}
/*******************************************************************************
* Function Name : USB_LP_CAN1_RX0_IRQHandler
* Description : This function handles USB Low Priority or CAN RX0 interrupts
* Input : None
* Output : None
* Return : None
* Attention : None
*******************************************************************************/
void USB_LP_CAN_RX0_IRQHandler(void)
{
CAN_Receive(CAN1,CAN_FIFO0, &RxMessage);
CAN_ClearITPendingBit(CAN1,CAN_IT_FMP0);
CanFlag=ENABLE;
}
Sağdan soldan toparladığım kodları düzenleyerek oluşturdum. Ben bir tek CanSendMessage Fonksiyonunu yazdım. Ana programda bu fonksiyonu çağırıyorum. Örneğin aşağıdaki gibi.
CanSendMessage(0x202,1,&buff[0]);
Program bu fonksiyona gidip geliyor fakat CAN_TX de hiçbir hareketlenme olmuyor. Neden kaynaklanıyor bilmiyorum. CAN ile ilk kez uğraşıyorum. konu hakkında fazla tecrübem yok. Kodları bi inceleyip varsa eksiklerim söylerseniz memnun olurum.
Birde Şu CAN_Baudrate konusunda biraz bilgi verirseniz sevinirim. Baudrate ayarını yapmak için CCS de fonksiyon var fakat STM32'de bu konuda pek birşey bulamadım. İlgili olabilecek Birtek CAN_Prescaller var onuda nasıl ayarlayacağım bilmiyorum.
Yardım ederseniz sevinirim.
Kaç kbit'te haberleşmek istiyorsun veya MCP2515 Kaç kbitte gönderiyor? İşlemci çalışma frekansı?
Scop ile can tx pinine baktın mı?
Hocam Usart cinsinden söylemek gerekirse 9600 Baudrate gibi bir değer işimi görür.
STM32F103 zaten 72Mhz de çalışıyor. MCP2515 ise şuanda Baudrate Prescalleri 4 olarak ayarlı. Ayrıca MCP2515'e 16Mhz Harici Osilatör bağlı. Çalışma frekansları farklı olduğundan iki çipinde baudrate prescalleri aynı yapılmaz herhalde. Yani ben öyle tahmin ediyorum. @CLR hocam tam olarak ne yapmam gerekiyor?
STM32'de CAN_TX pinine osiloskop ile bakıyorum hiçbirşey yok. Sürekli lojik1 konumunda.
Şunu anlamıyorum. Baudrate yanlış bile olsa STM32'den veri çıkması lazım. Fakat STM32'nin CAN modülü sankide hiç çalışmıyor. Anlam veremedim.
Fikri olan varmı?
@Mucit23
Yazdığın C fonksiyonları paylaşmışsın fakat şema olmadığı için programda kullandığın portları kullandığını ve bu yazdığın fonksiyonları main içinde yerli yerinde kullandığını varsayıyorum. Programı aşağıdaki gibi düzelt
1-) Can1 clock enable
2-) remap (gpiob8-9 kullanıyorsun galiba)
3-) Gpio ayarları : Rx input ama GPIO_Mode_IPU (tx kısmın doğru)
100kbit için can ayarlarını vereyim
4-) CAN_SJW_1tq
5-) CAN_BS1_8tq
6-) CAN_BS2_3tq
7-) CAN_Prescaler = 30
8-) tx 'in gönderildiğinden emin ol ve timeout koy
CAN_Transmit(CAN1,&TxMessage);
while((CAN_TransmitStatus(CAN1,TxMailBox)!=CAN_TxStatus_Ok) && (TimeOut != 0))
2515 ile haberleşe bilmen için onun bitrate'ini hesaplaman , logic analyzer ile scop ile bulman lazım.
@CLR Hocam biraz geç cevap yazıyorum kusura bakmayın ancak akşamdan akşama uğraşabiliyorum.
STM32 için bahsettiğiniz düzenlemeleri gerçekleştirdim. Birçok CAN ile ilgili kod parçası inceledim ve artık STM32'nin ayarlarında bir eksiklik olduğunu düşünmüyorum.
Herneyse STM32'nin ayarları yaptıktan sonra birkaç test yaptım ve edindiğim izlenimler şöyle
Şimdi STM32'nin CANTX pini çalışıyormuş. Dünde çalışıyormuş fakat benim ilk yaptığım denemede STM32 karşı tarafa sürekli veri basıp karşı taraftan gelen veriler için interrupt oluşturmasını bekliyordum. MCP2515'de aynı şekilde STM32'ye sürekli veri basıp bir yandanda karşı taraftan gelen mesajları dinliyordu.
Ben dün akşamki ilk denememde MCP2515 ile STM32 yi aynı anda çalıştırıyordum. MCP2515 STM32'ye sürekli veri basıyordu. Şimdi Sadece STM32 yi çalıştırınca CAN_TX pininden yoğun bir şekilde veri çıktığını gördüm. Yani CAN_TX çalışıyor.
Bunu gördükten sonra MCP2515'i kontrol eden pici Mesaj göndermek yerine sadece gelen mesajları dinlemesi için programladım. Yani STM32'ye hiçbir mesaj göndermiyor. Eğer STM32'den mesaj gelirse sözde interrupt oluşturacak.
İlk önce STM32'ye enerji veriyorum. Can_TX pini çok yoğun bir şekilde veri gittiğini görüyorum skop ile. Ardında MCP2515'e enerji veriyorum ve Hattaki yoğunluk çok azalıyor. Resimlerde daha net anlaşılıyor.
MCP2515 çalışmıyorken STM32'nin CAN_TX Pini
(http://s1.postimg.cc/sjs7cfmsr/DS1_EB133304861_0.jpg) (http://postimg.cc/image/sjs7cfmsr/)
Buda MCP2515 Çalışıyorken STM32'nin CAN_TX Pini
(http://s27.postimg.cc/5ecrh235b/DS1_EB133304861_1.jpg) (http://postimg.cc/image/5ecrh235b/)
Eğer MCP2515'de STM32'ye veri gönderince STM32'nin komple eli ayağı birbirine dolaşıyor olsa gerekki tamamen veri göndermeyide kesiyor
Şimdi ne kadar doğru emin değilim Bu sorunun Baudrate uyumsuzluğundan kaynaklanacağını düşünüyorum. Can'da güvenlik önemli biliyoruz. Verilen her bitin karşıya ulaşması lazım. STM32 birşey gönderiyor. Baudrate uygun olmadığı için MCP gelen mesajı alamıyor. STM32'de buna karşılık ne yapıyor bilmiyorum ama karşıklı mesajlaşma olunca donup kalıyor.
Benim CCS de kullandığım MCP2515 kütüphanesi budur.
/////////////////////////////////////////////////////////////////////////
//// mcp2515a.c NODE A ////
//// CAN Library routines for Microchip's MCP2510 (and compatable) ////
//// CAN IO expanders. ////
//// ////
//// This library provides the following functions: ////
//// (for more information on these functions see the comment ////
//// header above each function) ////
//// ////
//// can_init - Configures the MCP2510 CAN peripheral ////
//// ////
//// can_set_baud - Sets the baud rate control registers ////
//// ////
//// can_set_mode - Sets the CAN module into a specific mode ////
//// ////
//// can_set_id - Sets the standard and extended ID ////
//// ////
//// can_get_id - Gets the standard and extended ID ////
//// ////
//// can_putd - Sends a message/request with specified ID ////
//// ////
//// can_getd - Returns specifid message/request and ID ////
//// ////
//// can_kbhit - Returns true if there is data in one of the ////
//// receive buffers ////
//// ////
//// can_tbe - Returns true if the transmit buffer is ready to ////
//// send more data ////
//// ////
//// can_abort - Aborts all pending transmissions ////
//// ////
//// You will need a CAN transeiver to connect CANRX and CANTX ////
//// pins to CANH and CANL bus lines. ////
//// ////
//// CCS provides an example, ex_can_ccs_b.c, which shows how to use ////
//// this library with CCS's CAN Prototype board. ////
//// ////
/////////////////////////////////////////////////////////////////////////
//// ////
//// Version History ////
//// ////
//// Jul 27 04 - can_init() uses CAN_USE_EXTENDED_ID instead of ////
//// setting all RX filters to extended. ////
//// ////
//// Apr 20 04 - Fixed a compling problem. ////
//// ////
//// Feb 24 04 - can_get_id() fixed for EID<18:20>. ////
//// ////
/////////////////////////////////////////////////////////////////////////
//// (C) Copyright 1996,2003 Custom Computer Services ////
//// This source code may only be used by licensed users of the CCS ////
//// C compiler. This source code may only be distributed to other ////
//// licensed users of the CCS C compiler. No other use, ////
//// reproduction or distribution is permitted without written ////
//// permission. Derivative programs created using this software ////
//// in object code form are not restricted in any way. ////
/////////////////////////////////////////////////////////////////////////
#include <can-mcp2510.h>
//IO pins connected to MCP2510
#ifndef EXT_CAN_CS
#define EXT_CAN_CS PIN_C2
#define EXT_CAN_SI PIN_C5
#define EXT_CAN_SO PIN_C4
#define EXT_CAN_SCK PIN_C3
#define EXT_CAN_RESET PIN_C0 //CCS library does not use this pin by default
// #define EXT_CAN_TX0RTS PIN_C4 //CCS library does not use this pin by default
// #define EXT_CAN_TX1RTS PIN_B4 //CCS library does not use this pin by default
// #define EXT_CAN_TX2RTS PIN_C2 //CCS library does not use this pin by default
#endif
#if CAN_DO_DEBUG
#define can_debug printf
#else
#define can_debug
#endif
////////////////////////////////////////////////////////////////////////
//
// can_init()
//
// Initializes MCP2510 CAN peripheral. Sets the RX filter and masks so the
// CAN peripheral will receive all incoming IDs. Configures both RX buffers
// to only accept valid valid messages (as opposed to all messages, or all
// extended message, or all standard messages).
//
// The constants (CAN_USE_RX_DOUBLE_BUFFER, CAN_ENABLE_DRIVE_HIGH,
// CAN_ENABLE_CAN_CAPTURE, etc) are given a default define in the can-mcp2510.h file.
// These default values can be overwritten in the main code, but most
// applications will be fine with these defaults.
//
//////////////////////////////////////////////////////////////////////////////
void can_init(void) {
struct struct_RXB0CTRL b_rxb0ctrl;
mcp2510_init();
can_set_mode(CAN_OP_CONFIG); //must be in config mode before params can be set
can_set_baud();
b_rxb0ctrl=0;
b_rxb0ctrl.rxm=CAN_RX_VALID;
b_rxb0ctrl.bukt=CAN_USE_RX_DOUBLE_BUFFER;
mcp2510_write(RXB0CTRL, (int)b_rxb0ctrl);
mcp2510_write(RXB1CTRL, (int)b_rxb0ctrl);
//if you want to configure the TXnRTS pins, do it here. default is off
can_set_id(RX0MASK, CAN_MASK_ACCEPT_ALL, CAN_USE_EXTENDED_ID); //set mask 0 (RX BUFFER 0)
can_set_id(RX0FILTER0, 0, CAN_USE_EXTENDED_ID); //set filter 0 of mask 0 (RX BUFFER 0)
can_set_id(RX0FILTER1, 0, CAN_USE_EXTENDED_ID); //set filter 1 of mask 0 (RX BUFFER 0)
can_set_id(RX1MASK, CAN_MASK_ACCEPT_ALL, CAN_USE_EXTENDED_ID); //set mask 1 (RX BUFFER 1)
can_set_id(RX1FILTER2, 0, CAN_USE_EXTENDED_ID); //set filter 0 of mask 1 (RX BUFFER 1)
can_set_id(RX1FILTER3, 0, CAN_USE_EXTENDED_ID); //set filter 1 of mask 1 (RX BUFFER 1)
can_set_id(RX1FILTER4, 0, CAN_USE_EXTENDED_ID); //set filter 2 of mask 1 (RX BUFFER 1)
can_set_id(RX1FILTER5, 0, CAN_USE_EXTENDED_ID); //set filter 3 of mask 1 (RX BUFFER 1)
can_set_mode(CAN_OP_NORMAL);
}
////////////////////////////////////////////////////////////////////////
//
// can_set_baud()
//
// Configures the baud rate control registers. All the defines here
// are defaulted in the can-mcp2510.h file. These defaults can, and
// probably should, be overwritten in the main code.
//
// Current defaults are set to work with CCS's CAN Prototype board and
// Microchip's MCP250xxx CAN Developers Kit if this PIC is running at 20Mhz.
//
////////////////////////////////////////////////////////////////////////
void can_set_baud(void) {
struct struct_CNF1 new_CNF1;
struct struct_CNF2 new_CNF2;
struct struct_CNF3 new_CNF3;
new_CNF1.brp=CAN_BRG_PRESCALAR;
new_CNF1.sjw=CAN_BRG_SYNCH_JUMP_WIDTH;
new_CNF2.prseg=CAN_BRG_PROPAGATION_TIME;
new_CNF2.phseg1=CAN_BRG_PHASE_SEGMENT_1;
new_CNF2.sam=CAN_BRG_SAM;
new_CNF2.btlmode=CAN_BRG_SEG_2_PHASE_TS;
new_CNF3.phseg2=CAN_BRG_PHASE_SEGMENT_2;
new_CNF3.wakfil=CAN_BRG_WAKE_FILTER;
mcp2510_write(CNF1, (int)new_CNF1);
mcp2510_write(CNF2, (int)new_CNF2);
mcp2510_write(CNF3, (int)new_CNF3);
}
void can_set_mode(CAN_OP_MODE mode) {
struct struct_CANCTRL old_CANCTRL;
old_CANCTRL=mcp2510_read(CANCTRL);
old_CANCTRL.reqop=mode;
mcp2510_write(CANCTRL, (int)old_CANCTRL);
do {
old_CANCTRL=mcp2510_read(CANCTRL);
} while (old_CANCTRL.reqop != mode);
}
////////////////////////////////////////////////////////////////////////
//
// can_set_id()
//
// Configures the xxxxEIDL, xxxxEIDH, xxxxSIDL and xxxxSIDH registers to
// configure the defined buffer to use the specified ID
//
// Paramaters:
// addr - pointer to first byte of ID register, starting with xxxxEIDL.
// For example, a pointer to RXM1EIDL
// id - ID to set buffer to
// ext - Set to TRUE if this buffer uses an extended ID, FALSE if not
//
////////////////////////////////////////////////////////////////////////
void can_set_id(int addr, int32 id, int1 ext) {
int converted_id[4];
int *ptr;
ptr=&converted_id[3]; //3=eidl, 2=eidh, 1=sidl, 0=sidh
if (ext) { //extended
//eidl
*ptr=make8(id,0); //0:7
//eidh
ptr--;
*ptr=make8(id,1); //8:15
//sidl
ptr--;
*ptr=make8(id,2) & 0x03; //16:17
*ptr|=(make8(id,2) << 3) & 0xE0; //18:20
*ptr|=0x08;
//sidh
ptr--;
*ptr=((make8(id,2) >> 5) & 0x07 ); //21:23
*ptr|=((make8(id,3) << 3) & 0xF8);//24:28
}
else { //standard
//eidl
*ptr=0;
//eidh
ptr--;
*ptr=0;
//sidl
ptr--;
*ptr=(make8(id,0) << 5) & 0xE0;
//sidh
ptr--;
*ptr=(make8(id,0) >> 3) & 0x1F;
*ptr|=(make8(id,1) << 5) & 0xE0;
}
//0=eidl, 1=eidh, 2=sidl, 3=sidh
mcp2510_write(addr--, converted_id[3]);
mcp2510_write(addr--, converted_id[2]);
mcp2510_write(addr--, converted_id[1]);
mcp2510_write(addr, converted_id[0]);
}
////////////////////////////////////////////////////////////////////////
//
// can_get_id()
//
// Returns the ID of the specified buffer. (The opposite of can_set_id())
// This is used after receiving a message, to see which ID sent the message.
//
// Paramaters:
// addr - pointer to first byte of ID register, starting with xxxxEIDL.
// For example, a pointer to RXM1EIDL
// ext - Set to TRUE if this buffer uses an extended ID, FALSE if not
//
// Returns:
// The ID of the buffer
//
////////////////////////////////////////////////////////////////////////
int32 can_get_id(int addr, int1 ext) {
int32 ret;
int * ptr;
int converted_id[4];
ptr=&converted_id[3]; //3=eidl, 2=eidh, 1=sidl, 0=sidh
converted_id[3]=mcp2510_read(addr--);
converted_id[2]=mcp2510_read(addr--);
converted_id[1]=mcp2510_read(addr--);
converted_id[0]=mcp2510_read(addr);
ret=0;
if (ext) {
ret=*ptr; //eidl
ptr--; //eidh
ret|=((int32)*ptr << 8);
ptr--; //sidl
ret|=((int32)*ptr & 0x03) << 16;
ret|=((int32)*ptr & 0xE0) << 13;
ptr--; //sidh
ret|=((int32)*ptr << 21);
}
else {
ptr-=2; //sidl
ret=((int32)*ptr & 0xE0) >> 5;
ptr--; //sidh
ret|=((int32)*ptr << 3);
}
return(ret);
}
////////////////////////////////////////////////////////////////////////
//
// can_putd()
//
// Puts data on a transmit buffer, at which time the CAN peripheral will
// send when the CAN bus becomes available.
//
// Paramaters:
// id - ID to transmit data as
// data - pointer to data to send
// len - length of data to send
// priority - priority of message. The higher the number, the
// sooner the CAN peripheral will send the message.
// Numbers 0 through 3 are valid.
// ext - TRUE to use an extended ID, FALSE if not
// rtr - TRUE to set the RTR (request) bit in the ID, false if NOT
//
// Returns:
// If successful, it will return TRUE
// If un-successful, will return FALSE
//
////////////////////////////////////////////////////////////////////////
int1 can_putd(int32 id, int * data, int len, int priority, int1 ext, int1 rtr)
{
int i;
int port;
int TXRXBaD0;
int TXBaCTRL;
int TXRXBaEIDL;
int TXBaDLC;
struct txbNctrl_struct b_TXBaCTRL;
struct rxbNdlc_struct b_TXBaDLC;
struct txbNctrl_struct b_TXB0CTRL, b_TXB1CTRL, b_TXB2CTRL;
//output_high( PIN_E2); // tx indicator
b_TXB0CTRL=mcp2510_read(TXB0CTRL);
b_TXB1CTRL=mcp2510_read(TXB1CTRL);
b_TXB2CTRL=mcp2510_read(TXB2CTRL);
// find emtpy transmitter
//map access bank addresses to empty transmitter
if (!b_TXB0CTRL.txreq) {
TXRXBaD0=TXB0D0;
TXBaCTRL=TXB0CTRL;
TXRXBaEIDL=TXB0EIDL;
TXBaDLC=TXB0DLC;
port=0;
}
else if (!b_TXB1CTRL.txreq) {
TXRXBaD0=TXB1D0;
TXBaCTRL=TXB1CTRL;
TXRXBaEIDL=TXB1EIDL;
TXBaDLC=TXB1DLC;
port=1;
}
else if (!b_TXB2CTRL.txreq) {
TXRXBaD0=TXB2D0;
TXBaCTRL=TXB2CTRL;
TXRXBaEIDL=TXB2EIDL;
TXBaDLC=TXB2DLC;
port=2;
}
else {
#if CAN_DO_DEBUG
can_debug("\r\nCAN_PUTD() FAIL: NO OPEN TX BUFFERS\r\n");
#endif
return(0);
}
//set priority.
b_TXBaCTRL=mcp2510_read(TXBaCTRL);
b_TXBaCTRL.txpri=priority;
mcp2510_write(TXBaCTRL, (int)b_TXBaCTRL);
//set tx mask
can_set_id(TXRXBaEIDL, id, ext);
//set tx data count
b_TXBaDLC=len;
b_TXBaDLC.rtr=rtr;
mcp2510_write(TXBaDLC, (int)b_TXBaDLC);
//write to buffer
for (i=TXRXBaD0; i<(TXRXBaD0 + len); i++) {
mcp2510_write(i,*data);
data++;
}
//enable transmission
b_TXBaCTRL=mcp2510_read(TXBaCTRL);
b_TXBaCTRL.txreq=1;
mcp2510_write(TXBaCTRL, (int)b_TXBaCTRL);
#if CAN_DO_DEBUG
can_debug("\r\nCAN_PUTD(): BUFF=%U ID=%LX LEN=%U PRI=%U EXT=%U RTR=%U\r\n", port, id, len, priority, ext, rtr);
if ((len)&&(!rtr)) {
data-=len;
can_debug(" DATA = ");
for (i=0;i<len;i++) {
can_debug("%X ",*data);
data++;
}
can_debug("\r\n");
}
#endif
//output_low( PIN_E2); //tx led status
return(1);
}
////////////////////////////////////////////////////////////////////////
//
// can_getd()
//
// Gets data from a receive buffer, if the data exists
//
// Returns:
// id - ID who sent message
// data - pointer to array of data
// len - length of received data
// stat - structure holding some information (such as which buffer
// recieved it, ext or standard, etc)
//
// Returns:
// Function call returns a TRUE if there was data in a RX buffer, FALSE
// if there was none.
//
////////////////////////////////////////////////////////////////////////
int1 can_getd(int32 & id, int * data, int & len, struct rx_stat & stat)
{
int i;
struct struct_RXB0CTRL b_RXB0CTRL;
struct struct_RXB1CTRL b_RXB1CTRL;
struct struct_EFLG b_EFLG;
int RXBaDLC;
struct rxbNdlc_struct b_RXBaDLC;
int TXRXBaSIDL;
struct struct_TXRXBaSIDL b_TXRXBaSIDL;
int RXBaD0;
struct struct_CANINTF b_CANINTF;
b_CANINTF=mcp2510_read(CANINTF);
b_RXB0CTRL=mcp2510_read(RXB0CTRL);
b_RXB1CTRL=mcp2510_read(RXB1CTRL);
b_EFLG=mcp2510_read(EFLG);
if (b_CANINTF.rx0if) {
stat.buffer=0;
stat.err_ovfl=b_EFLG.rx0ovr;
b_EFLG.rx0ovr=0;
mcp2510_write(EFLG, (int)b_EFLG);
if (b_RXB0CTRL.bukt) {
stat.filthit=b_RXB0CTRL.filhit0;
}
RXBaDLC=RXB0DLC;
TXRXBaSIDL=RXB0SIDL;
RXBaD0=RXB0D0;
}
else if (b_CANINTF.rx1if)
{
stat.buffer=1;
stat.err_ovfl=b_EFLG.rx1ovr;
b_EFLG.rx1ovr=0;
mcp2510_write(EFLG, (int)b_EFLG);
stat.filthit=b_RXB1CTRL.filhit0;
RXBaDLC=RXB1DLC;
TXRXBaSIDL=RXB1SIDL;
RXBaD0=RXB1D0;
}
else {
#if CAN_DO_DEBUG
can_debug("\r\nFAIL ON CAN_GETD(): NO MESSAGE IN BUFFER\r\n");
#endif
return (0);
}
//get count
b_RXBaDLC=mcp2510_read(RXBaDLC);
len = b_RXBaDLC.dlc;
stat.rtr=b_RXBaDLC.rtr;
//was it extended or standard?
b_TXRXBaSIDL=mcp2510_read(TXRXBaSIDL);
stat.ext=b_TXRXBaSIDL.ext;
id=can_get_id(TXRXBaSIDL + 2,stat.ext);
//get data
for ( i = RXBaD0; i < (RXBaD0 + len); i++ ) {
*data=mcp2510_read(i);
data++;
}
stat.inv=b_CANINTF.merrf;
if (b_CANINTF.merrf) {
b_CANINTF.merrf=0;
}
if (stat.buffer) {
b_CANINTF.rx1if=0;
}
else {
b_CANINTF.rx0if=0;
}
mcp2510_write(CANINTF, (int)b_CANINTF);
#if CAN_DO_DEBUG
can_debug("\r\nCAN_GETD(): BUFF=%U ID=%LX LEN=%U OVF=%U ", stat.buffer, id, len, stat.err_ovfl);
can_debug("FILT=%U RTR=%U EXT=%U INV=%U", stat.filthit, stat.rtr, stat.ext, stat.inv);
if ((len)&&(!stat.rtr)) {
data-=len;
can_debug("\r\n DATA = ");
for (i=0;i<len;i++) {
can_debug("%X ",*data);
data++;
}
}
can_debug("\r\n");
#endif
return(1);
}
////////////////////////////////////////////////////////////////////////
//
// can_kbhit()
//
// Returns TRUE if there is data in the receive buffers
//
//////////////////////////////////////////////////////////////////////////////
int1 can_kbhit(void) {
struct struct_CANINTF b_CANINTF;
b_CANINTF=mcp2510_read(CANINTF);
if (b_CANINTF.rx0if || b_CANINTF.rx1if)
{return(1);}
return(0);
}
////////////////////////////////////////////////////////////////////////
//
// can_tbe()
//
// Returns TRUE if the transmit buffers are empty and ready to transmit data
//
//////////////////////////////////////////////////////////////////////////////
int1 can_tbe(void) {
struct txbNctrl_struct b_TXB0CTRL, b_TXB1CTRL, b_TXB2CTRL;
b_TXB0CTRL=mcp2510_read(TXB0CTRL);
b_TXB1CTRL=mcp2510_read(TXB1CTRL);
b_TXB2CTRL=mcp2510_read(TXB2CTRL);
if (!b_TXB0CTRL.txreq || !b_TXB1CTRL.txreq || !b_TXB2CTRL.txreq)
{return(1);}
return(0);
}
////////////////////////////////////////////////////////////////////////
//
// can_abort()
//
// Aborts all pending tranmissions.
//
//////////////////////////////////////////////////////////////////////////////
void can_abort(void) {
struct struct_CANCTRL b_CANCTRL;
b_CANCTRL=mcp2510_read(CANCTRL);
b_CANCTRL.abat=1;
mcp2510_write(CANCTRL, (int)b_CANCTRL);
delay_ms(5);
b_CANCTRL.abat=0;
mcp2510_write(CANCTRL, (int)b_CANCTRL);
}
///////////////////
///
//
// SPI CODE
//
///
//////////////////
//data clocked in on rising edge
//data driven out on falling edge
int mcp2510_read(int address) {
int command[2];
int i;
int data;
command[1]=0x03;
command[0]=address;
output_low(EXT_CAN_CS);
for (i=0;i<16;i++) {
output_bit(EXT_CAN_SI, shift_left(&command[0],2,0));
output_high(EXT_CAN_SCK);
output_low(EXT_CAN_SCK);
}
for (i=0;i<8;i++) {
shift_left(&data,1,input(EXT_CAN_SO));
output_high(EXT_CAN_SCK);
output_low(EXT_CAN_SCK);
}
output_high(EXT_CAN_CS);
return(data);
}
int mcp2510_status(void) {
int command;
int data;
int i;
command=0xA0;
output_low(EXT_CAN_CS);
for (i=0;i<8;i++) {
output_bit(EXT_CAN_SI, shift_left(&command,1,0));
output_high(EXT_CAN_SCK);
output_low(EXT_CAN_SCK);
}
for (i=0;i<8;i++) {
shift_left(&data,1,input(EXT_CAN_SO));
output_high(EXT_CAN_SCK);
output_low(EXT_CAN_SCK);
}
for (i=0;i<8;i++) {
output_high(EXT_CAN_SCK);
output_low(EXT_CAN_SCK);
}
output_high(EXT_CAN_CS);
return(data);
}
void mcp2510_write(int address, int data) {
int command[3];
int i;
command[2]=0x02;
command[1]=address;
command[0]=data;
output_low(EXT_CAN_CS);
for (i=0;i<24;i++) {
output_bit(EXT_CAN_SI, shift_left(&command[0],3,0));
output_high(EXT_CAN_SCK);
output_low(EXT_CAN_SCK);
}
output_high(EXT_CAN_CS);
}
void mcp2510_command(int command) {
int i;
output_low(EXT_CAN_CS);
for (i=0;i<8;i++) {
output_bit(EXT_CAN_SI, shift_left(&command,1,0));
output_high(EXT_CAN_SCK);
output_low(EXT_CAN_SCK);
}
output_high(EXT_CAN_CS);
}
void mcp2510_init(void) {
output_high(EXT_CAN_CS);
output_low(EXT_CAN_SCK);
#ifdef EXT_CAN_TX0RTS
output_high(EXT_CAN_TX0RTS);
#endif
#ifdef EXT_CAN_TX1RTS
output_high(EXT_CAN_TX1RTS);
#endif
#ifdef EXT_CAN_TX2RTS
output_high(EXT_CAN_TX2RTS);
#endif
#ifdef EXT_CAN_TX0RTS
output_high(EXT_CAN_RESET);
output_low(EXT_CAN_RESET);
output_high(EXT_CAN_RESET);
delay_ms(5);
#endif
mcp2510_command(0xC0); //reset
delay_ms(5);
}
Hocam Burada can_set_baud() diye bir fonksiyon var ve can_init() fonksiyonu içerisinde bu fonksiyon çağrılıyor. Şimdi STM32'yi 100Kbit için ayarladık. MCP2515'i de 100Kbit için ayarlamam gerekiyor.
Daha önce bu enteğre ile çalışan arkadaşların yardımına ihtiyacım var. Yukarıdaki kütüphanede, can_init() fonksiyonunda göze çarpan bir hata varmı? Sorun baudrate ile ilgilimidir? MCP2515'de Baudrate hesabı nasıl yapılıyor? Yardım ederseniz sevinirim.
@Mucit23
Aslında programından can tx pininden data çıktığını anlamıştım ama yazmak istemedim çünkü şema koymadığın için belki remap olayında hata yapıyor olabilirdin veya başka bir ölçüm veya donanım hatan olabilirdi diye ilk açıklamayı yazdım.
Şimdi bilmen gereken şu var.
Can busta sadece bir tane tranmitter veya transceiver varsa yani karşıda alıcı can device yoksa, transmitter aynı datayı sürekli gönderir çünkü karşıdan ack bekler. Senin durumunda da o var, ilk başta stm32 ardışık datayı gönderir çünkü alıcı yok sonra alıcı devreye girince sadece gönderim zamanlarında data gönderir veya alır ama bitrate'leri uymuyorsa error counter saymaya başlar.
mcp2515'li devre eğer 100kbit haricinde haberleşiyorsa stm32 ve mcp2515 içindeki error counter sürekli artar, belirli sayıları aştığında bus light, bus heavy ve bus off durumları oluşur bu nedenle bitrate ayarı kritiktir.
Ben CCS C'den anlamam verdiğin source code içerinde tanımlı olması gereken tanımlamaları vereyim
Mc2515 : 16mhz'de çalışıyorsa!!!!, 100kbit için aşağıdaki değerleri kullanabilirsin
CAN_BRG_PROPAGATION_TIME =1tq
CAN_BRG_PHASE_SEGMENT_1 = 8tq
CAN_BRG_SEG_2_PHASE_TS = 6tq
CAN_BRG_SYNCH_JUMP_WIDTH = 1tq
Hocam yok haberleşmeyi sağlayamadım. Biraz Canımı sıkacak bu konu. Değerleri o şekilde yapınca yine STM veri göndermeyi kesiyor. Ne yapacam bilmiyorum.
Şuandaki hedefim tek yönlü haberleşmeyi sağlamak. Yani şimdilik STM'den sabit sizin verdiğiniz 100Kbit init kodlarıyla sürekli Veri basıyorum. Tek Hedefim karşı tarafta Mesaj geldi kesmesini oluşturmak. Acaba tam tersinimi yapayım. MCP'den sabit data yollayıp STM'de kesme oluşturmaya çalışayım. Emin değilim.
Hocam CAN Baudrate nasıl hesaplanır derken microchip'in bir toolunu buldum.
http://www.intrepidcs.com/support/mbtime.htm (http://www.intrepidcs.com/support/mbtime.htm)
MCP2515 için doğrudan Register değerlerini açıklamalı olarak veriyor.
Bu programla aldığım değerleri birde deniyeyim. Sonucu Tekrardan yazarım.
İlginiz için teşekkürler.
mesaj birleştirme:: 14 Ağustos 2014, 01:05:10
Evet Denedim
Bahsetiğim o Programın 16Mhz osilatör ve 100KBit için verdiği çıktı şöyle.
(http://s8.postimg.cc/60safiqc1/Ekran_Al_nt_s.jpg) (http://postimg.cc/image/60safiqc1/)
Bu program sayesinde Bit Timing olayını biraz anladım. Ama PHASE_SEGMENT gibi değerleri teker teker girmemek için CNF1, CNF2 ve CNF3 registerlerine doğrudan programın verdiği Hex değerleri yazdım.
mcp2510_write(CNF1, 0x03);
mcp2510_write(CNF2, 0xBA);
mcp2510_write(CNF3, 0x07);
Sonuç olarak scop ile STM32'nin CAN_TX pinine Baktığımda bir önceki mesajımdaki 2. Resmi görüyorum. Yani eğer sizin yorumladığınız gibiyse hala baudrateler uyuşmayıp error counter artıyor.
Hocam Şemada bir problem olacağını sanmıyorum. STM32 tarafında deney kitinde çalışıyorum. STM32'nin PB8 ve PB9 pinleri doğrudan SN65HVD230'a bağlı.
MCP2515 tarafında ise seed studionun Arduino için üretmiş olduğu can bus shield'ini kullanıyorum
http://www.seeedstudio.com/wiki/CAN-BUS_Shield (http://www.seeedstudio.com/wiki/CAN-BUS_Shield)
MCP2515'in haberleşme bacaklarını yine başka bir deney kitinde bulunan Pic18F886'ya bağladım. Bunun yazılımıyla oynuyorum.
Donanım kabaca böyle. Bağlantılarıda 3-4 defa kontrol ettim. STM32'den gelen veri MCP2515'in CAN_RX pinine ulaşıyor. Bunu scop ile görebiliyorum.
Daha önce Can-Bus ile uğraşmış arkadaşların problem hakkında fikir ve önerilerini almak isterim.
@CLR Hocam ne yapmamı tavsiye edersiniz?
Konu güncel arkadaşlar. Konuyla ilgili çözüm önerilerisi bekliyorum.
@Mucit23
Aslında bu sorun komplex bir sorun değil, çözmeni beklerdim ama mesajlarından telaşlanmış gibi görünüyorsun. Çözüm yollarını söylüyeyim, sen hangisini beğenirsen uygula.
1) Logic analyzer'in yoksa scop ile mcp2515'in çıkışındaki sinyalin bit genişliğine bakıp bitrate'ni hesaplayacaksın veya varsa zaten o hesaplıyor.
2) Ayrıca ikinci bir stm32 module varsa onuda kullanabilirsin. Aynı değerleri atarsan aynı bitrate'e sahip olur.
3) Aynı RS485'teki gibi karşıdaki transceiver'in RX ve TX pinlerini birbirine bağlasan stm32 kendine yayın yapar.
4) Veya daha kolayı stm32 tek başına şöyle deneye bilirsin loopback modunda çalıştıracaksın bu durumda kendi kendine yayın yapacak. Hem data almasından hemde göndermesinden emin olursun. Normal modda değil loopback modda çalıştır. Loopback modunda STM'nin tx pini içeriden rx pinine bağlanır.
Anladım hocam. Bu hafta sonuna kadar ilk haberlesmemi yapsam benim için çok iyi olacak. Stm32 ve Mcp2515de bit timing ayarlarını öğrendim sayılır. Birde 125kbit de deneme yapmayı düşünüyorum.
Ben biraz stm32 üzerinde çalışacağım. Loopback modunda birkac test yapayım. Lojik analyserimda var. Bu akşam bu işi çözmeyi hedefliyorum. Sanırım stm32 loopback modunda kendi gönderdiğim mesajla kendi kendine mesaj geldi kesmesi oluşturur herhalde. Bunu stm32 ile yapabilirsem aynısını mcp2515 ile yapacam. Sonrasında zaten baudrateler uyuyorsa haberleşmeyi sağlarım.
mesaj birleştirme:: 14 Ağustos 2014, 13:04:09
Anladım hocam. Bu hafta sonuna kadar ilk haberlesmemi yapsam benim için çok iyi olacak. Stm32 ve Mcp2515de bit timing ayarlarını öğrendim sayılır. Birde 125kbit de deneme yapmayı düşünüyorum.
Ben biraz stm32 üzerinde çalışacağım. Loopback modunda birkac test yapayım. Lojik analyserimda var. Bu akşam bu işi çözmeyi hedefliyorum. Sanırım stm32 loopback modunda kendi gönderdiğim mesajla kendi kendine mesaj geldi kesmesi oluşturur herhalde. Bunu stm32 ile yapabilirsem aynısını mcp2515 ile yapacam. Sonrasında zaten baudrateler uyuyorsa haberleşmeyi sağlarım.
Hocam iki gündür STM32ile uğraşıyorum. LoopBack Modunda denemeler yapıyorum.
Şuanda interrupt olmadan LoopBack modunda Mesaj gönderip alabiliyorum. Ama interrupt'u aktif ettiğim zaman ( CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE);) STM32 Mesaj gönderme aşamasında takılıp kalıyor. (CAN_Transmit(CAN1,&TxMessage))
Kesme vektörünü Nvic Ayarlarını felan defalarca kontrol ettim. Bir türlü anlam veremedim. Sizin başınıza böyle birşey geldimi?
Açıkçası loopback modunda interruptı açıp açmadığımı hatırlamıyorum,
2007'de ilk kez can bus ile uğraşırken loopback kullandım. Sonra bir daha gerek kalmadı.
Ama mantıken loopback modunda da interrupt kullanabiliyor olman lazım.
Hocam deney kartımın örnek programı var. Onda çalışıyor aslında. Fakat Kodlar ST'nin Eski Firmwaresine göre yazılmış. Bendeki daha güncel.
Aradaki tek fark Firmware güncellemesinden kaynaklanan değişiklikler....
Örnek programdaki uygulamayı olduğu gibi kendi programıma import etmeye çalışacağım. Birde böyle deniyeyim. Kesinlikle interrupt oluşması lazım.
mesaj birleştirme:: 16 Ağustos 2014, 13:04:40
Ben bu işi çözeceğim ama çözene kadar ağzımdan emdiğim süt burnumdan gelecek. >:(
Hocam yok benim bu mcu'da birşeyler var benimle oyun oynuyor resmen. Interruptları aktif ettiğimde Data gönderiken program donuyor....
LoopBack Modunda interrupta çalışıyor çünkü deney kitimin örnek programında interupt kullanılıyor.
Aynı programı benim kendi programıma import ettiğimde çalışmıyor. Şu zincirleri bir kırabilsem herşey yerli yerine oturacak. >:(
Yedeklerime baktım, evet loopback modunda Rx ve Tx interrupt birlikte kullanmışım, aşağıdaki gibi ama ben ST library'yi kullanmadım o zaman kendim bir library hazırlamıştım. Gerçi halada mix olarak kullanıyorum.
Ayrıca ben hem loopback hemde silent modunu kullanmışım yani tx pininden sinyal çıkışı yok, herşey içeride gerçekleşiyor
void
Can_Testmodu(void){
can_btr.bits.SILM=1; // silent modu
can_btr.bits.LBKM=1; // loopback modu
}
// tx interrup
void
USB_HP_CAN_TX_IRQHandler(void) {
if(can_tsr.bits.RQCP0){
can_tsr.bits.RQCP0=1; // 1 yapılarak clear edilir
can_ier.bits.TMEIE=0; // interrupt clear
Can_Flags.TxReady=1;
}
}
// rx interrupt, USB_LP_CAN_RX0_IRQHandler
void
USB_LP_CAN_RX0_IRQHandler(void) {
if(can_rf0r.bits.FMP0) { // data gelmiş mi?
Can_Msg_Rd(&Can_Rx_Msg);
Can_Flags.RxReady=1;
}
}
Hocam bilmiyorum. ST'nin kütüphanesindede problem olabilir.
Aşağıdaki kod çalışınca Program kafayı yiyor.
CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
ST foruma mesaj attım. Bakalım oradan ne cevap gelecek. Birde STD lib kullanılmadan keilin kendi CANBUS kodları var. Onlarıda denemeyi düşünüyorum.
Biraz ara vereyim. Sakin kafayla tekrardan bakacağım.
STM32 can modulü ilgili olarak ile hemde kendi kütüphanemi, hem keilinkini hemde ST libi kullandım, hepsi sorunsuz çalışıyor. Şimdiki can projelerimi ST V3.5 ile yapıyorum yani problemlem yok, kütüphane otuşmuş ve kütüphanede hata olacağını sanmıyorum.
Hocam anlamadığım şey neden kesmeyi açınca program çalışmaz hale geliyor. Ne oluyor anlamıyorum bir türlü.
Kesme için Nvic ayarları gibi birçok ayarı yapıyorum.
Siz olsaydınız boyle bir sorunu çözmek için ne yapardınız? Elinizde StdLib kullanilarak yapılmış örnek uygulama varmı?
Can ile 10 kadar proje yaptım , bir kısmı çalıştığım firmalar için yaptığım projeler, geri kalan kısmı freelance olarak sözleşmeli proje yaptığım firmaların ticari projeleri.
Ama sana şöyle yardımcı olabilirim, Projende, varsa şirketine veya sana özel kısımlarını silip içinde sadece CAN projesi kalacak ve compile edilecek şekilde projeni bir yere upload edersen yardımcı olmaya çalışırım. Şematiğinde sadece can pinlerinin ve driver'ının olduğu yapıyı görsel olarak eklemen lazım.
OK ise Linki ister buraya yükle istersen bana özel mesaj atabilirsin.
Tamam hocam ilginiz teşekkür ederim
şuan programın ticari bir niteliği yok. Çalışmalarımı deney kiti uzerinde yapıyorum.
Can bus ile ilgili kodlarda çok karmaşık. Akşam onları biraz duzenleyeyim 2-3 saate proje dosyasını yüklerim.
Hocam selamlar.
Hocam benim program çok karmaşık. Bu yüzden sıfırdan bir template proje oluşturdum ve kullandığım Grafik LCD kütüphanemi Donanım kütüphanelerimi ve yazdığım CAN kütüphanemi ekledim.
Aşağıdaki deney kitini kullanıyorum
http://www.ebay.com/itm/FireBull-STM32F103VET6-development-board-with-MP3-3-2-TFT-Touch-/111429533076?pt=Art_Prints&hash=item19f1b7bd94 (http://www.ebay.com/itm/FireBull-STM32F103VET6-development-board-with-MP3-3-2-TFT-Touch-/111429533076?pt=Art_Prints&hash=item19f1b7bd94)
Yazdığım Template programı hemen yukarıdaki kartta deneyebilirim. LCD felan çalışıyor zaten denedim. Ama CAN'daki durum aynı.
Devre Şemasınıda dosyalara ekledim.
https://www.dropbox.com/s/71g1qo2goh9qcnf/STM32F103_Can_Test.rar (https://www.dropbox.com/s/71g1qo2goh9qcnf/STM32F103_Can_Test.rar)
Tekrardan teşekkür ederim. Bende biraz örnek programlara bakayım. Umarım farklı birşeyler görürüm.
Arkadaşlar bu konu keil debuggeri ile çözülebilir diye tahmin ediyorum. Ben programı debug ile iyi takip edemiyorum. Debug Konusunda bilgisi olan arkadaşların yardımına ihtiyacım var.
Ben birkaç test yaptım.
İlk önce programın nerde donduğunu söyleyeyim.
ErrorStatus CanSendMessage(uint32_t CanTxId, uint8_t CanTxBufSize, uint8_t* CanTxData)
{
CanTxMsg TxMessage;
uint8_t i=0,CanTxMailbox=0,TimeOut=0;
/* transmit */
TxMessage.StdId = CanTxId;
TxMessage.RTR = CAN_RTR_DATA;
TxMessage.IDE = CAN_ID_STD;
TxMessage.DLC = CanTxBufSize;
for(i=0;i<CanTxBufSize;i++)
{
TxMessage.Data[i]=CanTxData[i];
}
CanTxMailbox=CAN_Transmit(CAN1,&TxMessage); //Mesaj Gönderiliyor
TimeOut = 0;
while((CAN_TransmitStatus(CAN1,CanTxMailbox) != CANTXOK))
{
GPIO_SetBits(GPIOD,LED1);
TimeOut++;
if(TimeOut==255)return ERROR;
}
return SUCCESS;
}
Mesaj Gönderme fonksiyonum budur. While Döngüsünün içerisindeki GPIO_SetBits fonksiyonu hiç çalışmıyor.
keilde aşağıdaki kodun yanına breakpoint koyuyorum
while((CAN_TransmitStatus(CAN1,CanTxMailbox) != CANTXOK))
Sonra Debug moduna girip "Run" Tuşuna basıyorum program hemen benim break point koyduğum noktaya geliyor. Ardında "Step Over" tuşuna basıyorum ve Debugdaki step,step_over ve step out gibi butonlar pasif oluyor. Sonrasında Stop tuşuna basıyorum ve işlenen kodu gösteren imleç aşağıdaki startup dosyasında kesme vektörlerinin tanıltıldığı yerde bir yere geliyor.
Aşağıdaki resimden bakabilirsiniz.
(http://s4.postimg.cc/bx6a6r7gp/Ekran_Al_nt_s.jpg) (http://postimg.cc/image/bx6a6r7gp/)
Acaba Kesme vektörleriyle ilgili bir sorun olabilirmi diye düşünmeden edemiyorum. Çünkü Debugda yanlış anlamadıysam eğer CAN_TransmitStatus fonksiyonunda CANTXOK cevabı geliyor. Program while döngüsündeki kodları hiç çalıştırmıyor. Bu sırada interrupt geliyor ve program bilinmeyen boşluklara dalıyor.
Benim Startup dosyamda sıkıntı olabilir.
Debug'dan anlayan arkadaşlar bu durumu nasıl yorumlayabiliriz. Gerçekten vektörel bir problem olabilirmi?
Edit:
Kullandığım startup_stm32f10x_hd.s dosyasının içeriği
;******************** (C) COPYRIGHT 2011 STMicroelectronics ********************
;* File Name : startup_stm32f10x_hd.s
;* Author : MCD Application Team
;* Version : V3.5.0
;* Date : 11-March-2011
;* Description : STM32F10x High Density Devices vector table for MDK-ARM
;* toolchain.
;* This module performs:
;* - Set the initial SP
;* - Set the initial PC == Reset_Handler
;* - Set the vector table entries with the exceptions ISR address
;* - Configure the clock system and also configure the external
;* SRAM mounted on STM3210E-EVAL board to be used as data
;* memory (optional, to be enabled by user)
;* - Branches to __main in the C library (which eventually
;* calls main()).
;* After Reset the CortexM3 processor is in Thread mode,
;* priority is Privileged, and the Stack is set to Main.
;* <<< Use Configuration Wizard in Context Menu >>>
;*******************************************************************************
; THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
; WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
; AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
; INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
; CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
; INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
;*******************************************************************************
; Amount of memory (in bytes) allocated for Stack
; Tailor this value to your application needs
; <h> Stack Configuration
; <o> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>
Stack_Size EQU 0x00000400
AREA STACK, NOINIT, READWRITE, ALIGN=3
Stack_Mem SPACE Stack_Size
__initial_sp
; <h> Heap Configuration
; <o> Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>
Heap_Size EQU 0x00000200
AREA HEAP, NOINIT, READWRITE, ALIGN=3
__heap_base
Heap_Mem SPACE Heap_Size
__heap_limit
PRESERVE8
THUMB
; Vector Table Mapped to Address 0 at Reset
AREA RESET, DATA, READONLY
EXPORT __Vectors
EXPORT __Vectors_End
EXPORT __Vectors_Size
__Vectors DCD __initial_sp ; Top of Stack
DCD Reset_Handler ; Reset Handler
DCD NMI_Handler ; NMI Handler
DCD HardFault_Handler ; Hard Fault Handler
DCD MemManage_Handler ; MPU Fault Handler
DCD BusFault_Handler ; Bus Fault Handler
DCD UsageFault_Handler ; Usage Fault Handler
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD 0 ; Reserved
DCD SVC_Handler ; SVCall Handler
DCD DebugMon_Handler ; Debug Monitor Handler
DCD 0 ; Reserved
DCD PendSV_Handler ; PendSV Handler
DCD SysTick_Handler ; SysTick Handler
; External Interrupts
DCD WWDG_IRQHandler ; Window Watchdog
DCD PVD_IRQHandler ; PVD through EXTI Line detect
DCD TAMPER_IRQHandler ; Tamper
DCD RTC_IRQHandler ; RTC
DCD FLASH_IRQHandler ; Flash
DCD RCC_IRQHandler ; RCC
DCD EXTI0_IRQHandler ; EXTI Line 0
DCD EXTI1_IRQHandler ; EXTI Line 1
DCD EXTI2_IRQHandler ; EXTI Line 2
DCD EXTI3_IRQHandler ; EXTI Line 3
DCD EXTI4_IRQHandler ; EXTI Line 4
DCD DMA1_Channel1_IRQHandler ; DMA1 Channel 1
DCD DMA1_Channel2_IRQHandler ; DMA1 Channel 2
DCD DMA1_Channel3_IRQHandler ; DMA1 Channel 3
DCD DMA1_Channel4_IRQHandler ; DMA1 Channel 4
DCD DMA1_Channel5_IRQHandler ; DMA1 Channel 5
DCD DMA1_Channel6_IRQHandler ; DMA1 Channel 6
DCD DMA1_Channel7_IRQHandler ; DMA1 Channel 7
DCD ADC1_2_IRQHandler ; ADC1 & ADC2
DCD USB_HP_CAN1_TX_IRQHandler ; USB High Priority or CAN1 TX
DCD USB_LP_CAN1_RX0_IRQHandler ; USB Low Priority or CAN1 RX0
DCD CAN1_RX1_IRQHandler ; CAN1 RX1
DCD CAN1_SCE_IRQHandler ; CAN1 SCE
DCD EXTI9_5_IRQHandler ; EXTI Line 9..5
DCD TIM1_BRK_IRQHandler ; TIM1 Break
DCD TIM1_UP_IRQHandler ; TIM1 Update
DCD TIM1_TRG_COM_IRQHandler ; TIM1 Trigger and Commutation
DCD TIM1_CC_IRQHandler ; TIM1 Capture Compare
DCD TIM2_IRQHandler ; TIM2
DCD TIM3_IRQHandler ; TIM3
DCD TIM4_IRQHandler ; TIM4
DCD I2C1_EV_IRQHandler ; I2C1 Event
DCD I2C1_ER_IRQHandler ; I2C1 Error
DCD I2C2_EV_IRQHandler ; I2C2 Event
DCD I2C2_ER_IRQHandler ; I2C2 Error
DCD SPI1_IRQHandler ; SPI1
DCD SPI2_IRQHandler ; SPI2
DCD USART1_IRQHandler ; USART1
DCD USART2_IRQHandler ; USART2
DCD USART3_IRQHandler ; USART3
DCD EXTI15_10_IRQHandler ; EXTI Line 15..10
DCD RTCAlarm_IRQHandler ; RTC Alarm through EXTI Line
DCD USBWakeUp_IRQHandler ; USB Wakeup from suspend
DCD TIM8_BRK_IRQHandler ; TIM8 Break
DCD TIM8_UP_IRQHandler ; TIM8 Update
DCD TIM8_TRG_COM_IRQHandler ; TIM8 Trigger and Commutation
DCD TIM8_CC_IRQHandler ; TIM8 Capture Compare
DCD ADC3_IRQHandler ; ADC3
DCD FSMC_IRQHandler ; FSMC
DCD SDIO_IRQHandler ; SDIO
DCD TIM5_IRQHandler ; TIM5
DCD SPI3_IRQHandler ; SPI3
DCD UART4_IRQHandler ; UART4
DCD UART5_IRQHandler ; UART5
DCD TIM6_IRQHandler ; TIM6
DCD TIM7_IRQHandler ; TIM7
DCD DMA2_Channel1_IRQHandler ; DMA2 Channel1
DCD DMA2_Channel2_IRQHandler ; DMA2 Channel2
DCD DMA2_Channel3_IRQHandler ; DMA2 Channel3
DCD DMA2_Channel4_5_IRQHandler ; DMA2 Channel4 & Channel5
__Vectors_End
__Vectors_Size EQU __Vectors_End - __Vectors
AREA |.text|, CODE, READONLY
; Reset handler
Reset_Handler PROC
EXPORT Reset_Handler [WEAK]
IMPORT __main
IMPORT SystemInit
LDR R0, =SystemInit
BLX R0
LDR R0, =__main
BX R0
ENDP
; Dummy Exception Handlers (infinite loops which can be modified)
NMI_Handler PROC
EXPORT NMI_Handler [WEAK]
B .
ENDP
HardFault_Handler\
PROC
EXPORT HardFault_Handler [WEAK]
B .
ENDP
MemManage_Handler\
PROC
EXPORT MemManage_Handler [WEAK]
B .
ENDP
BusFault_Handler\
PROC
EXPORT BusFault_Handler [WEAK]
B .
ENDP
UsageFault_Handler\
PROC
EXPORT UsageFault_Handler [WEAK]
B .
ENDP
SVC_Handler PROC
EXPORT SVC_Handler [WEAK]
B .
ENDP
DebugMon_Handler\
PROC
EXPORT DebugMon_Handler [WEAK]
B .
ENDP
PendSV_Handler PROC
EXPORT PendSV_Handler [WEAK]
B .
ENDP
SysTick_Handler PROC
EXPORT SysTick_Handler [WEAK]
B .
ENDP
Default_Handler PROC
EXPORT WWDG_IRQHandler [WEAK]
EXPORT PVD_IRQHandler [WEAK]
EXPORT TAMPER_IRQHandler [WEAK]
EXPORT RTC_IRQHandler [WEAK]
EXPORT FLASH_IRQHandler [WEAK]
EXPORT RCC_IRQHandler [WEAK]
EXPORT EXTI0_IRQHandler [WEAK]
EXPORT EXTI1_IRQHandler [WEAK]
EXPORT EXTI2_IRQHandler [WEAK]
EXPORT EXTI3_IRQHandler [WEAK]
EXPORT EXTI4_IRQHandler [WEAK]
EXPORT DMA1_Channel1_IRQHandler [WEAK]
EXPORT DMA1_Channel2_IRQHandler [WEAK]
EXPORT DMA1_Channel3_IRQHandler [WEAK]
EXPORT DMA1_Channel4_IRQHandler [WEAK]
EXPORT DMA1_Channel5_IRQHandler [WEAK]
EXPORT DMA1_Channel6_IRQHandler [WEAK]
EXPORT DMA1_Channel7_IRQHandler [WEAK]
EXPORT ADC1_2_IRQHandler [WEAK]
EXPORT USB_HP_CAN1_TX_IRQHandler [WEAK]
EXPORT USB_LP_CAN1_RX0_IRQHandler [WEAK]
EXPORT CAN1_RX1_IRQHandler [WEAK]
EXPORT CAN1_SCE_IRQHandler [WEAK]
EXPORT EXTI9_5_IRQHandler [WEAK]
EXPORT TIM1_BRK_IRQHandler [WEAK]
EXPORT TIM1_UP_IRQHandler [WEAK]
EXPORT TIM1_TRG_COM_IRQHandler [WEAK]
EXPORT TIM1_CC_IRQHandler [WEAK]
EXPORT TIM2_IRQHandler [WEAK]
EXPORT TIM3_IRQHandler [WEAK]
EXPORT TIM4_IRQHandler [WEAK]
EXPORT I2C1_EV_IRQHandler [WEAK]
EXPORT I2C1_ER_IRQHandler [WEAK]
EXPORT I2C2_EV_IRQHandler [WEAK]
EXPORT I2C2_ER_IRQHandler [WEAK]
EXPORT SPI1_IRQHandler [WEAK]
EXPORT SPI2_IRQHandler [WEAK]
EXPORT USART1_IRQHandler [WEAK]
EXPORT USART2_IRQHandler [WEAK]
EXPORT USART3_IRQHandler [WEAK]
EXPORT EXTI15_10_IRQHandler [WEAK]
EXPORT RTCAlarm_IRQHandler [WEAK]
EXPORT USBWakeUp_IRQHandler [WEAK]
EXPORT TIM8_BRK_IRQHandler [WEAK]
EXPORT TIM8_UP_IRQHandler [WEAK]
EXPORT TIM8_TRG_COM_IRQHandler [WEAK]
EXPORT TIM8_CC_IRQHandler [WEAK]
EXPORT ADC3_IRQHandler [WEAK]
EXPORT FSMC_IRQHandler [WEAK]
EXPORT SDIO_IRQHandler [WEAK]
EXPORT TIM5_IRQHandler [WEAK]
EXPORT SPI3_IRQHandler [WEAK]
EXPORT UART4_IRQHandler [WEAK]
EXPORT UART5_IRQHandler [WEAK]
EXPORT TIM6_IRQHandler [WEAK]
EXPORT TIM7_IRQHandler [WEAK]
EXPORT DMA2_Channel1_IRQHandler [WEAK]
EXPORT DMA2_Channel2_IRQHandler [WEAK]
EXPORT DMA2_Channel3_IRQHandler [WEAK]
EXPORT DMA2_Channel4_5_IRQHandler [WEAK]
WWDG_IRQHandler
PVD_IRQHandler
TAMPER_IRQHandler
RTC_IRQHandler
FLASH_IRQHandler
RCC_IRQHandler
EXTI0_IRQHandler
EXTI1_IRQHandler
EXTI2_IRQHandler
EXTI3_IRQHandler
EXTI4_IRQHandler
DMA1_Channel1_IRQHandler
DMA1_Channel2_IRQHandler
DMA1_Channel3_IRQHandler
DMA1_Channel4_IRQHandler
DMA1_Channel5_IRQHandler
DMA1_Channel6_IRQHandler
DMA1_Channel7_IRQHandler
ADC1_2_IRQHandler
USB_HP_CAN1_TX_IRQHandler
USB_LP_CAN1_RX0_IRQHandler
CAN1_RX1_IRQHandler
CAN1_SCE_IRQHandler
EXTI9_5_IRQHandler
TIM1_BRK_IRQHandler
TIM1_UP_IRQHandler
TIM1_TRG_COM_IRQHandler
TIM1_CC_IRQHandler
TIM2_IRQHandler
TIM3_IRQHandler
TIM4_IRQHandler
I2C1_EV_IRQHandler
I2C1_ER_IRQHandler
I2C2_EV_IRQHandler
I2C2_ER_IRQHandler
SPI1_IRQHandler
SPI2_IRQHandler
USART1_IRQHandler
USART2_IRQHandler
USART3_IRQHandler
EXTI15_10_IRQHandler
RTCAlarm_IRQHandler
USBWakeUp_IRQHandler
TIM8_BRK_IRQHandler
TIM8_UP_IRQHandler
TIM8_TRG_COM_IRQHandler
TIM8_CC_IRQHandler
ADC3_IRQHandler
FSMC_IRQHandler
SDIO_IRQHandler
TIM5_IRQHandler
SPI3_IRQHandler
UART4_IRQHandler
UART5_IRQHandler
TIM6_IRQHandler
TIM7_IRQHandler
DMA2_Channel1_IRQHandler
DMA2_Channel2_IRQHandler
DMA2_Channel3_IRQHandler
DMA2_Channel4_5_IRQHandler
B .
ENDP
ALIGN
;*******************************************************************************
; User Stack and Heap initialization
;*******************************************************************************
IF :DEF:__MICROLIB
EXPORT __initial_sp
EXPORT __heap_base
EXPORT __heap_limit
ELSE
IMPORT __use_two_region_memory
EXPORT __user_initial_stackheap
__user_initial_stackheap
LDR R0, = Heap_Mem
LDR R1, =(Stack_Mem + Stack_Size)
LDR R2, = (Heap_Mem + Heap_Size)
LDR R3, = Stack_Mem
BX LR
ALIGN
ENDIF
END
;******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE*****
Merhaba
Az önce programını indirdim, debug yaparken baktım ki interrupta gitmek istiyor ama interrupt vector adresini bulamıyor ve sonsuz döngüye giriyor.
Keilin startup dosyasını ekleyince çalıştı. ST'nin startup dosyasını kullanma.
@Mucit23
Neoldu hala çalıştıramadın mı? Bir cevap gelmedi senden?
Hocam kusura bakmayın. Dün akşam keilin startup dosyasiyla bir deneme yaptım ama yine çalışmadı. Debugda durum aynı. Fakat ayrıntılı test yapamadım. Şuanda zaten şehir dışına çıktım hafta sonuna kadar dönmeyeceğim. Artık ozaman bakmayı düşünüyorum.
İlginiz için çok teşekkür ederim.
Aynı development boarddan bende de var, ilk testte senin start-up'ta kitlendi, debug yapınca interrupt adresini bulamıyordu ve start-up içinde interrupt adreslerinin sonunda kitlenip kalıyordu.
Sonra keilin startup dosyasını aldım kopyaladım çalıştı, can interface çalışınca ekrana success yazdı. 5dk kadar test yaptım her defasında başarılı oldu.
Neyse kolay gelsin,
Hocam ben memlekete dönünce tekrardan ayrıntılı bir şekilde bakacağım. Büyük ihtimal çözerim artık. Teşekkür ederim.
Hocam memlekete tekrardan döndüm. Şimdi yine Canbus üzerinde çalışmalara başladım. Kaldığım yerden devam ediyorum. En son startup dosyasında problem vardı. Ben keil içerisindeki Startup dosyasını kullandım ama değişen birşey olmadı. Sorun aynı şekilde devam ediyor.
Mümkünse eğer kendi kullandığınız startup dosyasını verebilirmisiniz, veya vakit kaybetmemek adına template projeyi gönderebilirmisiniz.
mesaj birleştirme:: 25 Ağustos 2014, 14:10:50
CLR Hocam teşekkürler.
Çözdüm problemi. Şuanda LoopBack Modunda veri gönderip alabildim. Kesme oluştu.
Sorun şuradaymış. Çok ufak bir hata, Startup dosyasını incelerken Vektör tanımlamaları USB_LP_CAN1_RX0_IRQHandler şeklinde verilmiş.
Benim İnterrupt fonksiyonlarım ise USB_LP_CAN_RX0_IRQHandler şeklinde tanımlanmıştı. Bunları düzelttim LoopBack modunda data gönderip aldım.
Artık STM32'nin çalıştığını söyleyebilirim. Şimdi hızımı almışken Baudrateleri ayarlayıp MCP ile haberleşmeye çalışayım.
Hocam STM32'yi normal moda aldım. MCP2515'den 100ms aralıklarla mesaj gönderiyorum. Amacım STM32'de mesaj geldi interrupt'u oluşturmak. STM32 sadece gelen mesajları dinliyor.
Baudrateleri Microchip'in Can Bit Timing Calculator denen bir programıyla ayarlıyorum. Linki aşağıdadır.
http://www.intrepidcs.com/support/mbtime.htm (http://www.intrepidcs.com/support/mbtime.htm)
Mümkünse eğer programı sizde bir inceleyin. Eğer doğru değerler veriyorsa eğer çok işlevsel olduğunu söyleyebilirim.
Bu program MCP2515'için doğrudan register değerlerini veriyor. STM32 için OSC frekansını 36Mhz Yapıp verdiği değerlerden Propagation Delay ile Phase Segment1 değerlerini toplayıp BS1'e, Phase Segment2 değerini BS2'ye, Syncro Jump With değerini ise SJW ye yazıyorum. Prescalleri Programın verdiği değer ile değiştiriyorum. Şimdilik ayarları bu şekilde yapıyorum. Örneğin 125KBit için STM32 de aşağıdaki değerleri kullandım.
CAN_InitStructure.CAN_SJW=CAN_SJW_1tq;
CAN_InitStructure.CAN_BS1=CAN_BS1_15tq;
CAN_InitStructure.CAN_BS2=CAN_BS2_8tq;
CAN_InitStructure.CAN_Prescaler=5;
Dediğim gibi LoopBack'de sıkıntı yok. Fakat MCP2515'den gönderdiğim mesajları almıyor. STM32'nin Can RX pininde çok yoğun bir data akışı oluyor(Skop ile bakıyorum)
Hocam elimde lojik analyser ile osiloskop var. Baudrate uyumsuzluğunu nasıl anlarım? Yada başka bir sorunmu var acaba? Artık STM32'dense MCP2515 tarafı beni daha çok endişendiriyor. Fikriniz nedir acaba
Merhaba yazınızı okumuştum ama STM hakkında çok bilğim olmadığı için yalnış yönlendirme yapar ve sizi daha çok uğraştırırım diye yazmamıştım.
Hocam böyle durumlarda ben canbus analyzer kullanıyorum. Hiç bilmediğim bir nodu bağlıyorum hızını gönderdiği dataları okuyup algoritma olusturuyordum. Böylece gönderdiğini yada hızının umdugum degerler olup olmadığını görüyorum.
Denetleyici tarafında Microchip Canbus24 ve Canbus18 kullandım. Can hatıında iki node oluşturdum. ikisini birbirine bağladım çalışmadı. Can analayzer ile baktım ikiside ayrı ayrı çalışıyor. Ama hızları farklı olmuş. Halbuki Can Bit Timing Calculator programı ile hesaplayıp değerleri girmiştim. Sonuçta Şunu gördüm. Canbus24 de Can Bit Timing Calculator programındaki değerleri girince 2 ile çarpıyordu. Yani biri diğerinin ikikat hızlı idi. Analayzer olmasa idi kütüphane dosyalarının içinde kaybolacaktım.
Piyasa da bir çok analyzer var. Ben bunu kullanıyorum. http://www.microchip.com/Developmenttools/ProductDetails.aspx?PartNO=APGDT002 (http://www.microchip.com/Developmenttools/ProductDetails.aspx?PartNO=APGDT002) Kaynak kodlarını da veriyorlar. Kullanımı kolay iki yıla yakın kullanıyorum bir sorun çıkmadı. Burda da tanıtımı Microchip CAN BUS Analyzer Demonstration (http://www.youtube.com/watch?v=WfSZdWHiM9k#ws)
Saygılarımla.
@Mucit23
logic analyzer varsa bitin yükselen ve düşen kenar arasındaki veya tersi süreyi ölç mesela 10us ise 1/10us ile bitrate'ini bulursun bu kadar basit. Ayrıca logic analyzer üzerinde can logger var direk bitrate'i tespit ediyormuydu hiç bakmadım, yoksa bulduğun bitrate ayarla gönderdiğin veriyi logic analyzer üzerinde alıyorsan bu işi doğru yapmışsındır. Bu işi scop ilede yapabilirsin.
@Kerim42
Microchipin 16bit serisinde instruction clock, fosc/2'dir pic 18'de ise fosc/4 aradaki fark buradan kaynaklanıyor.
Hocam sorunu çözdüm sayılır.
Dediğiniz gibi lojik analyser ile bakınca hemen baudratelerin farklı olduğunu anladım. Ben microchip'in hesaplama programıyla aldığım değerleri STM32'ye girmiştim. 125Kbit için ayarladığımı sanıyordum ama aslında STM32 300Kbit ile haberleşiyormuş. Fakat MCP2515 tam ayarladığım gibi 125Kbit ile haberleşiyordu. İletişim problemi bu hız farklılığından kaynaklanıyormuş.
Saleae nin logic analyseri bu farkı görmemde çok işime yaradı.
Şimdi haberleşme hızını 250Kbit'e ayarladım. STM32 tarafında bir sıkıntı yok görünüyor. İnterrupt felan oluşuyor. Gelen dataları alabiliyorum.
Lojik analyser'in Can Yorumlayıcısını açıyorum gelen giden bütün dataları gösteriyor. Gerçekten iyiymiş.
(http://s12.postimg.cc/ssvbibn5l/Ekran_Al_nt_s.jpg) (http://postimg.cc/image/ssvbibn5l/)
Anlamadığım birkaç şey kaldı
Lojik analyserda dikkat ederseniz Benim STM32'den gönderdiğim data Hem CANTX de hemde CANRX de görünüyor. Bunun sebebi nedir? Can Controlleri normal modda çalıştırıyorum. Halbuki MCP den gelen datalar sadece CANRX de görünüyor.
Tek bir sorun kaldı, oda benim stm32 ile gönderdiğim datalar STM 32 tarafında karşıya başarılı bir şekilde iletilmiş olarak görünsede mcp tarafında herhangi bir hareketlenme olmuyor. MCP2515 için can_kbhit fonksiyonu var. Bu fonksiyon 1 ile dönerse mesaj gelmiş diyoruz ama bir türlü mesaj geldiğini göremedim. Bunuda halledersem problem kalmayacak.