Friday, August 25, 2017

Meet The Grove Shield

The Grove Shield is a particularly useful tool for blind or sighted beginners working with Arduino. It’s awesome for quick proof-of-concept projects, introductory Arduino workshops, and for anyone with impaired dexterity or fine motor control issues. The main benefit of the Grove Shield and its family of components is that it saves you from the hassle of wiring each component to ground, power, and its respective input or output pins, simplifying project construction significantly. It also ensures solid connections with snugly fitting plugs and sockets. Only one kind of cable is used for all components, and the plugs have a clear orientation that prevents you from plugging them in backwards.

The Grove Shield from Seeed Studios piggybacks on the Arduino Uno or similar controller’s and allows easy connection to a large number of sensors, actuators, and communication options. In addition to the standard headers, the Grove Shield includes 16 sockets, all of which use the same four-conductor ribbon cables to connect Grove components to analog, digital, I2C, and UART pins on the Arduino. Each socket includes connections to ground and power, so wiring up projects becomes extremely easy. The Grove Shield also includes a Voltage Switch to switch between 5V and 3.3V power, a reset button duplicating the one on the Arduino, and the standard set of 6 male ISP pins. Oh, yeah – it also includes an LED if you’re in to that sort of thing.

A very nice Grove starter kit can be ordered from Amazon for about $45, although it does include a relatively expensive LCD component which blind makers won’t have much use for. Other than that, the starter kit is great and includes a nice variety of components. Additional components can be ordered from Amazon or from Seeed Studios. Note that the starter kit does not include an Arduino.

When you receive your Grove Shield the pins on the back of the board are embedded in a foam pad to protect them from being bent. While getting oriented to the shield we recommend leaving the board attached to the foam or seating the shield on an Arduino. The pins on the bottom of the shield are delicate, and whenever you connect or disconnect the shield from an Arduino you should always be careful to avoid bending pins.

Orienting to the Grove Shield

With the Grove shield and its foam pad on a table in front of you, rotate the board so the Voltage switch and reset buttons are at the top-left corner, and the standard headers run vertically along the left and right edges of the board. The 6 male ISP pins (looking something like a sideways braille cell) should be toward you in the middle of the bottom edge of the shield.

The Voltage Switch faces left at the top edge of the left side of the shield. When the switch is set toward you the shield is set to use 5V power supply. When the switch is set away from you the board receives 3.3V. We have found this switch to be a little delicate, so handle it with care. If it breaks, the board is broken. Just below the switch on the left edge of the board is the reset button (and the LED). Along the top edge of the shield are the 4 analog sockets. located between the two standard headers are 12 other sockets arranged in a 3X4 grid like a telephone keypad.

Analog Sockets

The analog sockets line the top edge of the shield. From left to right they are A0, A1, A2, and A3.

I2C Sockets

The I2C sockets are the left-most column of 4 in the array of 12 sockets. Using the telephone keypad analogy, the I2C sockets correspond to 1, 4, 7, and *.

Digital and UART Sockets

The digital sockets are the top-three sockets in the right-hand column of the main group of twelve, as well as the center column of 4 sockets. The UART socket which uses digital pins 0 and 1 is the bottom right socket in the group of twelve (the pound sign in our keypad analogy).

Moving up the column from the UART socket, the sockets are D2, D3, and D4. Starting with the bottom-center socket and moving up, sockets are D5, D6, D7, and D8.

Primary and Secondary Connections

Somewhat confusingly, each analog and digital socket actually connect to two different pins – a primary and a secondary. Most components only use one of these connections, but some use both. Above we have listed only the primary connections, but each socket also connects to the next pin as a secondary connection. In other words, the secondary connection for A0 is A1, the secondary connection for A1 is A2, and so on. The digital connections follow the same pattern, with the secondary connection for D2 being D3, etc. In general, you only need to worry about the primary connections.

Orientation to Grove Sockets and Plugs

