Posts with «mosfet» label

Reed Organ MIDI Conversion Tickles All 88 Keys

What did you do in high school? Chances are it wasn’t anywhere near as cool as turning a reed organ into a MIDI device. And even if you managed to pull something like that off, did you do it by mechanically controlling all 88 keys? Didn’t think so.

A reed organ is a keyboard instrument that channels moving air over sets of tuned brass reeds to produce notes. Most are fairly complex affairs with multiple keyboards and extra controls, but the one that [Willem Hillier] scored for free looks almost the same as a piano. Even with the free instrument [Willem] is about $500 into this project. Almost half of the budget went to the solenoids and driver MOSFETs — there’s a solenoid for each key, after all. And each one required minor surgery to reduce the clicking and clacking sounds that don’t exactly contribute to the musical experience. [Willem] designed custom driver boards for the MOSFETs with 16 channels per board, and added in a couple of power supplies to feed all those hungry solenoids and the three Arduinos needed to run the show. The video below shows the organ being stress-tested with the peppy “Flight of the Bumblebee”; there’s nothing wrong with a little showing off.

[Willem]’s build adds yet another instrument to the MIDI fold. We’ve covered plenty before, from accordions to harmonicas and even a really annoying siren.


Filed under: musical hacks

Super simple controller for Motorcycle LED lights

For automobiles, especially motorcycles, auxiliary lighting that augments the headlights can be quite useful, particularly when you need to drive/ride through foggy conditions and poorly lit or unlit roads and dirt tracks. Most primary lighting on vehicles still relies on tungsten filament lamps which have very poor efficiency. The availability of cheap, high-efficiency LED modules helps add additional lighting to the vehicle without adding a lot of burden on the electrical supply. If you want to add brightness control, you need to either buy a dimmer module, or roll your own. [PatH] from WhiskeyTangoHotel choose the latter route, and built a super simple LED controller for his KLR650 bike.

He chose a commonly available 18 W light bar module containing six 3 W LEDs. He then decided to build a microcontroller based dimmer to offer 33%, 50% and 100% intensities. And since more code wasn’t going to cost him anything extra, he added breathing and strobe modes. The hardware is as barebones as possible, consisting of an Arduino Nano, linear regulator, power MOSFET and control switch, with a few discretes thrown in. The handlebar mounted control switch is a generic motorcycle accessory that has two push buttons (horn, headlight) and a slide switch (turn indicators). One cycles through the various brightness modes on the pushbutton, while the slide switch activates the Strobe function. A status indicator LED is wired up to the Nano and installed on the handlebar control switch. It provides coded flashes to indicate the selected mode.

It’s a pity that the “breathing” effect is covered under a patent, at least for the next couple of years, so be careful if you plan to use that mode while on the road. And the Strobe mode — please don’t use it — like, Ever. It’s possible to induce a seizure which won’t be nice for everyone involved. Unless you are in a dire emergency and need to attract someone’s attention for help.


Filed under: led hacks
Hack a Day 09 Sep 09:00

Raspberry Pi Gets Turned On

The Raspberry Pi and other similar Linux-based single board computers simplify many projects. However, one issue with Linux is that it doesn’t like being turned off abruptly. Things have gotten better, and you can certainly configure things to minimize the risk, but–in general–shutting a Linux system down while it is running will eventually lead to file system corruption.

If your project has an interface, you can always provide a shutdown option, but that doesn’t help if your application is headless. You can provide a shutdown button, but that leaves the problem of turning the device back on.

[Ivan] solved this problem with–what else–an Arduino (see the video below). Simplistically, the Arduino reads a button and uses a FET to turn off the power to the Pi. The reason for the Arduino, is that the tiny processor (which draws less than a Pi and doesn’t mind being shut down abruptly) can log into the Pi and properly shut it down. The real advantage, though, is that you could use other Arduino inputs to determine when to turn the Pi on and off.

For example, it is easy to imagine a Pi in an automotive application where the Arduino would sense the ignition was off for a certain period of time and then go ahead and shut off the Pi. Or maybe the Pi needs to be turned on when a motion sensor fires and then turned off again once there is no motion for a particular time period. Any of these strategies would be simple to build with the Arduino.

We’ve seen a similar project that used an IR remote as the trigger instead of a physical button. If you are afraid the Pi will just lose power unexpectedly, you might consider a battery backup. If powering a Pi with regular electricity is too tame for you, try steam.


Filed under: Arduino Hacks, Raspberry Pi

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.

You Can Have my TIPs When You Pry them from my Cold, Dead Hands

We’ve seen a growing number of posts and recommendations around the net regarding components, specifically transistors. “Don’t use old parts” they cry,  “Go with newer components.”  You can often find these recommendations on Arduino forums. This all came to a head with a page called “Do Not TIP,” which was linked in the Arduino subreddit.  This page belongs to [Tom Jennings], creator of Fidonet, and one of the early authors of what would become Phoenix BIOS. [Tom] and a few others have been calling for everyone to send their old parts to the landfill – not use them, nor gift them to new experimenters. Get them out of the food chain. No offense to [Tom], but we have to disagree. These parts are still perfectly usable for experienced designers, and have a lot to offer new hardware hackers.

