Arduino – Cheatsheet

Phần này cung cấp thông tin cho việc tra cứu nhanh các hàm có thể sử dụng với Arduino và ngôn ngữ lập trình C . Với Arduino sẽ có rất nhiều thư viện cung cấp các tính năng hữu ích thông qua các API cho phép người sử dụng gọi, nội dung tóm lược ở đây chỉ đề cập tới các thư viện thường xuyên được sử dụng nhất. Nếu bạn sử dụng các thư viện khác, hoàn toàn có thể tra cứu dễ dàng trong tài liệu sử dụng của thư viện đó. Thông thường các thư viện được phát hành nguồn mở trên Github sẽ có file README.md cung cấp đầy đủ các thông tin.

Arduino Cheatsheet

/* CẤU TRÚC CƠ BẢN CỦA 1 SKETCH */
void setup() {
  /*
  Hàm được gọi khi bắt đầu sketch. Dùng để khởi tạo
  biến, cấu hình chân, gọi thư viện,...
  Code trong setup chỉ chạy 1 lần (khi khởi động hoặc
  reset board)
  */
}
void loop() {
  // Nội dung trong loop() lặp lại liên tục
}

/* LỆNH RẺ NHÁNH */

/* Lệnh if else */
if (x < 5)      // thực thi code nếu x<5
 { code }
else if (x > 10)// thực thi code nếu x>10
	{ code }
else { code }   // thực thi code các trường hợp còn lại

/* Lệnh switch case */
switch (var) {  // thực thi case có giá trị var
case 1:
{source code}
break;
case 2:
{source code}
break;
default:
{source code}
}

/* CÁC KIỂU VÒNG LẶP */

/* Vòng lặp while */
while (x < 5) { code };
/* Thực hiện code nếu x<5 */

/* Vòng lặp do  ... while */
do { code } while(x < 0);
/* Thực hiện code, so sánh, nếu x<0 tiếp tục thực hiện
code */

for (int i = 0; i < 10; i++) { code };
/* Khởi tạo i, thực hiện code và tăng i nếu i < 10 */
break; /* Thoát ra vòng lặp (for, while, do-while) ngay lập tức */
continue; /* Đi đến chu kì lặp tiếp theo của vòng lặp
hiện tại */

/* CÁC ĐỊNH NGHĨA VỀ HÀM*/
<ret. type> <name>(<params>) { ... }
/*  ret.type : Kiểu trả về của hàm
     name : Tên của hàm
     params : Các đối số truyền vào hàm
     { ... } : source code được viết trong {}
Ví dụ : int func_name(int x) {return x*2;}
*/

return x; // x phải trùng khớp với kiểủ trả về của hàm
return;   // loại return dành cho hàm void
/* INCLUDE */
#include <stdio.h>
/* include thư viện chuẩn */
#include "your-library.h"
/* include thư viện tạo bởi người dùng */

/* DỮ LIỆU KIỂU CHUỖI */

char str1[8] = {'A','r','d','u','i','n','o','\0'};
/* Chuỗi bao gồm kí tự kết thúc chuỗi \0 (null) */

char str2[8] = {'A','r','d','u','i','n','o'};
/* Trình biên dịch tự động thêm kí tự \0 vào cuối chuỗi */

char str3[] = "Arduino";
char str4[8] = "Arduino";
/* Khai báo và gán giá trị cho chuỗi */

/* DỮ LIỆU KIỂU MẢNG */

int myPins[] = {2, 4, 8, 3, 6}; /* Khai báo mảng kiểu
int có 6 phần tử và gán giá trị cho mỗi phần tử */

int myInts[6];
/* Mảng kiểu int 6 phần tử và không gán giá trị */

myInts[0] = 42; // Gán giá trị 42 cho phần tử đầu tiên
myInts[6] = 12; // LỖI ! chỉ số của mảng chỉ từ 0 đến 5

/*Qualifiers*/
static    // Không thay đổi giá trị ở các lần gọi
volatile  // In RAM (Thường dùng trong ngắt)
const     // Không đổi (chỉ đọc)
PROGMEM   /* Cho phép lưu trữ dữ liệu trong bộ nhớ
FLASH thay vì SRAM */

