Posts with «shield» label

Make Your Own Arduino Header Pins

There are two kinds of people in the world (and, no, this isn’t a binary joke). People who love the Arduino, and people who hate it. If you’ve ever tried to use a standard prototype board to mount on an Arduino, you’ll know what kind of person you are. When you notice the pins aren’t on 0.1 inch centers, you might think, “What the heck were those idiots thinking!” Or, you might say, “How clever! This way the connectors are keyed to prevent mistakes.” From your choice of statement, we can deduce your feelings on the subject.

[Rssalnero] clearly said something different. We weren’t there, but we suspect it was: “Gee. I should 3D print a jig to bend headers to fit.” Actually, he apparently tried to do it by hand (we’ve tried it, too). The results are not usually very good.

He created two simple 3D printed jigs that let you bend an 8-pin header. The first jig bends the correct offset and the second helps you straighten out the ends again. You can see the result in the picture above.

[Rssalnero] notes that the second jig needed reinforcement, so it is made to take 8 pins to use as fulcrums. Probably doesn’t hurt to print the jigs fairly solid and using harder plastic like ABS or PETG, too. Even if you don’t have a 3D printer, this is about a 15 or 30 minute print on any sort of reasonable printer, so make a friend. Worst case, you could have one of the 3D printing vendors make it for you, or buy local.

We love little tool hacks like this. If you are too lazy to snap 8 pins off a 40 pin strip, maybe you’d like some help. If you’d rather go with a custom PC board, you might start here.


Filed under: Arduino Hacks, tool hacks

Hackaday Prize Entry: Reverse Engineering Blood Glucose Monitors

Blood glucose monitors are pretty ubiquitous today. For most people with diabetes, these cheap and reliable sensors are their primary means of managing their blood sugar. But what is the enterprising diabetic hacker to do if he wakes up and realizes, with horror, that a primary aspect of his daily routine doesn’t involve an Arduino?

Rather than succumb to an Arduino-less reality, he can hopefully use the shield [M. Bindhammer] is working on to take his glucose measurement into his own hands.

[Bindhammer]’s initial work is based around the popular one-touch brand of strips. These are the cheapest, use very little blood, and the included needle is not as bad as it could be. His first challenge was just getting the connector for the strips. Naturally he could cannibalize a monitor from the pharmacy, but for someone making a shield that needs a supply line, this isn’t the best option. Surprisingly, the connectors used aren’t patented, so the companies are instead just more rigorous about who they sell them to. After a bit of work, he managed to find a source.

The next challenge is reverse engineering the actual algorithm used by the commercial sensor. It’s challenging. A simple mixture of water and glucose, for example, made the sensor throw an error. He’ll get it eventually, though, making this a great entry for the Hackaday Prize.

The HackadayPrize2016 is Sponsored by:

Filed under: Arduino Hacks, The Hackaday Prize

1Sheeld Turns your iPhone into a platform of Arduino shields

Have you ever thought of turning your iPhone and iPad into a platform of more than 40 Arduino shields? Now it’s possible!

The team of 1Sheeld have officially released the new 1Sheeld for iOS and it’s available for pre-orders for $39 instead of it’s original price $55 (shipping on May 2016).

You can  control robots, actuators, display sensors’ data and much more.  Take a look at the demo video:

The real open source Theremin on Arduino

Open.Theremin is an open source hardware and software project by Urs Gaudenz of  Gaudi Lab with the aim of building the next digital generation of the legendary music instrument developed in the ’20s by the Russian inventor professor Leon Theremin. The project is documented under a open license and uses Open.Theremin.UNO, an Arduino  or Genuino Uno shield featuring a digital mixer, combined 12 bit audio and CV out, audio jack on the bottom for more compact design, two completely separate antenna circuits:

The theremin is played with two antennas, one to control the pitch and one for volume. The electronic shield with two ports to connect those antennas comprises two heterodyne oscillators to measure the distance of the hand to the antenna when playing the instrument. The resulting signal is fed into the arduino. After linearization and filtering the arduino generates the instruments sound that is then played through a high quality digital analog audio converter on the board. The characteristics of the sound can be determined by a wave table on the arduino.

Most theremins on the market are either expensive or then not really playable. That’s how I decided to design a playable, open and affordable theremin. The first version was modular and difficult to program. Then I decided to redesign it as a shield to fit on the Arduino.UNO. This was a big success and many people could start using it, change the sounds and adapt it to their own application. The whole design is open source and documented on the website. I produced a small batch of the shield that can be bought through the small batch store on the website.