TIP is the part number prefix for a series of power transistors created by Texas Instruments.  In fact, “TIP” stands for Texas Instruments Power. The series was originally released in 1969. Yes, that’s right, 1969. Why are we still using parts designed when man first walked on the moon? The same reason people are still using the 555 timer: they’re simple, they’re easily available, they’re robust, and most of all, they get the job done. The TIP series has been used in thousands of classes, tutorials both online and off, and millions of projects over the years. Much of that documentation is already out there on the internet. The TIP series is also out in the distribution channel – they’ve been used for 40 years. Any retail shop that stocks a few electronics parts will have at least one of the TIP series.

The TIP series aren’t always the best transistors for the job. However, for most hobbyist-designed circuits, we don’t need the best performance, nor the best price – we’re going to use the parts we have on hand. There is always room to improve once you get the basic circuit working.  

In [Tom’s] specific example, he’s using a TIP120 to control a motor at 5 volts drawing 1 amp of current. [Tom’s] big problem with the TIP120 is that it’s inefficient when running the motor. That’s because the TIP120 isn’t a transistor. It’s two transistors configured as a Darlington pair. Like everything else in life, Darlington pairs have trade offs. To achieve high gain, you end up with higher voltage drop. In high current designs, that translates into heat. In this case, 2 watts of heat, which [Tom] claims will result in melted parts and fire. It turns out that the datasheet shows 2 watts is the upper limit for thermal dissipation on the TIP120’s TO-220 case. It will get very hot, but it will not catch fire. Want to be on the safe side? Add a heatsink, which is as easy as attaching a piece of metal using the convenient screw hole in the TO-220 case.

Just for fun, we created our own version of [Tom’s] example. We connected a TIP120 to a 12V lab supply. Rather than connect a motor, we grabbed our Re:Load Pro and set it for 1 amp. We use a 680 ohm base resistor to ensure the TIP120 was in saturation. The Re:Load Pro indicated that it was indeed seeing 1 amp of current flow, at 10.9 volts. This means that the TIP120 was only dropping 1.1V, rather than the 2V quoted on the datasheet. Were we just lucky? We tried a few TIP120s we had around the lab from a couple of manufacturers, and all of them were pretty close – well below the worst case 2V. Obviously you can’t design beyond the specs called on in the datasheet, but sometimes things work out in your favor. With the current set to 1 amp, the math is easy. The Re:Load Pro was converting 10.9 watts of power to heat. The TIP120 was dissipating 1.1 watts. The TIP120 did get hot – we measured up to 60°C. But it never went beyond that. A heatsink would have cooled things down, but we were shooting for worst case scenario.  We ran this setup for 2 hours and there was no smoke, fire, or failure.

Can you do better with a different part? Absolutely. [Tom] suggests a MOSFET such as the NTD4906N. FETs are great, we use them all the time. However, they come with a completely different set of rules and pitfalls compared to BJTs. Learning the rules, the design trade offs and pitfalls of both families of devices are key factors when learning electronics design. Every component a designer learns is a new color on their design palette. On the code side we worry about people becoming “cut and paste” coders. The same thing happens on the hardware side when a designer doesn’t learn how to use different types of parts.

So don’t throw away your old parts. Use them, learn from them, and become a better designer for it!


Filed under: classic hacks, misc hacks

Motion Sensing Water Gun Tweets Photos To Embarrass Enemies

[Ashish] is bringing office warfare to the next level with a motion sensing water gun. Not only does this water gun automatically fire when it detects motion, but it also takes a photo of the victim and publishes it on Twitter.

This hack began with the watergun. [Ashish] used a Super Soaker Thunderstorm motorized water gun. He pulled the case apart and cut one of the battery wires. he then lengthened the exposed ends and ran them out of the gun to his control circuit. He also placed a protection diode to help prevent any reverse EMF from damaging his more sensitive electronics. The new control wires run to a MOSFET on a bread board.

[Ashish] is using a Lightblue Bean board as a microcontroller. The Bean is Arduino compatible and can be programmed via low energy Bluetooth. The Bean uses an external PIR sensor to detect motion in the room. When it senses the motion, it activates the MOSFET which then turns on the water gun.

[Ashish] decided to use Node-RED and Python to link the Bean to a Twitter account. The system runs on a computer and monitor’s the Bean’s serial output. If it detects the proper command, it launches a Python script which takes a photo using a webcam. A second script will upload that photo to a Twitter account. The Node-RED server can also monitor the Twitter account for incoming direct messages. If it detects a message with the correct password, it can use the rest of the message as a command to enable or disable the gun.


Filed under: Arduino Hacks

DJ sets get more interactive with Cubled and Arduino

Cubled is an interactive installation made of 27 luminous spheres arranged in space to create a cube 5 mt (16.4ft) per side floating on a stage.

The project created by Giuseppe Acito of Opificio Sonico  has a structure made of steel wires, RGB LED Strips and Ikea paper lanterns.

