Zero To Maker Workshop | Fab Academy (Our Experience)

Welcome to the first video in this workshop! As a part of this series we will be completing Fab Academy 2024, a fast-paced hands-on maker course based on the MIT's "How to make anything" 
course. In this course, we will both be completing a project over the course of a few months and we will be taking all the essential maker skills that we use to complete those projects and try to pass them onto you through this workshop.

Liam will be building an self-watering and monitoring planter system, and Jaryd will be building an autonomous house robot. These projects are quite involved, so we will be covering a wide varitey of skills from 3D printing to coding and everything inbetween. 

So join us on this journey as we are excited to share not only these skills that define us as makers, but also all the experiences in completing these projects as a part of Fab Academy.

(Also check out the resource tabs...)

Each video will have this resources tab which will contain links to additional resources or things we discussed in the video. Sometimes it may be a link to a software suite or online calculator, sometimes it may be an entire 3D printing course. For example:

If you want to take a look at our projects, Plant Pulse and LEO both have their own dedicated sites. (spoiler alert, we may be learning how to set these up in the coming video)

Our first stop in this series is to find a project to work on. Choosing a project is quite a personal thing - projects are influenced by the problems we face, the hobbies we have, and the resources we have access to. There are a lot of rocky shores to get stuck on when it comes to projects and a lot of lessons to be learnt with experience. To save you some anguish, here are some of the most common ones that many of the team here wish they had known as a beginner:

1. Choose a project that has been done before, or has had similar projects done before.
2. Clearly define what your project sets out to do.
3. Break all your problems down into smaller problems.
4. Become friends with failure.
5. Get involved in a maker community, whether it be a physical maker space Fablab, or an online maker community.

That last one is really important. A beginner maker may struggle to see the difference between a project that can be done in a week, and one that might require a degree in robotics to complete. This along with many other issues can be avoided by chatting with more experienced makers in a maker community. And chances are one day you will be experienced enough to help beginners with the same problems as well!

If you need some inspiration for a project, we have a dedicated projects page showcasing some of the cool, weird and wonderful projects that our community has made.

Some of our favourites are Mark's Roverling project (which also got a MK2 update), an incredible art piece of simulated pedestrians in Paris by Pixmusix, and this awesome portable arcade emulator by M4xx.

Want to earn some cred within the maker community and keep track of your project progress? Github and Github Pages are essential tools that do so by allowing you to back up your projects, and create a free website to host your project documentation.

Git is a method of backing up and adding a “timeline” to your project, allowing you to create checkpoints that can be reverted to when needed. All this is stored in something called a repository and Github (and also a similar service called GitLab) can be used to instead have this repository stored online, accessible from anywhere in the world with any device (but only people that have been given access can make changes to it).

Once you have created a GitHub account and have a repo set up, you can do the following things:

• Clone: This creates a local copy of the online GitHub repo that you can edit and work out of and then upload back to GitHub later, with all the changes you made.
• Commit: Let's say you clone the repo, and then make some changes. When you commit, you save those changes you made to your local repo and you create a "checkpoint".
• Push: After making a commit and creating a checkpoint in your local repo, running a push command will send that local commit to the online Github repo. This kind of just syncs the changes you made locally with your online GitHub repo.
• Pull: If you have 2 devices working on the same repo and device A pushes a commit to GitHub, that change will not be automatically updated on device B, it will be "behind" the main repo. To fix this, run the pull command. It will update your local repo to whatever is in the online GitHub repo.

Using this system we create a safety net of backups that we can use, as well as make our project available to the maker community if we wish to make it public. You can take this one step further by using the GitHub Pages feature to create a free website built out of your repo to document your project with pictures, videos, links, and write-ups.

You can use GitHub to document and create a documentation website, or you could also use GitLab which is a similar alternative. As a part of Fab Academy, we are using GitLab and if you want to check out Jaryd or Liam's GitLab pages site, you'll find some information on how to set them up. Both of these services work in nearly the same ways, however with GitHub, you will be able to use GitHub Desktop.

