Linked Lists ๐๋ก ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ๊ธฐ์ ์ ํฅ์์ํค์ธ์.
"Embedded Linked Lists"์ ๋ํด ์๊ธฐ ์ ๊น์ง! ๊ทธ๋ค์ ์ง์ ํ ๊ฒ์ ์ฒด์ธ์ ์์ต๋๋ค!
์ฐ๊ฒฐ๋ ๋ชฉ๋ก
์์ํ๊ธฐ ์ ์ Wikipedia์์ ์ฝ๊ฐ์ ๋ณต์ต์ด ์์ต๋๋ค(๋ "C์ ๊ฐ์"์๋ฆฌ๋ฅผ ๋ด๊ธฐ ์ํด ๋ช ๊ฐ์ง ๋ณ๊ฒฝ ์ฌํญ ํฌํจ).
A linked list [is astruct
with] two fields: a value and a [pointer] to the next node. The last node is linked to [NULL
] used to signify the end of the list.
Linked List๋ ๋ฏธ๋ฆฌ ํ ๋น๋ ํฐ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ด ํ์ํ์ง ์๋ค๋ ํฐ ์ด์ ์ด ์์ต๋๋ค. ๋์ Linked List๋ ๋ค์๊ณผ ๊ฐ์ ์ ์์ต๋๋ค.
๊ทธ๋ฌ๋ Embedded C์์ ์์ฃผ ์ฌ์ฉ๋๋ ์ ์ ๋ฉ๋ชจ๋ฆฌ์์๋ ์ฐ๊ฒฐ ๋ชฉ๋ก์ ๋งค์ฐ ์ ์ฉํฉ๋๋ค.
๊ฐ๋จํ HTTP ํด๋ผ์ด์ธํธ
์๋ฅผ ๋ค์ด ํ ๋ฒ์ ํ๋์ ์์ฒญ๋ง ์ํํ ์ ์์ผ๋ฏ๋ก ๋ณด๋ฅ ์ค์ธ ์์ฒญ์ ๋๊ธฐ์ด์ ๋ฃ์ด์ผ ํ๋ HTTP ํด๋ผ์ด์ธํธ๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
๊ทธ๋ฌ๋: ๋๊ธฐ์ด์ด ์ผ๋ง๋ ๊ธธ์ด์ผ ํฉ๋๊น? ๐ค
์ ๋ ฅ: ์ฐ๊ฒฐ๋ ๋ชฉ๋ก! ๐ก
// http_client.h
/**
* Do a HTTP GET on the given request
*
* Params:
* - new_request: A struct with the Request data
* (URL, custom header fields, etc)
*
* Returns:
* - 0 if the request was accepted and started immediately
* - 1 if the request was queued
* - < 0 on error
*/
int http_get(struct http_request *new_request);
์ฐ๊ฒฐ๋ ๋ชฉ๋ก์ struct http_request์ ํฌํจ
Embedded C์์ ์ฐ๊ฒฐ ๋ชฉ๋ก์ ์ฌ์ฉํ๋ ์๋ น์ ํฌ์ธํฐ๋ฅผ ๊ตฌ์กฐ์ฒด ๋ด๋ถ์ ๋ค์ ๋ ธ๋์ ๋๋ ๊ฒ์ ๋๋ค. ๊ทธ๋ฐ ์์ผ๋ก ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๋ฅผ ์ฒ๋ฆฌํด์ผ ํ๋ฉฐ ๋ ์ด์ HTTP ํด๋ผ์ด์ธํธ ์ธก์์ ์ถ์ธกํ์ง ์์๋ ๋ฉ๋๋ค. ๐
// http_client.h
/**
* A struct that contains all the data
* for the HTTP request such as the URL
*/
struct http_request {
/** A pointer to the next HTTP request to perform */
struct http_request *next_request;
/** The URL to GET */
char *url;
// ...
// Other field omitted for brevity
};
http_get์์ ์์ฒญ ๋ชฉ๋ก ์ฒ๋ฆฌ
HTTP ํด๋ผ์ด์ธํธ ๋ด์์ ๋ชฉ๋ก ์์์ ๋ํ ์ฐธ์กฐ๋ฅผ ์ ์งํ๊ณ ๋ชจ๋ ์ ์์ฒญ์ ๋ชฉ๋ก ๋์ ์ถ๊ฐํ๊ธฐ๋ง ํ๋ฉด ๋ฉ๋๋ค.
// http_client.c
/**
* A pointer to the current HTTP request or NULL if
* no request is pending
*/
static struct http_request *current_request = NULL;
int http_get(struct http_request *new_request) {
// Check if we have an ongoing HTTP request
if(NULL != current_request) {
// We have a request ongoing and will add the
// new request to the end of the list
struct http_request *req = current_request;
while(NULL != req->next_request) {
req = req->next_request;
}
req->next_request = new_request
} else {
// No ongoing HTTP request, can start with current_request
}
}
ํ์ฌ ์์ฒญ์ด ์๋ฃ๋๋ฉด ๋ชจ๋ ์์ฒญ์ด ์๋ฃ๋ ๋๊น์ง ๋ชฉ๋ก์์ ๋ค์ ํญ๋ชฉ์ ๊ฐ์ ธ์ต๋๋ค.
// http_client.c
int http_get(struct http_request *new_request) {
// ...
// Finished current HTTP request,
// check if there is another one queued
current_request = current_request->next_request;
if(NULL != current_request) {
// Have an HTTP request queued, start with it now
}
}
๊ฒฐ๋ก
๊ทธ๋ฆฌ๊ณ ๊ทธ๊ฒ ๋ค์ผ. ์ด ๊ฐ๋จํ์ง๋ง ํจ๊ณผ์ ์ธ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ฉด ๋ฉ๋ชจ๋ฆฌ ์ค๋ฒํค๋ ์์ด ๊ฐ๋ ฅํ ๋๊ธฐ์ด ๋ฉ์ปค๋์ฆ์ ์์ฑํ ์ ์์ต๋๋ค.
์๋ฒ ๋๋ ์ด์ ์ฒด์ ์์ ์ฐ๊ฒฐ๋ ๋ชฉ๋ก์ ์ค์ ์ฌ์ฉ์ ๊ด์ฌ์ด ์๋ ๊ฒฝ์ฐ ์๋ฅผ ๋ค์ด Contiki OS ๋ฐ Contiki-NG์์ ์ฐพ์ ์ ์์ต๋๋ค. Zephyr ์ฝ๋ ๊ธฐ๋ฐ์ ๋ ์ ์๊ณ ์๋ค๋ฉด ๊ฑฐ๊ธฐ๋ ์ํฌํ๋ ์ผ๊ตด)
์ฌ๊ธฐ๊น์ง ํด์ฃผ์ ์ ๊ฐ์ฌํฉ๋๋ค! ์ฌ๊ธฐ์์ ๋ฌด์ธ๊ฐ๋ฅผ ๋ฐฐ์ ๋ค๋ฉด ์ฌ๊ธฐ์์ ๋ ๋ง์ IoT ๋ฐ ์๋ฒ ๋๋ ์ํํธ์จ์ด ๊ฐ๋ฐ ์ฝํ ์ธ ๋ฅผ ๋ณด๋ ค๋ฉด ์ ๋ฅผ ํ๋ก์ฐํ๊ณ ! ๐
Ioan Sameli์ ํ์ง ์ด๋ฏธ์ง
Reference
์ด ๋ฌธ์ ์ ๊ดํ์ฌ(Linked Lists ๐๋ก ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ๊ธฐ์ ์ ํฅ์์ํค์ธ์.), ์ฐ๋ฆฌ๋ ์ด๊ณณ์์ ๋ ๋ง์ ์๋ฃ๋ฅผ ๋ฐ๊ฒฌํ๊ณ ๋งํฌ๋ฅผ ํด๋ฆญํ์ฌ ๋ณด์๋ค https://dev.to/vsaw/improve-your-memory-management-skills-with-linked-lists-2o8dํ ์คํธ๋ฅผ ์์ ๋กญ๊ฒ ๊ณต์ ํ๊ฑฐ๋ ๋ณต์ฌํ ์ ์์ต๋๋ค.ํ์ง๋ง ์ด ๋ฌธ์์ URL์ ์ฐธ์กฐ URL๋ก ๋จ๊ฒจ ๋์ญ์์ค.
์ฐ์ํ ๊ฐ๋ฐ์ ์ฝํ ์ธ ๋ฐ๊ฒฌ์ ์ ๋ (Collection and Share based on the CC Protocol.)
์ข์ ์นํ์ด์ง ์ฆ๊ฒจ์ฐพ๊ธฐ
๊ฐ๋ฐ์ ์ฐ์ ์ฌ์ดํธ ์์ง
๊ฐ๋ฐ์๊ฐ ์์์ผ ํ ํ์ ์ฌ์ดํธ 100์ ์ถ์ฒ ์ฐ๋ฆฌ๋ ๋น์ ์ ์ํด 100๊ฐ์ ์์ฃผ ์ฌ์ฉํ๋ ๊ฐ๋ฐ์ ํ์ต ์ฌ์ดํธ๋ฅผ ์ ๋ฆฌํ์ต๋๋ค