Cheap standalone usb microcontroller

[JennySchubert]

What I want:
-Control at least 24 5V channels via usb
-cheap
-No additional hardware required

What is it for?
-controlling at least 8 12V colour led strips (the ones that come with a remote which I won't need in the end)
-I already have one long strip that can be cut up into smaller pieces
-I intend to keep using the control box that came with the strip because it already delivers the correct voltage and amps (DC12V, 3A/CH*3 I'm guessing that means 1A per channel)
-I will switch the 12V channels on and off (pwm) with transistors (feel free to recommend applicable ones) controlled by the 5V outputs (of the device I'm looking for)

My background:
I have no background in electronics at all, I'm just a programmer. I have looked into arduinos, raspberry and orange pi's, but those offer functionality I probably won't need and hence are more expensive than necessary.
Since I have no background, I'm looking for a standalone solution that doesn't require extra hardware to be programmed (i.e. I read that the atmega328p needs an arduino or other programming hardware to be programmed, but I may be wrong there). I imagine I'm not the first to ask this question, but since I have very little knowledge about ee, I don't even really know what to search for.

Thank you for your help! And sorry if I made a redundant thread

[tooki]

Forget about using the built-in PWM in the microcontrollers (like the Atmega); it's too slow and produces flicker at low duty cycles. Plus you don't have enough channels anyway.

Look instead at TI's LED driver chips, like the TLC5940 I've been playing with. It gives you 16 channels of high-speed PWM per chip, and you can daisy-chain as many chips as you need. TI makes chips with even larger channel counts. These take serial input (and thus can be controlled from a cheap microcontroller with few pins) to which you basically write brightness values for each channel, and then say "go"! Super simple and effective.

You WILL need some kind of programmer hardware to program the microcontroller, no matter what it is. Bear mind mind that you can get those off eBay for like $3. An Arduino board is basically just an Atmega chip on a breakout board with programming interface (other than the "pro" versions which omit the programming interface to save space), preloaded with a handy bootloader. This combines with the invaluable Arduino libraries, which are just C libraries that handle a ton of everyday stuff. Don't dismiss Arduino; you can buy a Chinese clone Arduino Uno for little more than what you'd pay a Western supplier just for the microcontroller chip alone.

In a nutshell, I'd suggest you dip your toes into microcontroller programming and LED control the exact same way I have, since I'm working on precisely this kind of project:
- Cheap Arduino Uno boards (you can get 5 for under $15)
- TLC5940 chips
- IRLZ540 or similar logic level MOSFETs for high power switching (the non-logic-level IRFZ series is much cheaper, so keep a keen eye out on the part number)
- AVRISP II clone programmer (get one with switchable 3.3V/5V support)
- use the Arduino IDE to get the hang of the basics. Then move to a "real" IDE, but still using the Arduino libraries. (There are many options for every OS.)
- use pre-existing Arduino libraries for the TLC5940 chips

Now, I wouldn't be surprised if there are already "smart home" LED strip controllers that connect via USB, ethernet, wifi, or Bluetooth and can accomplish what you want to do. If this is a one-off project, they might not be a bad choice. Unless you want the challenge of DIY, of course!

Hope this helps!

[mikeselectricstuff]

You could drive SPI type LED drivers directly from an FT232R in bit-bang mode, so no MCU programming needed.

[JennySchubert]

Thanks for your replies!

@tooki
I was even planning to implement my own pwm ^^
My guess was that a single arduino or Raspberry PI would suffice if I could switch the pins fast enough. Am I wrong there? If not, the Arduno Uno can be programmed directly without the AVRISP II, right?

@mikeselectricstuff
I'm looking for a more or less finished board. My desire is to plug in a usb cable and get 24+ pins that I can control from the PC. I don't really plan to tinker with individual chips, usb controllers, and the likes, since I believe that's a bit beyond me.

Thanks again though for your ideas

[danadak]

PSOC -

http://www.cypress.com/documentation/application-notes/an56377-psoc-3-and-psoc-5lp-introduction-implementing-usb-data

http://www.cypress.com/documentation/application-notes/an82072-psoc-3-and-psoc-5lp-usb-general-data-transfer-standard-hid

http://www.cypress.com/documentation/application-notes/an57473-usb-hid-basics-psoc-3-and-psoc-5lp

http://www.cypress.com/blog/psoc-insiders-blog/psoc-35-bulk-usb-example


Regards, Dana.

[Seekonk]

PCA9685

[FrankBuss]

If 22 IO pins instead of 24 is ok, I can recommend an Arduino nano. They are incredible cheap, like this board, EUR 2.39 shipped. All you need on the PC is to open a serial port, which hides all the complexity of USB. If you use something like the PCA9685 or TLC5940, you don't need that many pins anyway, and for 8 PWM channels it is better if you want it flicker free and with high resolution, unless you want to do some low-level assembly hacking on the Arduino.

[garboui]

If you are looking at a minimal integration effort, products like this already exist. The keywords are "DMX LED controller" they are available at may places including aliexpress (some examples below). The channels on these boxes are just a basic low side switch configuration. I recommend confirming the PWM frequency first if you are really concerned about flicker at low freq. The only other hardware you need is a RS-232 FTDI cable (or any 485 source) to jack into the unit. Getting things going id just a matter of a small amount of serial code. There are also freeware software consoles available like q-light controller etc.  A ttl serial source may work as well if you solder ahead of the 485 TxC on the board.

https://www.aliexpress.com/item/DC5V-24V-36CH-RGB-DMX512-decoder-LED-DMX-XRL-3P-Controller-36-channel-13groups-RGB-MAX/32797581310.html?spm=2114.01020208.3.229.7krT6f&ws_ab_test=searchweb0_0,searchweb201602_2_10065_10130_10068_433_434_10139_10136_10137_10138_10060_10062_10056_10055_10054_302_10059_9912_10099_129_10103_10102_10096_10052_10053_10050_10107_10051_10106_10084_10083_10080_10082_10081_10110_10111_10112_10113_10114_10078_10079_10073_10070_10122_10123_10126_6000000_10124-9912,searchweb201603_5,afswitch_1,ppcSwitch_3_ppcChannel,single_sort_0_default&btsid=c6e048ad-1e6a-46a1-aafc-d6697090c9f3&algo_expid=19e348dd-da91-488e-a6fc-f26c8f943f5b-28&algo_pvid=19e348dd-da91-488e-a6fc-f26c8f943f5b

https://www.aliexpress.com/item/Fast-shipping-DC5V-24V-24A-24CH-Channel-dmx-512-led-controller-decoder-dimmer-use-for-RGBW/32795328582.html?spm=2114.01020208.3.206.7krT6f&ws_ab_test=searchweb0_0,searchweb201602_2_10065_10130_10068_433_434_10139_10136_10137_10138_10060_10062_10056_10055_10054_302_10059_9912_10099_129_10103_10102_10096_10052_10053_10050_10107_10051_10106_10084_10083_10080_10082_10081_10110_10111_10112_10113_10114_10078_10079_10073_10070_10122_10123_10126_6000000_10124-9912,searchweb201603_5,afswitch_1,ppcSwitch_3_ppcChannel,single_sort_0_default&btsid=c6e048ad-1e6a-46a1-aafc-d6697090c9f3&algo_expid=19e348dd-da91-488e-a6fc-f26c8f943f5b-25&algo_pvid=19e348dd-da91-488e-a6fc-f26c8f943f5b

[mdijkens]

Can't you use WS2812b ledstrips? You only need one pin on an arduino-compatible to control 255 rgb-colorleds ...
Depending on what you need, this might be the easiest solution hardware-wise and software-wise ...

[tooki]

I was even planning to implement my own pwm ^^
My guess was that a single arduino or Raspberry PI would suffice if I could switch the pins fast enough. Am I wrong there?

It's not nearly fast enough, you'll only get hundreds of Hz PWM frequency, but to prevent flicker when dimmed to really low, you need several KHz. (2KHz is about the minimum for me to not perceive PWM flicker at low settings in most situations. More is better. Someone once calculated that you need 16KHz to completely eliminate it.)

Remember that your PWM clock is (number of brightness steps)*(PWM frequency). Now, thanks to the nonlinearity of human brightness perception, 256 steps is actually not enough to get perceived fine control at low brightness. (That's why those TI chips I showed let you use 4096 steps.) Let's take 1024 steps as a middle ground. Now let's say you want a barebones 1KHz PWM frequency. 1024*1KHz=1.024MHz PWM clock. That's way more than you can bit-bang on a little microcontroller. And that's just for one single channel, never mind 24. See why I recommended dedicated hardware?

If not, the Arduno Uno can be programmed directly without the AVRISP II, right?

Correct. The Uno, Mega2560, nano, etc. all have USB ports and don't require a separate programmer.

The Pro mini needs a TTL serial adapter (which is different from the AVRISP II that you use for a bare Atmega microcontroller), so it'd be the wrong choice for you.



That said, if tinkering with added chips exceeds what you want to do, I think you should avoid this DIY approach and instead look at the off-the-shelf solutions others here have proposed. You haven't told us what your actual goal is (XY problem), but chances are there's an existing thing that will do what you need in a sensible fashion.

[FrankBuss]

1 kHz PWM frequency is overkill, 100 Hz is all you need, unless you move or turn your head or the LEDs very fast. With 1024 steps this would need 100 kHz resolution. You can do this with some tricky programming, even for 24 channels. You just need to pre-calculate 1024 x 3 port bytes, then output them to the ports with 100 kHz. But a bigger Arduino is required, because the Nano has only 2 kB SRAM. An ATmega2560 has 8 kB. And it gets really tricky, if you want to update it glitch free from the serial port and with fast pattern changes. You have to disable the usual millisecond interrupt, poll the serial port etc. And some special PWM chips and an Arduino Nano would be cheaper and much easier to program.

Another way is to use a bigger microcontroller. I like my STM32F4 Discovery Kit. You can get it for EUR 15, programmer is included on-board, runs standalone after programming:

http://www.digikey.de/short/32ftjr

It has lots of goodies to play with, like an audio DAC, a microphone, a 3 axis accelerometer/magnetic sensor, a 3 axis gyroscope, 128 kB RAM, an ARM CPU core which runs with up to 168 MHz, and tons of IO. But it is more complicated to program. With this hardware it is possible to stream data from memory at a fixed samplerate to the IO pins with DMA, using the SRAM memory interface, as I've done, tested up to 8 MHz:

https://plus.google.com/u/0/+FrankBussProgrammer/posts/jQidPgbtKoW

Because of the DMA transfer, the CPU is free to do other things, like receiving data from the USB port and preparing the next data to stream. But only 16 pins are possible with the SRAM interface. 24 bits might be possible with bit banging at 1 MHz, if you use the FIQ feature of the ARM core. 100 kHz would be no problem. With this board you don't need extra PWM chips.

[tooki]

No, 1KHz isn't enough, 100Hz is a joke (seriously, try it at 100hz and the lowest dimming setting, it WILL flicker annoyingly). I readily see flicker with 1KHz PWM, and again, there have been studies on this that calculated 16KHz as necessary to eliminate flicker in all situations. And you say "as long as you don't move your head" quickly... umm, moving your eyes and head are normal things. So yeah, you need to consider that too. It's your eye movement that makes the high frequency necessary. Do you really think LED driver manufacturers would bother supporting 10+KHz PWM frequencies if it weren't necessary??

Mind you, I've done extensive testing of this in my own LED projects, because I'm very sensitive to flicker. Nothing below 1.5KHz is even just tolerable for me, and it's really only at 3KHz that I no longer notice it at all.

[FrankBuss]

I've tried it, with a small red LED, maybe it is different for larger and brighter LEDs, or for lower dimming setting than 1/100, but I can't see any flickering, even when moving my eyes fast. Test code is below. It uses 100 steps of a bitbanging PWM, with a 10 kHz interrupt, so 100 Hz PWM frequency. You are right that it is very non-linear when it is dim, you can clearly see the steps, which is no problem at the full brightness side. I had to even fixed the value at the lowest value (commented line), because the LSB of the AD value of the potentiometer randomly changed, resulting in random one step changes and this is clearly visible. But fixed at 1/100 dim level it is no problem, I can't see it flickering.

And the signal is very clean, no jitter etc. to see on the scope:



Arduino sketch:

Code: [Select]

const float samplerate = 10000.0f;
uint8_t count = 0;
uint8_t width = 0;

void setup()
{
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(12, OUTPUT);

  // initialize timer1
  noInterrupts(); // disable all interrupts
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT1 = 0;
  OCR1A = 16000000.0f / samplerate; // compare match register for IRQ with selected samplerate
  TCCR1B |= (1 << WGM12); // CTC mode
  TCCR1B |= (1 << CS10); // no prescaler
  TIMSK1 |= (1 << OCIE1A); // enable timer compare interrupt
  interrupts(); // enable all interrupts
}

// timer 1 interrupt
ISR(TIMER1_COMPA_vect)
{
  count++;
  if (count == 100) count = 0;
  if (count >= width) {
    digitalWrite(LED_BUILTIN, HIGH);
    digitalWrite(12, HIGH);
  } else {
    digitalWrite(LED_BUILTIN, LOW);
    digitalWrite(12, LOW);
  }
}

void loop()
{
  int poti = analogRead(A0);
  uint8_t next = map(poti, 0, 1023, 0, 100);
  // next = 99;
  noInterrupts();
  width = next;
  interrupts();
}


[mikeselectricstuff]

I usually use 250Hz PWM. Good compromise between flicker, switching losses and audible noise (PSUs, ceramic cams, sometimes even LEDs themselves)

[tooki]

Consider yourselves lucky if 100 or 250Hz is tolerable to you. That speed drives me absolutely batshit crazy. I have some LED lighting here using chinese dimmers that I modded to change from the factory 1KHz to 3KHz PWM because the flicker at 1KHz was driving me insane. I catch it in the corner of my eye (where we are far more sensitive to flicker) and find it impossible to ignore.

(To me, 250Hz isn't a compromise, it's far, far, FAR below what's even distantly acceptable.)

[FrankBuss]

Consider yourselves lucky if 100 or 250Hz is tolerable to you. That speed drives me absolutely batshit crazy. I have some LED lighting here using chinese dimmers that I modded to change from the factory 1KHz to 3KHz PWM because the flicker at 1KHz was driving me insane. I catch it in the corner of my eye (where we are far more sensitive to flicker) and find it impossible to ignore.

(To me, 250Hz isn't a compromise, it's far, far, FAR below what's even distantly acceptable.)

This would be an amazing capability, have you done a double-blind test? I doubt that you can see the difference between 1 kHz and 3 kHz. Maybe you can see somehow flickering with 250 Hz. Here is an interesting article on this problem and it mentions that you can get headache from 120 Hz fluorescent lights, so maybe very few people would have this problem with 250 Hz, too. But I doubt this would be a problem with 1 kHz.

[tooki]

Consider yourselves lucky if 100 or 250Hz is tolerable to you. That speed drives me absolutely batshit crazy. I have some LED lighting here using chinese dimmers that I modded to change from the factory 1KHz to 3KHz PWM because the flicker at 1KHz was driving me insane. I catch it in the corner of my eye (where we are far more sensitive to flicker) and find it impossible to ignore.

(To me, 250Hz isn't a compromise, it's far, far, FAR below what's even distantly acceptable.)

This would be an amazing capability, have you done a double-blind test? I doubt that you can see the difference between 1 kHz and 3 kHz. Maybe you can see somehow flickering with 250 Hz. Here is an interesting article on this problem and it mentions that you can get headache from 120 Hz fluorescent lights, so maybe very few people would have this problem with 250 Hz, too. But I doubt this would be a problem with 1 kHz.

I see that you're really skeptical. I wouldn't be pushing this point so hard if I were not 10000% sure. For those of us who perceive the flicker, it's extremely unpleasant. It's not something you wanna inflict on people. Your doubt doesn't change the fact that this is a very real effect.

What works for fluorescent is irrelevant, because fluorescent uses phosphors with persistence. LEDs have no persistence at all, so they ruthlessly pulse if that's the signal they're being fed.

I haven't done double-blind. But when I installed the dimmer as-is, the flicker drove me crazy. So I measured it and it was 1KHz, and then I modded the unit (changing RC values for the 555 timer inside) to 3KHz and now it doesn't bother me. (I didn't try intermediate values, so I can't tell you where the cutoff point was. Only that it's above 1KHz.) So to answer your implicit question: No, I wasn't looking for flicker under controlled conditions that maximize the effect. I noticed it in real-world use, with real-world lighting in my real-world bedroom, laying on my bed with the LED lighting dimmed to its minimum.

As for the science: it's called the phantom array effect. Our eyes do have persistence, limiting us to about 60Hz centrally, somewhere around 100Hz peripherally. If you stare at an LED at >100Hz, it won't flicker. But as soon as your eyes move, the LED's light becomes a series of dots of light on the retina, and it's super annoying. The DLP rainbow effect is the same effect, really. The phantom array effect isn't very noticeable when broad areas are lit, but the instant you can see the light source itself, or specular reflections of ambient light (i.e. any point light source) it becomes noticeable. In other words, the rule that applies to moving images doesn't apply to lighting, because it's a totally different effect, with different constraints.

[tooki]

Since you think I'm crazy, here's a paper from a study that showed that on average, test subjects noticed the phantom array effect up to 1.98KHz, but one subject was able to detect it up to 4.9KHz. (This paper calculates a theoretical maximum of 35KHz flicker discrimination based on saccading alone, but the response time of the retina reduces it in practice.)

http://www.essex.ac.uk/psychology/overlays/2013-207.pdf

Edit: original URL is dead, here's the archive.org backup: https://web.archive.org/web/20170325051112if_/http://www.essex.ac.uk/psychology/overlays/2013-207.pdf

[FrankBuss]

Ok, this makes sense. I doubted that you can see it flickering when looking at it, but with a saccade (quick eye movement) you could see individual dots. I tried this with my experiment and was no problem to see it with 100 Hz. But interesting that it has such a strong effect on some people. Now the 10 kHz PWM frequency makes sense.

I wonder if a low-pass filter at the output would help, if the driver likes, and then below 1 kHz would be possible again? A simple RC filter might be not a good idea, because probably of the high losses in R, but maybe some LC filter?

[tooki]

I asked that about a year ago on here, and people said that RC filters would fry the outputs, so you'd have to use LC. But the consequence is adding even more non-linearity to the system, since LED's light output is extremely non-linear with respect to current. It seems that in practice, it's easier to just raise the PWM frequency.

Yeah, I can't say that I consider being sensitive to flicker a gift. For example, one of my favorite cocktail bars in town uses dimmed LED lighting, and the specular highlights on all the glassware and metal stuff are really distracting because of the phantom array effect. (Think the cliché of a bird seeing shiny things!) I have to make a point to focus on the person's face to not get annoyed by the flicker.

Remember how in the days of CRT TVs, that in Europe they sold 100Hz double-scan TVs? I was one of those people that found an ordinary 50Hz TV to be annoyingly flickery. (American 60Hz was okay.)

[FrankBuss]

BTW, once I experimented with long exposure times with my camera (German usenet posting: https://groups.google.com/d/msg/de.sci.electronics/nx_OY5zq_M8/rsszGbZiA-gJ ) and I could count 160 dots with 1.6 seconds exposure time for some headlights, which calculates to 100 Hz PWM frequency:

[tooki]

Yep. LED tail lights (i.e. brake lights that are PWM-dimmed) are incredibly distracting to me when they use low PWM frequencies. I'm kinda surprised it's even allowed, it's like the auto industry did it without considering the consequences to safety.

Nice pic for illustrating the point, thanks!

[bingo600]

I just got 2 of these boards 16 chan 12-bit pwm

https://www.aliexpress.com/item/Smart-Electronics-PCA9685-16-Channel-12-bit-PWM-Servo-Driver-I2C-Interface-for-Arduino-Raspberry-Pi/32464046768.html

Haven't had the time to play yet , but they seems to fit the requirement

/Bingo

[tooki]

Maximum PWM frequency of 1.6KHz... borderline usable for LED lighting. :/

[danadak]

@tooki, I found your comments fascinating.

I have a problem with classic CRT monitors due to an astigmatism in one eye,
if I focus just right on the monitor, driven by a PC with some windows open,
I can see windows floating in 3D. Added, what was otherwise a bland look
on monitors, a wonderful attribute.


Regards, Dana.