So I have an Arduino that is reading the rpm from my car. I also have a 15-pixel neopixel strip connected to the Arduino.
What I want the Arduino to do is to make the led strip show the rpm. As the rpm increases, the number of LEDs that turn on is increased from the left side of the strip.
What I am stuck on and would love help with is that I don’t just want the LEDs to turn on or off based of the rpm, but also change brightness.
For example let’s say the rpm is at 2000, so pixel 4 (arbitrary number that will be calculated by the equation) is the top pixel to turn on. Now as the rpm is increased, pixel 5 will increase in brightness from 0 to 255. Then pixel 6 will increase in brightness and so on, creating a smooth transition between pixels.
So what I want help with is being able to input the rpm and output the top pixel and it’s brightness. From there I will be able to just fill in the LEDs below the top pixel.
I want the top rpm to be 8000.
Let me know if you need more info. Thanks!
Does this code help? This has the code to calculate the last pixel - and the brightness of that pixel.
#define NUM_LEDS 15
#define NUM_BRIGHTNESS_LEVELS 256
#define MAX_REVS 8000
void setup()
{
Serial.begin(9600);
}
void loop()
{
for ( int revs = 0 ; revs <= MAX_REVS ; revs += 500 )
{
int totalBrightness = ((float)revs / MAX_REVS) * (NUM_LEDS * NUM_BRIGHTNESS_LEVELS);
int lastPixel = (totalBrightness / NUM_BRIGHTNESS_LEVELS);
int brightness = totalBrightness % NUM_BRIGHTNESS_LEVELS;
if ( lastPixel >= NUM_LEDS )
{
lastPixel = NUM_LEDS - 1;
brightness = NUM_BRIGHTNESS_LEVELS - 1;
}
Serial.print("revs = ");
Serial.print(revs);
Serial.print(", pixel = ");
Serial.print(lastPixel);
Serial.print(", brightness = ");
Serial.println(brightness);
delay(100);
}
delay(2000);
}
I am using 2x16 LCD display with 16 header pins with Raspberry Pi 3 .To display messages I installed and configured Adafruit Char LCD library. and it works fine.
currently default backlight color is yellow, so I want to change it to other colors like blue, red .
for this ,I imported Adafruit_RGBCharLCD
class Adafruit_RGBCharLCD from Adafruit char LCD library is as follows
class Adafruit_RGBCharLCD(Adafruit_CharLCD):
"""Class to represent and interact with an HD44780 character LCD display with
an RGB backlight."""
def __init__(self, rs, en, d4, d5, d6, d7, cols, lines, red, green, blue,
gpio=GPIO.get_platform_gpio(),
invert_polarity=True,
enable_pwm=False,
pwm=PWM.get_platform_pwm(),
initial_color=(1.0, 1.0, 1.0)):
"""Initialize the LCD with RGB backlight. RS, EN, and D4...D7 parameters
should be the pins connected to the LCD RS, clock enable, and data line
4 through 7 connections. The LCD will be used in its 4-bit mode so these
6 lines are the only ones required to use the LCD. You must also pass in
the number of columns and lines on the LCD.
The red, green, and blue parameters define the pins which are connected
to the appropriate backlight LEDs. The invert_polarity parameter is a
boolean that controls if the LEDs are on with a LOW or HIGH signal. By
default invert_polarity is True, i.e. the backlight LEDs are on with a
low signal. If you want to enable PWM on the backlight LEDs (for finer
control of colors) and the hardware supports PWM on the provided pins,
set enable_pwm to True. Finally you can set an explicit initial backlight
color with the initial_color parameter. The default initial color is
white (all LEDs lit).
You can optionally pass in an explicit GPIO class,
for example if you want to use an MCP230xx GPIO extender. If you don't
pass in an GPIO instance, the default GPIO for the running platform will
be used.
"""
super(Adafruit_RGBCharLCD, self).__init__(rs, en, d4, d5, d6, d7,
cols,
lines,
enable_pwm=enable_pwm,
backlight=None,
invert_polarity=invert_polarity,
gpio=gpio,
pwm=pwm)
self._red = red
self._green = green
self._blue = blue
# Setup backlight pins.
if enable_pwm:
# Determine initial backlight duty cycles.
rdc, gdc, bdc = self._rgb_to_duty_cycle(initial_color)
pwm.start(red, rdc)
pwm.start(green, gdc)
pwm.start(blue, bdc)
else:
gpio.setup(red, GPIO.OUT)
gpio.setup(green, GPIO.OUT)
gpio.setup(blue, GPIO.OUT)
self._gpio.output_pins(self._rgb_to_pins(initial_color))
def _rgb_to_duty_cycle(self, rgb):
# Convert tuple of RGB 0-1 values to tuple of duty cycles (0-100).
red, green, blue = rgb
# Clamp colors between 0.0 and 1.0
red = max(0.0, min(1.0, red))
green = max(0.0, min(1.0, green))
blue = max(0.0, min(1.0, blue))
return (self._pwm_duty_cycle(red),
self._pwm_duty_cycle(green),
self._pwm_duty_cycle(blue))
def _rgb_to_pins(self, rgb):
# Convert tuple of RGB 0-1 values to dict of pin values.
red, green, blue = rgb
return { self._red: self._blpol if red else not self._blpol,
self._green: self._blpol if green else not self._blpol,
self._blue: self._blpol if blue else not self._blpol }
def set_color(self, red, green, blue):
"""Set backlight color to provided red, green, and blue values. If PWM
is enabled then color components can be values from 0.0 to 1.0, otherwise
components should be zero for off and non-zero for on.
"""
if self._pwm_enabled:
# Set duty cycle of PWM pins.
rdc, gdc, bdc = self._rgb_to_duty_cycle((red, green, blue))
self._pwm.set_duty_cycle(self._red, rdc)
self._pwm.set_duty_cycle(self._green, gdc)
self._pwm.set_duty_cycle(self._blue, bdc)
else:
# Set appropriate backlight pins based on polarity and enabled colors.
self._gpio.output_pins({self._red: self._blpol if red else not self._blpol,
self._green: self._blpol if green else not self._blpol,
self._blue: self._blpol if blue else not self._blpol })
def set_backlight(self, backlight):
"""Enable or disable the backlight. If PWM is not enabled (default), a
non-zero backlight value will turn on the backlight and a zero value will
turn it off. If PWM is enabled, backlight can be any value from 0.0 to
1.0, with 1.0 being full intensity backlight. On an RGB display this
function will set the backlight to all white.
"""
self.set_color(backlight, backlight, backlight)
and I am trying to used lcd.set_color() as follows , but its not working.
import time
from Adafruit_CharLCD import Adafruit_RGBCharLCD
# instantiate lcd and specify pins
lcd = Adafruit_RGBCharLCD(rs=26, en=19,
d4=13, d5=6, d6=5, d7=11,
cols=16, lines=2,red=True,Green=True,Blue=True)
lcd.clear()
#setting backlight color as blue
lcd.set_color(0,0,100)
# display text on LCD display \n = new line
lcd.message('2x16 CharLCD\n Raspberry Pi')
I am using 4 bit node,attached last two pins which are backlight pins to raspberry pi gpio pins as follows:
Backlight Pins
15 LED+ or A Pin No 2 of GPIO(5v Power)
16 LED- or K Pin No 6 of GPIO(GND)
please help me to set customized colors as backlight ,as I am new to all this.
If your display has pins for backlight (LED) you can switch the backlight ON and OFF only unless there is some voltage regulation available, which I doubt.
Usually displays based on HD44780 chip do not support backlight color change. You can only switch it ON and OFF.
Hi all, I'v done a project for a factory which were needing a packing machine, so I made it with some pneumatic cylinders using arduino, relays, IR sensor.
I'm attaching my code and a picture how schema looks because sometimes my relays are freezing suddenly and they just need to power off then again power on and its OK.
Btw; I'm attaching schema only for one relay with all elements, code is for 4
relays.
Any idea about this please?
Picture of schema
int relay1 = 13;
int relay2 = 12;
int relay3 = 11;
int relay4 = 10;
int sensor1 = 5;
int sensor2 = 6;
int sensor3 = 3;
int sensor4 = 2;
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
pinMode(relay1, OUTPUT);
pinMode(sensor1, INPUT);
pinMode(relay2, OUTPUT);
pinMode(sensor2,INPUT);
pinMode(relay 3, OUTPUT);
pinMode(sensor3,INPUT);
pinMode(relay4, OUTPUT);
pinMode(sensor4,INPUT);
pinMode(LED_BUILTIN,OUTPUT);
}
void loop() {
digitalWrite(relay1, LOW);
delay(2000);
digitalWrite(relay1, HIGH);
delay(2000);
digitalWrite(relay2, LOW);
delay(2000);
digitalWrite(relay2, HIGH);
delay(2000);
digitalWrite(relay 3, LOW);
delay(2000);
digitalWrite(relay3, HIGH);
delay(2000);
digitalWrite(relay4, LOW);
delay(2000);
digitalWrite(relay4, HIGH);
delay(2000);
while(1){
delay(100);
if(digitalRead(sensor2) == LOW)
{
Serial.println("Eggs on");
digitalWrite(relay1,HIGH);
delay(350); // shpejtesia sensorit // sensor speed
}
else
{
Serial.println("No eggs");
digitalWrite(relay1,LOW);
delay(50); // sa mu kthy shpejt klipi mbrapa // speed of cylinder getting back
}
if(digitalRead(sensor1) == LOW)
{
Serial.println("Eggs on");
digitalWrite(relay2,HIGH);
delay(350); // shpejtesia sensorit // sensor speed
}
else
{
Serial.println("No eggs");
digitalWrite(relay2,LOW);
delay(50); // sa mu kthy shpejt klipi mbrapa // speed of cylinder getting back
}
if(digitalRead(sensor3) == LOW)
{
Serial.println("Eggs on");
digitalWrite(relay3,HIGH);
delay(350); // shpejtesia sensorit // sensor speed
}
else
{
Serial.println("No egs");
digitalWrite(relay3 ,LOW);
delay(50); // sa mu kthy shpejt klipi mbrapa // speed of cylinder getting back
}
if(digitalRead(sensor4) == LOW)
{
Serial.println("Eggs on");
digitalWrite(relay4,HIGH);
delay(100); // shpejtesia sensorit // sensor speed
}
else
{
Serial.println("No eggs");
digitalWrite(relay4 ,LOW);
delay(50); // sa mu kthy shpejt klipi mbrapa // speed of cylinder getting back
}
}
I design systems with relays operating in production plants. Sticking of the relays is a rare condition, but can occur in certain situations.
Relay Coil Voltage Stability ----
If the relay coil voltage is insufficient then the relays may fail to switch on. I would measure the voltage at coil switch on ensure that the relay coil voltage is stable. For best results I would supply the relay coils from a separately regulated (5 VDC) supply. That ensures that any loading affects of the relay coils on the supply voltage do not cause dropouts on the Arduino supply and stop the program.
Relay Contact Erosion due to inductive loads ----
Relay contacts can become eroded over time, occasionally sticking and eventually welding shut. The damage occurs when switching inductive loads off. The inductive load's energy discharges across the contacts and can generate an arc in the contact gap if the inductively generated voltage is sufficiently high. The plasma then erodes the contacts. A solution is to add a transorb across the contacts that is rated above the normal load voltage (e.g. above 24 VDC). This will absorb the inductive energy harmlessly. Another option is an RC filter. See the relay manufacturer's technical guidelines for more information on this subject.
Some issues that may be present in you system. The details are not apparent from the posted circuit diagram due to absence of some of the circuitry.
Isolation of Earths ----
Ensure that the earth voltages of the Arduino and 24V power are not connected. Otherwise there may be an Arduino earth voltage spike when you are swuitching on and off the solenoids. This could trip of the Arduino and halt the program. The Arduino power and the 24 VDC power sources should be independent and floating.
Relay Driver Isolation ----
Add optical isolators to the relay driver circuit so that there is at least a 1000 V barrier between the Arduino and the relay driver.
Relay Coil Voltage Suppression ----
Add a reverse polarity diode connected across the coil to absorb the inductive energy when the relay coil discharges. Otherwise that energy may cause damage to the arduino output pin.
Good luck with your system
So I have this DC motor which I want to reduce it's speed to 25% so obviously I used phase correct pwm to do so via the motor driver , I was able to do it through timer1 but my assistant professor wants me to do it with the 8-bit timer0 so I wrote the code and it ran but in full so my question is there are some calculation that must be done before writing the code and if there are , what are these calculations ?
Note : motor frequency is 100-250 Hz
I am working with internal frequency 1 MHz and prescaler 1024
#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>
int main(void)
{
DDRB = DDRB | (1<<PB3); //set OC0 as output pin --> pin where the PWM signal is generated from MC
/*set CS02:0 to 101 to work with 1024 prescaler
set WGM0[1:0] to 01 to work with phase correct,pwm
set COM01:0 to 11 to Set OC0 on compare match when up-counting. Clear OC0 on compare match
when downcounting*/
TCCR0 = 0b00111101;
OCR0 = 64; // 25% DUTY CYCLE
while (1)
{
;
}
}
Your question actually forces us to guess a bit - You're not telling enough facts to really help you. So, I'll guess you're using fast PWM, and guess you're controlling the motor speed with the PWM duty cycle.
Motor frequency and prescaler values are actually not so interesting - If you want to have speed reduction, you want to change the duty cycle, I assume.
A duty cycle of 25% of a 16-bit timer ist $10000/4 = $4000 (I guess that's what you set the Output compare register of your 16 bit timer to)
Obviously, on an 8-bit timer, a duty cycle of 25% is $100/4 = $40.
Also note what you need to write into TCCR0 to achieve the same thing from timer 0 is entirely different from what you write to TCCR1 for pretty much the same action - The bit positions are 100% different. Consult the data sheet, I think you got that wrong.
** i want to turn on all 3 led'd at once then wait for sometimes(10 or 20 seceonds whatever) and then go off all 3 led;'s at a time **
here is my code:
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(LED_BUILTIN, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
digitalWrite(13, HIGH);
digitalWrite(12, HIGH);
digitalWrite(11, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(13, LOW);
digitalWrite(13, LOW);
digitalWrite(13, LOW);// turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
but its not working.
so, how i can turn all led on at a time and of at a time???