Mostly, this is an update to let you know that we are still active. CompanyDallas was a great place to meet and we are still thankful for the start they gave the group. But, CompanyDallas is no more and we are still searching for a good place to meet. We need a place that is open until a reasonable hour and will let a group of people work on building circuits and talking among ourselves. There are 2 candidate sites that may be available in early 2012.

We should start off the year with a project using the TI Launchpad. That is the little development board that Texas Instruments sells for under 5 dollars. It uses the MSP430 microcontroller which is slower than an Arduino, but fast enough for many thangs and consumes very little power. If you don’t have a Launchpad yet, you have time to get one before 2012. The project will also use a thermistor and an EEPROM. I’ll get a parts list up when I stop tinkering with the concept.

The last part of 2011 is bringing us several new products that should make interesting projects. I’ll list a few that I know about. If there is something else new that should be here, let me know.

The Raspberry PI is an inexpensive board targeted at teaching kids about the joys of tinkering. The developers speak of their experiences with the Commodore 64 when they were growing up and the desire to create something fun and inexpensive for kids like they used to be. The board should also be interesting to all sorts of hackers and I am sure looking forward to trying one or three of them out. It has an ARM processor and 128 or 256 megabytes of ram and a few ports. It is expected to sell for $25 or $35. http://www.raspberrypi.org/

The BeagleBone should be a nice step up from the AVR based Arduinos. It is also an Arm, but a more advanced one than the Raspberry PI. It seems to be a cost reduced BeagleBoard. The BeagleBoard was always interesting to me, but it was too expensive. Unless I can justify buying for a paid development project, I set a limit of 99 dollars for toys. The BeagleBone is under that limit. It also includes headers like the Arduino for interfacing LEDs and peripheral chips. So, it seems more friendly to hardware hackers. The BeagleBone leave out a way of connecting a video monitor, which is a shame. The Arduinos and Launchpads don’t have video out, so I’ll just think of it as the high end of that market. http://hackaday.com/2011/11/01/say-hello-to-our-little-friend-the-beaglebone/

The Arduino group has their own take on the Arm development boards. They are coming out with the Arduino Due(Italian for 2). I have seen estimates that it will be $60, but I have not seen anything official. The processor and memory are nice steps up from the Arduino Uno, but much less than the BeagleBone. There should be a degree of compatibility with old Arduino sketches and shields, which should be big pluses.http://arduino.cc/blog/2011/09/17/arduino-launches-new-products-in-maker-faire/

I have seen several sources for relatively bright chains of addressable RGB LEDs in the last year or so. They all seem to use the HL1606 controller, which works well with the Arduino. Adafruit Industries has an upgrade to that idea. They use a controller which seems much faster in addressing runs of LEDs. It goes for $35 a meter and I hope to have a meter if I can work out the problem I had placing an order. You can cut the meter up into smaller lengths. Two LEDs is the minimum length. I see several applications I want to make in the next year. http://www.adafruit.com/products/306 and I think a project for the group based on these LEDs would be good. I’d like feedback on that proposal.

I don’t know if this last one is really new. I just heard about it on TheAmpHour podcast. It is a dip version of an Arm CPU. That would be good for people like me who use breadboards for most of their circuits. I don’t know what it takes to program one, and that might be a show stopper.
http://www.nxp.com/products/microcontrollers/cortex_m0/lpc1100l/LPC1114FN28.html

This month, we installed tools to program the TI MSP430 microcontroller.

Local company Texas Instruments makes a nice little microcontroller called the MSP430. It is close to the power of a low end Atmel AVR, but has some advantages. I plan to write a follow up article comparing the microcontrollers. I have been avoiding the msp430 because TI only supports Windows as a development environment and we like to have our workshops support whichever OS participants want to use. Personally, I don’t even use Windows, so I was not interested, anyway. I have been reading lately that there seem to be good working open source solutions that run, at least on Linux. They would probably work on FreeBSD and the Mac. I believe FreeBSD was tested, and I will update this article with results when I get them.