All the Grove sockets have a basic rectangular profile ( approximately 1/2X1/4 inch), and they are all oriented on the board with the longer axis running from left to right. Each socket has a notch approximately ¼ inch wide cut in the center of the two longer sides. One side has a much deeper notch than the other, and we will call the side with the deeper notch the “front” of the socket. You may have already noticed that the analog sockets are rotated at 90 degrees to the other 12 sockets. In other words, analog sockets have their fronts facing up with plugs entering from the edge of the board, while the other twelve have their fronts facing you with plugs entering from above. Each Grove component also has the exact same socket with a front and back.

The ribbon cables that connect the Grove components to the shield have an identical plug at each end. Each plug has a flat side which goes toward the back of the socket, and a side with two long parallel ridges which goes toward the front of the socket. At the very end of each plug are four holes which connect with corresponding pins inside the sockets. These holes correspond to the four wires of the ribbon cable. When the cable is plugged in to a socket with the front of the socket facing you, the wires, from left to right are primary pin, secondary pin, power, and ground, and are colored yellow, white, red, and black respectively. This is extremely useful to know if you want to integrate Grove and non-Grove components.

Friday, October 7, 2016

Bay Area Blind Arduino Monthly Meetup

The Blind Arduino Project is delighted to announce the kickoff of the Bay Area Blind Arduino Monthly Meetup -- BABAMM!! Beginning on October 8, 2016, Bay Area makers, both blind and sighted, will gather on the second Saturday of every month to construct, code, converse, and collaborate on Arduino and Arduino-ish projects. Bring your own or plan to join with others to teach and learn in a supportive and friendly environment focusing on empowering blind and visually-impaired people to make their own accessible stuff with Arduino.

If you are a blind maker working on a project, or if you are blind or sighted and have an interest in learning more about how blind and visually-impaired makers build stuff with Arduino, we invite you to bring your projects and your passion to BABAMM. We welcome beginners and masters alike, and are eager to learn and share our knowledge about all things Blind Arduino!

Meetups take place in the Innovation Lab at the LightHouse in San Francisco from 1:00 to 5:00 on the second Saturday of every month. Space is not unlimited, so it is really helpful to have an idea of how many people to expect. If you’re interested or think you might want to come, we would really appreciate it if you would sign up for the Bay Area Blind Arduino Monthly Meetup group. This makes it a lot easier for us to remind you when the meetups are happening, and to let you know about any special things that might be planned for future meetups.

Please join us for BABAMM! We look forward to crossing paths with many new and old friends as the Bay Area Blind Arduino Monthly Meetups continue to build momentum, community, and cool devices.

Tuesday, August 23, 2016

Configuring The Arduino IDE with the Java Access Bridge

Elsewhere in this blog I have discussed the relative inaccessibility of the Arduino IDE -- the free integrated development environment downloadable from Various rumors and suggestions have reached me about how it can be configured to work with the Java Access Bridge, but despite hours of effort I have never been able to do it myself.

Now, Ken Perry, blind maker, frequent advisor to the Blind Arduino Blog, and software engineer at the American Printing House for the Blind, has finally documented how to make the Arduino IDE work with a Windows screen reader. It is one of the early posts in what is bound to be an awesome blog on blind electronics.

It's great that Ken has finally told us how to get the Arduino IDE to work with the JAB, but I will probably continue to write code and upload from Notepad++ rather than use JAB with the IDE. This is mostly because I have concerns about the security of the Java Access Bridge, but I also feel like I have spent enough hours of my life fruitlessly wrestling with the JAB and don't feel like doing it any more. Maybe I'll try it some day when I'm feeling energized and long on patience.

For many people working in larger institutions such as schools or libraries, the JAB approach will also not be convenient because it requires extensive modification of environment variables and system-level files. Many system administrators will not like the configuration changes necessary to make the Java Access Bridge work with the Arduino IDE.

But the good news is that you can do it if you want, and Ken Perry is the hero of the day for finally telling us how. Thanks, Ken!

