
@book{koopman_better_2010,
	edition = {1.st Edition, revised 2021},
	title = {Better Embedded System Software},
	isbn = {979-8596008050},
	url = {http://www.koopman.us/},
	pagetotal = {384},
	publisher = {Carnegie Mellon University},
	author = {Koopman, Phillip},
	urldate = {2021-02-24},
	date = {2010},
	file = {Better Embedded System Software:/home/matous/Zotero/storage/QHRLSAX2/www.koopman.us.html:text/html},
}

@online{akin_akins_nodate,
	title = {Akin's Laws of Spacecraft Design},
	url = {https://spacecraft.ssl.umd.edu/akins_laws.html},
	author = {Akin, David L.},
	urldate = {2021-02-24},
	file = {Akin's Laws of Spacecraft Design:/home/matous/Zotero/storage/IK7R9E2T/akins_laws.html:text/html},
}

@online{chromium_projects_memory_nodate,
	title = {Memory safety - The Chromium Projects},
	url = {https://www.chromium.org/Home/chromium-security/memory-safety},
	abstract = {Home of the Chromium Open Source Project},
	titleaddon = {The Chromium Projects},
	author = {{Chromium Projects}},
	urldate = {2021-03-31},
	file = {Snapshot:/home/matous/Zotero/storage/EEY5ZKJC/memory-safety.html:text/html},
}

@online{synopsys_heartbleed_2020,
	title = {The Heartbleed Bug},
	url = {https://heartbleed.com/},
	abstract = {The Heartbleed Bug is a serious vulnerability in the popular {OpenSSL} cryptographic software library. This weakness allows stealing the information protected, under normal conditions, by the {SSL}/{TLS} encryption used to secure the Internet. {SSL}/{TLS} provides communication security and privacy over the Internet for applications such as web, email, instant messaging ({IM}) and some virtual private networks ({VPNs}).},
	titleaddon = {The Heartbleed Bug},
	author = {{Synopsys}},
	urldate = {2021-03-31},
	date = {2020-03-06},
	file = {Heartbleed Bug:/home/matous/Zotero/storage/49D275IC/heartbleed.com.html:text/html},
}

@software{hybl_robotics-butdcmotor-firmware_2021,
	title = {Robotics-{BUT}/{DCMotor}-firmware},
	rights = {{MIT} License         ,                 {MIT} License},
	url = {https://github.com/Robotics-BUT/DCMotor-firmware},
	abstract = {Rust firmware for the {DC} motor controller. Contribute to Robotics-{BUT}/{DCMotor}-firmware development by creating an account on {GitHub}.},
	publisher = {{BUT} {FEEC} Robotics},
	author = {Hybl, Matous},
	urldate = {2021-03-31},
	date = {2021-02-06},
	note = {original-date: 2020-09-27T19:09:49Z},
}

@software{hybl_robotics-butkm3-rs_2020,
	title = {Robotics-{BUT}/{KM}3-rs},
	rights = {{MIT} License         ,                 {MIT} License},
	url = {https://github.com/Robotics-BUT/KM3-rs},
	abstract = {Rust firmware for the {KM}3 stepper motor controller.},
	publisher = {{BUT} {FEEC} Robotics},
	author = {Hybl, Matous},
	urldate = {2021-03-31},
	date = {2020-12-31},
	note = {original-date: 2020-10-18T19:51:28Z},
}

@online{faigl_program_nodate,
	title = {Program {\textbar} Student Conference on Planning in Artificial Intelligence and Robotics},
	url = {./index.html},
	author = {Faigl, Jan},
	urldate = {2021-03-31},
	langid = {american},
	file = {Snapshot:/home/matous/Zotero/storage/FKVLKVER/program.html:text/html},
}

@online{burian_modul_nodate,
	title = {Modul {KM}2 - {BPRP} - Robotika a počítačové vidění},
	url = {https://sites.google.com/a/vutbr.cz/bprp/kambot/dily/modul-km2},
	author = {Burian, Frantisek},
	urldate = {2021-03-31},
	file = {Snapshot:/home/matous/Zotero/storage/KJHA7FR6/modul-km2.html:text/html},
}

@online{burian_02_nodate,
	title = {02 - Platforma {KAMbot}, {GIT} (dokončení) - {BPRP} - Robotika a počítačové vidění},
	url = {https://sites.google.com/a/vutbr.cz/bprp/prednasky/2018/02},
	author = {Burian, Frantisek},
	urldate = {2021-03-31},
	file = {Snapshot:/home/matous/Zotero/storage/IU69U8IW/02.html:text/html},
}

@online{burian_pcbs_nodate,
	title = {{PCBS} / {KM}2},
	url = {https://student.robotika.ceitec.vutbr.cz/PCBS/KM2},
	abstract = {The {KM}2 stepped driver board},
	titleaddon = {{GitLab}},
	author = {Burian, Frantisek},
	urldate = {2021-03-31},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/6C82XQTS/KM2.html:text/html},
}

@online{burian_km2renderpng_nodate,
	title = {{KM}2.render.png ({PNG} Image, 1024 × 735 pixels) — Scaled (92\%)},
	url = {https://student.robotika.ceitec.vutbr.cz/PCBS/KM2/raw/master/bin/RevB/KM2.render.png},
	author = {Burian, Frantisek},
	urldate = {2021-04-03},
	file = {KM2.render.png (PNG Image, 1024 × 735 pixels) — Scaled (92%):/home/matous/Zotero/storage/HR7MBNC7/KM2.render.html:text/html},
}

@online{tropical_labs_mechaduino_2021,
	title = {Mechaduino – Tropical Labs},
	url = {https://tropical-labs.com/mechaduino/},
	abstract = {Mechaduino is an affordable open-source servo motor for {DIY} and professional mechatronics under development at Tropical Labs.  Mechaduino is Arduino-compatible for ease of use.},
	titleaddon = {Tropical Labs},
	author = {{Tropical Labs}},
	urldate = {2021-04-05},
	date = {2021},
	langid = {american},
	file = {Snapshot:/home/matous/Zotero/storage/ZDCT3CSD/mechaduino.html:text/html},
}

@online{braun_flott_nodate,
	title = {Flott - Motion Control in Rust},
	url = {https://flott-motion.org/},
	abstract = {Developing motion control software in Rust should be easy! Flott aims to make this a reality, by providing libraries that abstract over hardware commonly used for motion control, like motors, encoders, and other sensors and actuators.},
	titleaddon = {Flott},
	author = {Braun, Hanno},
	urldate = {2021-04-05},
	file = {Flott - Motion Control in Rust:/home/matous/Zotero/storage/43HURUL5/flott-motion.org.html:text/html},
}

@online{mansanet_ecorax_nodate,
	title = {{eCorax} - As above, so below: Bare metal Rust generics 1/2},
	url = {https://www.ecorax.net/as-above-so-below-1/},
	shorttitle = {{eCorax} - As above, so below},
	abstract = {Writing two flash drivers starting from an abstraction.},
	author = {Mansanet, Pablo},
	urldate = {2021-04-06},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/78XEPK98/as-above-so-below-1.html:text/html},
}

@online{aparicio_rfc_nodate,
	title = {[{RFC}] user defined memory layout · Issue \#164 · rust-embedded/cortex-m-rt},
	url = {https://github.com/rust-embedded/cortex-m-rt/issues/164},
	abstract = {Summary Change how the memory layout of cortex-m-rt programs is defined. Let the user specify memory regions and linker sections using a high level {API} from build scripts. Background Some embedded ...},
	titleaddon = {{GitHub}},
	author = {Aparicio, Jorge},
	urldate = {2021-04-06},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/4CLY8M9Z/lib.html:text/html},
}

@software{rust_embedded_devices_wg_rust-embeddedcortex-m-rt_nodate,
	title = {rust-embedded/cortex-m-rt},
	url = {https://github.com/rust-embedded/cortex-m-rt},
	abstract = {Minimal startup / runtime for Cortex-M microcontrollers - rust-embedded/cortex-m-rt},
	author = {{Rust Embedded Devices WG}},
	urldate = {2021-04-06},
	file = {Snapshot:/home/matous/Zotero/storage/SDFQMDVK/lib.html:text/html},
}

@online{stmicro_stm32f405rg_nodate,
	title = {{STM}32F405RG - High-performance foundation line, Arm Cortex-M4 core with {DSP} and {FPU}, 1 Mbyte of Flash memory, 168 {MHz} {CPU}, {ART} Accelerator - {STMicroelectronics}},
	url = {https://www.st.com/en/microcontrollers-microprocessors/stm32f405rg.html},
	abstract = {{STM}32F405RG - High-performance foundation line, Arm Cortex-M4 core with {DSP} and {FPU}, 1 Mbyte of Flash memory, 168 {MHz} {CPU}, {ART} Accelerator, {STM}32F405RGT6TR, {STM}32F405RGT6, {STM}32F405RGT7, {STM}32F405RGT6V, {STM}32F405RGT7TR, {STM}32F405RGT6W, {STMicroelectronics}},
	author = {{STMicro}},
	urldate = {2021-04-11},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/3M4PCT5T/stm32f405rg.html:text/html},
}

@online{stmicro_enbd_stm32f405_1mbjpg_nodate,
	title = {en.bd\_stm32f405\_1mb.jpg ({JPEG} Image, 700 × 754 pixels)},
	url = {https://www.st.com/content/ccc/fragment/product_related/rpn_information/product_circuit_diagram/group0/d1/5f/28/7e/77/7a/49/c0/bd_stm32f405_1m/files/bd_stm32f405_1mb.jpg/_jcr_content/translations/en.bd_stm32f405_1mb.jpg},
	author = {{STMicro}},
	urldate = {2021-04-11},
	file = {en.bd_stm32f405_1mb.jpg (JPEG Image, 700 × 754 pixels):/home/matous/Zotero/storage/EEAMUM6D/en.bd_stm32f405_1mb.html:text/html},
}

@online{astro_implement_2020,
	title = {Implement flash read/erase/program by astro · Pull Request \#239 · stm32-rs/stm32f4xx-hal},
	url = {https://github.com/stm32-rs/stm32f4xx-hal/pull/239},
	titleaddon = {{GitHub}},
	author = {{Astro}},
	urldate = {2021-04-15},
	date = {2020-10-12},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/MTPVZIEG/239.html:text/html},
}

@online{klabnik_rust_nodate,
	title = {The Rust Programming Language - The Rust Programming Language},
	url = {https://doc.rust-lang.org/book/title-page.html},
	author = {Klabnik, Steve and Nichols, Carol},
	urldate = {2021-04-19},
	file = {The Rust Programming Language - The Rust Programming Language:/home/matous/Zotero/storage/AUEGT2PZ/title-page.html:text/html},
}

@online{prusa_original_2017,
	title = {Original Prusa i3 {MK}3 is out! And it's bloody smart!},
	url = {https://blog.prusaprinters.org/original-prusa-i3-mk3-bloody-smart_7201/},
	abstract = {It has not been that long ago since we released Original Prusa i3 {MK}2S and some speculate that we can go for a year without…},
	titleaddon = {Prusa Printers},
	author = {Prusa, Josef},
	urldate = {2021-05-02},
	date = {2017-09-22},
	langid = {american},
	note = {Section: Highlights},
	file = {Snapshot:/home/matous/Zotero/storage/U7TEX2DY/original-prusa-i3-mk3-bloody-smart_7201.html:text/html},
}

@online{trinamic_chopper_nodate,
	title = {Chopper Modes},
	url = {https://www.trinamic.com/technology/motor-control-technology/chopper-modes/},
	abstract = {With Trinamic's chopper scheme, a current sine wave can be achieved with a smooth zero-crossing. This allows for resonance-free stepper motor operation with increased energy-efficiency.},
	titleaddon = {Trinamic},
	author = {Trinamic},
	urldate = {2021-04-30},
	langid = {american},
	file = {Snapshot:/home/matous/Zotero/storage/7UXY8G5D/chopper-modes.html:text/html},
}

@online{earl_all_nodate,
	title = {All About Stepper Motors},
	url = {https://learn.adafruit.com/all-about-stepper-motors/what-is-a-stepper-motor},
	abstract = {Stepper motors are the motor of choice for many precision motion control applications.  Stepper motors come in many different sizes and styles and electrical characteristics.  This guide details what you need to know to pick the right motor for the job.},
	titleaddon = {Adafruit Learning System},
	author = {Earl, Bill},
	urldate = {2021-04-30},
	langid = {american},
	file = {Snapshot:/home/matous/Zotero/storage/3ZVRGWD6/what-is-a-stepper-motor.html:text/html},
}

@online{carmine_fiore_stepper_2021,
	title = {Stepper Motors: Types, Uses and Working Principle {\textbar} Article {\textbar} {MPS}},
	url = {https://www.monolithicpower.com/en/stepper-motors-basics-types-uses},
	abstract = {In this article, we will cover the basics of stepper motors. You will learn about the working principles, construction, control methods, uses, and types of stepper motors, as well as its advantages and disadvantages.},
	titleaddon = {{MPS}},
	author = {{Carmine Fiore}},
	urldate = {2021-04-30},
	date = {2021},
	file = {Stepper Motors\: Types, Uses and Working Principle | Article | MPS:/home/matous/Zotero/storage/9NPXDD4Z/stepper-motors-basics-types-uses.html:text/html},
}

@online{prusa_original_2019,
	title = {Original Prusa {MINI} is here: Smart and compact 3D printer for everyone!},
	url = {https://blog.prusaprinters.org/original-prusa-mini-is-here-smart-and-compact-3d-printer_30887/},
	shorttitle = {Original Prusa {MINI} is here},
	abstract = {We still have a couple of weeks until the holiday season, but here’s an early gift for you: I’m excited to announce our brand new…},
	titleaddon = {Prusa Printers},
	author = {Prusa, Josef},
	urldate = {2021-05-02},
	date = {2019-10-12},
	langid = {american},
	note = {Section: Highlights},
	file = {Snapshot:/home/matous/Zotero/storage/ILRKCHNS/original-prusa-mini-is-here-smart-and-compact-3d-printer_30887.html:text/html},
}

@video{starsetonline_drv8825_2016,
	title = {{DRV}8825 vs {TMC}2100},
	url = {https://www.youtube.com/watch?v=oNAHOOolHWw},
	abstract = {Comparison of {DRV}8825 stepper drivers vs Silent Step-Stick drivers based on the Trinamic {TMC}2100 driver from Watterot:
https://github.com/watterott/{SilentSt}...​},
	author = {{starsetonline}},
	urldate = {2021-05-02},
	date = {2016-06-11},
}

@online{3daddict_stepper_2020,
	title = {Stepper Driver Comparison 3D Printer Upgrade},
	url = {https://3daddict.com/stepper-driver-comparison-3d-printer-upgrade/},
	abstract = {Stepper Driver Comparison for your 3D Printers. Compare different types of stepper drivers to upgrade your 3D Printer. Read more...},
	titleaddon = {3DAddict},
	author = {{3DAddict}},
	urldate = {2021-05-02},
	date = {2020-10-04},
	langid = {american},
	file = {Snapshot:/home/matous/Zotero/storage/BH894TU6/stepper-driver-comparison-3d-printer-upgrade.html:text/html},
}

@misc{texas_instruments_drv8825_2014,
	title = {{DRV}8825 Stepper Motor Controller {IC}},
	url = {https://www.ti.com/lit/ds/symlink/drv8825.pdf?ts=1619898319490&ref_url=https%253A%252F%252Fwww.google.com%252F},
	publisher = {Texas Instruments},
	author = {{Texas Instruments}},
	urldate = {2021-05-02},
	date = {2014-07},
	file = {drv8825.pdf:/home/matous/Zotero/storage/5GUZLPXE/drv8825.pdf:application/pdf},
}

@misc{allegro_microsystems_a4988_2014,
	title = {A4988 {DMOS} Microstepping Driver with Translator And Overcurrent Protection},
	url = {https://www.pololu.com/file/0J450/a4988_DMOS_microstepping_driver_with_translator.pdf},
	shorttitle = {A4988},
	publisher = {Allegro Microsystems},
	author = {{Allegro Microsystems}},
	urldate = {2021-05-02},
	date = {2014-05},
	file = {a4988_DMOS_microstepping_driver_with_translator.pdf:/home/matous/Zotero/storage/WXUSH6IC/a4988_DMOS_microstepping_driver_with_translator.pdf:application/pdf},
}

@misc{stmicro_an3969_2011,
	title = {{AN}3969 - {EEPROM} emulation in {STM}32F40x/{STM}32F41x microcontrollers},
	url = {https://www.st.com/content/ccc/resource/technical/document/application_note/ec/dd/8e/a8/39/49/4f/e5/DM00036065.pdf/files/DM00036065.pdf/jcr:content/translations/en.DM00036065.pdf},
	publisher = {{STMicro}},
	author = {{STMicro}},
	urldate = {2021-04-06},
	date = {2011-10},
	file = {AN3969 - EEPROM emulation in STM32F40x/STM32F41x microcontrollers:/home/matous/Zotero/storage/5RY8FXWI/en.DM00036065.pdf:application/pdf},
}

@misc{trinamic_tmc2100-datasheet_2018,
	title = {{TMC}2100-{LA} Datasheet},
	url = {https://www.trinamic.com/fileadmin/assets/Products/ICs_Documents/TMC2100_datasheet_Rev1.08.pdf},
	shorttitle = {{TMC}2100-{LA}},
	abstract = {Standalone intelligent Step/Direction driver for two-phase bipolar stepper motor. {stealthChop}™ for quiet movement. Integrated {MOSFETs} for up to 2.0A motor current per coil.},
	publisher = {Trinamic},
	author = {{Trinamic}},
	urldate = {2021-05-02},
	date = {2018-05-16},
	file = {TMC2100_datasheet_Rev1.08.pdf:/home/matous/Zotero/storage/U5IHBQGS/TMC2100_datasheet_Rev1.08.pdf:application/pdf},
}

@misc{trinamic_tmc2130-datasheet_2018,
	title = {{TMC}2130-{LA} Datasheet},
	url = {https://www.trinamic.com/fileadmin/assets/Products/ICs_Documents/TMC2130_datasheet.pdf},
	shorttitle = {{TMC}2130-{LA}},
	abstract = {Universal high  voltage driver  for  two-phase  bipolar  stepper  motor. {stealthChop}™  for  quiet movement. Integrated {MOSFETs} for up to 2.0A motor current per coil. With Step/Dir Interface and {SPI}.},
	publisher = {Trinamic},
	author = {{Trinamic}},
	urldate = {2021-05-02},
	date = {2018-05-09},
	file = {TMC2130_datasheet.pdf:/home/matous/Zotero/storage/GXNHND3F/TMC2130_datasheet.pdf:application/pdf},
}

@misc{trinamic_tmc2209_2019,
	title = {{TMC}2209 Datasheet},
	url = {https://www.trinamic.com/fileadmin/assets/Products/ICs_Documents/TMC2209_Datasheet_V103.pdf},
	shorttitle = {{TMC}2209},
	abstract = {Step/Dir Drivers  for  Two-Phase  Bipolar  Stepper  Motors  up  to 2.8A  peak–{StealthChop}™  for Quiet Movement–{UART} Interface Option–Sensorless Stall Detection {StallGuard}4.},
	publisher = {Trinamic},
	author = {{Trinamic}},
	urldate = {2021-05-02},
	date = {2019-05-26},
	file = {TMC2209_Datasheet_V103.pdf:/home/matous/Zotero/storage/9E4NSUDQ/TMC2209_Datasheet_V103.pdf:application/pdf},
}

@misc{trinamic_tmc2226_2020,
	title = {{TMC}2226 Datasheet},
	url = {https://www.trinamic.com/fileadmin/assets/Products/ICs_Documents/TMC2226_Datasheet_V106.pdf},
	shorttitle = {{TMC}2226},
	abstract = {Step/Dir Drivers  for  Two-Phase  Bipolar  Stepper  Motors  up  to 2.8A  peak – {StealthChop}™  for Quiet Movement – {UART} Interface Option – Sensorless Stall Detection {StallGuard}4.},
	publisher = {Trinamic},
	author = {{Trinamic}},
	urldate = {2021-05-02},
	date = {2020-05-18},
	file = {TMC2226_Datasheet_V106.pdf:/home/matous/Zotero/storage/8Q9L8JMC/TMC2226_Datasheet_V106.pdf:application/pdf},
}

@online{trinamic_microstepping_nodate,
	title = {Microstepping},
	url = {https://www.trinamic.com/technology/motor-control-technology/microstepping/},
	abstract = {Microstepping increases the accuracy, torque, energy efficiency, and smoothness of applications while at the same time reducing step loss, vibrations, and noise. With up to 256 microsteps per full step, Trinamic transforms digital information into perfect physical motion.},
	titleaddon = {Trinamic},
	author = {{Trinamic}},
	urldate = {2021-05-02},
	langid = {american},
	file = {Snapshot:/home/matous/Zotero/storage/7XM9GD65/microstepping.html:text/html},
}

@online{trinamic_trinamic_nodate,
	title = {Trinamic {StallGuard} and {CoolStep} Technology},
	url = {https://www.trinamic.com/technology/motor-control-technology/stallguard-and-coolstep/},
	abstract = {The sensorless technologies {StallGuard} and {CoolStep} reduce safety margins and increase energy efficiency using the back-{EMF} of a motor. Integrated into reliable building blocks, these industry-leading features improve user experience without extra cost.},
	titleaddon = {Trinamic},
	author = {{Trinamic}},
	urldate = {2021-05-02},
	langid = {american},
	file = {Snapshot:/home/matous/Zotero/storage/R7CCFYQK/stallguard-and-coolstep.html:text/html},
}

@online{piembsystech_can_nodate,
	title = {{CAN} Protocol},
	url = {https://piembsystech.com/can-protocol/},
	abstract = {The {CAN} is a multi-master, broadcasting, multi-casting, message-based, Event-driven, Flexibility, half-duplex, asynchronous type serial networking protocol.},
	titleaddon = {{PiEmbSysTech}},
	author = {{PiEmbSysTech}},
	urldate = {2021-05-03},
	langid = {american},
	file = {Snapshot:/home/matous/Zotero/storage/5DWSDSJ2/can-protocol.html:text/html},
}

@online{st_michael_introduction_2019,
	title = {Introduction to {CAN} (Controller Area Network) - Technical Articles},
	url = {https://www.allaboutcircuits.com/technical-articles/introduction-to-can-controller-area-network/},
	abstract = {This article introduces the Controller Area Network ({CAN}) serial communication bus, detailing message frames, bus arbitration, and signaling.},
	titleaddon = {All About Circuits},
	author = {St. Michael, Stephen},
	urldate = {2021-05-03},
	date = {2019-02-19},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/E7WJLW7P/introduction-to-can-controller-area-network.html:text/html},
}

@inreference{noauthor_can_2021,
	title = {{CAN} bus},
	rights = {Creative Commons Attribution-{ShareAlike} License},
	url = {https://en.wikipedia.org/w/index.php?title=CAN_bus&oldid=1018087172},
	abstract = {A Controller Area Network ({CAN} bus) is a robust vehicle bus standard designed to allow microcontrollers and devices to communicate with each other's applications without a host computer. It is a message-based protocol, designed originally for multiplex electrical wiring within automobiles to save on copper, but it can also be used in many other contexts. For each device, the data in a frame is transmitted sequentially but in such a way that if more than one device transmits at the same time, the highest priority device can continue while the others back off. Frames are received by all devices, including by the transmitting device.},
	booktitle = {Wikipedia},
	urldate = {2021-05-03},
	date = {2021-04-16},
	langid = {english},
	note = {Page Version {ID}: 1018087172},
	file = {Snapshot:/home/matous/Zotero/storage/UB3J2MN2/index.html:text/html},
}

@inreference{noauthor_canopen_2021,
	title = {{CANopen}},
	rights = {Creative Commons Attribution-{ShareAlike} License},
	url = {https://en.wikipedia.org/w/index.php?title=CANopen&oldid=1021343213},
	abstract = {{CANopen} is a communication protocol and device profile specification for embedded systems used in automation. In terms of the {OSI} model, {CANopen} implements the layers above and including the network layer. The {CANopen} standard consists of an addressing scheme, several small communication protocols and an application layer defined by a device profile.  The communication protocols have support for network management, device monitoring and communication between nodes, including a simple transport layer for message segmentation/desegmentation. The lower level protocol implementing the data link and physical layers is usually Controller Area Network ({CAN}), although devices using some other means of communication (such as Ethernet Powerlink, {EtherCAT}) can also implement the {CANopen} device profile.
The basic {CANopen} device and communication profiles are given in the {CiA} 301 specification released by {CAN} in Automation.[1] Profiles for more specialized devices are built on top of this basic profile, and are specified in numerous other standards released by {CAN} in Automation, such as {CiA} 401[2] for I/O-modules and {CiA} 402[3] for motion control.},
	booktitle = {Wikipedia},
	urldate = {2021-05-04},
	date = {2021-05-04},
	langid = {english},
	note = {Page Version {ID}: 1021343213},
	file = {Snapshot:/home/matous/Zotero/storage/UHDRP8PT/index.html:text/html},
}

@online{can_in_automation_can_2021,
	title = {{CAN} in Automation ({CiA}): {CANopen}},
	url = {https://www.can-cia.org/canopen/},
	abstract = {{CANopen} is a {CAN}-based communication system. It comprises higher-layer protocols and profile specifications. {CANopen} has been developed as a standardized embedded network with highly flexible configuration capabilities. It was designed originally for motion-oriented machine control systems, such as handling systems. Today it is used in various application fields, such as medical equipment, off-road vehicles, maritime electronics, railway applications, or building automation.},
	titleaddon = {{CAN} In Automation},
	author = {{CAN In Automation}},
	urldate = {2021-05-04},
	date = {2021},
	file = {CAN in Automation (CiA)\: CANopen:/home/matous/Zotero/storage/DR5VLIJR/canopen.html:text/html},
}

@online{circuitpython_circuitpython_2021,
	title = {{CircuitPython}},
	url = {https://circuitpython.org/},
	abstract = {The easiest way to program microcontrollers},
	titleaddon = {{CircuitPython}},
	author = {{CircuitPython}},
	urldate = {2021-05-06},
	date = {2021},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/G72533L5/circuitpython.org.html:text/html},
}

@online{dubois_programming_nodate,
	title = {Programming Languages for Embedded Systems 101: Background and Resources - News},
	url = {https://www.allaboutcircuits.com/news/programming-languages-for-embedded-systems-101-background-and-resources/},
	shorttitle = {Programming Languages for Embedded Systems 101},
	abstract = {A brief guide to some useful programming languages used in embedded systems design—and where you can learn, practice, and master them.},
	author = {Dubois, Chantelle},
	urldate = {2021-05-06},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/F7T3JAQJ/programming-languages-for-embedded-systems-101-background-and-resources.html:text/html},
}

@online{cohen_tech_nodate,
	title = {Tech Market Madness: The State of Embedded Programming Languages},
	url = {http://www.embeddedcomputing.com/technology/software-and-os/ides-application-programming/tech-market-madness-analyst-insights-for-engineers-embedded-programming-languages},
	shorttitle = {Tech Market Madness},
	abstract = {In this edition, Embedded Computing Design\&\#39;s technology editor, Perry Cohen, was joined by Chris Rommel, the Executive Vice President of {VDC} Research, a technology market intelligence firm.},
	titleaddon = {Embedded Computing Design},
	author = {Cohen, Perry},
	urldate = {2021-05-06},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/5GLAAMIA/tech-market-madness-analyst-insights-for-engineers-embedded-programming-languages.html:text/html},
}

@inreference{noauthor_embedded_2021,
	title = {Embedded software},
	rights = {Creative Commons Attribution-{ShareAlike} License},
	url = {https://en.wikipedia.org/w/index.php?title=Embedded_software&oldid=1021501630},
	abstract = {Embedded software is computer software, written to control machines or devices that are not typically thought of as computers, commonly known as embedded systems. It is typically specialized for the particular hardware that it runs on and has time and memory constraints. This term is sometimes used interchangeably with firmware.A precise and stable characteristic feature is that no or not all functions of embedded software are initiated/controlled via a human interface, but through machine-interfaces instead.Manufacturers build embedded software into the electronics of cars, telephones, modems, robots, appliances, toys, security systems, pacemakers, televisions and set-top boxes, and digital watches, for example. This software can be very simple, such as lighting controls running on an 8-bit microcontroller with a few kilobytes of memory with the suitable level of processing complexity determined with a Probably Approximately Correct Computation framework (a methodology based on randomized algorithms). However, embedded software can become very sophisticated in applications such as routers, optical network elements，airplanes, missiles, and process control systems.},
	booktitle = {Wikipedia},
	urldate = {2021-05-06},
	date = {2021-05-05},
	langid = {english},
	note = {Page Version {ID}: 1021501630},
	file = {Snapshot:/home/matous/Zotero/storage/Y5NBQ6WA/index.html:text/html},
}

@software{dubrov_idubroveeprom_2020,
	title = {idubrov/eeprom},
	rights = {View license         ,                 View license},
	url = {https://github.com/idubrov/eeprom},
	abstract = {Higher-level {API} for {FLASH} on {STM}32 + {EEPROM} emulation on top of {FLASH} pages},
	author = {Dubrov, Ivan},
	urldate = {2021-05-05},
	date = {2020-10-08},
	note = {original-date: 2017-09-28T06:54:38Z},
}

@online{texas_instruments_efuse_2021,
	title = {{eFuse} and Hot Swap Controllers},
	url = {https://www.ti.com/power-management/power-switches/efuse-hotswap-controllers/overview.html},
	titleaddon = {Texas Instruments},
	author = {{Texas Instruments}},
	urldate = {2021-05-05},
	date = {2021-05-05},
	file = {eFuse and Hot Swap Controllers | Overview | Power Management | TI.com:/home/matous/Zotero/storage/8EQY53WU/overview.html:text/html},
}

@video{greatscott_best_2021,
	title = {The Best Protection for your Circuits? {eFuse}! Here is why they are awesome! {EB}\#48},
	url = {https://www.youtube.com/watch?v=JOhQ3nsR7xo},
	shorttitle = {The Best Protection for your Circuits?},
	abstract = {\$2 for 1-4 Layer {PCBs}, Get {SMT} Coupons: https://jlcpcb.com/{AAA}​
Previous video: https://youtu.be/{pOsgXDpUQdM}​
{LiPo} Supercharger video: https://youtu.be/6LxRnf6sQNQ​
Short Circuit (Overcurrent) Protection video: https://youtu.be/7ctPSgaLxbc​
 Reverse Voltage Protection Circuit video: https://youtu.be/7Tk5ghH\_U2s​
Facebook: https://www.facebook.com/greatscottlab​
Twitter: https://twitter.com/{GreatScottLab}​
Support me for more videos: https://www.patreon.com/{GreatScott}?ty=h​

You can get an {eFuse} here: (affiliate link)
https://s.click.aliexpress.com/e/\_APh7dh​

In this electronics basics episode we will have a closer look at {eFuse} {ICs}. They offer a ton of protection features for a very small price tag. That is why I will show you how I used such an {eFuse} in my {LiPo} Supercharger project and how you can use it for pretty much every electronics project. The included protection features are the following: undervoltage, overvoltage, reverse voltage, overcurrent and short circuit current. Let's get started!

Thanks to {JLCPCB} for sponsoring this video.
Visit https://jlcpcb.com​ to get professional {PCBs} for low prices.

Music:
2011 Lookalike by Bartlebeats

0:00​ The ideal way to power electronics
1:00​ Why you need an {eFuse}!
2:19​ Intro
2:51​ How to select an {eFuse} {IC}?
5:10​ How to wire it up?
6:01​ Set the undervoltage limit
7:11​ Set the overvoltage limit
8:23​ Set the current limit
9:36​ Verdict
10:12​ Adding a reverse voltage protection},
	author = {{GreatScott!}},
	urldate = {2021-05-05},
	date = {2021-04-18},
}

@article{perkel_why_2020,
	title = {Why scientists are turning to Rust},
	volume = {588},
	rights = {2021 Nature},
	url = {https://www.nature.com/articles/d41586-020-03382-2},
	doi = {10.1038/d41586-020-03382-2},
	abstract = {Despite having a steep learning curve, the programming language offers speed and safety.},
	pages = {185--186},
	number = {7836},
	journaltitle = {Nature},
	author = {Perkel, Jeffrey M.},
	urldate = {2021-05-05},
	date = {2020-12-01},
	langid = {english},
	note = {Number: 7836
Publisher: Nature Publishing Group},
	file = {Snapshot:/home/matous/Zotero/storage/ZMNPJXEJ/d41586-020-03382-2.html:text/html;Full Text:/home/matous/Zotero/storage/R4WQYCAI/Perkel - 2020 - Why scientists are turning to Rust.pdf:application/pdf},
}

@online{noauthor_rust_nodate,
	title = {Rust and C++ interoperability - The Chromium Projects},
	url = {https://www.chromium.org/Home/chromium-security/memory-safety/rust-and-c-interoperability},
	abstract = {Home of the Chromium Open Source Project},
	urldate = {2021-05-05},
}

@online{chiovoloni_few_2020,
	title = {A Few Github Action “Recipes” for Rust},
	url = {https://shift.click/blog/github-actions-rust/},
	abstract = {Here’s some blocks of yaml you can copy-paste to make github actions work for your Rust project. Go nuts.},
	titleaddon = {shift.click},
	author = {Chiovoloni, Thom},
	urldate = {2021-05-05},
	date = {2020-09-06},
	langid = {english},
}

@online{coggeshall_openpgp_nodate,
	title = {{OpenPGP} in Rust: the Sequoia project [{LWN}.net]},
	url = {https://lwn.net/Articles/830902/},
	author = {Coggeshall, John},
	urldate = {2021-05-05},
	file = {OpenPGP in Rust\: the Sequoia project [LWN.net]:/home/matous/Zotero/storage/MQISH5RH/830902.html:text/html},
}

@online{sebastian_how_nodate,
	title = {How To Write Fast Rust Code},
	url = {https://likebike.com/posts/How_To_Write_Fast_Rust_Code.html},
	author = {Sebastian, Christopher},
	urldate = {2021-05-05},
	file = {How To Write Fast Rust Code:/home/matous/Zotero/storage/F46IA8QL/How_To_Write_Fast_Rust_Code.html:text/html},
}

@software{barber_mike-barberrust-zero-cost-abstractions_2021,
	title = {mike-barber/rust-zero-cost-abstractions},
	url = {https://github.com/mike-barber/rust-zero-cost-abstractions},
	abstract = {Testing out a Zero Cost Abstraction in Rust compared to similar approaches in C\# and Java},
	author = {Barber, Michael},
	urldate = {2021-05-05},
	date = {2021-05-05},
	note = {original-date: 2021-02-06T19:15:49Z},
	keywords = {benchmark, csharp, java, rust},
}

@online{microsoft_new_2020,
	title = {New safety rules in C++ Core Check},
	url = {https://devblogs.microsoft.com/cppblog/new-safety-rules-in-c-core-check/},
	abstract = {Rust and C++ are two popular systems programming languages. For years, the focus of C++ has been on performance. We are increasingly hearing calls from customers and security researchers that C++ should have stronger safety guarantees in the language. C++ often falls behind Rust when it comes to programming safety.},
	titleaddon = {C++ Team Blog},
	author = {{Microsoft}},
	urldate = {2021-05-05},
	date = {2020-09-04},
	langid = {american},
	file = {Snapshot:/home/matous/Zotero/storage/AMRG5MLW/new-safety-rules-in-c-core-check.html:text/html},
}

@article{jung_understanding_nodate,
	title = {Understanding and Evolving the Rust Programming Language},
	pages = {297},
	author = {Jung, Ralf},
	langid = {german},
	file = {Jung - Understanding and Evolving the Rust Programming La.pdf:/home/matous/Zotero/storage/5BREMNTI/Jung - Understanding and Evolving the Rust Programming La.pdf:application/pdf},
}

@software{doublet_audrandoubletopr_2021,
	title = {{AudranDoublet}/opr},
	url = {https://github.com/AudranDoublet/opr},
	abstract = {State-of-the-art (2020) Rust implementation of {SPH} (fluid simulation technique)},
	author = {Doublet, Audran},
	urldate = {2021-05-05},
	date = {2021-03-17},
	note = {original-date: 2020-05-10T15:53:07Z},
}

@online{hertleif_elegant_2016,
	title = {Elegant Library {APIs} in Rust},
	url = {https://deterministic.space/elegant-apis-in-rust.html},
	abstract = {The existence of libraries with nice, user-friendly interfaces is one of the most important factors when choosing a programming language. Here are some tips on how to write libraries with nice {APIs} in Rust. (Many of the points also apply to other languages.)},
	titleaddon = {Pascal’s Scribbles},
	author = {Hertleif, Pascal},
	urldate = {2021-05-05},
	date = {2016-07-21},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/KPUA96TA/elegant-apis-in-rust.html:text/html},
}

@online{molzer_magical_nodate,
	title = {The magical applications of Zero-Sized Types in Rust - Hardmo.de},
	url = {https://www.hardmo.de/article/2021-03-14-zst-proof-types.md},
	author = {Molzer, Andreas},
	urldate = {2021-05-05},
	file = {The magical applications of Zero-Sized Types in Rust - Hardmo.de:/home/matous/Zotero/storage/U8LV55TJ/2021-03-14-zst-proof-types.html:text/html},
}

@online{munns_ci_2021,
	title = {{CI} for Embedded Systems},
	url = {https://jamesmunns.com/blog/hardware-ci-overview/},
	titleaddon = {James Munns},
	author = {Munns, James},
	urldate = {2021-05-05},
	date = {2021-05-05},
	file = {James Munns:/home/matous/Zotero/storage/K5NQV47R/hardware-ci-overview.html:text/html},
}

@online{schwind_using_nodate,
	title = {Using Rust for a simple hardware project},
	url = {https://blog.tonari.no/rust-simple-hardware-project},
	abstract = {Diving into the embedded Rust ecosystem},
	titleaddon = {tonari blog},
	author = {Schwind, Brian},
	urldate = {2021-05-05},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/UWRV8468/rust-simple-hardware-project.html:text/html},
}

@online{egger_look_nodate,
	title = {A look into ways to implement and share data with interrupt handlers in Rust (Update 1)},
	url = {https://therealprof.github.io/blog/interrupt-comparison/},
	titleaddon = {The subconscious mumblings of therealprof},
	author = {Egger, Daniel},
	urldate = {2021-05-05},
}

@video{ferrous_systems_gmbh_how_2020,
	title = {How can we write the best device driver?},
	url = {https://www.youtube.com/watch?app=desktop&v=z9z74VpqO9A},
	abstract = {Writing a device driver can be a lot of work, writing a good one even more.

In this talk, we’ll explore some different styles of writing to and reading from registers and we’ll be weighing the pros and the cons. It will not conclude with a definitive best way, but hopefully it will give some ideas to use for the next driver you write.

The library discussed in this talk has also been publicly released since the talk was recorded: https://crates.io/crates/device-driver​},
	author = {{Ferrous Systems GmbH} and Dokter, Dion},
	urldate = {2021-05-05},
	date = {2020-10-01},
}

@online{vahter_release_nodate,
	title = {Release Rust embedded firmware using Github Actions},
	url = {https://andres.svbtle.com/release-rust-embedded-firmware-using-github-actions},
	abstract = {Github Actions \# Github Actions is a nice way to setup {CI}/{CD} pipelines for your Github projects. Let’s setup it for an embedded firmware project written in Rust. Continuous integration script would run every time when new code is pushed to master... {\textbar} Andres Vahter {\textbar} rust enthusiast},
	titleaddon = {Andres Vahter on Svbtle},
	author = {Vahter, Andres},
	urldate = {2021-05-05},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/TZSHTD84/release-rust-embedded-firmware-using-github-actions.html:text/html},
}

@online{schattinger_asyncawait_2020,
	title = {Async/Await for {AVR} with Rust},
	url = {https://lights0123.com/blog/2020/07/25/async-await-for-avr-with-rust/},
	abstract = {With the recent ability for Rust to target {AVR}, it's time for me to bring my favorite feature of Rust to Arduino: async/await. Asynchronous code allows for doing (seemingly) multiple things at once, without the memory or {CPU} overhead of threads.},
	titleaddon = {Ben Schattinger},
	author = {Schattinger, Ben},
	urldate = {2021-05-05},
	date = {2020-07-25},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/4PNXBS2Y/async-await-for-avr-with-rust.html:text/html},
}

@article{gaster_audio_2020,
	title = {Audio Anywhere with Faust},
	abstract = {This paper introduces Audio Anywhere ({AA}), a framework for working with audio plugins that are compiled once and run anywhere. At the heart of Audio Anywhere is an audio engine whose Digital Signal Processing ({DSP}) components are written in Faust and deployed with {WebAssembly}.},
	pages = {12},
	author = {Gaster, Benedict R and Cole, Max},
	date = {2020},
	langid = {english},
	file = {Gaster and Cole - 2020 - Audio Anywhere with Faust.pdf:/home/matous/Zotero/storage/ZLAB9USG/Gaster and Cole - 2020 - Audio Anywhere with Faust.pdf:application/pdf},
}

@online{mansanet_ecorax_nodate-1,
	title = {{eCorax} - As above, so below: Bare metal Rust generics 2/2},
	url = {https://www.ecorax.net/as-above-so-below-2/},
	shorttitle = {{eCorax} - As above, so below},
	abstract = {Writing two flash drivers starting from an abstraction, part two.},
	author = {Mansanet, Pablo},
	urldate = {2021-05-05},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/Y3RM2GNV/as-above-so-below-2.html:text/html},
}

@online{rahul_how_nodate,
	title = {How to run Rust on Arduino Uno - Our first blink},
	url = {https://creativcoder.dev/rust-on-arduino-uno},
	abstract = {A whirlwind tour on quickly getting up and running with Rust on Arduino},
	author = {Rahul, {CreativeCoder}},
	urldate = {2021-05-05},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/9FLLGKX4/rust-on-arduino-uno.html:text/html},
}

@online{gaynor_modern_2019,
	title = {Modern C++ Won't Save Us},
	url = {https://alexgaynor.net/2019/apr/21/modern-c++-wont-save-us/},
	author = {Gaynor, Alex},
	urldate = {2021-05-05},
	date = {2019-04-21},
	file = {Modern C++ Won't Save Us · Alex Gaynor:/home/matous/Zotero/storage/F8RMYZYG/modern-c++-wont-save-us.html:text/html},
}

@online{hutt_using_nodate,
	title = {Using std in embedded Rust},
	url = {http://blog.timhutt.co.uk/std-embedded-rust/index.html},
	author = {Hutt, Tim},
	urldate = {2021-05-05},
	file = {Using std in embedded Rust:/home/matous/Zotero/storage/GGQE3RLE/index.html:text/html},
}

@online{aparicio_concurrency_nodate,
	title = {Concurrency Patterns in Embedded Rust},
	url = {https://ferrous-systems.com/blog/embedded-concurrency-patterns/},
	author = {Aparicio, Jorge},
	urldate = {2021-05-05},
	file = {Concurrency Patterns in Embedded Rust:/home/matous/Zotero/storage/RPEZM6F9/embedded-concurrency-patterns.html:text/html},
}

@online{stoep_rust_nodate,
	title = {Rust in the Android platform},
	url = {https://security.googleblog.com/2021/04/rust-in-android-platform.html},
	abstract = {Posted by Jeff Vander Stoep and Stephen Hines, Android Team    Correctness of code in the Android platform is a top priority for the securit...},
	titleaddon = {Google Online Security Blog},
	author = {Stoep, Jeff Vander and Hines, Stephen},
	urldate = {2021-05-05},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/6VTAA48V/rust-in-android-platform.html:text/html},
}

@online{filho_rust_nodate,
	title = {Rust in the Linux kernel},
	url = {https://security.googleblog.com/2021/04/rust-in-linux-kernel.html},
	abstract = {Posted by Wedson Almeida Filho, Android Team    In our previous post , we announced that Android now supports the Rust  programming language...},
	titleaddon = {Google Online Security Blog},
	author = {Filho, Wedson Almeida},
	urldate = {2021-05-05},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/6ERCCFWM/rust-in-linux-kernel.html:text/html},
}

@software{dokter_diondokterdevice-driver_2021,
	title = {diondokter/device-driver},
	rights = {View license         ,                 View license},
	url = {https://github.com/diondokter/device-driver},
	abstract = {A toolkit to create better Rust device drivers, faster},
	author = {Dokter, Dion},
	urldate = {2021-05-05},
	date = {2021-05-02},
	note = {original-date: 2020-07-20T17:28:02Z},
}

@online{wolff_embedding_nodate,
	title = {Embedding Rust Into Zephyr Using Cbindgen},
	url = {https://www.jaredwolff.com/embedding-rust-into-zephyr-using-cbindgen/},
	author = {Wolff, Jared},
	urldate = {2021-05-05},
	file = {Embedding Rust Into Zephyr Using Cbindgen:/home/matous/Zotero/storage/DLVABQ5I/embedding-rust-into-zephyr-using-cbindgen.html:text/html},
}

@online{stenberg_half_nodate,
	title = {half of curl’s vulnerabilities are C mistakes {\textbar} daniel.haxx.se},
	url = {https://daniel.haxx.se/blog/2021/03/09/half-of-curls-vulnerabilities-are-c-mistakes/},
	author = {Stenberg, Daniel},
	urldate = {2021-05-05},
	langid = {american},
	file = {Snapshot:/home/matous/Zotero/storage/259QBFQY/half-of-curls-vulnerabilities-are-c-mistakes.html:text/html},
}

@online{johnston_embedded_2018,
	title = {Embedded Rules of Thumb},
	url = {https://embeddedartistry.com/blog/2018/04/26/embedded-rules-of-thumb/},
	abstract = {26 April 2018 by Phillip Johnston • Last updated 22 July 2020Updated: 20200602 Embedded Rules of Thumb You may call them guidelines, heuristics, or rules of thumb. No matter, the purpose is the same: to provide a reasonable approximation of the truth. These rules of thumb can help guide your understanding of the systems you … Continue reading "Embedded Rules of Thumb"},
	titleaddon = {Embedded Artistry},
	author = {Johnston, Phillip},
	urldate = {2021-05-05},
	date = {2018-04-26},
	langid = {american},
	file = {Snapshot:/home/matous/Zotero/storage/ZNRTAQ6W/embedded-rules-of-thumb.html:text/html},
}

@online{sfuptownmaker_i2c_2021,
	title = {I2C},
	rights = {Creative Commons Attribution-{ShareAlike} License},
	url = {https://learn.sparkfun.com/tutorials/i2c/all},
	shorttitle = {Sparkfun},
	abstract = {In this tutorial, you will learn all about the I2C communication protocol, why you would want to use it, and how it's implemented.},
	titleaddon = {Sparkfun - start something},
	author = {{SFUptownMaker}},
	urldate = {2021-05-05},
	date = {2021},
	file = {I2C - learn.sparkfun.com:/home/matous/Zotero/storage/P26XNGEH/all.html:text/html},
}

@misc{stmicro_an4879_2018,
	title = {{AN}4879 - {USB} hardware and {PCB} guidelines using {STM}32 {MCUs}},
	url = {https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahUKEwito5urq7LwAhXPFXcKHWKxDfAQFjAEegQIBhAD&url=https%3A%2F%2Fwww.st.com%2Fresource%2Fen%2Fapplication_note%2Fdm00296349-usb-hardware-and-pcb-guidelines-using-stm32-mcus-stmicroelectronics.pdf&usg=AOvVaw1eXmSESQxeC6yMXNhB_H59},
	publisher = {{STMicro}},
	author = {{STMicro}},
	urldate = {2021-05-05},
	date = {2018-12},
}

@inreference{noauthor_usb_2021,
	title = {{USB}},
	rights = {Creative Commons Attribution-{ShareAlike} License},
	url = {https://en.wikipedia.org/w/index.php?title=USB&oldid=1021306944},
	abstract = {Universal Serial Bus ({USB}) is an industry standard that establishes specifications for cables and connectors and protocols for connection, communication and power supply (interfacing) between computers, peripherals and other computers. A broad variety of {USB} hardware exists, including eleven different connectors, of which {USB}-C is the most recent.
Released in 1996, the {USB} standard is maintained by the {USB} Implementers Forum ({USB}-{IF}).  There have been four generations of {USB} specifications: {USB} 1.x, {USB} 2.0, {USB} 3.x, and {USB}4.},
	booktitle = {Wikipedia},
	urldate = {2021-05-05},
	date = {2021-05-04},
	langid = {english},
	note = {Page Version {ID}: 1021306944},
	file = {Snapshot:/home/matous/Zotero/storage/M6PX5WGA/index.html:text/html},
}

@article{valdez_understanding_2015,
	title = {Understanding the I2C Bus},
	abstract = {The I2C bus is a very popular and powerful bus used for communication between a master (or multiple masters) and a single or multiple slave devices. Figure 1 illustrates how many different peripherals may share a bus which is connected to a processor through only 2 wires, which is one of the largest benefits that the I2C bus can give when compared to other interfaces.},
	pages = {8},
	author = {Valdez, Jonathan and Becker, Jared},
	date = {2015},
	langid = {english},
	file = {Valdez and Becker - 2015 - Understanding the I2C Bus.pdf:/home/matous/Zotero/storage/DT5AZJ8N/Valdez and Becker - 2015 - Understanding the I2C Bus.pdf:application/pdf},
}

@online{rust_embedded_devices_wg_introduction_2021,
	title = {Introduction - The Embedded Rust Book},
	url = {https://docs.rust-embedded.org/book/intro/index.html},
	author = {Rust Embedded Devices {WG}},
	urldate = {2021-05-06},
	date = {2021},
	file = {Introduction - The Embedded Rust Book:/home/matous/Zotero/storage/QTJ364DT/index.html:text/html},
}

@online{noauthor_crates_2021,
	title = {Crates and source files - The Rust Reference},
	url = {https://doc.rust-lang.org/reference/crates-and-source-files.html#the-no_main-attribute},
	titleaddon = {The Rust Reference},
	urldate = {2021-05-06},
	date = {2021},
	file = {Crates and source files - The Rust Reference:/home/matous/Zotero/storage/ST5P458S/crates-and-source-files.html:text/html},
}

@online{munns_zero_2019,
	title = {From Zero to main(): Bare metal Rust},
	url = {https://interrupt.memfault.com/blog/zero-to-main-rust-1},
	shorttitle = {From Zero to main()},
	abstract = {A community and blog for embedded software makers},
	titleaddon = {Interrupt},
	author = {Munns, James},
	urldate = {2021-05-06},
	date = {2019-12-17},
	file = {Snapshot:/home/matous/Zotero/storage/DKG3PJ9D/zero-to-main-rust-1.html:text/html},
}

@software{rust_embedded_devices_wg_rust-embeddedalloc-cortex-m_2021,
	title = {rust-embedded/alloc-cortex-m},
	rights = {View license         ,                 View license},
	url = {https://github.com/rust-embedded/alloc-cortex-m},
	abstract = {A heap allocator for Cortex-M processors. Contribute to rust-embedded/alloc-cortex-m development by creating an account on {GitHub}.},
	publisher = {Rust Embedded},
	author = {Rust Embedded Devices {WG}},
	urldate = {2021-05-06},
	date = {2021-05-03},
	note = {original-date: 2016-11-19T15:34:18Z},
	keywords = {allocator, arm, cortex-m, microcontroller, no-std, rust},
}

@online{noauthor_alloc_nodate,
	title = {alloc - Rust},
	url = {https://doc.rust-lang.org/alloc/},
	urldate = {2021-05-06},
	file = {alloc - Rust:/home/matous/Zotero/storage/B45BLRBT/alloc.html:text/html},
}

@online{noauthor_platform_nodate,
	title = {Platform Support - The rustc book},
	url = {https://doc.rust-lang.org/nightly/rustc/platform-support.html},
	urldate = {2021-05-06},
	file = {Platform Support - The rustc book:/home/matous/Zotero/storage/PWNCWP6V/platform-support.html:text/html},
}

@software{mabin_mabezdevxtensa-rust-quickstart_2021,
	title = {{MabezDev}/xtensa-rust-quickstart},
	rights = {View license         ,                 View license},
	url = {https://github.com/MabezDev/xtensa-rust-quickstart},
	abstract = {A demo crate for the xtensa {uC}'s ({ESP}32, {ESP}8266). Contribute to {MabezDev}/xtensa-rust-quickstart development by creating an account on {GitHub}.},
	author = {Mabin, Scott},
	urldate = {2021-05-06},
	date = {2021-05-06},
	note = {original-date: 2019-03-05T23:57:17Z},
}

@software{rust_embedded_devices_wg_rust-embeddedsvd2rust_2021,
	title = {rust-embedded/svd2rust},
	rights = {View license         ,                 View license},
	url = {https://github.com/rust-embedded/svd2rust},
	abstract = {Generate Rust register maps (`struct`s) from {SVD} files},
	publisher = {Rust Embedded},
	author = {{Rust Embedded Devices WG}},
	urldate = {2021-05-06},
	date = {2021-05-06},
	note = {original-date: 2016-10-09T02:47:52Z},
	keywords = {arm, cmsis-svd, code-generator, cortex-m, microcontroller, rust},
}

@software{noauthor_stm32-rsstm32-rs_2021,
	title = {stm32-rs/stm32-rs},
	rights = {View license         ,                 View license},
	url = {https://github.com/stm32-rs/stm32-rs},
	abstract = {Embedded Rust device crates for {STM}32 microcontrollers},
	publisher = {stm32-rs},
	urldate = {2021-05-06},
	date = {2021-04-30},
	note = {original-date: 2017-05-31T02:43:32Z},
}

@software{rust_embedded_devices_wg_rust-embeddedembedded-hal_2021,
	title = {rust-embedded/embedded-hal},
	rights = {View license         ,                 View license},
	url = {https://github.com/rust-embedded/embedded-hal},
	abstract = {A Hardware Abstraction Layer ({HAL}) for embedded systems},
	publisher = {Rust Embedded},
	author = {{Rust Embedded Devices WG}},
	urldate = {2021-05-06},
	date = {2021-05-06},
	note = {original-date: 2017-06-09T20:57:29Z},
}

@software{rust_embedded_devices_wg_rust-embeddedwg_2021,
	title = {rust-embedded/wg},
	url = {https://github.com/rust-embedded/wg},
	abstract = {Coordination repository of the embedded devices Working Group},
	publisher = {Rust Embedded},
	author = {{Rust Embedded Devices WG}},
	urldate = {2021-05-06},
	date = {2021-05-04},
	note = {original-date: 2016-09-29T02:01:26Z},
}

@software{noauthor_stm32-rsstm32f4xx-hal_2021,
	title = {stm32-rs/stm32f4xx-hal},
	rights = {View license         ,                 View license},
	url = {https://github.com/stm32-rs/stm32f4xx-hal},
	abstract = {A Rust embedded-hal {HAL} for all {MCUs} in the {STM}32 F4 family},
	publisher = {stm32-rs},
	urldate = {2021-05-06},
	date = {2021-05-04},
	note = {original-date: 2018-10-01T22:03:48Z},
}

@online{noauthor_preface_nodate,
	title = {Preface - Real-Time Interrupt-driven Concurrency},
	url = {https://rtic.rs/0.5/book/en/},
	urldate = {2021-05-06},
	file = {Preface - Real-Time Interrupt-driven Concurrency:/home/matous/Zotero/storage/84JDJM7W/en.html:text/html},
}

@software{noauthor_stm32-rsbxcan_2021,
	title = {stm32-rs/bxcan},
	rights = {View license         ,                 View license},
	url = {https://github.com/stm32-rs/bxcan},
	abstract = {{bxCAN} peripheral driver for {STM}32 chips. Contribute to stm32-rs/bxcan development by creating an account on {GitHub}.},
	publisher = {stm32-rs},
	urldate = {2021-05-06},
	date = {2021-05-05},
	note = {original-date: 2020-11-18T19:45:39Z},
	keywords = {can-bus, embedded, hal, rust-embedded},
}

@software{noauthor_stm32-rsstm32-eth_2021,
	title = {stm32-rs/stm32-eth},
	rights = {Apache-2.0 License         ,                 Apache-2.0 License},
	url = {https://github.com/stm32-rs/stm32-eth},
	abstract = {Embedded Ethernet driver in Rust. Contribute to stm32-rs/stm32-eth development by creating an account on {GitHub}.},
	publisher = {stm32-rs},
	urldate = {2021-05-06},
	date = {2021-03-19},
	note = {original-date: 2018-02-06T02:18:56Z},
}

@software{noauthor_stm32-rsstm32-usbd_2021,
	title = {stm32-rs/stm32-usbd},
	rights = {{MIT} License         ,                 {MIT} License},
	url = {https://github.com/stm32-rs/stm32-usbd},
	abstract = {usb-device implementation for {STM}32 microcontrollers},
	publisher = {stm32-rs},
	urldate = {2021-05-06},
	date = {2021-04-25},
	note = {original-date: 2019-03-24T19:30:20Z},
}

@online{rust_embedded_devices_wg_preface_nodate,
	title = {Preface - The Embedonomicon},
	url = {https://docs.rust-embedded.org/embedonomicon/index.html},
	author = {{Rust Embedded Devices WG}},
	urldate = {2021-05-07},
	file = {Preface - The Embedonomicon:/home/matous/Zotero/storage/ZPPFRYKE/index.html:text/html},
}

@online{rust_embedded_devices_wg_introduction_nodate,
	title = {Introduction - Discovery},
	url = {https://docs.rust-embedded.org/discovery/index.html},
	author = {{Rust Embedded Devices WG}},
	urldate = {2021-05-07},
	file = {Introduction - Discovery:/home/matous/Zotero/storage/994ZWJYP/index.html:text/html},
}

@online{noauthor_embedded_nodate,
	title = {Embedded devices working group},
	url = {https://www.rust-lang.org/governance/wgs/embedded},
	abstract = {A language empowering everyone to build reliable and efficient software.},
	urldate = {2021-05-07},
	langid = {american},
	file = {Snapshot:/home/matous/Zotero/storage/4EVWA2CZ/embedded.html:text/html},
}

@software{greig_adamgreigstm32ral_2021,
	title = {adamgreig/stm32ral},
	rights = {View license         ,                 View license},
	url = {https://github.com/adamgreig/stm32ral},
	abstract = {Register access layer in Rust for all {STM}32 microcontrollers},
	author = {Greig, Adam},
	urldate = {2021-05-07},
	date = {2021-01-31},
	note = {original-date: 2018-06-25T22:35:57Z},
}

@online{aparicio_memory_nodate,
	title = {Memory safe {DMA} transfers - Embedded in Rust},
	url = {https://blog.japaric.io/safe-dma/},
	abstract = {A blog about Rust and embedded stuff},
	author = {Aparicio, Jorge},
	urldate = {2021-05-08},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/6ATR7PJ6/safe-dma.html:text/html},
}

@online{noauthor_static_nodate,
	title = {Static items - The Rust Reference},
	url = {https://doc.rust-lang.org/reference/items/static-items.html},
	urldate = {2021-05-08},
	file = {Static items - The Rust Reference:/home/matous/Zotero/storage/B7UFZMNF/static-items.html:text/html},
}

@software{noauthor_embassy-rsembassy_2021,
	title = {embassy-rs/embassy},
	rights = {View license         ,                 View license},
	url = {https://github.com/embassy-rs/embassy},
	abstract = {Rust Embedded async executor and {HALs}. Contribute to embassy-rs/embassy development by creating an account on {GitHub}.},
	publisher = {embassy-rs},
	urldate = {2021-05-08},
	date = {2021-05-08},
	note = {original-date: 2020-09-22T16:04:20Z},
	keywords = {async, drivers, embedded, executor, hal, rust},
}

@online{rust_embedded_devices_wg_interoperability_nodate,
	title = {Interoperability - The Embedded Rust Book},
	url = {https://docs.rust-embedded.org/book/interoperability/index.html},
	author = {{Rust Embedded Devices WG}},
	urldate = {2021-05-08},
	file = {Interoperability - The Embedded Rust Book:/home/matous/Zotero/storage/GV8AST66/index.html:text/html},
}

@software{probe_rs_project_probe-rscargo-embed_2021,
	title = {probe-rs/cargo-embed},
	rights = {View license         ,                 View license},
	url = {https://github.com/probe-rs/cargo-embed},
	abstract = {a cargo extension for working with microcontrollers},
	publisher = {probe.rs},
	author = {{Probe RS project}},
	urldate = {2021-05-09},
	date = {2021-05-06},
	note = {original-date: 2020-04-09T17:30:24Z},
	keywords = {arm, cargo, daplink, debugging, embedded, flash, jlink, rust, stlink},
}

@software{probe_rs_project_probe-rscargo-flash_2021,
	title = {probe-rs/cargo-flash},
	rights = {View license         ,                 View license},
	url = {https://github.com/probe-rs/cargo-flash},
	abstract = {a cargo extension for programming microcontrollers},
	publisher = {probe.rs},
	author = {Probe {RS} project},
	urldate = {2021-05-09},
	date = {2021-05-05},
	note = {original-date: 2020-01-29T19:52:01Z},
	keywords = {arm, cargo, daplink, debugging, embedded, flash, jlink, rust, stlink},
}

@software{knurling_project_knurling-rsprobe-run_2021,
	title = {knurling-rs/probe-run},
	rights = {View license         ,                 View license},
	url = {https://github.com/knurling-rs/probe-run},
	abstract = {Run embedded programs just like native ones. Contribute to knurling-rs/probe-run development by creating an account on {GitHub}.},
	publisher = {Knurling},
	author = {{Knurling Project}},
	urldate = {2021-05-09},
	date = {2021-05-08},
	note = {original-date: 2020-08-14T08:46:46Z},
	keywords = {cargo-runner, embedded-rust, ferrous-systems},
}

@software{knurling_project_knurling-rsdefmt_2021,
	title = {knurling-rs/defmt},
	rights = {View license         ,                 View license},
	url = {https://github.com/knurling-rs/defmt},
	abstract = {Efficient, deferred formatting for logging on embedded systems},
	publisher = {Knurling},
	author = {{Knurling Project}},
	urldate = {2021-05-09},
	date = {2021-05-07},
	note = {original-date: 2020-07-24T16:04:15Z},
	keywords = {embedded-systems, ferrous-systems, logging, rust, rust-tools},
}

@software{knurling_project_knurling-rsflip-link_2021,
	title = {knurling-rs/flip-link},
	rights = {View license         ,                 View license},
	url = {https://github.com/knurling-rs/flip-link},
	abstract = {Adds zero-cost stack overflow protection to your embedded programs},
	publisher = {Knurling},
	author = {{Knurling Project}},
	urldate = {2021-05-09},
	date = {2021-04-28},
	note = {original-date: 2020-09-07T17:05:51Z},
	keywords = {embedded, embedded-rust, ferrous-systems, linkers, rust, rust-tools, tooling},
}

@online{aparicio_using_nodate,
	title = {Using {GDB} and defmt to debug embedded programs},
	url = {https://ferrous-systems.com/blog/gdb-and-defmt/},
	author = {Aparicio, Jorge},
	urldate = {2021-05-09},
	file = {Using GDB and defmt to debug embedded programs:/home/matous/Zotero/storage/DHCAXVAG/gdb-and-defmt.html:text/html},
}

@software{probe_rs_project_probe-rsprobe-rs_2021,
	title = {probe-rs/probe-rs},
	rights = {View license         ,                 View license},
	url = {https://github.com/probe-rs/probe-rs},
	abstract = {A debugging toolset and library for debugging embedded {ARM} and {RISC}-V targets on a separate host},
	publisher = {probe.rs},
	author = {{Probe RS project}},
	urldate = {2021-05-09},
	date = {2021-05-08},
	note = {original-date: 2019-02-10T20:13:01Z},
	keywords = {arm, arm-cores, coresight, daplink, debug, debug-probes, jlink, probe-rs, riscv, rust, stlink},
}

@online{aparicio_testing_nodate,
	title = {Testing an embedded application},
	url = {https://ferrous-systems.com/blog/test-embedded-app/},
	author = {Aparicio, Jorge},
	urldate = {2021-05-09},
	file = {Testing an embedded application:/home/matous/Zotero/storage/QJM2A4SE/test-embedded-app.html:text/html},
}

@online{aparicio_testing_nodate-1,
	title = {Testing a Hardware Abstraction Layer ({HAL})},
	url = {https://ferrous-systems.com/blog/defmt-test-hal/},
	author = {Aparicio, Jorge},
	urldate = {2021-05-09},
	file = {Testing a Hardware Abstraction Layer (HAL):/home/matous/Zotero/storage/AAGCDC73/defmt-test-hal.html:text/html},
}

@online{schievink_running_nodate,
	title = {Running hardware-in-the-loop tests on {GitHub} Actions},
	url = {https://ferrous-systems.com/blog/gha-hil-tests/},
	author = {Schievink, Jonas},
	urldate = {2021-05-09},
	file = {Running hardware-in-the-loop tests on GitHub Actions:/home/matous/Zotero/storage/GVM7TPAC/gha-hil-tests.html:text/html},
}

@video{salmony_kicad_2020,
	title = {{KiCad} {STM}32 + {USB} + Buck Converter {PCB} Design and {JLCPCB} Assembly (Update)},
	url = {https://www.youtube.com/watch?v=C7-8nUU6e3E},
	abstract = {471,237 views • 26 Sept 2020 • Entire step-by-step {PCB} design process going through the schematic, layout, and routing of a 'barebones' {STM}32F4-based {PCB} including {USB} and a buck converter in {KiCAD}. All the way from schematic creation, through to four-layer {PCB} layout and routing, as well as sending it off for manufacture and assembly via {JLCPCB}. Visit https://jlcpcb.com/{RHS}​ for \$2 for five 2-layer {PCBs} and \$5 for five 4-layer {PCBs}.


This is an update from the original '{KiCad} {STM}32 Hardware Design' video, including some additional tips and tricks, as well as a show of various assembled boards made by {JLCPCB}. Hopefully with much improved audio quality!

Git: https://github.com/pms67/{STM}32F4-Refe...​

If you're enjoying my content, please consider becoming a patron:
https://www.patreon.com/phils94​

[{TIMESTAMPS}]
00:00​ Introduction
00:14​ Topics covered
00:31​ {JLCPCB} assembly showcase

00:58​ Parts used in design ({JLCPB} parts library)
03:28​ {STM}32 pin assignment in {STM}32CubeMX

({SCHEMATIC})
09:43​ {KiCad} project and schematic
10:06​ Schematic page settings
10:53​ Adding {STM}32F405 to schematic
12:10​ {STM}32 power pins
14:14​ Labelling pins/global labels
14:57​ {VCAP} pins
16:37​ {NRST} and {BOOT}0 pins, Bootmodes
20:24​ Transferring assignments from {CubeMX} to {KiCad}
23:58​ 'No connect' flags
24:48​ Decoupling capacitors
26:10​ {VDDA} pin decoupling
27:54​ Crystal circuitry ({HSE})
37:15​ {LED} and current limiting resistor
39:26​ Buck converter circuitry (+ fusing, reverse polarity protection)
56:15​ Connectors ({SWD}, I2C, {UART})
1:02:40​ {USB}
1:11:09​ Electrical rules checker ({ERC})
1:12:55​ Mounting holes
1:13:45​ Assigning footprints to symbols
1:24:36​ Generating the netlist

({LAYOUT})
1:24:55​ Choosing the number of {PCB} layers
1:26:11​ Design rules
1:27:26​ Rough layout (section by section)
1:35:09​ Improving the layout, finer details
1:53:17​ Mounting hole placement
1:55:10​ Board outline and rounded corners
1:57:40​ Rearranging connectors

({ROUTING})
2:00:19​ Adding track widths
2:00:55​ Power and ground planes (copper pours)
2:03:10​ {STM}32 routing (critical items first)
2:04:41​ Tombstoning
2:05:55​ Track spacing
2:08:49​ Buck converter routing
2:10:00​ Track width calculator
2:12:39​ {USB} controlled impedance differential traces
2:13:08​ {JLCPCB} impedance calculator
2:16:09​ Connecting {GND} and 3V3 (with vias to internal copper pours)
2:28:00​ Design rules check ({DRC})
2:28:50​ Silkscreen (labelling, pin 1 indication, polarity indication)
2:36:10​ Importing custom graphics as silkscreen

({MANUFACTURING} {AND} {ASSEMBLY})
2:36:55​ Hiding {JLCPCB} order number
2:37:42​ Adding tooling holes for assembly
2:39:10​ Generating Gerber and drill files
2:40:27​ Footprint position file
2:41:34​ Bill of materials ({BOM}) and assigning part numbers ({LCSC})
2:44:32​ Ordering {PCBs} via {JLCPCB} with assembly



  
        Show less
      


  
        Show more},
	author = {Salmony, Philip},
	urldate = {2021-05-09},
	date = {2020-09-26},
}

@misc{stmicro_stm32f405xx_2020,
	title = {{STM}32F405xx {STM}32F407xx},
	url = {https://www.st.com/resource/en/datasheet/stm32f405rg.pdf},
	abstract = {Arm® Cortex®-M4 32b {MCU}+{FPU}, 210DMIPS, up to 1MB Flash/192+4KB {RAM},{USB} {OTG} {HS}/{FS}, Ethernet, 17 {TIMs}, 3 {ADCs}, 15 comm. interfaces \& camera},
	publisher = {{STMicro}},
	author = {{STMicro}},
	urldate = {2020-09-05},
	date = {2020-08},
}

@misc{stmicro_ta0357_2018,
	title = {{TA}0357 - Overview of {USB} Type-C and Power Delivery technologies},
	url = {https://www.st.com/content/ccc/resource/technical/document/technical_article/group0/59/a8/53/96/fe/a8/45/35/DM00496853/files/DM00496853.pdf/jcr:content/translations/en.DM00496853.pdf},
	publisher = {{STMicro}},
	author = {{STMicro}},
	urldate = {2021-10-05},
	date = {2018-05},
}

@online{microchip_mcp2562_nodate,
	title = {{MCP}2562 - Interface - Interface- Controller Area Network ({CAN})},
	url = {https://www.microchip.com/wwwproducts/en/MCP2562},
	titleaddon = {Microchip},
	author = {{Microchip}},
	urldate = {2021-05-10},
	file = {MCP2562 - Interface - Interface- Controller Area Network (CAN):/home/matous/Zotero/storage/JF5N3LTG/MCP2562.html:text/html},
}

@misc{stmicro_an2867_2020,
	title = {{AN}2867 - Oscillator design guide for {STM}8AF/{AL}/S, {STM}32 {MCUs} and {MPUs}},
	url = {https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahUKEwjXke-Vhr_wAhVaPuwKHWkLCREQFjAAegQIBxAD&url=https%3A%2F%2Fwww.st.com%2Fresource%2Fen%2Fapplication_note%2Fcd00221665-oscillator-design-guide-for-stm8afals-stm32-mcus-and-mpus-stmicroelectronics.pdf&usg=AOvVaw0W61KfA6_gLIcIPUfy7taA},
	publisher = {{STMicro}},
	author = {{STMicro}},
	urldate = {2021-10-05},
	date = {2020-12},
}

@online{reprap_nema_nodate,
	title = {{NEMA} Motor - {RepRap}},
	url = {https://reprap.org/wiki/NEMA_Motor},
	author = {{RepRap}},
	urldate = {2021-05-10},
	file = {NEMA Motor - RepRap:/home/matous/Zotero/storage/JRGAEHZC/NEMA_Motor.html:text/html},
}

@online{noauthor_nema_nodate,
	title = {{NEMA} 17HS4401 Bipolar Stepper Motor},
	url = {https://www.cytron.io/p-nema-17hs4401-bipolar-stepper-motor},
	urldate = {2021-05-10},
	file = {NEMA 17HS4401 Bipolar Stepper Motor:/home/matous/Zotero/storage/B72URV2R/p-nema-17hs4401-bipolar-stepper-motor.html:text/html},
}

@software{rust_embedded_devices_wg_rust-embeddedcortex-m_2021,
	title = {rust-embedded/cortex-m},
	rights = {View license         ,                 View license},
	url = {https://github.com/rust-embedded/cortex-m},
	abstract = {Low level access to Cortex-M processors. Contribute to rust-embedded/cortex-m development by creating an account on {GitHub}.},
	publisher = {Rust Embedded},
	author = {{Rust Embedded Devices WG}},
	urldate = {2021-05-11},
	date = {2021-05-02},
	note = {original-date: 2016-09-27T23:35:04Z},
	keywords = {arm, cortex-m, microcontroller, no-std, rust},
}

@book{thomas_pragmatic_2019,
	location = {Boston},
	edition = {Second edition},
	title = {The pragmatic programmer, 20th anniversary edition: journey to mastery},
	isbn = {978-0-13-595705-9},
	shorttitle = {The pragmatic programmer, 20th anniversary edition},
	abstract = {"Straight from the trenches, The Pragmatic Programmer, 20th Anniversary Edition, cuts through the increasing specialization and technicalities of modern software development to examine the core process: transforming a requirement into working, maintainable code that delights users. Extensively updated with ten new sections and major revisions throughout, this edition covers topics ranging from career development to architectural techniques for keeping code flexible, adaptable, and reusable. The Pragmatic Programmer illustrates today's best practices and major pitfalls of many different aspects of software development. Whether you're a new coder, an experienced programmer, or a manager responsible for software projects, applying this guide's lessons will help you rapidly improve your productivity, quality, and job satisfaction"--},
	publisher = {Addison-Wesley},
	author = {Thomas, David and Hunt, Andrew},
	date = {2019},
}

@software{noauthor_stm32-rsstm32-usbd_2021-1,
	title = {stm32-rs/stm32-usbd},
	rights = {{MIT} License         ,                      {MIT} License},
	url = {https://github.com/stm32-rs/stm32-usbd},
	abstract = {usb-device implementation for {STM}32 microcontrollers},
	publisher = {stm32-rs},
	urldate = {2021-05-14},
	date = {2021-05-13},
	note = {original-date: 2019-03-24T19:30:20Z},
}

@software{virkkunen_mvirkkunenusb-device_2021,
	title = {mvirkkunen/usb-device},
	rights = {{MIT} License         ,                      {MIT} License},
	url = {https://github.com/mvirkkunen/usb-device},
	abstract = {Experimental device-side {USB} framework for microcontrollers in Rust.},
	author = {Virkkunen, Matti},
	urldate = {2021-05-14},
	date = {2021-05-11},
	note = {original-date: 2018-08-28T16:01:57Z},
}

@software{virkkunen_mvirkkunenusbd-serial_2021,
	title = {mvirkkunen/usbd-serial},
	rights = {{MIT} License         ,                      {MIT} License},
	url = {https://github.com/mvirkkunen/usbd-serial},
	abstract = {Work-in progress minimal {CDC}-{ACM} ({USB} serial port) class for usb-device},
	author = {Virkkunen, Matti},
	urldate = {2021-05-14},
	date = {2021-05-03},
	note = {original-date: 2019-05-23T15:14:29Z},
}

@online{noauthor_obdevv-usb_nodate,
	title = {obdev/v-usb},
	url = {https://github.com/obdev/v-usb},
	abstract = {A Firmware-Only {USB} implementation for Atmel's {AVR} Microcontrollers - obdev/v-usb},
	titleaddon = {{GitHub}},
	urldate = {2021-05-14},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/7KYBAKY4/USB-IDs-for-free.html:text/html},
}

@online{noauthor_rust_nodate-1,
	title = {Rust Foundation},
	url = {https://foundation.rust-lang.org},
	abstract = {The Rust Foundation is an independent non-profit organization to steward the Rust programming language and ecosystem, with a unique focus on supporting the set of maintainers that govern and develop the project.},
	urldate = {2021-05-16},
	langid = {english},
	file = {Snapshot:/home/matous/Zotero/storage/E4L8L92W/foundation.rust-lang.org.html:text/html},
}

@online{noauthor_servo_nodate,
	title = {Servo},
	url = {https://servo.org/},
	urldate = {2021-05-16},
	file = {Servo:/home/matous/Zotero/storage/IXCFYDMS/servo.org.html:text/html},
}