TI has a very inexpensive development board for the MSP430. It is called the Launchpad. It is a lot like an Arduino that someone forgot to put the shield base on. TI sells it for $4.30 plus free shipping at this time. You can order up to 3 boards from TI. Other distributors have it with no limit on the number you can order. We arranged some purchases, so we can all have boards at a future meeting. The plan is to see if we can get the boards before the next meeting after April and build some circuits with the TI chip. This month, we will setup the development environment. If you are using Windows, TI gives you a pointer to free, downloadable tools. You can find it in the TI student guide linked below. The guide also has some exercises, so it is useful for all msp430 beginners. If you are using Linux, the first two links here are to articles about setting up the tool chain. I will use the first one, but the second was tested by someone else at the meeting.

http://www.sakoman.com/OMAP/how-to-develop-msp430-launchpad-code-on-linux.html

http://hackaday.com/2010/08/11/how-to-launchpad-programming-with-linux/

Here is an article on porting Atmel AVR code to the TI msp430.
http://jumptuck.wordpress.com/2010/08/12/porting-avr-code-for-msp430-chips/

Here is a student guide from TI about the Launchpad.
http://software-dl.ti.com/trainingTTO/trainingTTO_public_sw/MSP430_LaunchPad_Workshop/LaunchPad.pdf

Here is a project that built an include file you can use for Arduino programs to let them compile and run on the Launchpad. Not tested yet, but too good not to pass on.
https://github.com/chrishulbert/friendly_launchpad

This is an article showing one way to use the Launchpad with a breadboard. We like breadboarded circuits for our workshops because they are quick to setup and test.
http://www.43oh.com/forum/viewtopic.php?f=8&t=138

The Linux tools run from the command line, so you get to pick your editor. The Linux tools are open source, and don’t have the code size restrictions that you get with the free Windows tools. The free Windows compilers will only create programs up to 2K or 4K in size. Neither limit is a problem for the chips included with the development board. I have seen MSP430 chips with up to 32K of program space, so these chips need the open source tools or a very expensive commercial tool. Being open source gives them a big edge in my mind, but not everyone agrees, I expect.

The Launchpad comes with two 14 pin microcontrollers in DIP form. After programming, they can easily be used in breadboard projects. The Launchpad board can program larger chips. It supports 14 and 20 pin processors. I have not seen any of the 20 pin devices yet, but they do seem to be available for ordering. A 20 pin ZIF socket with long enough pins for breadboard use would be handy to install on a breadboard or the Launchpad board. I am still looking for such sockets at a reasonable price.

I completed the building of the msp430-gcc and mspdebug tools and then tried the blink program in the sakoman article linked above. On my 700 MHz P3, the build took a couple of hours. As you might guess, msp430-gcc is the cross compiler for the msp430. The program mspdebug is useful for uploading code to the Launchpad. Everything worked fine. Once you have these two tools built, we can try putting a program on the msp430. I started with the MSP430G2231. Here is a simple bash script to drive the compile and upload cycle.

#!/bin/sh
die () {
echo >&2 "$@"
exit 1
}

sudo /usr/local/bin/mspdebug rf2500 "prog launchpad.elf"


Save that as 430cc.sh, and make it executable. Then, to compile and upload the blink.c program, you just have to type: ./430cc.sh blink

A local developer for the msp430 wrote a short program that I think is a better place to begin experimenting with the code, so I will include it here. I only changed the first include statement. The one here is correct for using the msp430-gcc compiler. I don’t know what compiler he used, but I will update this when I find out.

// Changes to the 'demo-breathing-led' code by Rusty Haddock.
// Removed 1-sin(x) data array and now calculate an x^2 curve
// on the fly.

// Wait to set the new TACCR1 until TAR has gone past it, so that we
// don't get interrupted again in this period.
while (TAR <= new_ccr1)
;
TACCR1 = new_ccr1;
}


Save that as breathe.c and then run it on your launchpad by typing: ./430cc.sh breathe

