[ Học ARM-Bài3 ] ADC STM32 với Standard Peripheral Library

Author: Cong Neb
Alias: Dark Neb
Studied at: SET BKHN K57
Nếu copy tài liệu: Nhớ ghi nguồn tác giả..Tk


Registers:

__IO uint32_t SR
__IO uint32_t CR1
__IO uint32_t CR2
__IO uint32_t SMPR1
__IO uint32_t SMPR2
__IO uint32_t JOFR1
__IO uint32_t JOFR2
__IO uint32_t JOFR3
__IO uint32_t JOFR4
__IO uint32_t HTR
__IO uint32_t LTR
__IO uint32_t SQR1
__IO uint32_t SQR2
__IO uint32_t SQR3
__IO uint32_t JSQR
__IO uint32_t JDR1
__IO uint32_t JDR2
__IO uint32_t JDR3
__IO uint32_t JDR4

__IO uint32_t DR


Các bước khởi tạo ADC

1.  Enable the ADC interface clock using

RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADCx, ENABLE);
2.  ADC pins configuration
3.  Configure the ADC Prescaler, conversion resolution and data alignment using  the ADC_Init() function.

4.  Activate the ADC peripheral using ADC_Cmd() function.

Các function chính

1.ADC_DeInit
void ADC_DeInit ( void )

[Học C++] Bài6 - Hàm và các keyword trong C++ (static,)

1. Các hàm thành viên trong Class
- Simple functions
- Static functions
- Const functions
- Inline functions
- Friend functions

1.1 Hàm đơn giản
Khai báo giống như 1 hàm bình thường.
[Kiểu trả về] [tên hàm] (tham số)
{
 //thân hàm
}
vi du:
void Neb {
 cout<<" Neb is handsome!";
}

1.2 Static function

1.5 Friend function
Friend function không phải là một thành viên của class. Như đã biết các class,hàm bên ngoài
không thể truy cập vào thành viên private... Do đó friend function được ra đời.
Mục đích là để giúp truy cập vào đối tượng private.
Ta có thể định nghĩa 1 hàm gobal như friend hay 1 thàm thành viên của class khác là friend.
Ví dụ
class WithFriend
{
    int i;
    public:
    friend void fun(); // global function as friend
};
void fun()
{
    WithFriend wf;
    wf.i=10;  // access to private data member
    cout << wf.i;
}
int main()
{
    fun(); //Can be called directly
}


--- Cách 2
Khi cấu hình 1 class là friend thì tất cả các hàm thành viên sẽ tự động trở thành hàm bạn...
class Other
{
    void fun();
};
class WithFriend
{
    private:
    int i;
    public:
    void getdata();  // Member function of class WithFriend
   
    // making function of class Other as friend here
    friend void Other::fun();  
   
    // making the complete class as friend
    friend class Other; 
};

2. Static Keyword

2.1 Static function

class COGE {
private:
 int x; //data member
public:
 int y;
 static void fun() {
  //x = 1; //error
  y = 1;
  cout<<"Neb";
 }
 void f() {
  //x = 1; //error,khong thể
  y = 1;
 }
};
int _tmain(int argc, _TCHAR* argv[])
{
 //void COGE::f(); //error,may not define outside of class
 COGE::fun();
 COGE obj1;
 COGE obj2.
 cout<<obj1.fun();
 cout<<obj2.fun();
 system("pause");
 return 0;
}
Cả 2 objects đều dùng chung 1 hàm fun() => Dùng static để đỡ phải khai báo 2 hàm.
Chú ý: Hàm static không thể truy cập vào data members và member function.
Chỉ có static data hoặc static function thôi.

2.2 Static data member
- Chia sẻ với tất cả các đối tượng.Và nó chỉ được lưu trữ 1 lần,do đó nó không hề copy riêng biệt cho mỗi đối tượng như
các biến thông thường.
- Biến static member (data members) không được khởi tạo bằng Constructor,bởi vì không có sự khởi tạo đối tượng.
- Nó có thể được khởi tạo giá trị bên ngoài class. Nếu không khởi tạo Linker sẽ báo lỗi.
- Một khi đã định nghĩa giá trị cho biến static,sau đó ra không thể khởi tạo lại giá trị cho biến nữa.
Vậy khi nào cần sử dụng?
Khi mà tất cả các đối tượng đều truy cập chung vào 1 biến . Thì ta nên sử dụng static.
Nếu không dùng static,thì mỗi đối tượng sẽ gọi 1 lần hàm COnstructor => Lãng phí hơn so với gọi 1 biến tĩnh.
Ví dụ:
class X
{
    public:
    static int i;
    X()
    {
        // construtor
    };
};
int X::i=1;
int main()
{
    X obj;
    cout << obj.i;   // in ra 10
}