Sunday, July 3, 2016

How to Compile and Upload Arduino Sketches with Notepad++ -- Simple, Convenient, Accessible


Blind people living in the real world are constantly working out hacks and alternatives to “normal” work flows that are inaccessible in whole or in part. Arduino software development is no exception, and many of the posts in this blog have been devoted to working around the sketchy (sic) accessibility of the Arduino IDE itself. For example, in an earlier post I describe (perhaps in more detail than strictly necessary) how to set up and configure the Arduino IDE from the Windows command line. In another post, Chancey Fleet provided excellent step-by-step instructions for installing and using Visual Micro to compile and upload Arduino sketches directly from Visual Studio. The current post offers the most convenient Arduino development tool chain I have yet found –editing, compiling, and uploading sketches directly from Notepad++.

Notepad++ (hereafter Npp) is my text editor of choice for almost any simple editing work including coding Arduino. It is used by many developers who don’t want the overhead of a giant IDE just to edit a bit of code. It’s free, open source, simple to install, and largely accessible with whatever screen reader you happen to prefer. It has features such as code completion, line numbers, support for different character encodings, and many others, yet it remains extremely compact and easy to use. Perhaps my favorite feature is that it doesn’t care what kind of line endings you use, CR/LF or just LF – it just does the right thing. This is really nice when using cross-platform source files such as Arduino sketches. If you don’t know what I’m talking about, just take my word for it: Notepad++ is extremely convenient and easy to use as a code editor.

Compiling and uploading Arduino sketches from the command line is great for those of us who are really old school and feel at home typing incredibly long text-based commands. For others though, those long commands are just opportunities for typos and inexplicable DOS error messages. Similarly, for hardcore hackers who have millions of lines of code under their belts, Visual Studio might be the best Arduino development environment you could want. Speaking for myself, however, Visual Studio makes me feel like the Sorcerer’s Apprentice with too many options, settings, and terms that I don’t quite understand, and an incredibly complex interface as reins to ultimate unwanted and undeserved power. In fact, I recently hit an accidental keystroke in VS and the entire thing stopped working. Of course, if I knew what I was doing in there then I’d be able to fix it, but I don’t have that kind of time and I don’t want that kind of power. I just want to write a little Arduino code!

In contrast, Npp is just my speed. It lets me do what I need to do without giving me a dangerous amount of rope. At the same time it has hidden depths which can be quite handy. You could say that I am definitely down with Npp…

But Npp is just an editor. It is not a compiler or an integrated development environment, so it can’t compile or upload your Arduino sketches. On the other hand, it can be configured to interact with other programs on your computer (such as the Arduino IDE) which can. This article explains how to set things up to let you edit an Arduino sketch with Notepad++, and then compile and upload that sketch with a single command without ever leaving Npp. The resulting Arduino compiler output and error messages are even displayed in a Notepad++ window for easy review.

The following sections offer two scripts that can be executed from inside Notepad++. The first allows you to set the Arduino COM port – convenient since this may change frequently with different boards and USB ports. The other compiles and uploads the Arduino sketch that is currently open in Notepad++.

Setting It Up

Step 1: Download the latest Arduino IDE and install it. If necessary, check out my instructions on installing and configuring the Arduino IDE from the command line.

Step 2: Download the latest version of Notepad++ (Npp) and install it. This process is easy and you should have no accessibility-related problems. Take note of the directory where you are installing it because you’ll need to find it later to install the Npp plugin.

Step 3: Download NppExec (a plugin for NPP) and install it. The installation process consists of unzipping the NppExec archive and copying the appropriate DLL into the plugins directory of the Npp installation directory. You are probably using the Unicode version of Npp, so copy the NppExec.dll file from the DLL_Unicode folder of the archive to the plugins directory of Npp and restart Npp to complete the installation. For example, my Npp plugins directory is "C:\Program Files (x86)\Notepad++\plugins"

