FabLab – Page 2 – SheekGeek

Cheap Color Lacquer Soldermask for DIY PCBs

October 20, 2023January 11, 2021 by Adam@SheekGeek

In the past, My milled PCBs corroded quickly. I began coating them with nail polish. I liked this method because I could be precise and not paint the soldered components in case I had to fix or hack the boards later. Spray on conformal coating is what Neil from FabAcademy recommended and he’s right that Nail Polish isn’t designed for circuits. But the overall results are fine, colors are abundant, and it’s like $1 a bottle rather than $20 a can of conformal coating.

While I see lots of folks online using UV curable liquid soldermask, or dry soldermask film, however the liquid is made of some pretty interesting chemicals. I also don’t want to figure out a way to UV cure the dry film such that I can get the pads uncovered on the PCB.

I found one guy who came up with a technique that was quick, easy, and cheap. Colored lacquer is cheap and readily available at hobby stores for less than $10. It also protects the traces from corrosion and comes in a variety of colors. With a quick spray (like conformal coating) I can paint the entire PCB. The benefit here is the second step. Instead of trying to figure out how to UV cure a dry film and then remove material from the pads, I simply throw the design into the old CO2 laser and burn off the lacquer on the pad areas. To get the files for this I went into EagleCAD’s layers and used the old technique of exporting bitmaps of the dimension+top and separately the dimensions + modified tStop. (This is my AtTiny412 General purpose Blinky board if you are curious. Detailed info about building and using it here).

I changed the fill style to solid by clicking on the tStop layer, then the Change button.

Along with the Top+Dimensions layers the design is complete.

You can tweak the colors in good old Gimp Like we “used-t’do” and throw it on the laser. At this point I handed the files over to Tom Dubick of Charlotte Latin School FabLab fame and he cut out a jig to hold the PCB in place and etched the layer of lacquer away.

I found the Lacquer quite soft and for smaller boards it might be just as quick to scrape it off the pad areas with a razor knife. Scraping actually was a more complete methods of removal as well. In the future maybe a milling step would work for this.

The lacquer will still melt when enough head is applied with the soldering iron (and you do NOT want to breathe that in…) but it does somewhat act like a solder resist when dealing with the tiny pins on the boards we make in the FabLab.

I think the better idea is to slap some kapton tape on the PCB, then laser it off. Kapton seems to be commonly used with lasers even in industry and is made of essentially Carbon, Oxygen, Nitrogen, and Hydrogen (ignoring the adhesive) and according to this MSDS “At temperatures above 400 degrees C the major off-gasses are carbon dioxide and carbon monoxide”. It should be safe to do.

Setup and Introduction Project for FreeCAD

December 2, 2020December 2, 2020 by Adam@SheekGeek

I’m in the process of adding a second extruder to my 3D printer. I’d like to print a Saturn5 or V2 rocket in a single go with the dual extruders.

I ordered a masterspool set from SunLu with black and white filament. IF you haven;’t heard of MasterSpools, they are a great idea to allow you to be more environmentally friendly while 3d printing. Instead of each troll of filament having its own non-recyclable and heavy plastic spool, you have a spool that can come apart. Then when you buy filament, you just buy the filament itself, which saves on shipping costs and all the pollution associated with it.

I had to make my own masterspool since the filament set only came with one. I didn’t want to use a ton of filament to make it, and also wanted it to be strong so I used this center bolt design (hafner.stl) (though I might switch to this one as it has a little more grip on the ends). I tried reusing an old spool like in the examples in those links but the centers were too big for the filament so I made my own.

I downloaded FreeCAD to test out and drew the flanges for the spool to cut on the laser. Learning CAD and constraints is foreign to me and the cause of literally all my previous 3D CAD failures in the past. I made a video showing how to set up FreeCAD and make these spools to remind myself how to use FreeCAD later.

After laser cutting, the sides stank of burned wood, so I scrubbed the soot off the cut edges and soaked them for a little while in water with white vinegar as I’d read online helps. It didn’t work well.

I cut a few inches off the end of a tube used to store vinyl for the vinyl cutter as the spacer and it kept the two flanges the appropriate distance apart, but ended up slipping and making them misalign. This caused the spool not to be usable on either a sit-on-bearing style OR a center post style filament holder. I took to inkscape to make a quick SVG of some spacers to place inside the cardboard tube of the center of the spool. This hugged the center post and kept the cardboard centered correctly and now the spool works for both styles of filament holders.