2.3 Static Class Object
- Static objects cũng được khởi tạo bằng Constructor như các Objects bình thường.
- Lifetime của static Object là khi kết thúc chương trình. Ví dụ dưới sec chứng minh rằng hàm Destructor
không được gọi khi ra khỏi if{} và đến tận lúc kết thúc chương trình...
Ví dụ:
class Abc
{
    int i;
    public:
    Abc()
    {
        i=0;
        cout << "constructor";
    }
    ~Abc()
    {
        cout << "destructor";
    }
};
void f()
{
    static Abc obj;
}
int main()
{
    int x=0;
    if(x==0)
    {
        f();
    }
    cout << "END";
}// gọi hàm hủy ở đây

OUTPUT
constructor END destructor

[Học C++] Bài7- Hàm tạo(Constructor),Hàm hủy (Destructor) trong C++

Hàm tạo là 1 hàm đặc biệt,thực hiện khởi tạo cho mỗi đối tượng.Compiler sẽ gọi hàm tạo bất cứ
khi nào 1 đối tượng được tạo...Hàm tạo khởi tạo giá trị cho đối tượng sau khi lưu trữ và cấp phát cho đối tượng.
Trong khi đó,hàm hủy được sử dụng để giải phóng tài nguyên của đối tượng đã được tạo trước đó.

1. Constructor - Hàm tạo
Có 3 loại hàm tạo
- Default Constructor
- Parametrized Constructor (Hàm tạo tham số)
- Copy COnstructor
Cú pháp : [Tên class](các tham số nếu có) {}
class A
{
    public:
    int i;
    A(); // constructor declared
};
// constructor definition
A::A()  
{
    i = 1;
}

1.1 Hàm tạo mặc định
Là hàm tạo không có tham số...
Nếu trong class không có hàm tạo nào..Compiler sẽ gọi ra 1 hàm tạo mặc định.
Còn khi bạn khai báo 1 hàm tạo trong class rồi thì Compiler sẽ không tự cung cấp hàm tạo mặc định.
class Cube
{
    public:
    int side;
    Cube()
    {
        side = 10;
    }
};
int main()
{
    Cube c;
    cout << c.side;
}


1.2 Hàm tạo tham số
class Cube
{
    public:
    int side;
    Cube(int x)
    {
        side=x;
    }
};
int main()
{
    Cube c1(10);
    Cube c2(20);
    Cube c3(30);
    cout << c1.side;
    cout << c2.side;
    cout << c3.side;
}


1.3. Constructor Overloading
Giống như hàm bình thường,.. Hàm tạo cũng có thể bị overloading..
Khi chúng ta có cả default và parametrized constructors được định nghĩa trong class thì ta sẽ có Overloading COnstructor.
Ví dụ:

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
class COGE{
public:
 int id;
 string name;
 // first constructor
 COGE(int x) {
  id = x;
  name = "None";
 }
 // second constructor
 COGE(int x,string str){
  id = x;
  name = str;
 }
};
int _tmain(int argc, _TCHAR* argv[])
{
 COGE nhanvien1(1);
 COGE nhanvien2(2,"Neb");
 //COGE nhanvien3;  //Error vì không có hàm tạo nào không có tham số
 system("pause");
 return 0;
}


2  Hàm tạo copy
Bản chất là copy các đối tượng đã được khởi tạo từ 1 hàm tạo có sẵn..
Cú pháp
Classname(const classname & objectname)
{
//
}

Ví dụ:

#include<iostream>
using namespace std;
class Samplecopyconstructor
{
    private:
    int x, y;   //data members
   
    public:
    Samplecopyconstructor(int x1, int y1)
    {
        x = x1;
        y = y1;
    }
   
    /* Copy constructor */
    Samplecopyconstructor (const Samplecopyconstructor &sam)
    {
        x = sam.x;
        y = sam.y;
    }
   
