View this page "Program"
Jonathan Oxer
Click on http://groups.google.com/group/arduino-miniconf-2010/web/program
- or copy & paste it into your browser's address bar if that doesn't
work.
andyg (geekscape)
drivers and application(s) for the hardware built during the morning.
Also, happy to help out with one or more of the morning sessions,
pertaining to building the hardware (Arduino shield ?) ... either as
assistant to session presenter (or presenting, but keen to share
around the presenting opportunities with those interested).
Hoping to aim for some sort of mesh-networking application(s) run by
the participants, by the end of the day !
cheers andyg (geekscape)
Jonathan Oxer
> Happy to run a software session after lunch, specifically about device
> drivers and application(s) for the hardware built during the morning.
> Also, happy to help out with one or more of the morning sessions,
> pertaining to building the hardware (Arduino shield ?) ... either as
> assistant to session presenter (or presenting, but keen to share
> around the presenting opportunities with those interested).
Thanks Andy,
> Hoping to aim for some sort of mesh-networking application(s) run by
> the participants, by the end of the day !
That would be very cool.
The general "shape" of the miniconf (at least in my mind) looks
something like this:
1. "Introduction to hardware" session with participants shown how to
solder and given an opportunity to assemble their own shield (probably
the Pebble shield as a generally useful experimental I/O shield).
Session designed to get software people over their fear of hardware and
have some comfort with soldering so they can feel confident doing things
at home after the conference.
2. "Introduction to Arduino" session that goes through Arduino basics
such as the IDE, analog / digital I/O, etc. Probably using the Pebble
shield constructed in the first session as a basis so participants can
try the various experiments for themselves.
3. More general and increasingly advanced sessions: traditional how-to
and project update talks.
With that general sequence people who haven't had experience with
soldering etc can come right from the start, those who want to skip that
and just learn about Arduino can come from #2 onwards, and those who are
already experienced can come from #3 onwards - although I'd hope that
experienced people would want to be there the whole time to help out the
beginners. Paying-it-forward (or back) and all that.
So the first question is how long session #1 will take. Looking at the
template schedule it would be *really* nice if we could fit that into
the first 60 minutes, but I'm sceptical of our ability to talk a bunch
of beginners through assembling their very first shield in that time. An
ideal structure would be something like the following because the
"phase" changes occur directly on morning tea and lunch:
09:00-10:00: Welcome, hardware assembly session
10:00-10:30: Morning tea
10:30-11:15: Introductory Arduino session, part 1
11:30-12:15: Introductory Arduino session, part 2
12:15-13:30: Lunch
13:30-14:15: Presentation 1
14:30-15:15: Presentation 2
15:15-15:45: Afternoon tea
15:45-16:30: Presentation 3
16:45-17:30: Presentation 4
Of course any of the presentation sessions could be split if necessary
to include say 2 x short presentations, or a bunch of lightning talks,
or a panel session, or whatever.
But the critical thing is whether the hardware assembly can be done in
that time. Perhaps a more practical structure would be something like:
09:00-10:00: Welcome. Hardware assembly session part 1
10:00-10:30: Morning tea
10:30-11:15: Hardware assembly session part 2
11:30-12:15: Introductory Arduino session
12:15-13:30: Lunch
13:30-14:15: Presentation 1
14:30-15:15: Presentation 2
15:15-15:45: Afternoon tea
15:45-16:30: Presentation 3
16:45-17:30: Presentation 4
That would leave only 45 minutes for the introductory session, but then
perhaps some of the experiments with the Pebble shield could be done
later. The "Presentation 1" slot could be used for part 2 of the
introductory session.
Suggestions?
--
Jonathan Oxer
Ph +61 4 3851 6600
Geek My Ride! <http://www.geekmyride.org/>
Mitch Davis
>
> So the first question is how long session #1 will take. Looking at the
> template schedule it would be *really* nice if we could fit that into
> the first 60 minutes, but I'm sceptical of our ability to talk a bunch
> of beginners through assembling their very first shield in that time.
Indeed. Personally, I think this is just too much to fit into the
time given. It sounds like a "Teach yourself Arduino in 24 hours"
book.
I'm wondering if it's possible to run some workshops here in Melbourne
as test runs where we can watch what newbies do, time how long these
sort of tasks take, and calibrate what we'd like to cover against the
time we have? Far better to find it out earlier rather than later.
Mitch.
Jonathan Oxer
> I'm wondering if it's possible to run some workshops here in Melbourne
> as test runs where we can watch what newbies do, time how long these
> sort of tasks take, and calibrate what we'd like to cover against the
> time we have? Far better to find it out earlier rather than later.
Genius, Mitch.
Let's do that! It could be run on a Hackerspace weekend: arrange for
some interested people with no soldering experience to come along, and
we'll run through the assembly of a Pebble each with an open-ended
schedule and simply time how long it takes.
Cheers :-)
Vik Olliver
> Let's do that! It could be run on a Hackerspace weekend: arrange for
> some interested people with no soldering experience to come along, and
> we'll run through the assembly of a Pebble each with an open-ended
> schedule and simply time how long it takes.
I could maybe do the same at Wellington Makerspace? At worst we end up
with partly-trained makerspace personell to hand on the day...
Vik :v)
Mitch Davis
>
> Let's do that! It could be run on a Hackerspace weekend: arrange for
> some interested people with no soldering experience to come along, and
> we'll run through the assembly of a Pebble each with an open-ended
> schedule and simply time how long it takes.
Another idea is to have two tracks, hardware and software. You choose
one and do that for half a day, learning what you need to learn. Then
after lunch, you pair with with someone who did the other stream, and
together, you integrate what you did.
Mitch.
Jonathan Oxer
> I could maybe do the same at Wellington Makerspace?
Sure! Andy and Luke have been reworking the Pebble design recently so
once they have that sorted out we'll arrange some PCBs and schedule some
sessions in both Melbourne and Wellington.
> At worst we end up
> with partly-trained makerspace personell to hand on the day...
Which is exactly what we need anyway, so having a few people go through
the testing session who are then willing to be assistants on the day
will be a big help quite apart from the knowledge we'll gain about
timing and what issues are likely to trip people up.
Trent Lloyd
On 10/08/2009, at 8:32 AM, Jonathan Oxer wrote:
>
> On Mon, 2009-08-10 at 12:25 +1200, Vik Olliver wrote:
>
>> I could maybe do the same at Wellington Makerspace?
>
> Sure! Andy and Luke have been reworking the Pebble design recently so
> once they have that sorted out we'll arrange some PCBs and schedule
> some
> sessions in both Melbourne and Wellington.
>
>> At worst we end up
>> with partly-trained makerspace personell to hand on the day...
>
> Which is exactly what we need anyway, so having a few people go
> through
> the testing session who are then willing to be assistants on the day
> will be a big help quite apart from the knowledge we'll gain about
> timing and what issues are likely to trip people up.
I guess the biggest thing we'll need to sort out is some kind of time
split from the practical to actual presentations. I think we will
realistically need both for maximum audience attraction and enjoyment
- but that there is time constraints on the practical.
I think a format of more "morning" presentations (intros, demos, etc)
to get people excited and then afternoon hands-on keeping it as basic
and simple as possible.
Thoughts?
Thanks,
Trent
Jonathan Oxer
> I think a format of more "morning" presentations (intros, demos, etc)
> to get people excited and then afternoon hands-on keeping it as basic
> and simple as possible.
That seems a bit backwards to me, because it starts with complex stuff
and ends with simpler stuff. The idea of having beginners assemble a
general-purpose experimental shield right at the start is to then
provide a common hardware platform for the introductory "getting started
with Arduino" topics, and leading through to more advanced things later
in the day. At least that way beginners can spend the whole day at the
miniconf and hopefully get something out of it from beginning to end,
since by the end of the day they'll have some grounding in what Arduino
is even if the more advanced talks are a bit beyond them.
Of course we don't want to ignore the more experienced developers in all
this too.
Trent Lloyd
On 13/08/2009, at 12:40 PM, Jonathan Oxer wrote:
>
> On Thu, 2009-08-13 at 11:00 +0800, Trent Lloyd wrote:
>
>> I think a format of more "morning" presentations (intros, demos, etc)
>> to get people excited and then afternoon hands-on keeping it as basic
>> and simple as possible.
>
> That seems a bit backwards to me, because it starts with complex stuff
> and ends with simpler stuff. The idea of having beginners assemble a
> general-purpose experimental shield right at the start is to then
> provide a common hardware platform for the introductory "getting
> started
> with Arduino" topics, and leading through to more advanced things
> later
> in the day. At least that way beginners can spend the whole day at the
> miniconf and hopefully get something out of it from beginning to end,
> since by the end of the day they'll have some grounding in what
> Arduino
> is even if the more advanced talks are a bit beyond them.
Hrm.. well - yeah I guess you could look at it either way.
From one sense, if you introduce people to the sorts of things they -
can- do, then let them get there's hands on it, could be useful. Plus
the end of the day will have more slack time than the start.
>
> Of course we don't want to ignore the more experienced developers in
> all
> this too.
While true, I think our over-all target audience is going to be less
experienced ones.
Thanks,
Trent
Vik
components and some terminal strip. No soldering at all, drives 12V@4A
(Spoondriver http://vik-olliver.blogspot.com/2009/08/spoondriver.html
) and plugs straight into the hole on an Arduino board. That might be
a useful ice-breaker for people not familiar with soldering irons?
Vik :v)
PS I think we might even be able to drive it using a headphone socket,
but I don't want to blow my laptop up either!
David Z
belief my talk might end up here instead of main programme.
On Aug 14, 8:15 pm, Vik <vikolli...@gmail.com> wrote:
> I've figured out a way to make a useful and cheap driver using just 3
> components and some terminal strip. No soldering at all, drives 12V@4A
> a useful ice-breaker for people not familiar with soldering irons?
cheap components. Presumably it's not going to be SMD soldering
straight away, and just PTH, which shouldn't be hard to pick up.
Certainly scrap boards with solder resist will help a huge amount,
IMO :)
andyg (geekscape)
On Aug 19, 11:56 am, David Z <tgk...@gmail.com> wrote:
> Well, it's probably more useful to start with scrap boards and a few
That's a good idea for those attendees who are doing their very first
solder joint.
Get them to solder a few wires or resistors onto some vero-board.
Doesn't have to do anything electronically useful. Just give them a
feel for the tools / technique and what a good joint looks like, etc.
Probably should also get everyone to make a "repair", e.g. use a
solder sucker or solder wick (let them know about "not lifting
pads" !).
Then, they can tackle their Arduino shield.
> Presumably it's not going to be SMD soldering
> straight away, and just PTH, which shouldn't be hard to pick up.
(no SMD, etc). It'll mostly be headers (for the LCD and optional
ZigBee), a few simple components (buttons, potentiometer, light
sensor, temperature sensor) and an IC socket. However, it will do
lots of useful stuff (so the shield is not just for beginners).
It also has a prototyping area, so that the more adventurous /
experienced can get more out of the session.
Yesterday, Sam Sabey and I quickly put a cheap speaker on to an
Arduino and in a few minutes had it playing tunes. Quick and fun.
Bringing along some extra components to the LCA mini-conf (like servo
motors, accelerometers, speakers, GPS, etc) to the LCA mini-conf and
showing additional possibilities for hardware hacking ... would be a
good thing.
Luke Weston has completed another round of design of the
"Pebble" (Arduino shield) and now getting feedback from everyone would
be great. We'll get the latest Eagle schematic checked into
GitHub ...
http://github.com/lukeweston/Pebble
Getting the PCB made is a solved problem (just ask Jon). However,
getting a fully assembled shield for those mini-conf attendees that
don't want to make their own ... is something that we still need to
sort out.
cheers andyg (@geekscape)
David Z
> Get them to solder a few wires or resistors onto some vero-board.
> Doesn't have to do anything electronically useful. Just give them a
> feel for the tools / technique and what a good joint looks like, etc.
feel for it before wasting a real board (which was infinitely harder
to get than some 0805 resistors..)
> Luke Weston has completed another round of design of the
> "Pebble" (Arduino shield) and now getting feedback from everyone would
> be great. We'll get the latest Eagle schematic checked into
> GitHub ...
>
> http://github.com/lukeweston/Pebble
>
> Getting the PCB made is a solved problem (just ask Jon). However,
> getting a fully assembled shield for those mini-conf attendees that
> don't want to make their own ... is something that we still need to
> sort out.
imagine more than a few people will be hesitant at doing it.
But as they're mostly easy SMD parts (0805 and SOT-223 are anyway,
SOIC less so) it's not too harsh an introduction to SMD soldering
technique.. and it wouldn't be hard to either do a partially-assembled
(all the SMD bits done) and let people do the PTH parts. Or fully
assembled. Gives you some options anyway.
Mitch Davis
>
> On Aug 19, 11:56 am, David Z <tgk...@gmail.com> wrote:
>> Well, it's probably more useful to start with scrap boards and a few
>> cheap components. Certainly scrap boards with solder resist will help a huge amount,
>
> That's a good idea for those attendees who are doing their very first
> solder joint.
I'm wondering if we can take a leaf from the book of usability
testing: Give a board to some newbies, and watch what happens.
Analyse and learn, rinse and repeat.
I can supply some newbies.
Mitch.
andyg (geekscape)
On Aug 19, 2:32 pm, "andyg (geekscape)" <an...@geekscape.org> wrote:
> Luke Weston has completed another round of design of the
> "Pebble" (Arduino shield) and now getting feedback from everyone would
> be great. We'll get the latest Eagle schematic checked into
> GitHub ...
There are PNG files of both the board (pebble-pcb.png) and the
schematic (pebble-sch.png).
On Aug 19, 2:06 pm, David Z <tgk...@gmail.com> wrote:
> Given there's a decent number of SMD components on that board, I
> imagine more than a few people will be hesitant at doing it.
it can be assembled by beginners.
- - - - - - - - - - - - - - - - - - - - - - - - -
You may also notice that the prototyping area is under the LCD.
Q: So, how does one use the prototyping area ?
A: The LCD that we've chosen has 2 identical sets of headers (top and
bottom), so you can plug the LCD into the top most headers on the PCB,
thus exposing the prototype area. For normal operation, the LCD have
two sets of headers, which plug into both headers on the PCB, meaning
that the display is more securely mounted.
cheers andyg (geekscape)
Vik Olliver
> The latest version has no SMD components on it, specifically so that
> it can be assembled by beginners.
Put an SMD Arduino CPU on the reverse for those who want the challenge!
Vik :v)
David Z
On Aug 19, 4:59 pm, "andyg (geekscape)" <an...@geekscape.org> wrote:
> The latest version has now been checked in ...http://github.com/lukeweston/Pebble
> There are PNG files of both the board (pebble-pcb.png) and the
> schematic (pebble-sch.png).
I'd be happy to help with assembly of the boards people will be
getting fully built.
andyg (geekscape)
On Aug 19, 5:14 pm, Vik Olliver <vikolli...@gmail.com> wrote:
> Put an SMD Arduino CPU on the reverse for those who want the challenge!
cheers andyg (geekscape)
andyg (geekscape)
On Aug 20, 8:41 am, David Z <tgk...@gmail.com> wrote:
> I'd be happy to help with assembly of the boards people will be
> getting fully built.
addition to the LCA2010 mini-conf.
To that end ... I'm anticipating looking into the best (and most
affordable) approach to having these board fully assembled by a third-
party (for those attendees who want to avoid soldering, etc).
However, if that doesn't pan-out ... then, "yes", we'll need to
distribute the assembly process amongst ourselves. Thanks for the
offer.
cheers andyg (geekscape)
Luke Weston
> > Hoping to aim for some sort of mesh-networking application(s) run by
> > the participants, by the end of the day !
>
> That would be very cool.
>
and many people probably won't have one, and if you included it in a
pre-defined kit of parts for the miniconf it would drive up the cost
substantially.
Since most people probably don't have them, you probably wouldn't want
to include discussion of Xbee-based software in the software side of
the miniconf.
Maybe have some pre-prepared XBee mesh network code made available, so
those people who do have an XBee can use it, and there can be a little
mesh network established, but it won't have many nodes.
Luke.
follower
I've finally caught up on the mail around this and have some thoughts/feedback.
In the past few months I've conducted three workshops which have some
relevance to the Arduino miniconf plans:
* A three-hour Arduino introduction for a digital arts conference
which had a mixed technical/non-technical audience--about 6 people or
pairs had kits and around the same were observing. In this time there
was about 30-45 minutes of an introduction to "Physical Computing",
the Arduino, its forms and what people have produced ("Inspiration &
theory"). The remainder of the time consisted of: an introduction to
the IDE, getting the on-board LED flashing, using a breadboard to
connect an external LED, connecting a pushbutton and finally using the
pushbutton to control the LED. (Side note: I've proposed something
similar as a tutorial for the main LCA conference--aimed at those who
are interested but not enough to attend a whole mini-conf to it and
enable them to start solder-free.)
* A two day beginner Arduino course with a class of 11, with a mixture
of technical experience from beginner to advanced. The first three
hours were pretty much the same as above, the remainder of the first
day covered more in-depth software creation and the second day people
worked on their own projects and learned about specific sensors they
wanted to use on an "as needed" basis. This schedule was inspired by
the approach tinker.it beginner courses in the UK are run.
* A 2 to 3 1/2 hour introduction to electronics in crafting workshop
with an almost entirely non-technical audience of 5 people. This
included teaching soldering and constructing something (without a pcb)
which had 3 solder joints. The actual soldering technique, practice
and execution probably took 30 minutes to cover with two irons.
One assumes that a large proportion of the mini-conf audience can be
considered technical when it comes to software but not so much with
hardware.
I would think it wouldn't be unrealistic to allow at least 45 minutes
for an intro to soldering with a large group of people--and maybe at
least the same again to actually do the soldering and debugging.
I think we need to be clear who the audience is for the different
sessions and make sure we don't overcomplicate for the beginners and
under-represent the more experienced.
--Philip.
follower
isn't a particularly straight-forward proposition (e.g. 32- vs 64- bit
and serial, gcc versions vs Atmel chip used, Java versions etc) so we
need to allow that time for the software sessions too.
--Phil.
Trent Lloyd
We can mitigate this to some extent by several methods
(1) Have a local archive/USB key/CDs/etc of the software to save
donwload time
(2) [We need to do this anyway] HEAVILY advertise materials/equipment
needed in advance.
(3) Provide a VirtualBox/vmware image
Trent
Jonathan Oxer
Email to the group will follow in a moment. In the meantime the
schedule skeleton has been updated.
Jonathan Oxer
After being totally nuked for so long I'm finally getting back to
working on the miniconf organisation. AndyG and I had a good chat
about it yesterday and so I've just revisited the program and sliced
it up a little differently.
Something I've learned since it was put up is that the keynote section
at the start that I assumed was for us is actually a keynote for the
main conference. That's then followed by morning tea, so the result is
that the miniconf doesn't actually start until 10:30! That seriously
cuts into our "morning of hardware assembly" concept but I really want
to limit the hands-on soldering section of the miniconf to pre-lunch
if possible. If we just run straight through the first two sessions
including the break in the middle that gives us 1:45 prior to the
lunch break, which should be enough time to give people a chance to
solder a few parts onto a shield but probably not enough to assemble a
whole shield unless they know what they're doing. I therefore propose
that we investigate partial pre-assembly of shields (perhaps fit all
the headers) so that beginner participants get to solder on some of
the parts but don't have to spend hours on it before they have a
usable board and we can move on to the software.
There's also the 75 minute lunch break immediately after that session,
so that provides some buffer for people who get a bit behind.
I've then sliced the rest of the sessions into half-length sessions
(pairs of 20 minutes with 5 minute changeover) rather than leave them
all as 45 min sessions. That should allow us to have a few talks about
things that can be done with the Pebble hardware and still have a few
talks about more advanced topics, project show-n-tell, etc.
With the schedule as it stands we run slightly overtime in order to
tack a 10 minute "thanks for coming, here are some prizes" session at
the end. An alternative would be to make the final talk a longer one
(30 - 35 mins) and then fit the wrap-up in before 5:30pm.
Anyway, the skeleton schedule is up now on the Google Group so please
check it out and let's start talking about what we'll slot into each
of those spots.
Cheers :-)
Jonathan Oxer
Jonathan Oxer
Green = miniconf sessions.
Yellow = speaker changeover between sessions.
Orange = LCA sessions / breaks. Honoring these keeps us in synch with
other miniconfs.
Cheers :-)
Jonathan Oxer
Andy Gelme
Jonathan Oxer wrote:
> After being totally nuked for so long I'm finally getting back to
> working on the miniconf organisation.
> but I really want to limit the hands-on soldering section of the miniconf
> to pre-lunch if possible.
> If we just run straight through the first two sessions
> including the break in the middle that gives us 1:45 prior to the
> lunch break, which should be enough time to give people a chance to
> solder a few parts onto a shield but probably not enough to assemble a
> whole shield unless they know what they're doing.
introduction (what are the goals, how will it operate, etc). Some basic
orientation.
Can you be convinced that one of the post-lunch talks ... could be used
to wrap-up the hardware assembly ?
I assume that some people will continue through some part of lunch-time,
especially if they are close to finishing.
--
-O- cheers = /\ /\/ /) `/ =
--O -- http://www.geekscape.org --
OOO -- an...@geekscape.org -- http://twitter.com/geekscape --
Thomas Sprinkmeier
> that we investigate partial pre-assembly of shields (perhaps fit all
> the headers) so that beginner participants get to solder on some of
> the parts but don't have to spend hours on it before they have a
> usable board and we can move on to the software.
the haders, they're harder to kill, non-polarised, no need to trim
leads etc.
Thomas
Mitch Davis
>
> If we just run straight through the first two sessions
> including the break in the middle that gives us 1:45 prior to the
> lunch break, which should be enough time to give people a chance to
> solder a few parts onto a shield but probably not enough to assemble a
> whole shield unless they know what they're doing.
I now have all the components for a Pebble except for the LCDs, which
should be here by next Tuesday night (*)
I'm planning to put together a Pebble and time myself doing it,
however given the speed I do things (a lot faster than a newbie, but a
lot slower than a guru), and given the speed of other people I've seen
doing things at CCHS, I really doubt that there's enough time to pull
it off in the time proposed. (Yeah, I've been saying that for
months).
From our experience with CCHS, it's hard enough having two people in a
group with little experience, let alone 40. Can we really marshall
the manpower to help that number of people? Working hardware is a
critical prerequisite for the rest of the day, yet I think we're
taking a big risk expecting inexperienced people to be able to get to
that stage within the timeframe.
How about the idea that as a baseline, attendees start the miniconf
with working Pebble hardware? They could buy a premade one they pick
up at LCA, build it at home from a kit we send them, or we could run a
workshop on the Sunday where attendees could build them, or sort out
problems they've had in a unit they built at home. (On Sunday we can
afford to work for as long as it takes)
For those who want to build it at home (and because I think Pebble is
useful even outside of LCA), I'd like to propose working on a series
of Youtube videos which walk people through assembling Pebble boards.
Perhaps we mail them a kit of parts, they follow along with the
videos, and as a result, they get a working Pebble board, which they
can then turn up to LCA with. If people don't want to assemble their
own board, they can still sign up for a finished Pebble board which
they can collect at LCA. This way, attendees will start off with more
or less working stuff, and we don't have to sacrifice precious LCA
talk (or lunch^H^H^H^H^Hnetworking) time.
(And if we did go with this hardware baseline idea, we could do intro
to Arduino software in the morning, and still have applied hardware
sessions in the afternoon, which used Pebble to do cool things, for
example, have a relay controlling a solenoid on a little catapult:
write software to propel something with just enough force that it
lands on a target, or in a mini basketball hoop. Equations of
ballistic motion which we use to turn on a solenoid for just enough
time...)
Anyway, that's just what I'm thinking. What's proposed worries me. I
think we can still have hardware and software (and a whole heap of
fun), but structure things in a way which minimises the risk.
Mitch.
(*) With the exception of Trent and Thomas, who will be receiving
their parts in the mail, the best way for those who ordered Pebble
parts to collect them will be CCHS next Tuesday night. Money and bank
details to follow...
Mitch.
Andy Gelme
Mitch Davis wrote:
> I really doubt that there's enough time to pull it off in the time proposed.
ways of optimizing the process, especially those parts that real
experimentation (with appropriately chosen test subjects and a
stop-watch) demonstrates are the actual time wasters or are particularly
difficult for newcomers.
I'd also suggest that we do some pre-qualification of attendees ... and
on the registration form ... (1) set some reasonable attendee
skill/experience expectations ... and (2) ask about relevant experience
("Have you ever held a soldering iron ?").
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
As a start (see below) ...
I've counted all the pins / leads to determine the total number of
solder joints required (to get some quantification before deciding what
is or isn't possible) and also classified them into different types of
soldering tasks. Headers are easiest and fastest ... and also the
majority of the joint count. 70% of the solder joints are just headers
and sockets !
I've stuck-my-neck-out and made some time estimates (for someone with
reasonable experience, not a top-gun-surface-mount-dude).
Also, made some "testing procedure" suggestions, because getting the
attendees to test with a multimeter, prior to doing the smoke test will
also take a considerable amount of time.
I've put this up as a base-line, so that we check how real practice runs
compare with an (as yet) theoretical check-list. I fully expect my
estimates to be off and my task list to be incomplete, but it's just a
starting point for us to improve and determine whether this can really
be done or not (and how to change accordingly).
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Component pin/lead count
~~~~~~~~~~~~~~~~~~~~~~~~
- 2 x 16 pin: LCD headers
- 2 x 10 pin: Zigbee headers
- 2 x 8 pin: Arduino headers
- 2 x 6 pin: Arduino headers
- 2 x 14 pin: IC sockets
- 1 x 16 pin: IC socket
- 1 x 6 pin: Header block
- 1 x 3 lead: Regulator
- 1 x 3 lead: DS18B20
- 12 x 2 lead: Resistor
- 2 x 2 lead: LED
- 2 x 2 lead: Capacitor
- 1 x 2 lead: Diode
- 1 x 2 lead: LDR
- 1 x 3 lead: Variable resistor
- 1 x 3 lead: Trim potentiometer
- 4 x 2 lead: Switches
Solder joints
~~~~~~~~~~~~~
Total: 186 = headers:80 + sockets:50 + components:56
Component leads to snip: 56
Components to insert into headers/sockets: 5
Estimates
~~~~~~~~~
- Assuming no significant errors (as an *unrealistic* starting point !)
- Familiarization with board and components: 10 minutes (before starting)
- Placing, soldering and testing 8 headers: 20 minutes
- Placing, soldering and testing 4 sockets: 10 minutes
- Placing, soldering 26 components: 60 minutes
- Testing (with no problems found): 20+ minutes ?!
Testing procedures
~~~~~~~~~~~~~~~~~~
Prior to placing Zigbee, LCD, ICs into sockets and before plugging into
Arduino.
- Test no short-circuits between 5 VDC, 3.3 VDC and ground.
- Test no short-circuits between any 2 adjacent header / socket pins.
- Will need to check if there are some valid exceptions and list them.
- Test continuity between board ground and ground on each component.
- Test continuity between board power and power on each component.
- Test continuity between Arduino I/O pin and appropriate pin on each
device.
- Test continuity when switches are on and no short-circuit when they
are off.
Place Pebbble shield into Arduino.
- Sniff, sniff ... any dark, brown burning smells ?
- Test correct 5 VDC or 3.3 VDC on Zigbee, LCD header and each IC socket.
- Test correct 5 VDC on DS18B20, LDR and any other components that need
power.
Load and run software test #1 into Arduino, which reports the LDR and
temperature values on the serial port.
Plug the relays into their IC sockets.
Load and run software test #2 into Arduino, which exercises the relays.
We may need a little LED visual test unit for the relay outputs.
Plug the 4094 IC into it's socket and the LCD screen into the LCD headers.
Load and run software test #3 into Arduino, which displays a series of
test patterns on the LCD screen.
Load and run software test #4 into Arduino, which displays LDR and
temperature values onto the LCD screen and also reports these values
on the serial port.
Plug the Zigbee module into the Zigbee headers.
Use another Zigbee module connected to the USB port of a PC.
Re-run software test #4, the serial port values should be seen again.
Send a command down the serial port to turn on/off either relay.
All good ? Then, load the real application firmware.
Pop the champagne cork !
Note: Only one LCD header is electrically active, other is a physical
mount only
Mitch Davis
>
> Also, made some "testing procedure" suggestions,
them on a project page so we can track and refine them?
Mitch.
Luke Weston
There's absolutely nothing "bad" about that detailed and elaborate
testing procedure, it absolutely in no way "hurts" anything, of
course.
However, *if* we find that there are scheduling constraints and there
really isn't sufficient time, we insist on getting all construction
completed in the morning session, etc., I think you could get away
with expediting that careful building and testing procedure and making
it a bit faster, *if* you were really limited in terms of time.
Important points to stress during construction:
Diodes, LEDs, electrolytic, DS18B20 *must* be soldered with the
correct orientation. IC sockets really, really should be soldered with
the correct orientation and then the ICs aligned with the orientation
mark on the socket.
XBee module *must* be plugged into its socket the right way!
The silk screen on proper PCBs will help a great deal with this stuff
of course.
If we were to be in a position where the timetable needed to be very
fast, I would suggest the following:
Solder all components, check carefully as you are loading and
soldering each one for correct component choice (eg. resistors) and
correct orientation or polarity.
After all soldering, inspect carefully for soldering flaws. Solder
bridges are very unlikely on a solder-masked properly fabbed board.
Repair any flaws which are apparent under careful visual inspection.
Without LCD, 4094, LCD or XBee, plugged into Pebble, attach Arduino
and plug in USB. Set power jumper correctly if using an old Arduino NG
or Decimalla. (unlikely)
Do not use any kind of battery at this stage - power over USB only.
Arduino power light comes on? Good. No warning or USB overcurrent
alert from PC? Good. Computer can detect the FTDI chip on the USB bus?
Good.
Remove USB cable. Plug in LCD and 4094. Reconnect USB. Is all the
above still good?
Measure voltage on XBee power pin. If it's good, disconnect power and
plug in xbee.
Plug it back in. Attempt to download a program to the Arduino.
Download code and run tests.
Thomas Sprinkmeier
> Do not use any kind of battery at this stage - power over USB only.
USB is supposed to be able to deliver 1/2 A per socket, at a pinch it'll
probably do more.
A cheap 9V battery will give a fraction of that. Better still, put a
resistor on the positive lead, if the circuit tries to draw too much
power the resistor will limit the current.
The new arduinos will need a USB cable with the 5V line cut.
Thomas
Andy Gelme
Thomas Sprinkmeier wrote:
> The new arduinos will need a USB cable with the 5V line cut.
Sounds like I've missed something.
Jonathan Oxer
> Thomas Sprinkmeier wrote:
> > The new arduinos will need a USB cable with the 5V line cut.
>
> Huh ? What are you thinking about here ? Which new Arduino model ?
It took me a couple of minutes of puzzling to figure out what I *think*
Thomas means, which is that if you want to power a current Arduino with
auto-power-sensing from a battery while also having USB connected you
have to cut the USB +5V line. Otherwise it will switch to USB power and
bypass the battery even if it's plugged in.
Personally I don't think it's worth it: the USB cable doesn't even need
to be plugged in during the smoke test if the preference is to do that
on battery power.
Cheers :-)
--
Jonathan Oxer
Ph +61 4 3851 6600
Geek My Ride! <www.geekmyride.org>
Practical Arduino <www.practicalarduino.com>
Luke Weston
power from the battery if the battery is connected, and only source
power from the USB if the USB is connected but not the battery.
I think that Thomas thinks that it sources power from the USB by
default and only from the battery if the USB port is not connected. So
there's no need to cut the 5V wire on a USB lead, you get the
behaviour you're expecting by default.
I think you can choose either route, really. You can include the 9 V
battery, battery connector, and DC plug in the cost of a kit, or you
can power over USB with no need for any of that. I think the 100 mA
limit for the USB host will be fine.
I've never heard of anybody blowing up an Arduino using only USB power
- solder bridges, shorts and reverse polarities should always put you
over the 100 mA threshold, momentarily, which will trip the USB host
controller's current limiter. A USB host won't allow a device to draw
more than 100 mA unless it negotiates with the host and specifically
requests high power operation, right? You've also got the 500 mA
polyswitch for an extra layer of protection.
They're quite rugged, idiot proof devices, really, until you start
doing something like connecting an unregulated battery to the female
header pins if you don't know what you're doing.
Trent Lloyd
chip on a Diecimiele. I didn't notice, plugged into USB.. it just hit
the current limit.
I wouldn't expect it to be an issue.
Regards,
Trent
Luke Weston
Impressive :)
Trent Lloyd
So, after you removed the solder and plugged it in, did it continue to work as normal?
Impressive :)
--
You received this message because you are subscribed to the Google Groups "arduino-miniconf-2010" group.
To post to this group, send email to arduino-mi...@googlegroups.com.
For more options, visit this group at http://groups.google.com/group/arduino-miniconf-2010?hl=en.
andyg (geekscape)
Picked up my Pebble LCDs from Mitch earlier this evening (or was that
last night) ... thanks Mitch.
On Nov 5, 7:56 pm, Andy Gelme <an...@geekscape.org> wrote:
> Let's enumerate the tasks and perform some timing first ...
headers onto the LCD.
> I've counted all the pins / leads to determine the total number of solder joints required ...
D'oh ! This is another 32 solder joints that I completely forgot :(
Keeping in mind that there is an equivalent 32 solder joints for the 2
female 16-pin headers that would be on the Pebble shield, which the
LCD plugs into.
> Solder joints
> Estimates
(using a stop-watch).
This included getting the pieces out of a box on the desk, snapping
off 2 x 16-pin headers (from a larger strip), clearing some space for
the soldering effort and assembling the components (LCD plus 2
headers) ... so that soldering could commence.
I didn't rush ... it wasn't a race ... and was aiming for quality
solder joints. Counting seconds in my head, I'd estimate I was
performing a solder joint every 5 seconds. Which is about 3 minutes
of soldering in total.
> Testing procedures
there were no short-circuited adjacent pins. Since the 2 headers are
electrically identical, I also checked that the corresponding pins on
each header were connected.
Total time: 4 minutes and 30 seconds.
At the LCA2010 mini-conf, we'll have completed Pebble shields, so the
testing could also include just quickly plugging the LCD with male-
headers into an existing, known working Pebble shield.
- - - - - - - - - - - - - - - - - - - - - - - - -
larger build. So, let's call it 5 minutes.
Given that the whole Pebble *header only* soldering effort is about 4
times the size of what I just completed. I'd be comfortable with an
estimate of 20 minutes for a "practiced" person to solder all of the
Pebble headers.
As a complete guess-timate ... let's say a less experienced person
takes around twice or three times as long ... then, we'd be looking at
between 40 to 60 minutes, for the attendees to get all the Pebble
headers done. I think that is a very generous estimate. If I was
doing a bunch of headers, because they are usually quick and easy, I'd
tend to do them all-in-one-go, and complete that consolidated set of
tasks fairly promptly.
- - - - - - - - - - - - - - - - - - - - - - - - -
appropriate test subject ... and see how long it takes them to perform
the same exercise, whilst I time and observe them.
cheers andyg (@geekscape)
Luke Weston
I would like to toss up a possible idea:
Get an Arduino Pro instead of an Arduino Duemilanove, and solder it on
to the pin headers on the shield.
This would result in a bit of a reduction of overall price if you need
to buy a new Arduino and don't already have one, and it would make the
overall shield plus Arduino assembly less tall and bulky, since the
Arduino Pro is more compact and it can be mounted right up against the
bottom of the PCB with the excess pin header length cut off.
However there are minor disadvantages - you can't disassemble it and
re-use the Arduino, but you'd probably want to leave an Arduino
permanently dedicated to this device in many cases anyway. You also
need an external FTDI module if you want to communicate with the PC or
reprogram the device. But if you're happy with Xbee-only
communications to the aiko gateway or other outside device and once
you're happy with the aiko node codebase, this probably wouldn't be a
big deal - you'd rarely need to use it.
It's not a design option that would suit everyone, but it is something
you can consider.
Mitch Davis
>
> I would like to toss up a possible idea:
>
> Get an Arduino Pro instead of an Arduino Duemilanove, and solder it on
> to the pin headers on the shield.
good for "permanentising" a design you're happy with, and want to
keep.
Mitch.
andyg (geekscape)
Some more Pebble assembly time metrics from this weekend.
But, first the good news ...
Last week, MichaelB created a (beautiful) double-sided PCB using
Luke's latest Pebble schematic design.
On Saturday evening (after the Aiko-Gateway build day), Luke populated
all the components.
It took Luke approximately 2.5 hours to completely solder all the
components onto the PCB.
There was only one 'implementation' mistake (a solder bridge), which
prevented the LCD from operating correctly at first.
Luke mentioned that the double-sided prototype board was more
difficult to populate (than the final professionally manufactured PCB
will be ... with plated thru-holes and solder mask), because several
components need to be soldered via the top-side of the board, slowing
down the whole process.
Luke also found that the 100 Kohm resistor used on the ZigBee serial
connection was too high ... and it needs to be replaced with a 10 Kohm
resistor. After Luke made that change, we were then sending data over
ZigBee from the Arduino / Pebble shield to the host computer ! * This
resistor value change is a (minor) 'design' mistake ... the schematic
and parts purchasing list will need to be updated. *
Picture: the working Pebble, sending sensor data over ZigBee to my
MacBook Pro ... http://twitpic.com/ppf1y
Note: The LCD screen is shifted onto just the top row of headers, so
that the prototyping area and components underneath can be seen (a
very handy feature).
It's possible that Luke (an experienced and quick board assembler) may
be able to complete the Pebble, using a professionally manufactured
PCB, in around 1.5 to 2 hours. And, he only made one small mistake,
which does add to the build time with diagnosis effort, which will
have an unpredictable affect on the total build time. We'll need to
compare / extrapolate this result for LCA attendees, who will probably
not be as experienced as Luke.
People less experienced at hardware assembly, which we assume LCA2010
attendee are, will both take longer than Luke and more likely make
more mistakes.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
As a controlled test, both Luke and Paul were given identical Arduino
proto-shields and under identical "lab" conditions were asked to
solder the 4 Arduino male headers onto the proto-shield. There are 2
x 6-pin headers and 2 x 8-pin headers, for a total of 28 solder
joints.
Luke completed in 3 minutes and Paul completed in just over 7 minutes
(plus 2 additional minutes performing testing using a multi-meter).
Since there are approx. 112 headers to be soldered on the Pebble, I'd
suggest it'll take Paul about 28 minutes (112 / 28 * 7) to complete
just the headers on the Pebble.
Since Paul was approx. half the speed of Luke, I'd expect that it
would take him between 3 and 4 hours to compete a Pebble, using a
manufactured PCB.
With no disrespect intended to Paul, I'd anticipate that he'd make a
couple more errors than Luke (especially on the hand-made PCB) and
that the process of diagnosing each mistake could be a non-trivial
amount of additional time to complete. We experienced exactly this
with the Aiko-Gateway sensor board (late on Saturday evening).
So, I believe that we'll seriously need to consider techniques for
reducing the hardware assembly time (roughly halving it), during the
LCA2010 mini-conf, e.g. semi-populating the board, qualifying the
required experience of attendees (who want to build it on the day).
As well as having the pre-assembled boards ready for the "less brave".
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
I also tried a regular 2 row LCD in the Pebble. It works fine, as
you'd expect, except that a 3.3 Kohm resistor is required (between pin
3 and ground) for the contrast to be set correctly. Perhaps that
resistor can be part of the regular Pebble design, so that people can
easily mix-n-match different LCD screens.
A nice thing about the 2 row LCD is that you get better access to the
prototyping area (but, the white-on-blue 4 row LCD is pretty darn cool
looking).
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
So, it would appear that the Pebble PCB design / schematic is
electrically good ... and that we now need to consider preparing the
Eagle schematic / exported Gerber files, ready for manufacture by
PCBCart.com. At the same time, pursuing options for getting the
Pebble completely assembled ... would be a good thing.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
MichaelC and Mitch also made a significant effort on the Pebble on
Sunday, producing 3 more PCBs that can be populated by various people
(including Paul, our "test" guinea pig). They spent a lot of time
working on improving their process for creating double-sided PCBs ...
and using the CCHS 1/3 built CNC machine as a high-tech drill press
for drilling holes in the Pebble PCB.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Note: No software developers were harmed in the making of the Pebble
board. But, one did get his finger burnt twice over the weekend :(
cheers andyg (geekscape)
Luke Weston
> I also tried a regular 2 row LCD in the Pebble. It works fine, as
> you'd expect, except that a 3.3 Kohm resistor is required (between pin
> 3 and ground) for the contrast to be set correctly. Perhaps that
> resistor can be part of the regular Pebble design, so that people can
> easily mix-n-match different LCD screens.
>
this purpose.
Have you tried using the 2 row LCD, without any extra 3.3k resistor or
similar connected to it, and adjusting the contrast to a desirable
level using the built-in trimpot?
Please feel free to test this; let me know how you go.
An aside: Interestingly, when assembling your spare set of Aiko
gateway router components, I was using a 16 x 2 LCD, the same as the
first batch that you ordered as far as I can tell, and I used a 3.3 k
resistor to set the contrast, which gave sub standard contrast - I had
to change the resistor to 2.2 k to give an optimum level of contrast.
Perhaps there is some "variability" between different LCDs?
After we receive the professionally fabricated boards it would be good
(if we have time to do this) if you could host a "build day" for
Pebbles, Andy. That way, we can get a garage full of volunteers
(including people who are relatively inexperienced) and watch them
assemble some boards, to see how long it takes using the good solder
masked plated-through board, where the tricky areas are, and where it
could be sped up. Also, at the same time, we have the side effect that
we're producing a number of assembled boards (and/or partially
assembled boards for everyone) for the LCA miniconf.
Solder bridges won't be a problem (shouldn't be) on a solder-masked
board.
Andy Gelme
Luke Weston wrote:
>> I also tried a regular 2 row LCD in the Pebble. It works fine, as
>> you'd expect, except that a 3.3 Kohm resistor is required (between pin
>> 3 and ground) for the contrast to be set correctly. Perhaps that
>> resistor can be part of the regular Pebble design, so that people can
>> easily mix-n-match different LCD screens.
>
> There is a trimpot built in on the Pebble PCB near the LCD for exactly
> this purpose.
But, do you know why I didn't remember or see the trimpot ?
Because when a regular 2 x 16 LCD is attached ... the LCD completely
obscures the trimpot, making adjustment impossible :(
> Have you tried using the 2 row LCD, without any extra 3.3k resistor or
> similar connected to it, and adjusting the contrast to a desirable
> level using the built-in trimpot?
> Please feel free to test this; let me know how you go.
However, I persisted and determined ...
1) The current trimpot has a very large range 100 Kohm ... and getting
close to 2.2 Kohm or 3.3 Kohm proved tricky. I removed the LCD and
attempted to adjust using a multi-meter.
2) The documentation for the regular green LCD recommends that the
contrast is set using a 10 Kohm variable resistor. Currently, you have
a 100 Kohm trimpot (between 5V and the LCD contrast pin) and an
additional 10 Kohm resistor (between the LCD contrast pin and ground).
Recommended ...
5 VDC -----+
\
LCD Vd --+ / 10 Kohm variable resistor
\ With wiper connected to LCD Vdisplay
Ground ----+
So, I haven't seen any success yet, just using the trimpot alone.
> Perhaps there is some "variability" between different LCDs ?
> After we receive the professionally fabricated boards it would be good
> (if we have time to do this) if you could host a "build day" for
> Pebbles, Andy. That way, we can get a garage full of volunteers
> (including people who are relatively inexperienced) and watch them
> assemble some boards, to see how long it takes using the good solder
> masked plated-through board, where the tricky areas are, and where it
> could be sped up. Also, at the same time, we have the side effect that
> we're producing a number of assembled boards (and/or partially
> assembled boards for everyone) for the LCA miniconf.
Jonathan Oxer
> Luke Weston wrote:
> > Perhaps there is some "variability" between different LCDs ?
>
> I wouldn't be surprised.
There definitely is. I've used LCD modules from a few different
manufacturers over the last few months and they vary dramatically. Some
you can just hard-wire the contrast pin to ground and they work
brilliantly, others need a voltage that varies anything up to about 1/2
VCC to make it legible. I now just put a 10K trimpot in as a voltage
divider feeding the contrast pin for every LCD I connect because they're
all different.
Cheers :-)
--
Jonathan Oxer
Ph +61 4 3851 6600
Practical Arduino <www.practicalarduino.com>
SuperHouse Automation <www.superhouse.tv>
Geek My Ride! <www.geekmyride.org>
Luke Weston
>
> 1) The current trimpot has a very large range 100 Kohm ... and getting
> close to 2.2 Kohm or 3.3 Kohm proved tricky. I removed the LCD and
> attempted to adjust using a multi-meter.
>
with the wiper connected to pin 3.
When you adjust the pot, the voltage on pin 3 will be variable between
0 and 5 V.
It doesn't matter what the resistances are, it matters what the
voltage is at pin 3.
This is the "standard", "proper" way to set the contrast on a HD44780
LCD display. The easy, cheap "hack" method, using a single 3.3 k
resistor, is a little bit dodgy, and it seems that it can't always be
reliably reproduced on the same model of 16 x 2 Sparkfun LCDs, let
alone on different models of LCD.
> 2) The documentation for the regular green LCD recommends that the
> contrast is set using a 10 Kohm variable resistor.
basically), it shouldn't actually matter if the pot's overall
resistance is 1 k, 10 k, 100 k, or whatever, you still get exactly the
same effect, which is adjustable voltage between 0 and 5 V at pin 3.
The "sensitivity" of that voltage adjustment won't vary if the pot's
overall resistance is different.
> Currently, you have
> a 100 Kohm trimpot (between 5V and the LCD contrast pin) and an
> additional 10 Kohm resistor (between the LCD contrast pin and ground).
>
far as I'm aware there isn't.
There are a couple of other resistors nearby on the board but they
have no connection to the contrast circuit.
Pin 3 goes straight to the pot wiper and to the pot alone.
When you set up a 16 x 2 LCD from Sparkfun, for example on an Aiko
gateway, and you've got a single 3k3 resistor setting the contrast on
the LCD to an appropriate value, what voltage do you see on pin 3? Try
setting the pot on the Pebble to reproduce that voltage.
> Recommended ...
>
> 5 VDC -----+
> \
> LCD Vd --+ / 10 Kohm variable resistor
> \ With wiper connected to LCD Vdisplay
> Ground ----+
>
there should be a pot connected between 5 V and ground with the wiper
connected to pin 3.
That should be exactly what is implemented on the Pebble board, except
for the choice of 10 k vs. 100 k.
Again, exact choice of pot resistance shouldn't matter.
(If all else fails and you absolutely can't change the contrast, we'll
experiment with changing to 10 k.)
Andy Gelme
Luke Weston wrote:
> Perhaps there is some "variability" between different LCDs ?
> There definitely is. I've used LCD modules from a few different
> manufacturers over the last few months and they vary dramatically. Some
> you can just hard-wire the contrast pin to ground and they work
> brilliantly, others need a voltage that varies anything up to about 1/2
> VCC to make it legible. I now just put a 10K trimpot in as a voltage
> divider feeding the contrast pin for every LCD I connect because they're
> all different.
the screw adjustment (horizontally) pointing towards the left-side of
the board ?
That way you wouldn't have to move it from under the LCD (very tricky
... I had a look at that ... it would have to be moved a fair distance).
And, then there would be easy adjustment from the left side with a
screwdriver.
I suspect that replacing the existing 100 Kohm trimpot and 10 Kohm
resistor ... with a single 10 Kohm variable trimpot (on its side)
between 5 VDC and ground, with the wiper connected to the LCD contrast
pin ... would be the way to go.
Andy Gelme
Luke Weston wrote:
> with the wiper connected to pin 3.
> far as I'm aware there isn't.
> for the choice of 10 k vs. 100 k.
I think the key part that I did get right was my concern about the
inaccessibility of the trimpot. My other ramblings can be ignored.
Let's test some LCDs at the CCHS tonight. The regular black-on-green 16
x 2 LCDs seem to have a problem.
p.s. I'm on a mission to turn all your 100 Kohm resistors into 10 Kohm
resistors !
Luke Weston
> p.s. I'm on a mission to turn all your 100 Kohm resistors into 10 Kohm
> resistors !
>
There's a 100 k pull-down resistor on the serial RXD line so that it's
not floating when battery power is used.
Would that work if it was 10 k or is that too strong a pull-down
resistor?
Jonathan Oxer
> There's a 100 k pull-down resistor on the serial RXD line so that it's
> not floating when battery power is used.
> Would that work if it was 10 k or is that too strong a pull-down
> resistor?
Too strong. I'd leave that one as 100K because it only has to stop the
line floating, and it still needs to be assertable (new-word alert!)
when connected. AVRs generally seem to use 20K internally for input
biasing so I'd stick to 100K in this case.
Jonathan Oxer
Group to prune out stuff that's no longer relevant as we enter the
final stages of planning. There'll be a To-Do list going up soon as
well.
Click on http://groups.google.com/group/arduino-miniconf-2010/web/program
- or copy & paste it into your browser's address bar if that doesn't
work.