You can download my files here if you’d like to make one yourself.

RGB565 to RGB888 Color Conversion

July 3, 2020June 28, 2020 by Adam@SheekGeek

While working with Charlotte Latin FabLab students this year, we came across an issue. Alex was using a camera module for her Arduino project (ArduCam) that gave RGB565 formatted pixel data but she needed to convert it to RGB888. Though there are tons of posts on stackExchange about how to do it, I couldn’t find a simplified broken-down explanation of how it works to point her to, so I decided to write one.

RGB565 means there are 5-bits of data for the Red component of the pixel, 6-bits for green and 5-bits for the blue. It looks like this:
pixel value =
RED= R4, R3, R2, R1, R0,
GREEN= G5, G4, G3, G2, G1, G0,
BLUE= B4, B3, B2, B1, B0

But Remember RGB565 is stored as two separate values (VL and VH from the example code for the camera we used), with the low value on the left and high value on the right.
VL = G2, G1, G0, B4, B3, B2, B1, B0 VH = R4, R3, R2, R1, R0, G5, G4, G3

Some clever bitmasking can strip out each component color and place them into individual variables. We’ll AND the bits of the values we want from VL and VH with ‘1’ or ‘0’ depending on which we want at a given time.

Of course this has to be done for each and every pixel, and she had 320 x 240 in her original image.

This is a simple nested for loop that already used in the example code to read the data from the camera

for (int i=0; i<240; i++){

  
   for (int j=0; j<320; j++){
  
    //Convert the RGB 565 to RGB 888 of the pixel in the bitmap and store it as PIXEL data type in the new larger array.

  
    //Step A convert to the new PIXELS format

  
    ///Step B scale from 565 to 888

  
    }//end for j

  
 }//end for i

STEP A: Convert the color to a new pixel format.

Based on some example code, it’s best to create a structure to contain the R, G and B values:

typedef struct { 
unsigned char blue; 
unsigned char green; 
unsigned char red; 
} PIXELS;

Then we need a large array to store the pixels of the new image:

PIXELS bigPIXELS [12] [12]; //the resulting RGB888 picture pixels are stored here

Then you can convert each pixel by using logic operations and bit shifting.

/*Blue is the easiest to see how this works so we'll do it first.
  
 The values for Blue is stored in VL So for example if VL = 1011  0101( blue = 21 in decimal) 
 to get the blue values all alone, we can AND them with 1s and AND the green bits with 0s 
 leaving you with an 8-bit number with only the blue data in the right spot. The result 
 is: 0001  0101  or 21 in decimal. 
*/
  bigPIXELS [i][j].blue =    ( VL & 0b00011111 ) ; //0x1F
 
 

/*Red is only slightly more complicated. We first get bits for red alone, then shift them 
 to the decimal point The 0b11111000 gives you only red data as before, but the digits 
 aren't in the right place. 
 
 There are place-holding 0s that make the value of red too big: 
 For example is VH = 1101  0110  The value of red is 26 in decimal here. ANDing as before
 would give you only 1101  0000, but if we convert this number to decimal, it =208, which 
 isn't right at all. Shifting to the right by 3 (>>3) moves the red value down to the 
 decimal point and gives you 0001  1010 = 26 in decimal in 8-bits
*/
  
bigPIXELS [i][j].red =   ((VH & 0b11111000) >> 3); //0xF8
 

/*Green is the most complicated as it has components in each VL and VH so we'll AND the 
 bits with 1s and then shift them to the right places, then we need to OR them to the correct spot
  
 VL = G2, G1, G0, B4, B3, B2, B1, B0  so to get only green values
 */ 

// since we don't use this variable for anything else, we can just dump the result of this operation back into VL
 VL&= 0b11100000 ;  // 0xE0  

 // VH = R4, R3, R2, R1, R0, G5, G4, G3  so to get only green values  
 VH &= 0b00000111; //0x07
  
 //Now shift the bits to the right places and OR them together to glue them into one number
bigPIXELS [i][j].green =  (uint8_t(VL) >> 5) | (VH << 3); //Shift lower 3 bits in VL to the decimal point, and shift the upper 3-bits in VH to their correct positions.

Great! Now we have our RGB values by themselves, now let’s let them stretch their arms to take up the full 8-bits that’s now available to them.