Watch the video below with Coralie Ehinger, a Swiss theremin player and organizer of the first Swiss theremin festival N / O / D / E, playing the instrument:

Arduino Blog 11 Jan 18:43

Kickstarter for new robotics shield. Smart servo control and Grove modules

Let's Make Robots 20 Nov 12:37

Arduino WiFi Shield 101 is now available in the US store!

We are excited to announce Arduino Wifi Shield 101 developed with Atmel is now available for purchase on the Arduino Store US (49.90$).

Arduino WiFi Shield 101 is a powerful IoT shield with crypto-authentication that connects your Arduino or Genuino board to the internet wirelessly. Connecting it to a WiFi network is simple, no further configuration in addition to the SSID and the password are required. The WiFI library allows you to write sketches which connect to the internet using the shield.

The shield is based on the Atmel SmartConnect-WINC1500 module, compliant with the IEEE 802.11 b/g/n standard. The WINC1500 module provided is a network controller capable of both TCP and UDP protocols.  The main feature is an hardware encryption/decryption security protocol provided by the ATECC508A CryptoAuthentication chip that is an ultra secure method to provide key agreement for encryption/decryption, specifically designed for the IoT market.

Last year, Massimo Banzi introduced the shield:

“In this increasingly connected world, the Arduino Wi-Fi Shield 101 will help drive more inventions in the IoT market. Expanding our portfolio of Arduino extensions, this new shield can flawlessly connect to any modern Arduino board giving our community more options for connectivity, along with added security elements to their creative projects.”

The WiFi Shield 101 is the first Arduino product fully supporting SSL and all the communication between your board and our secured server. With the power of the Arduino Zero and the WiFi Shield 101 it is possible to make secure IoT applications simply and just using the Arduino Language.

A working example and instructions on how to get started are available on Arduino Cloud, a work-in-progress project that gives you access to a pre-configured MQTT server for your IoT sketches using only your Arduino account. More examples and features will be available in the next months.

Feel like knowing more about the shield? Explore the  Getting Started guide.

Experimenting with Arduino and IKEA DIODER LED Strips

Introduction

A few weeks ago I found a DIODER LED strip set from a long-ago trek to IKEA, and considered that something could be done with it.  So in this article you can see how easy it is to control the LEDs using an Arduino or compatible board with ease… opening it up to all sorts of possibilities.

This is not the most original project – however things have been pretty quiet around here, so I thought it was time to share something new with you. Furthermore the DIODER control PCB has changed, so this will be relevant to new purchases. Nevertheless, let’s get on with it.

So what is DIODER anyhow? 

As you can see in the image below, the DIODER pack includes four RGB LED units each with nine RGB LEDs per unit. A controller box allows power and colour choice, a distribution box connects between the controller box and the LED strips, and the whole thing is powered by a 12V DC plugpack:

The following is a quick video showing the DIODER in action as devised by IKEA:

 

Thankfully the plugpack keeps us away from mains voltages, and includes a long detachable cable which connects to the LED strip distribution box. The first thought was to investigate the controller, and you can open it with a standard screwdriver. Carefully pry away the long-side, as two clips on each side hold it together…


… which reveals the PCB. Nothing too exciting here – you can see the potentiometer used for changing the lighting effects, power and range buttons and so on:

Our DIODER has the updated PCB with the Chinese market microcontroller. If you have an older DIODER with a Microchip PIC – you can reprogram it yourself.

The following three MOSFETs are used to control the current to each of the red, green and blue LED circuits. These will be the key to controlling the DIODER’s strips – but are way too small for me to solder to. The original plan was to have an Arduino’s PWM outputs tap into the MOSFET’s gates – but instead I will use external MOSFETs.

So what’s a MOSFET?

In the past you may have used a transistor to switch higher current from an Arduino, however a MOSFET is a better solution for this function. The can control large voltages and high currents without any effort. We will use N-channel MOSFETs, which have three pins – Source, Drain and Gate. When the Gate is HIGH, current will flow into the Drain and out of the Gate:

A simplistic explanation is that it can be used like a button – and when wiring your own N-MOSFET a 10k resistor should be used between Gate and Drain to keep the Gate low when the Arduino output is set to LOW (just like de-bouncing a button). To learn more about MOSFETS – get yourself a copy of “The Art of Electronics“. It is worth every cent.