Here is a handy list of resources for GitHub:

Backing up your project with Git and GitHub

• Git for Makers | Core Electronics 
• Getting started with Git | GitHub Docs
• Getting started with GitHub Desktop | GitHub Docs

Documenting your project with GitHub Pages

• Getting started with GitHub pages | GitHub Docs
• The Ultimate Markdown Cheat Sheet | GitHub Docs
• REMIX: Add a theme to your GitHub Pages Website | GitHub Docs

CAD (Computer Aided Design) is the bridge between an idea of a part in your head to having that part 3D printed or laser cut as a real-world part. There are many different types of 3D modelling and they all achieve different outcomes, but CAD is often our weapon of choice as makers due to its precise nature. While other modelling workflows like Blender are great at producing sculptures, CAD is very mathematical and exact which makes it great for modelling technical parts such as mechanisms, robots, and cars.

CAD modelling is also one of the easiest forms of digital 3D modelling to learn, and in this video, we will be learning to model in software called Onshape - it's an awesome CAD program that is free and browser-based. Don't worry about locking yourself into a specific software though as if you learn how to model in 1 CAD program, you kind of learn how to do it in all of them.

Modelling in CAD consists of roughly the same 3 steps.

• Sketching - this is where we draw a 2D shape using a variety of drawing tools.
• Extruding - this is where we take that 2D sketched shape and turn it into a 3D shape.
• Modifying - this takes that 3D shape and modifies using a series of tools (like smoothing off the edges of a shape)

And the entire 3D modelling process is just these 3 steps repeated in a given order to build up what we want to model. Once we have modelled our part to our liking, it's an easy process to get it manufactured with something like 3D printing or laser cutting.

CAD is a skill where practice is key and is by far the best way to learn, so head on over to the resources tab.

You can find onshape here. You will need to create an account and just be aware that although it is free, anything you model will be available to the public. CAD software is often aimed at (and priced at) professional engineers so it is an alright compromise. If you are currently a student though, sign up for a student account as you will get some more bells and whistles, as well as have all your models not be public.

If you are chasing some more tutorials, onshape has some fantastic self-paced and hands-on tutorials. A good next step would be to follow their Introduction to Part Design course, as it will step you through making a part like we did, but will demonstrate some more tools and techniques that we weren't able to fit into a 15-minute video.

That video is a part of their CAD Basics series which has some other great tutorials on things like using the assembly studio and parametric features.

Already a pro in CAD? Take a look at their catalogue of tutorials which has some more advanced tutorials.

Also, a bonus tip when 3D modelling in CAD, its often handy to have a set of calipers or a ruler on hand. When you model a part to be 240 mm wide, it's often hard to know how big that is without them, and it helps you visualise it.

3D printing has become one of the most common tools for makers to use thanks to its ease of use, wide availability, and ability to make complex parts relatively quickly. 3D printers use stepper motors to move a hot nozzle around which melts the plastic onto a print bed, building a part up layer by layer. One of the biggest pros of 3D printing is that it is a passive process meaning that it is often as simple as uploading your file to it, pressing a button, and then coming back when it's done printing.

But before we do that, we need to get our CAD designs ready for 3d printing. The first thing we need to do is to export the file from CAD into a universally accepted 3d model file. You may see many different file formats, but the most common is an STL and it has largely become the standard. When exporting from your CAD software as an STL, always ensure that you export in the highest quality/detail possible.

Next, we need to slice the file. 3D printers follow a set of instructions called machine code. This code just contains instructions telling the printer where to move the nozzle, what temperature to heat it to, how much plastic to extrude etc. A slicing software takes our STL and turns it into this machine code. The slicing software also gives us a range of options as to how the printer will build our part. We can customise things like layer height, the infill density and pattern, enabling supports, etc. Once we have the sliced file, we just need to get it onto the printer (usually with a USB or SD card), and press print.