Step B: Converting from one colorspace to another is simply a function of scaling. You’ve already done this a lot actually. Any time you’ve read an analog input, then used that to control an analog output on arduino you’ve done it. Imagine a knob on the Arduino’s analog input. Analog inputs can read values from 0-1023 (10-bits) where 100% is = 1023. Imagine a single red pixel as an LED on an analog output. It can only take values between 0 and 255 (8-bits) where 255 is 100% brightness of the LED.

You can do the same thing here. In a 5-bit number system, 100% is when all bits are 1’s so it is 11111. This needs to be converted to an 8-bit system where 100% is = 1111 1111.

You use Arduino’s map() function to map the values from one scale(0-1023) to the other (the LED’s 0-255), however this is very inefficient and slow.

Since you know what the numbers are going to be for the scaling calculation, and they won’t ever change you can pre-calculate them for your code. You’re scaling from 5-bits to 8-bits for red and blue which is 0xFF / 0x1F = 255 / 31 = 8. For green you start with 6-bits and convert to 8 which is 0xFF / 0x03 = 255 / 63 = 4. You could multiply these hardcoded numbers to scale red *= 8; green *=4; blue*=8; however since these are powers of 2, there’s a trick to make this code faster. Simply bit shift left. For each bit you shift, it is equal to a power of two so the code would be red and blue << 3 and green << by 2.

//If you want to see the RGB 565 values print them here, or comment out if you don't need them
Serial.print(" RGB565 =");
Serial.write(bigPIXELS [i][j].red);
Serial.write(bigPIXELS [i][j].green);
Serial.write(bigPIXELS [i][j].blue);

bigPIXELS[i][j].blue = bigPIXELS[i][j].blue << 3;//blue and red were 5-bits

bigPIXELS[i][j].red=  bigPIXELS[i][j].red<<3;

bigPIXELS[i][j].green =  bigPIXELS[i][j].green <<2;//Remember that green has 6 pixels to begin with so it only shifts 2 places

Now you can do with these as you please. Add a BMP header and print them to the serial port to be able to view this BMP image on your computer.

Serial.print(" RGB888 R= ");
Serial.write(bigPIXELS [i][j].red);
Serial.write(bigPIXELS [i][j].green);
Serial.write(bigPIXELS [i][j].blue);

Getting Started with (Git) Version Control and Fab Cloud

January 24, 2022February 11, 2020 by Adam@SheekGeek

Fab Cloud is the Git repository for all Fab Academy and FabLab sites. The first thing you have to do as part of Fab Academy is set up your own repository here for your website. Git very powerful tool used to synchronize multiple versions of files and folders that multiple coders are working on in the same project. Don’t let that scare you though, in the beginning we’ll just be using it to update the webpages on Fab Cloud.

I recommend you learn about using Git in the command line, but that’s a bit scary for some folks. Luckily, the simple basic stuff doesn’t require it (of course, unless you mess something up, then you’ll be learning all about those advanced functions in the command line tool).

Head over to Git for Windows download and install it.

While this downloads and installs, login to your Fab Cloud account. Recall that you’ll login using your FabLabs.io credentials, in fact the two sites are linked. Just click the button to pull in your FabLabs.io login and you’re good to go.

Once in, you’ll be at your dashboard. https://gitlab.fabcloud.org/dashboard/projects . Then click the big green “New Project” button at the top right of the screen. Name this project whatever you want and you can choose whether or not to have a Readme.md file in there. Go ahead and create the Readme.md file. This file is automatically rendered from markdown to html when you visit the directory in your repository it resides in. It’ll start off blank, but we’ll add something to it later.

Now we need to connect the web server and your computer in an encrypted way to transfer files back and forth.

Open Git GUI by clicking your windows start menu button and typing “Git GUI” click the icon when it appears. Since this is the first time you’ll have used the software, it’ll ask you what you’d like to do. Select “Clone Existing Repository” as we will be making a local copy of the one from the web. The local copy will be the one you edit and update and when you are ready, you can upload all your changes to the web.

It is at this point that we have 2 options. If you are on Central Piedmont’s campus, you CANNOT use ssh. You can only use the https method of accessing your gitlab site.

If you are using HTTPS:

Step 1: Visit your gitlab repository’s page and click the blue “Clone” button. You’ll need to select the “Clone with HTTPS” link.

Step 2: Open GitGui on your windows machine by clicking the windows icon and searching for it.

Step 3: Click “Clone Existing Repository”