/* CÁC TOẢN TỬ, PHÉP TOÁN THƯỜNG DÙNG */
/* Các toán tử thường dùng */
=   toán tử bằng
+   toán tử cộng
-   toán tử trừ
*   toán tử nhân
/   toán tử chia lấy phần nguyên
%   toán tử chia lấy phần dư
==  phép so sánh bằng
!=  phép so sánh không không bằng (khác)
<   phép so sánh nhỏ hơn
>   phép so sánh lớn hơn
<=  phép so sánh nhỏ hơn hoặc bằng
>=  phép so sánh lớn hơn hoặc bằng
&&  phép toán logic (AND)
\|\|  phép toán logic (OR)
!   phép toán logic (NOT)
/* Các toán tử hợp nhất */
++ tăng 1 đơn vị
-- giảm 1 đơn vị
+= phép toán cộng và gán giá trị
   ex: x = 5; x+= 1; //x = 6
-= phép toán trừ và gán giá trị
   ex: x = 5; x-= 1; //x = 4
*= phép toán nhân và gán giá trị
   ex: x = 5; x*= 3; //x = 15
/= phép toán chia lấy phần nguyên và gán giá trị
   ex: x = 6; x/= 2; //x = 3
&= phép toán logic AND và gán giá trị
   ex: x = 0b1010; x&= 0110; //x =0b0010
\|= phép toán logic OR và gán giá trị
   ex: x = 0b1010; x&= 0110; //x =0b1110

/* Các toán tử trên bit */
&   and          ^   xor
<<  dịch trái    >>  dịch phảii
\|  or           ~   not

/* Thực thi với con trỏ */
&reference:  // lấy địa chỉ của biến mà con trỏ trỏ tới
*dereference:// lấy giá trị của biến mà con trỏ trỏ tới

/* HẰNG SỐ VÀ KIỂU DỮ LIỆU */
123     Số thập phân
0b0111  Số nhị phân
0173    Số Octal - base 8
0x7B    Số thập lục phân base 16
123U    Số nguyên không dấu
123L    Số nguyên có dấu 4 bytes
123UL   Số nguyên không dấu 4bytes
123.0   Số thực
1.23e6  Số thực dùng cơ số mũ ex: 1.23*10^3 = 1230

/*PHẠM VI CỦA KIỂU DỮ LIỆU */
boolean       true \| false
char          -128        - 127, 'a' '$' etc.
unsigned char 0           - 255
byte          0           - 255
int           -32768      - 32767
unsigned int  0           - 65535
word          0           - 65535
long          -2147483648 - 2147483647
unsigned long 0           - 4294967295
float         -3.4028e+38 - 3.4028e+38
double        -3.4028e+38 - 3.4028e+38
void          i.e., no return value

/* KHAI BÁO BIẾN */
int       a;
int       a = 0b01111011, b = 0123, c = 1, d;
float     fa = 1.0f;
double    da = 1.0;
char      *pointer;
char      *other_pointer = NULL;

/**
 * BUILT-IN FUNCTIONS
 * Pin Input/Output
 * Digital I/O - pins 0-13 A0-A5
 */
pinMode(pin,[INPUT, OUTPUT, INPUT_PULLUP])
/* Thiết lập cấu hình chân */
int a = digitalRead(pin_6);
/* Đọc giá trị của pin_6 và gán cho a */
digitalWrite(pin_5, [HIGH, LOW])
/* Cài đặt mức HIGH/LOW cho pin_5 */
int a = analogRead(pin)
/* Đọc giá trị của pin và gán cho a, pin từ A0-->A5 */

analogWrite(pin, value)
/* PWM ngõ ra - pins 3 5 6 9 10 11
 * ESP8266: pin 0..16, range = 0..1023, 1KHz default
 */
/* Đặt giá trị PWM cho pin */
analogWriteRange(new_range)
/* ESP8266: thay đổi RANGE PWM output */
analogWriteFreq(new_frequency)
/* ESP8266: Tần số PWM output */

/* ADVANCED I/O */
tone(pin, freq_Hz)
/* Tạo sóng vuông tần số freq_Hz với duty cycle=50% */
tone(pin, freq_Hz, duration_ms)
/* Tạo sóng vuông tần số freq_Hz, duration mili giây */
noTone(pin)
/* Ngừng việc tạo sóng vuông khi dùng tone() */

shiftOut(dataPin, clockPin,[MSBFIRST, LSBFIRST], value)
/* Dịch 1 byte, mỗi lần dịch 1 bit, dịch từ bit cao */

unsigned long pulseIn(pin,[HIGH, LOW])
/* Trả về (ms) của xung HIGH/LOW trên chân pin */

