STM32F0 - symulacja model skrzyżowania

olek623 · Grudzień 3, 2016

Witam, próbuję wykonać projekt z mikroprocesorów, który polega na wykonaniu modelu skrzyżowania. Przewiduje on komunikację z USART oraz obsługę przycisków przy przejściach. W chwili obecnej stoję przy zapalaniu kolejno poszczególnych led-ów za pomocą timera. Udało mi się wykonać to, ale za pomocą systick/delay. Niestety ta metoda oczywiście jest nie do przyjęcia, więc postanowiłem wykorzystać timer. Nie wiem czy dobrze rozumiem, ale timer pracuje sobie jakby "w tle" i odlicza, czy w s lub ms kołowo (w zależności oczywiście jak jest skonfigurowany). Ja zaś na if-ach w while sprawdzam w którym jest momencie i w odpowiednim wykonuje instrukcje. Niestety led-y się zapalają, ale nie tak jak powinny. Proszę o pomoc w rozwiązaniu problemu z góry dziękuję.

kod:

#include <stm32f0xx_tim.h>
#include <stm32f0xx_rcc.h>
#include "stm32f0xx.h"
#include "stm32f0xx_gpio.h"

#include "stm32f0xx_misc.h"


#define czerwone GPIOA
#define zolte GPIOB
#define zielone GPIOC

#define SYG1 GPIO_Pin_1
#define SYG2 GPIO_Pin_2
#define SYG3 GPIO_Pin_3
#define SYG4 GPIO_Pin_4
#define SYG5 GPIO_Pin_5
#define SYG6 GPIO_Pin_6
#define SYG7 GPIO_Pin_7
#define SYG8 GPIO_Pin_8
#define SYG9 GPIO_Pin_9
#define SYG10 GPIO_Pin_10
#define SYG11 GPIO_Pin_11
#define SYG12 GPIO_Pin_12

uint32_t time;


void Timer()
{
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);

   TIM_TimeBaseInitTypeDef timerInitStructure;
   timerInitStructure.TIM_Prescaler = 48000;
   timerInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
   timerInitStructure.TIM_Period = 16000;
   timerInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
   timerInitStructure.TIM_RepetitionCounter = 0;
   TIM_TimeBaseInit(TIM1, &timerInitStructure);

   TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE);
   TIM_Cmd(TIM1, ENABLE);
}



void delayinit(void)
{
SystemInit();
SystemCoreClockUpdate();
SysTick_Config(SystemCoreClock/1000);

}

void SysTick_Handler(void) //nazwa jest w bibliotece
{
if (time>0)
{
	time--;
}
}

void delay(uint32_t czas)
{
time=czas;
while (time>0);
}

void LEDPC()
{
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE);
GPIO_InitTypeDef MGPIO;
MGPIO.GPIO_Speed = GPIO_Speed_50MHz;
MGPIO.GPIO_Pin= GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12   ;
MGPIO.GPIO_Mode = GPIO_Mode_OUT;
MGPIO.GPIO_OType = GPIO_OType_PP;;
GPIO_Init(GPIOC,&MGPIO);
}

void LEDPA()
{
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
GPIO_InitTypeDef MGPIO;
MGPIO.GPIO_Speed = GPIO_Speed_50MHz;
MGPIO.GPIO_Pin= GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12   ; ;
MGPIO.GPIO_Mode = GPIO_Mode_OUT;
MGPIO.GPIO_OType = GPIO_OType_PP;;
GPIO_Init(GPIOA,&MGPIO);
}

void LEDPB()
{
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
GPIO_InitTypeDef MGPIO;
MGPIO.GPIO_Speed = GPIO_Speed_50MHz;
MGPIO.GPIO_Pin= GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12   ; ;
MGPIO.GPIO_Mode = GPIO_Mode_OUT;
MGPIO.GPIO_OType = GPIO_OType_PP;;
GPIO_Init(GPIOB,&MGPIO);
}



void SYGNALIZATOR(int a, char numer[],char kolor[])
{
switch (a)
{
	case 1:
	{
		GPIO_SetBits(kolor, numer);
	break;
	}

	case 0:
	{
		GPIO_ResetBits(kolor, numer);
	break;
	}
}


}