    void display()
    {
        cout<<x<<" "<<y<<endl;
    }
};
/* main function */
int main()
{
    Samplecopyconstructor obj1(10, 15);     // Normal constructor
    Samplecopyconstructor obj2 = obj1;      // Copy constructor
    cout<<"Normal constructor : ";
    obj1.display();
    cout<<"Copy constructor : ";
    obj2.display();
    return 0;
}

OUTPUT
Normal constructor :10 15
Copy constructor : 10 15

Vi du 2:
#include <iostream>
using namespace std;
class COGE {
public:
 int x,y;
 COGE(int a,int b) {
  x = a;
  y = b;
 }
 // ham tao copy
 COGE(const COGE &Neb) {
  x = Neb.x;
  y = Neb.y;
 }
 ~COGE() {}
};
int _tmain(int argc, _TCHAR* argv[])
{
 COGE object1(1,2);
 cout<<object1.x; //in ra 1
 //
 COGE object2(object1);
 cout<<object2.x; //in ra 1
 //
 object1.x = 5;
 cout<<object1.x; //in ra 5
 cout<<object2.x; //in ra 1
 system("pause");
 return 0;
}

Nhận xét: Khi thay đổi giá trị của đối tượng này thì không ảnh hưởng đến đối tượng kia.
Vậy, làm sao để khi thay đổi 1 đối tượng thì các đối tượng khác thay đổi theo? Sử dụng phương pháp sau… Ahihi

 2.1 Shallow Copy Constructor
Các đối tượng tạo ra sẽ trỏ vào 1 cùng 1 vùng nhớ...

Do đó khi 1 đối tượng thay đổi,các đối tượng khác cũng thay đổi theo.

Ví dụ
#include<iostream>
#include<cstring>
using namespace std;
class CopyConstructor
{
    char *s_copy;
    public:
    CopyConstructor(const char *str)
    {
        s_copy = new char[16]; //Dynamic memory allocation
        strcpy(s_copy, str);
    }
    /* concatenate method */
    void concatenate(const char *str)
    {
        strcat(s_copy, str); //Concatenating 2 strings
    }
    /* copy constructor */
    ~CopyConstructor ()
    {
        delete [] s_copy;
    }
    void display()
    {
        cout<<s_copy<<endl;
    }
};
/* main function */
int main()
{
    CopyConstructor c1("Copy");
    CopyConstructor c2 = c1; //Copy constructor
    c1.display();
    c2.display();
    c1.concatenate("Constructor");    //c1 goi concatenate()
    c1.display();
    c2.display();
    return 0;
}


2.2 Deep Copy Constructor
Vậy khi ta muốn: Thay đổi đối tượng này sẽ không ảnh hưởng đến đ tượng kia?
Phương pháp Deep copy sẽ giúp ta giải quyết vấn đề,,,

Tương tự như ví dụ đầu tiên dùng cú pháp : tên class(const tên_class & tên_Object) {}

#include<iostream>
#include<cstring>
using namespace std;
class CopyConstructor
{
    char *s_copy;
    public:
    CopyConstructor (const char *str)
    {
        s_copy = new char[16];  //Dynamic memory alocation
        strcpy(s_copy, str);
    }
   
    CopyConstructor (const CopyConstructor &str)
    {
        s_copy = new char[16]; //Dynamic memory alocation
        strcpy(s_copy, str.s_copy);
    }
   
    void concatenate(const char *str)
    {
        strcat(s_copy, str); //Concatenating two strings
    }
    ~CopyConstructor()
    {
        delete [] s_copy;
    }
    void display()
    {
        cout<<s_copy<<endl;
    }
};
/* main function */
int main()
{
    CopyConstructor c1("Copy");
    CopyConstructor c2 = c1;    //copy constructor
    c1.display();
    c2.display();
    c1.concatenate("Constructor");    //c1 is invoking concatenate()
    c1.display();
    c2.display();
    return 0;
}

3. Hàm hủy
Cú pháp: ~[Tên class]
Hàm hủy không có tham số truyền vào.
Ví dụ:
class A
{
    public:
    // defining destructor for class
    ~A()
    {
        // statement
    }  
};


Ví dụ
class A
{
    // constructor
    A()
    {
        cout << "Constructor called";
    }
    // destructor
    ~A()
    {
        cout << "Destructor called";
    }
};
int main()
{
    A obj1;   // Constructor Called
    int x = 1
    if(x)
    {
        A obj2;  // Constructor Called
    }   // Destructor Called for obj2
} //  Destructor called for obj1