/* CHỨC NĂNG NGẮT */
attachInterrupt(interrupt, func, mode)
/* Thiết lập chức năng ngắt ở các chân digital */
/*
interrupt: số ngắt (thường là chân sử dụng chức năng
ngắt)
func : hàm sẽ được gọi khi ngắt xảy ra (lưu ý : hàm
không có tham số đầu vào cũng như kiểu trả về)
mode : gồm các chế độ LOW,CHANGE, RISING, FALLING. Ngắt
sẽ được kích hoạt khi chân ngắt ở mode tương ứng
*/
detachInterrupt(interrupt)
/* Vô hiệu hóa ngắt interrupt */
noInterrupts()
/* Vô hiệu hóa tấ cả các ngắt */
interrupts()
/* Cho phép tái ngắt sau khi dùng noInterrupts() */

/*************************************************
 *            THƯ VIỆN PHỔ BIẾN                 *
 *************************************************/

/*************************************************
 *                     Serial                    *
 *Thư viện giao tiếp với PC hoặc thông qua RX/TX*
 *************************************************/
begin(long speed)
/* Thiết lập giao tiếp serial-UART với tốc độ speed */

end()
/* Vô hiệu hóa giao tiếp serial */

int available()
/* Trả về số bytes có sẵn để đọc */

int read()
/* đọc dữ liệu đến từ serial (trả về byte đầu tiên của
dữ liệu từ serial hoặc -1 nếu dữ liệu không có */

flush()
/* Chờ quá trình truyền dữ liệu serial hoàn tất */

print(data)
/* In ra serial port dữ liệu data (với bất kì kiểu dữ
liệu nào được thiết lập */

println(data)
/* Tương tự như print(data) nhưng sau khi in ra serial
-port, con trỏ sẽ xuống dòng tiếp theo */

write(byte)
/* Gửi dữ liệu value/string/array đến serial port */

SerialEvent()
/* Hàm được gọi khi có dữ liệu đến từ chân RX */


/*************************************************
 *                  Servo.h                      *
 *     Thư viện hỗ trợ điều khiển động cơ servo *
 *************************************************/
attach(pin, [min_uS, max_uS])
/*
Thiết lập chân kết nối với servo và độ rộng xung
pin : Chân kết nối với servo
[min_uS, max_uS] : Độ rộng xung tính theo us tương ứng
với góc xoay từ 0 đến 180
*/

write(angle)
/* Ghi dữ liệu góc xoay cho động cơ angle từ 0~180 */

writeMicroseconds(uS)
/* Viết giá trị để điều khiển góc quay cho servo, giá
trị từ 700 ~ 2300 */

int read()
/* Đọc giá trị góc xoay (0 đến 180 độ) */

bool attached()
/* Trả về true nếu biến servo đã kết nối đến pin */

detach()
/* Gỡ bỏ biến servo ra khỏi chân đã kết nối */

/*************************************************
 *                       Wire.h                  *
 *               Dùng trong giao tiếp I2C        *
 *************************************************/

begin()
 /* Master khởi tạo thư viện Wire với giao tiếp I2C */

 begin(addr)
/* Slave tham gia vào kết nối i2C, addr là 7 bits địa
chỉ của slave */

requestFrom(address, count, stop)
/*
Master yêu cầu 1 số byte từ slave:
address: 7bits địa chỉ của slave.
count: Số lượng byte master yêu cầu
stop: Kiểu boolean, nếu true, master tín hiệu stop sau
khi yêu cầu và giải phóng bus I2C, nếu false, master
gửi yêu cầu restart để giữ kết nối
*/

beginTransmission(addr)
/* Gửi tín hiệu bắt đầu, truyền dữ liệu đến slave có
địa chỉ addr */

send(byte)
/* Gửi dữ liệu (1 byte)đến slave */

send(char * string)
/* Gửi dữ liệu (string) đến slave */

send(byte * data, size)
/* Gửi dữ liệu (1 mảng ) với số byte là size */

endTransmission()
/* Gửi tín hiệu kết thúc truyền dữ liệu tới slave */

int available()
/* Trả về số byte availabe sau khi đọc bởi read() */

byte receive()
/* truy xuất đến 1 byte đã truyền từ slave đến master
hoặc truyền ở chiều ngược lại khi nhận được
requestFrom. Trả về byte tiếp theo đã nhận được */

onReceive(handler)
/* Hàm handler sẽ được gọi khi slave nhận dữ liệu */

onRequest(handler)
/* Handler sẽ được gọi khi master yêu cầu dữ liệu */

C – Cheatsheet

