Francesco "Four" DiPietro IV

Godot PR - CAMERA_VISIBLE_LAYERS

Sat, 01 Oct 2022 00:00:00 +0000

I made my first engine contribution to Godot.

I was trying to make a game prototype with multiple viewports and with multiple cameras representing different view-modes (like normal vs thermal) so they overlapped.

And as of Godot 4.1 its officially included in the engine! The pull request is here

There are already tools built into Godot to facilitate rendering masks, so that actors were only visible to certain cameras depending on their mask. However, I wanted all actors to be visible to both cameras, I just wanted to change the material for the different cameras. I wanted the thermal camera to render the actor with a different texture than the normal one. And I wanted both cameras to be active at the same time.

This could be solved with the render-masking tool provided. I would just have two versions of the actor inhabiting the same space. This, however, would be an abysmal development workflow, making sure they were always coordinated.

Instead, I decided to modify the engine to pass the current-camera’s render mask as a shader uniform. It was actually pretty easy! Godot’s codebase has a lot of abstraction that I’ve barely even scratched the surface of, but I was able to understand it enough to make this change.

I got to experience the full pull-request flow, from making a proposal, doing a pitch in the weekly contributor’s meeting, and then finally getting it integrated.

In the demonstration image, The top viewport is a camera with an all-encompassing view mask, the bottom right renders only layer 1, and bottom left only renders layer 2.

The shader is then able to switch what color is output depending on that layer mask.

Forgetting to Push with Git

Sun, 09 Oct 2016 00:00:00 +0000

I’ve been tinkering around with my setups related to git lately, and have come up with an idea that I have found insanely helpful. To cut to the chase, I’m using private git repositories for all of my projects (personal and team) in order to never lose a change.

So the reason I did this was because after commiting a new build to our project’s build branch, I ran to the labs at like 11pm to get everything ready for the morning. Only then did I realize I forgot to push.
Returning home in shame, I was thinking of a way to prevent this problem from ever happening in the future. I thought about automatically pushing things whenever a commit was made, but that would wreak havoc on any team project. But then, it hit me. If I don’t have a team, I don’t have to worry about. I obviously can’t get rid of the team, but I can push to somewhere they can’t access. My solution was simple: Using a private git repository on gitlab, I would setup some scripts to automatically force-push everytime I commit to a another remote I named checkpoint.

Step 1: Private Repository

If you aren’t already aware, unlike GitHub, GitLab offers private repositories for free. While I still very much prefer GitHub for its community, issue tracker, and general website layout, this is a pretty big perk for GitLab.

So nothing special was done, just make a private repository, name it something relevant, and copy the SSH url of the repo. It is important to use SSH (and to have your computer’s public SSH key saved in your GitLab account) so that you don’t get prompted for a password every time your automatic pushing script fires.

Step 2: Adding a Second Remote

The easiest part. Navigate to your project folder, and execute the command git remote add checkpoint [ssh url]

This makes your project aware of the GitLab repository you made so that it can be pushed to under the name checkpoint.

Step 3: Auto-pushing Scripts

Git has this handy little system in place for running scripts whenever an event occured called hooks.
In your project folder, you have a (usually hidden) folder called .git/. And inside that, theres a hooks/ folder.

This folder contains all the scripts to run whenever a specific event fires. You can check out the list of events in the git documentation. When an event fires, the script with the a name that matches the event is executed.

So for this task, the first thing I did was make a script called autopush.sh, which as you’ll notice, isn’t a hook.

/.git/hooks/autopush.sh

#!/bin/sh

echo 'Pushing all branches'
# Force push to checkpoint and execute in the background
git push --all -f checkpoint & 

Next, I made the actual hook scripts. I picked the events post-commit, post-rebase, and post-update because between them they encompass just about all occurrances of a change. They also all looked the same, because they all just call autopush.sh

/.git/hooks/post-commit /.git/hooks/post-rebase and /.git/hooks/post-update

#!/bin/sh
$GIT_DIR/hooks/autopush.sh

And that’s it! Every time you make a commit or do a rebase, it should be pushed automatically to your backup remote.

Notes

This is a great way of both making sure you always have access to your work and backing it up in case something horrible happens to your computer. One could, of course, just host their own git server, but GitLab is free and always available.

It is important to keep in mind that this is force-pushing all your branches every time you commit. This means two things:

Anything you do will override what is there, so make sure if you’re on a new computer, you’re up to date before you commit.
It doesn’t push if you don’t commit. If you haven’t already built up the habit of committing at every little change rather than in bulk, do that now. It could save your project. Plus, it is good documentaiton. You can always squish an insignificant commit later.

Vim is Fun

Sun, 02 Oct 2016 00:00:00 +0000

Over the summer in my off time or whenever I was waiting for something to do, I invested some of my effort into learning the wizard-like editor known as Vim.
This post will serve as a reminder to myself for all the commands I find most useful in everyday situations.

Impressions

For the most part, I’ve always been dependent on nano for my in-terminal text editing. It’s simple and quick not requiring a lot of thought. But vim was so enticing. I enjoy the fast pace that comes with knowing a lot of keyboard shortcuts, and vim is nothing but that. Now I end up looking for vim plugins for just about every text editor I use. I really feel like every time I use it, I’m getting a little better, and with that, a little faster. It is also really enjoyable to think “I wonder if there is a way to do this already” and end up finding another trick to add to my repertoire. So this list is all the commands I’ve found to date which have made me love using vim over every other editor.

Commands

