STM32F429i - PWM + LED

Witajcie!
Jako kontynuację artykułów o STM32F429i przedstawię sposób płynnej
regulacji świecenia diodą led.
Do naszej zabawy będziemy potrzebować przejściówkę FT232, ponieważ
zmodyfikujemy nasz terminal, który wspomoże nas w płynnej regulacji
wypełnienia PWM, oraz diodę led wraz z rezystorem około 300 ohm.

PWM - czyli Pulse Width Modulation -  jest to modulacja szerokości impulsu
utworzonego np: na "wyjściu" naszego timera, który jest tak skonfigurowany aby
generował sygnał prostokątny. My zaś zmieniając parametry modulujemy
tzw. wypełnienie czyli szerokość, tym samym zmieniając wartość średnią
napięcia. Oczywiście nie możemy zapomnieć o bardzo ważnym parametrze
jakim jest częstotliwość naszego przebiegu prostokątnego. Częstotliwość tą
ustawiłem na 1kHz.
Dla lepszego zobrazowania o co chodzi przedstawię screeny z oscyloskopu,
w którym zmienię wartość wypełnienia co z kolei wpłynie na wartość średnią
napięcia na pinie mikrokontrolera.

PWM - 25% -Uavg = 768mV  f= 1kHz

PWM - 50% -Uavg = 1,5V     f= 1kHz

PWM - 75% -Uavg = 2.25V     f= 1kHz

Na oscylogramach widać ładnie jak zmienia się wypełnienie i tym samym wartość

średnia napięcia.

Oczywiście PWM możemy regulować np: prędkość obrotową silnika, nic nie stoi na

przeszkodzie :). W kolejnych cyklach pokażemy sobie jak sterować serwami 

modelarskimi :) co przydaje się każdemu elektronikowi chcącemu zbudować własnego

robota.

Ok najpierw zajmijmy się kodem C# naszego terminala ponieważ dodałem kontrolkę

TrackBara, którą regulujemy płynnie wypełnienie.

 private void trackBar1_Scroll(object sender, EventArgs e)
        {
            serialPort1.Write(trackBar1.Value.ToString() + "\r");
        }

Wygląd naszej formatki powinien wyglądać w taki sposób:

Widzimy że kod jest banalny. W zdarzeniu event_scroll TrackBara za każdym przesunięciem 

wskaźnika wysyłamy wartość na COM od 0 - 512.

Ok to teraz przejdźmy do trudniejszych rzeczy. Przedstawię kod pliku main.c

#include "main.h"

#include "stm32f4xx_gpio.h"
#include "stm32f4xx_rcc.h"
#include "stm32f4xx_tim.h"
#include "stm32_ub_uart.h"
#include "stdlib.h"


void Init(void);
void Delay(volatile uint32_t nCount);
void initPWM(void);

void strreverse(char* begin, char* end);


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


  SystemInit(); 
  Init();   //inicjalizacja diody - do tego ćwiczenia nie potrzebna
  initPWM();  //inicjalizacja timera 5, który pracuje w trybie PWM
  UB_Uart_Init();   //inicalizacja USARTA

  uint16_t i = 0;

  while(1)
  {
  check=UB_Uart_ReceiveString(COM1,rx_buf); //zapisujemy odebrane dane do bufora

  if(check==RX_READY) {  //sprawdzamy czy dane zostały odebrane 
      
    i = atol(rx_buf);  //konwertujemy dane z bufora czyli ascii na int
       TIM_SetCompare1(TIM5, i); //timer pwm - zapisujemy odebraną wartosc już skonwertowaną do timera

       UB_UART_SendInt(COM1,i,10); //wysylamy spowrotem odebraną wartosc
       //UB_Uart_SendString(COM1,rx_buf); 
       UB_Uart_SendString(COM1,"\r\n"); //wysylamy znak powrotu karetki i nowej lini
  }
       //Delay(5000000);


  }
}