int main(void)
{
Timer();
delayinit();
LEDPC();
LEDPA();
LEDPB();




//zapalnie wszytskich czerwonych start
SYGNALIZATOR(1,SYG1,czerwone);
SYGNALIZATOR(1,SYG2,czerwone);
SYGNALIZATOR(1,SYG3,czerwone);
SYGNALIZATOR(1,SYG4,czerwone);
SYGNALIZATOR(1,SYG5,czerwone);
SYGNALIZATOR(1,SYG6,czerwone);
SYGNALIZATOR(1,SYG7,czerwone);
SYGNALIZATOR(1,SYG8,czerwone);
SYGNALIZATOR(1,SYG9,czerwone);
SYGNALIZATOR(1,SYG10,czerwone);
SYGNALIZATOR(1,SYG11,czerwone);
SYGNALIZATOR(1,SYG12,czerwone);
delay(1000);

   while(1)
   {
   	int timerValue = TIM_GetCounter(TIM1);
   	int czas= 500;
   	//gotów dla prosto
   	//żółte dla prosto
   	if ((timerValue == 1000) | (timerValue == 16000))
	SYGNALIZATOR(1,SYG1,zolte);
	SYGNALIZATOR(1,SYG2,zolte);
	SYGNALIZATOR(1,SYG4,zolte);
	SYGNALIZATOR(1,SYG5,zolte);
	//delay(czas);
	if (timerValue == 1000)
	{

	//to dla pętli z poprzedniego cyklu
	//2 zgaszenie zółtego dla lewo
	SYGNALIZATOR(0,SYG9,zolte);
	SYGNALIZATOR(0,SYG12,zolte);
	//2 zapalenie czerwonego dla lewo
	SYGNALIZATOR(1,SYG9,czerwone);
	SYGNALIZATOR(1,SYG12,czerwone);

	//zgaszenie zółtego prosto
	SYGNALIZATOR(0,SYG1,zolte);
	SYGNALIZATOR(0,SYG2,zolte);
	SYGNALIZATOR(0,SYG4,zolte);
	SYGNALIZATOR(0,SYG5,zolte);

	//zgaszenie czerwonego prosto
	SYGNALIZATOR(0,SYG1,czerwone);
	SYGNALIZATOR(0,SYG2,czerwone);
	SYGNALIZATOR(0,SYG4,czerwone);
	SYGNALIZATOR(0,SYG5,czerwone);

	// zapalenie zielonego prosto
	SYGNALIZATOR(1,SYG1,zielone);
	SYGNALIZATOR(1,SYG2,zielone);
	SYGNALIZATOR(1,SYG4,zielone);
	SYGNALIZATOR(1,SYG5,zielone);
	}
	//delay(czas); //jadą prosto i w prawo

	if (timerValue == 4000)
	{
	//zgaszenie zielonego prosto
	SYGNALIZATOR(0,SYG1,zielone);
	SYGNALIZATOR(0,SYG2,zielone);
	SYGNALIZATOR(0,SYG4,zielone);
	SYGNALIZATOR(0,SYG5,zielone);
	//zapalenie zółtego prosto
	SYGNALIZATOR(1,SYG1,zolte);
	SYGNALIZATOR(1,SYG2,zolte);
	SYGNALIZATOR(1,SYG4,zolte);
	SYGNALIZATOR(1,SYG5,zolte);
	//zapalnie żółtego w lewo
	SYGNALIZATOR(1,SYG3,zolte);
	SYGNALIZATOR(1,SYG6,zolte);
	}
	//delay(czas); //lewo-gotów /prosto-żółte

	if (timerValue == 5000)
	{
	//zgaszenie żółtego prosto
	SYGNALIZATOR(0,SYG1,zolte);
	SYGNALIZATOR(0,SYG2,zolte);
	SYGNALIZATOR(0,SYG4,zolte);
	SYGNALIZATOR(0,SYG5,zolte);

	//zgaszenie żółtego i czerwonego lewo
	SYGNALIZATOR(0,SYG3,zolte);
	SYGNALIZATOR(0,SYG6,zolte);
	SYGNALIZATOR(0,SYG3,czerwone);
	SYGNALIZATOR(0,SYG6,czerwone);

	//zpalenie czerwonego prosto
	SYGNALIZATOR(1,SYG1,czerwone);
	SYGNALIZATOR(1,SYG2,czerwone);
	SYGNALIZATOR(1,SYG4,czerwone);
	SYGNALIZATOR(1,SYG5,czerwone);

	//zapalenie zielonego w lewo
	SYGNALIZATOR(1,SYG3,zielone);
	SYGNALIZATOR(1,SYG6,zielone);
	}
	//delay(czas); //jada w lewo

	if (timerValue == 8000)
	{
	//zgaszenie zielonego
	SYGNALIZATOR(0,SYG3,zielone);
	SYGNALIZATOR(0,SYG6,zielone);
	//zapalnie żółtego
	SYGNALIZATOR(1,SYG3,zolte);
	SYGNALIZATOR(1,SYG6,zolte);

//ULICE 2
   			//gotów dla prosto
   			//żółte dla prosto
			SYGNALIZATOR(1,SYG7,zolte);
			SYGNALIZATOR(1,SYG8,zolte);
			SYGNALIZATOR(1,SYG10,zolte);
			SYGNALIZATOR(1,SYG11,zolte);
	}
			//delay(czas);
			if (timerValue == 9000)
			{

			//z poprzedniej tury
			//1 zgaszenie zółtego dla lewo
			SYGNALIZATOR(0,SYG3,zolte);
			SYGNALIZATOR(0,SYG6,zolte);
			//1 zapalenie czerwonego dla lewo
			SYGNALIZATOR(1,SYG3,czerwone);
			SYGNALIZATOR(1,SYG6,czerwone);

			//zgaszenie zółtego prosto
			SYGNALIZATOR(0,SYG7,zolte);
			SYGNALIZATOR(0,SYG8,zolte);
			SYGNALIZATOR(0,SYG10,zolte);
			SYGNALIZATOR(0,SYG11,zolte);

			//zgaszenie czerwonego prosto
			SYGNALIZATOR(0,SYG7,czerwone);
			SYGNALIZATOR(0,SYG8,czerwone);
			SYGNALIZATOR(0,SYG10,czerwone);
			SYGNALIZATOR(0,SYG11,czerwone);

			// zapalenie zielonego prosto
			SYGNALIZATOR(1,SYG7,zielone);
			SYGNALIZATOR(1,SYG8,zielone);
			SYGNALIZATOR(1,SYG10,zielone);
			SYGNALIZATOR(1,SYG11,zielone);
			}
			//delay(czas); //jadą prosto i w prawo

			if (timerValue == 12000)
			{
			//zgaszenie zielonego prosto
			SYGNALIZATOR(0,SYG7,zielone);
			SYGNALIZATOR(0,SYG8,zielone);
			SYGNALIZATOR(0,SYG10,zielone);
			SYGNALIZATOR(0,SYG11,zielone);
			//zapalenie żółtego prosto
			SYGNALIZATOR(1,SYG7,zolte);
			SYGNALIZATOR(1,SYG8,zolte);
			SYGNALIZATOR(1,SYG10,zolte);
			SYGNALIZATOR(1,SYG11,zolte);
			//zapalnie żółtego w lewo
			SYGNALIZATOR(1,SYG9,zolte);
			SYGNALIZATOR(1,SYG12,zolte);
			}
			//delay(czas);//lewo-gotów /prosto-żółte

			if (timerValue == 13000)
			{
			//zgaszenie żółtego prosto
			SYGNALIZATOR(0,SYG7,zolte);
			SYGNALIZATOR(0,SYG8,zolte);
			SYGNALIZATOR(0,SYG10,zolte);
			SYGNALIZATOR(0,SYG11,zolte);

			//zgaszenie żółtego i czerwonego lewo
			SYGNALIZATOR(0,SYG9,zolte);
			SYGNALIZATOR(0,SYG12,zolte);
			SYGNALIZATOR(0,SYG9,czerwone);
			SYGNALIZATOR(0,SYG12,czerwone);

			//zpalenie czerwonego prosto
			SYGNALIZATOR(1,SYG7,czerwone);
			SYGNALIZATOR(1,SYG8,czerwone);
			SYGNALIZATOR(1,SYG10,czerwone);
			SYGNALIZATOR(1,SYG11,czerwone);
			//zapalenie zielonego lewo
			SYGNALIZATOR(1,SYG9,zielone);
			SYGNALIZATOR(1,SYG12,zielone);
			}
			//delay(czas); //jada w lewo

			if (timerValue == 16000)
			{
			//zgaszenie zielonego
			SYGNALIZATOR(0,SYG9,zielone);
			SYGNALIZATOR(0,SYG12,zielone);
			//zapalenie zielonego
			SYGNALIZATOR(1,SYG9,zolte);
			SYGNALIZATOR(1,SYG12,zolte);
			}

   }

}

