Posts with «sparkfun» label

New Project: The Internet of Bees: Adding Sensors to Monitor Hive Health

Learn how to pull realtime sensor data from a beehive to monitor its weight, temperature, and humidity over the internet.

Read more on MAKE

The post The Internet of Bees: Adding Sensors to Monitor Hive Health appeared first on Make: DIY Projects, How-Tos, Electronics, Crafts and Ideas for Makers.

Arduino Vs. Arduino: The Reseller’s Conundrum

Over the last few months, the internal struggles between the various founders of Arduino have come to a head. This began last November when Arduino SRL (the Italian version of an LLC) sued Arduino LLC for trademark infringement in Massachusetts District court. To assuage the hearts and minds of the maker community, Arduino SRL said they were the real Arduino by virtue of being the first ones to manufacture Arduino boards. A fork of the Arduino IDE by Arduino SRL – simply an update to the version number – was a ploy to further cement their position as the true developers of Arduino.

This is a mess, but not just for two organizations fighting over a trademark. If you’re selling Arduinos in your web store, which Arduino do you side with?

[Nate] from Sparkfun is answering that question with a non-answer.

Currently, Arduino SRL is the only source of Arduino Unos. Sparkfun will continue to buy Unos from SRL, but they’re not necessarily siding with Arduino SRL; people demand blue Arduinos with Italy silkscreened on the board, and Sparkfun is more than happy to supply these.

There are, however, questions about the future of Arduino hardware. The Arduino software stack will surely be around in a year, but anyone that will be purchasing thousands of little blue boards over the next year is understandably nervous.

This isn’t the first time Sparkfun has faced a challenge in Arduino supply. In 2012, when the Arduino Uno R3 was released, all the documentation for their very popular Inventor’s Kit was obsoleted overnight. In response to these supply chain problems, Sparkfun created the RedBoard.

Sparkfun has always offered to pay royalties on the RedBoard to Arduino LLC, just as they do with the Arduino Pro and Pro Mini. Effectively, Sparkfun is on the fence, with offers to manufacture the Arduino Zero, Uno, Mega, and Due coming from the LLC.

The reason for this is consumers. If someone wants an Arduino SRL-manufactured board, they’ll buy it. If, however, a customer wants to support Arduino LLC, that option is on the table as well.

It’s not a pretty position to be in, but it does show how someone can support one Arduino over another. In a year or two, there will only be one Arduino, but until then, if you have a preference, at least Sparkfun is giving you a choice.

Credit to Sparkfun for the great Spy vs. Spy image. Why don’t you sell googly eyes?


Filed under: Arduino Hacks, news

World’s Largest “Nixie” Clock at World Maker Faire

World Maker Faire was host to some incredible projects. Among the favorites was Nixie Rex [YouTube Link]. Nixie Rex is actually a Panaplex display, since it’s glow comes from 7 planer segments rather than 10 stacked wire digits. One thing that can’t be contested is the fact that Rex is BIG. Each digit is nearly 18 inches tall!

Nixie Rex was created by [Wayne Strattman]. Through his company Strattman Design, [Wayne] supplies lighting effects such as plasma globes and lightning tubes to the museums and corporations. Nixie Rex’s high voltage drive electronics were created by [Walker Chan], a PHD student at MIT. Believe it tor not the entire clock runs on an ATmega328P based Arduino. The digits are daisy chained from the arduino using common Ethernet cables and RJ45 connectors. A Sparkfun DS1307 based real-time clock module ensures the Arduino keeps accurate time.

[Wayne] and Rex were located in “The Dark Room” at Maker Faire, home to many LED and low light projects. The dim lighting certainly helped with the aesthetics, but it did make getting good photos of the clock difficult. Long time Hackaday tipster [Parker] graciously provided us with a size reference up above.

Click past the break to see a closeup of that awesome cathode glow, and a video of the Nixie Rex  in action.

Got to love that tube glow.

 


Filed under: clock hacks

Sparkfun Ships 2000 MicroViews Without Bootloaders

Everyone has a bad day right? Monday was a particularly bad day for the folks at Sparkfun. Customer support tickets started piling up, leading to the discovery that they had shipped out as many as 1,934 MicroViews without bootloaders.