Step 4a: Paste in your https link in the top box as shown below

Step 4b: Set a target directory on your computer for where you want the files copied to. I created a folder in my Documents named GitGUI. Then you must type in a slash and the name of the folder you want to create. You can’t select a folder that already exists… Here I manually added “/base” after selecting my GitGUI folder.

Step 5: Click “Clone” and it will ask you to login to gitlab.fabcloud.org. If you forget this, simply visit your gitlab.fabcloud page, login via fablabs.io, then look at your account info.

Save your progress locally:

You can now edit the files in that folder, and when you are ready to save your progress locally. You may think “I already saved the files I edited” but you want to make sure to save your progress on the entire repository in gitLab in case you ever need to revert back to this saved point. Think of it like a spawn point in a video game. You WILL break something eventually and need to go back to this save point.

To save your local progress, open gitGUI and open this repo. Then you can click the “scan” button. you’ll see a number of files in the top left pane. These are unsaved changes.

Step 1: Click “ReScan” to scan the folder for changes

Step 2: “Stage Changed” will setup the changes to be committed to your local repository (folder)

Step 3: “Commit” documents this as a save point for the future. You need to enter a comment in the “Commit message” window describing what works and what doesn’t at this point.

Step 4: “Push” Synchronizes these changes with the gitlab.fabcloud server. You’ll likely be asked to login and here you’ll again use your fabcloud credentials.

If you can use SSH use these instructions:

Before we can clone anything, we need to generate an SSH key for our computer. SSH is a encrypted (secure) method for communicating between different machines (be they computers or servers). Only devices with the “key” files can unencrypt the messages sent between the machines. We must generate a key pair on your machine. We need to generate what is called “Asymmetrical encryption” key pair. This consists of a private key (the file which stays on your computer and is not shared) and the public key (which you send to the other machines). Basically, the public key can encrypt messages and send them to your computer which can be decrypted by the private key. More info here.

To generate the keys, Go to Help—> Show SSH Key

In the new window click “Generate Key.” It will ask you to enter a password twice. Make sure to enter the same thing. Next, it will fill out the text box with what looks like gibberish. This is good! That’s the public key. You need to copy this to your clipboard so we can paste it into the website.

Add the SSH key to your gitlab.fabcloud.org account.

Login to your gitlab.fabcloud.org account (remember that it uses fablabs.io login credentials, don’t make a new account, be sure to click the button regarding FabLabs.io and login there.)

Click on your profile icon at the top right of the screen and visit “settings”

In the left column, click “SSH keys”

Paste your public key into the textbox labeled “key.” When you paste it, it should bring up the name of your computer. You have to then click the “Add key” button at the bottom to save this.

Once you do this, you can close the “Generate Key” window and you’re back to the “Clone Existing Repository” window.

The next window asks for two locations. “Source Location” refers to the one on the web server and “Target Directory” is the folder on your local machine you want to store it in.

To get the source location visit that new project you started earlier at and at https://gitlab.fabcloud.org/. At the top right click the blue “clone” button and copy what it says in the SSH window: Example:

git@gitlab.fabcloud.org:acharris/base.git

My username is acharris and I named my repository “base.”

The important thing here is that the folder you want to put it in cannot already exist. So I typed in “base” at the end of the line. Git GUI will create the “base” folder, then store my “base” project in there.

It’ll ask you for your login, so go ahead and type it as many times as it asks for it.

Once it is finished, it will open up the regular Git GUI interface window. It has now created a local branch. (Local means your computer, remote means the gitlab.fabcloud.org server)

In the future, you won’t need to clone this again, You can just “Open from Existing” at the first screen and it’ll bring you right to this window.

This can look intimidating, but it is really simple. First, take a look at the folder we created on your machine. Go to “Repository—> Explore Working Copy” This is the local copy (local branch) of the folder from the server (remote branch). We can add/delete/change any files or folders in this folder while we are working, then upload them all to the server when we reach a good stopping point for the day and it’ll merge the files with anyone else’s who has been working on the same project.

Let’s do a simply workflow.

Let’s change the README.md file. Open it in a text editor (such as sublime or notepad++) and put some text in there. Something like:

I did it!

Save and close the file. Now go into the Git GUI window and notice the buttons. Each time you want to upload files to the server. We will always click these buttons in order from top to bottom, starting with “Rescan” This will magically detect all changes in the project folder. you’ll see the file names in the left Pink panel and the file contents in the right Yellow panel. For now you should just see your txt in green with a + sign in front of it. This pane shows any added or removed text from what is on the server.