Note: If you are accessing a 3d printer through an institution like a FabLab or maker space, always check their policy for this process. They may require you to use a specific slicing software and settings, or may even do the slicing for you.

One of the most common times to damage a printer is when removing a print. To avoid this, always ensure that the printer is fully cooled down and that you never scratch the print bed with a sharp object.

If you are on the hunt for a 3D printer of your own, take a look at the Ender 3. It's a great budget printer that has become the poster child for entry-level printers.

This video is a cut-down and summarised version of this 1-hour 3D printing course that Jaryd made previously. So if you want to dive a little bit more into the 3d printing process, slicer settings, and CAD design for 3d printing, check it out because we go into a lot more technical depth and we cover topics that we were too constrained on time to do here.

Laser cutting is another tool that has found its way into the maker community due to its ability to cut larger objects extremely quickly. Laser cutters are simple, a powerful laser head is moved around by motors and rails (called a gantry) and is used to melt and blast away a very thin line of material from a large flat piece of material (and we can also turn it down a little to make an engraving). Although this limits us to creating 2D and flat pieces, it is extremely accurate, speedy, and can cut things like acrylic, and wood. Commonly laser-cut parts in a project include clear acrylic lids and windows, boxes using joinery methods, and snap-together wooden models.

To laser cut we will need something called a vector file, common formats include svg dxf and even pdf. We can generate these directly with a vector graphics software like Adobe Illustrator or Inkscape (which is free and open-source), or you can sketch in a CAD software like Onshape or Fusion 360, and export it as one of these file formats.

Once you have your vector file you will need to get it cut, but this process is most likely to differ from cutter to cutter, so always check what software and workflow your cutter uses. In this video, we outlined the process our Trotec uses, which requires a bit of manipulation in Illustrator. Even if you generate the vector in CAD, you still may have to use a software like Illustrator or Inkscape to get the file ready for printing (e.g. for our situation cuts will be made along red coloured lines, and black lines will be engravings). In this process, you will also need to select a cutting profile that determines the power and speeds of the laser, and it must be set according to the material and thickness - chances are your software will have some presets of these.

Eye safety is an important factor to keep in mind with laser cutting, an 80-watt laser can instantly vapourise wood, and your eyes are even less of a challenge, so always be vigilant with eye safety. Your laser cutter may be enclosed with a protective covering, if not always ensure you wear appropriate laser safety eyewear.

Check out FabLab's/Makerspaces near you to gain access to a laser cutter and have a chat with the coordinator to find out what materials you can use and how to operate it. Make sure to take notes on safety, and the file format thats being used, specifically the colour and line style if they are used.

We recommend Onshape or Inkscape to make and modify your 2D files.

If you're keen on making some of the examples from the video:

• Electronics base plate | Acrylic PiicoDev Platforms
• Slim Case for Raspberry Pi 3A+
• 3D printed x Acrylic case | LoRaWAN Weather station
• Smart City Tunnel with PiicoDev
• Stencil tool (download SVG)

And check out Liam's and Jaryd's project pages for this week:

• Liam - 3D blocks| Computer-controlled cutting
• Jaryd - Molecule diorama | Computer-controlled cutting

Computer numerically controlled (CNC) machining is a less common, but extremely handy manufacturing method that allows you to produce things that a 3D printer or laser cutter can only dream of. While 3D printers are limited to what they can melt and extrude out of a nozzle (typically plastics) and laser cutters are restricted to what they can melt (nothing too thick, nor metals), a CNC machine can blast through thick woods, plastics, and even soft metals like aluminium thanks to its high powered milling bit. CNC machines also tend to come in larger formats, the one in our local Fablab has a build volume of 1.5m x 1.5m, but we've seen some that are as big as 3 meters! This means that you can cut large pieces, and these machines can also do so relatively quickly.

So CNC machines can cut large thick material quickly, what are the downsides? Well first of all they are harder to come by. While nearly every maker space and home workshop nowadays has a 3D printer, you will find CNC machines much less frequently. A good bet though would be a Fablab, and quite a few maker spaces will still have them.