MicroView is the tiny OLED enabled, Arduino based, microcontroller system which had a wildly successful Kickstarter campaign earlier this year. [Marcus Schappi], the project creator, partnered up with SparkFun to get the MicroViews manufactured and shipped out to backers. This wasn’t a decision made on a whim, Sparkfun had proven themselves by fulfilling over 11,000 Makey Makey boards to backers of that campaign.

Rather than downplay the issue, Sparkfun CEO [Nathan Seidle] has taken to the company blog to explain what happened, how it happened, and what they’re going to do to make it right for their customers. This positions them as the subject of our Fail of the Week column where we commiserate instead of criticize.

First things first, anyone who receives an effected MicroView is getting a second working unit shipped out by the beginning of November. Furthermore, the bootloaderless units can be brought to life relatively easily. [Nate] provided a hex file with the correct bootloader. Anyone with an Atmel AVR In-System Programming (ISP) programmer and a steady hand can bring their MicroView to life. Several users have already done just that. The bootloader only has to be flashed via ISP once. After that, the MicroView will communicate via USB to a host PC. Sparkfun will publish a full tutorial in a few weeks.

Click past the break to read the rest of the story.

So what went wrong? The crux of the problem is a common one to manufacturing: An incomplete production test. For many of their products, Sparkfun loads a single hex file containing the production test and the optiboot bootloader. The test code proves out the functionality of the device, and the bootloader allows the customer to flash the device with their own sketches. The problem is the bootloader normally connects to a PC host via USB. Enumerating a USB connection can take up to 30 seconds. That’s way too slow for volume production.

Sparkfun opted to skip the bootloader test, since all the pins used to load firmware were electrically tested by their production test code. This has all worked fine for years – until now. The production team made a change to the test code on July 18th. The new hex file was released without the bootloader. The production test ran fine, and since no one was testing the bootloader, the problem wasn’t caught until it was out in the wild.