The next button “Stage Changed” will move the files from the top pink pane to the bottom green one. If you only want some of the files and not others, then you can click the icon next to the file name to change its location.

Slight detour… Warning: LF will be changes…

At this point you might get a popup on windows stating

Warning: LF will be replaced by CRLF in README.md. The file will have its original line endings in your working directory

This helps windows and linux compatibility, but in some cases (such as EagleCAD board files) it can break stuff. First we need to unstage the file we just staged by clicking at the top menu bar Commit –> Unstage from Commit then we need to turn that feature off by opening the file base/.git/config and adding autocrlf=false after ignorecase – true line and clicking save. If you can’t see the folder named “.git” it’s because windows is hiding it from you. In the windows file browser, click “view” and check “Hidden items” and “File Name Extensions” and you should be able to see it.

Now you can stage without the issue. This change only affects this one project now, but if you don’t want Git to change ANY files in this manner you can go to a command line, cd into a git project directory and enter the following:

git config core.autocrlf false

Back on track, Sign Off:

Next you want to add text to the comment box:

GIT GUI recommends:

First line : Describe in one sentence what you did.
Second line: Blank
Remaining Lines: Describe why this change is good
Sign Off.

Type your comment, then click the next button in the list to “Sign off” on the changes. It’ll paste a template in the “Comments” textbox. This says that you in particular were the person who uploaded stuff. This is helpful later when something breaks and you want to find out who to yell at.

The next button it “Commit” which will add this to the local branch of the Git repository file. When you click this, the files disappear in the Green pane. This does not mean it it available on the web however.

I hear you asking “Well I just copied the file into that folder, isn’t it already there?”…

The answer is yes and no. It’s on your computer, but it isn’t part of the project from the project. You need to tell Git this new version is what you want to use.

You need to click the last button to “Push” to upload these changes to the server. This will synchronize the entire folder, changes, comments and all to the remote branch (server). A window will pop up and just click “Push” again. You’ll be asked for the password again.

Now what happens if you screwed something up? Well…. don’t. You have plenty of opportunity to check things out before actually Staging, Committing, and Pushing. That’s the hope at least. In practice when stuff gets screwed up somehow or another.

You can fix the error quickly, then push a new copy to the server or you can try to rewrite history. This can get really messy and I do not recommend anyone mess with this unless you know what you are doing with Git already (which I assume is not the audience of this tutorial.)

Customizations:

The base version of Git GUI won’t help much as it is too limited. You have to end up using git commands. There’s two ways to do this. One is to go to you’ll have to get into the Git Bash screen (accessible from the “Repository” menu item at the top of the screen.) Another is to add the commands to Git GUI’s menu. (Wait.. What!?)

Click on Tools –> Add and you’ll be asked for a name you want to add, and the command. Check this one out for instance. Before you push, this will revert the file back to the version from the remote branch (the server):

AtTiny412 General Purpose Blinky Board and UPDI Programming

October 20, 2023February 11, 2020 by Adam@SheekGeek

In the 2020 season of Fab Academy, we are encouraged to use new chips (as opposed to the Attiny 84/85 chips). The new chips the lab got were AtTiny 412. This is a tiny 8-pin chip is pretty neat. Here’s my old design which was an EagleCAD Board file. It is based on Neil’s design for the AtTiny412 (Go here), ctrl+f for Attiny412 and look at his “board” link) board but I moved the LED to Digital Pin 0 (which is PA6 in Atmel speak – pin 2 from the top left) of the chip. My new design used KiCAD and is available here.

Here’s the layout of my board:

BOM:

AtTiny412
LED
499Ω resistor
4.9kΩ resistor
6-pin SMT header (FTDI)
2x 2×2 SMT header (Optional, general purpose for connecting other stuff to)

Once the board was made I needed a programmer. The new chips use UPDI instead of ISP protocol. There are two easy ways of making a cheap programmer for this. One is simple software but complex hardware (Arduino-based) and the other is simple hardware and complicated software (python upload/downloader). I tried them both to see what I could simplify about them.

First, mill the board. With this, I experimented with a lacquer finish as a soldermask it came out pretty well actually.

Complex hardware, simple software (Arduino):

First I installed the megaTinyCore library into Arduino.

