ABOUT
/ Concept. 1. Creating the Milling Files using FabModules. 2. Roland MDX-40 Setup. 3. Engraving of the FABISP. 4. Cutout of the FABISP. 5. Soldering SMD Components. 6. Giving Life to FABISP. 7. Desoldering the Bridge. // Aftermath. /// Download Files.

Electronics Production.

Concept

For this assignment, the goal was to reproduce a Printed Circuit Board (PCB), or in this case the FABISP board offered by one of the graduate Fab Academy Students Andy Bordagjy, using an ATTINY44 Microcontroller as well as give it logic by deploying a written code to it.

Reproducing a board involves a couple of critical steps, such as: creating a circuit layout file, milling out the board, cutout of the board as well as soldering the necessary components onto the board.

Since my experience involves creating a PCB board using the chemical-etching process, this was something new to get my mind and hands on.

Creating the Milling Files using FabModules.

Using the Monochrome .png files provided from the FABISP website, it is possible to create the necessary milling traces for the CNC machine. Since it is a one layer sided board, we will need one image for the traces.

And one for the cutout of the board.

As we navigate to the Fab Modules website, we load our PNG image. Since in our lab we benefit from having a Roland Mill MDX-40, this exact device will be chosen for the extension of the format that will be produced. Any other extension can be used accordingly. Since we are creating first the traces, the PCB traces (1/64) process is used.

Important settings to consider:

  • speed (mm/s): 4 (this value can be experimented with and depends on the machine accuracy)
  • x0 mm: 0 (states the starting origin point for X vector)
  • y0 mm: 0 (states the starting origin point for Y vector)
  • z0 mm: 0 (states the starting origin point for Z vector)
  • zjog mm: 2 (specifies how high will the machine displace in Z vector, while traveling to a different location)
  • cut depth mm: 0 (0 is used since Z depth is taken from the machine)
  • tool diameter mm: 0.2mm (depends on the milling tool used)
  • number of offsets mm: -1 (this value is used if we want to fill the entire board, we use that to avoid any shorts on the USB level)
    •

    We can notice that the blue lines represent the milling paths, while the red lines the jogs/travels. The .rml file is then saved.

    We repeat the process for the outline of the board. This time the PCB Outline 1/32 process is used. Setup settings remain to be the one generated by the website.

    As a result we have obtained two .rml files that will be used with our CNC machine.

    Roland MDX-40 Setup.

    The CNC machine has an enclosure that protects the outer environment. Once the View button is pressed, the milling area is moved forward toward the enclosure. Fixing the board to the milling area needs to be done firmly, so that the copper plate is not moved during the process.

    For the milling job, 0.2 mm tool will be loaded and for the cutout job, 1.0 mm.

    Using the software that accompanies the CNC machine, we can now specify the X,Y,Z origin points by pressing the red, green and blue arrows accordingly. The most crytical is the Z axis and needs to be done in such a way that the milling tool justscratches the surfaceof the board.

    Once the origin point is set, we can load the files by pressing the Cut.. button and load our first file.

    Engraving of the FABISP.

    During the first attempt to mill the board, the depth was not well stated. As a result parts of the copper sheet remained unmilled. This can noticed in the next picture, where the second job was not finished.

    Going some hundreds of milimeters deeper, or 0.003 mm fixed the job.

    Cutout of the FABISP.

    Followed the cutout process, which finalized the milling process.

    The board is ready for soldering.

    Soldering SMD Components.

    In order to understand which components are necessary for the soldering, it is helpful to consult the schematic provided by the creator.

    Necessary components are:

  • 1 ATTiny 44 microcontroller
  • 1 Capacitor 1uF
  • 0.1 Capacitor 1uF
  • 2 Capacitor 10 pF
  • 2 Resistor 100 ohm
  • 1 Resistor 499 ohm
  • 1 Resistor 1K ohm
  • 1 Resistor 10K
  • 1 6 pin header
  • 1 Cystal 20MHz
    •

    For the next process we will need a soldering iron, soldering material, soldering station, a multimeter and previusly mentioned SMD components.

    For start we will solder our microcontroller in order to get all pins connected firmly. We start by setting our soldering tool to the necessary temperature, usually above 300 degrees to increase the efficiency and speed. We add some soldering material on one of the pad, usually the corner one.

    We will go ahead and solder that pad to the designated pin of the microcontroller to enable a mechanical hold and position the processor. After which we continue by soldering each pin of the microcontroller.

    *Important to notice that in this image one column of pins were skipped by accident and another board was created to accomplish the results.

    Rest of components are soldered accordingly.

    Now we can test using the multimeter if each of the path has electrical connection with the pin of the ATTINY44. If the value shifts from 1 in the test mode, this means the connection is established or a short exists. Otherwise the soldering was done poorly and needs to be redone or some path need to be separated.

    Giving Life to FABISP.

    In this step, we will use an Arduino Uno to enable the FabIsp as a programmer. First using the Arduino IDE we will load the ArduinoISP example found under Examples > 11.ArduinoISP. Once loaded we upload this code onto our Arduino Uno board so that it works as a programmer.

    Since we will be communicating using the SPI (serial peripheral bus), it's important to notice the pins of FabISP, provided in the schematic, in order to connect the board correctly to the Arduino Uno.

    As well as the pinage of the Arduino Uno.

    The FabISP board is connected to both the computer which will be used to write the firmware and to the Arduino Uno using the SPI.

    In order to write the firmware on to the FabISP, a Linux virtual machine is used. Once the Arduino Uno board is recognized by the virtual machine, we following the Linux OS instructions documented here.

    First we make sure to install the necessary packages. We type each line one by one, by making sure to acknowledge the installation using the "y" key. Terminal lines for installing the packages:

    sudo apt-get install flex byacc bison gcc libusb-dev avrdude
    sudo apt-get install gcc-avr 
    sudo apt-get install avr-libc  
    sudo apt-get install libc6-dev

    We change the path to a place where we can download the firmware. For instance the media directory:

    cd /media

    Download and unzip the firmware files:

    wget http://academy.cba.mit.edu/classes/embedded_programming/firmware.zip
    unzip firmware.zip

    Once the firmware is unzipped, we navigate inside the firmware folder and open the Makefile using any text editor:

    cd /fabISP_mac.0.8.2_firmware
    nano Makefile

    Crytical is to make some adjustments to the firmware file. The line:

    AVRDUDE = avrdude -c avrisp2 -P usb -p $(DEVICE)

    is exchanged to

    AVRDUDE = avrdude -c stk500v1 -P /dev/ttyACM0 -b19200 -p $(DEVICE)

    We save and exit the editor. What follows is a set of commands which will write the firmware onto our new board. These commands need to be executed one afte another. In case the execution results in anything else than the results provided here, make sure to double check the connections, physical and software.

    make clean
    make hex
    make fuse
    make program

    As a result, we get a "done. Thank you." message.

    Finally we verify whether the board has been successfully programmed, simply running a check of plugged devices using:

    ls usb
    Desoldering the Bridge.

    To make the board fully function, one last step is required. That is to desolder the bridge located closest to the microcontroller.

    Aftermath

    Creating an open-source board takes quite some time, effort and tinkering, however this allows repolicating boards and adopting new circuits in no time. In this session we recreated a board as well as program it using the Arduino IDE. Important is, after each step accomplished, to verify whether parts of the system are working well. Once all parts are working well, the whole assembly will function properly.

    As a result, our FabISP will serve to program other future boards simply by using the SPI.

    Download Files:
  • FabISP Roland Layout File
  • FabISP Roland Cutout File