Step 4: Set up the following Arduino-related NppExec scripts in Npp. You can either copy and paste them from below or download the NppExec scripts in this convenient archive.

The easiest way to install these scripts is to copy and paste them individually into the Execute dialog in NPP. This dialog can be opened with a keyboard shortcut (F6 inside Npp), or through Npp’s menus (Plugins > NppExec > Execute…).

The Execute dialog has a multi-line edit field for pasting or typing the script itself, a Save button for naming and saving scripts, a combo box for recalling previously saved scripts, and an OK button to execute the selected script. All the controls in this dialog are accessible with NVDA or JAWS.

The Arduino COM Port Script

This script makes it easy to quickly update the Arduino IDE’s COM port. This is the port used to upload the sketch to the board. When you invoke this script from inside Npp, a dialog pops up asking for the Arduino’s COM port. Appropriate responses are like the parameters you would use on the command line when setting the com port (e.g., com3, com4, etc.).

To set up the port selection script, open the Execute dialog by pressing F6 or by selecting Execute from the NppExec sub-menu of the Plugins menu. Paste the following script into the edit field and press the Save button. In the Save dialog, type something like “ Arduino Port,” and press return. The port selection script will then be saved for future use using that name.

Before saving, be sure to edit this script to reflect the actual location of your Arduino installation. I have mine in the root directory for convenience – “c:\arduino”.

//This NppExec script sets the com port of your Arduino IDE
//By Josh Miele -- June 27, 2016
//The Blind Arduino Project
set arduino_path = c:\arduino\arduino_debug //the path to your Arduino IDE.
//put up a dialog box requesting com port name
inputbox "Please enter the COM port of your Arduino (e.g., com5):" //gets com port value
//use result to set port value doesn't verify
cmd /c "$(arduino_path)" --port $(input)
npp_console 0 //hide the console

Note: This script does no checking to make sure that you have entered a valid COM port or string. If you make an error typing or enter an invalid com port, you will get no error message or other feedback to indicate your mistake. Take care!

The Compile and Upload Script

This script saves the currently open Arduino sketch, then calls the Arduino IDE with the command line parameters to compile and upload it. It then passes any output, including errors to a new Npp file so that you can easily see what happened.

To set up the compile/upload script, open the Execute dialog by pressing F6 or by selecting Execute from the NppExec sub-menu of the Plugins menu. Paste the following script into the edit field and press the Save button. In the Save dialog, type something like “ Arduino Upload,” and press return. The compile/upload script will then be saved for future use using that name.

Before saving, be sure to edit this script to reflect the actual location of your Arduino installation. I have mine in the root directory for convenience – “c:\arduino”. Also make sure that the Arduino_output.txt file is being created in a directory where you have write privileges and where it won’t cause any problems. I put mine in “c:\temp”. The first time the script runs it will ask for permission to create the output file. After that it will quietly overwrite the file with each new execution of the script.

//This NppExec script compiles and uploads the current Arduino sketch in Npp
//By Josh Miele -- June 27, 2016
//The Blind Arduino Project
//Set where the output goes. Make sure you have write privileges
set arduino_output = "c:\temp\arduino messages.txt" 
//Set location of Arduino executable. 
set arduino_path = c:\arduino\arduino_debug 
npp_save //save current file before uploading
//Compile and upload sketch in current Npp window and send stdOut and stdErr to arduino_output
cmd /c "$(arduino_path)" --upload $(full_current_path)>$(arduino_output) 2>&1
npp_console 0 //hide the console
//show the results of the compile/upload in Npp window
npp_open $(arduino_output)  

Note: This script does not account for the fact that the Arduino IDE will move your sketch if it is not already inside a folder of the same name as the stem of the script. For example, if you are editing a file called MySketch.ino located in c:\temp, executing the above NppExec compile/upload script will compile and upload the sketch, but the Arduino Ide will create a directory called c:\temp\MySketch and move the file MySketch.ino inside it. Notepad++will be left with an open file that has been moved out from under it. This has the potential to lead to unexpected errors and problems, so I recommend making sure your sketches are contained within folders of the appropriate name as modeled in the Arduino examples directory.