/* CẤU TRÚC CƠ BẢN */
Viết chú thích trên 1 dòng dùng //
      ex: x++ ; // tăng x 1 đơn vị
/* */ Viết chú thích trên nhiều dòng.
ex : /*************************
      * Chú thích được viết   *
      *    trên nhiều dòng    *
      ************************/
/* CẤU TRÚC 1 CHƯƠNG TRÌNH */
#include <stdio.h>//include thư viện chuẩn của C
#include "iLib.h"// include thư viện tạo bởi người dùng
int global_var; //biến được dùng  trong chương trình
/* Khai báo hàm bắt đầu của 1 chương trình C với kiểu
trả về là integer. Đối số arg kiểu int được truyền vào
hàm */
int main (int arg){
 float local_var ; // Biến chỉ được dùng trong hàm main
 Lệnh 1
 ...
 Lệnh n ;
return 0; //chương trình thực hiện thành công và thoát
}

/*KIỂU DỮ LIỆU VÀ PHẠM VI */
boolean       true \| false
char          -128         -  127, 'a' '$' etc.
unsigned char 0            -  255
byte          0            -  255
int           -32768       -  32767
unsigned int  0            -  65535
word          0            -  65535
long          -2147483648  -  2147483647
unsigned long 0            -  4294967295
float         -3.4028e+38  -  3.4028e+38
double        -3.4028e+38  -  3.4028e+38
void          i.e., no return value

/* ĐẶT TÊN BIẾN */
/* Đặt tên đúng */
int x;            // Một biến
int x = 1;        // Biến được khai báo và khởi tạo
float x, y, z;    // Nhiều biến cùng kiểu dữ liệu
const int x = 88; // Biễn tĩnh, không ghi được
int tenBien1ok;   // Đặt tên biến này đúng
int ten_bien_nay_ok;
/* Đặt tên sai */
int 2001_tensai;  // Vì số ở đầu
int ten-sai;      // Dấu '-' không phải là alphanumberic
int while;        // Sai, vì dùng từ khóa vòng lặp while

/* HẰNG SỐ VÀ KIỂU DỮ LIỆU */
123      Số thập phân
0b0111   Số nhị phân
0173     Số Octal - base 8
0x7B     Số thập lục phân base 16
123U     Số nguyên không dấu
123L     Số nguyên có dấu 4 bytes
123UL    Số nguyên không dấu 4bytes
123.0    Số thực
1.23e6   Số thực dùng cơ số mũ ex: 1.23*10^3 = 1230
/* định nghĩa hằng số a kiểu nguyên, có giá trị là 1 */
const int a = 1;
/* Định nghĩa hằng số x kiểu thực, có giá trị là 4.0 */
const float x = 4;
/* Định nghĩa hằng số c kiểu integer có giá trị 49 */
const c = ‘1’; // Kí tự 1 trong mã ASCII là 49
/* Định nghĩa str là hằng số kiểu con trỏ, trỏ tới
chuỗi “Cheasheet C” */
const char * str = “Cheasheet C”;

/* KHAI BÁO BIẾN */
/* Khai báo biến a kiểu nguyên và không gán giá trị */
int a;
/* khai báo a kiểu binary, b kiểu base8, c kiểu số
nguyên, d kiểu số nguyên và không gán giá trị */
int a = 0b01111011, b = 0123, c = 1, d;
/* Khai báo biến fa thuộc kiểu số thực float */
float fa = 1.0f;
/* Khai báo biến da thuộc kiểu số thực double */
double da = 1.0;
/* Khai báo biến con trỏ và trỏ đến 1 vùng nhớ không
xác định */
char *pointer;
/* Khai báo biến con trỏ và trỏ về NULL (0)*/
char *other_pointer = NULL;

/* CHUỖI KÍ TỰ */
/* Chuỗi bao gồm kí tự kết thúc chuỗi \0 (null) */
char str1[8] = {'A','r','d','u','i','n','o','\0'};
/* Trình biên dịch tự động thêm kí tự \0 vào cuối
chuỗi */
char str2[8] = {'A','r','d','u','i','n','o'};
/* Khai báo chuỗi ,không khai báo số phần tử và gán giá
trị chuỗi */
char str3[] = "Arduino";
/* Khai báo và gán giá trị cho chuỗi */
char str4[8] = "Arduino";