void initPWM()
{
 /* TIM5 włączenie zegara */
 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM5, ENABLE);

 TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;

 /* Obliczenie wartoci preskalera */
 uint16_t u16PrescalerValue = (uint16_t) ((SystemCoreClock) / 1000000)- 1;
 TIM_TimeBaseStructure.TIM_Prescaler = u16PrescalerValue; // 1MHz - preskaler
 TIM_TimeBaseStructure.TIM_Period = 500;                  // 1 MHz / 500 /2  = 1kHz (1ms)
 TIM_TimeBaseStructure.TIM_ClockDivision = 0;
 TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //licznik zlicza w góre

 TIM_TimeBaseInit(TIM5, &TIM_TimeBaseStructure); //inicjalizacja struktury Timera 5

 TIM_OCInitTypeDef TIM_OCInitStructure;

 TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;  //tryb pwm
 TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;  //odpalenie timera
 TIM_OCInitStructure.TIM_Pulse = 0; 
 TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;

 /*********************TIM5**************************/
 /* konfiguracja trybu PWM: kanał 1 (GPIOA Pin 0)*/
 TIM_OC1Init(TIM5, &TIM_OCInitStructure);
 TIM_OC1PreloadConfig(TIM5, TIM_OCPreload_Enable );
        TIM_Cmd(TIM5, ENABLE); //odpalenie timera

 ///////////////konfuguracja GPIO ///////////////
 GPIO_InitTypeDef GPIO_PWM;

 RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);

 GPIO_PWM.GPIO_Mode = GPIO_Mode_AF;
 GPIO_PWM.GPIO_Speed = GPIO_Speed_50MHz;
 GPIO_PWM.GPIO_OType = GPIO_OType_PP;
 GPIO_PWM.GPIO_PuPd = GPIO_PuPd_UP;

 //PORT A Pin0
 GPIO_PWM.GPIO_Pin = GPIO_Pin_0;
 GPIO_Init(GPIOA, &GPIO_PWM);

 GPIO_PinAFConfig(GPIOA, GPIO_PinSource0, GPIO_AF_TIM5 );

Myślę, że komentarze pomogą w zrozumieniu kodu.

Na koniec zostaje nam pokazanie jak wszystko wspólnie działa. Na filmie będzie
ładnie widać jak płynnie zmienia się wartość PWM a dioda led czerwona zmienia
jasność.

Przyjemnej zabawy :)

C# - Baza Danych (edit) - cz.4

Witajcie!
Dzisiaj będzie kontynuacja wątku o bazie danych. Pokażemy sobie jak zrobić możliwość
edycji naszych danych.

No to do dzieła!
Przeciągamy z ToolBoxa button i zmieniamy mu "content" w kodzie XAML na Edytuj,
oraz "Name" na "btnEdit".

Ok. jeśli dołożyliśmy nasz button i zmieniliśmy jego parametry, to klikamy dwa razy
na niego i przechodzi do zdarzenia kliknięcia.
Tam stworzymy nowy obiekt klasy Baza oraz wywołamy metodę "EditaData" do, której
przekażemy parametry takie jak: nazwę naszej kontrolki DataGridView, numer wiersza do
edycji, nazwę naszego textBoxa z imieniem, oraz nazwę textBoxa z nazwiskiem.

        private void btnEdit_Click(object sender, RoutedEventArgs e)
        {
            Baza b1 = new Baza(@"Data Source = Baza.sdf");
            b1.EditData(dg, numerWiersza, txtImie.Text, txtNazwisko.Text);
            MessageBox.Show("Edytowano");
            b1.UpdateGrid(dg);
        }

Ok. Jak widać dzięki temu że cały kod metody do edycji jest zawarty w naszej klasie
to w zdarzeniu nasz kod sprowadza się raptem do 4 linijek.
Co my tu mamy?.
Tworzymy nowy obiekt klasy Baza gdzie w konstruktorze przekazujemy ścieżkę
do naszej bazy danych. Następnie wywołujemy metodę, która woła aby jej zapodać
nazwę naszej kontrolki DataGridView, numer wiersza jaki został wybrany mychą,
textBox w który wpisujemy Imię oraz drugi z Nazwiskiem. Ostatnia linijka to funkcja
która robi update naszej kolekcji w gridzie.

