์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | |||||
3 | 4 | 5 | 6 | 7 | 8 | 9 |
10 | 11 | 12 | 13 | 14 | 15 | 16 |
17 | 18 | 19 | 20 | 21 | 22 | 23 |
24 | 25 | 26 | 27 | 28 | 29 | 30 |
- Absolute
- AGI
- ai
- AI agents
- AI engineer
- AI researcher
- ajax
- algorithm
- Algorithms
- aliases
- Array ๊ฐ์ฒด
- ASI
- bayes' theorem
- Bit
- Blur
- BOM
- bootstrap
- canva
- challenges
- ChatGPT
- Today
- In Total
A Joyful AI Research Journey๐ณ๐
[47] 230307 Ch. 6 Flask๋ฅผ ํ์ฉํ ์ผ์ ์ ์ด: 1. Flask ์ธํ ํ๊ธฐ, 2. Flask ์น์๋ฒ ๊ตฌ์ถํ๊ธฐ, 3. Flask ๋ผ์ฐํ , 4. Flask LED ์ ์ดํ๊ธฐ [K-๋์งํธ ํธ๋ ์ด๋ 47์ผ] ๋ณธ๋ฌธ
[47] 230307 Ch. 6 Flask๋ฅผ ํ์ฉํ ์ผ์ ์ ์ด: 1. Flask ์ธํ ํ๊ธฐ, 2. Flask ์น์๋ฒ ๊ตฌ์ถํ๊ธฐ, 3. Flask ๋ผ์ฐํ , 4. Flask LED ์ ์ดํ๊ธฐ [K-๋์งํธ ํธ๋ ์ด๋ 47์ผ]
yjyuwisely 2023. 3. 7. 12:49230307 Tue 47th class
Ch. 6 Flask๋ฅผ ํ์ฉํ ์ผ์ ์ ์ด
์ง๋: p. 156 ~ (๊ต์ฌ: IoT ์ฌ๋ฌผ์ธํฐ๋ท์ ์ํ ๋ผ์ฆ๋ฒ ๋ฆฌํ์ด 4 ์ ์, ์ ์: ์ต์ฃผํธ , ๊น์ฌ๋ฒ , ์ ๋์ง)
๊ต์ฌ ์ฝ๋ ๊นํ๋ธ: https://github.com/codingspecialist/RaspberryPi4-Book-Example
๊ต์ฌ ์์ค ๋ฐ PPT: http://jspstudy.co.kr/main/main.jsp
์ ์ ์นดํ: https://cafe.naver.com/metacoding
์ค๋ ๋ฐฐ์ด ๊ฒ ์ค ๊ธฐ์ตํ ๊ฒ์ ์ ๋ฆฌํ๋ค.
๋ชฐ๋๋ ๊ฒ
- ํด๋ผ์ด์ธํธ: ์ปดํจํฐ ๋คํธ์ํฌ์์ ํด๋ผ์ด์ธํธ(client, ๋ฌธํ์ด: ์๋ขฐ๊ธฐ)๋ ๋คํธ์ํฌ๋ฅผ ํตํ์ฌ ์๋ฒ๋ผ๋ ๋ค๋ฅธ ์ปดํจํฐ ์์คํ ์์ ์๊ฒฉ ์๋น์ค์ ์ ์ํ ์ ์๋ ์์ฉ ํ๋ก๊ทธ๋จ์ด๋ ์๋น์ค๋ฅผ ๋งํ๋ค.
- ๋ชจ๋(module)์ด๋ ํ๋ก๊ทธ๋จ์ ๊ตฌ์ฑํ๋ ๊ตฌ์ฑ ์์๋ก, ๊ด๋ จ๋ ๋ฐ์ดํฐ์ ํจ์๋ฅผ ํ๋๋ก ๋ฌถ์ ๋จ์๋ฅผ ์๋ฏธํฉ๋๋ค. ๋ณดํต ํ๋์ ์์ค ํ์ผ์ ๋ชจ๋ ํจ์๋ฅผ ์์ฑํ์ง ์๊ณ , ํจ์์ ๊ธฐ๋ฅ๋ณ๋ก ๋ฐ๋ก ๋ชจ๋์ ๊ตฌ์ฑํฉ๋๋ค. ์ด๋ฌํ ๋ชจ๋์ ํฉ์ณ ํ๋์ ํ์ผ๋ก ์์ฑํ๋ ๋ฐฉ์์ผ๋ก ํ๋ก๊ทธ๋จ์ ๋ง๋ค๊ฒ ๋ฉ๋๋ค. ์์ฒ๋ผ ํ๋ก๊ทธ๋จ ์ฝ๋๋ฅผ ๊ธฐ๋ฅ๋ณ๋ก ๋๋ ์ ๋ ๋ฆฝ๋ ํ์ผ์ ์ ์ฅํ์ฌ ๊ด๋ฆฌํ๋ ๋ฐฉ์์ ๋ชจ๋ํ ํ๋ก๊ทธ๋๋ฐ์ด๋ผ๊ณ ํฉ๋๋ค.
- A view function, or view for short, is a Python function that takes a web request and returns a web response. This response can be the HTML contents of a web page, or a redirect, or a 404 error, or an XML document, or an image . . . or anything, really. The view itself contains whatever arbitrary logic is necessary to return that response.
์ฐธ๊ณ : https://docs.djangoproject.com/en/4.1/topics/http/views/
Django views are Python functions that takes http requests and returns http response, like HTML documents.
(route ๋ฐ์ฝ๋ ์ดํฐ ์๋์ ์์)
์ฐธ๊ณ : https://www.w3schools.com/django/django_views.php
- ๋ผ์ฐํ ์ ๋คํธ์ํฌ์์ ๊ฒฝ๋ก๋ฅผ ์ ํํ๋ ํ๋ก์ธ์ค์ ๋๋ค. ์ปดํจํฐ ๋คํธ์ํฌ๋ ๋ ธ๋๋ผ๊ณ ํ๋ ์ฌ๋ฌ ์์คํ ๊ณผ ์ด๋ฌํ ๋ ธ๋๋ฅผ ์ฐ๊ฒฐํ๋ ๊ฒฝ๋ก ๋๋ ๋งํฌ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค. ์ํธ ์ฐ๊ฒฐ๋ ๋คํธ์ํฌ์์ ๋ ๋ ธ๋ ๊ฐ์ ํต์ ์ ์ฌ๋ฌ ๊ฒฝ๋ก๋ฅผ ํตํด ์ด๋ฃจ์ด์ง ์ ์์ต๋๋ค.
Routing is the process of selecting a path for traffic in a network or between or across multiple networks. Broadly, routing is performed in many types of networks, including circuit-switched networks, such as the public switched telephone network (PSTN), and computer networks, such as the Internet.
[์๋ฆฌ]
return์ ํตํด ์น๋ธ๋ผ์ฐ์ ์ ๊ฐ์ ์ค๋ค.
๊ฐ์ ๋ฐ๋ ๊ฒ์ ๋งค๊ฐ ๋ณ์๋ก ํ๋ค.
์ด๋ฐ ์์ผ๋ก ๊ฐ์ ์ฃผ๊ณ ๋ฐ๋๋ค.
GPIO.cleanup()
GPIO.cleanup()์ ํ์ด์ฌ ํ๋ก๊ทธ๋จ ์์์ ์ด๊ธฐํํ๋ ํ ์ค์ ๋ค์ ๋ชจ๋ '์ฒญ์'(clean up)ํด์ฃผ๋ ๊ธฐ๋ฅ, ์ฆ GPIO ๋ผ์ด๋ธ๋ฌ๋ฆฌ/๋ชจ๋์ด ์ ์ ํ ๋ฆฌ์์ค๋ฅผ ํด์ ํ๋ ๊ธฐ๋ฅ์ ํ๋ค.
GPIO์ ์ฌ์ฉ์ด ๋ชจ๋ ๋๋ ๋(=ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ๋ ๋) GPIO.cleanup() ํจ์๋ฅผ ํธ์ถํ๋๋ก ํ๋ ๊ฒ์ด ์ข๊ณ , ๋ผ์ฆ๋ฒ ๋ฆฌ ํ์ด ๊ฐ๋ฐ์ ์ธก์์๋ ๊ฐ๋ ฅํ ๊ถ์ฅํ๋ ์ฌํญ์ด๋ค.
์ฐธ๊ณ : https://junolefou.tistory.com/5
์ฐธ๊ณ : https://programming119.tistory.com/194
์ฐธ๊ณ : https://hoyeonkim795.github.io/posts/rest_api/
๋ฌผ์ํ ๋ค์ ์ค๋ ๊ฒ์ ์ฟผ๋ฆฌ์คํธ๋ง์ด๋ค.
Vscode์์ Python Flask๊ฐ๋ฐํ๊ฒฝ ๊ตฌ์ถํ๊ธฐ
์ฐธ๊ณ : https://krksap.tistory.com/1766
์์ฝ
1. ๋ผ์ฆ๋ฒ ๋ฆฌํ์ด ์ง๋์๋ํฐ -> vscode ์๋ํฐ
2. vscode ์๋ํฐ + flask framework๋ฅผ ์ค์
3. flask + server ๊ตฌ์ถ
Ch. 6 Flask๋ฅผ ํ์ฉํ ์ผ์ ์ ์ด
์ฑ ์ ๋ชฉ์ฐจ
01 _ Flask ์ธํ ํ๊ธฐ
01-1 ๋ผ์ฆ๋ฒ ๋ฆฌ 4์์ ์ค์นํ๊ธฐ
01-2 Flask ์ค์นํ๊ธฐ
02 _ Flask ์น์๋ฒ ๊ตฌ์ถํ๊ธฐ
03 _ Flask ๋ผ์ฐํ
04 _ Flask LED ์ ์ดํ๊ธฐ
04-1 Flask LED ์ ์ด ์ ์ ๋ผ์ฐํ
04-2 Flask LED ์ ์ด ๋์ ๋ผ์ฐํ ใ์ฐํ๊ดํธใ
04-3 Flask LED ์ ์ด ๋์ ๋ผ์ฐํ ใ์ฟผ๋ฆฌ์คํธ๋งใ
05 _ Flask ์นํ์ด์ง
05-1 Flask, HTML, CSS, Javascript๋ฅผ ์ด์ฉํ ์นํ์ด์ง ๋ง๋ค๊ธฐ
05-2 fetch() ํจ์ ์ดํดํ๊ธฐ
05-3 ํ์ดํ ํจ์ ์ดํดํ๊ธฐ
06 _ IP, Port, Process ๊ฐ๋ ์ก๊ธฐ
06-1 IP ๊ฐ๋ ์ก๊ธฐ
06-2 Port ๊ฐ๋ ์ก๊ธฐ
06-3 Process ๊ฐ๋ ์ก๊ธฐ
07 _ cron๊ณผ daemon ๊ฐ๋ ์ก๊ธฐ
07-1 cron(ํฌ๋ก ) ๊ฐ๋ ์ก๊ธฐ
07-2 daemon(๋ฐ๋ชฌ) ๊ฐ๋ ์ก๊ธฐ
08 _ ๊ณต๊ณต๋ฐ์ดํฐ ํ์ฉํ๊ธฐ
08-1 ๊ณต๊ณต๋ฐ์ดํฐ ์ ์ฒญํ๊ธฐ
08-2 ๊ณต๊ณต๋ฐ์ดํฐ ๋ถ์ํ๊ธฐ
08-3 ํ์ด์ฌ์ ํ์ฉํ์ฌ ์จ์ต๋ ํ์ธํ๊ธฐ
ํ์ต๋ชฉํ
ํ์ต๋ด์ฉ
1 Flask ์ธํ ํ๊ธฐ
WSGI์ฝ์ด์ URL ๋ผ์ฐํ ์ ์ง์ํ๊ธฐ ์ํด werkzeug(๋ฒก์์ด๊ทธ)์ ํ ํ๋ฆฟ ์ถ๋ ฅ์ ์ํด jinja2 ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํจ๊ป ๋ฐฐํฌํ๋ค.
๊ผญ ํ์ํ ํต์ฌ์์๋ฅผ ์ ์ธํ๊ณ ๋ ํ์ํ ๋ ๋ง๋ค ์ง์ ํ๊ฒฝ์ ๋ง์ถฐ ๊ฐ๋ฐ์ ํ๊ณ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฐพ์์ ์ถ๊ฐํด์ผ ํฉ๋๋ค.
- WSGI: The Web Server Gateway Interface is a simple calling convention for web servers to forward requests to web applications or frameworks written in the Python programming language.
- Werkzeug is a collection of libraries that can be used to create a WSGI (Web Server Gateway Interface) compatible web application in Python. A WSGI (Web Server Gateway Interface) server is necessary for Python web applications since a web server cannot communicate directly with Python.
- Routing is the process of selecting a path for traffic in a network or between or across multiple networks. Broadly, routing is performed in many types of networks, including circuit-switched networks, such as the public switched telephone network (PSTN), and computer networks, such as the Internet.
- ํ
ํ๋ฆฟ ์์ง(Template Engine)์ด๋
ํ
ํ๋ฆฟ ์์๊ณผ ํน์ ๋ฐ์ดํฐ ๋ชจ๋ธ์ ๋ฐ๋ฅธ ์
๋ ฅ ์๋ฃ๋ฅผ ํฉ์ฑํ์ฌ ๊ฒฐ๊ณผ ๋ฌธ์๋ฅผ ์ถ๋ ฅํ๋ ์ํํธ์จ์ด(๋๋ ์ํํธ์จ์ด ์ปดํฌ๋ํธ)๋ฅผ ๋งํ๋ค.
๊ทธ ์ค ์น ํ
ํ๋ฆฟ ์์ง(web template engine)์ด๋ ์น ๋ฌธ์๊ฐ ์ถ๋ ฅ๋๋ ํ
ํ๋ฆฟ ์์ง์ ๋งํ๋ค.
์ฐธ๊ณ : https://gmlwjd9405.github.io/2018/12/21/template-engine.html
- Jinja is a web template engine for the Python programming language.
1.1 ๋ผ์ฆ๋ฒ ๋ฆฌ 4์์ ์ค์นํ๊ธฐ
$ sudo apt install code
2. ๋ฉ๋ด์ฐฝ์์ ๊ฐ๋ฐ - Code - OSS๋ฅผ ํด๋ฆญํ๋ฉด ์คํ๋ฉ๋๋ค.
3. ์คํ์ด ์๋ฃ๋๋ค.
4. ๋ฉ๋ด์์ File - Open Folder๋ฅผ ํตํด์ webapps ํด๋๋ฅผ ๊ธฐ๋ณธ ํด๋๋ก ์ค์ ํ๋ค.
1.2 Flask ์ค์นํ๊ธฐ
$ python -V
3. Flask ์ค์น
~ ํ์๋ ํด๋ ์์น๋ฅผ ๋งํ๋ค.
4. ํฐ๋ฏธ๋์์ python ์คํฌ๋ฆฝํธ๋ฅผ ์คํํ๋ค.
$ python
5. flask๊ฐ ์ ์ค์น๋์๋์ง ํ์ธํ๊ธฐ ์ํด flask๋ฅผ import ํ๋ค.
>>> from flask import Flask
์๋ฌด๋ฐ ๋ฉ์์ง๊ฐ ์๋ค๋ฉด ์ ์์ ์ผ๋ก ์ค์น๊ฐ ๋ ๊ฒ์ด๋ค.
6. Python extension์ ์ค์นํ๋ค.
์ค์น ์๋ฆผ์ฐฝ์ด ๋จ์ง ์์ผ๋ฉด ์ผ์ชฝ์ ์๋ ๋๊ตฌ ์ฐฝ ๊ฐ์ฅ ์๋์ ์๋ extension์ ํด๋ฆญํ ๋ค ๊ฒ์์ฐฝ์์ python์ ๊ฒ์ํ์ฌ ์ค์นํ๋ค.
2 Flask ์น์๋ฒ ๊ตฌ์ถํ๊ธฐ
ํด๋ ๊ตฌ์ฑ๊ณผ ํ์ผ ๊ตฌ์ฑ์ ๋ค์๊ณผ ๊ฐ์ด ํ๋ค.
webapps
- ch06
- helloworld
- app_start.py
1. ์ฝ๋๋ฅผ ์์ฑํ๊ณ ์ ์ฅํ๋ค.
[1] app_start.py
from flask import Flask
app = Flask(__name__) #ํ์ผ๋ช
์ ์ฅ
@app.route("/") # ์ด๋ก ์ ์ผ๋ก ๋ค์ด๊ฐ, ์ง์ ํ์ดํํ ์ฃผ์์ / ์๋ต ๊ฐ๋ฅ
#@app.route("/abc")
#@app.route("/main") # ex) http://news.naver.com/main
def helloworld(): #์น๋ธ๋ผ์ฐ์ ์์ ๋ด๋ถ์ ์ผ๋ก ํธ์ถํ๋ค.
return "Hello World"
if __name__ = "__main__": #main ๋ฌธ์์ด ์ ์ฅ
app.run(host="0.0.0.0")
์์ "__main__"์ ์๋ ์๋ฐ์ main()๊ณผ ๊ฐ๋ค.
class A{}
class B{}
class C{
public static void main(){
B b = new B();
A a = new A();
}
}
2. ์คํ๋ฐฉ๋ฒ์ ํฐ๋ฏธ๋์ ์ด๊ณ ์๋๋ฅผ ์ ๋ ฅํ๋ค.
$ cd /home/pi/webapps/ch06/helloworld
$ python app_start.py
3. ์น๋ธ๋ผ์ฐ์ ๋ฅผ ์ด๊ณ ๋ค์ ์ฃผ์๋ฅผ ์ ๋ ฅํ๋ค.
http://localhost:5000
4. ์๋๋ถํฐ ์ฝ๋ ๋ฆฌ๋ทฐ์ด๋ค.
1) from flask์์ flask๋ ํด๋๋ฅผ ์๋ฏธํ๋ค.
from flask import Flask
from flask: flask ํด๋ ๋๋ flask ๋ชจ๋์ด ๋ ์ ์๋ค. ์ฌ๊ธฐ์ flask ๋ชจ๋์ด๋ flask.py ํ์ผ์ ์๋ฏธํ๋ค.
์์ฑํ from flask๋ ํด๋๋ช
์ด๋ค.
2) import Flask์์ Flask๋ ํด๋์ค๋ช ์ด๋ค.
from flask import Flask
import Flask์์ Flask๋ ํด๋์ค๋ช
, ํจ์๋ช
, ๋ณ์๋ช
์ด ๋ ์๋ ์๋ค. ์ด๋ฆ์ด ๋๋ฌธ์๋ก ์์ํ๋ ๊ฒ์ ํด๋์ค์ด๋ค.
๋ผ์ด๋ธ๋ฌ๋ฆฌ path๊ฐ ์ ์ฉ๋ ๊ธฐ๋ณธ ํด๋์์ flask๋ผ๋ ํด๋๋ฅผ ์ฐพ๊ณ , ๊ทธ ์์ ์๋ Flaskํด๋์ค๋ฅผ importํ๋ผ๋ ๋ป์ด๋ค.
import๋ฅผ ํตํด์ ํจ์๋ง ํธ์ถํ ์ ์๋ค.
from ๋ชจ๋๋ช
import ํจ์๋ช
3) app์ Flask ๊ฐ์ฒด๋ฅผ ๊ฐ์ง๋ค.
app = Flask(__name__)
flask ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ค. flask ๊ฐ์ฒด๋ ์น ๋ธ๋ผ์ฐ์ ๋ก ์ค๋ ๋ชจ๋ ์์ฒญ๊ณผ ํ
ํ๋ฆฟ๊ณผ์ ์ฐ๊ณ์ ๊ฐ์ ์น ์ ํ๋ฆฌ์ผ์ด์
์ ๋ฐ์ ๋ํด์ ์ํฅ์ ๋ฏธ์น๋ ๋ฉ์ธ ๊ฐ์ฒด์ด๋ค.
Flask ํด๋์ค๋ ์์ฑ์ ์ธ์๋ฅผ ํ๋ ๋ฐ๊ฒ ๋๋๋ฐ ๋ฐ๋ก __name__์ด๋ค.
__name__ : ๋ด ํ์ผ๋ช
, ์ฆ ๋ชจ๋๋ช
์ ์๋ฏธํ๋ค.
์ฐ๋ฆฌ๊ฐ ๋ง๋ ํ์ผ๋ช
์ด app_start.py์ด๋ฏ๋ก __name__์ app_start.py์ด๋ค.
๊ฒฐ๊ตญ Flask ๊ฐ์ฒด๊ฐ ์์ฑ๋ ๋ app_start.py ํ์ผ๋ช
์ ์ด์ฉํด์ ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ค.
__name__ ๋ด์ฅ ๋ณ์์ด๋ฉด์ ์ ์ญ ๋ณ์์ด๋ค.
์ด ๋ณ์์๋ ํด๋น ํ์ด์ฌ ํ์ผ์ ์ด๋ฆ(์ฌ๊ธฐ์๋app_start)์ด ์ ์ฅ๋๋ค.
์ด๋ ํ์ด์ฌ์ด ํด์์ ํ ๋ app_start.py๋ฅผ ์์์ ์ผ๋ก ํ๊ธฐ ์ํด
app_start.pyํ์ผ์ ์คํํ๋ ๊ฒฝ์ฐ __name__๋ณ์์ __main__(๋ฌธ์์ด)์ด๋ผ๋ ๊ฐ์ ํ ๋นํ๋ค.
๊ฒฐ๋ก : if __name__ == "__main__"์ ์์์ ์ ์๋ฏธํ๋ค.
4) app.route("/")๋ ๋ผ์ฐํ
์ ์ํ ๋ทฐ ํจ์(๋ฐ์ def ํจ์)๋ฅผ ๋ฑ๋กํ๋ ์ฝ๋์ด๋ค.
์ฐธ๊ณ : https://hleecaster.com/flask-introduction
@app.route("/")
"/"์ด๋ฏ๋ก http://localhost:5000/์ผ๋ก ์์ฒญํ๊ฒ ๋๋ฉด ํด๋น route๊ฐ ํธ์ถ๋๋ค.
ํด๋ผ์ด์ธํธ๊ฐ URI๋ก ("/") ์์ฒญ์ ํ๊ฒ ๋๋ฉด ํด๋น route ๋ฐ์ฝ๋ ์ดํฐ ์๋์ ์๋ ๋ทฐ ํจ์๊ฐ ์๋์ผ๋ก ํธ์ถ๋๋ค.
ex) ("/") ์ด๋ ๊ฒ ๋์ด์์ผ๋ http://localhost:5000/์ผ๋ก ์์ฒญํ๊ฒ ๋๋ฉด ํด๋น route๊ฐ ํธ์ถ๋๋ค.
@app.route("/helloworld")
์์ ๊ฐ๋ค๋ฉด ํธ์ถ ๋ฐฉ๋ฒ์ http://localhost:5000/helloworld๊ฐ ๋๋ค.
5) "Hello World"๋ ํจ์๊ฐ ์ข ๋ฃ๋ ๋ ์์ฒญํ์ชฝ์ผ๋ก ์๋ต๋๋ String ๊ฐ์ด๋ค.
def helloworld():
return "Hello World"
route ๋ฐ์ฝ๋ ์ดํฐ๋ฅผ ํตํด์ ๋ทฐ ํจ์๊ฐ ํธ์ถ
* ํด๋ผ์ด์ธํธ๊ฐ ์ฃผ์์์ฒญ์ ํ๊ฒ ๋๋ฉด ๋ทฐ ํจ์๊ฐ ํธ์ถ๋๋ ๋ฐ ์ด๋ ๋ทฐ ํจ์์๋ ํ์์ ์ผ๋ก return๋ฌธ์ด ์์ด์ผ ํ๋ค.
6) app.run()์ด ํธ์ถ๋๋ฉด ์น์๋ฒ๊ฐ ๋์ํ๋ค.
if __name__ = "__main__":
app.run(host="0.0.0.0")
__name__: ๋ ๊ฐ์ง ์ด๋ฆ์ ๊ฐ์ง๋ค.
1. ๋ด ๋ชจ๋๋ช
: app_start.py (ํ์ผ ์ด๋ฆ)
2. app_start.py ํ์ผ์ ์ง์ ํฐ๋ฏธ๋์์ ์คํํ๋ฉด __main__์ด๋ผ๋ ์ด๋ฆ์ ๊ฐ์ง๋ค.
๋ง์ฝ ๋ค๋ฅธ ํ์ผ์์ app_start.py ํ์ผ์ importํด์ ์ฌ์ฉํ๊ฒ ๋๋ฉด __name__์ด __main__์ด๋ผ๋ ์ด๋ฆ์ด ๋ ์ ์๋ค.
__name__์ด __main__์ด ๋๋ ค๋ฉด import๊ฐ ์๋ ํด๋น ํ์ผ์ ์ง์ ์คํ์ํฌ ๋๋ง ๊ฐ๋ฅํ๋ค.
์ ๋ฌธ์ฅ์ด ํ์ํ ์ด์ ๋ app_start.py ํ์ผ์ ์ง์ ์คํ์์ผฐ์ ๋๋ง "์๋ฒ๋ฅผ ์๋์์ผ"๋ผ๋ ๋ป์ด๋ค.
app.run()์ ์๋ฒ๋ฅผ ์์ํ๋ผ๋ ๋ช
๋ น์ด๊ณ , ์ธ์ 0,0,0,0(ip ์ฃผ์)์ ์ด๋ค ip์์ ์์ฒญ์ด ๋ค์ด์๋ ์๋ต์ ํด์ฃผ๊ฒ ๋ค๋ ์๋ฏธ์ด๋ค.
ํ์ฌ ํ์ผ์ด app_start.py import flask
__name__ ==> "_main_"
ํ์ฌ ํ์ผ์ด app_end.py import app_start
__name__ ==> "ํ์ผ๋ช "(app_end)
์ฐธ๊ณ : https://www.freecodecamp.org/korean/news/untitled-2/
3 Flask ๋ผ์ฐํ p. 180
URI ๋์คํจ์น: Flask์์ URL์ ์ฒ๋ฆฌํ๋ ๊ฒ
URI ๋์คํจ์น์ ์ญํ
1) ์ฌ์ฉ์๊ฐ ์
๋ ฅํ URI๋ฅผ ์ง์ผ๋ณด๋ค๊ฐ URI๋ฅผ ๋ถ์ํ์ฌ ์ฌ๋ฐ๋ฅธ ๊ธธ๋ก ์๋ดํด์ค๋ค.
2) ๋ทฐ ๋ฐ์ฝ๋ ์ด์
์ ํตํด์ ๋ทฐ ํจ์๋ฅผ ์์ฑํ์ฌ ์ฌ๋ฐ๋ฅธ ๊ธธ๋ก ์๋ดํด์ค๋ค.
URI๋ ํน์ ๋ฆฌ์์ค๋ฅผ ์๋ณํ๋ ํตํฉ ์์ ์๋ณ์(Uniform Resource Identifier)๋ฅผ ์๋ฏธํ๋ค. ์น ๊ธฐ์ ์์ ์ฌ์ฉํ๋ ๋ ผ๋ฆฌ์ ๋๋ ๋ฌผ๋ฆฌ์ ๋ฆฌ์์ค๋ฅผ ์๋ณํ๋ ๊ณ ์ ํ ๋ฌธ์์ด ์ํ์ค๋ค.
์ฐธ๊ณ : https://www.charlezz.com/?p=44767
[2] app_start.py
from flask import Flask
app = Flask(__name__)
@app.route("/")
def helloworld():
return "Hello World"
@app.route("/led/on")
def led_on():
return "LED ON"
@app.route("/led/off")
def led_off():
return "LEF OFF"
if __name__ == "__main__":
app.run(host="0.0.0.0")
return์ ํตํด ์น๋ธ๋ผ์ฐ์ ์ ๊ฐ์ ์ค๋ค.
๊ฐ์ ๋ฐ๋ ๊ฒ์ ๋งค๊ฐ ๋ณ์๋ก ํ๋ค.
์ด๋ฐ ์์ผ๋ก ๊ฐ์ ์ฃผ๊ณ ๋ฐ๋๋ค.
2. ์น๋ธ๋ผ์ฐ์ ๋ฅผ ์ด์ด์ ์คํ์ํจ๋ค.
์น๋ธ๋ผ์ฐ์ ์ localhost:5000/led/on ์
๋ ฅ ์ ์น๋ธ๋ผ์ฐ์ ์ LED ON ๋ฉ์์ง ์ถ๋ ฅ
์น๋ธ๋ผ์ฐ์ ์ localhost:5000/led/off ์
๋ ฅ ์ ์น๋ธ๋ผ์ฐ์ ์ LED OFF๋ฉ์์ง ์ถ๋ ฅ
4 Flask LED ์ ์ดํ๊ธฐ
4.1 Flask LED ์ ์ด ์ ์ ๋ผ์ฐํ
p. 181
[3] app_start.py
from flask import Flask
import RPi.GPIO as GPIO
app = Flask(__name__)
LED = 8 #GPIO 8๋ฒ๊ณผ ์ฐ๊ฒฐ
GPIO.setmode(GPIO.BOARD) #BOARD๋ ์ปค๋ฅํฐ pin๋ฒํธ ์ฌ์ฉ
GPIO.setup(LED, GPIO.OUT, initial=GPIO.LOW)
@app.route("/")
def helloworld():
return "Hello World"
@app.route("/led/on")
def led_on():
GPIO.output(LED, GPIO.HIGH)
return "LED ON"
@app.route("/led/off")
def led_off():
GPIO.output(LED, GPIO.LOW)
return "LED OFF"
@app.route("/gpio/cleanup")
def gpio_cleanup():
GPIO.cleanup()
return "GPIO CLEANUP"
if __name__ == "__main__":
app.run(host="0.0.0.0")
์ฐธ๊ณ
์ ํญ์ 200์ด ์ด์๋ง ๋๋ค๋ฉด OK!!
06 ์น๋ธ๋ผ์ฐ์ ๋ฅผ ์ด์ด์ localhost:5000/gpio/cleanup์ผ๋ก ์ ์ํ๋ค. (์ฃผ์์ฐฝ์ ์ ๋๋ค.)
๊ฒฐ๊ณผ: GPIO CLEANUP
์ฐธ๊ณ : https://kibua20.tistory.com/95
๊ฒฐ๊ณผ:
Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
Protocol ํ๋กํ ์ฝ: http://0.0.0.0
Port ํฌํธ๋ฒํธ: 5000
์ฐธ๊ณ : https://code.visualstudio.com/docs/python/tutorial-flask
http://localhost:5000/led/off <๋ณ์๋ช >: ์ฐํธ ๊ดํธ
//๋ณ์๋ช (state) = ๊ฐ(off) (๋ฌธ์์ด์ด์ด๋ off๋ก ํ์ํ๋ค. " " ์ ์ด๋ค.)
http://localhost:5000/led/?state=off : ์ฟผ๋ฆฌ์คํธ๋ง
4.2 Flask LED ์ ์ด ๋์ ๋ผ์ฐํ
ใ์ฐํ ๊ดํธใ
ํด๋น ๋ณ์๊ฐ ํด๋ผ์ด์ธํธ๋ก ๋ถํฐ URL๋ก ์ ๋ฌ๋๋ฉด ํจ์์ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์์ค์ผ ์ฌ์ฉ์ด ๊ฐ๋ฅํฉ๋๋ค.
app_start.py
from flask import Flask
import RPi.GPIO as GPIO
app = Flask(__name__)
LED = 8
GPIO.setmode(GPIO.BOARD) #BOARD๋ ์ปค๋ฅํฐ pin๋ฒํธ ์ฌ์ฉ
GPIO.setup(LED, GPIO.OUT, initial=GPIO.LOW)
@app.route("/")
def helloworld():
return "Hello World"
@app.route("/led/<state>")
def led(state):
if state == "on":
GPIO.output(LED, GPIO.HIGH)
else:
GPIO.output(LED, GPIO.LOW)
return "LED" +state
@app.route("/gpio/cleanup")
def gpio_cleanup():
GPIO.cleanup()
return "GPIO CLEANUP"
if __name__ = "__main__"
app.run(host="0.0.0.0")
4.3 Flask LED ์ ์ด ๋์ ๋ผ์ฐํ ใ์ฟผ๋ฆฌ ์คํธ๋งใ?state=on
//๋ณ์๋ช
(state) = ๊ฐ(off) (๋ฌธ์์ด์ด์ด๋ off๋ก ํ์ํ๋ค. " " ์ ์ด๋ค.)
http://localhost:5000/led/?state=off : ์ฟผ๋ฆฌ์คํธ๋ง
๋์ ์ผ๋ก ๋ณ๊ฒฝ๋๋ URLํจ์๋ ์ฟผ๋ฆฌ ์คํธ๋ง ๋ฐฉ์์ผ๋ก๋ ํธ์ถ ๊ฐ๋ฅํ๋ค. ์ฟผ๋ฆฌ ์คํธ๋ง์ด๋
http://localhost:5000/led?state=on
์ฒ๋ผ ์ฃผ์ ํธ์ถ์ด ์ฌ ๋ ? ๋ค์ ์ค๋ ๊ฒ์ ๋งํ๋ค.
? ๋ค์ ์ค๋ ๊ฒ๋ค์ HTTP์์ฒญ์์ GET๋ฐฉ์์ผ๋ก ์์ฒญ ๊ฐ๋ฅํ๋ค.
์ ๋ฌ๋๋ ๋ฐ์ดํฐ๋ฅผ request ํด๋์ค์ args ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ ์ ์๋ค.
from flask import Flask, request
app_start.py
from f1
from flask import Flask
import RPi.GPIO as GPIO
app = Flask(__name__)
LED = 8
GPIO.setmode(GPIO.BOARD) #BOARD๋ ์ปค๋ฅํฐ pin๋ฒํธ ์ฌ์ฉ
GPIO.setup(LED, GPIO.OUT, initial=GPIO.LOW)
@app.route("/")
def helloworld():
return "Hello World"
@app.route("/led")
def led():
state = request.args.get("state") #on์์ ๋ณ์์ด๋ฆ์ด "state"์ธ ๊ฒ์ ๊ฐ์ ธ์จ๋ค.
if state == "on":
GPIO.output(LED, GPIO.HIGH)
else:
GPIO.output(LED, GPIO.LOW)
return "LED"+state
@app.route("/gpio/cleanup")
def gpio_cleanup():
GPIO.cleanup()
return "GPIO CLEANUP"
if __name__ = "__main__"
app.run(host="0.0.0.0")
2. ์น๋ธ๋ผ์ฐ์ ๋ฅผ ์ด์ด์ localhost:5000/led?state=on์ผ๋ก ์ ์ํ๋ค. (=์ฃผ์์ฐฝ์ ์ ๋๋ค.)
๊ฒฐ๊ณผ(์นํ์ด์ง์ ๋ฌ๋ค.): LED on
3. ์น๋ธ๋ผ์ฐ์ ๋ฅผ ์ด์ด์ localhost:5000/led?state=off๋ก ์ ์ํ๋ค.
๊ฒฐ๊ณผ: LED off
4. ๊ฒฐ๊ณผ:์น๋ธ๋ผ์ฐ์ ๋ฅผ ์ด์ด์ localhost:5000/led๋ก ์ ์ํ๋ค. (?๊ฐ ์์ผ๋ฏ๋ก)
๊ฒฐ๊ณผ: Internal Server Error ์นํ์ด์ง๊ฐ ๋ฌ๋ค.
์๋ฒ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
์ด์ ๋ ๋ทฐ ํจ์์์๋ ์ฟผ๋ฆฌ์คํธ๋ง์ ๋ฐ๊ธฐ ์ํ ์ฝ๋๊ฐ ์ค๋น๋์ด ์์ง๋ง ์ฃผ์ ์์ฒญ ์ ์ฟผ๋ฆฌ์คํธ๋ง์ ์ ๋ฌํ์ง ์์๊ธฐ ๋๋ฌธ์ด๋ค.
์ด๋ด ๊ฒฝ์ฐ, ๋ฌผ๋ก ์ฟผ๋ฆฌ์คํธ๋ง์ ์ ์์ ์ผ๋ก ๋ณด๋ด๊ฒ ๋๋ฉด ์ค๋ฅ๊ฐ ๋์ง ์๊ฒ ์ง๋ง ๋ฏธ๋ ๋๋นํ๋ฉด ์ข๋ค.
5. app_start.py ํ์ผ์ ์์ ํ๋ค.
@app.route("/led")
def led():
state = request.args.get("state") #on์์ ๋ณ์์ด๋ฆ์ด "state"์ธ ๊ฒ์ ๊ฐ์ ธ์จ๋ค.
if state == "on":
GPIO.output(LED, GPIO.HIGH)
else:
GPIO.output(LED, GPIO.LOW)
elif state == "error":
return "์ฟผ๋ฆฌ์คํธ๋ง state๊ฐ ์ ๋ฌ๋์ง ์์์ต๋๋ค."
else:
return "์๋ชป๋ ์ฟผ๋ฆฌ์คํธ๋ง์ด ์ ๋ฌ๋์์ต๋๋ค."
return "LED"+state
6. ๋ค์ํ๊ฒ ์ฃผ์๋ฅผ ์ ๋ ฅํ์ฌ ํ ์คํธํ๋ค.
localhost5000/led #state == "error"
#๊ฒฐ๊ณผ: ์ฟผ๋ฆฌ์คํธ๋ง state๊ฐ ์ ๋ฌ๋์ง ์์์ต๋๋ค.
localhost5000/led?see=on #state == "error"
#๊ฒฐ๊ณผ: ์ฟผ๋ฆฌ์คํธ๋ง state๊ฐ ์ ๋ฌ๋์ง ์์์ต๋๋ค.
localhost5000/led?state= #๋ค์ ๋น์์
#๊ฒฐ๊ณผ: ์๋ชป๋ ์ฟผ๋ฆฌ์คํธ๋ง์ด ์ ๋ฌ๋์์ต๋๋ค.
localhost5000/led?state=hello #on, off๋ง ์ค์ ํ์
#๊ฒฐ๊ณผ: ์๋ชป๋ ์ฟผ๋ฆฌ์คํธ๋ง์ด ์ ๋ฌ๋์์ต๋๋ค.