The Sparkfun crew are taking several steps to make sure this never happens again.They’re using a second ATmega chip on their test fixture to verify the bootloader without the slow PC enumeration step. Sparkfun will also avoid changing firmware during a production run. If firmware has to change, they’re planning to beta test before going live on the production line. Finally, Sparkfun is changing the way they approach large scale production. In [Nathan's] own words:

Moving from low volume to mid-volume production requires a very different approach. SparkFun has made this type of mistake before (faulty firmware on a device) but it was on a smaller scale and we were agile enough to fix the problem before it became too large. As we started producing very large production runs we did not realize quality control and testing would need very different thinking. This was a painful lesson to learn but these checks and balances are needed. If it didn’t happen on Microview it would have happened on a larger production run someday in the future.

Everyone has bad days, this isn’t the first time Sparkfun has lost money due to a mistake. However, they’re doing the right thing by attacking it head on and fixing not only the immediate issue but the underlying thought process which allowed the problem to arise.


Filed under: Hackaday Columns, news

How to Fix Your Broken MicroView

The response by GeekAmmo and Sparkfun to the MicroView problem has been amazing, but you can fix your broken one fairly simply if you're prepared to crack the case.

Read more on MAKE

Are you experiencing problems with your new MicroView?

If you're having problems with your MicroView, you aren't alone, as it appears that close to 2,000 boards may have been sent out without bootloaders. We talk to Marcus Schappi about the problem.

Read more on MAKE

Tutorial – Arduino and Color LCD

Learn how to use an inexpensive colour LCD shield with your Arduino. This is chapter twenty-eight of our huge Arduino tutorial series.

Updated 03/02/2014

There are many colour LCDs on the market that can be used with an Arduino, and for this tutorial we’re using a relatively simple model available that is available from suppliers such as Tronixlabs, based on a small LCD originally used in Nokia 6100 mobile phones:

These are a convenient and inexpensive way of displaying data, or for monitoring variables when debugging a sketch. Before getting started, a small amount of work is required.

From the two examples we have seen, neither of them arrive fitted with stacking headers (or in Sparkfun’s case – not included) or pins, so before doing anything you’ll need to fit your choice of connector. Although the LCD shield arrived with stacking headers, we used in-line pins as another shield would never be placed on top:

Which can easily be soldered to the shield in a few minutes:

 While we’re on the subject of pins – this shield uses D3~D5 for the three buttons, and D8, 9, 11 and 13 for the LCD interface. The shield takes 5V and doesn’t require any external power for the backlight. The LCD module has a resolution of 128 x 128 pixels, with nine defined colours (red, green, blue, cyan, magenta, yellow, brown, orange, pink) as well as black and white.

So let’s get started. From a software perspective, the first thing to do is download and install the library for the LCD shield. Visit the library page here. Then download the .zip file, extract and copy the resulting folder into your ..\arduino-1.0.x\libraries folder. Be sure to rename the folder to “ColorLCDShield“. Then restart the Arduino IDE if it was already open.

At this point let’s check the shield is working before moving forward. Once fitted to your Arduino, upload the ChronoLCD_Color sketch that’s included with the library, from the IDE Examples menu:

This will result with a neat analogue clock you can adjust with the buttons on the shield, as shown in this video.

It’s difficult to photograph the LCD – (some of them have very bright backlights), so the image may not be a true reflection of reality. Nevertheless this shield is easy to use and we will prove this in the following examples. So how do you control the color LCD shield in your sketches?

At the start of every sketch, you will need the following lines:

#include "ColorLCDShield.h"
LCDShield lcd;

as well as the following in void setup():

lcd.init(PHILIPS); 
lcd.contrast(63); // sets LCD contrast (value between 0~63)

With regards to lcd.init(), try it first without a parameter. If the screen doesn’t work, try EPSON instead. There are two versions of the LCD shield floating about each with a different controller chip. The contrast parameter is subjective, however 63 looks good – but test for yourself.

Now let’s move on to examine each function with a small example, then use the LCD shield in more complex applications.

The LCD can display 8 rows of 16 characters of text. The function to display text is:

lcd.setStr("text", y,x, foreground colour, background colour);

where x and y are the coordinates of the top left pixel of the first character in the string. Another necessary function is:

lcd.clear(colour);

Which clears the screen and sets the background colour to the parameter colour.  Please note – when referring to the X- and Y-axis in this article, they are relative to the LCD in the position shown below. Now for an example – to recreate the following display:

… use the following sketch:

// Example 28.1
#include "ColorLCDShield.h"
LCDShield lcd;

void setup()
{
 // following two required for LCD
 lcd.init(PHILIPS); 
 lcd.contrast(63); // sets LCD contrast (value between 0~63)
}

void loop()
{
 lcd.clear(BLACK);
 lcd.setStr("ABCDefghiJKLMNOP", 0,2, WHITE, BLACK);
 lcd.setStr("0123456789012345", 15,2, WHITE, BLACK);
 lcd.setStr("ABCDefghiJKLMNOP", 30,2, WHITE, BLACK);
 lcd.setStr("0123456789012345", 45,2, WHITE, BLACK);
 lcd.setStr("ABCDefghiJKLMNOP", 60,2, WHITE, BLACK);
 lcd.setStr("0123456789012345", 75,2, WHITE, BLACK);
 lcd.setStr("ABCDefghiJKLMNOP", 90,2, WHITE, BLACK);
 lcd.setStr("0123456789012345", 105,2, WHITE, BLACK);
 do {} while (1>0);
}

In example 28.1 we used the function lcd.clear(), which unsurprisingly cleared the screen and set the background a certain colour.

Let’s have a look at the various background colours in the following example. The lcd.clear()  function is helpful as it can set the entire screen area to a particular colour. As mentioned earlier, there are the predefined colours red, green, blue, cyan, magenta, yellow, brown, orange, pink, as well as black and white. Here they are in the following example:

// Example 28.2

int del = 1000;
#include "ColorLCDShield.h"
LCDShield lcd; 
void setup() 
{ 
  // following two required for LCD 
  lcd.init(PHILIPS); 
  lcd.contrast(63); // sets LCD contrast (value between 0~63) 
}

void loop()
{
 lcd.clear(WHITE);
 lcd.setStr("White", 39,40, WHITE, BLACK);
 delay(del);
 lcd.clear(BLACK);
 lcd.setStr("Black", 39,40, WHITE, BLACK);
 delay(del);
 lcd.clear(YELLOW);
 lcd.setStr("Yellow", 39,40, WHITE, BLACK);
 delay(del);
 lcd.clear(PINK);
 lcd.setStr("Pink", 39,40, WHITE, BLACK);
 delay(del);
 lcd.clear(MAGENTA);
 lcd.setStr("Magenta", 39,40, WHITE, BLACK);
 delay(del);
 lcd.clear(CYAN);
 lcd.setStr("Cyan", 39,40, WHITE, BLACK);
 delay(del);
 lcd.clear(BROWN);
 lcd.setStr("Brown", 39,40, WHITE, BLACK);
 delay(del);
 lcd.clear(ORANGE);
 lcd.setStr("Orange", 39,40, WHITE, BLACK);
 delay(del);
 lcd.clear(BLUE);
 lcd.setStr("Blue", 39,40, WHITE, BLACK);
 delay(del);
 lcd.clear(RED);
 lcd.setStr("Red", 39,40, WHITE, BLACK);
 delay(del);
 lcd.clear(GREEN);
 lcd.setStr("Green", 39,40, WHITE, BLACK);
 delay(del);
}

And now to see it in action. In this demonstration video the colours are more livid in real life, unfortunately the camera does not capture them so well.

 

Now that we have had some experience with the LCD library’s functions, we can move on to drawing some graphical objects. Recall that the screen has a resolution of 128 by 128 pixels. We have four functions to make use of this LCD real estate, so let’s see how they work. The first is:

lcd.setPixel(int colour, Y, X);

This function places a pixel (one LCD dot) at location x, y with the colour of colour.

Note – in this (and all the functions that have a colour parameter) you can substitute the colour (e.g. BLACK) for a 12-bit RGB value representing the colour required. Next is:

lcd.setLine(x0, y0, x1, y1, COLOUR);

Which draws a line of colour COLOUR, from position x0, y0 to x1, y1. Our next function is:

lcd.setRect(x0, y0, x1, y1, fill, COLOUR);

This function draws an oblong or square of colour COLOUR with the top-left point at x0, y0 and the bottom right at x1, y1. Fill is set to 0 for an outline, and 1 for a filled oblong. It would be convenient for drawing bar graphs for data representation. And finally, we can also create circles, using:

lcd.setCircle(x, y, radius, COLOUR);

X and Y is the location for the centre of the circle, radius and COLOUR are self-explanatory. We will now use these graphical functions in the following demonstration sketch:
// Example 28.3

#include "ColorLCDShield.h"
LCDShield lcd;
int del = 1000;
int xx, yy = 0;

void setup()
{
  lcd.init(PHILIPS); 
  lcd.contrast(63); // sets LCD contrast (value between 0~63)
  lcd.clear(BLACK);
  randomSeed(analogRead(0));
}

void loop()
{
  lcd.setStr("Graphic Function", 40,3, WHITE, BLACK);
  lcd.setStr("Test Sketch", 55, 20, WHITE, BLACK); 
  delay(5000);
  lcd.clear(BLACK);
  lcd.setStr("lcd.setPixel", 40,20, WHITE, BLACK);
  delay(del);
  lcd.clear(BLACK);
  for (int a=0; a<500; a++)
  {
    xx=random(160);
    yy=random(160);
    lcd.setPixel(WHITE, yy, xx);
    delay(10);
  }
  delay(del);
  lcd.clear(BLACK);
  lcd.setStr("LCDDrawCircle", 40,10, WHITE, BLACK);
  delay(del);
  lcd.clear(BLACK); 
  for (int a=0; a<2; a++)
  {
    for (int b=1; b<6; b++)
    {
      xx=b*5;
      lcd.setCircle(32, 32, xx, WHITE);
      delay(200);
      lcd.setCircle(32, 32, xx, BLACK);
      delay(200);
    }
  }
  lcd.clear(BLACK); 
  for (int a=0; a<3; a++)
  {
    for (int b=1; b<12; b++)
    {
      xx=b*5;
      lcd.setCircle(32, 32, xx, WHITE);
      delay(100);
    }
    lcd.clear(BLACK);
  }
  lcd.clear(BLACK); 
  for (int a=0; a<3; a++)
  {
    for (int b=1; b<12; b++)
    {
      xx=b*5;
      lcd.setCircle(32, 32, xx, WHITE);
      delay(100);
    }
    lcd.clear(BLACK);
  }
  delay(del);
  lcd.clear(BLACK);
  lcd.setStr("LCDSetLine", 40,10, WHITE, BLACK);
  delay(del);
  lcd.clear(BLACK); 
  for (int a=0; a<160; a++)
  {
    xx=random(160);
    lcd.setLine(a, 1, xx, a, WHITE);
    delay(10);
  }
  lcd.clear(BLACK);
  lcd.setStr("LCDSetRect", 40,10, WHITE, BLACK);
  delay(del);
  lcd.clear(BLACK); 
  for (int a=0; a<10; a++)
  {
    lcd.setRect(32,32,64,64,0,WHITE);
    delay(200);
    lcd.clear(BLACK);
    lcd.setRect(32,32,64,64,1,WHITE);
    delay(200);
    lcd.clear(BLACK); 
  }
  lcd.clear(BLACK); 
}

The results of this sketch are shown in this video. For photographic reasons, I will stick with white on black for the colours.

So now you have an explanation of the functions to drive the screen – and only your imagination is holding you back.

Conclusion

Hopefully this tutorial is of use to you. and you’re no longer wondering “how to use a color LCD with Arduino”. They’re available from our tronixlabs store. And if you enjoyed this article, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop”.

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column, or join our forum – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

The post Tutorial – Arduino and Color LCD appeared first on tronixstuff.

Visualized: Arduino Uno shows up in NASA's Swamp Works facility

There are certain things you'd expect to encounter on a visit to NASA's Swamp Works research facility. Walking into the former Apollo testing facility, you'll almost certainly catch glimpses of martian rovers, soil samples and an assortment of scientific testing devices. But in spite of Arduino's near ubiquity these days, we'll admit that we were a bit taken aback when the familiar blue microcontroller made an appearance on a lab desk during our conversation with NASA "lighting guy," Dr. Eirik Holbert. It seems that NASA, like pretty much everyone else, is experimenting with the hacker-friendly component.

The board was hooked up to a lighting fixture Holbert is working on as part of NASA's upcoming deep space habitat concept generator. It's an attempt to bring some sunlit consistency to space exploration, simulating Earth-like lighting patterns to help keep the crew alert and get them ready for sleep in the evenings. So, where does NASA turn when it's looking to conserve weight and save some taxpayer money in the process? Toward the Arduino Uno, naturally. Holbert assembled a number of off-the-shelf products, including the aforementioned microcontroller and shields from Sparkfun to make a fixture for under $500.

Asked whether we might be seeing an Arduino setup like this on an upcoming mission, Dr. Holbert told us, "I'm all about interchangeability. If they can make something space compatible, I'd be all for it."

Filed under: Science

Comments

Engadget 21 Feb 07:33

BeetBox drops a beat with a side of Raspberry Pi, and other plant puns (video)

Sometimes the plays on words are unavoidable -- in fact, they form the very heart of Scott Garner's recent musical creation. His BeetBox turns six of its namesake root vegetables into drum pads through SparkFun capacitive touch sensors, all of which are controlled by (what else?) a Raspberry Pi. Cleverness goes beyond the core technology and food jokes, as well. All of the circuitry and audio equipment is hidden within the wood box, making it look more like a horticultural project than machinery. We don't mind the lack of production plans when there's source code available; we're mostly curious as to what in our garden would make for a good rhythm section.

[Image credit: Scott Garner, Flickr]

Continue reading BeetBox drops a beat with a side of Raspberry Pi, and other plant puns (video)

Filed under: Misc, Alt

Comments

Via: Gizmag

Source: Scott Made This

Engadget 20 Dec 05:58

Self-balancing unicycle using Arduino and Sparkfun IMU

Here’s proof that you can build cool stuff with simple tools. This self-balancing unicycle uses an Arduino and a five degree of freedom IMU from Sparkfun to keep the rider upright. Well, it’ll keep you upright as long as you have good side-to-side balance. But that’s true of any unicycle, right?

The Raptor was built by [Nick Thatcker] who is no stranger to self-balancing transportation. A few years back he built a Segway clone and the same type of geared motor used in that project also went into this one. I connects to the wheel with a chain, allowing him to keep the motor hidden in the saddle. He gets between 90 and 120 minutes of used on one charge with a top speed of 10 MPH. The motor could move you along faster but he has limited this in firmware to ensure it has enough power to ‘catch up’ if you lean too far forward.

Don’t miss the demo after the break. If you like this unicycle there are several others worth looking at.


Filed under: transportation hacks