Ok teraz przejdźmy do naszej klasy Baza.
W kodzie naszej klasy dodajemy metodę EdytujDane, której nadajemy atrybut public
oraz nie zwracamy nic czyli typ void.

public void EditData(DataGrid dg, int RowNumber, string imie, string nazwisko)
        {
            SqlCeConnection cn = new SqlCeConnection(_conn);
            da = new SqlCeDataAdapter();
           

            da.UpdateCommand = new SqlCeCommand("UPDATE Pracownicy SET Imie=@Imie, Nazwisko=@Nazwisko WHERE ID = @ID", cn);
            da.UpdateCommand.Parameters.Add("@Imie", SqlDbType.NVarChar).Value = imie;
            da.UpdateCommand.Parameters.Add("@Nazwisko", SqlDbType.NVarChar).Value = nazwisko;
            da.UpdateCommand.Parameters.Add("@ID",SqlDbType.Int).Value = RowNumber;

            cn.Open();
            da.UpdateCommand.ExecuteNonQuery();
            cn.Close();
        }

W pierwszej kolejności tworzymy obiekt cn, gdzie w konstruktorze przekazujemy string
połączenia z bazą, również tworzymy obiekt typu DataAdapter - obiekt ten reprezentuje zestaw
poleceń do połączenia z bazą danych jak również manipulacji na tychże danych.
W następnej linijce wywołujemy zapytanie query do naszej bazy danych, gdzie ustawiamy
do Imienia przypisujemy zmienną Imię a do Nazwiska nazwisko.
W następnych linijka jest do naszych edytowanych wierszy przekazywana wartość imienia i nazwiska
które są parametrem metody. dalej otwieramy połączenie, wykonujemy polecenie query i natychmiast
połączenie to zamykamy.

 Zrobiłem jeszcze małą modyfikację poprzednich metod, wywaliłem z tamtą odświeżanie
grida i zrobiełm z tego metodę, którą wywołujemy po dodaniu, usunięciu czy edycji danych.

 public void UpdateGrid(DataGrid dg)
        {
            da = new SqlCeDataAdapter();
            dt = new DataTable();

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

Całość teraz wygląda tak:

Kod klasy Baza.cs

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();
            
            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();            
        }
        public void EditData(DataGrid dg, int RowNumber, string imie, string nazwisko)
        {
            SqlCeConnection cn = new SqlCeConnection(_conn);
            da = new SqlCeDataAdapter();
           

            da.UpdateCommand = new SqlCeCommand("UPDATE Pracownicy SET Imie=@Imie, Nazwisko=@Nazwisko WHERE ID = @ID", cn);
            da.UpdateCommand.Parameters.Add("@Imie", SqlDbType.NVarChar).Value = imie;
            da.UpdateCommand.Parameters.Add("@Nazwisko", SqlDbType.NVarChar).Value = nazwisko;
            da.UpdateCommand.Parameters.Add("@ID",SqlDbType.Int).Value = RowNumber;

            cn.Open();
            da.UpdateCommand.ExecuteNonQuery();
            cn.Close();
        }
        public void UpdateGrid(DataGrid dg)
        {
            da = new SqlCeDataAdapter();
            dt = new DataTable();

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

Ok to by było na tyle w tym odcinku.
 Jeśli będziecie mieć jakieś pytania to śmiało piszcie!!

STM32F429i-Discovery USART_LED_TOG + C#

Witajcie!
W ostatnim odcinku o STM32F429i opowiedzieliśmy sobie jak odpalić uarta
na naszej płytce. Dzisiaj chciałbym troszkę zmodyfikować nasz kod a raczej
dodać do niego mruganie diodami, ale nie za pomocą micro-switcha a zrobić
sterowanie za pomocą naszego terminala, w którym dodamy sobie taką możliwość.
Będziemy wysyłać literkę przez port COM na naszą płytkę co spowoduje
zapale się diody.
Oczywiście nie użyjemy tam żadnych sztucznych opóźnień. Zrobimy to tak jak
należy:).
Kod to mrugania diody oczywiście znajduje się w jednym z poprzednich postów
wprowadzających do opisu naszej płytki STM32F429i i to ten kod użyjemy.

