sobota, 31 maja 2014

STM32F429i-discovery -UART

Witajcie!
Dzisiaj sobie przedstawimy chyba najbardziej popularny sposób komunikacji
procka z otoczeniem - w naszym przypadku będzie to płytka STM32F429i- Discovery + przejściówka FT232RL, a dane powędrują na  terminal, który został opisany w jednym z postów wcześniej.
Protokołu komunikacji RS232 oczywiście nie będę tutaj opisywał jest tego masa w necie,
wujek google wyświetli masę wiadomości o tym.
Ramka oczywiście będzie wyglądała standardowo 8n1 - czyli 8 bitów danych, bez bitów parzystości
z jednym bitem stopu. Prędkość transmisji ustawimy sobie na 115200 (baudrate).

Jeśli chodzi o nasza płytkę to zawiera ona 8 uartów, my skorzystamy z pierwszego. Piny
nadawczy i odbiorczy są na porcie A odpowiednio TX - PA9, RX - PA10. I tak należy
podpiąć przewodzikami nasz zestaw z przejściówką USB/RS232 FT232RL.
Aha ważna informacja - standard napięć jakie panują na pinach naszej płytki to 3,3V,
należy o tym pamiętać!!!.

Link do projektu w CooCoxie zamieszczę na końcu artykułu, będzie sobie go można
pobrać i testować.

Generalnie omówię tutaj plik main.c. Pliki uart.h i uart.c będą zawierały komentarze
więc będzie się można lepiej z nimi zapoznać.

#include "main.h"
#include "stm32_ub_uart.h"


void Delay(volatile uint32_t nCount);

int main(void)
{
  UART_RXSTATUS_t check;
  char rx_buf[RX_BUF_SIZE];

  SystemInit();

  // inicjalizacja UART (COM1 : TX=PA9, RX=PA10)
  UB_Uart_Init();


  while(1)
  {
    }
   UB_Uart_SendString(COM1, "WITAJ SWIECIE\r\n");
   Delay(10000000);
  }
}
void Delay(volatile uint32_t nCount) { // funkcja opóźniająca
  while(nCount--)
  {
  }
}
Jak widać plik jest bardzo czytelny i nie zawiera wiele kodu.
Na początku deklarujemy funkcję, która wprowadzi nam opóźnienie do wysyłania
informacji na terminal. W ciele tej funkcji po każdym biegu pętli odliczamy wartość
jaką wprowadzamy do niej jako parametr.
Zmianna typu UART_RXSTATUS_t określa status bufora, w tej części artykułu
jeszcze nie będzie nam potrzebna. Następnie deklarujemy nasz bufor odbiorczy.
Jest on wielkości 50 bajtów. Jego rozmiar określa się w pliku uart.h. W pętli
głównej co około 100ms wysyłamy string "WITAJ ŚWICIE" zakończony znakami
powrotu karetki oraz nowej linii,


W następnej części zmodyfikujemy nasz kod w pętli głównej, tak aby po wysłaniu
odpowiedniej komendy np: literki "a" zaświeciła nam się dioda na naszej płytce.
Oczywiście modyfikacji będzie wymagał nasz terminal. Dodamy mu funkcję wysyłania
danych za pomocą buttona.

Link to projektu.

Przyjemnej zabawy:)

poniedziałek, 26 maja 2014

C# - Baza Danych (show and delete) - cz.3

W poprzednim odcinku pokazaliśmy sobie jak wprowadzić dane do naszej bazy
oraz stworzyliśmy klasę "Baza.cs" i utworzyliśmy konstruktor oraz
metodę pozwalającą dodawać dane.
Dzisiaj napiszemy metody, które to wprowadzone dane do bazy wyświetlą nam
w kontrolce DataGrid oraz usuną z bazy.
.
No to jedziemy:). Z "ToolBoxa" przeciągamy na nasze główne okno kontrolkę
"DataGrid", oraz buton i nazywamy odpowiednio "dg" oraz "btnShow".


hm... teraz pasuje się zastanowić jak dobrać się do grida z poziomu kasy,
ponieważ pasuje tak zmontować nasza klasę dalej, aby metody, które w niej
implementujemy były najbardziej uniwersalne jak to tylko możliwe a kod w głównym
oknie był jak najbardziej uproszczony.

Aby tego dokonać musimy przekazać jako parametr do naszej metody
"ShowData" obiekt typu DataGrid. najlepiej będzie to widać w kodzie:

