warp-core
warp-core: A Hybrid Rocket Launch Controller Built on an 8-bit AVR and the W5500
0
Project description
Summary
warp-core is the launch control firmware that an ECE capstone team built for the Oregon State University (OSU) hybrid rocket team. It receives JSON commands from a mission control PC over the hardware TCP socket of the WIZnet W5500 and hands them to FreeRTOS tasks running on an ATmega1284p. It is a useful reference because it shows that an 8-bit MCU with 16 KB of SRAM can run a remote control link in a small amount of code, with no TCP/IP stack of its own.
Overview
A hybrid rocket uses a solid fuel together with a liquid or gaseous oxidizer. The oxidizer is usually loaded at the pad shortly before launch. Once filling starts, people must stay far from the rocket and operate the valves and ignition remotely.
warp-core is the pad-side brain of that remote operation. Its README names two challenges unique to hybrid rockets: pre-flight remote oxidizer filling and ignition timing matched to oxidizer injection.
- Developers: Quinn Handley, Thomas Prihoda
- Timeline: first commit 2019-10-22, last commit 2020-03-08, 48 commits
- Environment: custom AVR controller, FreeRTOS AVR port, avr-gcc 5.4.0
โ GitHub: https://github.com/qhandley/warp-core
Why Remote Control Is Required
How the Repository Was Actually Used
- Confirmed: According to the capstone page, the subscale system (T3st Core) supported many fuel grain tests
- Full-scale launch not completed: The phase 3 full-scale launch was postponed due to COVID-19. Spaceport America Cup 2020, planned for the same year, was also canceled in March 2020
- Activity: 1 star, 1 fork. The repository was created for a university capstone and has not been updated since
โ Capstone project page: https://sites.google.com/oregonstate.edu/ece44x201932/home
โ Competition cancellation notice (ESRA, 2020-03-24, archived copy): http://web.archive.org/web/20250914092355/https://www.soundingrocket.org/news1/2020-spaceport-america-cup-cancelled
What the Competition Rules Require
The Design, Test & Evaluation Guide (DTEG) from ESRA, which runs the student rocketry competition, sets these requirements for hybrid propulsion and launch equipment.
| Section | Requirement |
|---|---|
| 5.2.2.3 | Nitrous oxide (NโO) is the only allowed hybrid oxidizer |
| 5.10.1 | Hybrid and liquid systems must be able to remotely vent all propellants |
| 11.3.4 | Hybrid launch controllers must include oxidizer fill level instrumentation |
| 11.5.1 | Launch control systems must be single fault tolerant (key or jumper interlock) |
| 11.5.3 | Hybrid launch controllers must automatically vent oxidizer if power or communication is lost during fill |
In other words, remote operation itself is mandatory, and what happens when the link drops is an explicit requirement. We come back to this in "Limitations and Future Improvements."
The edition cited here is the 2024 revision (Rev 2024 V1.1.3). We could not confirm the section numbers or wording of the edition in force in 2020, when warp-core was written.
โ ESRA IREC DTEG (2024 V1.1.3): https://www.soundingrocket.org/uploads/9/0/6/4/9064598/2025_irec_dteg_v1.1.3_10-22-24.pdf
Architecture
The full system designed by the capstone team consists of an MCU board, FPGA board, I/O board, power board, and a C# GUI. The warp-core repository contains the firmware for the MCU board.
- Covered by the code: mission control โ W5500 โ TCP task โ queue โ control task
- Described only on the capstone page: the FPGA gateway between the MCU and the I/O board with its failsafe, the RS232 link to the rocket avionics, and the C# GUI
Technology Background
Filling and Igniting a Hybrid Rocket
A hybrid rocket stores its fuel (a solid grain) and its oxidizer (a fluid such as NโO) separately. Combustion starts only when the oxidizer flows into the combustion chamber. Unlike a solid motor, the oxidizer valve can start and stop combustion.
- Fill: NโO flows from a supply tank at the pad into the rocket's tank. From this point the rocket carries a pressure vessel
- Vent: If the launch is scrubbed, the oxidizer must be dumped remotely (DTEG 5.10.1)
- Ignite: The igniter heats the fuel grain surface, then the main oxidizer valve opens. The order and spacing of these two steps decide whether ignition is clean
This is why warp-core lists "ignition timing matched to oxidizer injection" as a core challenge. Every command from mission control acts on high-pressure oxidizer, so the reliability of the command link is a safety issue.
FreeRTOS Tasks and Queues
FreeRTOS is a real-time kernel for small MCUs. A program is split into tasks, and the kernel shares the CPU among them by priority. Tasks exchange data through queues, which decouple the sender from the receiver in time.
warp-core uses this structure directly.
- vTCPServerTask (priority +2): handles only the network. It wakes every 10 ticks (100 ms at a 100 Hz tick) through
vTaskDelayUntil()and checks the socket - vControlTask (priority +1): only takes commands from the queue and drives the output
- xControlCmdQueue: a 10-entry queue that connects the two tasks
The benefit of this split is that the control task's code path stays the same even when the network side slows down or reconnects.
โ FreeRTOS queue documentation: https://www.freertos.org/Documentation/02-Kernel/02-Kernel-features/02-Queues-mutexes-and-semaphores/01-Queues
Knowing When a TCP Connection Is Gone
TCP is connection-oriented, but it does not always tell you that the peer has disappeared.
| Situation | Does the server know? |
|---|---|
| The mission control program exits normally | Yes โ the peer sends a FIN to close the connection |
| The mission control PC loses power, or the cable is cut | No โ no packet arrives, so the connection still looks alive |
There are two ways to catch the second case.
- TCP keep-alive: after a period with no data, send an empty probe to ask whether the peer is still there (RFC 1122)
- Application-level heartbeat: mission control sends an "alive" message at a fixed interval, and the pad side enters a safe state if it misses them for too long
To meet the "automatic venting on communication loss" rule in DTEG 11.5.3 in software, you need at least one of these.
โ RFC 1122 (4.2.3.6 TCP Keep-Alives): https://www.rfc-editor.org/rfc/rfc1122
Technical Highlights
- Communication and control are separated: the TCP task only receives and parses, and the control task on the other side of the queue drives the output. Communication (+2) runs at a higher priority than control (+1)
- A command is a single integer: from
{"cmd": 5}, only the value of thecmdkey is extracted and converted withatoi(). The parser is jsmn (MIT license), a single header file that uses no dynamic memory - Bare-metal port without Arduino: the firmware brings in WIZnet ioLibrary and fills in the hardware-dependent functions in
wizchip_conf.cโ SPI chip select and byte read/write โ with AVR registers. Burst read/write calls these byte functions in a loop - Debug output: the
_TCP_DEBUG_macro prints received data, the chip version, and the IP settings to USART1 - Signs of iterative development: the commit log includes "Fixed memory bug causing reset loop" and "Protected wizchip recv with critical section," and the README FAQ explains how to check RTOS reset causes (stack overflow, heap settings, watchdog)
Where WIZnet Fits
TOE in Use: Yes
warp-core uses the W5500 as a hardware TCP/IP offload engine (TOE). The evidence is in the code.
socket(sn, Sn_MR_TCP, tcpPORT, 0x00)โ opens an ioLibrary hardware socket in TCP modegetSn_SR()reads the socket status register inside the chip to drive the state machine- The firmware build (the source list in the makefile) does not include a software TCP/IP stack such as lwIP. The repository does contain the demo lwIP and uIP sources that ship with FreeRTOS, but they are not built
Configuration
| Item | Value | Location |
|---|---|---|
| Chip | W5500 (_WIZCHIP_ W5500) |
lib/Ethernet/wizchip_conf.h |
| Sockets used | Socket 0 only | tcp_server.c |
| Socket buffers | TX 16 KB, RX 16 KB, all assigned to socket 0 | tcp_server.c |
| Address | Static IP 10.0.0.10, gateway 10.0.0.1 | tcp_server.h |
| Port | 8080 | tcp_server.h |
| SPI chip select | PB3 | wizchip_conf.c |
The W5500's 8 sockets share an internal buffer of 16 KB TX and 16 KB RX. Because warp-core accepts only one connection, it gives the entire buffer to socket 0.
โ W5500 datasheet: https://docs.wiznet.io/Product/Chip/Ethernet/W5500/datasheet
How One Command Is Processed
- Open the socket โ if socket 0 is closed (
SOCK_CLOSED), the MCU opens it in TCP mode withsocket(). When the chip reachesSOCK_INIT, the MCU callslisten() - Connect โ when the mission control PC connects to
10.0.0.10:8080, the W5500 handles the SYN/SYN-ACK/ACK handshake and the state changes toSOCK_ESTABLISHED. The MCU sees this when it reads the status register every 100 ms - Receive โ when the PC sends
{"cmd": 3}, the W5500 receives the TCP segment, returns the ACK, and stores the payload in its internal RX buffer - Fetch โ the MCU reads the number of waiting bytes with
getSn_RX_RSR(0)and pulls up to 64 bytes over SPI withrecv() - Parse and forward โ the MCU extracts the
cmdvalue3with jsmn and passes it to the control task withxQueueSend() - Close โ when mission control closes the connection, the W5500 receives the FIN and moves to
SOCK_CLOSE_WAIT. The MCU finishes withdisconnect()and returns to step 1
What the MCU does not do: ARP replies, the TCP handshake, ACKs, retransmission, buffering received data
What the MCU does: check the status register, read 64 bytes, parse JSON, forward to the queue
Analogy: The Radio Operator at the Pad
The W5500 is the radio operator in the pad bunker. Tuning the radio, answering calls, and asking for repeats when a message is garbled are all the operator's job. The commander (ATmega1284p) only asks the operator every 100 ms, "Any orders?", reads the one line the operator wrote down, and hands it to a subordinate (the control task). The commander never needs to learn radio procedure.
What If the Chip Were Not There [Inferred]
The ATmega1284p has 16 KB of SRAM. warp-core reserves 10,000 bytes of it as the FreeRTOS heap and allocates 2,048 (bytes, in the AVR port) from that heap for the TCP task stack.
- With a MAC/PHY-only Ethernet chip and a software TCP/IP stack (uIP, lwIP, etc.), packet buffers, connection state, and retransmission timers compete with the RTOS for the same SRAM
- The MCU would have to keep retransmission timing, so TCP handling would be tied to task scheduling
- In the current design, received data stays in the chip's 16 KB buffer, and the MCU uses a single 64-byte array for incoming data
Similar Projects on WIZnet Makers
Several university rocket teams already use the W5500 in their ground equipment. They solve the same problem in different ways, which makes them worth reading side by side.
- Hybrid PCC โ the hybrid rocket pad control box from the CU InSpace team at Carleton University in Canada. It is also hybrid rocket ground control, but it is built on an RP2040 + W5500-EVB-Pico board, in contrast to warp-core's custom PCB
โ Project link: https://maker.wiznet.io/Sunny_/projects/hybrid-pcc/ - phoenix-gs (Phoenix Ground Station) โ the liquid rocket ground station from RPL at UC San Diego. Like warp-core, it sends valve commands and receives sensor data. But it opens the W5500 in MACRAW mode and talks in custom Layer-2 frames with no TCP/IP, the opposite choice to warp-core's TOE approach
โ Project link: https://maker.wiznet.io/matthew/projects/phoenix-gs-phoenix-ground-station/ - PSPL CMS โ the liquid rocket avionics from the Purdue Space Program Liquids team. Built on RP2040 + W5500, it splits commands into TCP request-response (CommandNet) and sensor data into UDP multicast (SensorNet). Commands get a reply, which is the difference from warp-core (Hybrid PCC also reports command results by design)
โ Project link: https://maker.wiznet.io/Aimee0/projects/cms--rocket-developed-by-the-purdue-space-program-liquids-team/
All four projects build their wired Ethernet segment with a W5500 attached over SPI. Hybrid PCC, however, relies on a separate wireless bridge for the long link between mission control and the pad, and PSPL CMS uses Ethernet as a backbone between the rocket's flight computers and ground equipment. What differs is how much of the chip each one uses.
| Item | warp-core (OSU) | Hybrid PCC (Carleton) | phoenix-gs (UCSD) | PSPL CMS (Purdue) |
|---|---|---|---|---|
| Propulsion | Hybrid | Hybrid | Liquid | Liquid |
| MCU | ATmega1284p (8-bit) | RP2040 | Arduino-compatible (model unknown) | RP2040 |
| W5500 mode | TOE | Unknown | MACRAW | Unknown |
| Command transport | TCP, JSON | Unknown | Layer-2 frame, 1 byte | TCP, MessagePack |
| Command reply | No | Yes (reports results by design) | No | Yes (request-response) |
| RTOS | FreeRTOS | Apache NuttX | Unknown | FreeRTOS |
Of these, warp-core is the only one confirmed to run on an 8-bit MCU, and it leans on the chip's TCP engine to build its remote control link. Placed next to phoenix-gs, which builds raw frames over MACRAW, it shows clearly that the same chip can serve as either "a finished TCP socket" or "a bare Ethernet port."
Use Cases
- Remote valve and ignition links for student rocket teams and engine test stands โ a minimal skeleton that connects mission control and the pad with a single wired TCP link. The communication-loss handling described under "Limitations" must be added first
- Adding wired remote control to 8-bit equipment โ an example of attaching one W5500 over SPI to existing AVR-based equipment to create a TCP command port
- Porting ioLibrary to bare-metal AVR โ a minimal port that changes only the chip select and SPI read/write functions in
wizchip_conf.c, without the Arduino library - Practicing the network/control split on an RTOS โ the structure that links a communication task and a control task through a queue fits in about 260 lines of non-comment code (
tcp_server,control), which makes it good teaching material
Limitations and Future Improvements
In roughly one capstone cycle, warp-core got a hardware socket state machine, RTOS task separation, and JSON command parsing working. When the full-scale launch stopped because of COVID, some parts were left unpolished. Teams that want to build on it should address the following first.
1. Communication Loss Goes Undetected โ The Most Important Improvement
- Today: keep-alive is not configured, and there is no application-level heartbeat. If the mission control PC shuts off or a cable is pulled, no FIN arrives, so the socket stays in
SOCK_ESTABLISHED - Why it matters: DTEG 11.5.3 requires automatic oxidizer venting on communication loss during fill. If the firmware cannot detect the loss, it cannot meet that rule in software (we could not confirm whether the FPGA failsafe in the capstone design covered this)
- Improvements:
- Use the W5500 keep-alive โ the W5500 has a per-socket keep-alive timer register,
Sn_KPALVTR. Writing a value above 0 (in 5-second units) makes the chip send keep-alive packets on its own. If the peer does not respond, the chip drops the connection and raises a timeout interrupt. The MCU only needs to watchgetSn_SR()change toSOCK_CLOSED. Setup is one line:setSn_KPALVTR(). Note that keep-alive starts only after data has been sent or received at least once followingSOCK_ESTABLISHED, so this alone cannot catch a loss right after connecting, before any command arrives - Application-level heartbeat โ mission control sends, for example,
{"cmd": 0}every second. The control task uses a queue timeout and, if no command arrives within the limit, enters a safe state that opens the vent valve. This can detect a loss faster than keep-alive
- Use the W5500 keep-alive โ the W5500 has a per-socket keep-alive timer register,
โ W5500 datasheet PDF v1.1.0 (Sn_KPALVTR, p. 56): https://docs.wiznet.io/img/products/w5500/W5500_ds_v110e.pdf
2. Commands Get No Reply
- Today: the server code never calls
send(). Mission control cannot tell whether a command arrived or ran - Improvement: send back the result and the current valve state. The request-response structure in PSPL CMS is a good reference
3. The Control Task Is Still a Skeleton
- Today: it toggles an LED regardless of the command value. The real valve and ignition outputs are not in the repository
- Improvement: add a per-command output map, an interlock check before ignition, and sequence validation (fill โ ignite) to the control task
4. Small Code Defects
- Received string boundary: if exactly 64 bytes arrive, there is no NUL terminator, so
strlen()can read past the buffer. Sizing the buffer at 65 bytes and keeping the last byte 0 fixes it - Queue type mismatch: an
int8_tcommand goes into a queue sized forBaseType_t, and the receiver reads it into aBaseType_t *variable. Making the three types match is safer - Busy waiting: the control task polls the queue with a timeout of 0, leaving no time for lower-priority tasks. Giving the queue a wait time lets the CPU rest, and the same timeout can serve as the heartbeat monitor
5. Operational Notes
- One client, static IP, no authentication โ the design assumes a closed launch site network
- The repository has no LICENSE file. Check with the authors before reuse (the bundled jsmn and the FreeRTOS kernel are each MIT-licensed)
FAQ
Q1. Can it be moved to an MCU other than the ATmega1284p?
The README says to first check whether a FreeRTOS port exists for the target MCU. On the W5500 side, only four ioLibrary functions (chip select and SPI read/write) need to be rewritten for the new MCU, so most of the porting effort is on the RTOS side.
Q2. Why TCP instead of UDP?
The repository does not say. [Inferred] Valve and ignition commands must not be lost but are small in volume, so TCP, with retransmission and ordering handled by the chip, was probably the simpler choice. For high-volume data where only the latest value matters, such as sensor readings, some designs add a separate UDP channel, as PSPL CMS does.
Q3. Can several mission control PCs connect at once?
The current code uses only socket 0. The W5500 has 8 hardware sockets, so calling listen() on the same port for each socket would accept multiple clients. The 16 KB buffers would need to be split across those sockets, though, and you first need logic that decides who holds command authority.
Q4. What does it add to the parts list?
On the MCU board, roughly a W5500, a 25 MHz crystal, and an RJ45 jack with integrated magnetics (MagJack). [Inferred] The README links to the OSU team's schematic on Google Drive for the actual parts, but the link would not open as of October 2026, so we could not confirm them.
์์ฝ
warp-core๋ ์ค๋ฆฌ๊ฑด์ฃผ๋ฆฝ๋(OSU) ํ์ด๋ธ๋ฆฌ๋ ๋ก์ผ ํ์ ์ํด ECE ์บก์คํค ํ์ด ๋ง๋ ๋ฐ์ฌ ์ ์ด ํ์จ์ด์ ๋๋ค. ๊ด์ PC๊ฐ ๋ณด๋ธ JSON ๋ช ๋ น์ WIZnet W5500์ ํ๋์จ์ด TCP ์์ผ์ผ๋ก ๋ฐ์, ATmega1284p ์์ FreeRTOS ํ์คํฌ๋ก ๋๊น๋๋ค. SRAM 16KB์ง๋ฆฌ 8๋นํธ MCU์์๋ TCP/IP ์คํ ์์ด ์๊ฒฉ ์ ์ด ๋งํฌ๋ฅผ ์งง์ ์ฝ๋๋ก ๊ตฌ์ฑํ ์ ์๋ค๋ ์ ์์ ์ฐธ๊ณ ํ ๋งํ ์ฌ๋ก์ ๋๋ค.
๊ฐ์
ํ์ด๋ธ๋ฆฌ๋ ๋ก์ผ์ ๊ณ ์ฒด ์ฐ๋ฃ์ ์ก์ฒดยท๊ธฐ์ฒด ์ฐํ์ ๋ฅผ ํจ๊ป ์๋๋ค. ์ฐํ์ ๋ ๋ณดํต ๋ฐ์ฌ ์ง์ ๋ฐ์ฌ๋์์ ์ถฉ์ ํ๋ฏ๋ก, ์ถฉ์ ์ด ์์๋๋ฉด ์ฌ๋์ ๋ก์ผ์์ ๋ฉ๋ฆฌ ๋จ์ด์ง ์ฑ๋ก ๋ฐธ๋ธ์ ์ ํ๋ฅผ ์กฐ์ํด์ผ ํฉ๋๋ค.
warp-core๋ ์ด ์๊ฒฉ ์กฐ์์ ๋ฐ์ฌ๋ ์ชฝ ๋๋์ ๋๋ค. README๋ ์ด ํ๋ก๊ทธ๋จ์ด ๋ค๋ฃจ๋ ํ์ด๋ธ๋ฆฌ๋ ๋ก์ผ ๊ณ ์ ์ ๊ณผ์ ๋ก ๋ฐ์ฌ ์ ์๊ฒฉ ์ฐํ์ ์ถฉ์ ๊ณผ ์ฐํ์ ์ฃผ์ ์ ๋ง์ถ ์ ํ ํ์ด๋ฐ์ ๊ผฝ์ต๋๋ค.
- ๊ฐ๋ฐ: Quinn Handley, Thomas Prihoda
- ๊ธฐ๊ฐ: 2019-10-22 ์ฒซ ์ปค๋ฐ ~ 2020-03-08 ๋ง์ง๋ง ์ปค๋ฐ, ์ปค๋ฐ 48๊ฐ
- ํ๊ฒฝ: ๋ง์ถค ์ ์ํ AVR ์ปจํธ๋กค๋ฌ, FreeRTOS AVR ํฌํธ, avr-gcc 5.4.0
โ GitHub: https://github.com/qhandley/warp-core
์ ์๊ฒฉ ์ ์ด๊ฐ ํ์ํ๊ฐ
์ ์ฅ์์ ์ค์ ์ฌ์ฉ
- ํ์ธ๋จ: ์บก์คํค ํ์ด์ง์ ๋ฐ๋ฅด๋ฉด ์๋ธ์ค์ผ์ผ ์์คํ (T3st Core)์ด ์ฐ๋ฃ ๊ทธ๋ ์ธ ์ํ์ ์ฌ๋ฌ ์ฐจ๋ก ์ง์ํ์ต๋๋ค
- ์ค๋ฌผ ํฌ๊ธฐ ๋ฐ์ฌ๋ ๋ฏธ์๋ฃ: 3๋จ๊ณ ์ค๋ฌผ ํฌ๊ธฐ ๋ฐ์ฌ๋ COVID-19๋ก ์ฐ๊ธฐ๋์ต๋๋ค. ๊ฐ์ ํด ์ด๋ฆด ์์ ์ด๋ Spaceport America Cup 2020๋ 2020๋ 3์ ์ทจ์๋์ต๋๋ค
- ํ๋ ์งํ: Star 1, Fork 1. ๋ํ ์บก์คํค ๊ณผ์ ๋ก ๋ง๋ค์ด์ง ์ ์ฅ์์ด๋ฉฐ, ์ดํ ์ ๋ฐ์ดํธ๋ ์์ต๋๋ค
โ ์บก์คํค ํ๋ก์ ํธ ํ์ด์ง: https://sites.google.com/oregonstate.edu/ece44x201932/home
โ ๋ํ ์ทจ์ ๊ณต์ง(ESRA, 2020-03-24, ๋ณด๊ด๋ณธ): http://web.archive.org/web/20250914092355/https://www.soundingrocket.org/news1/2020-spaceport-america-cup-cancelled
๋ํ ๊ท์ ์ด ์๊ตฌํ๋ ๊ฒ
ํ์ ๋ก์ผ ๋ํ๋ฅผ ์ฃผ๊ดํ๋ ESRA์ ์ค๊ณยท์ํยทํ๊ฐ ์ง์นจ(DTEG)์ ํ์ด๋ธ๋ฆฌ๋ ์ถ์ง๊ณ์ ๋ฐ์ฌ ์ฅ๋น์ ๋ค์์ ์๊ตฌํฉ๋๋ค.
| ์กฐํญ | ์๊ตฌ ๋ด์ฉ |
|---|---|
| 5.2.2.3 | ํ์ด๋ธ๋ฆฌ๋ ์ฐํ์ ๋ ์์ฐํ์ง์(NโO)๋ง ํ์ฉ |
| 5.10.1 | ํ์ด๋ธ๋ฆฌ๋ยท์ก์ฒด ์ถ์ง์ ๋ชจ๋ ์ถ์ง์ ๋ฅผ ์๊ฒฉ์ผ๋ก ๋ฐฐ์ถ(venting) ํ ์๋จ์ ๊ฐ์ถ ๊ฒ |
| 11.3.4 | ํ์ด๋ธ๋ฆฌ๋ ๋ฐ์ฌ ์ ์ด๊ธฐ๋ ์ฐํ์ ์ถฉ์ ๋ ๊ณ์ธก์ ํฌํจํ ๊ฒ |
| 11.5.1 | ๋ฐ์ฌ ์ ์ด ์์คํ ์ ๋จ์ผ ๊ณ ์ฅ ํ์ฉ(ํคยท์ ํผ ์ธํฐ๋ก)์ผ ๊ฒ |
| 11.5.3 | ์ถฉ์ ์ค ์ ์ ๋๋ ํต์ ์ด ๋๊ธฐ๋ฉด ์ฐํ์ ๋ฅผ ์๋ ๋ฐฐ์ถํ๋ ํ์ผ์ธ์ดํ๋ฅผ ๊ฐ์ถ ๊ฒ |
์ฆ ์๊ฒฉ ์กฐ์ ์์ฒด๊ฐ ๊ท์ ์ ํ์์ด๊ณ , ํนํ ํต์ ๋งํฌ๊ฐ ๋๊ฒผ์ ๋ ์ด๋ป๊ฒ ๋๋๊ฐ๊ฐ ๋ช ์์ ์๊ตฌ์ฌํญ์ ๋๋ค. ์ด ์ ์ ์๋ ใํ๊ณ์ ๊ฐ์ ๋ฐฉํฅใ์์ ๋ค์ ๋ค๋ฃน๋๋ค.
์ธ์ฉํ ํ๋ณธ์ 2024๋ ํ(Rev 2024 V1.1.3) ์ด๋ฉฐ, warp-core๊ฐ ๊ฐ๋ฐ๋ 2020๋ ๋น์ ํ๋ณธ์ ์กฐํญ ๋ฒํธ์ ๋ฌธ๊ตฌ๋ ํ์ธํ์ง ๋ชปํ์ต๋๋ค.
โ ESRA IREC DTEG (2024 V1.1.3): https://www.soundingrocket.org/uploads/9/0/6/4/9064598/2025_irec_dteg_v1.1.3_10-22-24.pdf
์์คํ ๊ตฌ์ฑ
์บก์คํค ํ์ด ์ค๊ณํ ์ ์ฒด ์์คํ ์ MCU ๋ณด๋, FPGA ๋ณด๋, I/O ๋ณด๋, ์ ์ ๋ณด๋, C# GUI๋ก ์ด๋ค์ง๋๋ค. ๊ทธ์ค warp-core ์ ์ฅ์๊ฐ ๋ด๊ณ ์๋ ๊ฒ์ MCU ๋ณด๋์ ํ์จ์ด์ ๋๋ค.