We are going to follow the excellent workshop from last month with one that builds on it. We will use a similar 8 pin Atmel microcontroller. The ATTiny13a we used last month is just fine for lots of projects, but we need more memory because we are going to emulate a USB keyboard. We will use a GPL library developed by Objective Development (http://www.obdev.at/products/vusb/index.html). It enables any AVR with enough memory to do a pretty good job of emulating a standard USB device. The AVR with this library is not fully within the USB 1.1 specification, but it works well enough for a lot of things. Before you try to make this into a commercial device, or something you depend on, please test and be sure it meets your needs. We are going to test it and see how well it works for us. I see lots of applications I could use it for. For example, I want a single big key to press when the next page is turned on the book scanner I hope to build. The Objective Development website has a page called Community Projects where you can see how a bunch of other people have used the library.
If you plan on attending this workshop, you need to bring a few things with you. You will need:

3 push buttons suitable for breadboarding
a breadboard
0.1 micro farad capacitor
A sacrificial USB cable
hookup wire
AVR programmer
your computer, setup for Atmel programming

There are other parts needed, but we have them for you, unless we get too many participants. Tanners has .1 micro farad mica capacitors for 19 cents. The original design used electrolytic, but Tanners did not have those. I hope the mica ones work.

This project is derived from the work of Flip. You can see his project at: http://blog.flipwork.nl/?x=entry:entry100224-003937
The main change I made was to cut back the number of buttons from 4 to 3. He wanted to maximize the use of the little AVR chip. He disables reset on pin 1 to make it another button pin. This means he needs a special chip programmer. We are going to skip that complication and limit our design to 3 buttons.

This article is a work in progress. I decided to publish it as I go and maybe there will be some feedback to improve it before the workshop.

On January 14, 2011, we had a workshop on programming Atmel ATTiny13 chips. The ATTiny13 is an 8 pin microcontroller that can do a lot, and costs about $2 in low volume. The workshop was conducted by Dale Wheat and he did an excellent job. Dale’s guide is available here.(VeryTinyDevelopment). This is just my notes. They don’t give all the nice detail Dale had. They are intended to add some information that I think might help on our future projects. Since the February 2011 project will use the same programmer we learned about this month, but use the ATTiny45 or the ATTiny85, I will show where the differences matter to us.

Dale found some inexpensive chip programmers for AVR chips. They are compatible with the Atmel AVRISP mkii and cost about $10 each. Here is a picture of one.

To connect the programmer to the breadboard containing the ATTiny, we use a breakout board developed by Dale and a 10 pin ribbon cable. Here is a picture of a breadboard with the board plugged in with an ATTiny chip in it.

Dale had a nice exercise that showed us how to program the chip and run a program to blink 1 to 4 LEDs. Here is what the populated breadboard looked like.

Resources:
Datasheet on Atmel ATTiny 25/45/85
http://www.atmel.com/dyn/resources/prod_documents/doc2586.pdf

Datasheet on Atmel ATTiny 13/13V
http://www.atmel.com/dyn/resources/prod_documents/doc2535.pdf

Important differences between ATTiny13a and ATTiny85
1. ATTiny85 has more memory
2. ATTiny85 pin 2, 3 have added function of XTAL and OC1B
3. ATTiny85 pin 5, 6, 7 have slightly different functions
4. AtTiny85 has a superset of the machine instruction set of ATTiny13a
5. memory(flash/eeprom/sram) AtTiny13 1K/64/64 ATTiny85 8K/512/512
6. sample compile options for ATTiny13a/ATTiny45/ATTiny85
avr-gcc -mmcu=attiny13a blink.c -o blink.o
avr-gcc -mmcu=attiny45 blink.c -o blink.o
avr-gcc -mmcu=attiny85 blink.c -o blink.o
7. sample program upload options for ATTiny13a/ATTiny45/ATTiny85
sudo avrdude -p attiny13 -c avrispmkii -P usb -U flash:w:blink.hex
sudo avrdude -p attiny45 -c avrispmkii -P usb -U flash:w:blink.hex
sudo avrdude -p attiny85 -c avrispmkii -P usb -U flash:w:blink.hex

To find out which AVR chips your compiler and assembler support, type
avr-as –help

Information to add. Someone in the group found a nice way to avoid having to upload the program using sudo. Document that here.

The regional Python conference for Texas is coming up soon and I was asked to make a timer for the lightning talk events. Here is what I came up with and I am interested in comments on improving it. 

/*
  Lightning Talk Timer
 
 Show green light during bulk of talk.  Show yellow in the last
 10 seconds.  Show red when the time is up.
 
 The circuit:
 * Green LED connected from digital pin 9 to ground.
 * Red LEDs connected from digital pins 12,13 to ground.
 * Yellow LEDs connected from digital pins 10,11 to ground.
 * Note: On most Arduino boards, there is already an LED on the board
 connected to pin 13, so you don't need any extra components for this example.
 
 Created 29 July 2010
 By Ralph Green
 
 based on an orginal by H. Barragan for the Wiring i/o board
 
 */
int switchPin = 2;              // Switch connected to digital pin 2
int redLedPin1 = 12;    // LED connected to digital pin 12
int redLedPin2 = 13;    // LED connected to digital pin 13
int yellowLedPin1 = 10;    // LED connected to digital pin 10
int yellowLedPin2 = 11;    // LED connected to digital pin 11
int greenLedPin =  9;    // LED connected to digital pin 9
int which, CounterState;
int pause;
int killLoopCounter;
unsigned long startTime, newTime, nextStepTime;
unsigned long TalkLengthSeconds = 300;
unsigned long WarningTimeSeconds = 10;

// The setup() method runs once, when the sketch starts

void setup()   {                
  Serial.begin(9600);           // set up Serial library at 9600 bps
  pinMode(switchPin, INPUT);    // sets the digital pin as input to read switch
  // initialize the digital pin as an output:
  pinMode(greenLedPin, OUTPUT);     
  pinMode(redLedPin1, OUTPUT);     
  pinMode(redLedPin2, OUTPUT);     
  pinMode(yellowLedPin1, OUTPUT);     
  pinMode(yellowLedPin2, OUTPUT);     
  digitalWrite(greenLedPin, LOW);   // set the LED off
  digitalWrite(redLedPin1, LOW);    // set the LED off
  digitalWrite(redLedPin2, LOW);    // set the LED off
  digitalWrite(yellowLedPin1, LOW);    // set the LED off
  digitalWrite(yellowLedPin2, LOW);    // set the LED off
  digitalWrite(greenLedPin, HIGH);   // set the LED on
  delay(400);                  // wait for a bit
  digitalWrite(greenLedPin, LOW);   // set the LED of
  digitalWrite(yellowLedPin1, HIGH);    // set the LED on
  digitalWrite(yellowLedPin2, HIGH);    // set the LED on
  delay(400);                  // wait for a bit
  digitalWrite(yellowLedPin1, LOW);    // set the LED off
  digitalWrite(yellowLedPin2, LOW);    // set the LED off
  digitalWrite(redLedPin1, HIGH);    // set the LED on
  digitalWrite(redLedPin2, HIGH);    // set the LED on
  delay(400);                  // wait for a bit
  digitalWrite(redLedPin1, LOW);    // set the LED off
  digitalWrite(redLedPin2, LOW);    // set the LED off
  delay(400);                  // wait for a bit
  which = 1;
  CounterState = 0;
  killLoopCounter = 0;
}

// the loop() method runs over and over again,
// as long as the Arduino has power

void loop()                     
{
//  Serial.println(CounterState);
  switch (CounterState) {
  case 0: // Initial state. Blink to tell the world you are alive
    if (digitalRead(switchPin) == 1) {// Read the pin
      CounterState = 1;
      startTime = millis();
      nextStepTime = (TalkLengthSeconds - WarningTimeSeconds) * 1000;
      pause = 0;
    }
    else {
      if (--killLoopCounter < 1) {
        killLoopCounter = 80;
        digitalWrite(greenLedPin, HIGH);   // set the LED on
      }
      else if (killLoopCounter < 78) {
        digitalWrite(greenLedPin, LOW);   // set the LED on
      }
      delay(40);                  // wait for a bit
    }
    break;
  case 1: // Start countdown for the main part of the talk
    newTime = millis();
    if (digitalRead(switchPin) == 1) {// Read the pin
      if (pause == 0) {
        pause = 1;
        nextStepTime -= (newTime - startTime);
      }
      digitalWrite(greenLedPin, LOW);   // set the LED off
      break;
    }
    else {
      if (pause == 1) { // we must be coming off a pause
        pause = 0;
        newTime = startTime = millis();
      }
      digitalWrite(greenLedPin, HIGH);   // set the LED on
      delay(20);                  // wait for 20 milliseconds
    }
    if ((newTime - startTime) > nextStepTime) {
      CounterState = 2;
      startTime = millis();
      nextStepTime = WarningTimeSeconds * 1000;
    }
    break;
  case 2: // Warn that the time for the talk is almost over
    newTime = millis();
    digitalWrite(greenLedPin, LOW);   // set the LED off
    digitalWrite(yellowLedPin1, HIGH);   // set the LED on
    digitalWrite(yellowLedPin2, HIGH);   // set the LED on
    if ((newTime - startTime) > nextStepTime) {
      CounterState = 3;
    }
    break;
  case 3: // Show that time is up until button signals another round
    digitalWrite(yellowLedPin1, LOW);   // set the LED off
    digitalWrite(yellowLedPin2, LOW);   // set the LED off
    digitalWrite(redLedPin1, HIGH);    // set the LED on
    digitalWrite(redLedPin2, HIGH);    // set the LED on
    if (digitalRead(switchPin) == 1) // Read the pin and display the value
      CounterState = 4;
    else
      delay(20);                  // wait for a bit
    break;
  default: // Reset variables for another lightning talk round
    digitalWrite(greenLedPin, LOW);   // set the LED off
    digitalWrite(redLedPin1, LOW);    // set the LED off
    digitalWrite(redLedPin2, LOW);    // set the LED off
    digitalWrite(yellowLedPin1, LOW);    // set the LED off
    digitalWrite(yellowLedPin2, LOW);    // set the LED off
    which = 1;
    CounterState = 0;
    killLoopCounter = 0;
    delay(250);                  // wait for a quarter second
  }
}

The project for June and July is to control a fan motor with the Arduino. We are using computer fans, which have speed sensors. The intention is that the Arduino will regulate the speed of the fan to a given RPM value.
The first attempt uncovered a limitation of the Arduino software. With a standard program, where you read the sensor and calculate the speed, the speed seems erratic and the the value received seems low. This is most likely due to the Arduino not being fast enough to do the job this way. Here is the program we used.

int ledCylon[5] = {3, 6, 9, 10, 11};
// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 5; // the number of the pushbutton pin
const int ledRed = 13; // the number of the LED pin
const int ledGreen = 12; // the number of the LED pin
const int fanPWM = 3; // the number of the LED pin

Serial.println (endtime - starttime);
// if(digitalRead(2) == HIGH)
// if (count < 60)
// Serial.print("1"); // print as an ASCII-encoded decimal
// else {
// Serial.println("1");
// count = 0;
// }
// else
// if (count < 60)
// Serial.print("0");
// else {
// Serial.println("0");
// count = 0;
// }
}


