The device will be comprised of a laser, an enclosure with controls, and a Raspberry Pi retrofitted onto an old 3D printer. Stepper motors will control the position of the laser along the toast, and the power of the laser will be modulated at each point to create different toasting patterns. Software will be developed to combine photos, Web-scraped text, and more into a grayscale image to be burned on the toast, and it will then generate G-code for printing. This project will aim to recreate the toaster experience using an Arduino to control the knobs, dings, and doors that we’ve all grown to love.

The GUI is the central hub of the software, connecting all of the pieces together. It runs in the Processing Development Environment, and monitors the touchscreen for button presses and acts accordingly. Each button is hardcoded because we didn't want to waste time making something fancy - we just need something that works. The GUI was laid out in Microsoft PowerPoint, then the layout was transferred over to Processing by determining all of the button sizes and locations. Screenshots of the GUI (running on a separate computer) are below:

The GUI forces the user to follow the steps on the flowchart above, first prompting the user to either choose to toast from image or data, then prompting the user to select the specific pattern to toast. The user can either take an image using the Raspberry Pi camera, or use an existing file by navigating through the file browser. The toast from data option grabs the latest tweets from Twitter based on the selection, and formats the text as an image. The user then opts to immediately send the image to the toaster for processing and toasting, or to wait until the specified time.

Each button press runs a bunch of scripts. We're using the launch() function in Processing, and launching .desktop files that run bash scripts that either run terminal functions or Python scripts. It's a really roundabout way of doing things, but it's the way we've been able to make Processing work for us. Variables for other scripts (like the image path, scheduled time, or status of the emergency stop button) are stored in dedicated text files. We chose to use Processing for the GUI environment because we want to integrate Arduino StandardFirmata and also want to make an attractive layout for the touchscreen.

Once a user is ready to make his toast, he initiates a printing sequence by selecting the "Toast Now" button on the GUI. This actuates a series of steps that lead to printing, all executed in Python:

1. Image Processing:

• Image resized to 128 x 128 pixels, which are the dimensions of the print (these numbers could change based on testing)
• Image recolored to grayscale with lighter colors corresponding to darker pixels
  • This is so that lighter images will be more toasted
  • RGB values are converted to grayscale using a weighted average formula: I = .299[R] + .587[G] + .114[B]
• Grayscale values are scaled to a power level 0-255, corresponding to the PWM range of the RAMBo Fan MOSFET output
  • Scaling is also based on the user's deisred toast power level (provided through the potentionmeter knob and Arduino)

2. Automatic G-Code Generation:

• Based on the printer's print-area coordinates, the code generates a path for the laser head that covers each pixel in the image
• At each pixel, the laser intensity changes corresponding to the intensity at that pixel
• At the end of the print, the platform returns the toast to the user.
• The G-Code is generated and saved as a .gcode file

3. Communicating with the Printer:

• We use Printcore, a software developed by Printrun (same group that makes Pronterface, Pronsole), to communicate with our RAMBo board.
  • Printcore is developed in Python and includes a module of commands that allow a user to interact with a printer
• Connect with the printer through Serial Port, send over the G Code, and initiate print.
• For safety, we also added the capability for a user to cancel the print mid-print, using the red "X" button in the GUI

The modified 3D printer hardware was modelled in SolidWorks, and the enclosure was created around it. The enclosure is made of plywood, which is fine for now because the laser isn't powerful enough to burn through it. It was made in the OEDK woodshop, and the display panel was ironically cut using a lasercutter. For the interface with the user, we're using a Raspberry Pi touchscreen display and a couple buttons and knobs for tactile control. A sliding door will shield the user from the laser during operation.

On the electrical side, we'll be using three boards for this project: a Raspberry Pi, a RAMBo motherboard, and an Arduino Uno. We had a bunch of problems hooking up the laser to the RAMBo; the idea was to control the intensity using the 12V PWM slot for cooling fans, but the fuses on the board kept burning out when our 5V lasers were connnected. We made a linear voltage regulator circuit to control the input voltage to the laser diode, and it seems to be more stable now. Both the Arduino and the RAMBo communicate with the Raspberry Pi using a serial connection. The Pi connects directly to the touchscreen and uses that as the only display. Ideally, the keyboard and mouse will be unnecessary to run the printer.

• Sensors:

  • Check if bread is on the plate
  • Check door status (open/closed)
  • Check power level dial
  • Button for start
  • Laser temperature

• Actuators:

  • Emergency stop button
  • Eject button (might be fun to have this under a plastic shield)
  • Must include spring actuation and self-deployed toast parachute
  • Move platform
  • Open/close door
  • Ring bell when complete
  • Laser ventilation
  • Alarm clock function that wakes you up to fresh toast

• If we have time (we won’t have time):

  • Toast flipper
  • Camera on toast (timelapse?) (Twitter?)
  • Butter melter and liquid butter spreader
  • Photo booth

Health. The most threatening safety concern is health - pointing a laser at a person for too long could cause blindness or burns. The easiest countermeasure is to buy the lowest-powered laser that will still accomplish our goal. We're ready to do some testing on Thursday using the OEDK laser cutter to see what powers we realistically need for etching the toast, but online research has shown that we won't need more than 1-2 W. For testing, we'll want to modulate that power down to the mW range (typical laser pointers are 5-10 mW) so we can see what we're doing but aren't creating any threat. The final device will have a door that seals the inside off from the outside, so there can be no leakage of light. We can make this door into a physical switch, so the laser can't receive power unless this door is closed. For testing, we'll also have to get some laser safety glasses, which depend on the wavelength of light produced by the laser.

Fire. Another big one, also mostly solved by choosing the right laser. We want to do some testing on the laser that we eventually choose, but if need be, we can solder on a heatsink and provide forced convection with a fan. I don't expect there to be too much smoke produced, since normal toasters don't produce an unreasonable amount of smoke and we plan to only etch the surface of the toast. We want to make the enclosure out of think aluminum or 1/4" wood - the laser shouldn't be high-powered enough to penetrate or ignite either of these.

Electrical. Good insulation practices should resolve any concerns.