However being somewhat time poor (lazy?), I have instead used a Freetronics NDrive Shield for Arduino – which contains six N-MOSFETs all on one convenient shield  – with each MOSFET’s Gate pin connected to an Arduino PWM output.

So let’s head back to the LED strips for a moment, in order to determine how the LEDs are wired in the strip. Thanks to the manufacturer – the PCB has the markings as shown below:

They’re 12V LEDs in a common-anode configuration. How much current do they draw? Depends on how many strips you have connected together…

For the curious I measured each colour at each length, with the results in the following table:

So all four strips turned on, with all colours on – the strips will draw around 165 mA of current at 12V. Those blue LEDs are certainly thirsty.

Moving on, the next step is to connect the strips to the MOSFET shield. This is easy thanks to the cable included in the DIODER pack, just chop the white connector off as shown below:

By connecting an LED strip to the other end of the cable you can then determine which wire is common, and which are the cathodes for red, green and blue.

The plugpack included with the DIODER pack can be used to power the entire project, so you will need cut the DC plug (the plug that connects into the DIODER’s distribution box) off the lead, and use a multimeter to determine which wire is negative, and which is positive.

Connect the negative wire to the GND terminal on the shield, and the positive wire to the Vin terminal.  Then…

  • the red LED wire to the D3 terminal,
  • the green LED wire to the D9 terminal,
  • and the blue LED wire to the D10 terminal.

Finally, connect the 12V LED wire (anode) into the Vin terminal. Now double-check your wiring. Then check it again.

Testing

Now to run a test sketch to show the LED strip can easily be controlled. We’ll turn each colour on and off using PWM (Pulse-Width Modulation) – a neat way to control the brightness of each colour. The following sketch will pulse each colour in turn, and there’s also a blink function you can use.

// Controlling IKEA DIODER LED strips with Arduino and Freetronics NDRIVE N-MOSFET shield
// CC by-sa-nc John Boxall 2015 - tronixstuff.com 
// Components from tronixlabs.com

#define red 3
#define green 9
#define blue 10
#define delaya 2

void setup() 
{
  pinMode(red, OUTPUT);
  pinMode(green, OUTPUT);
  pinMode(blue, OUTPUT);
}

void blinkRGB()
{
  digitalWrite(red, HIGH);
  delay(1000);
  digitalWrite(red, LOW);
  digitalWrite(green, HIGH);
  delay(1000);
  digitalWrite(green, LOW);
  digitalWrite(blue, HIGH);
  delay(1000);
  digitalWrite(blue, LOW);
}

void pulseRed()
{
  for (int i=0; i<256; i++)
  {
    analogWrite(red,i);
    delay(delaya);
  }
  for (int i=255; i>=0; --i)
  {
    analogWrite(red,i);
    delay(delaya);
  }
}

void pulseGreen()
{
  for (int i=0; i<256; i++)
  {
    analogWrite(green,i);
    delay(delaya);
  }
  for (int i=255; i>=0; --i)
  {
    analogWrite(green,i);
    delay(delaya);
  }
}

void pulseBlue()
{
  for (int i=0; i<256; i++)
  {
    analogWrite(blue,i);
    delay(delaya);
  }
  for (int i=255; i>=0; --i)
  {
    analogWrite(blue,i);
    delay(delaya);
  }
}

void loop()
{
  pulseRed();
  pulseGreen();
  pulseBlue();
}

Success. And for the non-believers, watch the following video:

Better LED control

As always, there’s a better way of doing things and one example of LED control is the awesome FASTLED library by Daniel Garcia and others. Go and download it now – https://github.com/FastLED/FastLED. Apart from our simple LEDS, the FASTLED library is also great with WS2812B/Adafruit NeoPixels and others.

One excellent demonstration included with the library is the AnalogOutput sketch, which I have supplied below to work with our example hardware:

#include <FastLED.h>

// Example showing how to use FastLED color functions
// even when you're NOT using a "pixel-addressible" smart LED strip.
//
// This example is designed to control an "analog" RGB LED strip
// (or a single RGB LED) being driven by Arduino PWM output pins.
// So this code never calls FastLED.addLEDs() or FastLED.show().
//
// This example illustrates one way you can use just the portions 
// of FastLED that you need.  In this case, this code uses just the
// fast HSV color conversion code.
// 
// In this example, the RGB values are output on three separate
// 'analog' PWM pins, one for red, one for green, and one for blue.
 