public void ShowData(DataGrid dg)
        {
            SqlCeConnection cn = new SqlCeConnection(_conn);
            dt = new DataTable();
            da = new SqlCeDataAdapter();
            da.SelectCommand = new SqlCeCommand("SELECT Imie, Nazwisko FROM Pracownicy", cn);
            dt.Clear();
            da.Fill(dt);
            dg.ItemsSource = dt.DefaultView;
            da.Update(dt);
        }

Widzimy tutaj, że jako parametr przekazujemy obiekt tupu DataGrid i do grida
podpinamy DataTable.

Komentarza wymaga myślę jeszcze zapytanie query:

da.SelectCommand = new SqlCeCommand("SELECT Imie, Nazwisko FROM Pracownicy", cn);

A więc, poleceniem "SELECT" zaznaczamy kolumny jakie chcemy wyświetlić
z tabeli "Pracownicy".
Moglibyśmy zrobić to też w taki sposób "SELECT * FROM Pracownicy",
w tym przypadku efekt był by taki sam z tym, że jeszcze dostalibyśmy
kolumnę z numerami ID. Użycie gwiazdki powoduje wybranie wszystkich
dostępnych kolumn z tabeli "Pracownicy". Myślę że reszta kodu jest zrozumiała.

Natomiast w zdarzeniu buttona napiszemy sobie taki o to krótki kod:

            Baza b1 = new Baza(@"Data Source = Baza.sdf"); //tworzymy nowy obiekt naszej klasy Baza
            b1.ShowData(this.dg); //odpalamy metodę ShowData i przekazujemy jako parametr nazwę naszego grida

Teraz możemy odpalić nasz program oraz wprowadzić kilku pracowników
do naszej bazy i wyświetlić buttonem "Wyświetl". Efekt powinien
być podobny do tego na obrazku poniżej.
 
Ok, teraz stworzymy sobie przycisk do usuwania danych z bazy. W tym celu
przeciągamy sobie z "ToolBoxa" buttona i w widoku kodu XAML zmienimy

właściwość "Content" na "Usuń" oraz właściwość "Name" na "btnDel".

Przechodzimy do okienka Properties i klikamy na nasz GridView po czym
w zakładce properties wybieramy zakładkę "Events" i odszukujemy zdarzenie
"SelectedCellsChangedeventHendler" i klikamy dwa razy co zaowocuje stworzenie
 kodu zdarzenia kliknięcia.
 

Zanim przejdziemy do kodu zdarzenia utworzymy zmienna globalną, która będzie
przechowywać dla nas wartość komórki ID naszego delikwenta w bazie przez
co będziemy mieć pewność, że taki a nie inny został usunięty.

private int numerWiersza;

Teraz przechodzimy do zdarzenia "SelectedCellsChanged" i w pętli foreach
przeszukujemy GridView w poszukiwaniu zaznaczonego wiersza w kolumnie ID.

private void dg_SelectedCellsChanged(object sender, SelectedCellsChangedEventArgs e)
        {
            foreach (DataRowView dgv in dg.SelectedItems)
            {
                numerWiersza = Convert.ToInt32( dgv[0]); //zapisanie do zmiennej numerWiersza wartości z pod kolumny ID
            }                    
        }

Zmienna "dvg" jest typu "DataGrid" więc musimy ją przekonwertować na inta.

Teraz przejdźmy do pliku klasy gdzie zaimplementujemy metodę która usuwa
wybrany element z grida a co za tym idzie z bazy.

public void DeleteData(DataGrid dg, int RowNumber)
        {
            SqlCeConnection cn = new SqlCeConnection(_conn);
            da = new SqlCeDataAdapter();
            dt = new DataTable();

            da.DeleteCommand = new SqlCeCommand("DELETE FROM Pracownicy WHERE ID = @ID", cn);
            da.DeleteCommand.Parameters.Add("@ID", SqlDbType.Int).Value = RowNumber; //usunięcie numeru wiersza przekazanego jako parametr do metody

            cn.Open();
            da.DeleteCommand.ExecuteNonQuery();
            cn.Close();


            dg.ItemsSource = dt.DefaultView;
            da.Update(dt); //update grida
        }

Polecenie query usuwa dane z bazy które są filtrowane za pomocą słowa kluczowego
"WHERE" i to tutaj precyzujemy po jakim indeksie będziemy usuwać dane. Najbezpieczniej
jest właśnie usuwać po numerze ID, ponieważ jeśli byśmy chcieli usunąć po imieniu bądź
nazwisku przypadkiem usunęlibyśmy nie tą osobę jaką chcieliśmy.