Vi du 2:
class Dual
{
    public:
    int a;
    Dual(int x=0)
    {
        a = x;
    }
};
int main()
{
    Dual obj1;
    Dual obj2(10);
}

[Học C++] Bài5- Định nghĩa và tạo đối tượng Class trong C++

1. Tạo đối tượng cho class
Ví dụ:
class Student
{
    public:
    int id;
    string name;
};
Có 2 cách để tạo đối tượng của class: 2 cách này có ý nghĩa như nhau.
- Cách 1:
class Student
{
    public:
    int id;
    string name;
}A,B;
A,B là 2 đối tượng của class Student
- Cách 2:
int main()
{
// tên class tên_Object
    Student A;
    Student B;
}


2. Truy cập vào class

2.1 Phương thức Public
class Student
{
    public:
    int rollno;
    string name;
};
int main()
{
    Student A;
    Student B;
   
    // setting values for A object
    A.rollno=1;
    A.name="Adam";
   
    // setting values for B object
    B.rollno=2;
    B.name="Bella";
    cout <<"Name and Roll no of A is: "<< A.name << "-" << A.rollno;
    cout <<"Name and Roll no of B is: "<< B.name << "-" << B.rollno;
}
OUTPUT
Name and Roll no of A is: Adam-1
Name and Roll no of B is: Bella-2


2.1 Private
class Student
{
    private:    // private data member
    int rollno;
    public:
    // public function to get value of rollno - getter
    int getRollno()
    {
        return rollno;
    }
    // public function to set value for rollno - setter
    void setRollno(int i)
    {
        rollno=i;
    }
};
int main()
{
    Student A;
    A.rollono=1;  //Compile time error
    cout<< A.rollno; //Compile time error
    A.setRollno(1);  //Rollno initialized to 1
    cout<< A.getRollno(); //Output will be 1
}


3. Hàm thành viên của Class

Hàm thành viên được định nghĩa trong class... Đê định nghĩa ta có 2 cách: Trong và ngoài class.
class COGE {
public:
 int year_old;
 //khai bao ham thanh vien
 int getYearOld();
};
- Cách 1: Định nghĩa hàm thành viên trong class
class COGE {
public:
 int year_old;
 //khai bao ham thanh vien
 int getYearOld() {
  return year_old+8;
 }
};
- Cách 2: Định nghĩa ngoài class
Ta phải sử dụng toán tử phạm vi ::
class COGE {
public:
 int year_old;
 //khai bao ham thanh vien
 int getYearOld();
};
int COGE::getYearOld() {
 return year_old;
}

4. gọi thành viên trong class
Để gọi 1 thành viên trong class ta dùng dấu chấm '.'
#include "stdafx.h"
#include <iostream>
using namespace std;
class COGE {
public:
 int year_old;
 //khai bao ham thanh vien
 int getYearOld();
};
int COGE::getYearOld() {
 return year_old;
}
int _tmain(int argc, _TCHAR* argv[])
{
 COGE Neb;
 Neb.year_old = 8;
 Neb.getYearOld();
 system("pause");
 return 0;
}


Author: Cong Neb
Alias: Dark Neb
Studied at: SET BKHN K57
Nếu copy tài liệu: Nhớ ghi nguồn tác giả..Tks

[Học C++] Bài4- Giới thiệu class trong C++

1. Giới thiệu
Class là đặc tính rất quan trọng của C++ cái thể hiện rõ hướng đối tượng..
Nó định nghĩa kiểu dữ liệu người dùng,class sẽ quản lý các thành viên và các hàm thành viên.

2. Coding Rule
- Tên class nên bắt đầu bằng chữ in hoa (Mặc dù không bắt buộc)
ví dụ: class Neb,class Coge... etc
- Các hàm thành viên của class có thể được định nghĩa bên trong hoặc bên ngoài class.
- Class ở C++ tương đương như Struct trong C,chỉ khác rằng class cung cấp 1 phương thức
private,còn với struct tất cả thành viên đều là public.