The other downside is that they are a little more difficult to use than 3D printers and laser cutters. While they all share a common workflow, CNC machines are more difficult to use in that they are more involved in the CAM process (the slicing process for CNC's where we turn CAD models into machine code). Its not harder, there is just more micromanaging involved with having to specify the cuts that are required to make your parts. But if you are accessing your machine through a Fablab or maker space, you will find support in doing this process.

Don't have an industrial CNC machine lying around in your shed? Check out this FabLab map to find one near you, and see if they have a CNC machine.

If you want to brush up your knowledge of CNC machining a bit more, UNSW has a great written guide that has some great information on how CNC machines work, different types of milling bits, and some more practical advice on things like clamping down your stock.

Microcontrollers (MC) like the Pico are small, cheap and low-power computers that we can program to control all the electrical components of our projects - motors, servos, sensors, lights, buttons screens. They have pins that allow us to connect these components to the MC board, and all of these devices deal in voltages. When you press a button it supplies a voltage to the MC. An MC can supply a voltage to a light or motor to turn it on. Sensors? Most of the time they are just reporting back a voltage. So a microcontroller is just a little computer that can read and output voltages to interact with these devices, but we need to tell it how to do this with code.

Microcontrollers don't typically have a mouse, keyboard, or computer monitor that we can use to interact with them. Instead, we must write the code on another computer (like your desktop or laptop), and upload the code to the microcontroller which the microcontroller will then read and carry out those instructions. But microcontrollers don't speak the human languages that you and I use, instead we must use a programming language like MicroPython that is designed for these boards.

And learning to code nowadays is easier than ever with a wealth of educational resources available and large language models like ChatGPT and Gemini which can write basic code for microcontrollers. Want to learn everything you need to know about the Pico microcontroller and Micropython? Check out our comprehensive Course.

I know we have said it before, but if you are looking to learn microcontrollers and coding, check out our Pico Workshop Course. It is a course designed to take an absolute beginner and teach them enough about microcontrollers, electronics and MicroPython so that they can go out and start making some cool projects. By the end of the course, you will know how to use GPS on a microcontroller to locate it anywhere in the world, connect it to the internet and pull live data from the web, as well as plug in and use a wide range of components and everything in between.

We designed this course to be the one-stop destination for learning the Pico microcontroller so check it out!

An input device is anything that can send a signal to our microcontroller, and in the context of makers, we also use the term sensor interchangeably. A sensor is an input device that takes a real-world measurement, whether that be temperature, distance, or windspeed, and turns it into an electrical voltage. A microcontroller can then read this electrical voltage and collect information on this measurement that we can then use in our code. 

There is a vast ocean of sensors that we can use in projects, so many that you could scroll for hours on our sensors page, and choosing the right sensor for the right job is sometimes a little bit tricky. But there are a few principles that you can keep in mind to help:

• How can we measure it: Often there is a sensor specifically designed to measure what you are looking to measure. For example, if you are looking to measure temperature, you can find a temperature sensor. But if you were trying to measure the level in a water tank, you would need to get creative as it would be hard to find a sensor to directly measure that. E.g. maybe a weight sensor, under the tank would do the trick.
• Price vs performance: You can find industrial temperature sensors that can measure to an accuracy of 1/100 of a degree. Although it would be really cool to have one in your project, the several thousand dollar price tag would not be justifiable. A good rule of thumb is to choose the least accurate sensor your project can use as it might save a little bit of money.
• Documentation: You can find many sensors to do the same job, and something that should be taken into consideration is documentation. Documentation is just any information supplied with the sensor to get you going, things like example code, wiring diagrams, data sheets, all the important things to prevent you from guessing how to use your sensor.
• Logic level: This one is really easy. Your microcontroller will read data on its pins at a specific voltage. This is known as a logic level, and the sensor you buy should match it. For example, the pico, has a 3.3-volt logic level, so a 5-volt logic sensor won't work, we need to ensure that the sensor supports 3.3-volt logic. This is not the power that the sensor requires, but the voltage level of the signal it takes.

We have a goodie bag of resources for you this week for all of your input needs.

• If you are looking for a sensor, we have a long list of sensors to measure nearly anything you can think of.
• We also have a variety of guides on sensors.
• And if you are using a Pico, you can find many sensor guides on our Pico page.
• If you want to check out the temperature / atmospheric sensor, we have a guide on it.
• And if you want to get a camera on a microcontroller (which really pushes microcontrollers to their limits), check out how we developed the libraries.

If our project can sense the world around it, and process that data on a microcontroller, the next step is to then use that information to do something - this is where an output device comes in. An output device is anything that can receive a signal from our microcontroller, and then act upon or change something in its environment. Motors, speakers, and lights are all examples of outputs. 

Exactly like inputs, a microcontroller interacts with outputs by setting voltages. The added difficulty of using outputs is that they often need many times more power to operate than the GPIO pins of a microcontroller can output. Connecting a large motor straight to a GPIO pin will not result in any movement, but will most likely result in a damaged microcontroller. To avoid this, we will often need to use something called a driver board, which sources power from an external source like a LiPo battery, but still allows us to control the device with the signal from a microcontroller.

Another important concept when dealing with output devices is current and Voltage, and ensuring that your device gets the right amount of power. The general rule of thumb is to ensure that you match the voltage it requires and supply MORE, current than required. For example, this OLED display needs 3.3 Volts and 30 milliamps of current.  A 1.5 Volt or 5 Volt power supply may cause damage to this module, so we must ensure that it provides 3.3 volts. And this device will try to draw 30 milliamps when we plug it in, so we must ensure that our 3.3 Volt power source can supply this much current. If it can't supply this much, we may damage the power source.

We have 2 really important resources for this week. The first is our actuators guide where we cover the 5 most common actuators that you'll encounter as a maker and everything you need to know to know which one is best for a given application.

The other is a practical guide where we demonstrate how we can source power from a microcontroller and take a deeper look at ensuring that we supply the correct voltage and current to our output devices.

And of course, that guide is a part of our Pico workshop, which is a course designed to take an absolute beginner and teach them enough about electronics, coding and the Pico, so they can go out and start making some cool things.

Microcontrollers, inputs, and outputs - all of our electronics, but how do we wire them together in a considered way? Common methods are breadboards, protoboards, and printed circuit boards (PCBs). Each of these comes with their own pros and cons:

Breadboards:

• Fast and easy to make, great for prototyping and verifying that your designs work. Parts are non-permanent, reusable, and easy to change around / rewire with jumper wires or solid-core wire. Always a great test before prototyping/ making a PCB of your circuit.
• Connections aren't mechanically strong - they can easily fall out, especially in projects that may shake and move around.
• Can't handle high-current or high-speed/high-frequency signals.

Protoboards: 

• More permanent assembly method - components are soldered to the board, and are often troublesome to remove once soldered on.
• Requires soldering skills, and soldering gear - iron, safety glasses, fume extractor, etc.
• Protoboard is cheap and comes in many layouts.

PCBs: 

• Highly professional, wires are run inside the board, everything can be custom designed, choices in colours, connectors, holes to be drilled - complete freedom.
• Requires PCB design software skills and soldering skills.
• Manufactured in a house, have to deal with shipping times, but once a design is made, it's as easy to order 100 as it is to order 5 - easy to scale to large numbers of the same board.
• Fixing Mistakes can be difficult and often requires re-printing a board.

Breadboards aren't the most intuitive tool, the breadboard and circuit section of our Pico workshop has some additional tips and tricks on breadboarding.

A pre-requisite for protoboard-ing is soldering - a key maker skill that lets you join electronics together, our guide walks through what you need to start, and how to make excellent connections.

We talk through some of these topics in The Factory - a series exploring more technical aspects of a project. This video even talks about designing a protoboard!

There are 3 main steps when making a PCB, each with their relevant checks to make sure we don't make any mistakes before getting them manufactured.

1. Schematic Design - Here we lay out all of the components we want to use and connect the different pins, at this stage everything in our design is symbolic.

Before moving to the next step we should check out the connections with the 'Highlight Nets' tool and perform our 'Electrical Rules Check' or 'ERC'

2. Footprints - This is where we add dimensions and shapes to each of our components. If you do not have the part in front of you, be sure to check the datasheets for detailed drawings

We should double-check the dimensions of each footprint before moving on

3. Board Layout - We combine the connections from our schematic, and the dimensions of each component to make our final PCB. We add traces to connect components, pours to connect lots of things at once, and artwork and text to our silkscreen layer to make the PCB look nice.

We can run the 'Design Rules Check' to make sure we haven't overlooked anything like putting a part underneath another.

Finally, we generate the manufacturing files, for PCBs these are called 'Gerbers' - be sure to export the drill files as well. 

And now we can order them, solder our components on and implement our super clean electrical design into our project!

Making PCB's at home would be a lot harder without the open source PCB design software - KiCAD. We use it here at Core Electronics for all of our open source designs!

If you're looking for a more in-depth tutorial on designing your own PCB's from scratch we recommend the official KiCAD Getting Started or if you like these videos by Michael through NU Teams.

And for more technical content, we have lots of discussions around PCB's on The Factory.

There are 2 ways to avoid making bad mechanical design choices. 1 you create a mathematical model and run computer simulations to determine what the most optimal choice is, or 2 you make a design choice, realise it's a bad choice, and learn not to do it in the future. For us makers, that latter option is the usual path and in this chapter, we try and speed up the process by going over the design choices we have made in our projects.

There is an incredible amount of lessons to cover and we could do an entire series on just mechanical design choices. Instead, we thought it would be better to create a list of questions that might help you avoid making some mistakes that makers often fall into:

• Is the material you are using easy to work with (cut, bend, weld etc.)
• Will your part be exposed to sunlight? If so is it UV-resistant?
• Does your project have moving parts? Do you need bearings or will just some lubricant work?
• Is your project easy to clean and maintain?
• How waterproof does this project need to be? Is it worth at least making it spill-resistant in the event of an accident?
• Are your materials suitable for the project's operating temperatures? PLA softens at only 55 degrees, a hot car can get up to 70 degrees in the summer!
• Is your material too heavy? Will swapping it out for something lighter be of benefit to the project?
• How are you fastening parts together? Bolts? Zip ties? Velcro? Magnets? Zips? Clips?
• If you are using bolts, can you embed a nut into your project? Or is it worth using heat-set threaded inserts?

We have mentioned it before, but our actuators guide has some great and relevant information on torque, speed, and gearings, as well as some very light physics aimed at makers.

Looking for some inspiration? Take a browse through some community projects we've seen where you'll encounter a wide range of different chassis, frames and enclosures, all suited to different operating environments and needs.

If you use 3d printed parts and want the run-down on how to make them more mechanically strong, check out these 3 short videos that cover most of what you'll need to know as a maker:

• Print orientation and the Achilles heel.
• Shell thickness and torsion/bending forces.
• Infill and compression forces.

Moulding and Casting is a great addition to your maker toolbox as it is another manufacturing process that allows a great deal of creative freedom. The process is extremely straightforward and is hard to explain verbally, but we will attempt to do so in reverse. Your final part is cast from a mould - this part could be made by casting plaster of Paris or pottery plaster, but the most common is to cast a resin into the mould. But you need a mould to cast into (most of the time silicon), and while you can find many moulds online, we makers tend to need our own custom moulds. To do so we will need a primary mould (which can be a milled wax block or a 3d printed) and we will use this to cast the resin mould into. So primary mould > silicon mould > final part.

For the overwhelming majority of the parts in your project, 3d printing or laser cutting may be a far more appropriate manufacturing method. But there are some upsides to this process that are difficult to get with others:

• Resin can be clear and you can produce clear parts with complex geometries.
• With good technique, the same mould will make identical parts with no print defects.
• You can make lots of parts quickly (although it is more labour-intensive than 3d printing)
• Your parts can be intricately detailed (if your silicon mould is detailed)
• You can cast other things inside the resin (e.g. embedding electronics in a part)
• You can mix and cast weird materials - glow-in-the-dark pigment, carbon fibre for strength, ceramics for extreme heat resistance, and UV fluorescent dyes.

So while not every project you make will use casted parts, there are times when you may be able to get creative with the process to produce things that otherwise wouldn't be possible.

If you are also a dice nerd like us, check out this fantastic 2 part video by Robert Tolone. It covers a lot of the process and some great tips to get started.

Getting multiple boards to communicate and work together is an incredible tool to have as a maker as it gives you greater design freedom in your projects. Need a really powerful board to process some object recognition with a camera? Use a Raspberry Pi SBC. But what if you needed to control a series of motors with it? The Pi 5 isn't a good candidate for this and finding a board to do both of these may be a challenge. An easy solution would be to connect a Pico to it and get them to work together as one unit.

There are many ways that we can do this. The most common wired ways are through I2C, SPI, UART and CANBUS, but if we had to recommend one, UART is the clear winner due to its simplicity and ease of use. But CANBUS is another candidate for more complex projects that have a lot of boards needing to be connected.

We also have the option to add hardware to connect boards. We could add Bluetooth modules which are not great but easier to use, LoRa modules which allow us to send small amounts of 10's of kilometres without much power, or even radio transceiver modules.

But most modern microcontrollers now come with wireless capabilities inbuilt into them, which we can use to get boards to communicate with each other without any additional hardware. We could connect boards to a Wi-Fi Network and serve a webpage to facilitate interactions (although this isn't a wise option), or we could connect them using MQTT which is a maker favourite. If you happen to be using an ESP32, you can use ESP-NOW which is a brilliant protocol that uses the Wi-Fi chip to directly communicate with other boards.

This list is far from comprehensive and are just some of the maker favourites we see - no single option will be suitable for every project and it's a situation of "which fits best for me". Regardless of what you choose, we have some links in the resources section to get you started.

If you are looking at getting started with:

• UART, we have a great tutorial on how to use it in micropython from another workshop.
• I2C or SPI, we also have some other videos as a part of that series, but they are specific to sensors.
• CANBus, here is a great video series on the theory and operations of it
• Bluetooth: Here is one of our Arduino-based guides, but there is still valuable information to get started.
• PiicoDev Transceiver, we have a step-by-step guide on getting it going in a MicroPython Environment.
• LoRa, we have a guide on connecting your device to LoRaWan, but also check out Meshtastic, it's a fantastic community project.
• 4G / Mobile Data HAT, we have another great step-by-step guide.
• Web Pages, we have a guide from that workshop again where we code a Pico to host a web page from scratch.
• MQTT, there are plenty of guides for all devices, but we have a beginner's guide for the Pico.
• ESP-NOW, DonskyTech has a great little series on getting it going in MicroPython

System integration is one of the final stages of a project and is when you put everything together. Although these parts might have worked fine individually, they may not smoothly integrate and unseen problems may arise. This can be the longest part of the project, it can be the shortest part, it can be the most annoying, or the least annoying depending on how well you manage it. It is a skill that comes with experience and is often hard to teach, but here are some lessons from our experiences that will help:

• Incremental integration is your friend - This is a process where you get a small module, chunk or part of your project working, and integrate it, bit by bit. By drip-feeding in the parts of your project it becomes easier to deal with any issues that arise.
• Time crunch is real - system integration is an extremely underestimated stage of the project and often has huge time sinks involved to fix niche issues.
• Double-check everything - The time you spend double-checking everything as you go will result in fewer issues that you have to discover later in system integration.
• Intermittent faults are the worst - An issue that is non-repeatable is often the hardest to find, let alone fix. Lots of testing and testing in isolation or separation can help remedy this.
• More problems will arise - Always prepare for more problems to arise in system integration. Sometimes the problems that arise in system integration will result in the need for a redesign, or lead you down paths that become difficult to solve.
• Make debugging easy - Make it as easy as possible to debug your project. Print statements in your code make it easy to see what your project is "thinking". If your project is away from a computer, the onboard LED is a low-cost debugging solution, or an OLED screen can be a lifesaver.

We don't have resources for this week, check back in next weeks!

This one might be a bit of a curveball in a course like this, but trust us, it is a skill that is deservedly alongside 3D printing, coding and soldering. There are just parts and situations that you will encounter in a project where a sewn part will be the easiest and best option, and unless you have sewing and textiles as a skill in your maker toolbox, you will struggle to find this option.

Some examples of times you might use sewing is when you need sleeves or protective wraps in your project, or a great example is the robot socks from the video. But like moulding and casting, this is also a medium with great creative potential. You can use fire and heat-resistant materials, and strengthen your robot against punctures and piercings with Kevlar, our fab academy supervisor Claire used conductive fabric to sense when a plush is being touched. There is a largely unexplored world of textiles in maker projects out there right now.

And we can get even more creative and combine it with other processes. Fabric can be laser cut, this not only allows us to cut complex patterns with ease, but it also seals the edge in the process - helping to stop the edges from fraying. You can even 3D print onto textiles to create unique compounds and parts!

We have 2 big resources this week. The first is this FAQ page on the sewing subreddit which has a rabbit hole of links for anyone looking to get started.

The other is the quintessential start video from Uncle Jessie about printing on fabrics. This is the internet's seminal source of anything relating to 3d printing on textiles.

If you want to see our experiments with a different method of printing on fabrics, you can see our Fab Academy page here, and if you are REALLY keen, we also have our page on making robot socks.

So you've made an awesome project by spending a great deal of time and effort on it, and you want to get it out there into the world for others to see and learn from it, well there is an important step you should do before putting out there - licensing it. Attaching a license to your project is an incredibly important task as it both protects your work and also people using it. Simply put, a license states how the public may use your work: can they use it for commercial purposes? Can they alter it? If they build upon your work, do they have to make it free again? All of these questions are answered by a license.

Now thankfully you don't need to be a lawyer to give a license to your project and there are many existing legal frameworks that you can use. Some common ones to name are; the MIT license, Creative Commons, and the GNU license. The process is simple, find one you like, and copy and paste it to your project - it's usually that easy. If you go for a scroll through GitHub or Thingiverse, chances are you will find the licenses that people are distributing their creations with and they will be a copy-paste of these most popular ones.

While these are great and easy for us makers to use, if you do end up commercialising a project, it may be worth consulting with a professional lawyer about licensing.

Check out some of the following licenses:

• MIT 
• Creative Commons
• GNU

Don't know which one to pick? Here is a great site for choosing an open license. Or if you know you want a Creative Commons license, they have created their own quiz

The majority of projects you will make will include human interaction in one way or another. Whether it's a simple button or dial to control an aspect of your robot, or a display or buzzer to receive information from your project, there are a lot of reasons you may need a human to be involved. 

To break it down you will either your project to take information from a human to control it, send information from a project to a human, or both. When you break it down and abstract it like this, there are a wealth of different ways we can do this, which is what we will explore in this video.

Wanna get started with?

• Buttons with Pull-Down Resistors
• Interrupts and Debounce
• Capacitive Touch Button
• Potentiometers
• Rotary Encoders
• Joysticks
• Force Sensitive Resistors
• Load Cells
• IMUs
• Gesture control
• EMG Sensors
• EEG Sensors
• Voice Recognition
• Machine Learning
• Speakers
• RGB LEDs
• OLED Displays
• E-Ink Displays
• Touch screens