Analog Arduino Projects with TinkerCAD

In Arduino microcontrollers, analog inputs are constrained to a range of 0 to 1023 because they use a 10-bit analog-to-digital converter (ADC) to convert continuous analog voltage levels into discrete digital values.

A 10-bit ADC can represent a voltage range from 0 to 2^10 - 1, which is 0 to 1023. This means that the analog input value you read from an Arduino pin will be a number between 0 and 1023, representing the voltage level applied to that pin. The reference voltage for the ADC is typically the operating voltage of the microcontroller, which is usually 5V for most Arduino boards.

This limited range can be a bit coarse for some applications, but it's usually sufficient for many common tasks. If higher precision is needed, external hardware or specialized ADCs with higher bit resolutions can be used.

If you want to map this 0-1023 range to a different range (for example, if you're working with a sensor that outputs a voltage range not equal to 0-5V), you can use the map() function in Arduino to scale the readings to your desired range.

 2. Write the Arduino Sketch

• The goal of this code is to understand mapping inputs. Create two variables for your analog input and your digital output. Assigning input and output pins to variables is best practice and will help you keep track of things in larger projects. On TinkerCAD, mapping is as simple as using the mapping block under the math blocks. Just map the variable you want to change to new values. In this case, we are mapping the 0 to 1023 of the analog input to 0 to 255, the PWM range for power output on an Arduino. 

 3. Understand the Code

• int sensorValue = LOW (0); stores the starting state of the potentiometer.

• int outputValue = LOW (0); stores the starting state of the output which is later assigned to pin 3.

In the loop():

• outputValue = digitalRead(3); Sets pin 3 to outputValue variable

• sensorValue = analogRead(A0); Sets A0 to sensorValue variable

• outputValue = map(sensorValue, 0, 1023, 0, 255); maps the analog sensor's range of 0 to 1023 to the output variable of 0 to 255 for PWM.

• Serial.print; prints text and variable values for both

Questions: 

1. How does analog mapping enhance the interpretation of potentiometer readings?

2. What other information can be useful to display in the Serial Monitor when working with analog mapping?

3. How do you interpret the data displayed in the Serial Monitor, especially after analog mapping?

4. How can you relate the original potentiometer readings to the mapped values?

5. How does this project lay the groundwork for more complex projects involving analog signals?

 2. Write the Arduino Sketch

• This code should be relatively easy to write. You are using what you know about mapping to map your analog sensor to time in milliseconds instead of power for the output pin. 

 3. Understand the Code

• pinMode(ledPin, OUTPUT); sets the LED pin as an output.

In the loop():

• int Sensor = analogRead(Sensor); reads the value from the potentiometer.

• int blinkInterval = map(Sensor, 0, 1023, 50, 1000); maps the potentiometer reading (0-1023) to a delay range (50-1000 ms).

• digitalWrite(ledPin, HIGH); turns on the LED.

• delay(blinkInterval); waits for the specified interval.

• digitalWrite(ledPin, LOW); turns off the LED.

• delay(blinkInterval); waits for the specified interval again.

4. Upload and Monitor

• Upload the sketch to the Arduino board. Open the Serial Monitor in the Arduino IDE (Ctrl+Shift+M or Tools > Serial Monitor).

 5. Experiment and Observe

• Spin the potentiometer. The LED will blink faster or slower depending on the proportion of the variable resistor's low and max in relationship to 50 ms and 1000 ms.

This project provides a hands-on demonstration of how a potentiometer can be used to dynamically control an aspect of an electronic circuit, in this case, the blink rate of an LED. This knowledge can be applied to various projects where adjustable parameters are required.

Questions: 

1. How does the potentiometer interact with the LED in terms of controlling the blink speed?

2. How are variables initialized in the Arduino sketch for storing potentiometer readings and LED blink speed values?

3. What naming conventions are followed when creating variables in the sketch?

4. How does the choice of variable names contribute to code readability?

5. Can you think of applications where dynamic control of visual elements is valuable?

6. Can you modify the sketch to display both potentiometer readings and LED blink speed variables in the Serial Monitor?

 2. Write the Arduino Sketch

• In the Arduino IDE, this code would be much shorter and simpler because you can increment pin outputs- in TinkerCAD you cannot so your only option is to do Logic statements. This works fine but is cumbersome. For a sample of this less cumbersome code, check out the AnalogWriteMga code under Analog in the example library on Arduino Create.

 3. Understand the Code

• pinMode(ledPin, OUTPUT); sets the different LED pins as an outputs

In the loop():

• int Sensor = analogRead(Sensor); reads the value from the potentiometer.

• int blinkInterval = map(Sensor, 0, 1023, 0, 10); maps the potentiometer reading (0-1023) to a number of LEDs (0-10)

• if (LEDNumber > 2) {

•     digitalWrite(1, HIGH);

•   } else {

•     digitalWrite(1, LOW); sets the LED to on if the sensor is in range, otherwise keeps it off.

4. Upload and Monitor

• Upload the sketch to the Arduino board. Open the Serial Monitor in the Arduino IDE (Ctrl+Shift+M or Tools > Serial Monitor).

 5. Experiment and Observe

• Spin the potentiometer. A different amount of LEDs will urn on between 0 and 10 depending on the proportion of the variable resistor's low and max in relationship to the mapped 0 and 10 LEDs.

This project provides a hands-on demonstration of how a potentiometer can be used to dynamically control an aspect of an electronic circuit, in this case, the number of LEDs turned on. This knowledge can be applied to various projects where adjustable outputs such as a battery or power scale is required visually.

Questions: 

1. How do the 10 LEDs contribute to creating a "fading scale" effect?

2. Why is there only one resistor for all the LEDs?

3. What functions or techniques are used to create the fading effect?

4. Can you modify the sketch to create different fading patterns or sequences?

In this project, we'll use a flex sensor to control the brightness of an LED. When the flex sensor is bent, the LED's brightness will change accordingly. This project will explore how Arduino reads analog sensors through the voltage drops the sensor creates. 

 2. Find the range of your Flex Sensor

Knowing the range of the flex sensor allows you to effectively map its readings to a specific range of values that suits your application. This is crucial for accurate and responsive control using the flex sensor in your projects. Keep in mind that the range may vary depending on the specific flex sensor model and its specifications. It's always a good practice to consult the datasheet or product documentation for accurate information. If you do not have a datasheet, you can also just make sure the first thing you do when making a project with a flex sensor is to test the range using your serial monitor. 

• The range of the flex sensor is the difference between the highest and lowest readings you recorded. This range will vary depending on the resistor in series with the flex sensor, changing the voltage drop that is read by the Arduino. For example, if the lowest reading is 300 and the highest reading is 900, the range is 600 (900 - 300).

• The Arduino has a set of pins labeled with "A" (e.g., A0, A1, A2, etc.) that are specifically designed for reading analog voltages. These pins can read a voltage between 0V (ground) and the reference voltage (usually 5V for most Arduinos).

• The reference voltage is the maximum voltage that the ADC can measure. In most cases, it's set to 5V. This means the ADC can represent voltages from 0V to 5V in a range of digital values from 0 to 1023.

 3. Write the Arduino Sketch

• In the Arduino IDE, this code would be much shorter and simpler because you can increment pin outputs- in TinkerCAD you cannot so your only option is to do Logic statements. This works fine but is cumbersome. For a sample of this less cumbersome code, check out the AnalogWriteMga code under Analog in the example library on Arduino Create.

4. Understand the Code

• pinMode(A0, INPUT); sets the flex sensor as an input.

• pinMode(ledPin, OUTPUT); sets the LED pin as an output.

In the loop():

• Flex = constrain(analogRead(A0), 0, 255); Constrains the flex sensors range that we just found of 59 to 256 to 0 to 255. This means it will never exceed this range when outputting later in the code. In this case, this is important because we are going to use the flex sensor to control the brightness of an LED which is 0 to 255. A number higher than 255 will turn an LED off. 

• Serial.println(Flex); Shows us our new constrained values on the serial monitor for reference.

• analogWrite(3, Flex); outputs the LED to the flex sensor ranges.

 5. Upload and Monitor

• Upload the sketch to the Arduino board. Open the Serial Monitor in the Arduino IDE (Ctrl+Shift+M or Tools > Serial Monitor).

6. Experiment and Observe

• Bend the Flex Sensor. The LED should brighten and dim as the Flex Sensor is manipulated.

This project demonstrates how to use a flex sensor as an input device to control the brightness of an LED. This concept can be extended to various applications, such as creating interactive lighting or responsive devices based on physical manipulation.

Questions: 

1. How is the flex sensor connected to the Arduino board?

2. Can you explain the concept of voltage drop across the flex sensor as it bends?

3. How does the Arduino read the voltage drop across the flex sensor?

4. Can you think of applications where sensing physical deformation is valuable?

5. How does this project build on your knowledge of basic Arduino programming and sensor integration?