Key Combo	Function
:mks!	Saves the current vim session (all open files and whatnot) to a file called Session.vim
:s/[search]/[replace]	Search for text and replace it on this line only
:%s/[search]/[replace]/g	Search for text and replace every instance in every line
/[search]	Search for text in file
n	Go to next result of search
:tabe [file]	Open file in new tab
g t	Go to next tab
g T	Go to previous tab
m [key]	Mark line as almost a bookmark to given key
’ [key]	Jump to the mark location assigned to that key
’ ‘	Jump back after jumping to mark
` .	Jump to location of last edit
:vsp [file]	Open file in new tab, but split the tab vertically
CTRL + w CTRL + w	Go to other file within this tab
:e .	Open current directory, which lets you explore files
:![command]	Run a command in the shell
:map [key] [command]	Bind a key to an action, useful for building. Ex: `:map <F5> :!node test<CR>`
y y	Yank (like copy) a line
p	Paste last yank
” x y y	Yank current line to buffer `x`
” x p	Paste line from buffer `x`
zf[movement]	Make a fold from cursor to movement
za	Toggle fold
zM	Close all folds
zR	Open all folds
zd	Delete fold

Raspberry Pi Zero Super Gadget

Sat, 13 Feb 2016 00:00:00 +0000

So I just got a RaspberryPi Zero in the mail a few days ago, and found a way to turn it into a plug-and-play flash drive and computer combo, using just one OTG cable for both power and data. Its a real neat trick I picked up from this blog post, but I took it just a slight step forward.

features

Power and use your RaspberryPi Zero using only one Micro USB cable! Plug it into a computer and SSH into pi@169.254.54.54 to access it! Then at a flip of a switch, it becomes a flash-drive for easy access to your Pi’s files!

The project is simple, you tell your RasPi0 to pretend to be a gadget instead of a host on its second USB port. Normally the Pi expects to be the host since it expects things that get plugged in to be gadgets like a mouse or flash drive, things that generally don’t think for themselves and are just a tool to the host. But the RasPi0’s USB port was designed to support being a gadget, which means all that’s left is some software to communicate with a host computer. Fortunately Raspian Jessie comes with a few of these as kernel modules which you can turn on to do various things. I found the most useful would be g_ether and g_mass_storage.

g_ether lets you create an ad-hoc network between your gadget (the Pi) and the host computer. In short this would mean you could SSH into your Pi over a USB cable without having to plug in an Ethernet cable or WiFi dongle.

g_mass_storage makes your Pi pretend to be a flash drive, so that the host computer can access files on the Pi from its file browser.

My reasoning for picking these was this: I wanted a portable computer that I could plug in anywhere and instantly work from, and should I need to copy project files, I wanted that to be easy as well. So my solution was to add a physical switch on the GPIO pins that would switch between the two modes.

Implementation

The majority of the work was done just by following the instructions laid out over here which came from the blog post. I only made two modifications.
1) ignore step 6 regarding adding your chosen module to /etc/modules, I was going to do that myself later.
2) was to increase the size of the flash drive partition. I changed the command sudo dd if=/dev/zero of=/piusb.bin bs=512 count=2880 from its ~1.5MB to about 2GB sudo dd if=/dev/zero of=/piusb.bin bs=1M count=2000 since that was where I planned on storing all my project data. Note that the second command will take significantly longer (about 10 minutes for me). This also required some partitioning because for some reason that I couldn’t figure out, g_mass_storage didn’t like the bigger bin file. So using this guide, I partitioned the .bin file. I kept the number of sectors and heads the same, but I used 32768 cylinders. (2GB = 2097152KB, 2097152KB/64tracks = 32768 cylinders. Don’t use google for these calculations, use an actual byte converter )

The next part was writing something that would listen for a GPIO switch and switch out the current kernel module accordingly. For this I decided to make a daemon script in /etc/init.d so that it could be turned on and off as a service and would start during boot (g_ether seems to take a few seconds to activate, so the earlier the better).

Before this I had no experience creating daemons, so take my work with a huge grain of salt. You can view my init.d script here as well as the actual GPIO-reading script here. The init.d script is what is called by the OS when it wants to turn on your service, then the init.d script runs my GPIO-reading script, while also making sure only one is ever running at a time.

The last step was to wire a switch onto pin 7 and ground, and since they were adjacent pins it was as easy as just soldering a switch to the Pi. IMAGE

And the project is done!

Limitations

For some reason, I cannot get windows to allow internet-sharing over the USB connection. The blog post cites that unix systems have it easier, but I don’t have one to test it.

Copying files and projects onto the flash-drive portion of the device can be rather slow and sometimes fails saying ‘the filename is too big’ which I’m still unsure how to handle.

Heroku, Node.js, and Twitch.tv

Wed, 03 Feb 2016 00:00:00 +0000

This last summer, I spent my free time learning how to use Node.js for a variety of small projects with friends: A Node.js website on Heroku, a javascript Twitch bot, and a combination Twitch streamer overlay and webpage in Unity3D.

The Heroku website was a utility for Twitch users to find games based on a streamer to viewer ratio so streamers could find games that they could stream to possibly get more viewers. It was an idea by a friend of mine (the same one I made Hecklebot for). It was also my introduction to Heroku as a platform, since we needed to find a way to host it. In my experience, it was a really strong tool for development. It allowed seamless git integration, free hosting for a max 18 hours a day, and quick-setup for a lot of 3rd-party tools like MongoDB. The website itself started strong, I managed to get a lot of the core functionality done using Twitch’s API. I designed the core in an API sort of structure itself for a couple of reasons. First of all, I didn’t know how the website itself should access the data. I was thinking of having the webpages that need info grabbing data from the server after loading rather than having the server contruct webpages for each request. That way the page could refresh its data without being refreshed. Secondly, I sort of wanted it to be open if for whatever reason I or anyone else wanted to access the sorted data remotely. I doubted it would ever get that big, but it was a fun structure to design. However, as the summer progressed, my friend had less and less time to spend on it between his job, so without him the project faded. I couldn’t pick up the slack because he had all the ideas and the strength in designing actual webpages. Plus, it wasn’t as fun without a partner.

The twitch bot was a remake of Hecklebot written in javascript for two purposes for a different friend of mine who decided to try to become a streamer. 1) I was fed up with python’s whitespace sensitivity 2) I wanted to run it on a Heroku server I enjoyed writing hecklebot, but some of the original appeal to writing it was learning both python and the Twitch API. As I got more and more annoyed with python, that appeal drained away until another friend of mine wanted a Twitch bot. He actually asked if I could just route hecklebot to help on his stream, and for a while that’s what he got, but as he began wanting more things from heckebot and I came up with more ideas, I decided to rewrite it in Node, which I was excited to learn. Node.js really appealed to me because it was simple tool with a language that I already knew and understood pretty well wich allowed me to prototype quickly. Node just basically opened up the door of using javascript as a standalone, full-body application rather than having to setup a whole webpage with file hosting to use it. However, Python wouldn’t have been so difficult to work with if I wasn’t on a windows computer, but Node didn’t have that problem. Setup was a breeze and there were already a ton of APIs to start from. The rewrite instantly felt more organized than its Python counterpart. By the end of the summer, I had learned a lot about Node and javascript in general, I knew I had a lot to learn still because javascript has a ton of neat tricks beneath its surface, but I could call myself proficient.

Lastly, something I tinkered with while my friend was streaming was an interactive Twitch overlay in Unity3D. Using a technique I learned from PsydraGames and Bendry?, I could make what almost amounted to a game as an overlay for his stream. It was as simple as setting the Unity application’s background to green and setting up chroma keying in the screencasting software, in our case OBS. My friend had this idea of turning his stream’s chat into a sort of game, where there would be characters on-screen represented by the current viewers, and the viewers could take actions via chat commands. Occasionally, events would occur, like a monster showing up in the overlay and viewers could attack it to gain some currency, then use it to buy weapons or enter raffles. We had a boatload of ideas, but not a lot of time, since the idea was conceived close to the end of the summer. My goal was to get it both reading chat and communicating with ROWBot (his version of Hecklebot) behind the scenes to sync up user and currency information, since ROWBot would still handle the raffles. The chat was accomplished using some code that PsydraGames wrote and linked me to, while the communication was handled simply by putting all user info on a Mongo database. One of the coolest features, however, was that I wanted to setup an external controller for the overlay that would be in the form of a webpage. This webpage would be hosted by the overlay process itself which would be running a websocket server listening on the localhost:80 and would serve up a pre-made HTML file inlaid with javascript interactivity which would send messages to that same websocket server to control the overlay. I did this because I couldn’t put buttons on the overlay itself, all screen-space had to be dedicated to the overlay because anything there would be seen by viewers. I had heard about a cool debugging tool a company had designed for one of their applications which was a small webserver running within debug builds of their application which the programmer could connect to and view any output or relevant data. I thought it would be a cool tool for this project since it would basically allow for two screens on this Unity application. The biggest trouble I had with it though, was writing a websocket server. Through my research, I found many websocket tools for Unity3D, but none that actually hosted a websocket server as far as I could tell. This meant I had to do a lot of learning about websockets to write my own. In the end I was successful, but I have to say that websocket security is weird. So much effort is put into preventing eavesdroppers, and before looking into it I believed the designers behind websockets had security down, but it seemed to me that anyone listening on the data had just as much access to it as the person its intended for, since the encryption keys have to be sent the same way. However, it wasn’t like I had any ideas to improve it (nor did I need to, since it would all be local anyway), but it was an interesting thing to think about. Much like the Heroku website, all the functionality got implemented, but when it came to designing the actual aesthetic and graphics of the overlay, the project slowed dramatically. UI design in general has plagued me in many projects, and this one was no different seeing how neither my friend nor I had any skill in such designs. The prototype was still an interesting thing to work on though, and my biggest takeaway from it is the websocket server, since now I can use it as an external debugging tool in the future should I need it. The project in its unfinished state is available to browse through here,

Summer with Android

Wed, 03 Feb 2016 00:00:00 +0000

This last summer I was hired as a intern programmer to work on an app called ReallyMake. It is an app that lets you throw, sculpt, and paint pottery on your phone as though you were at a potters wheel. It also has some cool features like viewing the pot in augmented reality and sending the the model to be 3D printed.

I was hired on sort of halfway through the project as I understand it. It had a lot of the core functionality out of the way, but they wanted someone to help with the graphical side of things in OpenGL, namely shaders. It was interesting working with graphics in the restrictions of mobile devices. It became even more interesting when I was asked to find the reasons for the different outputs with different devices. It was an issue rendering the texture on some older devices and the only thing I could surmise to be the problem was that some devices had a significantly smaller amount of memory on the GPU. I can’t imagine how big companies handle this sort of thing. There are hundreds of different android devices with different internals, so the possible problems are endless. The company I worked for was rather small, and almost all the code was written in-house for this project, so no large libraries to handle the funny things with android. The only thing we did use was something called the Nasa Worldwind API, which was used to build and render the meshes for the pots in OpenGL. Though from what I understand it is primarily targeted at non-mobile systems.

So beyond android, the other major thing I got to learn while working there was SVN. I am primarily a GIT user, and have enjoyed every feature I’ve learned about it, but going from GIT to SVN was more troubling than I thought. The trouble didn’t come from using it. Using it was mostly the same. A single upstream with branches (though the team I worked with didn’t use them). The only big difference that I really had any conflicts with was that SVN stores all commits on the central server. It meant that I couldn’t rewind or research any old commits without connecting to the server via VPN (which was a lengthy process in itself for security reasons). Perhaps this was a security thing, my boss is really heavy in protecting code and information so anyone getting access to the whole history of the project might be an issue to him, and I can respect that. It wasn’t really a hassle, just something that rubbed me the wrong way

Lilywatch Part3: Computers and Code

Thu, 21 May 2015 00:00:00 +0000

This is a continuation of my previous posts regarding the Lilywatch: A watch built using an Arduino. This post goes over the programming and computer aspects of the device.

Computers and Code

Arduino

I call myself primarily a programmer, so this part of the project was the least daunting. However, I have never done anything so big with an Arduino before. I wish I had learned earlier that I could use multiple files, that would have made things a lot easier. Navigating a single 900-line file is infuriating to say the least. But the job got done, all was well, and I finally had a wearable, functional watch made from an Arduino.

I also put the code on GitHub. At first it seemed kinda silly since it was all in one file, but versioning software is still useful even then. I just had a very sad looking repo. TODO ADD LINK

Significantly later on in the project, I did end up doing a major refactor and splitting all the different modules into their own classes.

Arduino was mostly OK with this, however I had to use Notepad++ as the actual editor since Arduino’s IDE mandated that all the files open in scrolling tabs which was unbearable. Arduino’s compiler also didn’t seem to like having sub-directories which made me sad, but I managed all the same.

The only real concern I started having was that splitting the files seemed to take up noticeably more memory on the board when uploading. I was at a little more than 50% before the split, and about 70% after. So at least I still had some room, but I had to make sure I considered that whenever I thought about adding more features. Future things were going to have to do the thinking outside the board.

Anyway, the code is structured in such a way so that each “app” or state is its own class and stored in an array in the Lilywatch class. The Lilywatch class is the main overseer of everything, looping through whichever state is the current one and storing references to all the sensors. I also made a class called a daemon. A daemon is typically a program or process that runs in the background. Since Arduino doesn’t have multi-threading, these daemons were just like states but they were always running. Daemons handled things like changing the brightness based on light levels or handling input from bluetooth. In comparison states were things like the clock or flashlight states, which were only run while selected.

Android

To enable communications between the watch and my phone, I had to write some sort of app to relay information to Tasker, which I would then use as the main brains behind the watch/phone communications. I did this because 1) I liked the idea of being able to edit things on the fly, without having to return to my computer to reprogram a feature and 2) I am not greatly skilled in Android programming yet. I’ve been experimenting for a while, but nothing has come out that I’m proud of.

So the basic plan was: - Obtain a bluetooth connection using my own Android app - Pass any incoming messages from the watch to Tasker using that app

The App

The app was as simple as I could make it. I compiled what I needed from Google’s bluetooth examples and BlueTerm which was open source.

It wasn’t anything pretty to look at, in fact it still just looks like Google’s example, but it worked. All it did was establish a connection to the phone and send out / receive intents pertaining to anything related to that bluetooth connection. To put it simply, intents are Android’s way of sending messages between its various components. I was going to use these to tell Tasker when new messages from the watch were received and I made Tasker send Intents to my app which detailed messages to send over bluetooth.

Tasker

If you don’t know what Tasker is, it is an app that listens to events that happen on your phone and allow you to designate actions to be performed when those events happen. For example, make a popup whenever the clock strikes 12 or vibrate to a pattern when you get a text from a certain person while in a certain location. It has a lot of possibilities. So I made it listen to intents broadcast from my small app and make sent return intents accordingly.

Getting this working was as fun as it was frustrating. This was my first major delve into the mechanics of Tasker, so getting used to the interface was unpleasant, but the results were worth it. Whenever a bluetooth connection to the Lilywatch was reported, Tasker would send a message detailing the current time so that the watch could stay accurate. I also programmed events in using the Notification Listener plugin so that whenever a notification arrived using the from hangouts(SMS), Google(Reminders), or an alarm went active, Tasker would send corresponding messages to the watch so it can notify me.

Experiments

Bluetooth and RSSI

During early testing with the bluetooth module, I wanted to see if there was a way to recreate a program I had in middle-school that unlocked my computer automatically when my phone was in range. I did some research and discovered this was done by reading a bluetooth connection signal strength to estimate a distance. It was far from accurate, but it could at least tell if I was a few feet vs in another room.

Bluetooth uses something named RSSI or Received Signal Strength Indication to inform the bluetooth radio’s user of its connection strength. However, I was met with some major problems when trying to use this for anything practical.

My intention was to use it as a sort of ‘find my phone’ application, beeping like a metal detector whenever you got nearer. Unfortunately, the only way to get RSSI information was to request that they start being broadcast from the radio module’s command state itself. The worst part was that they would only ever update every 5 seconds, and it would be nigh-unpredictable. The signal strength would jump from full power down to ~80% at around 10m, then gradually fell sporadically until something blocked line-of-sight with the device.

I tried turning down the power consumption of the radio module, but it showed the same effect of not doing anything for a distance and then gradually falling although this time the initial distance was about 2m. Still, not that great. It could be usable if the strength gradient it took was more predictable, but it jumped around far too much. Plus, if anything broke line-of-sight at the lower power setting, it would just disconnect entirely.

I still see potential to get this feature working, and maybe one day find to achieve it, but for now I am putting it on hold. I did however keep the power level low for the sake of battery consumption.

Unity

In my attempts to make an interactive app, I also tried communicating with a Unity3D project on my PC over serial. Getting it to work wasn’t hard at all, since C# already has classes built in for serial communications, the only fault was that I couldn’t calculate a decent orientation vector given the accelerometer and magnetometer data. For whatever reason, the compass seemed so inconsistent, and whenever I pointed in certain directions, the orientation vector was horribly skewed. I wanted to get some sort of mock-motion control going, but I scraped that idea quickly in favor of working with the TV. Which I will talk about in the next post.

A note to those who may wish to use Unity3D, it required enabling .Net 2.0, which you can do by going to:

ProjectSettings > Player settings > Change .Net 2.0 Subset to .Net 2.0

Lilywatch Part2: The Build

Wed, 20 May 2015 00:00:00 +0000

This is a continuation of my previous posts regarding the Lilywatch: A watch built using an Arduino. This post goes over the building of the watch itself.

Process

Printing the Housing

Since I already had a design from the last project, this was fairly easy. The only thing I did was make some improvements to the model. Namely I added holes in the bottom so connections could be made via the bottom of the watch. I wanted to do this because in the last project everything was attached to the cap, making removal of the cap difficult. That was a silly choice, but I learned.

The battery housing had to be done from scratch for this project, though that wasn’t hard. It may not be pretty, it’s just a box, but it gets the job done. I wanted the battery to be it’s own entity because I wanted to keep the charging circuit on-board. I also made sure that the cap for the battery housing was quickly removable so that if something goes horribly wrong, as it occasionally does with batteries, it’s not so strongly fixed to my wrist.

Components

The Foam Ring

Similar to the last project, I used a foam ring to do make all the connections directly with the board. Using some 1.5mm thick foam I had laying around in my materials box, I cut rings for the top and the bottom of the board that matched the radius of the Lilypad and were thick enough to cover most of the metal pads on already the board. Then I took some copper tape and taped the ring wherever there was a pad on the Lilypad I thought I would use, and made sure to place a a small wire with a loop on the end between the layers of the tape (I only looped around a little more than once to leave an overlap). That wire would be what I would make my soldered connections to, since in the last project I learned not to solder directly to the copper pads. That melted the foam, made the pads too hard, and in general was a terrible mess.

The bottom of the pad needed a little extra care, since the Lilypad I have doesn’t come with connection pads on the bottom. This was easily fixed though with a little more copper tape. I just needed to make sure I scraped off some glue so that a connection could be made between the tape and the pad.

Neopixels

Neopixel attachment was kind of fun. This was mostly due to not having to sew through leather with my feeble, makeshift connectors. I was aware that there was already a product meant for this kind of project (see Neopixel Ring), but I knew I wouldn’t be using the full ring, plus I already had some perfectly fine Neopixels laying around.

To solder them, I made an indent in some sticky putty (meant to hold posters on walls) using the face of the watch and laid out the Neopixels where they should go in relation to the watch. This kept them in place relative to each other while I soldered the necessary wires together. Then it was as easy as pulling it off as one thing and gluing it to the watch face. I soldered the power and ground wires to the little connector wires I made, and tucked a resistor under the trim of the cap for the data wire. It all was falling into place better than I expected.

Bottom Motor and Sensors

The bottom sensors were attached kind of hap-hazardly. I didn’t mean to do it that way, but I didn’t really have a plan for them since I knew I’d be adding more sensors later. I just didn’t know what. The vibration motor and its transistor went on first. I tried to make sure there was ample room for the future, but with so little room already, any effort made to that effect was unnoticeible.

Next came the Flora accel/mag sensor. I initally tried to make sure this wasn’t placed permanently, but I only had two types of glue: Superglue and rubber cement. Rubber cement was too weak to hold it and the Superglue was obviously too strong. I tried mixing them to dilute the superglue, but that was silly and messy and the part was still stuck too strong. Oh well.

The photo resistor came much later in the project, but adding it was pretty trivial. I obviously had to make the head of it peak out to the top, so I wrapped it up towards the cap and glued it to a square I cut off the little plastic thing the Neopixels came in. It fit miraculously well, and left the photoresistor tucked nicely into a corner.

Leather and Straps

The leather for this was bought at Micheals (I’m pretty sure it’s not real). I just got a small square, enough for this project and a few others. I cut it to fit and tied it down with some string and volia! That’s done.

The leather on the bottoms of the watch and battery housings were there to prevent the components from being an irritant, which they were. The leather helped immensly.

Battery

I was kind of worried about the battery. I’ve had some pretty undesirable things happen to my cellphone batteries in the past, and I didn’t want to take any chances.

That is why I gave it its own housing with enough room to have the charging circuit. That way it doubled as protection and built-in charging. I mean, if I had to wear it around and it died, I’d like to be able to charge it without going home to fetch a charger box.

The battery box was pretty simple and strapped down like the watch itself. It also has a cap, but with the way its designed this cap was not really meant to come off as easily. The cap was designed to fit around the plugs of the charging circuit and the two clips holding it in place were much sturdier, preventing them from bending back. I took advantage of the bending clips on the watch face so that it was removable, but I knew I wasn’t going to be removing the battery very often and I’d rather have it secure. In fact, the cap is so secure it took a screwdriver to get the clips to bend at all during one of the iterations, so for the final cap I added a middle wall which allowed me to sort of push the cap to one side while bending the opposite clip, releasing it only when I intend to.

Wiring plug

To go along with removability, the plug for the battery was attached to the pins intended for the USB cable. The plug was simple, it provided a switch as well as continued pins so that I could plug things in behind the plug. Namely this was for the Bluetooth module.

The wires for this were a little frustrating. The connections kept breaking due to being moved around so much. I tried to hold them in place using various things wrapped around to keep the connections together, but all proved fruitless. The biggest hassle was between the JST connector its wire. What I eventually found was that using solid wire as opposed to bendable, stranded wire made for a more lasting connection.

Lilywatch Part1: Intro

Wed, 20 May 2015 00:00:00 +0000

Lilywatch: a smartwatch powered by Arduino

What is it?

A watch powered by a removable Lilypad arduino and equipped with a bluetooth connection to my android phone.

This was a project I started for my Physical Media class that went way off course. The original premise was to make a small device that communicates with another device to create an interesting experience, but I quickly got distracted and made a watch instead (I made an ‘experience’ app for it too).

The watch was something I already had rough plans for after designing a housing for a Lilypad during my last PhysMed project(link). At the time, I really just wanted something I could plug my Lilypad into without having it permanently attached to a circuit. I wanted to have it available for other projects should they come up without compromising whatever project I’m taking it from.

So, with that design already in hand, I took to improving it so I could turn it into a platform on which I could make whatever this ‘experience’ my next assignment called for. But in doing so, I got side-tracked testing to make sure it could do anything and ended up focusing on turning into a personalized smartwatch. A smartwatch tailored to me and my expectations for how things work.

Over the next few days I will be writing posts on the process of making it and some accompanying projects to document this adventure. The project is not done, it’s one of those that I hope to gradually keep adding to over a long span of time, but I will try to keep adding to this blog as well to continue documenting its progress.

Features

Time keeping displayed in binary
Lilypad is removable for project swapping or testing
EEPROM (with wear-levelling) for config saving
Auto-light level (disable-able through config)
Notification for when an SMS is received
Watch alerts you to phone alarms
Contextual control over my livingroom and bedroom music when in range of them
App-like programming structure Current ‘apps’
- Clock
- Compass
- Flashlight
- Feature config menu
- Time and brightness settings
On-board LED will freeze if something goes horribly wrong

Intentions

Removable

I can be a bit of a cheapskate when it comes to materials. I don’t like using components in ways that would make them unusable for future prospects, and that was my number-one drive for keeping the Lilypad removable. Plus, there are times when testing is a whole lot easier with a Arduino board that isn’t attached to anything. So the housing for the arduino is snapped in place and able to be removed and replaced with ease.

Sturdy

Compared to my last project, where everything was sewn together in unforgiving leather, everything here is soldered together in a way to support daily movement as well as the removability of the board. (Truthfully I’m just so happy I don’t have to deal with sewing wires in leather anymore)

Modular

Wires are attached to the board by copper-coated foam pads which are pressed into the existing pads of the Lilypad to create a solid connection. This makes it easy to add more components should I ever find something worth attaching later on.

Configurable without Android programming

The app which talks to the watch is in-essence just a relay for bluetooth communications and doesn’t handle any logic. All the actual communications are handled by Tasker which sends messages to the watch through the app when appropriate. I wanted to use Tasker because I didn’t want to have to go plug my phone in to my computer to reprogram or change something. This was still technically expected to be a class project, so I was expected to work in class, and I wasn’t going to setup the Android SDK on a school computer.

Future Goals and Improvements

My goal now is to make this something worth wearing daily. To have it able to do enough that the bulkiness of it is outweighed by its usefulness.

At this time though, some major improvements would be

The bluetooth app. I’d like to have it handle more rather than let Tasker handle it all
Have a single housing, not the three pieces of the watch, battery and bluetooth separately
Arduino coding improvements. I haven’t done a lot of research into this, but having all the code in one file is always a taboo
Move more control to android. Able to write and control whole states from the phone
Point the connection wires away from the wrist. At this time the power and bluetooth connectors are pointed straight where my wrist bends up, and it can be rather obnoxious.
The cap currently pops off if the strap is too tight. Perhaps moving the clamps 90° to the would make it a little better.
The foam rings acting as the connector pads to the Lilypad wear down too quickly, sometimes requiring some serious pressure when trying to put the board back after taking it out to make the connections stable again.

HFOSS: Lit Review 2

Wed, 20 May 2015 00:00:00 +0000

This is a literature review of A Legal Issues Primer for Open Source and Free Software Projects

It serves as an introduction to the many different kinds of copyright licenses, as well as their categories.

The Good:

It gives a good overview of all the different licenses an open-source project may need, and where they would best be applied. Most of the descriptions are pretty short, and link similarities and differences between each other. It could almost be used as a reference guide each time someone needs to pick a license. It also does a pretty good job of keeping the vocabulary of these descriptions within the scope of an everyday person, so you don’t already have to be a lawyer to read this.

The Bad:

Several of the chapters past the initial descriptions of the licenses don’t clearly describe why they are relevant to open-source project licenses. Plus, they are in full-on lawyer-speak, and I can barely parse out enough to get a gist of what it is saying through most of the text.

Questions:

-How often do these licenses ‘break’? Or in other words, are there people trying to nullify these licenses, or are they sound? -Who would be trying to break them if they are? and why?

HFOSS Homestretch Hackathon

Wed, 20 May 2015 00:00:00 +0000

The Homestretch Hackathon was a ‘hackathon’ put on by the HFOSS community at RIT. Unlike most hackathons, this one had no premise except “Finish your final projects before they are due!”

They had free pizza and music, so it was just a small gathering of about 30 students trying to finish everything up before the semester ends. I’ve never really attended a hackathon before, so I’m not quite sure if this completely qualifies as one. It was a nice chance to hang out with people who either were facing the same problems as me or knew how to fix them though. They were almost all either people from my HFOSS class or those who attended it before.

I spent most of my time with another team member for the OLPC project we were working on, trying to get things finalized. I wonder if most hackathons are like this, because if they are I really need to go to more of them.

HFOSS Quiz2

Mon, 04 May 2015 00:00:00 +0000

This is my response to a quiz given for my HFOSS class on the topic of open-source licensing.

In the first 3 Chapters of the SFLC’s FOSS Legal Primer, there was much background information on the types of licenses a FOSS Developer may choose, and why.

When does a work become “copyrighted” by an Author?

As soon as the idea comes out of the mind and onto a tangible medium. (physical and digital included)

Without copyright, there could be no copyleft. What are the copyrights that an author has when they create a work, according to the US Copyright office?

Right to sell, reproduce, edit, distribute, and pass permission of any of these things to others.

Free/Open Source Licenses fall onto a spectrum of Software Freedom. What descriptive words are at either end? restrictive & distributive vs permissive & non-copyleft
When someone reliquishes their copyrights, this is referred to as what? Waiver
Below is a list of licenses. Please identify where on the spectrum each falls, and whether or not it is an OSI approved license.
- GPLv2 : copyleft, OSI
- BSD : non-copyleft, non-OSI
- GPLv3 : copyleft, OSI
- MIT : non-copyleft, permissive, non-OSI
- AGPLv3+ : copyleft OSI
- Apache 2.0 : copyleft, OSI
- LGPL : copyleft, OSI
- WTFPL : permissive, non-OSI

Bonus:

True or False: You cannot sell GPL’d software True
True or False: You can fork a GPL licensed Project and release it under an MIT license? False
True or False: You can fork a MIT licensed Project and release it under an GPL license? True

Web Applications: Project2 Concept

Tue, 21 Apr 2015 00:00:00 +0000

Classic Flight Radar

Premise

Develop a useful and interesting web application combining two or more JSON or XML web APIs.

My Plan

My idea is to use a combination of Google Maps with FlightAware’s FlightXML2 REST API to create a classic radar for nearby planes similar to what you see in old films in a submarine or on a military computer. Google Maps would be used to find a location to center your radar. Then the FlightXML API would be used to find flights from nearby airports. A HTML5 canvas will be used to draw out the radar and any blips that appear. I will be trying to make it look as much like a classic film radar as possible.

Image courtesy of pixbay

Possible Limitations

From my brief research on this flight API, it does not look like you can search for flights by location, only by airport, aircraft, or operator. So it’s possible flights flying overhead that don’t land in nearby airports won’t register on the radar. However, this still needs to be tested.

Physical Computing: Project3 Writeup

Mon, 20 Apr 2015 00:00:00 +0000

Premise: Using an arduino, build a simple interactive machine that somehow involves audio whether that is input or output. This was a significanlty smaller project than the last one, and my idea was to detect notes made by whistling.

However, through experimentation, that goal changed to detecting notes made by an instrument. Instruments can make a much more consistent and clean noise compared to whistling via mouth, making detection easier.

Implementing an FFT algorithm wasn’t too difficult using libraries available. They were interesting to read up on since anything dealing with audio aiming to be functional must keep the sample rate high since audio is just really fast waves essentially, and so the code that managed the FFT didn’t bother using many of the normal functions for getting input from pins. Instead they used variables built in to grab values from the analog pin and optimize speed.

#Fitting the FFT to work for me

PhysComp: Project1 Experience Taxonomy

Sat, 18 Apr 2015 00:00:00 +0000

category: blog

This is a writeup for my Physical Media Project 1 describing the taxonomies of the experience I intended to create. Since it was such a small project, this writeup will be equally small as there were not a lot of intended emotions beyond curiosity.

Approaching

Slight curiosity. They would see two white LEDs and a few components.

During

Interest, puzzlement. Coming close would prompt the device to change its colors to green. As the user experiments, they’d find that waving a hand changes the color to yellow and touching it would turn it red irreversibly. Leaving and coming back only makes it change to white as they are at a distance. It’s not until I explain that they have made the device upset and must apologize through the use my phone’s bluetooth connection does the device turn green and yellow again.

After

Satisfaction of the slight curiosity. It is a small device with small features to be discovered.

Outer Wilds

Fri, 17 Apr 2015 00:00:00 +0000

I recently heard about and played a game called Outer Wilds. It’s a free-to-play title described as an open-world adventure in space and it has already become one of my favorite games for how well it’s designed its experience.

Warning: This game does not deserve to have a single piece of it spoiled. Do not read before playing, it’s not a long game

The game didn’t seem all that great at first. With sub-par graphics and a oddly small starting world, it didn’t look like something I was going to spend a lot of time enjoying. The first task asked of me was to go retrieve a launch code, which was a simple first task. Sometimes games give you something easy to force you to learn the ropes and explore a bit, and this was exactly what this quest did. I walked around, talked to some village people, did the tutorials, and went to the museum where the launch code waited. The museum was interesting, it detailed this world’s history and it’s discoveries. It told of creatures they saw, artifacts they found, and some space-related scientific theories that matched our own like how the sun is expected to one day explode. Even after I got in my first space ship, I didn’t think it was great. And then, out of nowhere, while exploring the comet that circled around the solar system, there was a flash of red and I died.

Questions

At first I was rather confused. I kind of brushed off the death as my fault though. At the time, I was inside some weird blue crystal thing being knocked around by what I could only assume was gravity, but the red flash was still inexplicable. When I spawned back on the beginning planet, I went straight for my ship almost instinctively. I didn’t even talk to the guy who gave me my first task, I just entered the launch code and was about to go on my way when the guy stopped me. He asked “How’d you already know the code?” or something along those lines. I thought that was kind of neat. Not a lot of games even acknowledge death in canon. And with that, I thought no more of it.

In my second life, I spent the majority of my time exploring some desert planets closest to the sun. For context, this was actually 2 planets orbiting each other called the Hourglass Twins. In my last life I saw through my telescope that one was covered with sand and the other looked like rocks and plants. This time, when I came over to visit, I saw a huge funnel of sand flowing from one planet to the other, filling the rock planet. I thought it was odd, but I was more interested in a weird blue structure I had found, which was quickly being buried. Then, strangely, gravity started to shift. I looked up to see the sun expanding rapidly and fraying apart. It was exploding, then there was a flash of red and I died. That’s when I realized what killed me last time was the sun dying, and it was supposed to happen. After that I was so full of questions. How was I alive again? How come time was moving so fast? I visited the museum again just to be sure, and as I expected the exhibit on the sun’s death said it wasn’t expected for millions of years.

With questions unanswered, I went back onboard my ship. I took a moment to go to it’s computer, which logs information about the planets you visit and fortunately it had kept the data on planets I had visited in previous lives. Going over the information about the desert planets, I noticed that it said “Spontaneous sand transfer occurs once every 100 years,” which further piqued my interest, as it went along with my thinking that time was moving my much more quickly than it seemed. This continued to be backed up when I visited more and more planets, discovering that almost all of them had some sort of time-related mechanism that was each going off during my explorations, and resetting as I died. So I theorized that something was forcing this universe to be stuck in a loop of time, and I had the strongest urge to figure out what it was.

Mysteries

So with that, I was on a quest all my own. But the game was ready. Each planet had a secret to find, a piece to the puzzle of what was going on in this universe. I spent a few hours exploring around, looking for the remains of a past civilization. Each piece told a part of the story through vaguely drawn pictures. However, I didn’t make sense until I found the final piece hidden within the Dark Bramble, a foggy planet inhabited by massive anglerfish which hunt down any unsuspecting travellers. It was a terrifying place, so obviously I left it for last.

Discovery

After coming to terms with my fears and a lot of time searching, I finally found something that stuck out from the fog and let me to the final piece of the puzzle. And with that, my curiosity was (mostly) satiated. Up until that point, I was constantly finding more questions than answers, but then suddenly so many were fulfilled. I’m kind of glad that I still have questions though, it leaves me something to look for should I come back or if I hear of any updates.

The best part though? The only task this game gave me was to go fetch those launch codes at the beginning of the game. The rest of it, every question I had and goal I sought was all my own drive. That is the mark of a well crafted experience, when nothing is written out explicitly, but the player finds what to do anyway and wants to do it.

Even still, despite not actively guiding the player in any way, the game designers were totally prepared at each leg of the player’s journey. They knew exactly where the player would go and when, so they designed the game around that. It is so refreshing to see since too many games I’ve played have done the reverse where an experience is crafted, and the player’s journey is fit to the experience.

Working with RAIN (Unity3D)

Wed, 15 Apr 2015 00:00:00 +0000

For a course I’m in, we’ve been covering the topic of behaviour trees for AI in games. They are quite an interesting topic, and I was excited to implement them. However, I was disappointed to find all the most popular behaviour tree implementations in Unity3D cost >$60, which I was unwilling to pay. My professor also felt the same way, as he couldn’t find any free implementations either.

So, as I was preparing to make my own implementation, I came across a slightly less popular behaviour tree implementation called RAIN. At first I was relieved. Before that discovery I was getting ready to write a whole UI, which is no small task. I also found that this tool was used in some titles that I had heard of, namely SUPERHOT and Among the Sleep, so I thought it was going to be great. But unfortunately after working with it, I came up with far more problems than progress.

First of all, the documentation for RAIN was shoddy and full of holes, making the whole process exponentially more difficult. From what I could understand, it seemed like RAIN wanted its users to only use functions built into RAIN. This included detection of objects and movement, which were pretty much the only things I wanted to use. This would have been fine, however despite several hours of experimentation and research, I could not find what I had done wrong which separated my tests from their examples.

So, to summarize, I would not recommend this. I wish I could, it has great potential, but the lack of proper and full documentation is really a huge bottleneck.

Hecklebot

Mon, 06 Apr 2015 00:00:00 +0000

Check out Hecklebot on Github

For a little while on and off (mostly off) I’ve been working on a small project called Hecklebot for a friend of mine. It’s an IRC bot written in python meant to monitor and play some games for a MisterAtomBomb who recently picked up video game streaming on Twitch. Keep in mind he didn’t ask for this, my motivation was mostly just boredom instead.

To preface, MisterAtomBomb’s “tagline” of sorts used to be ‘come by and heckle me.’ So in the spirit of that, Hecklebot’s original function was just randomly spitting out not-very-insulting insults, kinda just fun ones for the sake of laughs, nothing truely mean-spirited. And since it was so small and because it was my first project in python, it was originally written all in one file. That quickly became a problem, but I fixed that despite needing to get used to pythons foreign-to-me variable scoping (specifically requiring self., which got annoying)

Over time and against my expectations, MisterAtomBomb and others actually started liking the idea and started requesting others. Since I had a decent amount of free-time at the time, I took them as challenges. Some of these features include adding FAQ commands at runtime, The biggest and so far most popular feature was King Of the Hill, where viewers type !kingofthehill into the chat to roll to become the reigning king. There really is no reward for being king except for if someone else types !kingofthehill and fails to roll >10, the current king is praised.

I find it’s a fun feature. One of the biggest pitfalls of Twitch is a lack of interactivity. Some streamers try to read chat and talk, but it often seems like a burden to manage that plus play the game. TwitchPlaysPokemon enlightened me to the possibilty of Twitch-chat gaming and while kingofthehill may not be of that magnitude, it still adds a degree of play to the viewers. Plus, it encourages people to talk and interact where they may not otherwise, since there is no penalty.

Hecklebot has mostly fallen on the backburner for now though. It’s mostly stable with some rare network-related crashes that I havent quite figured out. I keep it running on a server computer I have and check on it whenever I notice MisterAtomBomb is streaming. However, I don’t have a lot of plans to improve it, so until that changes I probably won’t be touching the project.

Javascript Space Game

Fri, 03 Apr 2015 00:00:00 +0000

My Web330 course assigned a project which had the premise of “A game or experience written with the Javascript canvas.” I chose to make a game and my idea was a gravity platformer.

You can check it out here

There’s as much of a writeup as I could manage here which details some gameplay aspects and details.

Originally, like pretty much all Web330 projects, we are expected to host them on our university’s student server. However, it can be slow and has a very storage size limit. Halfway through the project I discovered I could host it through Github pages. I thought maybe it’d be a nice idea since all I’d need to do to preview things would be to push to the repository. It came with some issues though, since the page complaining about cross-domain resources. I discovered this was because the resource-loading code my professor provided used XHR to load things, and Github pages hosted the page under the domain githubpreview.com or something while the resources were still hosted on github.com, and that differing domain caused a lot of havoc. Mostly because I didn’t know much about XHR and had to do a lot of research.

Overall the project was rather enjoyable. Something very small and without much expected of it was refreshing to work on. And while it remained small, it is still very extensible should I choose to make something more of it in the future. The final levels were rather rushed though, because I didn’t have a lot of ideas and there was a requirement of 4 levels minimum. If I had more time and drive to work on it, I would add more diversity to things and actual challenges. I left a lot of room to add character into the game through images and the info box for each planet, but again I didn’t have any ideas at the time, so that will be something I’ll work on later if I choose to.

HFOSS- Education Project Team Proposal

Wed, 01 Apr 2015 07:30:00 +0000

A team proposal for the creation of an educational game built on the OLPC XO laptops and Sugar Labs

List Your Other Team Members Below:

direkitteh : lkd8070@rit.education
milistisia2 : bxc4440@rit.edu
NumbuhFour : fad4470@rit.edu
holtr94 : rgh7614@rit.edu

Which Project Did Your Team Choose?

Mini Game Mayhem

2-liner description of the project?

An application similar to Luminosity with a collection of math-themed games to teach various topics of the fourth grade curriculum. Users receive scores for their performance and can improve over time.

What will each team member’s role be?

Everyone will make their own very small minigames and assist in others where needed.

Source Code Repository URL?

Github: https://github.com/milistisia2/MiniGameMayhem
Sugar labs build: https://github.com/sugarlabs/sugar-build
Sugarizer: https://github.com/llaske/Sugarizer

List your upstream Mentors below:

To be determined

How will you communicate with them? (i.e. IRC Channel, Email Addresss, mail lists, issue trackers, etc…)

IRC channel
Email sugar-devel mail list

What are the easy parts?

Adjusting to sugar lab development environment
Getting in contact with sugar lab developers
Testing

What are the hard parts?

Creating multiple small, fun games that teach concepts
Having enough functional content
Getting everything done in six weeks
Avoiding adding too many features that will make it too much work to complete, while still keeping it interesting
Masking the lessons under themes rather than math

How will you overcome both?

Staying in constant contact with other team members
Coming up with ideas early
Building prototypes early
Keeping the scope as small as possible

A Week with an XO Laptop

Wed, 01 Apr 2015 00:00:00 +0000

So last week was my spring break and I decided to go home for the duration. However, I only have a desktop computer… my laptop is only a frisbee now.

However, I had a huge physical media project due this week, and it required a lot of sewing. Like, 6 yards of sewing. As a result, a personal computer wasn’t all that necessary and would probably just feed my habit of procrastinating. I thought “great, I can just do some Arduino programming with this. It can probably handle at least that.” So I got to spend some personal time with this low-power laptop.

I learned a little bit about it. I had it set to GNU mode (rather than the educational and simple SugarLabs mode) so I could actually use it for some work. I had to install Java and the Arduino IDE, but I’m figuring we’ll do a wipe of these computers at the end of the semester. If not I’ll uninstall them myself. I don’t have a whole lot of experience with unix operating systems and their terminals, and absolutely none with Fedora in-particular, but I managed.

I didn’t do a lot with the laptop in terms of testing it, but it ran fine with the Arduino IDE, a web browser with a few documentation tabs, and an SSH client open. I did notice however that the power to USB ports is cut off if the mouse is not moving constantly, which was interesting. I can see some reasoning behind this, the laptop is designed to be used in places where power can be scarce, but it made testing a USB-powered Arduino annoying. The keyboard was also an unrelenting hassle. I thought I would get used to the tiny rubber buttons intended for gradeschooler’s fingers, but such was unfortunately not the case.

Overall however, I was rather impressed how well it handled. It was rarely slow and never froze. I came into it thinking all I could do was write text files in hopes I could actually do debugging when I returned to school, but not needing to wait certainly helped the project. I hope the OLPC initiative is doing well, I hadn’t heard anything about it in 4 years and had completely forgotten about it until my HFOSS course. I really feel these laptops could make a difference.

Stuff Incoming!

Wed, 01 Apr 2015 00:00:00 +0000

After not having access to my wordpress blog for about 2 weeks due to both my forgetfullness and stubornness, a lot of things have built up. Many projects have picked those particular weeks to show their faces so hopefully I can talk about some of those things.

Also, there will probably be at least one test-post and many temporary errors. The down side of using Github Pages (until I setup Jekyll locally) is that I can’t test things without committing and pushing. The worse thing is that pages are only visible on the master branch, and I am well aware that testing on the master branch is blasphemy at best… Maybe rebasing could be a solution? But I don’t know enough about that subject yet to know.

Physical Media Project2

Wed, 01 Apr 2015 00:00:00 +0000

Premise:

A interactive experience built into a glove. Using an array of neopixels, a vibration motor, and an accelerometer the idea was to make a glove covered in RGB LEDs light the LEDs on facing up a different color than those facing down. And the vibration motor would power up more as the glove was turned upside-down.

It was a pretty simple and not very useful idea, but I wanted to get away from utility for this project and just make an experience.

Building

I planned this out in two parts. A watch-like container and the glove.

The Watch

So the watch was by far my favorite part. I was using an old model Lilypad Arduino which is designed to be small and used with conductive thread. However, I hate the permanence that sewing to the board entails. I wanted to be able to use the board for other projects without permanently dismantling this one. My solution was to design and print a container for the board that would allow me to connect things to it without being permanent.

After a few iterations trying to get the sizing right, the fit was perfect. My plan was to lay the arduino inside, use copper tape on a ring of foam aligned with the pin-pads of the Lilypad, then click on a cap to apply pressure to the foam and arduino guaranteeing a solid connection.

The only real issue was the fact that I still needed to connect the pins to things… This was why I put a cross bar through the hole on top of the watch. That way I could solder small wires to the copper-tape pads and wire them through the crossbar and out to where they are needed. This presented problems when it came to removing the cap, since some wires were connected to the base of the watch, but it was the only solution I could come up with and if I gave the wires enough slack everything turned out fine.

The Glove

Since I didn’t have any gloves to spare, I had to make one (or at least most of one) using materials I had. Which was leather. Which was not a great idea.

I only made what I needed, which was basically a strap around the palm with a smaller strap to hold it in place. It held very well and was pretty comfortable. However, what I didn’t think about was that I had to sew through this stuff. I have some leatherworking tools and needles, but while that made things easier, it did not make things enjoyable.

The Lights

For the lights I chose Neopixels. Neopixels are RGB LEDs which which are strung in a line transferring data so that they only occupy 1 pin on the arduino. This was something I had wished for since highschool.

However, the website was sold out of the Neopixels prefitted with sewing pads, but they had a lot of unmodified pixels for like a 3rd of the price so I figured I could solder some pads on to those as needed. Plus the prefitted ones were a lot bigger.

I had some trouble getting them to work. As a result I burned out 3 of them, but fortunately I bought like 10 extra (they were so cheap). It turns out the documentation on which pin is which got me confused and I had it backwards. In my defence the image was looked like the pixel both flipped and not.

My arangement was columns of 3 around the hand for a total of 18 (minus one which had its spot replaced by the accelerometer)

They worked really well, and were each as bright as a flashlight. However, my dinky little pads made from curled wire were not very strong and broke off a few times during soldering and during sewing (sometimes the solder-pad on the LED broke off too)

The Sewing

As mentioned in another post I didn’t have a lot to do over my spring break besides sew.

It was a tedious process but I had a lot of free time. My biggest concern was making sure no wires were touching. The leather was useful since I could needle deeper into the leather to avoid unintentional, but this didn’t stop everything. There were still a few places where the ends of wires got free enough to bend over and touch another wire.

The Folly

So, by the end of my spring break, I had a nearly complete product. Almost everything was working individually, the only thing left to do was make the actual functionallity and combine the LEDs and accelerometer together through code. Unforunately, on the Sunday before the deadline, the accelerometer stopped respoding properly. After a few hours of tinkering to no avail, I ended up jerry-rigging a sonar distance sensor to make something completely different but functional.

My new idea was to make a glove that would indicate through lights and vibration whenever something got too close.

The lights would go from red to yellow to green whenever something was within about 20” and getting closer. If an object was detected closer than about 6” the vibration motor would start, which caused some issues with the sonar sensor so it had to dampened significantly.

This was the final product, not the prettiest thing and definitely not the most robust, but it worked most of the time.

Postmortem

So, from this my most important lesson is probably not to skimp out on materials. I ran out of a lot of things (conductive thread, insulating paint, a not-leather glove) and didn’t bother getting a replacement but instead improvised. However, I do enjoy having a good, working design for a Lilypad case. I foresee that being very useful in the future.

Blog Migration

Mon, 30 Mar 2015 00:00:00 +0000

So I’ve decided to jump ship from Wordpress to Github Pages as a blog after discovering Jekyll… and losing access to my old blog. This particular blog is a derivative if Barry Clark’s Jekyll Now repository, which allowed me to set up the most basic things with ease.

At first glance Jekyll seemed rather intense, but after only a couple hours I’m understanding a majority of it. I haven’t found all the details yet, like where certain things are defined or organized, but I haven’t done enough digging to say that information is unavailable. Either way Jekyll looks like it will be a fun thing to experiment with.

If all goes well you should see prior posts moved over retroactively, so the posts will keep their respective post-dates. I’d like to get some features that Wordpress provided (tags and comments namely) implemented too, but after my very brief reading it sounds like Github Pages don’t allow certain features of Jekyll which would enable the features I would like. If that’s true (again, I may be wrong as it’s only been a couple hours) I’ll end up doing the Jekyll compiling/building/whateveritscalled locally and push the generated pages to Github instead.

HFOSS - Curriculum Project Ideas

Wed, 18 Mar 2015 00:00:00 +0000

This is a brief list of possible ideas for the HFOSS Curriculum project, where the students team up and attempt to create and educational game for students grade 4 and under using an XO laptop.

Interesting units:

Algebraic thinking with variables, geometry, and data representation.

Dull units:

Grammar, writing, anything English.

Mechanic Ideas:

(Algebra) Take buckets (variables) from equations, fill them to the right amount, and return them to the equation to make the equation true.
(Data) Shoot a slingshot arrows at apples that the ducks who are at the correct spot on the graph
(Geometry) Control a snake avoiding obstacles. Pause time to make turns at specific angles. Forming shapes, parallel lines, or perpendicular lines earns points.

Community Architecture Assignment for HFOSS

Mon, 09 Mar 2015 00:00:00 +0000

Go here for now!

Personal answers:

Is this the kind of structure you would enjoy working in? Why or why not?

Not entirely. I would rather there be a solid amount of readable, accessible documentation going in. People, while able to answer any question, are not always available and may not have the answer you are looking for or even have the wrong answer. Though the social structure of no established leaders is rather appealing.

HFOSS Community Architecture Project Proposal

Wed, 04 Mar 2015 00:00:00 +0000

COMMARCH TEAM PROPOSAL

Which project did your team choose?

Dolphin Nintendo Emulator

2-liner description of the project?

An emulator for two recent Nintendo video game consoles: Gamecube and the Wii. It allows PC gamers to enjoy games for these two consoles in full HD (1080p) with several enhancements: compatibility with all PC controllers, turbo speed, networked multiplayer, and more.

What will each team member’s role be?

NumbuhFour – Mentor communications
milistisia2 – Technical and Production editor
mellolikejello – Design lead

Source code repository URL? Github Repo

List your upstream Mentor’s below:

HdKr

Many/any devs on #dolphin-emu @ freenode

How will you communicate with them? (i.e. IRC Channel, Email Addresss, mail lists, issue trackers, etc…)

IRC on #dolphin-emu any time except 1-6am CST (2am to 7am EST)

What are the easy parts?

Contacting devs (hopefully)
Accessing history (because github)
Finding issues/bugs that have arisen

What are the hard parts?

Filling this out in time!
Calculating the Callaway Coefficient of Fail for the project
Discovering the structure and hierarchy of official releases and patches

How will you overcome both?

Communicating early and often to provide developers with ample time to respond/direct us in the right direction
Hopefully be able to speak with a dev that has been with the project for a long time that can speak of any large changes to the way the project was managed.
Use filters to search closed issues on github to find relevant information about bugs and bugfixes.

XO Laptop Smoke Test

Wed, 25 Feb 2015 00:00:00 +0000

So for my HFOSS course, we were given XO laptops. I’m not sure why yet, but it sure is cool.

The first assignment is to perform a smoke test to check all the features for bugs or breaks. After going through what I could, all the hardware seems functional. Without another XO to communicate with some tests are impossible, but I have no reason to believe its broken. Can’t wait to see what we do with this thing. I don’t have a laptop myself since the Macbook Air my uncle gave has made a full conversion into nothing more than an aluminum frisbee, so I can probably find some uses for it myself.

Physical Computing: Project1 Writeup

Fri, 20 Feb 2015 00:00:00 +0000

Experience taxonomy writeup here

Premise: Using an arduino, build a simple interactive machine that utilizes a minimum of three sensors. My project idea was to create a character with two RGB LEDs for eyes. The sensors I used were a ultrasonic rangefinder, accelerometer, a bluetooth radio, and a potentiometer (just to dim the LEDs).

The character, nicknamed Fido, interacts by showing its current emotion with the color of its eyes. Green means happy, red means mad, and white means bored.

Whenever someone is within about 30 cm of the rangefinder, Fido registers as happy. Otherwise, Fido gets bored. If Fido is shaken, he gets mad until someone apologizes. Apologies are input by typing “sorry” through a bluetooth connection. And lastly, if someone waves their hand in front of his face (rangefinder), he blinks yellow and says hello.

Overall it was a pretty simple project, the first feature I worked on was the detection of presence with the rangefinder. My rangefinder had several different options for input including analog, PWM, and TX/RX. I couldn’t find any good documentation for TX/RX, and PWM yielded jumpy and ugly numbers, so I went with analog. The bluetooth module didn’t cause many issues, it just had a TX/RX that would report any messages received over the radio, though it did have a protocol I had to look into. The module was something I had laying around at home from previous experiments, so I had some experience with it going in. The accelerometer was much the same in that I had no issues, again it was something I had messed around with and could get to work with ease.

First Bugfix!

Fri, 20 Feb 2015 00:00:00 +0000

I have just gotten done sending in my first patch to an open-source project and man am I relieved. Looking at this goal a week ago I thought it would be fun, but the more I thought about it and the more I tried to do this the more daunting the task became. I knew it wouldn’t be easy, but the full weight of the task didn’t hit me until I realized that even once I found a project (one I understood in a language I knew), I would have to build a programmer’s map in my head detailed enough to find a file causing a given bug and any associated files that might be affected by changes. And that had me terrified. Debugging code can already be a challenge, but picking up someone else’s project, especially a project that could have been accumulating code for years, would require learning everything that the project does as you search for where a problem could be. It was not something I thought could be well done in a week.

After many hours of searching issue listings, FIXMEs, and TODOs I came across a simple TODO in openstreetmap‘s website repository that just asked that a save button change to “publish” when making a new diary and “save” when editing. After finally getting a copy of the project up and running on my box, I then realized that ruby on rails was absolute greek to me. But I powered through. Mostly motivated by the fact that I successfully setup and ran the repo, (I had tried and failed with 2 other projects and did not want to go through it again), I figured out the basic syntax of rails, at least enough to fix the issue. I am still not sure if what I did was as efficient or professional as it could be, but as I filled in the pull-request, I figured that after all my stressing, that could be something for upstream to decide. And with that thought I realized that it didn’t really matter if I didn’t understand the whole project and ever facet of it, I just needed to understand enough to contribute. If there was an issue, someone more experienced will step in later on and improve what I had done, and that’s just how open-source development works.

I would like to keep doing this. When I first heard about it I got kind of excited as though it could be something I could just do here and there in my free time. I probably can’t expect to be that carefree about it, but now it’s something that I don’t look at as though the weight of the entire project would rest on my shoulders should I choose to take part. I’ll try to browse Github a bit more from now on and see if there isn’t anything I can do to help some people.

Here’s the Pull Request by the way.

HFOSS Quiz

Thu, 12 Feb 2015 00:00:00 +0000

This is a post answering questions for a class I’m taking. Not much more to say besides that.

In Chapter 3 of Stephen Weber’s The Success of Open Source, there was a listing of eight “General Principles” contained within the chapter. Last week, we discussed in class the five pillars of “The Open Source Way.”

What are the titles of each Pillar?
- Open Exchange
- Participation
- Rapid Prototyping
- Meritocracy
- Community
What are the titles of each General Principle?
- Make it Interesting and Make Sure it Happens
- Scratch an Itch
- Minimize How Many Times You Have to Reinvent the Wheel
- Solve Problems Through Parallel Work Processes Whenever Possible
- Leverage the Law of Large Numbers
- Document What You Do
- Release Early and Release Often
- Talk a Lot
What are the similarities between Weber’s eight principles, and the five pillars? They both believe that the key to open source is making things open and accessible to anyone who wants to contribute.
What are the differences? Weber’s principals are more focused on the people who contribute to open-source works and what they need to consider, while the principles are more of a definition of what an open-source project is.
Who’s “keen analysis” did Weber “Draw Heavily” upon?” Eric S. Raymond
What was the title of this “keen analysis?” The Cathedral and the Bazaar
Where can this keen analysis be found? Right here!

HFOSS: Lit Review 1

Mon, 09 Feb 2015 00:00:00 +0000

This is a literature review of What Is Open Source by Steve Weber.

It tells a brief history of open source software, how it started and how it has developed. It talks about how important it is to the creation of things that everyone who experiences a thing should have an unburdened means of improving that thing because everyone has the potential to see a different problem or have better solutions.

The Good: It is a very detailed reading while also being written in a way anyone should be able to understand. It puts a programmer’s perspective into view for those who don’t usually see things that same way. I don’t think I’ve ever read anything that so accurately put into words how programmers behave and see differently from an average person. I also quite like how it

The Bad: It is a very long read, covering many subjects in lengths that I didn’t feel was necessary.

Questions: -Is there any project that shouldn’t be open-source? -Is there any way to make projects be both open-source and for a profit or is that oxymoronic? Even though the reading says that the source should be unobstructed, do all projects need to be completely unobstructed to benefit from the open-source mentality? -Could the open-source community be considered ‘too trusting’? In my experience, bugs and errors aren’t always obvious and the cause can be even less so coming from sections of code seemingly unrelated. Without strict rules, how often do those problems sneak in?

Wednesday: Shader Success

Thu, 05 Feb 2015 00:00:00 +0000

Even after a few hours of tinkering, my selection shader has managed to stay stable, which is a relief even though I can’t quite pin down how Unity deals with shader properties since it seems to ignore the default value sometimes, and I haven’t found a pattern. Still, I’m starting to get the hang of shaders in general and even made it slightly animated. Though since I’m not sure how most animated shaders work, I don’t know if they way I’m implementing it is ‘standard’ or ‘efficient’ or anything. But, it works. All I did was use shader globals to access a _Timer counter, and then increment that variable via script. It looks kinda nice.

I also finally made the project into a git repo. I should have done it from the beginning but I didn’t think I’d really work on it for more than a day at the time. However, some of the files are being rejected from GitHub because they are too big. I’ll get that fixed tomorrow and post a link.

Tuesday: Shaders Aren't That Hard, Unity's UI Might Be.

Thu, 05 Feb 2015 00:00:00 +0000

After spending a good chunk of the day playing with and learning Unity’s shaders trying to get a CCTV refresh lines effect and an outline, I spent almost the entire rest of the day wrestling with Unity’s 4.6 UI system and learning the hard way that python can be mean. Unity’s new UI system is actually rather nice, especially compared to its old onGUI system, but there doesn’t yet seem to be any clean way to convert world coordinates to UI coordinates. World coordinates to screen coordinates work well, but unfortunately they don’t seem to be the same.

However, python was a ruthless vixen to deal with, since I am not fully familiar with how it deals with scope regarding globals. I spent far too long trying to figure out when python thinks variables are global and when they are local. Plus I think I had my first run in with incorrect whitespace character errors since that’s the only explanation I can come up with for that trouble. That was 2 hours I’ll never get back, but hopefully will never have to lose again. I wish I had set that project up on git sooner, maybe that never would have happened.

Monday: Shaders are Hard

Wed, 04 Feb 2015 00:00:00 +0000

The AI game I mentioned last week has quickly become more of an exercise in graphics rather than AI. While hung-up on not having any idea what to do to make Unity’s built-in navigation system simulate queuing, I’ve instead turned to messing with shaders, with which I have almost no experience. The concept of the game involves selecting an NPC on-screen with the mouse, so I’m trying to do some silly shader shenanigans with a second overlay camera to highlight whoever is selected. So far, it’s proven difficult. 1:00am Edit: Nevermind, this funk rocks socks.

Initial Commit

Sun, 01 Feb 2015 00:00:00 +0000

So, with a lack of any real idea of what to say, I guess this will just be a log of all the things I do and create. I already do that but in two-word bullet points in a .txt file, so now it’s gonna be at least three words per bullet point.

So, week of Jan 25th, 2015:

I decided I was gonna start following a “Don’t break the chain” ideology. I gotta work on a game for some amount every day without exception, getting a little better each day.

I started the week with an idea for a super-simple game involving a car with pistons for wheels travelling through parking-lot-traffic by running over everything in the way while avoiding anything popping up in sunroofs or hitting cop cars. It went alright with prototyping, I made it over three days using Unity’s 2D engine so I got some experience with that and its perlin noise implementation. I made the assets using gimp and I finally got my pen tablet working.

For the next few days I started working on a project inspired by my AI class. My partner and I had to come up with a simple game concept that wouldn’t require any intensive programming or graphics so we can focus on the AI alone. One of the ideas that was scraped because another was significantly better was pretending to be a crazy mall cop trying to stop thieves. So far I’ve created another prototype in Unity 3D using some basic models and textures. So far I’ve used it as a practice in UV mapping, light mapping, and baking ambient occlusion maps.

Along the way I also got distracted by my friend’s endeavor to become a daily streamer on twitch.tv. His tagline is “come by and heckle me” so I got to writing a bot that would do just that in python. I’m not to strong with python so it was great fun and super simple. Whitespace-sensitive languages are heathens though. I’m not aiming to do a lot with that, all it does is spit out a random, pre-defined ‘insult’ whenever someone types !heckleme. I put insult in quotations because the best I could come up with was “I bet you don’t even like crayons” and “your mother is a respected member of society,” but my friend is filling up that dictionary.

Lastly, I started a small project in my livingroom after missing a rather important email on one of my many email accounts. So I started looking into writing a script that will display a notification on the TV in my livingroom whenever I get one. It shouldn’t be too hard, that TV is hooked up to an ubuntu desktop that I use as a server for various things, although I plan to also attach a PIR motion-detecting sensor via an arduino so that it can tell when I enter the room to display the message. Otherwise it would either always be on the notifications screen (risking burn-in I think) or always be in screensaver. Again, a very simple project, but it still takes some time amidst everything else.

I should note I don’t foresee entries being this long every week. This week was the first of the semester(weird school) as well as a busy one relatively speaking, so future entries will probably be rather empty by comparison. Now I’ve got to go write a pull request for my HFOSS’s class Github repo, which shouldn’t be too hard (knock on wood) or worth writing about as it is a level of git I’m vaguely familiar with. I think this class will be fun though, Github and sourcing is something I’ve always been fascinated with, but never been able to master since it tends to go alongside a project that demands more attention. Now I’ve got a chance to put some time into it.

Test Post; Please Ignore (:) : colon?

Thu, 01 Jan 1970 00:00:00 +0000

This is a post dedicated to testing Jekyll capabilities with Github Pages since until I setup Jekyll locally, I cannot perform tests without pushing to the master branch

Test1: Html code for colons in title? Since a normal colon breaks Jekyll

Test2: Tables in markdown

Tables	Are	Cool
col 3 is	right-aligned	$1600
col 2 is	centered	$12
zebra stripes	are neat	$1

Title	Title2
Rawr	ASNVAK
Stuff	is
here	maybe

Title	Title2
Rawr	ASNVAK
Stuff	is
here	maybe

Poof: testinmg tables: rawr work: please —

Test3: Tables in html

Rawr	Rawr	Rawr
Rawr	Rawr	Rawr