Chumanista · Grudzień 4, 2016

void LEDPB()
{
   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
   GPIO_InitTypeDef MGPIO;
   MGPIO.GPIO_Speed = GPIO_Speed_50MHz;
   MGPIO.GPIO_Pin= GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12   ; ;
   MGPIO.GPIO_Mode = GPIO_Mode_OUT;
   MGPIO.GPIO_OType = GPIO_OType_PP;;
   GPIO_Init(GPIOB,&MGPIO);
}

Oczekujesz że ktoś tu będzie debugował coś takiego na podstawie opisu:

led-y się zapalają, ale nie tak jak powinny

olek623 · Grudzień 4, 2016

Nie, funkcje LEDPC, PB, PA są funkcjami inicjującymi ledy i działają ok, chodzi mi o sam timer ok 10 linijek kodu + jego użycie w main, czy jest prawidłowe, a nie jest na pewno. W main do zmiennej timerValue przypisuje timera, który nie leci po kolei z wartościami, tylko mam wrażenie randomowych wartości. W tym problem, cała reszta mimo braku komentarzy jest w przypadku bo działa z delay() idelanie.

void Timer()
{
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);

   TIM_TimeBaseInitTypeDef timerInitStructure;
   timerInitStructure.TIM_Prescaler = 48000;
   timerInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
   timerInitStructure.TIM_Period = 16000;
   timerInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
   timerInitStructure.TIM_RepetitionCounter = 0;
   TIM_TimeBaseInit(TIM1, &timerInitStructure);

   TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE);
   TIM_Cmd(TIM1, ENABLE);
}