/* Các hàm xử lí chuỗi thường dùng */
/* Nối các kí tự từ chuỗi source tiếp vào vị trí cuối
của chuỗi dest */
strcat(dest, source)
/* Tìm vị trí xuất hiện đầu tiên của kí tự c trong
source, trả về con trỏ chỉ tới vị trí đó hoặc null nếu
không tìm thấy c trong source */
strchr(source, c)
/* Hàm trả về độ dài của chuỗi st */
strlen(st)
/* copy và thay các kí tự của chuỗi soure vào dest */
strcpy(dest, source)
/* chép kí tự từ đầu đến n từ chuỗi source vào dest */
strncpy(dest, source, n)

/* MẢNG */
/* Khai báo mảng 1 chiều 6 phần tử kiểu integer và gán
giá trị cho mỗi phần tử */
int myPins[] = {2, 4, 8, 3, 6};
/* Khai báo mảng 1 chiều 6 phần tử kiểu integer và
không gán giá trị */
int myInts[6];
myInts[0] = 42; // Gán giá trị 42 cho phần tử đầu tiên
myInts[6] = 12; // LỖI ! chỉ số của mảng chỉ từ 0 đến 5
/* Lấy giá trị của phần tử thứ 3 trong mảng myInts */
int c = myInts[2]; // Có thể dùng *(myInts + 2)
/* Lấy địa chỉ của phần tử thứ 3 trong mảng myInts */
int c = &myInts[2]; // Có thể dùng int c = myInts + int
/* Trả về chiều dài của mảng myInts */
int length = sizeof(myInts) / sizeof(myInts[0]);
/* Khai báo 2 mảng kiểu float, arr1 có 5 phần tử, arr2
có 10 phần tử */
float arr1[5], arr2[10];
/* Khai báo mảng số nguyên arr có 2 dòng, 5 cột. Tổng
cộng có 10 phần tử */
int a[2][5];

/* KHỐI LỆNH VÀ CÁC LỆNH DÙNG TRONG VÒNG LẶP */
{} // bao gồm nhiều lệnh, thường được sử dụng trong hàm
/* Goto : chương trình sẽ nhảy đến nhãn (nhãn phải có
mặt trong câu lệnh chứa goto) */
goto nhãn;
/* Continue : Chỉ dùng trong các lệnh có vòng lặp sẽ
chuyển qua chu kì mới của vòng lặp trong cùng nhất */
continue; /*
/* Break : Dùng với các vòng lặp thoát khỏi vòng lặp
trong cùng nhất, hoặc dùng trong cấu trúc switch..case
để thoát ra khỏi case tương ứng */
break; /*
/* Return */
/* Dùng cho hàm không có kiểu trả về (void) */
return;
/* Value có thể là hằng số, biến, biểu thức hoặc gọi
đến 1 hàm khác để trả về giá trị */
return <value>;

/* LỆNH RẺ NHÁNH */
if (x < 5)      // thực thi code nếu x<5
 { code }
else if (x > 10)// thực thi code nếu x>10
	{ code }
else { code }   // thực thi code các trường hợp còn lại

switch (var) {  // thực thi case có giá trị var
case 1:
...
break;
case 2:
...
break;
default:
...
}

/* CÁC KIỂU VÒNG LẶP */
/* While: Thực hiện code nếu x<5 */
while (x < 5) { code };
/* Do-While : Thực hiện code, so sánh, nếu x<0 tiếp tục
thực hiện code */
do { code } while(x < 0);
/* for : Khởi tạo và gán giá trị cho i, thực hiện code
tăng i nếu i < 10 */
for (int i = 0; i < 10; i++) { code };

/* PHÉP TOÁN VÀ TOÁN TỬ THƯỜNG DÙNG
/* Các toán tử thường dùng */
=   toán tử bằng
+   toán tử cộng
-   toán tử trừ
*   toán tử nhân
/   toán tử chia lấy phần nguyên
%   toán tử chia lấy phần dư
==  phép so sánh bằng
!=  phép so sánh không không bằng (khác)
<   phép so sánh nhỏ hơn
>   phép so sánh lớn hơn
<=  phép so sánh nhỏ hơn hoặc bằng
>=  phép so sánh lớn hơn hoặc bằng
&&  phép toán logic (AND)
\|\|  phép toán logic (OR)
!   phép toán logic (NOT)

/* Các toán tử hợp nhất */
++   tăng 1 đơn vị
--   giảm 1 đơn vị
+=   phép toán cộng và gán giá trị
     ex: x = 5; x+= 1; //x = 6
-=   phép toán trừ và gán giá trị
     ex: x = 5; x-= 1; //x = 4
*=   phép toán nhân và gán giá trị
     ex: x = 5; x*= 3; //x = 15