3. Đối tượng của class
Giống struct,ta cần tạo đối tượng để tương tác với class..
Một đối tượng là thể hiện của class đó,nó sẽ giữ giá trị biến được định nghĩa bên trong class
và cả các hàm thành viên nữa.
Các đối tượng được khởi tạo bằng 1 hàm đặc biệt được gọi là Constructor (Hàm tạo)
Và bất kì khi nào đối tượng ra khỏi phạm vi,thì một hàm đặc biệt khác được gọi: Destructor (Hàm hủy)
. Hàm hủy để giải phóng vùng nhớ của đối tượng được tạo ra trước đó.
Ví dụ:
class Abc
{
    int x;
    void display()
    {
        // Khởi tạo gì đó
    }
}; 
int main()
{
    Abc obj;   // đối tượng của class Abc được tạo
}

4. Truy cập class
Có 3 phương thức để truy cập vào 1 class
- public
- private
- protected

4.1 Public
Có nghĩa rằng chung ta có thể truy cập vào tất cả các thành viên của class được định nghĩa public.
Dữ liệu của các thành viên và các hàm thành viên cũng được truy cập ở class khác được.
Ví dụ:
class PublicAccess
{
    // public access modifier
    public:  
    int x;            // Data Member
    void display();   // Member Function
}

4.2 Private
Khác public,các đối tượng bên ngoài class không thể truy nhập vào các thành viên của class ,mà chỉ các đối tượng bên
trong class đó mới được phép.
Nếu một ai đó cố tình truy nhập vào thành viên private thì compiler sẽ báo lỗi.
Mặc định trong class khi ta không khai báo kiểu truy nhập thì luôn là private.
class PrivateAccess
{
    // private access
    private:  
    int x;            // Data Member
    void display();   // Member Function
}

4.3 Protected
Giống với private,các thành viên trong class không thể truy cập bên ngoài class.Nhưng có thể truy cập bởi các class con.
class ProtectedAccess
{
    // protected access
    protected:
    int x;            // Data Member 
    void display();   // Member Function
}


Author: Cong Neb
Alias: Dark Neb
Studied at: SET BKHN K57
Nếu copy tài liệu: Nhớ ghi nguồn tác giả..Tks

[Học C++] Bài3- Biến trong C++

1. Biến Static

Biến static là biến được khởi tạo và cấp phát bộ nhớ chỉ một lần tại thời điểm bắt đầu chương trình.
Biến static sẽ giữ lại giá trị đến khi chương trình dừng hoạt động...

Ví dụ
#include "stdafx.h"
#include <iostream>
using namespace std;
void static_fun();
int _tmain(int argc, _TCHAR* argv[])
{
 static_fun();//in ra 11
 static_fun();//in ra 12
 system("pause");
 return 0;
}
void static_fun() {
 static int a = 10;
 a++;
 cout<<a;
}

Ví dụ 2: Không dùng biến static

int _tmain(int argc, _TCHAR* argv[])
{
 static_fun();//in ra 11
 static_fun();//in ra 11 .. Không tăng lên sau các gần gọi hàm tiếp theo
 system("pause");
 return 0;
}

void static_fun() {
 int a = 10;
 a++;
 cout<<a;
}

Author: Cong Neb
Alias: Dark Neb
Studied at: SET BKHN K57
Nếu copy tài liệu: Nhớ ghi nguồn tác giả..Tks

[Học C++] Bài2 - Hàm trong C++

Hàm giúp cho chương trình dễ hiểu,rõ ràng và dễ check errors

1. Cú phám cơ bản
[kiểu trả về]  [tên hàm] (tham số 1,tham số 2,...)
{
// thân hàm
}
- Kiểu trả về: Kiểu dữ liệu mà hàm trả về.. Nó có thể là int,char,con trỏ hay class..
Và nếu hàm không trả về giá trị,bạn nên dùng kiểu trả về là void.
- Tên hàm: Tên hàm (Chú ý không đặt trùng với từ khóa)..
- Tham số : Là các biến giữ giá trị khi hàm được gọi.Một hàm có thể có hoặc không có
tham số... Khi gọi hàm,hàm có bao nhiêu tham số thì lúc gọi hàm ta phải truyền vào bấy
nhiêu tham số... ví dụ dưới: hàm sum có 2 tham số x,y...trong hàm main() khi gọi hàm sum()
ta cũng phải truyền vào 2 biến..
Ví dụ: Hàm tính tổng 2 số
// hàm sum có 2 tham số đầu vào x,y
void sum(int x, int y)
{
    int z;
    z = x + y;
    cout << z;
}
int main()
{
    int a = 10;
    int b = 20;
    //gọi hàm sum ở trên,và truyền vào 2 đối số a,b
    sum (a, b);
}