//------------------------------------------------------------main

   	int timerValue = TIM_GetCounter(TIM1);

if (timerValue == 4000)
	{ //intrukcja, która ma się wykonać jeśli licznik wyniesie 4000tys
	//zgaszenie zielonego prosto
	SYGNALIZATOR(0,SYG1,zielone);
	SYGNALIZATOR(0,SYG2,zielone);

Ogólnie myślałem, że timer będzie liczył od 0 do 16000, z tego 1000 na około sekundę.

Elvis · Grudzień 4, 2016

        if ((timerValue == 1000) | (timerValue == 16000))
       SYGNALIZATOR(1,SYG1,zolte);
       SYGNALIZATOR(1,SYG2,zolte);
       SYGNALIZATOR(1,SYG4,zolte);
       SYGNALIZATOR(1,SYG5,zolte);

Po pierwsze powinno być || zamiast |. Po drugie brakuje { } po warunku - teraz wszystkie linie poza pierwszą wykonują się zawsze.

Produkcja i montaż PCB - wybierz sprawdzone PCBWay!
   • Darmowe płytki dla studentów i projektów non-profit
   • Tylko 5$ za 10 prototypów PCB w 24 godziny
   • Usługa projektowania PCB na zlecenie
   • Montaż PCB od 30$ + bezpłatna dostawa i szablony
   • Darmowe narzędzie do podglądu plików Gerber
Zobacz również » Film z fabryki PCBWay

olek623 · Grudzień 4, 2016

No nie wierzę, co za banał xD już wczoraj ze zmęczenia nie ogarniałem. Bardzo dziękuję, jeszcze chciałem podpytać bo próbowałem w TIM_Prescaler ustawić 48000000 oraz TIM_Period = 16, ja to rozumiem że będzie liczone 1/1sekundę (16 sekund cały cykl), ale chyba się mylę bo nie działa zbytnio?

Elvis · Grudzień 4, 2016

TIM_Prescaler jest wartością 16-bitową, więc ustawianie na więcej niż 65535 raczej niewiele da.

olek623 · Grudzień 4, 2016

ok, teraz rozumiem. Czy jest jakiś jeszcze sposób na miganie ledami? Oprócz wykorzystanego przeze mnie timera lub funkcji delay (systick)?

olek623 · Grudzień 11, 2016

Witam jeszcze raz, mam kolejny mały problem chciałem zrobić przyciski dla przejść. Mój zamysł jest taki, że zrobię funkcję, która będzie sprawdzała czy przycisk został wciśnięty, jeśli tak zmieni zmienną globalną (taką flagę np a=1) i wtedy w odpowiednim cyklu zapali LED za pomocą if. Niestety coś mi nie działa, wrzucę część kodu na przykładowych led, jeśli w tym kodzie mi ktoś pomoże w właściwym już ogarnę (nie chcę wrzucać 400lini)

  #include <stm32f0xx_rcc.h>
#include "stm32f0xx_gpio.h"

void LED()
{

	GPIO_InitTypeDef GPIO_InitStructure;

	  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE);
	  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9;
	  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
	  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
	  GPIO_Init(GPIOC, &GPIO_InitStructure);
}