Ostatnią rzeczą jaką nam pozostała jest kod zdarzenia przycisku "Usuń". Trzymając
się założeń że całą robotę ma odwalać metoda w naszej klasie a kod w głównym
oknie ma być jak najbardziej czytelny to tak uczynimy pisząc tylko trzy linijki.
Więc klikamy dwa razy na nasz buton co spowoduje utworzenie kodu zdarzenia
kliknięcia buttona i wklepujemy kodzik:
private void btnDel_Click(object sender, RoutedEventArgs e)
        {
            Baza b1 = new Baza(@"Data Source = Baza.sdf");
            b1.DeleteData(dg, numerWiersza);
            MessageBox.Show("Usunięto!");
        }

W ciele zdarzenia tworzymy nowy obiekt naszej klasy oraz podajemy ścieżkę
dostępu do bazy. Obiekt posiada metodę "DeleteData", która to jako parametry
przyjmuje nazwę naszego grida oraz numer wiersza który ma zostać usunięty
i to wszystko. :)

Jeszcze update kodu naszej klasy:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlServerCe;
using System.Data;
using System.Windows;
using System.Windows.Controls;


namespace WPF_Baza
{
    public class Baza
    {
        private static string _conn;
                
        
        public SqlCeDataAdapter da;
        public DataTable dt;
        

        /// 
        /// konstruktor
        /// 
        /// 
        public Baza(string conn)
        {
            _conn = conn;
        }       
        
        /// 
        /// dodawanie danych do bazy
        /// 
        public void InsertData(string Imie, string Nazwisko)
        {
            SqlCeConnection cn = new SqlCeConnection(_conn);

            da = new SqlCeDataAdapter();
            da.InsertCommand = new SqlCeCommand("INSERT INTO Pracownicy(Imie, Nazwisko) VALUES(@Imie, @Nazwisko)", cn);
            da.InsertCommand.Parameters.Add("@Imie", SqlDbType.NVarChar).Value = Imie;
            da.InsertCommand.Parameters.Add("@Nazwisko", SqlDbType.NVarChar).Value = Nazwisko;

            cn.Open();      
            da.InsertCommand.ExecuteNonQuery();
            cn.Close();
            
            MessageBox.Show("Dodano do bazy!");
        }
        /// 
        /// wyświetlanie danych z bazy
        /// 
        public void ShowData(DataGrid dg)
        {
            SqlCeConnection cn = new SqlCeConnection(_conn);
            dt = new DataTable();
            da = new SqlCeDataAdapter();
            da.SelectCommand = new SqlCeCommand("SELECT * FROM Pracownicy", cn);
            dt.Clear();
            da.Fill(dt);
            dg.ItemsSource = dt.DefaultView;
            da.Update(dt);
        }
        /// 
        /// usuwanie danych z bazy
        /// 
        public void DeleteData(DataGrid dg, int RowNumber)
        {
            SqlCeConnection cn = new SqlCeConnection(_conn);
            da = new SqlCeDataAdapter();
            dt = new DataTable();

            da.DeleteCommand = new SqlCeCommand("DELETE FROM Pracownicy WHERE ID = @ID", cn);
            da.DeleteCommand.Parameters.Add("@ID", SqlDbType.Int).Value = RowNumber; //usunięcie numeru wiersza przekazanego jako parametr do metody

            cn.Open();
            da.DeleteCommand.ExecuteNonQuery();
            cn.Close();


            dg.ItemsSource = dt.DefaultView;
            da.Update(dt); //update grida
        }
    }
}


Wszystko działa przyjemnie i miło. Zachęcam do testów:)

W następnej części opiszemy metodę edycji naszych danych w bazie:)
a może uda się coś jeszcze zrobić.

sobota, 24 maja 2014

C# - Baza Danych (dodawanie danych)- cz.2

W pierwszym odcinku pokazaliśmy sobie jak stworzyć bazę danych na podstawie
SQL Compact 4.0 oraz utworzyć tabelę, i jak wykonać połączenie.
Dzisiaj pokażemy sobie jak wprowadzić dane do bazy a może uda się też
takie dane wyświetlić.

Do naszego okna z ToolBoxa przenosimy 2 TextBoxy, button oraz dwie
labelki.
Zmieniamy nazwy textboxów odpowiednio na "txtImie oraz txtNazwisko",
nazwę naszego buttona na "btnDodaj" a nazwę która będzie wyświetlana
na nim na "Dodaj".