The system is MIDI-controlled, the notes generated by a sequencer are converted to electric signals using an Arduino UNO and a Mosfet:

No DMX device was used for this system which is 12V DC powered, with slim electric wires in order to give the lightness needed to this installation. In this clip, the performance is splitted in 2 parts: in the first a kit of electronic percussion is “played” live by a step sequencer named Sonic Fraction Beatdown (a Max\MSP device for Ableton Live), the combinations of 12 MIDI notes generated are linked to the spheres. In the second part the combinations of sounds and lights are pre-programmed patterns clip and performed live by a Tenori-on Yamaha and Ableton Live. The installation was mounted inside the Link Club (Bologna – Italy) in December 2013, which hosted some world-famous DJ set, during a month of permanence.

 

Arduino Blog 27 May 21:24

Play Robotic Bongos using your Household Plants

[Kirk Kaiser] isn’t afraid to admit his latest project a bit strange, being a plant-controlled set of robotic bongos. We don’t find it odd at all.  This is the kind of thing we love to see. His project’s origins began a month ago after taking a class at NYC Resistor about creating music from robotic instruments. Inspired to make his own, [Kirk] repurposed a neighbor’s old wooden dish rack to serve as a mount for solenoids that, when triggered, strike a couple of plastic cowbells or bongo drums.

A Raspberry Pi was originally used to interface the solenoids with a computer or MIDI keyboard, but after frying it, he went with a Teensy LC instead and never looked back. Taking advantage of the Teensy’s MIDI features, [Kirk] programmed a specific note to trigger each solenoid. When he realized that the Teensy also had capacitive touch sensors, he decided to get his plants in on the fun in a MaKey MaKey kind of way. Each plant is connected to the Teensy’s touchRead pins by stranded wire; the other end is stripped, covered with copper tape, and placed into the soil. When a plant’s capacitance surpasses a threshold, the respective MIDI note – and solenoid – is triggered. [Kirk] quickly discovered that hard-coding threshold values was not the best idea. Looking for large changes was a better method, as the capacitance was dramatically affected when the plant’s soil dried up. As [Kirk] stood back and admired his work, he realized there was one thing missing – lights! He hooked up an Arduino with a DMX shield and some LEDs that light up whenever a plant is touched.

We do feel a disclaimer is at hand for anyone interested in using this botanical technique: thorny varieties are ill-advised, unless you want to play a prank and make a cactus the only way to turn the bongos off!


Filed under: Arduino Hacks, musical hacks
Hack a Day 17 Apr 03:00

1-Day Project: Pantry Light

We have two pantries in our flat, one of which could use some light.

There's an outlet in there, but a simple solution won't do: I have more circuitry and time on my hands than I can handle, and the least I can do is make an over-complicated pantry light.

Parts lying around to use:

  • AC-DC converter blocks with screw-terminals outputting 12V at 2A. I have a bunch of these-- came with the LED strips.
  • A length of white LED strip.
  • Lots of TIP-120-style MOSFETs, intended for a second light suit. It's fun to have a lot of high power switches around.
  • Spare Arduino-compatible boards, including the "StripDuino" by "Tinkeract.com," here I quote the names since links go nowhere.
The idea is simple-- rest your hand on the large strip on the door sill as you scan the pantry contents. The light will turn on if you tap the strip, or it will fade if you leave your hand on it.

This design solves the problem uniquely with:

  1. Very large switch surface,
  2. Variable brightness by holding the switch,
  3. Indirect lighting from compact, dense LED strip tucked out of view.
I have a hardware sketch working in terms of the key elements of the controlling Arduino system:
  • Capacitive touch sensing works between pins D5 and D6 with a 1M resistor
  • Touch surface works: aluminum foil with soldered wire plus a layer of hot glue and tape.
  • PWM works with the MOSFET to control the LED strip nicely, with the board's 3.3V logic.
For the light strip at full power, I measure 240.8 mA at 11.85 V, so 2.85 W of power. This is not much but it scales proportionally to the length of the strip.

To do:

  1. Capture the working circuit in an Eagle schematic.
  2. Build a looping sketch with the tap/hold fading behavior.
More to come...

Electric bike (earplugs not included)

It’s obvious this bike has some extra parts. But look closely and you’ll see the chainring has no chain connecting to it. Pedaling will get you nowhere since [PJ Allen] rerouted the chain in order to drive this bicycle using an electric motor.

He’s got beefy motor which pulls 350 Watts at 24 Volts. For speed control he opted to use an Arduino, pumping out PWM signals to some MOSFETs. This results in an incredibly noisy setup, as you can hear in the bench test video after the break. But once this is installed on the bike it doesn’t quiet down at all. You can hear the thing a block away.

The original road test fried the first set of 7A MOSFETs when trying to start the motor from a standstill. It sounds like the 40A replacements he chose did the trick through. We didn’t see any information on the battery life, but if he runs out of juice on the other side of town we bet he’ll be wishing he had left the chain connected to the crankset.


Filed under: transportation hacks
Hack a Day 29 Jun 22:01