Using the Scripts

To invoke these scripts from inside Npp, press F6 to bring up the Execute dialog, then use your arrow keys to select the desired script from the combo box and press return. Pressing ctrl-F6 will execute the last script without invoking the execute dialog.

Note: There is a way to map individual NppExec scripts to their own keyboard shortcuts using the Shortcut Mapper under the Settings menu. Unfortunately, this dialog is not accessible using NVDA or JAWS. I believe there is a way to modify the shortcut mappings by editing one of Npp’s XML files, but I don’t yet know how to do this. In the interest of getting this info into your hands, I decided to post this anyway and update the post when I find an accessible way to map the shortcuts. If you have info about how to do this, please leave it in the comments.

References and Disclaimers

I’m no expert in any of the several areas necessary for creating elegant and effective NppExec scripts. I encourage feedback in the comments and invite suggestions for improvement and additional helpful scripts.

In developing these scripts I found the following resources extremely informative:

Monday, June 20, 2016

Consider the Continuity Tester

It has been argued that the continuity tester is one of the most essential pieces of equipment for a blind electronics maker. It is a device which provides accessible feedback when current flows in a circuit -- basically an Ohmmeter or resistance meter. A continuity tester with audio or tactile output provides an accessible way of testing and even identifying components, leads, and connections, tracing paths on circuit boards, checking solder joints, and even making other simple measurement tools such as light detectors and thermometers. While the sighted person finds occasional uses for an Ohmmeter, the continuity tester is an indispensable and pervasive tool for the blind maker. I cannot over emphasize the importance of having one.

They come in a variety of flavors, from simple circuits which buzz below a specified resistance threshold to oscillators that vary the pitch of an audible tone depending on the amount of resistance in the circuit. The classic continuity tester described in the following section, as well as many other awesome accessible continuity tester circuits and their uses, are fully documented in the Fall, 1982 issue of the Smith-Kettlewell Technical File. Advanced makers should definitely study these for insight into some old-school accessible test equipment.

The Classic Continuity Tester

The classic Smith-Kettlewell continuity tester is an elegantly simple circuit which makes for an excellent first soldering project (read the Soldering Series in the Smith-Kettlewell Technical File for all the information you need on blind soldering techniques). If you're planning to build electronics, make stuff with Arduino, or otherwise make a habit of messing around with wires and components, I strongly recommend building one. It's reliable, versatile, and extremely nice to have around.

Building the Classic Continuity Tester

The continuity tester's oscillator consists of an audio output transformer and a PNP transistor. An 8 Ohm speaker is connected across the leads of the low-impedance secondary of the transformer. The primary of the transformer has a center tap which connects to the emitter of the transistor. One end of the transformer's primary connects to the Positive terminal of a 9-volt battery. The other primary lead connects through a 0.022 uF capacitor to the base of the transistor. Across the entire primary is another 0.022 uF capacitor. The base of the transistor connects through a 22K resistor to the positive test terminal. The negative test terminal connects to the collector of the transistor and the negative terminal of the battery (ground). That's it!

A Simple Arduino-Based Continuity Tester

While the continuity tester described above is extremely simple and reliable, you may not have these capacitors, transformers, or transistors readily at hand. Possibly you aren't yet confident enough with a soldering iron to build it. Sometimes you may want to slap a continuity tester together using an Arduino and a couple of resistors. The following sketch makes a reasonably handy audible continuity tester, although the classic continuity tester described above is superior in most ways.

Building the Arduino Continuity Tester

Connect a 1 mega Ohm resistor and a 1 kilo Ohm resistor to analog pin 0 of the Arduino board. Connect the other end of the 1 mega Ohm resistor to ground and the other end of the 1 kilo Ohm resistor to +5v. Connect a piezoelectric buzzer to digital pin 9 and ground, (or you can substitute a speaker in series with a 100 Ohm resistor). Connect the positive test lead to analog pin 0 and the negative test lead to ground.