Ok, skoro textboxy oraz button zostały dodane, klikamy "ppm" w
SolutionExplorerze na nazwę naszego projektu i dodajemy nową klasę, którą
nazwiemy "Baza". Do klasy tej wrzucimy sobie wszystkie metody wykorzystywane
do połączenia, zamknięcia bazy oraz dodawania danych i edycji. itp.

Kod naszego pliku klasy Baza na razie zawiera jedną metodę oraz konstruktor klasy:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlServerCe;
using System.Data;
using System.Windows;

namespace WPF_Baza
{
    public class Baza
    {
        private static string _conn;

        
        public SqlCeDataAdapter da;
        public BazaDataSet ds;

        /// 
        /// konstruktor
        /// 
        /// 
        public Baza(string conn)
        {
            _conn = conn;
        }       
        
        /// 
        /// dodawanie danych do bazy
        /// 
        public void InsertData(string Imie, string Nazwisko)
        {
            SqlCeConnection cn = new SqlCeConnection(_conn);

            da = new SqlCeDataAdapter();
            da.InsertCommand = new SqlCeCommand("INSERT INTO Pracownicy(Imie, Nazwisko) VALUES(@Imie, @Nazwisko)", cn);
            da.InsertCommand.Parameters.Add("@Imie", SqlDbType.NVarChar).Value = Imie;
            da.InsertCommand.Parameters.Add("@Nazwisko", SqlDbType.NVarChar).Value = Nazwisko;

            cn.Open();      
            da.InsertCommand.ExecuteNonQuery();
            cn.Close();
            
            MessageBox.Show("Dodano do bazy!");
        }
    }
}
Tutaj kod naszego głównego okna:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Data.SqlServerCe;

namespace WPF_Baza
{
    /// 
    /// Interaction logic for MainWindow.xaml
    /// 
    public partial class MainWindow : Window
    {
       
        public MainWindow()
        {           
            InitializeComponent();
            

        }

        private void btnDodaj_Click(object sender, RoutedEventArgs e)
        {
            Baza b1 = new Baza(@"Data Source = Baza.sdf");
            b1.InsertData(txtImie.Text, txtNazwisko.Text);
        }
    }
}


Po napisaniu naszej klasy możemy odpalić nasz program i wpisać w textboxy imię oraz nazwisko naszego pracownika po czym dodajemy go do bazy buttonem "Dodaj". Naszym oczom powinno się ukazać okienko potwierdzające dodanie pracownika do bazy.



Ok, w tym odcinku to by było na tyle. Jednak w następnym razem opowiemy sobie
jak wyświetlać dane z bazy w kontrolce "DataGridView".

poniedziałek, 19 maja 2014

C# - Baza Danych - cz1.

Witajcie!
Miało dzisiaj być o czym innym ale...,   ale powiemy sobie jak powołać do życia
bazę danych SQL Compact.
Jako, że każdy programista  prędzej czy później będzie musiał wykorzystać
w swoich programach bazę to tutaj powiemy sobie jak takie cudo zaimplementować
w naszym programie. Skorzystamy sobie z technologii ADO.NET, ale po kolei.

W pierwszej kolejności musimy sobie zainstalować SQL Server Compact
z tej strony:
link

Ok, kiedy już zainstalowaliśmy nasz SQL Server odpalamy Visual Studio i
tworzymy nowy projekt WPF :), tak zbudujemy sobie softa w Windows
Presentation Foundation. Nazwijmy go przykładowo "WPF_Baza".


Jest to główne okno gdzie będziemy dodawać nasze kontrolki oraz pod spodem
zakładka z kodem XAML z poziomu którego można modyfikować wygląd
oraz właściwości dodawanych kontrolek.

Teraz musimy przejść do okienka SolutionExplorer i kliknąć "ppm" na folder
"References" -> "Add References" i dodać bibliotekę naszej bazy danych.
U mnie kompakt zainstalował się w folderze ProgramFiles(x86)->
Microsoft SQL Server Compact i tam wyszukujemy dll-ki o nazwie:
"System.Data.SqlServerCe.dll", którą dodajemy do projektu.


Widzimy że nasza dll-ka jest dodana :). OK to teraz klikamy na "Main Window"
"ppm" wybieramy ViewCode i dodajemy przestrzeń nazw:
using System.Data.SqlServerCe;
Teraz z kolei klikamy w SolutionExplorer "ppm" na nazwie naszego projektu
i wybieramy "Add->NewItem". W okienku, które nam się otworzy wyszukujemy
Local DataBase i nazywamy "Baza.sdf" oraz klikamy Add.