What we need to do is use interrupts to get the sensor readings and that will be the main focus for July, 2010.

We’re going to formalize the meeting schedule and go with the 2nd Friday of the month. The next meeting will be held on January 8, 2010 @ 6PM. If this is a bad day for anyone, let us know and we’ll try to work something out overall.

For the January project, we will be driving a motor from an Arduino. We will be following the tutorial at: http://itp.nyu.edu/physcomp/Labs/DCMotorControl. The parts you will need are:
LED
10Kohm resistors
switch
L293NE
12V power supply
DC motot
Arduino
Breadboard

We were recently given a large number of electronic parts that will be useful for many of the type of projects we intend to have. These parts will be made available to people who build our monthly projects at no cost. I will give credit to the person who donated them after I work out how the credit is to be given. I am putting the parts in a database and I will put a report on that database here. Most of the parts are diodes, capacitor and resistors. I am starting with cataloging ICs.

+——–+——-+———-+———-+————————————————————+
| box | shelf | partnum | category | descrip |
+——–+——-+———-+———-+————————————————————+
| EW0001 | 1 | 54hc123 | logic | Dual retriggerable monostable multivibrator with reset |
| EW0001 | 1 | 74hc00 | logic | Quad 2-input NAND gate |
| EW0001 | 1 | 74hc02 | logic | Quad 2-input NOR gate |
| EW0001 | 1 | 74hc04 | logic | Hex inverter |
| EW0001 | 1 | 74hc10 | logic | Triple 3-input NAND gate |
| EW0001 | 1 | 74hc109 | logic | Dual JK flip-flop with set and reset |
| EW0001 | 1 | 74hc138 | logic | 3-to-8 Line Decoder |
| EW0001 | 1 | 74hc14 | logic | Hex inverting Schmitt trigger |
| EW0001 | 1 | 74hc157 | logic | Quad 2-Input Data Selectors/Multiplexers |
| EW0001 | 1 | 74hc160 | logic | Synchronous Decade Counter with Asynchronous Clear |
| EW0001 | 1 | 74hc161 | logic | Presettable synchronous 4-bit binary counter |
| EW0001 | 1 | 74hc162 | logic | Presettable synchronous BCD decade counter |
| EW0001 | 1 | 74hc164 | logic | 8-bit serial-in, parallel-out shift register |
| EW0001 | 1 | 74hc175 | logic | Quad D Flip-Flop with Common Clock and Reset |
| EW0001 | 1 | 74hc221 | logic | Dual non-retriggerable monostable multivibrator with reset |
| EW0001 | 1 | 74hc241 | logic | Octal buffer/line driver; 3-state |
| EW0001 | 1 | 74hc243 | logic | Quad bus transceiver; 3-state |
| EW0001 | 1 | 74hc244 | logic | Octal buffer/line driver; 3-state |
| EW0001 | 1 | 74hc251 | logic | 8-Input Data Selector/Multiplexer with 3-State Outputs |
| EW0001 | 1 | 74hc266 | logic | QUADRUPLE 2 INPUT EXCLUSIVE NOR |
| EW0001 | 1 | 74hc373 | logic | Octal 3-State Non-Inverting Transparent Latch |
| EW0001 | 1 | 74hc374 | logic | Octal D-Type Flip-Flop |
| EW0001 | 1 | 74hc4020 | logic | 14-stage binary ripple counter |
| EW0001 | 1 | 74hc4060 | logic | 14 Stage Binary Counter |
| EW0001 | 1 | 74hc4316 | logic | Quad Bilateral Switches |
| EW0001 | 1 | 74hc573 | logic | Octal D-type transparent latch |
| EW0001 | 1 | 74hc574 | logic | Octal D-type flip-flop |
| EW0001 | 1 | 74hc74 | logic | Dual D-type flip-flop with set and reset; |
| EW0001 | 1 | 74hc82 | logic | 2-Bit Binary Full Adder |
| EW0001 | 1 | 74hc85 | logic | 4-bit magnitude comparator |
| EW0001 | 1 | 74hct14 | logic | Hex inverting Schmitt trigger |
| EW0001 | 1 | 74hct162 | logic | Presettable synchronous BCD decade counter |
+——–+——-+———-+———-+————————————————————+