Programming the Arduino Continuity Tester

Copy and paste the following sketch into your development environment, make any desired modifications, and upload it to your Arduino. You can also download the continuity tester sketch here.

Simple Audio Continuity Tester

Wiring Description
Resistors -- 1Meg, 1K, 100 Ohm.
8 Ohm speaker or piezo buzzer
jumper cables and test leads

Connect buzzer to pin 9 and ground.
If using a speaker, connect one side to pin 9. 
The other side of the speaker goes to 100 Ohm res, which goes to ground.

Connect 1K to +5V. The other end connects to a junction which includes the positive test lead, analog pin 0, and  the 1M. 
The other end of the 1M goes to ground. 

The negative test lead also connects to ground.

When there is no connection between the test leads, the speaker is silent. It begins to click when there is some conductivity, and produces a 500 Hz tone when there is no resistance.

Play with resistor values and the mapping of reading to ici to optimize for the range of sensitivity you need.

By Josh Miele
The Blind Arduino Project, June 17, 2016.

int sensorPin = 0; //the pin connected to +test lead
int speakerPin = 9;  //connected to speaker or buzzer
int thresh = 1000;   //above this sensor val no sound is played
int reading = 0;  //analog input value somewhere between 0 and 1023;
int ici = 0;   //inter-click interval in ms. Shorter for lower resistance values.

void setup() {
 pinMode(speakerPin, OUTPUT);    //speaker (or buzzer) pin 
 pinMode(sensorPin, INPUT);   //connected to +test lead
}   //end of setup

void loop() {
 reading = analogRead(sensorPin);  //measure voltage across 1Meg Ohm
 if (reading < thresh) {
  //if reading is less than threshold then speaker clicks
  //play a 500 Hz click 5 mS long
  tone(speakerPin, 500, 5);   
  //scale reading val to delay value in mS
  ici = map(reading, thresh, 0, 200, 0);  
  delay(ici);   //wait before playing next click
 }   //end of if
}   //end of loop

Monday, May 30, 2016

HELP -- My Arduino Headers Don't Have Gaps!

In another post I wrote about orienting yourself to the Arduino pins using tactile landmarks such as the gaps in the left and right header blocks. Unfortunately, the header blocks on some Arduino boards are manufactured without gaps between sections. Instead, both right and left headers are continuous blocks that include both upper and lower sections. Where the gap would be on most boards is simply a double-wide space on the header with no hole at all.

You can orient yourself the hard way using a probe such as a jumper pin, wire, or stylus to feel your way along the top of the header to find the spot where there is a wider gap between holes. This is the break between the upper and lower sections. While this is doable, it’s definitely a pain to do every time you need to find a particular pin.

To make navigation easier on these notchless boards, use a serrated dinner knife or a metal nail file to cut a notch between upper and lower sections that is easily detectable by touch. Guide the knife or file by placing male jumper cables on either side of the gap, that is, in the bottom hole of the top section and the top hole of the bottom section. Placing the knife or file between the two jumpers, gently saw back and forth to cut a small notch in the plastic header. Be sure to hold the Arduino by the header, not the board, to avoid straining the joint between the header and the board. The notch doesn’t need to be deep in order to be easily felt. Five to ten strokes with the knife or file should be enough. Check to be sure you can feel it and continue if necessary.

If you don’t want to permanently mark your header you can use a probe to find the gap and place a temporary landmark such as a flexible plastic toothpick or male-female jumper cable in one of the adjacent holes. The main consideration here is not to use anything which might accidentally break off or create a short.

Wednesday, May 25, 2016

What is the Blind Arduino Blog?

There is nothing new about blind makers -- we have a long history of creativity and innovation in order to get access to the information we need to do the things we want to do. We also have a long history of sharing how-to information among ourselves in order to support our community in achieving our goals and potential. The Blind Arduino Blog follows in this proud tradition.