Po czym w okienku SolutionExplorer powinniśmy zobaczyć nasz plik z bazą:

Przechodzimy teraz do okienka ServerExplorer, gdzie klikamy na nasz plik Baza.sdf
i rozwijamy go. Następnie klikamy "ppm" na folder "Table " i wybieramy "Create Table".




W polu "Name" przypisujemy nazwę naszej tablicy: "Pracownicy", następnie dodajemy kolumny oraz określamy dla nich typy:
- ID - int - dla ID zmieniamy pod spodem wartość Identity na true.
- Imie - nvarchar
- Nazwisko - nvarchr


klikamy OK i przechodzimy z powrotem do kodu.
O troszkę się zapędziłem, ponieważ musimy dodać DataSet:)
No to klikamy "ppm" na DataSource i wybieramy "Add New Data Source", po czym wybieramy
"Database", klikamy next -> wybieramy DataSet oraz wybieramy z naszej tabeli tylko
dwie kolumny "Imie" i "Nazawisko" i klikamy Finish.


Teraz przechodzimy do kodu aby dodać połączenie z nasza bazą:)

Nad konstruktorem naszego okna głównego w kodzie dodajemy połączenie
tworzymy nowy obiekt a w konstruktorze podajemy ścieżkę do naszej bazy.

SqlCeConnection cn = new SqlCeConnection(@"Data Source = Baza.sdf");

W kodzie konstrukotra naszego okna a poniżej inicjalizacji komponentów
otwieramy połączenie oraz sprawdzamy czy faktycznie takie połączenie
istnieje.

            cn.Open();
            MessageBox.Show(cn.State.ToString());
            cn.Close();

Po odpaleniu programu naszym oczom powinno ukazac się okienko z napisem "Open"
jak na obrazku poniżej:

 
A tutaj nasz kod napisany do tej pory:
 
 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Data.SqlServerCe;

namespace WPF_Baza
{
    /// 
    /// Interaction logic for MainWindow.xaml
    /// 
    public partial class MainWindow : Window
    {
        SqlCeConnection cn = new SqlCeConnection(@"Data Source = Baza.sdf");
        public MainWindow()
        {
           
            InitializeComponent();
            cn.Open();
            MessageBox.Show(cn.State.ToString());
            cn.Close();
        }
    }
}


OK. W dzisiejszym odcinku to by było na tyle w następnym pokodzimy troszkę więcej.

niedziela, 11 maja 2014

Capacitive Touch Switch - czyli sensor dotykowy :)

Witajcie! W dzisiejszym odcinku chciałbym zaprezentować takie nietypowe "mrygadełko" diodą led. Mianowice chodzi mi tutaj o sensor pojemnościowy. Z tego typu sensorami możemy się spotkać np: w telefonach komórkowych gdzie zarządzanie aplikacjami odbywa się za pomocą wybierania na ekranie funkcji. W naszych zastosowania to raczej będzie się nadawało to jakiegoś włącznika światła czy urządzenia zbudowanego na mikrokontrolerze. Przedstawiony sposób jest o tyle fajny, że wykorzystujemy tylko jeden pin portu na nasz TouchSwitch. Ja na mojej płytce prototypowej podłączyłem kawałek typowej łączówki do pinu PC7 Atmegi32 a na jej końcu umieściłem rezystor 560K, dla lepszej czułości. Tutaj proponuje samodzielnie dobrać wartość rezystora i sprawdzić dla jakiej wartości czułość naszego TouchSwitcha będzie odpowiednia. Ja akurat taki rezystor miałem pod ręką. Kod jest bardzo prosty i nie wymaga tłumaczenia. Wszystkie ważniejsze kroki zostały opisane komentarzami:)
#include 
#include 

void touch_switch(void);
uint8_t key_lock;

int main(void)
{
	DDRC |= (1 << PC0);    // pin diody jako wyjcie

	while(1)
{

		touch_switch();

	}
}
void touch_switch(void)
{


		DDRC |= (1 << PC7);		//pin PC7 jako wejcie
		PORTC &=~(1 << PC7);		// stan niski na pin PC7
		_delay_ms(1);
		DDRC &=~(1 << PC7);		//pin PC7 jako wejcie
		_delay_us(20);



	if( !key_lock && (PINC & (1 << PC7) )) //tutaj sprawdzamy czy nasz sensor pojemnociowy jest dotknięty
    {
	  key_lock=150;				//ustawiamy stan zmiennej key_lock na wartoc początkową 150				

	  PORTC ^= (1 << PC0);                 //zmiana stanu diody

	} else if( key_lock && (PINC & 1 << PC7 )) key_lock++;	//sprawdzamy czy sensor został puszczony

}