/=   phép toán chia lấy phần nguyên và gán giá trị
     ex: x = 6; x/= 2; //x = 3
&=   phép toán logic AND và gán giá trị
     ex: x = 0b1010; x&= 0110; //x =0b0010
\|=   phép toán logic OR và gán giá trị
     ex: x = 0b1010; x&= 0110; //x =0b1110

/* Các toán tử trên bit */
&   and          ^   xor
<<  dịch trái    >>  dịch phảii
\|  or           ~   not

/* THỰC THI VỚI CON TRỎ */
&reference:  // lấy địa chỉ của biến mà con trỏ trỏ tới
*dereference:// lấy giá trị của biến mà con trỏ trỏ tới
/* khai báo biến con trỏ kiểu int trỏ tới địa chỉ của
biến a */
int a = 5; int *pointer = &a;

/* CÁC KÍ TỰ ĐIỀU KHIỂN VÀ KÍ TỰ ĐẶC BIỆT */
\n  Nhảy xuống dòng kế tiếp canh về cột đầu tiên
\t  Canh cột tab ngang.
\r  Nhảy về đầu hàng, không xuống hàng.
\a  Tiếng kêu bip.
\\  In ra dấu \
\"  In ra dấu "
\'  In ra dấu '
%%: In ra dấu %
\b ~ backspace (xóa 1 ký tự ngay trước)

/* HÀM VÀ CÁC VẤN ĐỀ LIÊN QUAN */
/* Khai báo prototype của hàm max, có 2 đối số đầu vào
là a và b thuộc kiểu số nguyên, kết quả trả về của hàm
kiểu số nguyên */
int max(int a, int b);
/* Khai báo biến c là giá trị trả về của hàm max */
int c = max(5,4);
/* Khai báo prototype của hàm không có đối số và không
có kiểu trả về (void) */
void none();

/* TYPEDEF- Định nghĩa kiểu dữ liệu */
/* Định nghĩa kiểu unsigned char là BYTE, khai báo các
biến a, b thuộc kiểu BYTE */
typedef unsigned char BYTE;  BYTE  a, b;

/* KIỂU LIỆT KÊ - ENUMERATION (enum) */
/* khai báo kiểu dữ liệu enum là các ngày trong tuần */
enum daysOfWeek { sunday, monday, tuesday, wednesday };
/* Tạo biến toDay thuộc daysOfWeek và gán giá trị */
daysOfWeek toDay = wednesday;

/* STRUCT - KIỂU DỮ LIỆU DO NGƯỜI DÙNG ĐỊNH NGHĨA */
/* Khai báo struct sinhVien */
struct sinhVien{
  char tenSinhVien;
  char MSSinhVien;
  int tuoiSinhVien;
};
/* Truy xuất đến thành phần MSSinhVien trong struct
sinhVien */
sinhVien.MSSinhVien;
/* Đổi tên struct sinhVien thành 1 biến duy nhất là
SINHVIEN */
typedef struct sinhVien SINHVIEN;
/* Khai báo biến sinhVienA thuộc struct SINHVIEN */
SINHVIEN sinhVienA;

/* CÁC LỆNH XỬ LÝ TẬP TIN (#include <stdio.h>) */
/* Khai báo 1 biến con trỏ là đường dẫn của 1 file */
const char *filePath = "Đường/dẫn/file/document.txt";
/* Tạo 1 biến con trỏ thuộc kiểu FILE */
FILE *file;
/* Mở 1 file ở đường dẫn filePath và đọc dữ liệu */
file = fopen(filePath, "r");// Trả về NULL nếu thất bại
/* Đóng 1 file đã mở, trả về 0 nếu thành công , ngược
lại trả về EOF */
fclose(file);
/* Viết kí tự c lên file đang mở, trả về EOF nếu ghi
thất bại, trả về mã ASCII của c nếu thành công */
int fputc(int c, FILE *f);
/* Viết chuỗi "hello" lên file đang mở */
int c = fputs("hello", file);
/* Đọc (255-1) kí tự từ file đang mở, kết quả đọc được
sẽ lưu vào mảng str, việc đọc bị dừng nếu gặp kí tự
'\n' hoặc EOL */
fgets(str, 255, file);
/* Thay đổi vị trí trỏ đến trong file của con trỏ
internal file position indicator về lại đầu file */
int fseek(file, 0, SEEK_SET);
/* Trả về kích thước của nội dung có trong file */
ftell(file);

Leave a Comment