#define REDPIN   3
#define GREENPIN 9
#define BLUEPIN  10

// showAnalogRGB: this is like FastLED.show(), but outputs on 
// analog PWM output pins instead of sending data to an intelligent,
// pixel-addressable LED strip.
// 
// This function takes the incoming RGB values and outputs the values
// on three analog PWM output pins to the r, g, and b values respectively.
void showAnalogRGB( const CRGB& rgb)
{
  analogWrite(REDPIN,   rgb.r );
  analogWrite(GREENPIN, rgb.g );
  analogWrite(BLUEPIN,  rgb.b );
}



// colorBars: flashes Red, then Green, then Blue, then Black.
// Helpful for diagnosing if you've mis-wired which is which.
void colorBars()
{
  showAnalogRGB( CRGB::Red );   delay(500);
  showAnalogRGB( CRGB::Green ); delay(500);
  showAnalogRGB( CRGB::Blue );  delay(500);
  showAnalogRGB( CRGB::Black ); delay(500);
}

void loop() 
{
  static uint8_t hue;
  hue = hue + 1;
  // Use FastLED automatic HSV->RGB conversion
  showAnalogRGB( CHSV( hue, 255, 255) );
  
  delay(20);
}


void setup() {
  pinMode(REDPIN,   OUTPUT);
  pinMode(GREENPIN, OUTPUT);
  pinMode(BLUEPIN,  OUTPUT);

  // Flash the "hello" color sequence: R, G, B, black.
  colorBars();
}

You can see this in action through the following video:

Conclusion

So if you have some IKEA LED strips, or anything else that requires more current than an Arduino’s output pin can offer – you can use MOSFETs to take over the current control and have fun. And finally a plug for my own store – tronixlabs.com – offering a growing range and Australia’s best value for supported hobbyist electronics from adafruit, DFRobot, Freetronics, Seeed Studio and much much more.

As always, 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.

The post Experimenting with Arduino and IKEA DIODER LED Strips appeared first on tronixstuff.

A DIY Jukebox made with Arduino and NFC Shield

DIY Jukebox is a project made by Mario Pucci to show how Arduino Uno, NFC Shield and Python can be used to build a real jukebox. NFC means Near Field Communication and the NFC shield can perceive objects attached to little chips called NFC tags containing specific messages. In this project, Marco programmed each chip to play a different music genre when the tag is inserted in the cardboard jukebox:

You can download the file of the cardboard Jukebox at this link and the sketches here.

The steps of the tutorial are in italian but you can use google translate if needed! Enjoy the sound of music

Arduino Blog 16 Sep 14:32
arduino  featured  jukebox  music  nfc  shield  tutorial  uno  

New Project: How to Make Custom Shields for Your Microcontroller Board

Shields are great for connecting external circuits to your microcontroller board. In this project, you'll learn to make your own custom shields for Arduino.

Read more on MAKE

The post How to Make Custom Shields for Your Microcontroller Board appeared first on Make: DIY Projects, How-Tos, Electronics, Crafts and Ideas for Makers.

HamShield Puts Your Arduino On The Radio

Anybody can grab a USB TV tuner card and start monitoring the airwaves, but to get into the real meat of radio you’ll need your amateur radio license. Once you have that, the bandwidth really opens up… if you can afford the equipment. However, [spaceneedle] and friends have dramatically lowered the costs while increasing the possibilities of owning a radio by creating this ham radio shield for the Arduino.

The HamShield, is a versatile shield for any standard Arduino that allows it to function like an off-the-shelf radio would, but with a virtually unlimited number of functions. Anything that could be imagined can be programmed into the Arduino for use over the air, including voice and packet applications. The project’s sandbox already includes things like setting up mesh networks, communicating over APRS, setting up repeaters or beacons, monitoring weather stations, and a whole host of other ham radio applications.

HamShield operates on a wide range of frequencies and only uses a 250 mW amplifier. The power draw is small enough that the HamShield team operated it from a small solar panel, making it ideal for people in remote areas. The project is currently gathering funding and has surpassed their goal on Kickstarter, branding itself appropriately as the swiss army of amateur radio. The transceiver seems to be very robust, meaning that the only thing standing in the way of using this tool is simply writing the Arduino code for whatever project you want to do, whether that’s as a police scanner or even just a frequency counter. And if you want to follow along on hackaday.io, the project can be found here.


Filed under: Arduino Hacks, radio hacks