Question: I have a 2000mA AC adapter and also I have the lights that I show here:

[![LED light](https://i.stack.imgur.com/iyrO4.jpg)](https://i.stack.imgur.com/iyrO4.jpg)

[![LED light connected to an Arduino Uno](https://i.stack.imgur.com/lfdnn.jpg)](https://i.stack.imgur.com/lfdnn.jpg)

Each of these lights consume up to 300mA.

If I make a circuit with 3 lights in serial, ¿will the amperage of each light decrease?

If I make a circuit with 3 lights in parallel, ¿will the amperage of each light decrease?

I am asking it because I don't want the lights to decrease the luminosity. I want the maximum luminosity in each light.

The lights are for growing lettuces. Now I am using a low consumption light but are not efficient:
[![Growing vegetables](https://i.stack.imgur.com/xhBvB.jpg)](https://i.stack.imgur.com/xhBvB.jpg)

Answer: 
If you need to represent numbers that are not integers, the simplest
solution is to use floating point variables, also known as “floats”. A
float is declared with the `float` keyword. A numeric constant is
automatically a float if it has a decimal point :

* `42` is an integer (`int` type)
* `42.0` is a float

If you combine an int and a float in an arithmetic operation, the int is
implicitly promoted to float, and the result is a float.

A float gives you a precision of 24 *significant bits*. “Significant”
means that we are counting both the bits *before* and *after* the binary
point. Then, a small number will have many fractional bits, whereas a
large number will have only a few, and any number larger than
223 = 8388608 will have *no* fractional bits at all.

This precision is almost always better that 7 significant decimals and
worse than 8 significant decimals. For example, the following two
numbers are consecutive: any computation that yields a result *in
between* them will be rounded to either of them (usually the closest):

```
    binary (24 bits)          decimal
101010.000000000000000000  42.0
101010.000000000000000001  42.000003814697265625

```

The issue with floats is that they are expensive. Unlike a desktop
computer, the Trinket has no hardware support for floats (it's an
ATtiny: it doesn't even have a hardware multiplier!). Then every
computation is done by software. Even the simplest things, like adding
two numbers, can take quite a few CPU cycles and *a lot* of flash space.
That's why on very small devices people sometimes prefer *fixed point*
arithmetic. In a nutshell, fixed point is all about choosing appropriate
units of measurement in order to achieve the required precision using
only integers. For example, the ADC converter in the Trinket gives you
the voltage readings in units of

```
5 V ÷ 1024 = 4.8828125 mV

```

That unit may seem unpractical, but it allows a reasonable precision
using only integers. If you can avoid converting to volts, you will be
able to write integer-only code which is smaller and faster.

I would suggest you first try using floats, as it's the simplest
solution. If that leads to code with is either too large or too slow,
then try to rewrite with fixed-point (i.e. integer only) arithmetic.
> 
> At least 2 or 3 [digits], just the type smallest amount above this so I can
>  save processing power on my Trinket board
> 
> 
> 

Processors (computers) do not normally store values in [Binary Coded Decimal (BCD)](https://en.wikipedia.org/wiki/Binary-coded_decimal) (as in base 10) because such storage wast valuable space. Rather, processors usually use [Binary numbers](https://en.wikipedia.org/wiki/Binary_number) (as in base 2).

Most processors deal with binary values in multiples of 8 bits. So, values are usually represented by 8 bits, 16 bits, 32 bits, ect. An 8 bit binary number can have 2^8 possible values or 2 \* 2 \* 2 \* 2 \* 2 \* 2 \* 2 \* 2 or 256. That is to say, an 8 bit binary number can have values between 0 and 255 inclusive.

If your requirement of "reasonable amount of decimals" falls within that range, then the type you are looking for is "uint8\_t" or "char". Both are normally 8 bits in the C / C++ language. If you need more the next binary number has 16 bits or 2^16 or values between 0 and 65535. Then the type you are looking for is "uint16\_t" or "unsigned int".