2. Định nghĩa hàm
Hãy nhớ rằng Compiler thực thi chương trình trong hàm main() trước... Sau đó.nếu trong
hàm main() có gọi đến 1 hàm nào đó bạn tự khai báo.
Với các project nhỏ thì ta viết luôn hàm tự khởi tạo ở phía trên hàm main(),nhưng với các
chương trình lớn mà ta cần include rất nhiều các file như .h,.c thì không khả thi và sẽ sinh lỗi
... Vì khi hàm main() chạy thì hàm tự khởi tạo của chúng ta chưa hề được định nghĩa trước đó.
Mặc dù khi Compile chương trinhg vẫn OK,không lỗi :D
Để khắc phục: Người ta dùng phương pháp "Lời gọi hàm"
ví dụ với hàm sum() ở trên:
#include <iostream>
using namespace std;
int sum(int x,int y); //copy y nguyên hàm sum() thôi
void main ()
{
 int a,b = 1;
 int sum_val = sum(a,b);
}
// ham sum khai báo sau hàm main()
int sum (int x,int y) {
 int sum = x + y;
 return sum;
}

3. Gọi hàm
Hàm được gọi bởi tên hàm... Nếu hàm không có tham số,nó có thể được gọi trực tiếp thông qua tên hàm.
Với những hàm có tham số,chúng ta có 2 cách gọi:
- gọi bởi tham trị
- gọi bởi tham chiếu

3.1 Gọi hàm bằng tham trị
Là kĩ thuật gọi hàm,chúng ta truyền vào giá trị cho đối số cái sẽ được lưu trữ hoặc copy trong hàm.. Khi ra khỏi hàm giá trị đó không có tác dụng nữa.
Do đó,giá trị ban đầu KHÔNG THAY ĐỔI...
void calc(int x);
int main()
{
    int x = 10;
    calc(x);
    printf("%d", x); //in ra 10
}
int calc(int x)
{
    x = x + 10 ;
    return x;
}
Giải thích:
Giá trị thực của biến x không thay đổi,bởi vì ta truyền vào giá trị,do đó 1 biến copy của x sẽ được truyền vào.
Biến copy này sẽ bị hủy sau khi ra khỏi hàm calc().

* Cach 2:
int calc(int x);
int main()
{
    int x = 10;
    x = calc(x);
    printf("%d", x); //in ra 20-ok
}
int calc(int x)
{
    x = x + 10 ;
    return x;
}

3.2 Gọi hàm bằng tham chiếu
Khi muốn thay đổi giá trị của biến sau khi gọi hàm...
Ta truyền vào địa chỉ của biến,trong phương pháp này tham số chính thức có thể được thực hiện
như là tham chiếu hay con trỏ,cả 2 phương pháp đều giúp thay đổi giá trị biến ban đầu.
void calc(int *p);
int main()
{
    int x = 10;
    calc(&x);     // truyền địa chỉ của x,như 1 đối số
    printf("%d", x);
}
void calc(int *p)
{
    *p = *p + 10;
}



Author: Cong Neb
Alias: Dark Neb
Studied at: SET BKHN K57
Nếu copy tài liệu: Nhớ ghi nguồn tác giả..Tks

[Học C++] Bài 1 - sizeof và typedef trong C++

1... sizeof

sizeof là 1 Operator,được sử dụng để lấy thông tin về tổng bộ nhớ được cấp phát cho
kiểu dữ liệu hoặc đối tượng...
Ví dụ:
cout<<sizeof(double); //in ra size của kiểu double
//Nếu sử dụng cho biến thì ta không cần ngoặc đơn
int x = 1;
int i = sizeof x;
cout<<i; //in ra 4

2... typedef
Là keyword trong C,dùng để thay thế một loại dữ liệu đã tồn tại...
Ví dụ: Tạo một kiểu dữ liệu mới có tên neb từ kiểu int.
typedef int neb;
neb i = 8;
cout<<sizeof(int); //4
cout<<sizeof(neb); //4


