Krátké shrnutí o mně.
Informace o mém projektu.
První obrysy mého projektu.
Mé první kroky v CAD, laserové vyřezávání a vlastní stavebnice.
Základy 3D skenování a 3D tisku.
Pájení jednoduchého obvodu.
Tvorba kinetické struktury.
Arduino, senzory a vstupní zařízení.
Aktuátory a vástupní zařízení.
Velké CNC obrábění.
ESP32, bezdrátová komunikace.
Programování hry a aplikace.
Týmová tvorba stroje.
Tvorba forem a odlévání všeho druhu.
Shrnutí obsahu pro týden 14.
O mně
Jmenuji se Ondřej Plšek a již druhým rokem studuji program Kybernetika a robotika na ČVUT FEL. Ve volném čase se nejraději věnuji hudbě, čtení nebo fotografování. Moje oblíbená kapela jsou The Beatles, sám jinak hraji od dětství na kytaru. Co se týče čtení, nejraději mám klasické nebo fantasy romány. Rád si také rozšiřuji obzory populárně naučnou literaturou nebo filozofií. Samotné fotografování pak rád spojuji s cestováním po různých zemích. Nejraději fotím přírodu a zvířata obecně. S tím je ostatně i spojen můj projekt v rámci předmětu JVC.
Fotopast
Jako svůj závěrečný projekt bych chtěl udělat fotopast, tedy automatizovaný fotoaparát sloužící k zachycení fotografie volně žijících zvířat. Měla by být v ideálním případě schopna pracovat v odlehlé oblasti (v mém případě v lese) a odesílat data na cloud. Také by měla být schopna pracovat delší dobu úplně samostatně. Její kostra a case bude vytisknutá na 3D tiskárně. Systém fotopasti pak bude tvořen souhrou mikrokontroleru Arduino a Raspberry Pi (dále Rpi).
Co se chci při tomto projektu naučit?
- Pracovat s Rpi
- Navrhnout energeticky efektivní systém, který dokáže delší dobu samostatně pracovat
- Navrhnout systém, který je tvořen Arduinem i Rpi
- Odesílat data pomocí GSM modulu
- Smysluplně dokumentovat větší projekt
Schéma funkce
Obecně o funkci projektu
Po celou dobu běhu projektu poběží Arduino s pohybovým PIR senzorem. V moment, co PIR senzor detekuje objekt se zapne Rpi začne natáčet video. Poté, co toto video natočí ho uloží do Rpi a zároveň nahraje část obsahu (pár fotek) na Google Drive. Aby mohla fotopast fungovat i v odlehlých oblastech, bude k Rpi připojen GSM modul, který zprostředkuje datové připojení. To přináší značnou výhodu, protože běžné fotopasti ukládají data pouze do zařízení.
Má motivace
Proč jsem se rozhodl právě pro tento projekt? Fotopast mi přijde jako zajímavé zařízení na sledování chování zvířat v přírodě. Pokud bychom je chtěli sledovat „standartně“ s dalekohledem, bylo by to časově náročné, neefektivní a rušili bychom přirozený život zvířat. Naopak s fotopastí je nijak nerušíme. Výhodou je také možnost připevnění několika IR LEDek, které v kombinaci se správnou kamerou umožňují natáčet i ve tmě, kdy jsou volně žijící zvířata běžně nejaktivnější (a protože IR není ve viditelném spektru, tak to zvířata nijak neruší).
Krátce k hlavní konstrukci – od počátku jsem chtěl, aby systém obsahoval Raspberry Pi, s kterým jsme se během kurzu JVC na rozdíl od Arduina z pochopitelných důvodů neučili pracovat. Raspberry Pi je na hodně věcí vhodnější, především díky většímu výpočetnímu výkonu a podpoře více knihoven. Takže ano, na nahrávání videa bych mohl použít ESP32, které je více podobné Arduinu a pravděpodobně by to tak bylo jednodušší. Ale třeba nahrávání dat na Google Drive nebo používání GSM modulu by bylo bez Raspberry Pi složitější. Nyní se podrobněji podíváme na jednotlivé části projektu.
Raspberry Pi
Výběr Raspberry Pi
Raspberry Pi obecně umožňuje daleko složitější operace než pouze natáčení videa, tudíž jsem hledal spíše méně výkonné verze. Důležitá pro mě byla také jeho energetická spotřeba, jelikož bych byl rád, aby fotopast fungovala co nejdéle. Proto jsem se nakonec rozhodl vybrat Raspberry Pi Zero 2 W, které je pro tyto účely nejvhodnější a umožňuje také připojení GSM modulu.
Zprovoznění Raspberry Pi
Nejdříve jsem se rozhodl zprovoznit Rpi. Nejprve jsem musel na mikro SD kartu nahrát operační systém pro Rpi. K tomu jsem použil aplikaci Raspberry Pi Imager. Zde jsem zvolil operační systém Rapberry Pi OS Lite (32-bit). Ten jsem zvolil, protože je pro funkci kamery dostatečný. Také je vhodný z hlediska rychlého spuštění operačního systému, což bude pro funkci fotopasti esenciální. Pak jsem v dodatečném nastavení ještě povolil SSH, zadal informace o mé Wi-Fi a nastavil jméno a heslo mého zařízení. Pomocí tohoto jména a hesla se pak budu přes SSH přes Wi-Fi připojovat k Rpi přes PC.
Pak jsem k němu připojil kameru Raspberry Pi NoIR camera V2 (nutno upozornit, že pro toto Rpi je potřeba přikoupit menší kabel, který není součástí běžného balení).
Pro samotné SSH připojování jsem používal extension Remote – SSH pro Visual Studio Code. Pak se dá k zařízení připojit pomocí příkazu „ssh pi_name@pi_IP_adress“, po kterém nás terminál vyzve k zadání dříve nastaveného hesla. Následně už terminál ovládá Rpi a my v něm můžeme začít pracovat.
Nastavení Raspberry Pi
Nejdříve jsem nainstaloval všechny potřebné knihovny/programy pro tento projekt pomocí příkazu sudo apt install: git, python3, python3-pip, python3-venv, python3-dev build-essential, libcamera-apps, python3-picamera2, ffmpeg, rclone.
Git slouží k práci s Git repozitářem, kam jsem si zálohoval všechny programy z Rpi. Kód pro natáčení videa je psán v Pythonu a vyžaduje tedy některé knihovny pro Python a pro samotnou kameru. Knihovna ffmpeg slouží pro převod videa do formátu .mp4. Program rclone slouží k přenosu dat na námi zvolený cloud server, v mém případě Google drive.
Program rclone jsem musel ještě nakonfigurovat pomocí příkazu rclone config, který provede uživatele nastavením programu. Jelikož mé Rpi je v tomto nastavení bez GUI interface, musí se část nastavení (konkrétně přihlášení ke Google Drive) provést na PC.
Nejdříve jsem vytvořil program pro natočení videa. Tento program také zároveň video uloží na Rpi. Každé video je pojmenováno podle času a data natočení, díky čemuž má každé unikátní jméno (pokud by to tak nebylo, tak by se neustále přepisoval 1 a ten samý soubor; toto mi přišlo jako nejjednodušší způsob, jak tomu zabránit). Na konci tohoto programu je 2 minutový delay pro případ, že bych chtěl něco upravit, abych měl čas vypnout automatické vypínání. V běžném provozu by toto bylo odstraněno. Nakonec se Rpi korektně vypne pomocí sudo poweroff.
Aktuálně tedy program již zvládne natočit a uložit video a vypnout Rpi. Aby byl program pro Rpi kompletní, musíme ještě přidat funkcionalitu, která ihned po spuštění Rpi automaticky spustí program natáčení videa a přidat posílání dat pomocí GMS modulu. Tím se uzavře celý cyklus práce Rpi v tomto projektu.
Přidání GSM modulu
Pak jsem přidal GSM modul Waveshare R800C GSM/GPRS HAT, který umožňuje datové připojení a posílání SMS. Nejprve jsem otestoval jeho funkci v prostředí minicom, abych měl jistotu, že vše funguje tak, jak má. Zde se dá otestovat připojení k síti, posílání a přijímání SMS a datový přenos. Při tomto testování mi tyto funkce nejdříve fungovaly, ale další den už přestaly fungovat – v mém případě SIM zablokoval operátor, protože mé zařízení nebylo mezi povolenými zařízeními pro SIM (naštěstí šlo vyřešit pár telefonáty s operátorem a týdenním čekáním), takže na to je při výběru SIM také potřeba myslet.
Pak jsem následovně upravil 2 soubory pro GSM:
Soubor /etc/chatscripts/gprs:
ABORT BUSY
ABORT "NO CARRIER"
ABORT "NO DIALTONE"
ABORT "NO DIAL TONE"
ABORT "NO ANSWER"
ABORT "DELAYED"
ABORT "ERROR"
ABORT "+CGATT: 0" # if GPRS not connected, end
"" AT
TIMEOUT 12
OK ATH
OK ATE1
OK AT+CGDCONT=1,"IP","internet" # for operator O2
OK AT+CGATT=1 # connect GPRS
OK ATD*99# # dial data connection
TIMEOUT 22
CONNECT ""
Soubor /etc/ppp/peers/gprs:
/dev/serial0 115200
connect 'chat -v -f /etc/chatscripts/gprs'
noauth
defaultroute
replacedefaultroute
usepeerdns
persist
noipv6
Do kódu jsem pak přidal funkce start_gprs a wait_for_ppp0, které zprostředkovávají rozhraní pro GSM modul. Vzhledem k tomu, že GSM modul většinou operuje v rychlostech kolem 20 KB/s, je vhodné nahrávat na Google Drive pouze několik fotek z průběhu videa. Tím zjistíme, zda se opravdu něco zajímavého natočilo a můžeme pak video v plném rozlišení stáhnout přes kabel z Rpi. Následující kód pak nahrává kromě toho i video na Google Drive a to z důvodu prezentace projektu, abych mohl jednoduše ukázat i výsledek (Rpi se připojí na hotspot a přes něj to odešle rclone).
Zde je tedy kompletní Python program, který běží na Raspberry Pi:
#!/usr/bin/env python3
import sys
import subprocess
from pathlib import Path
from datetime import datetime
from picamera2 import Picamera2
from picamera2.encoders import H264Encoder
from picamera2.outputs import FfmpegOutput
import time
import os
# Set path to gitlab repository and flag-file
REPO_DIR = Path(__file__).resolve().parent
FLAG = REPO_DIR / ".production_mode"
# Local directory for saving photos
PHOTOS_BASE_DIR = REPO_DIR.parent / "photos"
VIDEOS_DIR = REPO_DIR.parent / "videos"
def start_gprs() -> bool:
"""
Starts PPP connection for GPRS (uses /etc/ppp/peers/gprs).
Returns True if 'ppp0' is up, otherwise False.
"""
try:
subprocess.run(["sudo", "pppd", "call", "gprs"], check=True)
except subprocess.CalledProcessError as e:
print(f"[ERROR] start_gprs failed: {e}", file=sys.stderr)
return False
return True
def wait_for_ppp0(timeout: int = 30) -> bool:
"""
Waits for interface ppp0 to appear, up to seconds.
Returns True if ppp0 exists, otherwise False.
"""
start_time = time.time()
while time.time() - start_time < timeout:
result = subprocess.run(
["ip", "addr", "show", "ppp0"],
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
)
if result.returncode == 0:
return True
time.sleep(1)
return False
def main() -> None:
# Prepare photo directory named by HH_MM in parent 'photos' directory
now = datetime.now()
folder_name = now.strftime("%H_%M")
photos_dir = PHOTOS_BASE_DIR / folder_name
os.makedirs(photos_dir, exist_ok=True)
# Video configuration: 24 fps, bitrate 2 Mbps
picam2 = Picamera2()
video_config = picam2.create_video_configuration(
controls={"FrameRate": 24}
)
picam2.configure(video_config)
encoder = H264Encoder(bitrate=2_000_000)
# Save video with timestamp to 'videos' directory
ts = now.strftime("__%H_%M_%S____%d_%m_20%y")
video_file = REPO_DIR.parent / "videos" / f"vid_{ts}.mp4"
output = FfmpegOutput(str(video_file))
# Record video and take photos every 5 seconds (30s total)
picam2.start_recording(encoder, output)
intervals = 3 # 30s / 10s
for _ in range(intervals):
time.sleep(10)
photo_ts = datetime.now().strftime("%Y%m%d_%H%M%S")
photo_file = photos_dir / f"photo_{photo_ts}.jpg"
picam2.capture_file(str(photo_file))
print(f"Photo saved: {photo_file}")
picam2.stop_recording()
picam2.close()
print(f"Video saved as: {video_file}")
print("Starting GPRS (ppp0) …")
start_gprs() # success or failure only affects the log
if wait_for_ppp0(30):
print("ppp0 is up, proceeding with rclone upload…")
else:
print("ppp0 not detected, trying to upload via any available link.")
# Upload photos to Google Drive in subfolder HH_MM
try:
subprocess.run(
["rclone", "copy", str(photos_dir), f"gdrive:JVC_videos/{folder_name}", "--progress"],
check=True
)
print("Photos upload finished.")
subprocess.run(["rclone", "copy", str(video_file), "gdrive:JVC_videos/", "--progress", "--verbose"], check=True)
print("Video upload finished.")
except subprocess.CalledProcessError as err:
print(f"Upload FAILED: {err}", file=sys.stderr)
print("Waiting 2 minutes before shutdown…")
time.sleep(120)
# Shutdown the device in production mode
print("Initiating shutdown …")
subprocess.run(["sudo", "shutdown", "-h", "now"])
if __name__ == "__main__":
main()
Automatické spuštění programu
K tomu, aby se ihned po spuštění Rpi spustil program na natáčení videa jsem musel vytvořit soubor služby v umístění /etc/systemd/system/auto_record.service. Do toho jsem pak vložil následující obsah:
[Unit]
Description=Run record video script after boot
# After=network-online.target # Runs script after network initialization
[Service]
Type=simple
WorkingDirectory=/home/pi/code/jvc_projekt
# script working directory
ExecStart=/usr/bin/python3 /home/pi/code/jvc_projekt/record_video.py
# must be absolute path
Restart=on-failure
# restarts this service if an error occures
User=pi
[Install]
WantedBy=multi-user.target
Tento soubor uložíme, pak načteme novou definici služeb pomocí příkazu sudo systemctl daemon-reload. Následně povolíme automatické spuštění po bootu pomocí příkazu sudo systemctl enable auto_record.service. Po spuštění Rpi tedy tento program spustí program v daném adresáři.
Arduino
Výběr Arduina
Jak vyplývá z kapitoly o obecné funkci tohoto projektu, Arduino poběží po celou dobu funkce projektu. Tím pádem bude jeho energetická spotřeba klíčová v celkové spotřebě projektu. Nízká spotřeba sice implikuje i nižší výpočetní výkon, ale vzhledem k tomu, že potřebujeme pouze pracovat s jedním senzorem a spínat MOSFET, tak nám to vůbec nevadí. Proto jsem si zvolil Arduino Pro Mini, které se k tomuto projektu hodí nejvíce.
Zprovoznění Arduina
Nevýhodou mnou zvoleného Arduina bylo to, že k nahrávání programu je potřeba použít externí USB konektor. Po jeho připojení jsem testoval funkci pohybového PIR senzoru HC-SR501. Jak tento senzor funguje? Na senzoru se dají manuálně nastavit 2 parametry senzoru – sensitivity a time delay. Sensitivity nastavuje citlivost senzoru, a tedy i vzdálenost, na kterou detekuje pohyb. Tu jsem nastavil jako maximální, což by dle výrobce mělo zajistit detekci až na vzdálenost sedmi metrů. Druhý ukazatel vyjadřuje, jak dlouho se drží výstup senzoru na napětí HIGH. Tuto funkci ale nepoužívám, a tak jsem ji nastavil na střední hodnotu, protože s to pro mě není důležité.
Funkce Arduina
Arduino běží v tomto projektu neustále. Když detekuje pohyb pomocí PIR senzoru, sepne pomocí MOSFET modulu LR7843 Raspberry Pi a IR LEDky. V tomto stavu čeká 10 minut (během kterých pracuje Rpi) a pak nastaví MOSFET do režimu OFF. Takto vypadá celý kód běžící na Arduinu:
// PIR output
const int pir_sensor_pin = 2;
// test LED
const int led_pin = 13;
// MOSFET
const int mosfet_pin = 3;
// How long to keep MOSFET on (10 minutes)
const unsigned long ON_TIME_MS = 10UL * 60UL * 1000UL;
void setup() {
Serial.begin(9600);
pinMode(pir_sensor_pin, INPUT);
pinMode(led_pin, OUTPUT);
pinMode(mosfet_pin, OUTPUT);
// ensure MOSFET + LED are off at start
digitalWrite(mosfet_pin, LOW);
digitalWrite(led_pin, LOW);
}
void loop() {
// if PIR detects motion
if (digitalRead(pir_sensor_pin) == HIGH) {
Serial.println("Motion detected! MOSFET on for ON_TIME.");
digitalWrite(led_pin, HIGH); // zapni kontrolní LED
digitalWrite(mosfet_pin, HIGH); // sepni MOSFET
// hold on high for ON_TIME
delay(ON_TIME_MS);
digitalWrite(mosfet_pin, LOW);
digitalWrite(led_pin, LOW);
}
delay(100);
}
IR LEDky
Jelikož kamera použitá na Rpi podporuje i natáčení videa ve tmě při přisvicování IR LEDkami, přidal jsem ještě k celému projektu 6 těchto LEDek. Vybral jsem konkrétně Super-bright 5mm IR LED - 940nm, což byly nejsvětlejší LED, co jsem našel. I tak z mého testování vyplynulo, že by bylo potřeba ještě více ledek, ale na krátkou vzdálenost relativně rozumně fungovaly, takže jsem se s výsledkem spokojil. Kdybych jich totiž použil více, tak by už odebíraly příliš mnoho energie a nepřišlo mi to jako dobrý trade-off. Zde je pak ilustrační snímek mého psa vyfoceného za pološera, je vidět že jeho tmavý obličej je hůře viditelný:
Konstrukce
Vzhledem k povaze mého projektu jsem se rozhodl si udělat vlastní napájení. Jak Arduino, tak Rpi potřebují napětí 5V, takže jsem se rozhodl použít 2S zapojení GeB Li-Ion baterií 18650 3000mAh 3.7 V. Jelikož mi kapacita přišla malá, přidal jsem ke každé z nich ještě jednu stejnou paralelní baterii (viz schéma níže). K těmto bateriím jsem pak přidal ochranu a balancér Li-Ion baterie 2S 20A. Na výstup této ochrany jsem pak připojil LaskaKit AP63300 Step-down měnič 5.5-32V 5V/3A, který je pro mé účely ideální. Z toho jsem pak napájení rozvedl pomocí svorkovnic na další spotřebiče. Celkové zapojení pak vypadalo takto:
Celé pouzdro jsem se rozhodl vytisknout na 3D tiskárně. To jsem navrhl ve Fusion 360 tak, aby se do něj tak akorát vešly všechny komponenty:
Následně jsem navrhnul i jednoduché víko pro toto pouzdro:
Finální podoba projektu
Takto vypadala má hotová fotopast:
Bohužel zevnitř vypadala o trošku hůře, jelikož se mi před závěrečnou prezentací povedlo zkratem zničit ochranu i step down, takže jsem musel improvizovat. Nakonec šlo napájení celkem jednoduše nahradit powerbankou s USB redukcí, kterou jsem používal pro připojení k Arduinu. Powerbanka ovšem zabírá mnohem více místa než původní řešení a není pro tento typ projektu ideální. Následkem toho ale uvnitř nebylo tolik místa, kolik jsem původně doufal, což je z obrázku vcelku evidentní:
Po zkouškovém bych toto rád opravil, abych zařízení mohl plně využít.
Jinak je ale projekt funkční, takto vypadá video natočené za dne:
Kvůli tomu, že IR LEDky svítí i za dne, je celý obraz v růžovém zbarvení. Nevidím to jako velký nedostatek, zbarvení by se dalo odstranit převedením obrazu do grayscale. LEDky nevypínám za dne, protože mi to v danou chvíli nepřišlo důležité řešit z hlediska úspory energie a funkčnosti všeobecně. Do budoucna zvažuji, že přidám další MOSFET právě pro tuto funkci.
A takto pak vypadá video natočené za šera:
Díky osvícení vidíme více detailů, ale je vidět, že tmavší rysy mého psa (čumák) už jsou i tak hůře viditelné. Pro viditelnost obrysů by ale z blízka měly být dostatečné.
I když má projekt ještě jisté nedostatky, tak jsem rád, že jsem k jeho tvorbě dostal v tomto předmětu příležitost. Nakonec jsem se při jeho vytváření naučil mnohem více, než jsem původně myslel, obzvláště v oblasti elektroniky, se kterou jsem doposud neměl prakticky žádné zkušenosti v praxi.
Týden 1
Tento týden jsem vytvořil tyto webové za pomocí ChatGPT tyto webové stránky.
Návrh závěrečného projektu
Jako závěrečný projekt bych chtěl sestavit jednoduchý fotoaparát. V první fázi bych rád fotoaparát zprovoznil v režimu, kdy se údaje z čipu fotoaparátu přenášejí do počítače, kde se dále zpracují a vytvoří se zde i finální obrázek, viz schéma:
S výrobou tohoto typu nemám prakticky žádné zkušenosti, tudíž nemám moc představu jak náročné pro mě bude realizace tohoto projektu. Rád bych ale stihl více než tento "základ" a projekt pak dále rozšiřoval například snižováním závislosti na PC nebo přidáváním nových funkcí (video, barevné filtry, LCD displej, ...).
Požadavek na obrázku vpravo ohledně bajonetu (tedy závitu) vychází z toho, že výrobní proces objektivů je velmi náročný a drahý (pro zájemce doporučuji krátké video o výrobním procesu https://www.youtube.com/watch?v=YilqiH7e3jo ). Proto jsem se rozhodl, že bude vhodnější, pokud fotoaparát uzpůsobím tak, aby byl kompatibilní s některým z objektivů Canon, který už vlastním.
Podobná situace nastává i se senzorem fotoaparátu. Zde bych musel použít buď senzor ze starého fotoaparátu, nebo Raspberry Pi (se kterým by ale zase mohlo být zařízení zcela nezávislé na PC).
Týden 2
V tomto týdnu jsme se věnovali 2D modelování a vyřezávání. Nejdříve jsme měli za úkol změřit a pomocí CAD nakreslit libovolný objekt, já jsem se rozhodl vymodelovat stolní lampičku, na které jsem se naučil pracovat s funkcemi revolve (3D objekt ze sketche) a fillet (tvorba zaoblených hran):
Dále jsme navrhovali a vyřezávali vlastní nálepky a stavebnice.
Nálepka
Rozhodl jsem se udělat nálepku loga Fireflies ze hry The Last of Us, která má jednoduchý design, který se mi líbí. Nálepku jsem vykreslil v programu Fusion 360. Využil jsem toho, že do tohoto programu lze vložit jakýkoliv obrázek, podle kterého pak můžete jednoduše vykreslit váš požadovaný návrh. Díky tomu lze rychle a přesně vytvořit modely i složitějších objetků. Vlevo můj návrh samolepky, vpravo původní design:
K vyřezávání jsem použil řezací plotr – zařízení, do kterého lze přes počítač vložit vektorový obrázek a plotr ho vyřeže na lepící fólii. Takto vypadala má nálepka po vyndání z plotru (jemně jsou vidět vyřezané linie budoucí samolepky):
Pak bylo potřeba oddělit to, co bude samolepkou od zbytku kolem ní. To jsme provedli pomocí speciální pomůcky s ostrým koncem, ale postačí pro to klidně i párátko: (vlevo nepotřebná část, kterou jsem odloupnul; vpravo finální samolepka)
Tu jsem pak nalepil na speciální lepivý materiál, na kterém jsem si nálepku mohl odnést domů a následně ji pak nalepit na cílený povrch:
Laserové vyřezávání z kartonu
Nejdříve jsme jako skupina měli za úkol určit tloušťku laseru. V počítači připojeném k řezačce jsme vytvořili čtverec s přesně zadanými rozměry. Ten jsme vyřezali a šuplerou změřili jeho rozměry, které se lišily právě o tloušťku laseru: 0,2 mm.
Pak jsme měli za úkol individuálně vyřezávat parametrickou stavebnici z kartonu. Parametrická znamená to, že jednotlivé rozměry vykresleného předmětu v programu jsou stanovené jako proměnné (nastavují se v záložce Solid/Modify/Change Parameters). Díky tomu lze takto stanovené rozměry rychle měnit pro celý návrh, což je obrovskou výhodou při finálních úpravách (např. v této úloze jsme museli upravit rozměry pro započtení tloušťky laseru, aby nám stavebnice dobře seděla na sebe).
Původně jsem chtěl udělat stavebnici pro nějakou věž nebo stavbu, ale právě s parametrizací mi nastávaly problémy, které se mi nedařilo vyřešit a raději jsem přešel k jednodušší variantě (což doporučuji i ostatním, kteří s 3D modelováním nemají zatím zkušenosti). Vytvořil jsem tedy několik jednoduchých tvarů s otvory pro jejich vzájemné spojování:
Kvůli nedostatku času na konci cvičení jsem bohužel nestihl vytisknout všechny plánované součástky, ale u této jednoduché stavebnice to moc nevadí a jsem hlavně rád, že jsem si řezačku mohl vyzkoušet. Ze stavebnice lze pak vytvořit mnoho různých objektů, například:
Týden 3
Tento týden jsme se věnovali 3D tisku a 3D skenování.
3D skenování
Při cvičení jsme navštívili speciálně vybavenou učebnu se 3D skenery:
Na obrázku je vidět jak samotný skener, tak i speciální destička s tečkami. Ta je položena na rotující podložce, která umožňuje naskenování předmětu ze všech stran. Za objektem je pak tmavá stěna pro odstínění okolí. Skener pak na předmět vysílá různě široké paprsky, které se deformují podle tvaru předmětu a podle toho se vytvoří 3D model. Proto je nevhodné skenovat lesklé povrchy, viz sken mých hodinek (ve středu obrázku jsou hodinky na stojánku, je vidět řemínek, ale lesklý ciferník se vůbec nenaskenoval; omlouvám se za kvalitu obrázku):
Proto jsem se pak rozhodl vymodelovat mou myš od počítače. Po jejím naskenování pak samotný sken dolaďujeme na počítači. Nejdříve pomocí Align propojíme jednotlivé snímky mezi sebou (pomocí shift+levé tlačítko myši zvolíme 3 referenční body na každé z vrstev, podle kterých se vrstvy zarovnají). Pak uděláme Mesh celého modelu a program nám dovolí udělat ještě menší dodatečné úpravy.
Nakonec má myš vypadala takto:
Myslel jsem, že s ní nebudou problémy, ale pravděpodobně je moc tmavá, takže se sken moc nepovedl (zkoušel jsem skenovat 2x). V následné úpravě v Align pak byl problém vrstvy nakalibrovat přesně, protože má myš oblé hrany na kterých se těžce stanovují přesně ony dříve zmíněné 3 referenční body. Díky mé konzistentní schopnosti vybírat předměty nevhodné pro tento sken jsem si po Meshi mohl dopodrobna vyzkoušet úpravy jako smooth nebo fill holes a další.
Ze zvědavosti jsem ještě stejné předměty naskenoval doma pomocí mobilu. To jsem provedl zdarma pomocí aplikace Polycam. V té stačí zapnout režim „object“ a aplikace začne sama fotit předmět. Takto ze všech stran pořídíme několik desítek fotek a aplikace je pak přetvoří do 3D modelu:
Vidíme, že u této metody už není problémem vysoká odrazivost mých hodinek a sken se vcelku povedl.
3D Tisk
V 3D tisku jsme měli za úkol vytvořit menší předmět. Rozhodl jsem se vytisknout trsátko na kytaru, protože mě zajímalo, jak se bude materiál chovat v takto tenké vrstvě při zátěži (trstátko nakonec hraní přežilo; sice není tak pružné jako běžná trsátka, ale má díky tomu unikátní zvuk). Nejdříve jsem tedy udělal návrh v Autodesk Fusion:
Ten jsem vyexportoval jako formát .3mf a vložil do programu PrusaSlicer. V tom se pak dají upravit jednotlivá specifika tisku, např. podpěry, výplň atd. Po zmáčknutí tlačítka „Slicovat“ si pak můžeme prohlédnout, jakým způsobem bude probíhat tisk:
Zároveň se vytvoří tzv. G-code, který obsahuje instrukce ohledně tisku pro tiskárnu. Zvolíme tedy „Exportovat G-code“ a tento soubor s příponou .gcode uložíme na SD kartu. Tu už pak stačí vložit do tiskárny a můžeme spustit tisk našeho projektu.
Při samotném tisku je důležité kontrolovat, zda se neodlepila spodní vrstva objektu od podložky. Pokud se tak stane, tisk ihned přerušíme, vyčistíme 3D tiskárnu a začneme znovu. Nejen při čištění je nutné nezapomenout, že tryska a podložka se nahřívají na vysoké teploty!
Údržba 3D tiskárny
Před použitím zkontrolujeme, že pod podložkou nejsou nějaké nečistoty, které by mohly způsobovat její naklonění. Sebemenší naklonění by nám mohlo pokazit celý tisk. Pak povrch podložky vyčistíme izopropylalkoholem (IPA) (ničím jiným!). IPA je pro tento účel nejvhodnější, protože odmašťuje povrch a je šetrný vůči podložce. Následně necháme 3D tiskárnu zkalibrovat a až pak můžeme tisknout.
Týden 4
Tento týden jsme se učili pájet. Pro mě to byla zajímavá zkušenost, protože jsem ještě nikdy v životě nepájel. K pájení jsme dostali následující stavebnici pro běžící světlo s časovačem:
Zde je jeho schéma (součástí stavebnice):
Pájku máme doma, takže jsem se rozhodl si obvod spájet v klidu doma. Nejdříve jsem si pájení vyzkoušel na rezistorech a pak jsem pájel čítač. Při pájení je vhodné nejdříve přiložit pájku na pár sekund ke spoji a pak přiložit cín tak, aby se zároveň dotýkal spoje i hrotu pájky. U čítače jsem ale začal mít problémy, protože naše domácí pájka má o dost větší hrot než ta školní. Po dlouhém zkoušení jsem přišel na to, že u součástky s tolika „nožičkami“ bude nejlepší nanést cín nejdříve na desku a až pak připájet čítač. Na obrázku níže je vidět, že spodní část čítače se mi nakonec povedla připájet poměrně hezky. Bohužel při bližším pohledu si lze všimnout také toho, že jsem součástku připájel obráceně. Toho jsem si všiml až když jsem měl připájenou i druhou stranu a kvůli tomu už se mi nepodařilo čítač kompletně oddělit od desky.
I když jsem věděl, že obvod už nebude fungovat, pokračoval jsem dál v pájení, protože jsem si chtěl hlavně pájení pořádně vyzkoušet. Dále jsem tedy napájel diody. Nejdříve jsem je zastrkal do spojů, pak jsem jejich nožičky jsem ohnul o úhel cca 45°. Díky tomu jsem pak desku mohl otočit a pájet.
Pak jsem nožičky ostřihal a dopájel jsem zbytek součástek:
Obvod nepřekvapivě po připojení ke zdroji napětí nefungoval. Jsem ale rád, že jsem si pájení vyzkoušel, protože jsem se toho hodně přiučil a zjistil jsem, že se není čeho bát a je to vlastně vcelku relaxační činnost.
Týden 5
V tomto týdnu jsme tvořili kinetické struktury nejen pomocí metod, které jsme se naučili v předchozích týdnech.
Vodní pila
Já jsem se rozhodl vytvořit model vodní pily, viz inspirace:
Jedná se o mechanismus podobný vodnímu mlýnu, v případě vodní pily se ale energie vodního toku používá k řezání dřeva. Tento mechanismus je znám už z dob starověku, ve středověku se používal i na území Čech.
Můj původní záměr bylo celý mechanismus vyřezat na laserové řezačce z překližky, ale kvůli technickým problémům (a bezpochyby několika zásahům nepřejícné vyšší moci) se mi nic vyřezat nepovedlo. Místo toho jsem tedy vhodné součástky vytiskl na 3D tiskárně a zbytek vyřezal z překližky manuálně. Takto vypadal Fusion návrh součástek pro 3D tisk:
Mlýnská kola a ostatní součástky jsem navrhl také ve Fusionu, ale použil jsem funkci drawing (File -> New Drawing -> From Design) pomocí které jsem návrh mohl 1:1 vytisknout na papír a podle toho vyřezávat z překližky. Jako pilu jsem pak použil část staré tupé pilky. Pro jednoduchost jsem některé dílky lepil tavnou pistolí. Největší dolaďování jsem pak musel dělat kvůli tomu, že některé díry v kolečkách byly moc malé, tudíž jsem některé součástky musel tisknout opakovaně.
Nakonec sestavený model vypadá takto:
A zde je video jeho funkce:
Zdroje
Týden 6
Tento týden jsme měli za úkol změřit nějakou fyzikální veličinu pomocí Arduina a senzoru.
Já jsem se rozhodl měřit vzdálenost pomocí ultrazvukového senzoru HC-SR04. Ten vyšle ultrazvukovou vlnu, která se ideálně odrazí od objektu zpět na senzor. Protože se vlna šíří konstantní rychlostí, stačí senzoru změřit čas za který se vlna dostane k objektu a zpět a pomocí toho určí vzdálenost objektu.
Nejdříve jsem ale musel v Arduino IDE napsat program, ten vypadá následovně:
const int trigger_pin = 2;
const int echo_pin = 3;
void setup() {
Serial.begin(9600);
pinMode(trigger_pin, OUTPUT);
pinMode(echo_pin, INPUT);
}
void loop() {
// Make sure TRIG is LOW before sending a pulse
digitalWrite(trigger_pin, LOW);
delayMicroseconds(2);
// Send a 10 µs pulse on TRIG to start measurement
digitalWrite(trigger_pin, HIGH);
delayMicroseconds(10);
digitalWrite(trigger_pin, LOW);
// Computation and print
Serial.print("Distance: ");
Serial.print(pulseIn(echo_pin, HIGH) * 0.034 / 2);
Serial.println(" cm");
delay(500);
}
Součástí kódu je i výpis hodnot na počítači. Pak jsem obvod zapojil, viz schéma:
A takto to vypadalo zapojené:
Následně jsem naměřil 10 bodů a srovnal je se vzdáleností měřenou metrem. Tím jsem získal závislost výstupu programu na vzdálenosti:
Vidíme, že senzor je relativně přesný.
Týden 7
Tento týden jsme oproti předchozímu týdnu pracovali i s výstupními zařízeními pro Arduino.
Já jsem rozšířil svůj projekt z minulého týdne a k ultrazvukovému senzoru jsem přidal krokový motor 28BYJ-48, aby se senzor mohl točit dokola. Pro snadnější ovládání jsem Arduino s motorem propojil pomocí řadiče ULN2003. Na motor jsem pak na 3D tiskárně vytiskl jednoduchý držák na senzor. Otáčení motoru se pak mělo zastavit, pokud senzor detekuje objekt, jehož vzdálenost od senzoru je menší než 20 cm. Takto vypadalo celé zapojení:
A takto vypadá kód programu:
const int motor_pin_1 = 8; // ULN2003 IN1
const int motor_pin_2 = 9; // ULN2003 IN2
const int motor_pin_3 = 10; // ULN2003 IN3
const int motor_pin_4 = 11; // ULN2003 IN4
const int trigger_pin = 2;
const int echo_pin = 3;
int step_sequence[8][4] = {
{1, 0, 0, 0},
{1, 1, 0, 0},
{0, 1, 0, 0},
{0, 1, 1, 0},
{0, 0, 1, 0},
{0, 0, 1, 1},
{0, 0, 0, 1},
{1, 0, 0, 1}
};
int current_step = 0;
const int total_steps = 8;
const int step_delay = 2;
unsigned long last_sensor_time = 0;
const unsigned long sensor_interval = 50;
float measured_dist = 1000.0;
float measure_distance() {
digitalWrite(trigger_pin, LOW);
delayMicroseconds(2);
digitalWrite(trigger_pin, HIGH);
delayMicroseconds(10);
digitalWrite(trigger_pin, LOW);
return pulseIn(echo_pin, HIGH) * 0.034 / 2;
}
void setup() {
pinMode(motor_pin_1, OUTPUT);
pinMode(motor_pin_2, OUTPUT);
pinMode(motor_pin_3, OUTPUT);
pinMode(motor_pin_4, OUTPUT);
Serial.begin(9600);
pinMode(trigger_pin, OUTPUT);
pinMode(echo_pin, INPUT);
}
void loop() {
unsigned long current_time = millis();
if (current_time - last_sensor_time >= sensor_interval) {
measured_dist = measure_distance();
last_sensor_time = current_time;
Serial.print("Distance: ");
Serial.println(measured_dist);
}
if (measured_dist < 20) {
Serial.println("OBJECT DETECTED");
digitalWrite(motor_pin_1, LOW);
digitalWrite(motor_pin_2, LOW);
digitalWrite(motor_pin_3, LOW);
digitalWrite(motor_pin_4, LOW);
return;
}
digitalWrite(motor_pin_1, step_sequence[current_step][0]);
digitalWrite(motor_pin_2, step_sequence[current_step][1]);
digitalWrite(motor_pin_3, step_sequence[current_step][2]);
digitalWrite(motor_pin_4, step_sequence[current_step][3]);
delay(step_delay);
current_step = (current_step + 1) % total_steps;
}
Takto fungoval program v praxi:
Následně jsme ještě měli změřit výkon nějakého výstupního zařízení. Změřil jsem tedy výkon dříve zmíněného motoru - naměřil jsem napětí U = 4.736 V a proud I = 199.4 mA. Výkon jsem tedy určil jako P = UI = 0.94 W.
Týden 8
Tento týden jsme se věnovali CNC obrábění. Naším úkolem bylo vyfrézovat něco o maximálním rozměru 500 x 400 x 15 mm.
Já jsem se rozhodl vyfrézovat hodiny z 12 mm překližky. Nejprve jsem udělal návrh ve Fusion:
Poté jsem se ve Fusionu přemístil do sekce Manufacture. Zde jsem vytvořil nový setup a v něm navrhoval to, jak bude probíhat frézování. Pro to jsem využíval funkce z okna 2D (nikoliv 3D!) – pro vyřezání vnitřku hodin Pocket a pro vyřezání obrysu hodin Countour. V obou těchto nastaveních jsem musel nastavit Tool na 4mm Flat Endmill a zvolit vhodnou rychlost pro překližku (viz nastavení na obrázku).
Pak jsem v záložce Geometry vybral to, co chci vyřezat – výběr jsem prováděl označením dolní hrany objektu. Pak se musíme ujistit, že se červená šipka (která se po kliknutí na hranu zobrazí) nachází na té straně hrany, kde budeme chtít řezat (viz obr). Ostatní nastavení už jsou většinou nastavená správně, za zmínku stojí pouze Stock to Leave v záložce passes, které je pro naše účely většinou vhodné vypnout.
Countour jsem nastavil podobně jako Pocket s jedním zásadním rozdílem – v záložce Passes jsem zapnul Multiple Depths a nastavím Maximum Roughing na 6 mm. To jsem udělal kvůli tomu, že deska je moc široká a je ji tedy vhodnější vyřezat na vícero řezů s nižší hloubkou.
Takto pak vypadalo frézování našich výtvorů:
Takto vypadal můj návrh po vyfrézování:
Oproti původnímu návrhu jsou čísla vyřezaná dovnitř, předpokládám že to nějaká hodná duše změnila, protože by se to jinak špatně vyřezalo, takže děkuji ;).
Někdy později k hodinám doplním strojek a ručičky aby z toho byly funkční hodiny.
Týden 9
Tento týden jsme se naučili pracovat s ESP32 a ovládat pomocí něj obvod přes Wi-Fi a získávat pomocí něj data z internetu.
Nejdříve jsem se naučil ovládat obvod přes lokální Wi-Fi síť. To jsem si vyzkoušel na jednoduchém počítadle kliknutí na počítači, počet kliknutí se pak ukazoval na hodinovém displeji. Zapojení vypadalo takto:
Zde je jeho kód programu:
#include
#include
#include
// vyplnit wifi udaje
const char* ssid = "ssid";
const char* password = "password";
const int tm1637_clk_pin = 22;
const int tm1637_dio_pin = 21;
int click_count = 0;
WebServer server(80);
TM1637Display display(tm1637_clk_pin, tm1637_dio_pin);
// Zobrazí HTML stránku s čtvercem
void handle_root() {
String html = R"rawliteral(
// Zde html kod webové stránky - neuvádím kvůli tomu,
// že interpreter to bere jako html co má
// zobrazit a rozbijou se tím stránky
)rawliteral";
server.send(200, "text/html", html);
}
// zpracování kliknutí
void handle_click() {
click_count++;
display.showNumberDec(click_count, false);
server.send(200, "application/json", String("{\"count\":") + click_count + "}");
}
void setup() {
Serial.begin(115200);
// připojení k wifi
WiFi.begin(ssid, password);
Serial.println("WiFi připojeno, IP: " + WiFi.localIP().toString());
// init TM1637
display.setBrightness(0x0f); // max jas
display.showNumberDec(click_count, false);
// nastavení HTTP rout
server.on("/", HTTP_GET, handle_root);
server.on("/click", HTTP_GET, handle_click);
server.begin();
}
void loop() {
server.handleClient();
}
Zde je pak video jeho funkce:
Pak jsem si vyzkoušel získávání dat z internetu pomocí API. Díky tomu lze například právě pomocí ESP32 získávat data z různých internetových stránek a zobrazovat si je např. na displeji. Nevýhodou pak bývá nutnost se registrovat na těchto webech a od určitého počtu požadavků i platit předplatné. Já jsem se rozhodl vyzkoušet si na OLED displeji zobrazovat aktuální tržní informace. Ty jsem získával ze stránky Financial Modeling Prep. Kvůli malé velikosti displeje jsem zobrazoval pouze denní procentuální změnu indexu S&P 500. Protože je displej monochromatický, přidal jsem ještě indikaci pomocí červené (-) a zelené (+) LED.
Takto pak vypadalo zapojení:
Toto je použítý kód:
#include
#include
#include
#include
#include
#include
// — OLED rozměry a reset
#define value_of_screen_width 128
#define value_of_screen_height 64
#define value_of_oled_reset -1
Adafruit_SSD1306 display(value_of_screen_width, value_of_screen_height, &Wire, value_of_oled_reset);
// vyplnit wifi udaje
const char* ssid = "ssid";
const char* password = "password";
// API
const char* api_key = "MY_API_KEY";
// ETF SPY (kopíruje S&P 500)
const char* symbol = "SPY";
const int pin_led_red = 25;
const int pin_led_green = 26;
void setup() {
Serial.begin(115200);
// LED piny
pinMode(pin_led_red, OUTPUT);
pinMode(pin_led_green, OUTPUT);
digitalWrite(pin_led_red, LOW);
digitalWrite(pin_led_green, LOW);
// Připojení k wifi
WiFi.begin(ssid, password);
Serial.println();
Serial.println("WiFi připojeno, IP: " + WiFi.localIP().toString());
// Inicializace OLED
Wire.begin(21, 22); // SDA = GPIO21, SCL = GPIO22
if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Serial.println("OLED nebyl nalezen");
while (true) delay(1000);
}
display.clearDisplay();
display.setTextSize(2);
display.setTextColor(SSD1306_WHITE);
display.display();
}
void loop() {
if (WiFi.status() == WL_CONNECTED) {
HTTPClient http;
String request_url = String("https://financialmodelingprep.com/api/v3/quote/")
+ symbol + "?apikey=" + api_key;
Serial.println("Request URL: " + request_url);
http.begin(request_url);
int http_code = http.GET();
if (http_code == HTTP_CODE_OK) {
String payload = http.getString();
StaticJsonDocument<200> doc;
auto err = deserializeJson(doc, payload);
if (!err) {
float changes_percentage = doc[0]["changesPercentage"];
// Zobrazení na OLED
display.clearDisplay();
display.setCursor(0, 0);
display.print("S&P500:\n");
if (changes_percentage >= 0) display.print('+');
display.print(changes_percentage, 2);
display.print("%\n");
if (changes_percentage >= 0) display.print(":)");
else display.print(":(");
display.display();
// Indikace barvou LED
if (changes_percentage >= 0) {
digitalWrite(pin_led_green, HIGH);
digitalWrite(pin_led_red, LOW);
} else {
digitalWrite(pin_led_green, LOW);
digitalWrite(pin_led_red, HIGH);
}
}
}
http.end();
}
// Aktualizace každých 30 sekund
delay(30 * 1000);
}
A takto vypadal při běhu (na pozadí je pro referenci změna kurzu, která se má zobrazovat):
Oba zmíněné kódy jsem vytvořil s pomocí ChatGPT.
Týden 10
Tento týden jsme tvořili aplikaci, která tvoří rozhraní mezi uživatelem a naším vstupním nebo výstupním zařízením. Já jsem se rozhodl k tvorbě aplikace využít program Processing, který je asi nejvíce user friendly prostředí.
Rozhodl jsem se inspirovat hrou The Dinosaur Game, což je webová hra, která se zobrazí v prohlížeči Google Chrome při neúspěšném načtení stránky. Na počítači mi poběží obraz hry, ovládání hry pak bude vyřešeno pomocí tlačítka pomocí ESP32. V Processing jsem tedy nejdříve udělal zjednodušenou verzi této hry, která šla ovládat pomocí klávesnice. Žádnou hru jsem předtím nikdy nedělal, takže to pro mě byla úplně nová zkušenost. Nakonec mě překvapilo, jak krátký kód na tuto hru byl nakonec potřeba. Nejzajímavější mi v kódu přijde implementace pohybu jednotlivých překážek a gravitace. Jinak jsem se rozhodl programovat v defaultní Javě, což nakonec bylo dost podobné C až na odlišnou práci s arrays a odlišnou strukturu kódu.
Když pak hra fungovala tak jsem přidal propojení s ESP32. Pro to jsem v ArduinoIDE udělal tento kód, který zprostředkovává ovládání pomocí buttonu na ESP32:
const int button_pin = 2;
void setup() {
Serial.begin(115200);
pinMode(button_pin, INPUT_PULLUP);
}
void loop() {
if (digitalRead(button_pin) == LOW) {
Serial.write('J'); // for jump
delay(200);
}
}
Zapojení ESP32 pak je na dalším obrázku, pro ovládání slouží pouze tlačítko, které ovládá skok.
Takto pak vypadá kód samotné hry v Processingu:
import processing.serial.*;
Serial port;
float dino_x = 50;
float dino_y;
float dino_size = 20;
float dino_vy = 0;
float gravity = 0.8;
float speed = 0;
ArrayList obs_x = new ArrayList();
ArrayList obs_h = new ArrayList();
ArrayList obs_color = new ArrayList();
float obs_w = 15;
int spawn_timer = 0;
int score = 0;
void setup() {
size(600, 150);
dino_y = height - dino_size - 20;
textSize(30);
println(Serial.list());
port = new Serial(this, Serial.list()[0], 115200);
}
void draw() {
background(90);
stroke(255);
line(0, height-20, width, height-20);
// ESP32 connection
while (port.available() > 0) {
char inChar = (char)port.read();
if (inChar == 'J' && dino_vy == 0) {
dino_vy = -12;
}
}
// dino physics
dino_vy += gravity;
dino_y += dino_vy;
if (dino_y > height - dino_size - 20) {
dino_y = height - dino_size - 20;
dino_vy = 0;
}
// draw dino
fill(0, 200, 0);
rect(dino_x, dino_y, dino_size, dino_size);
// spawn blocks
spawn_timer++;
if (spawn_timer > 60) {
spawn_timer = 0;
obs_x.add((float)width);
obs_h.add(random(10, 50));
obs_color.add(color(random(255), random(255), random(255)));
speed += 0.2;
}
// movement and draw blocks
for (int i = obs_x.size() - 1; i >= 0; i--) {
float x = obs_x.get(i);
float h = obs_h.get(i);
fill(obs_color.get(i));
rect(x, height-20-h, obs_w, h);
obs_x.set(i, x - 5 - speed);
// remove when out of frame, increase score
if (x < -obs_w) {
obs_x.remove(i);
obs_h.remove(i);
obs_color.remove(i);
score++;
}
// collision deteciton
if (dino_x + dino_size > x && dino_x < x + obs_w &&
dino_y + dino_size > height-20-h) {
noLoop();
}
}
// draw score
fill(255);
text("Score: " + score, 10, 20);
}
// for keyboard
void keyPressed() {
if (key == ' ' && dino_vy == 0) {
dino_vy = -12;
}
}
A zde je video funkce celého projektu:
Týden 11 & 12
Týmovým prokjektem našeho týmu Griffin byl stroj Sisyphus, který pomocí kovové kuličky kreslí obrazce do písku. Pohyb kuličky je pak řízen pomocí SCARA (Selective Compliance Articulated Robot Arm) ramene s magnetem. Inspirací pro nás bylo například následující video:
Zde je pak video finální funkce našeho projektu:
Podrobnější informace o našem projektu naleznete na stránkách našeho projektu (https://griffin-a19299.pages.fel.cvut.cz ) a stránkách jednotlivých členů týmu. Stránky našeho projektu jsou rovněž mým přínosem do tohoto projektu. Krom toho jsem pak vytvářel některé pomocné 3D návrhy ve Fusionu. Mým největším přínosem pak bylo pomáhání při konstrukci stroje a řešení problémů, které vyplynuly až při sestavování stroje.
Týden 13
Tento týden jsme se věnovali odlévání. Objekt k odlití byl omezen na rozměry 5x5x2 a proto jsem si vybral víčko od píva. Nejdříve jsem si musel vytisknout ohrádku, ve které budu odlévat formu. Takto vypadla ohrádka:
Na cvičení jsem ale zjistil, že pro můj objekt bude vhodnější použít Equinox 38 Medium, což je modelovací silikon, a tudíž jsem ohrádku nakonec nepotřeboval. Silikon jsem namíchal v objemovém poměru 1:1. Takto víčko pak vypadalo už zabalené ve formě (stlačoval jsem ho z obou stran aby měla forma správný tvar):
V té jsem pak výrobek nechal cca půl hodiny trochu stlačené tuhnout. Poté jsem formu částečně rozřízl z boku skalpelem jen tak, abych mohl vyndat víčko. Když jsem ho pak vyndal, tak jsem namíchal v poměru 1:1 pryskyřici smooth cast a nalil do vzniklé díry. Pak jsem lehce uzavřel silikon a nechal ho tvrdnout. Pryskyřice vypadala takto:
Pak jsem 30 minut čekal až pryskyřici ztvrdne. Bohužel se pak ale ukázalo, že použitá Smooth cast 321 nebyla funkční, takže roztok neztvrdl. Následně jsem vyzkoušel Smooth cast 305, který ovšem také nefungoval. Nakonec mi bylo tedy doporučeno použít úplně jinou pryskyřici, kterou jsem namíchal v poměru 2:1 a ta už naštěstí fungovala. Takto pak nakonec vypadal ztvrdlý odlitek, který jsem nechal odformovat přes víkend:
Takto pak vypadal finální produkt:
Je vidět, že by bylo vhodnější použít nějaký více elastický materiál, protože v některých místech odlitek popraskal. I přes to jsem ale překvapený, že takto tenký objekt s ostrými hranami se odlil vcelku věrohodně. S přípravky Smooth Cast by byl výsledek možná lepší, ale jsem rád, že jsem si alespoň mohl vyzkoušet různé způsoby přípravy odlitku. Sice tento způsob výroby dále asi nevyužiju, ale zase to bylo velmi obohacující a zajímavé.
Týden 14
Tento týden jsem již pracoval na závěrečném projektu, více naleznete v okně Projekt.