Bob Gunderson's Braille Technical Press was a great, mid-century example of blind people supporting other blind people in building the tools they need. It largely focused on amateur radio tools and techniques, but it was an early pioneer in the blind DIY electronics genre. Bob worked as an electronics teacher at the New York Institute for the Blind and published the Braille Technical press in the 1950s as a way of documenting the accessible tools he and his students developed so that other blind hams could build and use them.

More recently in the 1980s and 90s, Bill Gerrey at The Smith-Kettlewell Eye Research Institute (where I happen to work) published the Smith-Kettlewell Technical File -- a publication inspired by Gunderson's earlier magazine. In addition to publishing instructions for building all kinds of useful accessible test equipment and refining the technique of circuit description, the Technical File published a series of excellent tutorial articles on techniques for blind solderers.

With the advent of open-source, relatively standardized, microprocessor-based project kits like Arduino, the kinds of devices that can be built by the casual maker at home have become quite sophisticated. In fact, Arduino is an ideal platform for creating a variety of accessibility devices which blind makers and users might find useful. For example Arduino would be perfect for building tools like audio and tactile meters and gauges which could be driven by any manner of sensors and detectors. From accessible scales to timers, range finders, multimeters and beyond, Arduino could make it relatively easy to design and share accessible tools which can be endlessly modified, adapted, and improved to meet a wide range of applications and needs.

A little googling reveals that there are designs for a number of Arduino-based accessibility devices scattered across the net. However, none that we have found are intended to be built by blind people, Nor is the documentation necessarily accessible. Furthermore, the fact that they are from all over the place means that they are inconsistently documented and occasionally hard to find.

The Blind Arduino Blog is another step along the road paved by Gunderson and Gerrey. Its intent is to provide a public clearing house for blind makers who want to build accessible devices with Arduino. The project has two main objectives:

  1. To provide clear instructions and accessible resources for blind people who want to develop for Arduino, and
  2. To Assemble a library of accessible project descriptions for devices that might be of particular use for blind people.

Before we can begin assembling our library of accessible Arduino devices for blind makers, there are a number of hurdles to be overcome. We can build on Bill Gerrey and Bob Gunderson's hardware-assembly description techniques to document how to build the Arduino hardware, but the coding component needs some R&D. First we need to identify and document the accessible tools and resources for learning, writing, and uploading code to the Arduino itself.

There are many different Arduino boards and accessories, and many different software tools available for coding, uploading, and debugging. Thus, the first posts to this blog will document our investigations into which boards, tutorials, and other tools are most accessible, as well as any work-arounds or tricks for getting the most out of them as a blind user. Once we have a nice foundation of accessible tools for Arduino development on which to build, we can move on to our long-range plan of collecting and developing accessible instructions for building a wide variety of accessibility devices based on Arduino. My own personal interest is in duplicating a number of devices from the S-K Technical File recast in Arduino. As our group learns and grows, I have confidence that the depth and diversity of projects will expand well beyond what I currently imagine.

Some Comments on Platforms, Screen Readers, and Browsers

Arduino software development can be done on Linux, Mac, Windows, and other platforms. This blog will focus on identifying tools that are Windows based. For folks who are comfortable in Linux, I suspect that is the easiest and most accessible path for Arduino development. However, most people are a little intimidated by Linux. While Apple has done great work with VoiceOver, the vast majority of blind users are still on Windows. For these reasons, we are committed to charting an accessible Arduino-development path through Windows. This doesn't mean that we won't include some posts on tools for other platforms, it just means that the emphasis here will be on tools for Windows.

In addition, in making our judgements about accessibility of tools and informational resources, we will assume the default screen reader/browser combination of NVDA and Firefox. Certainly there are other screen readers and browsers and preferences will vary, but web site performance will as well. Since we can't test all combinations, we will generally stick to NVDA and Firefox when we test Arduino resource sites for accessibility.