2.1 typedef và Pointer
Tương tự thì typedef có thể sử dụng để tạo 1 biệt danh(alias) cho pointers...
Ví dụ:
 typedef int* neb_Ptr;
 neb_Ptr a;
 cout<<sizeof(int*);
 cout<<sizeof(neb_Ptr);
 // khai bao 1 pointer,..cho vao 1 bien
 int var = 1;
 neb_Ptr prt = &var;


Author: Cong Neb
Alias: Dark Neb
Studied at: SET BKHN K57
Nếu copy tài liệu: Nhớ ghi nguồn tác giả..Tks

[Học ARM-Bài1] Power Control STM32 với Standard Peripheral Library

Author: Cong Neb
Alias: Dark Neb
Studied at: SET BKHN K57
Nếu copy tài liệu: Nhớ ghi nguồn tác giả..Tks


Registers
__IO uint32_t CR

__IO uint32_t CSR

Các function của Power Control

I . Backup Domain access

Sau khi Reset,thì MCU sẽ thực hiện Backup Domain (Như RTC Registers)
Các steps để thực hiện BDA

- Enable the Power Controller (PWR) APB1 interface clock:
Sử dụng RCC_APB1PeriphClockCmd() function

- Enable access to RTC domain using the PWR_BackupAccessCmd()
- PWR_DeInit()
- PWR_BackupAccessCmd()




Ví dụ
/* Enable PWR Clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);

/* Enable WKUP pin 1 */
PWR_WakeUpPinCmd(ENABLE);

/* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */
PWR_EnterSTANDBYMode();

[Học ARM-Bài0] RCC STM32 với Standard Peripheral Library

Author: Cong Neb
Alias: Dark Neb
Studied at: SET BKHN K57
Nếu copy tài liệu: Nhớ ghi nguồn tác giả..Tks

Reset and clock control (RCC)
RCC là một khối cực kì quan trọng của MCU... Nếu không có RCC MCU của ta sẽ không khác gì các con IC như 555..ect chứ không còn là MCU nữa...
MCU chỉ làm việc được khi được cung cấp 1 xung Clock... Và RCC làm việc đó...
Nếu nói Nguồn là năng lượng thì RCC là hơi thở của MCU...

Chức năng: Cung cấp xung Clock cho hệ thống...
RCC_TypeDef is defined in the stm32f2xx.h file and contains the RCC registers

Các Registers:

__IO uint32_t CR
__IO uint32_t PLLCFGR
__IO uint32_t CFGR
__IO uint32_t CIR
__IO uint32_t AHB1RSTR
__IO uint32_t AHB2RSTR
__IO uint32_t AHB3RSTR
uint32_t RESERVED0
__IO uint32_t APB1RSTR
__IO uint32_t APB2RSTR
uint32_t RESERVED1
__IO uint32_t AHB1ENR
__IO uint32_t AHB2ENR
__IO uint32_t AHB3ENR
uint32_t RESERVED2
__IO uint32_t APB1ENR
__IO uint32_t APB2ENR
uint32_t RESERVED3
__IO uint32_t AHB1LPENR
__IO uint32_t AHB2LPENR
__IO uint32_t AHB3LPENR
uint32_t RESERVED4
__IO uint32_t APB1LPENR
__IO uint32_t APB2LPENR
uint32_t RESERVED5
__IO uint32_t BDCR
__IO uint32_t CSR
uint32_t RESERVED6
__IO uint32_t SSCGR
__IO uint32_t PLLI2SCFGR

// Mình khác Shock khi lần đầu đọc về các Reg của RCC...Nhiều vch.
Nhưng nó là khối rất quan trọng của MCU nên ta phải tìm hiểu nó...

[Học ARM-Bài2] GPIO STM32 với Standard Peripheral Library

Author: Cong Neb
Alias: Dark Neb
Studied at: SET BKHN K57
Nếu copy tài liệu: Nhớ ghi nguồn tác giả..Tks


Các Register của GPIO

__IO uint32_t MODER
__IO uint32_t OTYPER
__IO uint32_t OSPEEDR
__IO uint32_t PUPDR
__IO uint32_t IDR
__IO uint32_t ODR
__IO uint16_t BSRRL
__IO uint16_t BSRRH
__IO uint32_t LCKR
__IO uint32_t AFR

Các steps để sử dụng GPIO Driver...

1.   Enable the GPIO AHB clock (RCC: Reset Control Clock)
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOx,ENABLE);

GPIOx: Port mà bạn muốn sử dụng.... Eg : GPIOA/GPIOC...etc