Guys/Gals,

We’ve been under a bot attack to our Comments area….if you have posted a comment in the past and don’t see it – please repeat the comment again.  If you would like to post a comment – you will now need to be a registered user on the site AND be logged in before you can post.  This is hoped to help reduce the amount of comment spam.

-dave

We have talked about this further and we are going to open it back up for comments. No login needed, as long as we can handle it. We want to make it easier for our users, yet keep the spammers and such away.

Most of the comments clearly come from bots. There are lots of links from porn sites and people who purport to sell drugs. None of those will ever be approved, but I doubt the bots will notice this message. A little more interesting are the comments that are just linkbait. A few examples were

My wife and I have been longing for this facts all afternoon.

I really love to read this post and I am glad to find your distinguished way of writing the post.

Buy cod cheapest Singapore

Once again, you have managed to captivate my interest with another great post. I find it all very exciting.

I know cod is a northern fish, so I don’t understand why anyone would expect to get it from Singapore. The others are nice compliments, if they were real. But, they are all so generic that I don’t believe someone actually, consciously entered them to our website. If you genuinely made a comment, and it has not shown up, please try again. Make some reference to our actual content and don’t include a link to some site that wants to sell something.

The roads aren’t too bad so I plan to be there for this evening’s meeting. Again, this will be primarily Show & Tell and work on your own project night so you’re not really missing anything if you don’t attend tonight. If you do plan to attend, please drive safely and we’ll see you at 6pm.

If by chance no one shows we’ll likely stick around until 6:45-7pm before ending the meeting.