Followed these instructions to make a UDPI programmer out of an arduino. Here’s a board you I designed that you can fab yourself for this project. Simply download the jtag2UDPI sketch to an arduino board to make it a programmer. You’ll need to connect up a 4.7k resistor from Digital Pin 6 to go to the AtTiny412 board to program. Additionally, if you can’t disconnect the the DTR line from the serial chip to the reset pin of the arduino, just add a large capacitor from the reset pin to ground. The capacitor acts like a tiny battery and when the DTR pin on the FTDI chip drops voltage to 0 to reset the arduino (typically how it works when using the arduino software) the capacitor will keep the voltage high so the jtag2UPDI won’t reset in the middle of trying to program the AtTiny chip.

This is a stupid simple solution that costs very very little. You can get an arduino board for $2 online and add a resistor and capacitor to make it a programmer and you’re done. This is the way to go. The issue is that Fab academy wants you to actually build your own programmer. I’ll revisit this in another post soon…

Once you’ve built the programmer, change your chip in the Arduino software to the AtTiny412 and change the Programmer to “jtag2UPDI” then load up Blink example and change the led_pin to pin 0 (if you are using my board design). When you click program, all should go well.

Simple Hardware Complex Software:

This solution uses just a USB serial chip (FTDI or similar) and only 1 resistor. No additional arudino required. Neil encouraged in week 2 Instructors meeting to build his FTDI-based UDP programmer and use PyUDPI (See under “hardware” if you search for “UPDI” here). Basically you use a simple USB to serial converter chip (FTDI chip or similar) and all the hard work is done on the software side. The setup for PyUDPI is a lot of overhead when you can just get it working directly in arduino using the jtag2UDPI linked above.

The first board Fab academy recommends is hello.serial-UPDI.FT230X assumes you have an FTDI board. This only provides a resistor and two connectors. One connector accepts the FTDI 6-pin header and the other is the 1 pin and Gnd signal to program the AtTiny. Of course this one is WAY too easy to build…

The second board under “hardware” on that page (hello.USB-UPDI.FT230X) is an actual FTDI board, exactly like you could buy. The FTDI chip has smaller pin pitch than the ones we typically do in FabLab so he recommended using the heated desoldering iron.

The workflow will be to use Arduino (because why not?) or any other compiler to generate the hex file, then use the PyUDPI python script to send the hex file to the AtTiny chip manually.

Since this used Python 3 and the terminal, I didn’t want to mess around with windows paths and all that disastrous junk. I installed it in an osboxes.org virtualbox linux installation inside my windows machine and tunneled access to the USB device to it.

First install Python 3 (NOT python 2!) if you don’t already have it. Open a terminal and check
```
$ python3 --version
```
If not installed, then install it:
```
$ sudo apt-get update
$ sudo apt-get install python3.6
```
Install pip 3 (Tom Dubick says – python since version 3.2 comes with PIP)
Then install the dependencies for PyUPDI with this line
```
pip3 install intelhex pylint pyserial
```
Download and unzip the pyUPDI project from here (Click the “clone or download” green button and download a zip (you need the whole thing so just unzip the whole folder).
Plug in a 3.3v FTDI chip (Convert a 5v version to 3.3 volts shown here)
Open Arduino and load up the blink example. Change the LED pin to 0 since that’s what my board uses. Save the file to the Desktop. Export a compiled Binary from the Sketch menu in Arduino. Sketch—?Export compiled Binary This will save the .hex file in the Arduino project folder. (You saved this to the Desktop like I told you to right?) Otherwise you’ll be digging through temp files to find it.
Open a terminal window inside the pyUDPI folder (or navigate to it). Open a terminal and download to the board using the following command:
```
sudo python3 pyupdi.py -d tiny412 -c /dev/ttyUSB0 -b 115200 -f Blink.ino.hex -v
```

Where /dev/ttyUSB* is the path to the FTDI port and Blink.ino.hex is your file’s name.

Board:

Tweaked the design of Neil’s Blinky board. I changed the pinout of his board to use Pin 0. You can see the pinouts of the new chips:

Image source: https://github.com/SpenceKonde/megaTinyCore/blob/master/megaavr/extras/ATtiny_x12.md

Other new chip pinouts available in uncropped image:

Tom Dubick added the following resource which is great as well: https://npk-stn.ru/2019/07/19/simple_programming_attiny414_via_updi/?lang=en