void PRZYCISK()
{
	GPIO_InitTypeDef MGPIO;

	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOF, ENABLE);
	MGPIO.GPIO_Pin = GPIO_Pin_1;
	MGPIO.GPIO_Mode = GPIO_Mode_IN;
	MGPIO.GPIO_OType = GPIO_OType_PP;
	MGPIO.GPIO_Speed = GPIO_Speed_50MHz;
	MGPIO.GPIO_PuPd = GPIO_PuPd_NOPULL;
	GPIO_Init(GPIOF, &MGPIO);

	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
	MGPIO.GPIO_Pin = GPIO_Pin_0;
	MGPIO.GPIO_Mode = GPIO_Mode_IN;
	MGPIO.GPIO_OType = GPIO_OType_PP;
	MGPIO.GPIO_Speed = GPIO_Speed_50MHz;
	MGPIO.GPIO_PuPd = GPIO_PuPd_NOPULL;
	GPIO_Init(GPIOA, &MGPIO);

}

int a=0;
void PRZEJSCIE()
{
	 if(GPIO_ReadInputDataBit(GPIOF, GPIO_Pin_1))
		 {
			a=1;
		 }
	 if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0))
		 {
			a=0;
		 }

}



int main(void)
{
PRZYCISK();
LED();
   while(1)
   {
   	PRZEJSCIE();
   	if(a==1)
   	{
   		GPIO_SetBits(GPIOC, GPIO_Pin_8);
   		GPIO_ResetBits(GPIOC, GPIO_Pin_9);
   	}
   	else
   	{
   		GPIO_ResetBits(GPIOC, GPIO_Pin_8 );
   		GPIO_SetBits(GPIOC, GPIO_Pin_9);

   	}

   }
}

Przycisk mam podłączony do 3v i do pf1. Spr przycisk na mikro- woltomierzem i właśnie miał blisko 3v stąd ten pomysł. Próbowałem tez na przerwaniach, ale niestety to wgl mi nie wychodziło. Dziękuję z góry za pomoc- jestem trochę zielony z mikro.

[ Dodano: 11-12-2016, 23:15 ]

Na przerwaniach, nie wiem jak użyć nvic. jakiej biblioteki itd.

 
#include <stm32f0xx_rcc.h>
#include "stm32f0xx_gpio.h"
#include "stm32f0xx_conf.h"

static uint8_t LedState = 0;

void EXTI0_1_IRQHandler(void)
{
  if(EXTI_GetITStatus(EXTI_Line0) != RESET)
  {
     LedState ^= 1 << 1;
  }
  EXTI_ClearITPendingBit(EXTI_Line0);
}

int main(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;
  EXTI_InitTypeDef EXTI_InitStruct;
  NVIC_InitTypeDef NVIC_InitStruct;

  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA | RCC_AHBPeriph_GPIOC, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG,ENABLE);

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_Level_1;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
  GPIO_Init(GPIOA,&GPIO_InitStructure);

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_Level_1;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOC,&GPIO_InitStructure);

  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource0);

  EXTI_InitStruct.EXTI_Line = EXTI_Line0;
  EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
  EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising;
  EXTI_InitStruct.EXTI_LineCmd = ENABLE;
  EXTI_Init(&EXTI_InitStruct);

  NVIC_InitStruct.NVIC_IRQChannel = EXTI0_1_IRQn;
  NVIC_InitStruct.NVIC_IRQChannelPriority = 0;
  NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStruct);

  while(1)
  {
     if(LedState == 0x01)
        GPIO_SetBits(GPIOC, GPIO_Pin_8);
     else
        GPIO_ResetBits(GPIOC, GPIO_Pin_8);
  }
  return (0);
}

STM32F0 - symulacja model skrzyżowania

Pomocna odpowiedź

olek623

Link do komentarza

Share on other sites

Chumanista

Link do komentarza

Share on other sites

olek623

Link do komentarza

Share on other sites

Elvis

Link do komentarza

Share on other sites

Polecacz 101

olek623

Link do komentarza

Share on other sites

Elvis

Link do komentarza

Share on other sites

olek623

Link do komentarza

Share on other sites

olek623

Link do komentarza

Share on other sites

Bądź aktywny - zaloguj się lub utwórz konto!

Utwórz konto w ~20 sekund!

Zaloguj się

Quizy

Najnowsze posty w innych tematach

Oczyszczacz powietrza

Projekt płytki PCB

Zgrzewarka do ogniw 18650 Li-ion skoki napiecia

Tablica kierunkowa autobusowa

Kurs elektroniki – #3 – prawa Ohma i Kirchhoffa w praktyce 1 2 3 4 45

Inne