Ale najpierw uzbroimy nasz terminal w możliwość wysyłania własnych
znaków (stringów) przez port COM.

Jeszcze zanim dodamy przyciski do wysyłania naszych znaków, wstawimy
sobie buttonik do czyszczenia terminalu, tego w sumie mi brakowało
podczas pracy z tym terminalem.
A więc metoda drag&drop przeciągamy na naszą formatkę z ToolBoxa
buton i zmieniamy mu nazwę na "btnClear" oraz nazwę, która będzie wyświetlana
na nim na "Wyczyść".
Klikamy ppm na buttonie i przechodzimy do zdarzenia kliknięcia, w którym
napiszemy kod do wyczyszczenia tekstu z "richTextBox1".

private void btnClear_Click(object sender, EventArgs e)
{
    richTextBox1.Clear(); //czyszczenie richtexboxa
}

Teraz możemy sobie dodać dwa buttony do sterowania diodami na naszej
płytce.
Nazwiemy odpowiednio "btnRed i btnGreen", jak nazwa wskazuje jeden będzie
odpowiadał za mruganie diodą zieloną a drugi czerwoną.
Aby nasze butony ładnie wyglądały po odpaleniu naszego terminala
zmienimy im kolory.
W zdarzeniu Form1_Load dodajemy kod:

private void Form1_Load(object sender, EventArgs e)
{
    btnGreen.BackColor = Color.Green;
    btnRed.BackColor = Color.Red;
}

Podczas ładowania okna kolor tła naszych przycisków będzie miał odpowiednio
zielony i czerwony.
Wstępnie terminal powinien wyglądać tak:

OK. Jeśli mamy dodane nasze butony to oprogramujemy sobie ich zdarzenia kliknięcia.

 private void btnRed_Click(object sender, EventArgs e)
 {
        serialPort1.WriteLine("r\n\r");
 }

 private void btnGreen_Click(object sender, EventArgs e)
 {
        serialPort1.WriteLine("g\n\r");
 }

Generalnie jeśli chodzi o nasz terminal to będzie na dzień dzisiejszy tyle modyfikacji.
W przyszłości dodamy sobie możliwości wysyłania stringów zdefiniowanych przez nas,
co będzie bardziej uniwersalnym rozwiązaniem.

Ok teraz przejdziemy do kodu w C jaki zapodamy do naszego procka:

 

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

void Diody_Init(void);
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();
  Diody_Init();

  while(1)
  {
       check=UB_Uart_ReceiveString(COM1,rx_buf);

       if(check==RX_READY) {

      if(rx_buf[0] == 'g')
      {
        GPIOG->ODR ^= GPIO_Pin_13; // led_tog red
      }else if(rx_buf[0] == 'r')
      {
        GPIOG->ODR ^= GPIO_Pin_14; // led_tog green
      }

    }

  }
}
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 Delay(volatile uint32_t nCount) { // funkcja opóźniająca
  while(nCount--)
  {
  }
}

Myślę że kod jest czytelny i nie wymaga jakiegoś większego tłumaczenia.
W pętli głównej odbieramy literkę "r lub g" i po odebraniu po prostu zmieniamy
stan naszych diod na przeciwny.

Jeszcze krótki film pokazujący działanie naszego terminala i mruganie diodkami
na Discovery.

Link do pliku exe terminala.

Przyjemnej zabawy

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:)

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

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

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.