Puff-Suck interface for fast text input

As bespoken, we took the video to show our working Puff-Suck!

It still has some kinks to iron out (as does my Morse code, this was not the first take) and more software functionality, but this is a huge step in the right direction.

Until next time,

Ana

After a few head-scratching hardware bugs, we finally connected the puff-suck switch to the Arduino Mega 2560 and got our first prototype working. Video coming soon!

Aaand we have another todo list:

• Clean up and comment code (in progress)
• Connect interface to a Leonardo so we can control the mouse and keyboard
• Implement more codes and escape sequences, perhaps custom codes

Until next time (when hopefully we will have a video and more to show you),

-Ana

In the last project log, we briefly mentioned that we found an existing product that is similar to ours.  

We had searched before we started our project and didn't find anything like it.  But searching for our own project from another computer, brought it up when we misspelled some term.  Searching for morse puff auck interface brought up this "Morse Codes for Computer Access" page.

Let's have a look at the differences between our project and the TandemMaster.

We've never seen a TandemMaster but from the description it seems to be a similar device that accepts switch inputs and generates Morse code and then emulates a USB keyboard and mouse.  It costs $500 + $20 shipping.

The switches you need to connect to it can be obtained from multiple sources.  Some we've seen for $160, some more than $200.

We think they all work very good but they seem expensive to us.

Our project includes both the switch assembly and the electronics that generate Morse code and then the text and control commands.

Being open source, it can be configured to also emulate a keyboard and mouse for a computer; it can connect to a smart-phone/tablet through Bluetooth or it can be integrated in a more complex embedded system for mobility/portability.

It can be modified to be compatible with the same codes a user may have already learned.

Other/any switches can be used instead of the presented puff-suck switch.

The cost to make this complete system should be below $50.

The tube and membrane switch assembly is not too difficult to make, and we may eventually provide a 3D printable version.

Though our project shares many similarities with the TandemMaster, it is different!

-Ana

We just found out that a product similar to our idea already exists and can be bought from "http://www.tandemmaster.org/".

We will discuss this in a later post as it's time to snooze now.

-Ana

Cat and I hooked up a speaker to the Arduino, and now you can hear the Morse you send!

Watch the video (sound on) here:

I've also made every time relative to each other, I'll have to test it at different speeds to be sure if it works or not.

-Ana

Currently, an LED flashes for Morse code, but visual feedback is not good enough. To Morse quickly, you need to have sound feedback. Cat and I will need to find a suitable speaker and turn it on at the same time as the LED, and I'm also working on a way to change the speed at which you Morse.

The Arduino tone() function seems to be good for our purposes, but it does use a timer, so I wrote the code and ran it without connecting the speaker, and it still seems to work fine.

-Ana

My mechanical abilities are not great, so first I tried to find the closest ready made sensor I could use.

Since it's puffing and sucking we're talking about, I started to look for pressure sensors on the Digikey web site. They don't carry EVERYTHING but they do carry A LOT of parts.

They appear to sell 29,562 kinds of pressure sensors and/or transducers (some may be the same part but packaged differently) but we can quickly filter down to just a few when we select "Active", "In stock" (only 2,120 remaining)  and then the two lowest available "bipolar" (+ and -) sensitivities because we're human and don't have pumps for lungs: +/-0.36PSI and +/-0.72PSI.

Only five left and the cheapest is more than $50 so I gave up for now as too expensive but might get back to it if I find nothing else works better.

What's left is to try to make a sensor.

Since it has to be "bipolar" (puffing increases pressure and sucking reduces it) I kept wondering how I could modify a small balloon that would work for puffing, to also work for sucking.

Something springy could hold it into a half-inflated state (is that how Whoopee Cushions work?) and it would grow (closing one set of contacts) when puffed and shrink (closing another set) when sucked.

I couldn't find any way to make this small enough with my limited means, but something could be designed that could be 3D-printed so it's not a dead end.

For now, I had another idea: suspend an elastic flat membrane in a small cavity that has a tube attached to one side and may be somewhat (we'll see later) open on the other side.

When puffed or sucked, the membrane would move one way or another and block the light between an LED and a photo-sensor on either side of the membrane.

Said and done; I'll be back soon, with another cartoon build log.

No tube connected yet, but we're well on our way!

All bugs mentioned in the previous post have been fixed, and you can see the code as of now here. I still have some commenting to do, but it's not the ugliest, and works good (so far!). 

The problem with "36" printing instead of "#" (for non-existent characters) was easily solved by changing pMark's type from char to byte.

The second problem (speed changing erratically) was caused by some code I forgot to remove. It was supposed to automatically detect the user's speed, however it wouldn't work for a dual-lever paddle.

The third problem (random DIT's) was much more troublesome. I "debugged" (putting LOTS of print statements) the code and found out it lied in the switch/case statement. I tried to figure out the problem... I really did. In the end I just changed it into a series of IFs and ELSE IFs, hoped for the best, and tah dah! It works.

I'll have to revisit the code later and attempt to pinpoint the problem, as I prefer to not leave things unsolved.

Here is the morsing in action (The light labeled 'L' flashes morse code, and TX flashes when a character is sent):

It's not the clearest video, but, I did what I could. Characters are printed to the serial port right after being morsed!

-Ana

The programming is almost done (and VERY messy, I'm going to have to clean it up), and I've began testing with an Arduino Mega 2560.

Some bugs I've noted:

• 90% of the time, when you morse a character incorrectly, it will print "36".
• After a few characters are sent, the morsing speed begins changing erratically.
• Worst of all, every half a second or so, a "DIT"/"DOT" is sent without any action taken by the user.

Hopefully, they are all minor problems. I believe the first problem lies here:

void printPunctuation()
{
  byte pMark = '#'; // Just in case nothing matches
  if (myNum == 71)
    pMark = ':';
  if (myNum == 76)
    pMark = ',';
  if (myNum == 84)
    pMark = '!';
  if (myNum == 94)
    pMark = '-';
  if (myNum == 101)
    pMark = '@';
  if (myNum == 106)
    pMark = '.';
  if (myNum == 115)
    pMark = '?';
  Serial.print(pMark);
}

The second and third issues are more of a mystery, and I need to make all the wait times for sending morse proportional, but we're getting there :)

-Ana

Our project is made of two main parts:

- a puff-suck sensor that translates the puffing-and-sucking actions into electrical signals,

- a micro-controller system (like an Arduino) that interprets the signals from the sensor into humanly readable text,commands or other information.

On this occasion, my (Cat's) part is the sensor, and Ana does the programming

I've been considering many ways to implement the mechanical part of the puff-suck sensor that would be suitable for Morse code input.

I've known Morse code for a long time and it was easy to imagine puffing-and-sucking it, but a few requirements have to be met to make it efficient (I have no idea if the same requirements are suitable for "normal" puff-suck switches):

- It has to have three states: puffed, sucked, neither

- It has to be able to switch fast between the states

- It has to work with relatively small volume of air

- It has to be able to keep a state for a while (up to a few seconds if slow) without effort

- Ideally it would provide some feedback

Next time I'll write about some options I considered and some I discarded, at least to start with.

Cat