Film pokazujący nasz czujnik w akcji:)



Oczywiście aby mieć bardziej profesjonalny czujnik można takowy zaprojektować sobie
np. w Eaglu oraz wytrawić płytkę.

Przyjemnej zabawy:)

piątek, 9 maja 2014

STM32F429i - User Button - zmiana stanu diod za pomocą buttona

W dzisiejszym artykule opowiemy sobie jak mrugać naszymi diodami na pinach
 PG13 i PG14 za pomocą buttona, który mamy do dyspozycji. Jak wiadomo z
user manuala button ten jest na pinie PA0. Skonfigurujemy sobie go w taki sposób
aby przy wciśnięciu i zwolnieniu stany naszych dwóch diod się zmieniały.
Oczywiście w kodzie zmieściłem stosowne komentarze co pomoże w zrozumieniu
kodu. Kod jest modyfikacją kodu do mrugania diodami z poprzedniej lekcji.

#include "main.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_rcc.h"


void Delay(volatile uint32_t nCount);
void Diody_Init(void);
void Button_Init(void);

int main(void)
{
  SystemInit();
  Diody_Init();
  Button_Init();

  while(1)
  {
   if(GPIOA->IDR & 0x0001) //sprawdzanie IDR (input data register)

   {
    GPIOG->ODR |= GPIO_Pin_13; // zapalenie diody
    GPIOG->ODR &=~ GPIO_Pin_14; // zapalenie diody

   }
   else
    {
       GPIOG->ODR &=~ GPIO_Pin_13; // zgaszenie diody
       GPIOG->ODR |= GPIO_Pin_14; // zgaszenie diody
    }

  }
}
void Diody_Init(void) {
  GPIO_InitTypeDef GPIO_InitStructure;

  // włączenie zegara
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE); //ustawienie zegara

  // ustawienie pinów portu G
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOG, &GPIO_InitStructure);
}

void Button_Init(void){
 GPIO_InitTypeDef GPIO_InitStructure;
 //ustawienie zegara
 RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);


 //ustawienie user buttona na Pinie PA0
 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;    //ustawienie pinu PA0
 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;    //button jako wejcie
 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//ustawienie prędkoci GPIO
 GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;   //ustawienie pinu w trybie push/pull
 GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;   //włączenie rezystora pulldown
 GPIO_Init(GPIOA, &GPIO_InitStructure);     //przekazanie parametró do funkcji inicjalizacyjnej
}


void Delay(volatile uint32_t nCount) { // funkcja opóźniająca
  while(nCount--)
  {
  }
}


Cały projekt jest do pobrania w poprzedniej lekcji z mruganiem diodami, więc stamtąd można sobie go pobrać i stosownie pozmieniać odpowiednie linie kodu. Przyjemnej zabawy:)

środa, 7 maja 2014

STM32F429i Disco- LED TOGGLE

W ostatnim odcinku opisałem z grubsza płytkę STM32F429i disco, i jak obiecałem
napiszemy prosty program do mrugania naszymi diodami. Płytka posiada dwie diody
dla użytkownika (czerwona i zielona) i właśnie je wykorzystamy.
Pod listingiem zamieszczę cały projekt do CooCoxa więc będzie można sobie go
pobrać i odpalić od razu na swoim PC. W kodzie zamieściłem komentarze więc widać co i jak :)

#include "main.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_rcc.h"


void Delay(volatile uint32_t nCount);
void init(void);


int main(void)
{
  SystemInit(); 
  init();



  while(1)
  {


   GPIOG->ODR |= GPIO_Pin_13; // PG13 mryganie //ODR - output data register
   GPIOG->ODR &=~ GPIO_Pin_14; // PG14 mryganie
   Delay(5000000);
   GPIOG->ODR &=~ GPIO_Pin_13; // PG13 mryganie
   GPIOG->ODR |= GPIO_Pin_14; // PG14 mryganie
   Delay(5000000);
  }
}
void init(void) {
  GPIO_InitTypeDef GPIO_InitStructure;

  // włączenie zegara
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE); //ustawienie zegara

  // ustawienie pinów portu G 
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOG, &GPIO_InitStructure);
}

void Delay(volatile uint32_t nCount) { // funkcja opóźniająca
  while(nCount--)
  {
  }
}


A tutaj link do projektu: link