Elvis Wiki - User contributions [en]

Arduino Board Uno Rev3-Atmega 328: First Steps

2020-08-27T23:40:18Z

CCinay: /* Arduino UNO Überblick */

STM32 LoRa Discovery Kit: First Steps

2020-08-11T22:15:01Z

CCinay:

<div style="max-width: 970px">

== Summary ==
STMicroelectronics B-L072Z-LRWAN1 STM32 LoRa Discovery Board is a development tool to learn and develop solutions based on LoRa and/or FSK/OOK technologies. This tool features an all-in-one open module solution (by Murata), which is the smallest and cheapest on the market, to address wide area network (LPWAN) wireless modules that support the LoRaWAN long range wireless protocol.
The Discovery board comes with the certified embedded software (I-CUBE-LRWAN) to provide the means to set up a complete LoRaWAN node. The I-CUBE-LRWAN is LoRaWAN class A certified and sustains the Class C.

<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Disco-Overview.jpg|thumb|none|400px|STM32-LoRa-Disco-Overview]] </li>
</ul></div>

== Features ==
&emsp;➥ Embedded ultra low power STM32L072CZ series MCUs based on ARM Cortex -M0+ core

&emsp;➥ 192 Kbytes of flash memory, 20 Kbytes of RAM, 20 Kbytes of EEPROM

&emsp;➥ 4-channel, 12bit ADC, 2 x DAC, USB 2.0 FS & 157dB maximum link budget

&emsp;➥ Low RX current of 10mA, 200nA register retention & preamble detection

&emsp;➥ System requirements are Windows OS (XP, 7, 8, 10), Linux or macOS and USB type-A to Micro-B cable

=== Hardware block diagramm ===
<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Hardware-block-Diagramm.JPG|thumb|none|400px|STM32-LoRa-Hardware-block-Diagramm]] </li>
</ul></div>

== Configuring STM32 LoRa Discovery Kit ==
Now, we will programm the STM32 LoRa Discovery Kit B-L072Z-LRWAN1 and the Nucleo Expansion (X-NUCLEO-IKS01A1) as the Node device.
[https://www.st.com/content/st_com/en/products/embedded-software/mcu-mpu-embedded-software/stm32-embedded-software/stm32cube-expansion-packages/i-cube-lrwan.html <br>Unzip I-CUBE-LRWAN] and start [http://www2.keil.com/stmicroelectronics-stm32/mdk Keil uVision].

&emsp;➥ On Keil, click Project > Open > Open Project..., select the project inside the unzipped I-CUBE-LRWAN

&emsp;➥ STM32CubeExpansion_LRWAN_V1.3.1\Projects\B-L072Z-LRWAN1\Applications\LoRa\End_Node\MDK-ARM

&emsp;➥ The original demo was originally set to the european frequency 868MHz so we'll need to modify it to work on the 915MHz frequency.
<br>&emsp;&emsp; Right-click on the project and select "Options for Target 'mlm32l07x01' ..."

<div><ul>
<li style="display: inline-block;"> [[File:STM32CubeExpansion_LRWAN_V1.3.1_Projects.jpg|thumb|none|400px|STM32CubeExpansion_LRWAN_V1.3.1_Projects]] </li>
</ul></div>

&emsp;➥ Select the "C / C ++" tab, change "REGION_EU868" to "REGION_US915" and add the define "X_NUCLEO_IKS01A1". Click OK to proceed.

<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Step2.JPG|thumb|none|400px|STM32-LoRa-Step2]] </li>
</ul></div>

&emsp;➥ Right-click on "Drivers/BSP/X_NUCLEO_IKS01A2" > Options for Group...

<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Step3.JPG|thumb|none|400px|STM32-LoRa-Step3]] </li>
</ul></div>

&emsp;➥ Uncheck "Include in Target Build". Click Ok.

<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Step4.JPG|thumb|none|400px|STM32-LoRa-Step4]] </li>
</ul></div>

&emsp;➥ Then right-click on "Drivers/BSP/X_NUCLEO_IKS01A1" > Options for Group...

<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Step5.JPG|thumb|none|400px|STM32-LoRa-Step5]] </li>
</ul></div>

Check "Include in Target Build". Click Ok.

<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Step6.JPG|thumb|none|400px|STM32-LoRa-Step6]] </li>
</ul></div>

&emsp;➥ Open the file "Commissioning.h"

<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Step7.JPG|thumb|none|400px|STM32-LoRa-Step7]] </li>
</ul></div>

&emsp;➥ Make the following code changes on line 77:
<pre>#define OVER_THE_AIR_ACTIVATION 0 </pre>
line 89:
<pre>#define STATIC_DEVICE_EUI 1</pre>
<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Step8.JPG|thumb|none|400px|STM32-LoRa-Step8]] </li>
</ul></div>

and line 122:
<pre>#define STATIC_DEVICE_ADDRESS 1 </pre>
<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Step9.JPG|thumb|none|400px|STM32-LoRa-Step9]] </li>
</ul></div>

== Used Hardware ==
&emsp;➠ [[STM32 LoRa and Sigfox Discovery kit]]

&emsp;➠ [[X-NUCLEO-IKS01A2 nucleo expansion board]]

== References ==
&emsp;➠ https://www.hackster.io/victorffs/environmental-sensing-using-lora-and-stm32-c0136e

&emsp;➠ https://www.st.com/content/st_com/en/search.html#q=lrwan-t=tools-page=1

&emsp;➠ https://www.electronicdesign.com/technologies/embedded-revolution/article/21806418/a-handson-look-at-the-stm32-kit-for-longrange-wireless

&emsp;➠ https://www.hackster.io/victorffs/environmental-sensing-using-lora-and-stm32-c0136e

[[Category:Documentation]]

File:STM32-LoRa-Disco-Overview.jpg

2020-08-11T22:14:15Z

CCinay:

STM32 LoRa Discovery Kit: First Steps

2020-08-11T22:12:51Z

CCinay: Created page with "<div style="max-width: 970px"> == Summary == STMicroelectronics B-L072Z-LRWAN1 STM32 LoRa Discovery Board is a development tool to learn and develop solutions based on LoRa a..."

<div style="max-width: 970px">

== Summary ==
STMicroelectronics B-L072Z-LRWAN1 STM32 LoRa Discovery Board is a development tool to learn and develop solutions based on LoRa and/or FSK/OOK technologies. This tool features an all-in-one open module solution (by Murata), which is the smallest and cheapest on the market, to address wide area network (LPWAN) wireless modules that support the LoRaWAN long range wireless protocol.
The Discovery board comes with the certified embedded software (I-CUBE-LRWAN) to provide the means to set up a complete LoRaWAN node. The I-CUBE-LRWAN is LoRaWAN class A certified and sustains the Class C.

== Features ==
&emsp;➥ Embedded ultra low power STM32L072CZ series MCUs based on ARM Cortex -M0+ core

&emsp;➥ 192 Kbytes of flash memory, 20 Kbytes of RAM, 20 Kbytes of EEPROM

&emsp;➥ 4-channel, 12bit ADC, 2 x DAC, USB 2.0 FS & 157dB maximum link budget

&emsp;➥ Low RX current of 10mA, 200nA register retention & preamble detection

&emsp;➥ System requirements are Windows OS (XP, 7, 8, 10), Linux or macOS and USB type-A to Micro-B cable

=== Hardware block diagramm ===
<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Hardware-block-Diagramm.JPG|thumb|none|400px|STM32-LoRa-Hardware-block-Diagramm]] </li>
</ul></div>

== Configuring STM32 LoRa Discovery Kit ==
Now, we will programm the STM32 LoRa Discovery Kit B-L072Z-LRWAN1 and the Nucleo Expansion (X-NUCLEO-IKS01A1) as the Node device.
[https://www.st.com/content/st_com/en/products/embedded-software/mcu-mpu-embedded-software/stm32-embedded-software/stm32cube-expansion-packages/i-cube-lrwan.html <br>Unzip I-CUBE-LRWAN] and start [http://www2.keil.com/stmicroelectronics-stm32/mdk Keil uVision].

&emsp;➥ On Keil, click Project > Open > Open Project..., select the project inside the unzipped I-CUBE-LRWAN

&emsp;➥ STM32CubeExpansion_LRWAN_V1.3.1\Projects\B-L072Z-LRWAN1\Applications\LoRa\End_Node\MDK-ARM

&emsp;➥ The original demo was originally set to the european frequency 868MHz so we'll need to modify it to work on the 915MHz frequency.
<br>&emsp;&emsp; Right-click on the project and select "Options for Target 'mlm32l07x01' ..."

<div><ul>
<li style="display: inline-block;"> [[File:STM32CubeExpansion_LRWAN_V1.3.1_Projects.jpg|thumb|none|400px|STM32CubeExpansion_LRWAN_V1.3.1_Projects]] </li>
</ul></div>

&emsp;➥ Select the "C / C ++" tab, change "REGION_EU868" to "REGION_US915" and add the define "X_NUCLEO_IKS01A1". Click OK to proceed.

<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Step2.JPG|thumb|none|400px|STM32-LoRa-Step2]] </li>
</ul></div>

&emsp;➥ Right-click on "Drivers/BSP/X_NUCLEO_IKS01A2" > Options for Group...

<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Step3.JPG|thumb|none|400px|STM32-LoRa-Step3]] </li>
</ul></div>

&emsp;➥ Uncheck "Include in Target Build". Click Ok.

<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Step4.JPG|thumb|none|400px|STM32-LoRa-Step4]] </li>
</ul></div>

&emsp;➥ Then right-click on "Drivers/BSP/X_NUCLEO_IKS01A1" > Options for Group...

<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Step5.JPG|thumb|none|400px|STM32-LoRa-Step5]] </li>
</ul></div>

Check "Include in Target Build". Click Ok.

<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Step6.JPG|thumb|none|400px|STM32-LoRa-Step6]] </li>
</ul></div>

&emsp;➥ Open the file "Commissioning.h"

<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Step7.JPG|thumb|none|400px|STM32-LoRa-Step7]] </li>
</ul></div>

&emsp;➥ Make the following code changes on line 77:
<pre>#define OVER_THE_AIR_ACTIVATION 0 </pre>
line 89:
<pre>#define STATIC_DEVICE_EUI 1</pre>
<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Step8.JPG|thumb|none|400px|STM32-LoRa-Step8]] </li>
</ul></div>

and line 122:
<pre>#define STATIC_DEVICE_ADDRESS 1 </pre>
<div><ul>
<li style="display: inline-block;"> [[File:STM32-LoRa-Step9.JPG|thumb|none|400px|STM32-LoRa-Step9]] </li>
</ul></div>

== Used Hardware ==
&emsp;➠ [[STM32 LoRa and Sigfox Discovery kit]]

&emsp;➠ [[X-NUCLEO-IKS01A2 nucleo expansion board]]

== References ==
&emsp;➠ https://www.hackster.io/victorffs/environmental-sensing-using-lora-and-stm32-c0136e

&emsp;➠ https://www.st.com/content/st_com/en/search.html#q=lrwan-t=tools-page=1

&emsp;➠ https://www.electronicdesign.com/technologies/embedded-revolution/article/21806418/a-handson-look-at-the-stm32-kit-for-longrange-wireless

&emsp;➠ https://www.hackster.io/victorffs/environmental-sensing-using-lora-and-stm32-c0136e

[[Category:Documentation]]

File:STM32-LoRa-Hardware-block-Diagramm.JPG

2020-08-11T22:08:27Z

CCinay:

File:STM32-LoRa-Step9.JPG

2020-08-11T21:55:30Z

CCinay:

File:STM32-LoRa-Step8.JPG

2020-08-11T21:53:20Z

CCinay:

File:STM32-LoRa-Step7.JPG

2020-08-11T21:44:16Z

CCinay:

File:STM32-LoRa-Step6.JPG

2020-08-11T21:42:16Z

CCinay:

File:STM32-LoRa-Step5.JPG

2020-08-11T21:35:31Z

CCinay:

File:STM32-LoRa-Step4.JPG

2020-08-11T20:13:31Z

CCinay:

File:STM32-LoRa-Step3.JPG

2020-08-11T19:51:36Z

CCinay:

File:STM32-LoRa-Step2.JPG

2020-08-11T19:25:41Z

CCinay:

File:STM32CubeExpansion LRWAN V1.3.1 Projects.jpg

2020-08-11T19:08:33Z

CCinay:

Arduino Board Uno Rev3-Atmega 328: Programming Guide

2020-08-10T20:57:30Z

CCinay: /* Serial.println(data) */

<div style="max-width: 970px">

== Summary ==
The <b>Arduino IDE</b> is a cross-platform Java application that acts as a program code editor and compiler and is also able to send firmware serially to the board. The development environment is based on Processing, an IDE designed to program artists, who normally do not have much contact with the art world programming environments. The programming language is based on Wiring, a C similar language which has a similar scope for a more restricted board design, whose IDE is also based on processing. Make sure you have an updated version of <b>[https://www.arduino.cc/en/Main/Software Arduino IDE]</b> installed.

== Struktur ==
The basic structure of the Arduino programming language is relatively simple and is divided into at least two parts. These two required parts or functions enclose blocks of statements.

<pre>void setup() { // put your setup code here, to run once:
}
void loop() { // put your main code here, to run repeatedly:
}</pre>

&emsp;➥ Here <b>setup()</b> is the preparation and <b>loop()</b> is the execution. Both functions are necessary to execute the program.

&emsp;➥ The setup function should follow the variable definition, which must be listed before. Setup must be run through as the first function in a program. <br>&emsp;&emsp; It is executed only once and is used to set <b>PinMode</b> or to initiate serial communication.

&emsp;➥ The <b>setup()</b> function is called once when the program starts. Use this function to set PinModes or start serial communication. The <b>setup()</b> function must <br>&emsp;&emsp; appear in every program, even if it does not contain any instructions.

&emsp;➥ After the <b>setup()</b> function follows the <b>loop()</b> function. It contains program code that is executed continuously in an infinite loop - read inputs, trigger <br>&emsp;&emsp; outputs, etc. This function is the core of all Arduino programs and does the main work.

=== setup() ===
The <b>setup()</b> function is called once when the program starts. Use this function to set <b>PinModes</b> or start serial communication.
The <b>setup()</b> function must appear in every program, even if it does not contain any instructions.

<pre>void setup()
{
pinMode(pin, OUTPUT); // 'pin' define as output
}</pre>

=== loop() ===
After running through the <b>setup() function</b>, the <b>loop() function</b> does exactly what its name suggests and runs in an endless loop. This allows the program to interact with the Arduino board via changes, reactions and controls.
<pre>void loop()
{
digitalWrite(pin, HIGH); // switches 'pin' on
delay(1000); // Pause for one second
digitalWrite(pin, LOW); // switches 'pin' off
delay(1000); // Pause for one second
}</pre>

=== Functions ===
A function is a block of program code that has a name and a set of instructions that are executed when the function is called. The functions <b>void setup()</b> and <b>void loop()</b> have already been explained. There are more built-in functions that will be discussed later.

<pre>Type FunctionName(parameter)
{
instructions;
}</pre>

The following integer type function <b>delayVal()</b> is used to insert a delay value into a program by reading a potentiometer. First a local variable <b>'v'</b> is created. Next, <b>'v'</b> is equated with the position of the potentiometer, which can have a value between <b>0 and 1023</b>. The value is then <b>divided by 4 to get a scale from 0 to 255</b> and at the end the result of the function is returned to the main program.

<pre>int delayVal()
{
int v; // create temporary variable 'v
v = analogRead(pot); // read potentiometer Value
v /= 4; // Convert from 0-1023 to 0-255
return v; // return the calculated value
}</pre>

=== {} curly brackets ===
Curly brackets (also called <b>'curly brackets'</b>) define the start and end of function and statement blocks as in the <b>'void loop()'</b> function and also in the <b>'for' and 'if'</b> statement.

<pre>type function()
{
instructions;
}</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: An opening curved bracket '{' must always be followed by a closing curved bracket '}'. Here it is often said that the number of brackets must be balanced. Unbalanced parentheses often lead to cryptic, inscrutable errors in the compiler, which are sometimes hard to find, especially in large programs.

The Arduino programming environment helps to check that the curved brackets are balanced. To do this, simply select a brace or click just behind it, and the logically connected counterpart is highlighted. </div>

=== ;semicolon ===
A semicolon must be used at the end of a statement and is used to separate the elements of a program.
A semicolon is also used to separate the elements of a for loop.

<pre>int x = 13; // declares variable 'x' as integer with value 13</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Forgetting a semicolon at the end of a line leads to an error in the compiler. The error description can be very clear and directly point to the missing semicolon, but this does not have to be the case. If an inscrutable or apparently illogical error is reported, the first thing to do is to add missing semicolons near the reported error. </div>

=== /*... */ block comments ===
Block comments or multiline comments are text areas that are ignored by the program. They are used for longer descriptions or comments and help other authors to understand program parts. They start with /* and end with */ and can cover several lines.

<pre>/* This is an inserted block comment
please do not forget the closing comment -
These must be balanced
*/</pre>

=== // Single line comments ===
Simple single-line comments are defined with a // at the beginning of the line and end with the end of the line. They are ignored by the program and do not consume memory.
<pre>// this is a single line comment</pre>

== Variables ==
A variable is the name of a numeric value with a name and memory location for later use in a program. A variable must be declared and optionally provided with a value. The following example declares a variable 'inputVariable' and assigns the value of analog pin 2 to it:
<pre>int inputVariable = 0; // declares a variable and
// sets its value to 0
inputVariable = analogRead(2); // sets the value of the variable equal
// with the value of analog pin 2 </pre>

'inputVariable' is the variable itself. The first line explains that its data type is 'int', which is the short expression for integer. The second line gives the variable the value of the analog pin 2, making the value of the pin available everywhere in the code.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Variables should always have descriptive names as clearly as possible to make the code easier to read.</div>

=== Declaration of variables: ===
All variables must be declared before use. Declaring a variable means defining its type such as int, long, float, etc., giving it a name and optionally an initial value.This only needs to be done once in the program. Afterwards the value can be changed at any time by calculations or various assignments.

The following example declares 'inputVariable' as 'int', i.e. integer data type and sets the initial value to 0. This is called a 'simple assignment'.
<pre>int inputVariable = 0;</pre>

A variable can be declared at many places in the program. The location of the declaration determines which program parts have access to the variable.

== Data types ==
&emsp;➥ <b>byte</b>: Byte stores an <b>8-bit numeric</b>, integer value without decimal point. The <b>value</b> can be between <b>0 and 255</b>.
<pre>byte someVariable = 180; // declares 'someVariable as a 'byte' data type </pre>

&emsp;➥ <b>int</b>: Integers are the most common data type for storing integer values without decimal point. Its <b>value</b> is <b>16 bits and ranges from -32,767 to 32,768</b>.
<pre>int someVariable = 1500; // declares 'someVariable as an 'integer' data type</pre>

&emsp;➥ <b>long</b>: Data type for long integers with extended size, without decimal point, <b>stored in a 32-bit</b> value in a spectrum from <br>&emsp;&emsp;<b>-2,147,483,648 to 2,147,483,647</b>
<pre>long someVariable = 90000; // declares 'someVariable as a 'long' data type </pre>

&emsp;➥ <b>float</b>: A data type for floating point values or numbers with decimal places. Floating point numbers have a better resolution than integers and are<br>&emsp;&emsp; expressed as <b>32-bit values with a spectrum from -3.4028235E+38 to 3.4028235E+38</b>.
<pre>float someVariable = 3.14; // declares 'someVariable' as a 'float' data type </pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Floating point numbers are not precise and may lead to strange results when compared. Also, floating-point calculations are much slower than with integer data types. Calculations with floating-point values should be avoided if possible. </div>

&emsp;➥ <b>arrays</b>: An array is a collection of values that are accessed with an index number.
Each value in the array can be accessed by retrieving the name of<br>&emsp;&emsp; the array and the index number of the value. The index number always starts at 0 for an array.<br>&emsp;&emsp; An array must be declared and optionally assigned values before it can be used.
<pre>int myArray[] = {value0, value1, value2...} </pre>

In the same way it is possible to declare an array first with datatype and size and later to give a value to an index position.
<pre>int myArray[5]; // declare datatype 'integer' as array with 5 Positions
myArray[3] = 10; // gives the 4th index the value 10 </pre>

To read the value of an array you can simply assign it to a variable specifying the array and the index position.
<pre>x = myArray[3]; // x now has the value 10 </pre>

Arrays are often used for loops, where the counter of the loop is also used as index position for the values in the array. The following example uses an array to make an LED flicker. With a for loop and a counter starting at 0 an index position in the array is read, sent to the LED pin, paused for 200ms and then the same is done with the next index position.
<pre>int ledPin = 10; // LED on pin 10
byte flicker[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array with 8 different values
void setup()
{
pinMode(ledPin, OUTPUT); // Sets the OUTPUT pin
}

void loop()
{
for(int i=0; i<7; i++) // loop equals the number
{ // of the values in the array
analogWrite(ledPin, flicker[i]); // writes the index value to the LED
delay(200); // 200ms pause
}
}</pre>

== Digitaler Input - Output ==
=== pinMode(pin,mode) ===
Used in 'void setup()' to configure a specific pin as either input or output.
<pre>pinMode(pin, OUTPUT); // sets 'pin' as output </pre>

Arduino digital pins are inputs by default, so they don't need to be specified as inputs with 'pinMode()'. Pins configured as inputs have a high impedance state.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: There are also comfortable 20 k 'pullup' resistors in the ATmega chip which are accessible via software.</div>

These built-in 'pullup' resistors can be accessed in the following way:
<pre>pinMode(pin, INPUT); // sets 'pin' as input
digitalWrite(pin, HIGH); // switches on the 'Pullup' resistor</pre>

&emsp;➥ Pullup resistors are normally used to connect inputs like switches. In the example shown here it is noticeable that the pin is not defined as an output<br>&emsp;&emsp; although it is written to. It is only the method to activate the internal 'pullup' resistor.

&emsp;➥ Pins configured as output are in a low impedance state and can be loaded with a maximum of 40 mAmpere current from connected elements<br>&emsp;&emsp; and circuits. This is enough to make an LED light up (don't forget the serial resistor), but not enough to drive most relays, solenoids or motors.

&emsp;➥ Short circuits at the Arduino pins as well as too high current can destroy the output pin or even the whole ATmega chip. For this reason it is a good idea<br>&emsp;&emsp; to connect an output pin with external elements in series with a 470 or 1K resistor to
switch.

=== digitalRead(pin) ===
digitalRead(pin)' reads the value from a specified digital pin, with the result either HIGH or LOW. The pin can be set either as a variable or constant (0-13).
<pre>value = digitalRead(Pin); // sets 'value' equal to the input pin </pre>

digitalWrite(pin,value)
Outputs either logic level HIGH or LOW at a specified pin. The pin can be set as a variable or constant (0-13).
<pre>digitalWrite(pin, HIGH); // sets 'pin' to high</pre>

The following example reads a button on a digital input and switches an LED on when the button is pressed:
<pre>int led = 13; // LED connected to pin 13
int pin = 7; // Button connected to pin 7
int value = 0; // Variable to store the readout value

void setup()
{
pinMode(led, OUTPUT); // defines pin 13 as output
pinMode(pin, INPUT); // sets pin 7 as input
}

void loop()
{
value = digitalRead(pin); // sets 'value' equal to
// the input pin
digitalWrite(led, value); // sets 'led' equal to the
} // Value of the button</pre>

== Analoger Input - Output ==
=== analogRead(pin) ===
Reads the value of a specified analog pin with a 10 bit resolution. This function is only available for pins (0-5). The resulting integer values have a spectrum from 0 to 1023.
<pre>value = analogRead(pin); // sets 'value' equal to 'pin</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Unlike digital pins, analog pins do not have to be declared as input or output first. </div>

=== analogWrite(pin, value) ===
Writes pseudo-analog values to an output pin using hardware-based pulse width modulation (PWM). On newer Arduino boards with the ATmega 168 chip this function is applicable to pins 3, 5, 6, 9, 10 and 11. Older Arduinos with the ATmega8 only support pins 9,10 and 11. The value can be set as a variable or constant in the range 0-255.
<pre>analogWrite(pin, value); // writes 'value' to the analog 'pin </pre>

A value of 0 generates a uniform voltage of 0 volts at a fixed pin; a value of 255 generates a uniform voltage of 5 volts at a fixed pin. For values between 0 and 255, the pin changes very quickly between 0 and 5 volts - the higher the value, the longer the pin is HIGH (5 volts). For a value of 64, the pin is at 0 volts for three-quarters of the time and at 5 volts for one-quarter of the time. A value of 128 means that the output voltage is HIGH half of the time and LOW the other half. A value of 192 means that the voltage at the pin measures 0 volts at one quarter of the time and the full 5 volts at three quarters of the time.

Because this is a hardware-based function, the constant wave runs independently of the program until the next change of state via analogWrite (or a call to digitalRead or digitalWrite on the same pin).

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: In contrast to digital pins, analog pins do not have to be declared as input or output before. </div>

&emsp;➥ The following example reads an analog value from 'pin', converts the value by dividing it by 4 and then outputs it as a PWM signal to 'led'.

<pre>int led = 10; // LED with 220 resistor at pin 10
int pin = 0; // Potentiometer at analog pin 0
int value; // Value for readout

void setup(){} // no setup required

void loop()
{
value = analogRead(pin); // sets 'value' equal to 'pin
value /= 4; // converts 0-1023 into 0-255
analogWrite(led, value); // outputs the PWM signal 'led
}</pre>

== Random functions ==
=== randomSeed(seed) ===
Sets a value or 'Seed' as starting point for the random() function.
<pre>randomSeed(value); // sets 'value' as the random seed</pre>

The Arduino itself is not able to produce a truly random value. With randomSeed() a variable can be used as 'seed' to get better random results. For example, millis() or analogRead() can be used as a seed variable or function to use electrical noise through the analog pin as an output for random values.

=== random(min, max) ===
The random function allows the generation of pseudo-random values within a defined range of minimum and maxium values.
<pre>value = random(100, 200); // sets 'value' with a random number between 100 and 200 equal </pre>

The following example generates a random value between 0 and 255 and outputs it as PWM signal on a PWM pin.
<pre>int randNumber; // Variable to store the random value
int led = 10; // LED with 220 Ohm resistor at pin 10

void setup() {} // no setup necessary

void loop()
{
randomSeed(millis()); // uses millis() as seed
randNumber = random(255); // Random number in the range 0-255
analogWrite(led, randNumber); // PWM signal as output
delay(500); // half second pause
}</pre>

== Serial communication ==
=== Serial.begin(rate) ===
Serial.begin(rate)' Opens the serial port and sets the baud rate for the serial transmission. The typical baud rate with the computer is 9600 baud. Other speeds are also supported.
<pre>void setup()
{
Serial.begin(9600); // opens serial port sets the data rate to 9600 bps
}</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: When using serial communication, <b>digital pins 0 (RX) and 1 (TX)</b> cannot be used at the same time. </div>

=== Serial.println(data) ===
Writes data to the serial port, followed by an automatic line break as carrier return and line feed. This function has the same form as 'Serial.print()', but is easier to read on the serial monitor.
<pre>Serial.println(analogValue); // sends the value of 'analogValue'</pre>

More detailed information about the numerous variants of the 'Serial.println()' and 'Serial.print()' functions can be found on the Arduino website.

The following simple example reads a value from analog pin 0 and sends the data to the computer once per second.
<pre>void setup()
{
Serial.begin(9600); // sets the data rate to 9600 bps
}

void loop()
{
Serial.println(analogRead(0)); // sends the analog value
delay(1000); // pauses for 1 second
}</pre>

== Examples ==
=== Digital output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Output.JPG|thumb|none|300px|Arduino-Example-Digital-Output]] </li>
</ul></div>

This is a simple 'Hello World' program and turns something on and off. In this example a LED is connected to PIN 13 and flashes every second. The resistor may be superfluous at this pin because the Arduino has a built-in resistor.
<pre>int ledPin = 13; // LED off digital pin 13

void setup() // will run through once
{
pinMode(ledPin, OUTPUT); // sets pin 13 as output
}

void loop() // Running as endless loop
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}</pre>

=== Digital input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Input.JPG|thumb|none|300px|Arduino-Example-Digital-Input]] </li>
</ul></div>

This is the simplest form of an input with only two possible states: on or off.
This example reads out a simple switch or button at pin 2. When the switch is closed and the input pin is HIGH, the LED is turned on.
<pre>int ledPin = 13; // Output pin for the LED
int inPin = 2; // Input pin for a switch

void setup()
{
pinMode(ledPin, OUTPUT); // declares LED as output
pinMode(inPin, INPUT); // declares switch as input
}
void loop()
if (digitalRead(inPin) == HIGH) // check if this is the HIGH input
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}
}</pre>

=== analog PWM output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

Pulse width modulation (PWM) is a method of simulating analog outputs by pulsing the output voltage. This allows you to make an LED brighter or darker or check a servomotor later. The following example uses a loop to slowly make an LED brighter and darker.

<pre>int ledPin = 9; // PWM Pin for the LED

void setup(){} // No setup necessary

void loop()
{
for (int i=0; i<=255; i++) // ascending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}

for (int i=255; i>=0; i--) // descending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}
}</pre>

=== potentiometer Input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

With a potentiometer and one of the analog-digital converter (ADC) inputs of the Arduino it is possible to read analog values from 0-1024. The following example uses a potentiometer to control the blinking rate of an LED.

<pre>int potPin = 0; // Input pin for the potentiometer
int ledPin = 13; // Output pin for the LED

void setup()
{
pinMode(ledPin, OUTPUT); // declare ledPin as OUTPUT
}

void loop()
{
digitalWrite(ledPin, HIGH); // switches on ledPin
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
digitalWrite(ledPin, LOW); // switches ledPin off
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
}</pre>

== Used Hardware ==
&emsp;➠ [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

&emsp;➠ [[ARDUINO Wireless Proto Shield]]

&emsp;➠ [[Arduino MKR WAN 1300 LoRa]]

&emsp;➠ [[Arduino MKR LoRa Gateway Pro]]

== References ==
&emsp;➠ https://www.elektronik-kompendium.de/sites/com/1810231.htm

&emsp;➠ http://myhomearchiv.synology.me/download/Anleitung_Furduino.pdf

&emsp;➠ https://starthardware.org/arduino-uno/

&emsp;➠ https://starthardware.org/category/projekte/arduino-projekte/

&emsp;➠ http://www.netzmafia.de/skripten/hardware/Arduino/Arduino_Programmierhandbuch.pdf

[[Category:Documentation]]

Arduino Board Uno Rev3-Atmega 328: Programming Guide

2020-08-10T20:56:51Z

CCinay: /* Serial.begin(rate) */

Arduino Board Uno Rev3-Atmega 328: Programming Guide

2020-08-10T20:56:24Z

CCinay: /* Serial communication */

<div style="max-width: 970px">

== Summary ==
The <b>Arduino IDE</b> is a cross-platform Java application that acts as a program code editor and compiler and is also able to send firmware serially to the board. The development environment is based on Processing, an IDE designed to program artists, who normally do not have much contact with the art world programming environments. The programming language is based on Wiring, a C similar language which has a similar scope for a more restricted board design, whose IDE is also based on processing. Make sure you have an updated version of <b>[https://www.arduino.cc/en/Main/Software Arduino IDE]</b> installed.

== Struktur ==
The basic structure of the Arduino programming language is relatively simple and is divided into at least two parts. These two required parts or functions enclose blocks of statements.

<pre>void setup() { // put your setup code here, to run once:
}
void loop() { // put your main code here, to run repeatedly:
}</pre>

&emsp;➥ Here <b>setup()</b> is the preparation and <b>loop()</b> is the execution. Both functions are necessary to execute the program.

&emsp;➥ The setup function should follow the variable definition, which must be listed before. Setup must be run through as the first function in a program. <br>&emsp;&emsp; It is executed only once and is used to set <b>PinMode</b> or to initiate serial communication.

&emsp;➥ The <b>setup()</b> function is called once when the program starts. Use this function to set PinModes or start serial communication. The <b>setup()</b> function must <br>&emsp;&emsp; appear in every program, even if it does not contain any instructions.

&emsp;➥ After the <b>setup()</b> function follows the <b>loop()</b> function. It contains program code that is executed continuously in an infinite loop - read inputs, trigger <br>&emsp;&emsp; outputs, etc. This function is the core of all Arduino programs and does the main work.

=== setup() ===
The <b>setup()</b> function is called once when the program starts. Use this function to set <b>PinModes</b> or start serial communication.
The <b>setup()</b> function must appear in every program, even if it does not contain any instructions.

<pre>void setup()
{
pinMode(pin, OUTPUT); // 'pin' define as output
}</pre>

=== loop() ===
After running through the <b>setup() function</b>, the <b>loop() function</b> does exactly what its name suggests and runs in an endless loop. This allows the program to interact with the Arduino board via changes, reactions and controls.
<pre>void loop()
{
digitalWrite(pin, HIGH); // switches 'pin' on
delay(1000); // Pause for one second
digitalWrite(pin, LOW); // switches 'pin' off
delay(1000); // Pause for one second
}</pre>

=== Functions ===
A function is a block of program code that has a name and a set of instructions that are executed when the function is called. The functions <b>void setup()</b> and <b>void loop()</b> have already been explained. There are more built-in functions that will be discussed later.

<pre>Type FunctionName(parameter)
{
instructions;
}</pre>

The following integer type function <b>delayVal()</b> is used to insert a delay value into a program by reading a potentiometer. First a local variable <b>'v'</b> is created. Next, <b>'v'</b> is equated with the position of the potentiometer, which can have a value between <b>0 and 1023</b>. The value is then <b>divided by 4 to get a scale from 0 to 255</b> and at the end the result of the function is returned to the main program.

<pre>int delayVal()
{
int v; // create temporary variable 'v
v = analogRead(pot); // read potentiometer Value
v /= 4; // Convert from 0-1023 to 0-255
return v; // return the calculated value
}</pre>

=== {} curly brackets ===
Curly brackets (also called <b>'curly brackets'</b>) define the start and end of function and statement blocks as in the <b>'void loop()'</b> function and also in the <b>'for' and 'if'</b> statement.

<pre>type function()
{
instructions;
}</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: An opening curved bracket '{' must always be followed by a closing curved bracket '}'. Here it is often said that the number of brackets must be balanced. Unbalanced parentheses often lead to cryptic, inscrutable errors in the compiler, which are sometimes hard to find, especially in large programs.

The Arduino programming environment helps to check that the curved brackets are balanced. To do this, simply select a brace or click just behind it, and the logically connected counterpart is highlighted. </div>

=== ;semicolon ===
A semicolon must be used at the end of a statement and is used to separate the elements of a program.
A semicolon is also used to separate the elements of a for loop.

<pre>int x = 13; // declares variable 'x' as integer with value 13</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Forgetting a semicolon at the end of a line leads to an error in the compiler. The error description can be very clear and directly point to the missing semicolon, but this does not have to be the case. If an inscrutable or apparently illogical error is reported, the first thing to do is to add missing semicolons near the reported error. </div>

=== /*... */ block comments ===
Block comments or multiline comments are text areas that are ignored by the program. They are used for longer descriptions or comments and help other authors to understand program parts. They start with /* and end with */ and can cover several lines.

<pre>/* This is an inserted block comment
please do not forget the closing comment -
These must be balanced
*/</pre>

=== // Single line comments ===
Simple single-line comments are defined with a // at the beginning of the line and end with the end of the line. They are ignored by the program and do not consume memory.
<pre>// this is a single line comment</pre>

== Variables ==
A variable is the name of a numeric value with a name and memory location for later use in a program. A variable must be declared and optionally provided with a value. The following example declares a variable 'inputVariable' and assigns the value of analog pin 2 to it:
<pre>int inputVariable = 0; // declares a variable and
// sets its value to 0
inputVariable = analogRead(2); // sets the value of the variable equal
// with the value of analog pin 2 </pre>

'inputVariable' is the variable itself. The first line explains that its data type is 'int', which is the short expression for integer. The second line gives the variable the value of the analog pin 2, making the value of the pin available everywhere in the code.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Variables should always have descriptive names as clearly as possible to make the code easier to read.</div>

=== Declaration of variables: ===
All variables must be declared before use. Declaring a variable means defining its type such as int, long, float, etc., giving it a name and optionally an initial value.This only needs to be done once in the program. Afterwards the value can be changed at any time by calculations or various assignments.

The following example declares 'inputVariable' as 'int', i.e. integer data type and sets the initial value to 0. This is called a 'simple assignment'.
<pre>int inputVariable = 0;</pre>

A variable can be declared at many places in the program. The location of the declaration determines which program parts have access to the variable.

== Data types ==
&emsp;➥ <b>byte</b>: Byte stores an <b>8-bit numeric</b>, integer value without decimal point. The <b>value</b> can be between <b>0 and 255</b>.
<pre>byte someVariable = 180; // declares 'someVariable as a 'byte' data type </pre>

&emsp;➥ <b>int</b>: Integers are the most common data type for storing integer values without decimal point. Its <b>value</b> is <b>16 bits and ranges from -32,767 to 32,768</b>.
<pre>int someVariable = 1500; // declares 'someVariable as an 'integer' data type</pre>

&emsp;➥ <b>long</b>: Data type for long integers with extended size, without decimal point, <b>stored in a 32-bit</b> value in a spectrum from <br>&emsp;&emsp;<b>-2,147,483,648 to 2,147,483,647</b>
<pre>long someVariable = 90000; // declares 'someVariable as a 'long' data type </pre>

&emsp;➥ <b>float</b>: A data type for floating point values or numbers with decimal places. Floating point numbers have a better resolution than integers and are<br>&emsp;&emsp; expressed as <b>32-bit values with a spectrum from -3.4028235E+38 to 3.4028235E+38</b>.
<pre>float someVariable = 3.14; // declares 'someVariable' as a 'float' data type </pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Floating point numbers are not precise and may lead to strange results when compared. Also, floating-point calculations are much slower than with integer data types. Calculations with floating-point values should be avoided if possible. </div>

&emsp;➥ <b>arrays</b>: An array is a collection of values that are accessed with an index number.
Each value in the array can be accessed by retrieving the name of<br>&emsp;&emsp; the array and the index number of the value. The index number always starts at 0 for an array.<br>&emsp;&emsp; An array must be declared and optionally assigned values before it can be used.
<pre>int myArray[] = {value0, value1, value2...} </pre>

In the same way it is possible to declare an array first with datatype and size and later to give a value to an index position.
<pre>int myArray[5]; // declare datatype 'integer' as array with 5 Positions
myArray[3] = 10; // gives the 4th index the value 10 </pre>

To read the value of an array you can simply assign it to a variable specifying the array and the index position.
<pre>x = myArray[3]; // x now has the value 10 </pre>

Arrays are often used for loops, where the counter of the loop is also used as index position for the values in the array. The following example uses an array to make an LED flicker. With a for loop and a counter starting at 0 an index position in the array is read, sent to the LED pin, paused for 200ms and then the same is done with the next index position.
<pre>int ledPin = 10; // LED on pin 10
byte flicker[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array with 8 different values
void setup()
{
pinMode(ledPin, OUTPUT); // Sets the OUTPUT pin
}

void loop()
{
for(int i=0; i<7; i++) // loop equals the number
{ // of the values in the array
analogWrite(ledPin, flicker[i]); // writes the index value to the LED
delay(200); // 200ms pause
}
}</pre>

== Digitaler Input - Output ==
=== pinMode(pin,mode) ===
Used in 'void setup()' to configure a specific pin as either input or output.
<pre>pinMode(pin, OUTPUT); // sets 'pin' as output </pre>

Arduino digital pins are inputs by default, so they don't need to be specified as inputs with 'pinMode()'. Pins configured as inputs have a high impedance state.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: There are also comfortable 20 k 'pullup' resistors in the ATmega chip which are accessible via software.</div>

These built-in 'pullup' resistors can be accessed in the following way:
<pre>pinMode(pin, INPUT); // sets 'pin' as input
digitalWrite(pin, HIGH); // switches on the 'Pullup' resistor</pre>

&emsp;➥ Pullup resistors are normally used to connect inputs like switches. In the example shown here it is noticeable that the pin is not defined as an output<br>&emsp;&emsp; although it is written to. It is only the method to activate the internal 'pullup' resistor.

&emsp;➥ Pins configured as output are in a low impedance state and can be loaded with a maximum of 40 mAmpere current from connected elements<br>&emsp;&emsp; and circuits. This is enough to make an LED light up (don't forget the serial resistor), but not enough to drive most relays, solenoids or motors.

&emsp;➥ Short circuits at the Arduino pins as well as too high current can destroy the output pin or even the whole ATmega chip. For this reason it is a good idea<br>&emsp;&emsp; to connect an output pin with external elements in series with a 470 or 1K resistor to
switch.

=== digitalRead(pin) ===
digitalRead(pin)' reads the value from a specified digital pin, with the result either HIGH or LOW. The pin can be set either as a variable or constant (0-13).
<pre>value = digitalRead(Pin); // sets 'value' equal to the input pin </pre>

digitalWrite(pin,value)
Outputs either logic level HIGH or LOW at a specified pin. The pin can be set as a variable or constant (0-13).
<pre>digitalWrite(pin, HIGH); // sets 'pin' to high</pre>

The following example reads a button on a digital input and switches an LED on when the button is pressed:
<pre>int led = 13; // LED connected to pin 13
int pin = 7; // Button connected to pin 7
int value = 0; // Variable to store the readout value

void setup()
{
pinMode(led, OUTPUT); // defines pin 13 as output
pinMode(pin, INPUT); // sets pin 7 as input
}

void loop()
{
value = digitalRead(pin); // sets 'value' equal to
// the input pin
digitalWrite(led, value); // sets 'led' equal to the
} // Value of the button</pre>

== Analoger Input - Output ==
=== analogRead(pin) ===
Reads the value of a specified analog pin with a 10 bit resolution. This function is only available for pins (0-5). The resulting integer values have a spectrum from 0 to 1023.
<pre>value = analogRead(pin); // sets 'value' equal to 'pin</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Unlike digital pins, analog pins do not have to be declared as input or output first. </div>

=== analogWrite(pin, value) ===
Writes pseudo-analog values to an output pin using hardware-based pulse width modulation (PWM). On newer Arduino boards with the ATmega 168 chip this function is applicable to pins 3, 5, 6, 9, 10 and 11. Older Arduinos with the ATmega8 only support pins 9,10 and 11. The value can be set as a variable or constant in the range 0-255.
<pre>analogWrite(pin, value); // writes 'value' to the analog 'pin </pre>

A value of 0 generates a uniform voltage of 0 volts at a fixed pin; a value of 255 generates a uniform voltage of 5 volts at a fixed pin. For values between 0 and 255, the pin changes very quickly between 0 and 5 volts - the higher the value, the longer the pin is HIGH (5 volts). For a value of 64, the pin is at 0 volts for three-quarters of the time and at 5 volts for one-quarter of the time. A value of 128 means that the output voltage is HIGH half of the time and LOW the other half. A value of 192 means that the voltage at the pin measures 0 volts at one quarter of the time and the full 5 volts at three quarters of the time.

Because this is a hardware-based function, the constant wave runs independently of the program until the next change of state via analogWrite (or a call to digitalRead or digitalWrite on the same pin).

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: In contrast to digital pins, analog pins do not have to be declared as input or output before. </div>

&emsp;➥ The following example reads an analog value from 'pin', converts the value by dividing it by 4 and then outputs it as a PWM signal to 'led'.

<pre>int led = 10; // LED with 220 resistor at pin 10
int pin = 0; // Potentiometer at analog pin 0
int value; // Value for readout

void setup(){} // no setup required

void loop()
{
value = analogRead(pin); // sets 'value' equal to 'pin
value /= 4; // converts 0-1023 into 0-255
analogWrite(led, value); // outputs the PWM signal 'led
}</pre>

== Random functions ==
=== randomSeed(seed) ===
Sets a value or 'Seed' as starting point for the random() function.
<pre>randomSeed(value); // sets 'value' as the random seed</pre>

The Arduino itself is not able to produce a truly random value. With randomSeed() a variable can be used as 'seed' to get better random results. For example, millis() or analogRead() can be used as a seed variable or function to use electrical noise through the analog pin as an output for random values.

=== random(min, max) ===
The random function allows the generation of pseudo-random values within a defined range of minimum and maxium values.
<pre>value = random(100, 200); // sets 'value' with a random number between 100 and 200 equal </pre>

The following example generates a random value between 0 and 255 and outputs it as PWM signal on a PWM pin.
<pre>int randNumber; // Variable to store the random value
int led = 10; // LED with 220 Ohm resistor at pin 10

void setup() {} // no setup necessary

void loop()
{
randomSeed(millis()); // uses millis() as seed
randNumber = random(255); // Random number in the range 0-255
analogWrite(led, randNumber); // PWM signal as output
delay(500); // half second pause
}</pre>

== Serial communication ==
=== Serial.begin(rate) ===
Serial.begin(rate)' Opens the serial port and sets the baud rate for the serial transmission. The typical baud rate with the computer is 9600 baud. Other speeds are also supported.
<pre>void setup()
{
Serial.begin(9600); // opens serial port sets the data rate to 9600 bps
}</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: When using serial communication, digital pins 0 (RX) and 1 (TX) cannot be used at the same time. </div>

=== Serial.println(data) ===
Writes data to the serial port, followed by an automatic line break as carrier return and line feed. This function has the same form as 'Serial.print()', but is easier to read on the serial monitor.
<pre>Serial.println(analogValue); // sends the value of 'analogValue'</pre>

More detailed information about the numerous variants of the 'Serial.println()' and 'Serial.print()' functions can be found on the Arduino website.

The following simple example reads a value from analog pin 0 and sends the data to the computer once per second.
<pre>void setup()
{
Serial.begin(9600); // sets the data rate to 9600 bps
}

void loop()
{
Serial.println(analogRead(0)); // sends the analog value
delay(1000); // pauses for 1 second
}</pre>

== Examples ==
=== Digital output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Output.JPG|thumb|none|300px|Arduino-Example-Digital-Output]] </li>
</ul></div>

This is a simple 'Hello World' program and turns something on and off. In this example a LED is connected to PIN 13 and flashes every second. The resistor may be superfluous at this pin because the Arduino has a built-in resistor.
<pre>int ledPin = 13; // LED off digital pin 13

void setup() // will run through once
{
pinMode(ledPin, OUTPUT); // sets pin 13 as output
}

void loop() // Running as endless loop
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}</pre>

=== Digital input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Input.JPG|thumb|none|300px|Arduino-Example-Digital-Input]] </li>
</ul></div>

This is the simplest form of an input with only two possible states: on or off.
This example reads out a simple switch or button at pin 2. When the switch is closed and the input pin is HIGH, the LED is turned on.
<pre>int ledPin = 13; // Output pin for the LED
int inPin = 2; // Input pin for a switch

void setup()
{
pinMode(ledPin, OUTPUT); // declares LED as output
pinMode(inPin, INPUT); // declares switch as input
}
void loop()
if (digitalRead(inPin) == HIGH) // check if this is the HIGH input
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}
}</pre>

=== analog PWM output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

Pulse width modulation (PWM) is a method of simulating analog outputs by pulsing the output voltage. This allows you to make an LED brighter or darker or check a servomotor later. The following example uses a loop to slowly make an LED brighter and darker.

<pre>int ledPin = 9; // PWM Pin for the LED

void setup(){} // No setup necessary

void loop()
{
for (int i=0; i<=255; i++) // ascending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}

for (int i=255; i>=0; i--) // descending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}
}</pre>

=== potentiometer Input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

With a potentiometer and one of the analog-digital converter (ADC) inputs of the Arduino it is possible to read analog values from 0-1024. The following example uses a potentiometer to control the blinking rate of an LED.

<pre>int potPin = 0; // Input pin for the potentiometer
int ledPin = 13; // Output pin for the LED

void setup()
{
pinMode(ledPin, OUTPUT); // declare ledPin as OUTPUT
}

void loop()
{
digitalWrite(ledPin, HIGH); // switches on ledPin
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
digitalWrite(ledPin, LOW); // switches ledPin off
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
}</pre>

== Used Hardware ==
&emsp;➠ [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

&emsp;➠ [[ARDUINO Wireless Proto Shield]]

&emsp;➠ [[Arduino MKR WAN 1300 LoRa]]

&emsp;➠ [[Arduino MKR LoRa Gateway Pro]]

== References ==
&emsp;➠ https://www.elektronik-kompendium.de/sites/com/1810231.htm

&emsp;➠ http://myhomearchiv.synology.me/download/Anleitung_Furduino.pdf

&emsp;➠ https://starthardware.org/arduino-uno/

&emsp;➠ https://starthardware.org/category/projekte/arduino-projekte/

&emsp;➠ http://www.netzmafia.de/skripten/hardware/Arduino/Arduino_Programmierhandbuch.pdf

[[Category:Documentation]]

Arduino Board Uno Rev3-Atmega 328: Programming Guide

2020-08-10T20:54:39Z

CCinay: /* Random functions */

<div style="max-width: 970px">

== Summary ==
The <b>Arduino IDE</b> is a cross-platform Java application that acts as a program code editor and compiler and is also able to send firmware serially to the board. The development environment is based on Processing, an IDE designed to program artists, who normally do not have much contact with the art world programming environments. The programming language is based on Wiring, a C similar language which has a similar scope for a more restricted board design, whose IDE is also based on processing. Make sure you have an updated version of <b>[https://www.arduino.cc/en/Main/Software Arduino IDE]</b> installed.

== Struktur ==
The basic structure of the Arduino programming language is relatively simple and is divided into at least two parts. These two required parts or functions enclose blocks of statements.

<pre>void setup() { // put your setup code here, to run once:
}
void loop() { // put your main code here, to run repeatedly:
}</pre>

&emsp;➥ Here <b>setup()</b> is the preparation and <b>loop()</b> is the execution. Both functions are necessary to execute the program.

&emsp;➥ The setup function should follow the variable definition, which must be listed before. Setup must be run through as the first function in a program. <br>&emsp;&emsp; It is executed only once and is used to set <b>PinMode</b> or to initiate serial communication.

&emsp;➥ The <b>setup()</b> function is called once when the program starts. Use this function to set PinModes or start serial communication. The <b>setup()</b> function must <br>&emsp;&emsp; appear in every program, even if it does not contain any instructions.

&emsp;➥ After the <b>setup()</b> function follows the <b>loop()</b> function. It contains program code that is executed continuously in an infinite loop - read inputs, trigger <br>&emsp;&emsp; outputs, etc. This function is the core of all Arduino programs and does the main work.

=== setup() ===
The <b>setup()</b> function is called once when the program starts. Use this function to set <b>PinModes</b> or start serial communication.
The <b>setup()</b> function must appear in every program, even if it does not contain any instructions.

<pre>void setup()
{
pinMode(pin, OUTPUT); // 'pin' define as output
}</pre>

=== loop() ===
After running through the <b>setup() function</b>, the <b>loop() function</b> does exactly what its name suggests and runs in an endless loop. This allows the program to interact with the Arduino board via changes, reactions and controls.
<pre>void loop()
{
digitalWrite(pin, HIGH); // switches 'pin' on
delay(1000); // Pause for one second
digitalWrite(pin, LOW); // switches 'pin' off
delay(1000); // Pause for one second
}</pre>

=== Functions ===
A function is a block of program code that has a name and a set of instructions that are executed when the function is called. The functions <b>void setup()</b> and <b>void loop()</b> have already been explained. There are more built-in functions that will be discussed later.

<pre>Type FunctionName(parameter)
{
instructions;
}</pre>

The following integer type function <b>delayVal()</b> is used to insert a delay value into a program by reading a potentiometer. First a local variable <b>'v'</b> is created. Next, <b>'v'</b> is equated with the position of the potentiometer, which can have a value between <b>0 and 1023</b>. The value is then <b>divided by 4 to get a scale from 0 to 255</b> and at the end the result of the function is returned to the main program.

<pre>int delayVal()
{
int v; // create temporary variable 'v
v = analogRead(pot); // read potentiometer Value
v /= 4; // Convert from 0-1023 to 0-255
return v; // return the calculated value
}</pre>

=== {} curly brackets ===
Curly brackets (also called <b>'curly brackets'</b>) define the start and end of function and statement blocks as in the <b>'void loop()'</b> function and also in the <b>'for' and 'if'</b> statement.

<pre>type function()
{
instructions;
}</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: An opening curved bracket '{' must always be followed by a closing curved bracket '}'. Here it is often said that the number of brackets must be balanced. Unbalanced parentheses often lead to cryptic, inscrutable errors in the compiler, which are sometimes hard to find, especially in large programs.

The Arduino programming environment helps to check that the curved brackets are balanced. To do this, simply select a brace or click just behind it, and the logically connected counterpart is highlighted. </div>

=== ;semicolon ===
A semicolon must be used at the end of a statement and is used to separate the elements of a program.
A semicolon is also used to separate the elements of a for loop.

<pre>int x = 13; // declares variable 'x' as integer with value 13</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Forgetting a semicolon at the end of a line leads to an error in the compiler. The error description can be very clear and directly point to the missing semicolon, but this does not have to be the case. If an inscrutable or apparently illogical error is reported, the first thing to do is to add missing semicolons near the reported error. </div>

=== /*... */ block comments ===
Block comments or multiline comments are text areas that are ignored by the program. They are used for longer descriptions or comments and help other authors to understand program parts. They start with /* and end with */ and can cover several lines.

<pre>/* This is an inserted block comment
please do not forget the closing comment -
These must be balanced
*/</pre>

=== // Single line comments ===
Simple single-line comments are defined with a // at the beginning of the line and end with the end of the line. They are ignored by the program and do not consume memory.
<pre>// this is a single line comment</pre>

== Variables ==
A variable is the name of a numeric value with a name and memory location for later use in a program. A variable must be declared and optionally provided with a value. The following example declares a variable 'inputVariable' and assigns the value of analog pin 2 to it:
<pre>int inputVariable = 0; // declares a variable and
// sets its value to 0
inputVariable = analogRead(2); // sets the value of the variable equal
// with the value of analog pin 2 </pre>

'inputVariable' is the variable itself. The first line explains that its data type is 'int', which is the short expression for integer. The second line gives the variable the value of the analog pin 2, making the value of the pin available everywhere in the code.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Variables should always have descriptive names as clearly as possible to make the code easier to read.</div>

=== Declaration of variables: ===
All variables must be declared before use. Declaring a variable means defining its type such as int, long, float, etc., giving it a name and optionally an initial value.This only needs to be done once in the program. Afterwards the value can be changed at any time by calculations or various assignments.

The following example declares 'inputVariable' as 'int', i.e. integer data type and sets the initial value to 0. This is called a 'simple assignment'.
<pre>int inputVariable = 0;</pre>

A variable can be declared at many places in the program. The location of the declaration determines which program parts have access to the variable.

== Data types ==
&emsp;➥ <b>byte</b>: Byte stores an <b>8-bit numeric</b>, integer value without decimal point. The <b>value</b> can be between <b>0 and 255</b>.
<pre>byte someVariable = 180; // declares 'someVariable as a 'byte' data type </pre>

&emsp;➥ <b>int</b>: Integers are the most common data type for storing integer values without decimal point. Its <b>value</b> is <b>16 bits and ranges from -32,767 to 32,768</b>.
<pre>int someVariable = 1500; // declares 'someVariable as an 'integer' data type</pre>

&emsp;➥ <b>long</b>: Data type for long integers with extended size, without decimal point, <b>stored in a 32-bit</b> value in a spectrum from <br>&emsp;&emsp;<b>-2,147,483,648 to 2,147,483,647</b>
<pre>long someVariable = 90000; // declares 'someVariable as a 'long' data type </pre>

&emsp;➥ <b>float</b>: A data type for floating point values or numbers with decimal places. Floating point numbers have a better resolution than integers and are<br>&emsp;&emsp; expressed as <b>32-bit values with a spectrum from -3.4028235E+38 to 3.4028235E+38</b>.
<pre>float someVariable = 3.14; // declares 'someVariable' as a 'float' data type </pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Floating point numbers are not precise and may lead to strange results when compared. Also, floating-point calculations are much slower than with integer data types. Calculations with floating-point values should be avoided if possible. </div>

&emsp;➥ <b>arrays</b>: An array is a collection of values that are accessed with an index number.
Each value in the array can be accessed by retrieving the name of<br>&emsp;&emsp; the array and the index number of the value. The index number always starts at 0 for an array.<br>&emsp;&emsp; An array must be declared and optionally assigned values before it can be used.
<pre>int myArray[] = {value0, value1, value2...} </pre>

In the same way it is possible to declare an array first with datatype and size and later to give a value to an index position.
<pre>int myArray[5]; // declare datatype 'integer' as array with 5 Positions
myArray[3] = 10; // gives the 4th index the value 10 </pre>

To read the value of an array you can simply assign it to a variable specifying the array and the index position.
<pre>x = myArray[3]; // x now has the value 10 </pre>

Arrays are often used for loops, where the counter of the loop is also used as index position for the values in the array. The following example uses an array to make an LED flicker. With a for loop and a counter starting at 0 an index position in the array is read, sent to the LED pin, paused for 200ms and then the same is done with the next index position.
<pre>int ledPin = 10; // LED on pin 10
byte flicker[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array with 8 different values
void setup()
{
pinMode(ledPin, OUTPUT); // Sets the OUTPUT pin
}

void loop()
{
for(int i=0; i<7; i++) // loop equals the number
{ // of the values in the array
analogWrite(ledPin, flicker[i]); // writes the index value to the LED
delay(200); // 200ms pause
}
}</pre>

== Digitaler Input - Output ==
=== pinMode(pin,mode) ===
Used in 'void setup()' to configure a specific pin as either input or output.
<pre>pinMode(pin, OUTPUT); // sets 'pin' as output </pre>

Arduino digital pins are inputs by default, so they don't need to be specified as inputs with 'pinMode()'. Pins configured as inputs have a high impedance state.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: There are also comfortable 20 k 'pullup' resistors in the ATmega chip which are accessible via software.</div>

These built-in 'pullup' resistors can be accessed in the following way:
<pre>pinMode(pin, INPUT); // sets 'pin' as input
digitalWrite(pin, HIGH); // switches on the 'Pullup' resistor</pre>

&emsp;➥ Pullup resistors are normally used to connect inputs like switches. In the example shown here it is noticeable that the pin is not defined as an output<br>&emsp;&emsp; although it is written to. It is only the method to activate the internal 'pullup' resistor.

&emsp;➥ Pins configured as output are in a low impedance state and can be loaded with a maximum of 40 mAmpere current from connected elements<br>&emsp;&emsp; and circuits. This is enough to make an LED light up (don't forget the serial resistor), but not enough to drive most relays, solenoids or motors.

&emsp;➥ Short circuits at the Arduino pins as well as too high current can destroy the output pin or even the whole ATmega chip. For this reason it is a good idea<br>&emsp;&emsp; to connect an output pin with external elements in series with a 470 or 1K resistor to
switch.

=== digitalRead(pin) ===
digitalRead(pin)' reads the value from a specified digital pin, with the result either HIGH or LOW. The pin can be set either as a variable or constant (0-13).
<pre>value = digitalRead(Pin); // sets 'value' equal to the input pin </pre>

digitalWrite(pin,value)
Outputs either logic level HIGH or LOW at a specified pin. The pin can be set as a variable or constant (0-13).
<pre>digitalWrite(pin, HIGH); // sets 'pin' to high</pre>

The following example reads a button on a digital input and switches an LED on when the button is pressed:
<pre>int led = 13; // LED connected to pin 13
int pin = 7; // Button connected to pin 7
int value = 0; // Variable to store the readout value

void setup()
{
pinMode(led, OUTPUT); // defines pin 13 as output
pinMode(pin, INPUT); // sets pin 7 as input
}

void loop()
{
value = digitalRead(pin); // sets 'value' equal to
// the input pin
digitalWrite(led, value); // sets 'led' equal to the
} // Value of the button</pre>

== Analoger Input - Output ==
=== analogRead(pin) ===
Reads the value of a specified analog pin with a 10 bit resolution. This function is only available for pins (0-5). The resulting integer values have a spectrum from 0 to 1023.
<pre>value = analogRead(pin); // sets 'value' equal to 'pin</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Unlike digital pins, analog pins do not have to be declared as input or output first. </div>

=== analogWrite(pin, value) ===
Writes pseudo-analog values to an output pin using hardware-based pulse width modulation (PWM). On newer Arduino boards with the ATmega 168 chip this function is applicable to pins 3, 5, 6, 9, 10 and 11. Older Arduinos with the ATmega8 only support pins 9,10 and 11. The value can be set as a variable or constant in the range 0-255.
<pre>analogWrite(pin, value); // writes 'value' to the analog 'pin </pre>

A value of 0 generates a uniform voltage of 0 volts at a fixed pin; a value of 255 generates a uniform voltage of 5 volts at a fixed pin. For values between 0 and 255, the pin changes very quickly between 0 and 5 volts - the higher the value, the longer the pin is HIGH (5 volts). For a value of 64, the pin is at 0 volts for three-quarters of the time and at 5 volts for one-quarter of the time. A value of 128 means that the output voltage is HIGH half of the time and LOW the other half. A value of 192 means that the voltage at the pin measures 0 volts at one quarter of the time and the full 5 volts at three quarters of the time.

Because this is a hardware-based function, the constant wave runs independently of the program until the next change of state via analogWrite (or a call to digitalRead or digitalWrite on the same pin).

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: In contrast to digital pins, analog pins do not have to be declared as input or output before. </div>

&emsp;➥ The following example reads an analog value from 'pin', converts the value by dividing it by 4 and then outputs it as a PWM signal to 'led'.

<pre>int led = 10; // LED with 220 resistor at pin 10
int pin = 0; // Potentiometer at analog pin 0
int value; // Value for readout

void setup(){} // no setup required

void loop()
{
value = analogRead(pin); // sets 'value' equal to 'pin
value /= 4; // converts 0-1023 into 0-255
analogWrite(led, value); // outputs the PWM signal 'led
}</pre>

== Random functions ==
=== randomSeed(seed) ===
Sets a value or 'Seed' as starting point for the random() function.
<pre>randomSeed(value); // sets 'value' as the random seed</pre>

The Arduino itself is not able to produce a truly random value. With randomSeed() a variable can be used as 'seed' to get better random results. For example, millis() or analogRead() can be used as a seed variable or function to use electrical noise through the analog pin as an output for random values.

=== random(min, max) ===
The random function allows the generation of pseudo-random values within a defined range of minimum and maxium values.
<pre>value = random(100, 200); // sets 'value' with a random number between 100 and 200 equal </pre>

The following example generates a random value between 0 and 255 and outputs it as PWM signal on a PWM pin.
<pre>int randNumber; // Variable to store the random value
int led = 10; // LED with 220 Ohm resistor at pin 10

void setup() {} // no setup necessary

void loop()
{
randomSeed(millis()); // uses millis() as seed
randNumber = random(255); // Random number in the range 0-255
analogWrite(led, randNumber); // PWM signal as output
delay(500); // half second pause
}</pre>

== Serial communication ==
=== Serial.begin(rate) ===
Serial.begin(rate)' Opens the serial port and sets the baud rate for the serial transmission. The typical baud rate with the computer is 9600 baud. Other speeds are also supported.
<pre>void setup()
{
Serial.begin(9600); // opens serial port
} // sets the data rate to 9600 bps</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: When using serial communication, digital pins 0 (RX) and 1 (TX) cannot be used at the same time. </div>

=== Serial.println(data) ===
Writes data to the serial port, followed by an automatic line break as carrier return and line feed. This function has the same form as 'Serial.print()', but is easier to read on the serial monitor.
<pre>Serial.println(analogValue); // sends the value of 'analogValue'</pre>

More detailed information about the numerous variants of the 'Serial.println()' and 'Serial.print()' functions can be found on the Arduino website.

The following simple example reads a value from analog pin 0 and sends the data to the computer once per second.
<pre>void setup()
{
Serial.begin(9600); // sets the data rate to 9600 bps
}

void loop()
{
Serial.println(analogRead(0)); // sends the analog value
delay(1000); // pauses for 1 second
}</pre>

== Examples ==
=== Digital output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Output.JPG|thumb|none|300px|Arduino-Example-Digital-Output]] </li>
</ul></div>

This is a simple 'Hello World' program and turns something on and off. In this example a LED is connected to PIN 13 and flashes every second. The resistor may be superfluous at this pin because the Arduino has a built-in resistor.
<pre>int ledPin = 13; // LED off digital pin 13

void setup() // will run through once
{
pinMode(ledPin, OUTPUT); // sets pin 13 as output
}

void loop() // Running as endless loop
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}</pre>

=== Digital input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Input.JPG|thumb|none|300px|Arduino-Example-Digital-Input]] </li>
</ul></div>

This is the simplest form of an input with only two possible states: on or off.
This example reads out a simple switch or button at pin 2. When the switch is closed and the input pin is HIGH, the LED is turned on.
<pre>int ledPin = 13; // Output pin for the LED
int inPin = 2; // Input pin for a switch

void setup()
{
pinMode(ledPin, OUTPUT); // declares LED as output
pinMode(inPin, INPUT); // declares switch as input
}
void loop()
if (digitalRead(inPin) == HIGH) // check if this is the HIGH input
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}
}</pre>

=== analog PWM output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

Pulse width modulation (PWM) is a method of simulating analog outputs by pulsing the output voltage. This allows you to make an LED brighter or darker or check a servomotor later. The following example uses a loop to slowly make an LED brighter and darker.

<pre>int ledPin = 9; // PWM Pin for the LED

void setup(){} // No setup necessary

void loop()
{
for (int i=0; i<=255; i++) // ascending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}

for (int i=255; i>=0; i--) // descending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}
}</pre>

=== potentiometer Input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

With a potentiometer and one of the analog-digital converter (ADC) inputs of the Arduino it is possible to read analog values from 0-1024. The following example uses a potentiometer to control the blinking rate of an LED.

<pre>int potPin = 0; // Input pin for the potentiometer
int ledPin = 13; // Output pin for the LED

void setup()
{
pinMode(ledPin, OUTPUT); // declare ledPin as OUTPUT
}

void loop()
{
digitalWrite(ledPin, HIGH); // switches on ledPin
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
digitalWrite(ledPin, LOW); // switches ledPin off
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
}</pre>

== Used Hardware ==
&emsp;➠ [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

&emsp;➠ [[ARDUINO Wireless Proto Shield]]

&emsp;➠ [[Arduino MKR WAN 1300 LoRa]]

&emsp;➠ [[Arduino MKR LoRa Gateway Pro]]

== References ==
&emsp;➠ https://www.elektronik-kompendium.de/sites/com/1810231.htm

&emsp;➠ http://myhomearchiv.synology.me/download/Anleitung_Furduino.pdf

&emsp;➠ https://starthardware.org/arduino-uno/

&emsp;➠ https://starthardware.org/category/projekte/arduino-projekte/

&emsp;➠ http://www.netzmafia.de/skripten/hardware/Arduino/Arduino_Programmierhandbuch.pdf

[[Category:Documentation]]

Arduino Board Uno Rev3-Atmega 328: Programming Guide

2020-08-10T20:52:32Z

CCinay: /* Data types */

<div style="max-width: 970px">

== Summary ==
The <b>Arduino IDE</b> is a cross-platform Java application that acts as a program code editor and compiler and is also able to send firmware serially to the board. The development environment is based on Processing, an IDE designed to program artists, who normally do not have much contact with the art world programming environments. The programming language is based on Wiring, a C similar language which has a similar scope for a more restricted board design, whose IDE is also based on processing. Make sure you have an updated version of <b>[https://www.arduino.cc/en/Main/Software Arduino IDE]</b> installed.

== Struktur ==
The basic structure of the Arduino programming language is relatively simple and is divided into at least two parts. These two required parts or functions enclose blocks of statements.

<pre>void setup() { // put your setup code here, to run once:
}
void loop() { // put your main code here, to run repeatedly:
}</pre>

&emsp;➥ Here <b>setup()</b> is the preparation and <b>loop()</b> is the execution. Both functions are necessary to execute the program.

&emsp;➥ The setup function should follow the variable definition, which must be listed before. Setup must be run through as the first function in a program. <br>&emsp;&emsp; It is executed only once and is used to set <b>PinMode</b> or to initiate serial communication.

&emsp;➥ The <b>setup()</b> function is called once when the program starts. Use this function to set PinModes or start serial communication. The <b>setup()</b> function must <br>&emsp;&emsp; appear in every program, even if it does not contain any instructions.

&emsp;➥ After the <b>setup()</b> function follows the <b>loop()</b> function. It contains program code that is executed continuously in an infinite loop - read inputs, trigger <br>&emsp;&emsp; outputs, etc. This function is the core of all Arduino programs and does the main work.

=== setup() ===
The <b>setup()</b> function is called once when the program starts. Use this function to set <b>PinModes</b> or start serial communication.
The <b>setup()</b> function must appear in every program, even if it does not contain any instructions.

<pre>void setup()
{
pinMode(pin, OUTPUT); // 'pin' define as output
}</pre>

=== loop() ===
After running through the <b>setup() function</b>, the <b>loop() function</b> does exactly what its name suggests and runs in an endless loop. This allows the program to interact with the Arduino board via changes, reactions and controls.
<pre>void loop()
{
digitalWrite(pin, HIGH); // switches 'pin' on
delay(1000); // Pause for one second
digitalWrite(pin, LOW); // switches 'pin' off
delay(1000); // Pause for one second
}</pre>

=== Functions ===
A function is a block of program code that has a name and a set of instructions that are executed when the function is called. The functions <b>void setup()</b> and <b>void loop()</b> have already been explained. There are more built-in functions that will be discussed later.

<pre>Type FunctionName(parameter)
{
instructions;
}</pre>

The following integer type function <b>delayVal()</b> is used to insert a delay value into a program by reading a potentiometer. First a local variable <b>'v'</b> is created. Next, <b>'v'</b> is equated with the position of the potentiometer, which can have a value between <b>0 and 1023</b>. The value is then <b>divided by 4 to get a scale from 0 to 255</b> and at the end the result of the function is returned to the main program.

<pre>int delayVal()
{
int v; // create temporary variable 'v
v = analogRead(pot); // read potentiometer Value
v /= 4; // Convert from 0-1023 to 0-255
return v; // return the calculated value
}</pre>

=== {} curly brackets ===
Curly brackets (also called <b>'curly brackets'</b>) define the start and end of function and statement blocks as in the <b>'void loop()'</b> function and also in the <b>'for' and 'if'</b> statement.

<pre>type function()
{
instructions;
}</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: An opening curved bracket '{' must always be followed by a closing curved bracket '}'. Here it is often said that the number of brackets must be balanced. Unbalanced parentheses often lead to cryptic, inscrutable errors in the compiler, which are sometimes hard to find, especially in large programs.

The Arduino programming environment helps to check that the curved brackets are balanced. To do this, simply select a brace or click just behind it, and the logically connected counterpart is highlighted. </div>

=== ;semicolon ===
A semicolon must be used at the end of a statement and is used to separate the elements of a program.
A semicolon is also used to separate the elements of a for loop.

<pre>int x = 13; // declares variable 'x' as integer with value 13</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Forgetting a semicolon at the end of a line leads to an error in the compiler. The error description can be very clear and directly point to the missing semicolon, but this does not have to be the case. If an inscrutable or apparently illogical error is reported, the first thing to do is to add missing semicolons near the reported error. </div>

=== /*... */ block comments ===
Block comments or multiline comments are text areas that are ignored by the program. They are used for longer descriptions or comments and help other authors to understand program parts. They start with /* and end with */ and can cover several lines.

<pre>/* This is an inserted block comment
please do not forget the closing comment -
These must be balanced
*/</pre>

=== // Single line comments ===
Simple single-line comments are defined with a // at the beginning of the line and end with the end of the line. They are ignored by the program and do not consume memory.
<pre>// this is a single line comment</pre>

== Variables ==
A variable is the name of a numeric value with a name and memory location for later use in a program. A variable must be declared and optionally provided with a value. The following example declares a variable 'inputVariable' and assigns the value of analog pin 2 to it:
<pre>int inputVariable = 0; // declares a variable and
// sets its value to 0
inputVariable = analogRead(2); // sets the value of the variable equal
// with the value of analog pin 2 </pre>

'inputVariable' is the variable itself. The first line explains that its data type is 'int', which is the short expression for integer. The second line gives the variable the value of the analog pin 2, making the value of the pin available everywhere in the code.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Variables should always have descriptive names as clearly as possible to make the code easier to read.</div>

=== Declaration of variables: ===
All variables must be declared before use. Declaring a variable means defining its type such as int, long, float, etc., giving it a name and optionally an initial value.This only needs to be done once in the program. Afterwards the value can be changed at any time by calculations or various assignments.

The following example declares 'inputVariable' as 'int', i.e. integer data type and sets the initial value to 0. This is called a 'simple assignment'.
<pre>int inputVariable = 0;</pre>

A variable can be declared at many places in the program. The location of the declaration determines which program parts have access to the variable.

== Data types ==
&emsp;➥ <b>byte</b>: Byte stores an <b>8-bit numeric</b>, integer value without decimal point. The <b>value</b> can be between <b>0 and 255</b>.
<pre>byte someVariable = 180; // declares 'someVariable as a 'byte' data type </pre>

&emsp;➥ <b>int</b>: Integers are the most common data type for storing integer values without decimal point. Its <b>value</b> is <b>16 bits and ranges from -32,767 to 32,768</b>.
<pre>int someVariable = 1500; // declares 'someVariable as an 'integer' data type</pre>

&emsp;➥ <b>long</b>: Data type for long integers with extended size, without decimal point, <b>stored in a 32-bit</b> value in a spectrum from <br>&emsp;&emsp;<b>-2,147,483,648 to 2,147,483,647</b>
<pre>long someVariable = 90000; // declares 'someVariable as a 'long' data type </pre>

&emsp;➥ <b>float</b>: A data type for floating point values or numbers with decimal places. Floating point numbers have a better resolution than integers and are<br>&emsp;&emsp; expressed as <b>32-bit values with a spectrum from -3.4028235E+38 to 3.4028235E+38</b>.
<pre>float someVariable = 3.14; // declares 'someVariable' as a 'float' data type </pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Floating point numbers are not precise and may lead to strange results when compared. Also, floating-point calculations are much slower than with integer data types. Calculations with floating-point values should be avoided if possible. </div>

&emsp;➥ <b>arrays</b>: An array is a collection of values that are accessed with an index number.
Each value in the array can be accessed by retrieving the name of<br>&emsp;&emsp; the array and the index number of the value. The index number always starts at 0 for an array.<br>&emsp;&emsp; An array must be declared and optionally assigned values before it can be used.
<pre>int myArray[] = {value0, value1, value2...} </pre>

In the same way it is possible to declare an array first with datatype and size and later to give a value to an index position.
<pre>int myArray[5]; // declare datatype 'integer' as array with 5 Positions
myArray[3] = 10; // gives the 4th index the value 10 </pre>

To read the value of an array you can simply assign it to a variable specifying the array and the index position.
<pre>x = myArray[3]; // x now has the value 10 </pre>

Arrays are often used for loops, where the counter of the loop is also used as index position for the values in the array. The following example uses an array to make an LED flicker. With a for loop and a counter starting at 0 an index position in the array is read, sent to the LED pin, paused for 200ms and then the same is done with the next index position.
<pre>int ledPin = 10; // LED on pin 10
byte flicker[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array with 8 different values
void setup()
{
pinMode(ledPin, OUTPUT); // Sets the OUTPUT pin
}

void loop()
{
for(int i=0; i<7; i++) // loop equals the number
{ // of the values in the array
analogWrite(ledPin, flicker[i]); // writes the index value to the LED
delay(200); // 200ms pause
}
}</pre>

== Digitaler Input - Output ==
=== pinMode(pin,mode) ===
Used in 'void setup()' to configure a specific pin as either input or output.
<pre>pinMode(pin, OUTPUT); // sets 'pin' as output </pre>

Arduino digital pins are inputs by default, so they don't need to be specified as inputs with 'pinMode()'. Pins configured as inputs have a high impedance state.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: There are also comfortable 20 k 'pullup' resistors in the ATmega chip which are accessible via software.</div>

These built-in 'pullup' resistors can be accessed in the following way:
<pre>pinMode(pin, INPUT); // sets 'pin' as input
digitalWrite(pin, HIGH); // switches on the 'Pullup' resistor</pre>

&emsp;➥ Pullup resistors are normally used to connect inputs like switches. In the example shown here it is noticeable that the pin is not defined as an output<br>&emsp;&emsp; although it is written to. It is only the method to activate the internal 'pullup' resistor.

&emsp;➥ Pins configured as output are in a low impedance state and can be loaded with a maximum of 40 mAmpere current from connected elements<br>&emsp;&emsp; and circuits. This is enough to make an LED light up (don't forget the serial resistor), but not enough to drive most relays, solenoids or motors.

&emsp;➥ Short circuits at the Arduino pins as well as too high current can destroy the output pin or even the whole ATmega chip. For this reason it is a good idea<br>&emsp;&emsp; to connect an output pin with external elements in series with a 470 or 1K resistor to
switch.

=== digitalRead(pin) ===
digitalRead(pin)' reads the value from a specified digital pin, with the result either HIGH or LOW. The pin can be set either as a variable or constant (0-13).
<pre>value = digitalRead(Pin); // sets 'value' equal to the input pin </pre>

digitalWrite(pin,value)
Outputs either logic level HIGH or LOW at a specified pin. The pin can be set as a variable or constant (0-13).
<pre>digitalWrite(pin, HIGH); // sets 'pin' to high</pre>

The following example reads a button on a digital input and switches an LED on when the button is pressed:
<pre>int led = 13; // LED connected to pin 13
int pin = 7; // Button connected to pin 7
int value = 0; // Variable to store the readout value

void setup()
{
pinMode(led, OUTPUT); // defines pin 13 as output
pinMode(pin, INPUT); // sets pin 7 as input
}

void loop()
{
value = digitalRead(pin); // sets 'value' equal to
// the input pin
digitalWrite(led, value); // sets 'led' equal to the
} // Value of the button</pre>

== Analoger Input - Output ==
=== analogRead(pin) ===
Reads the value of a specified analog pin with a 10 bit resolution. This function is only available for pins (0-5). The resulting integer values have a spectrum from 0 to 1023.
<pre>value = analogRead(pin); // sets 'value' equal to 'pin</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Unlike digital pins, analog pins do not have to be declared as input or output first. </div>

=== analogWrite(pin, value) ===
Writes pseudo-analog values to an output pin using hardware-based pulse width modulation (PWM). On newer Arduino boards with the ATmega 168 chip this function is applicable to pins 3, 5, 6, 9, 10 and 11. Older Arduinos with the ATmega8 only support pins 9,10 and 11. The value can be set as a variable or constant in the range 0-255.
<pre>analogWrite(pin, value); // writes 'value' to the analog 'pin </pre>

A value of 0 generates a uniform voltage of 0 volts at a fixed pin; a value of 255 generates a uniform voltage of 5 volts at a fixed pin. For values between 0 and 255, the pin changes very quickly between 0 and 5 volts - the higher the value, the longer the pin is HIGH (5 volts). For a value of 64, the pin is at 0 volts for three-quarters of the time and at 5 volts for one-quarter of the time. A value of 128 means that the output voltage is HIGH half of the time and LOW the other half. A value of 192 means that the voltage at the pin measures 0 volts at one quarter of the time and the full 5 volts at three quarters of the time.

Because this is a hardware-based function, the constant wave runs independently of the program until the next change of state via analogWrite (or a call to digitalRead or digitalWrite on the same pin).

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: In contrast to digital pins, analog pins do not have to be declared as input or output before. </div>

&emsp;➥ The following example reads an analog value from 'pin', converts the value by dividing it by 4 and then outputs it as a PWM signal to 'led'.

<pre>int led = 10; // LED with 220 resistor at pin 10
int pin = 0; // Potentiometer at analog pin 0
int value; // Value for readout

void setup(){} // no setup required

void loop()
{
value = analogRead(pin); // sets 'value' equal to 'pin
value /= 4; // converts 0-1023 into 0-255
analogWrite(led, value); // outputs the PWM signal 'led
}</pre>

== Random functions ==
=== randomSeed(seed) ===
Sets a value or 'Seed' as starting point for the random() function.
<pre>randomSeed(value); // sets 'value' as the random seed</pre>

The Arduino itself is not able to produce a truly random value. With randomSeed() a variable can be used as 'seed' to get better random results. For example, millis() or analogRead() can be used as a seed variable or function to use electrical noise through the analog pin as an output for random values.

=== random(min, max) ===
The random function allows the generation of pseudo-random values within a defined range of minimum and maxium values.
<pre>value = random(100, 200); // sets 'value' with a random number
// between 100 and 200 equal </pre>

The following example generates a random value between 0 and 255 and outputs it as PWM signal on a PWM pin.
<pre>int randNumber; // Variable to store the random value
int led = 10; // LED with 220 Ohm resistor at pin 10

void setup() {} // no setup necessary

void loop()
{
randomSeed(millis()); // uses millis() as seed
randNumber = random(255); // Random number in the range 0-255
analogWrite(led, randNumber); // PWM signal as output
delay(500); // half second pause
}</pre>

== Serial communication ==
=== Serial.begin(rate) ===
Serial.begin(rate)' Opens the serial port and sets the baud rate for the serial transmission. The typical baud rate with the computer is 9600 baud. Other speeds are also supported.
<pre>void setup()
{
Serial.begin(9600); // opens serial port
} // sets the data rate to 9600 bps</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: When using serial communication, digital pins 0 (RX) and 1 (TX) cannot be used at the same time. </div>

=== Serial.println(data) ===
Writes data to the serial port, followed by an automatic line break as carrier return and line feed. This function has the same form as 'Serial.print()', but is easier to read on the serial monitor.
<pre>Serial.println(analogValue); // sends the value of 'analogValue'</pre>

More detailed information about the numerous variants of the 'Serial.println()' and 'Serial.print()' functions can be found on the Arduino website.

The following simple example reads a value from analog pin 0 and sends the data to the computer once per second.
<pre>void setup()
{
Serial.begin(9600); // sets the data rate to 9600 bps
}

void loop()
{
Serial.println(analogRead(0)); // sends the analog value
delay(1000); // pauses for 1 second
}</pre>

== Examples ==
=== Digital output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Output.JPG|thumb|none|300px|Arduino-Example-Digital-Output]] </li>
</ul></div>

This is a simple 'Hello World' program and turns something on and off. In this example a LED is connected to PIN 13 and flashes every second. The resistor may be superfluous at this pin because the Arduino has a built-in resistor.
<pre>int ledPin = 13; // LED off digital pin 13

void setup() // will run through once
{
pinMode(ledPin, OUTPUT); // sets pin 13 as output
}

void loop() // Running as endless loop
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}</pre>

=== Digital input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Input.JPG|thumb|none|300px|Arduino-Example-Digital-Input]] </li>
</ul></div>

This is the simplest form of an input with only two possible states: on or off.
This example reads out a simple switch or button at pin 2. When the switch is closed and the input pin is HIGH, the LED is turned on.
<pre>int ledPin = 13; // Output pin for the LED
int inPin = 2; // Input pin for a switch

void setup()
{
pinMode(ledPin, OUTPUT); // declares LED as output
pinMode(inPin, INPUT); // declares switch as input
}
void loop()
if (digitalRead(inPin) == HIGH) // check if this is the HIGH input
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}
}</pre>

=== analog PWM output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

Pulse width modulation (PWM) is a method of simulating analog outputs by pulsing the output voltage. This allows you to make an LED brighter or darker or check a servomotor later. The following example uses a loop to slowly make an LED brighter and darker.

<pre>int ledPin = 9; // PWM Pin for the LED

void setup(){} // No setup necessary

void loop()
{
for (int i=0; i<=255; i++) // ascending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}

for (int i=255; i>=0; i--) // descending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}
}</pre>

=== potentiometer Input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

With a potentiometer and one of the analog-digital converter (ADC) inputs of the Arduino it is possible to read analog values from 0-1024. The following example uses a potentiometer to control the blinking rate of an LED.

<pre>int potPin = 0; // Input pin for the potentiometer
int ledPin = 13; // Output pin for the LED

void setup()
{
pinMode(ledPin, OUTPUT); // declare ledPin as OUTPUT
}

void loop()
{
digitalWrite(ledPin, HIGH); // switches on ledPin
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
digitalWrite(ledPin, LOW); // switches ledPin off
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
}</pre>

== Used Hardware ==
&emsp;➠ [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

&emsp;➠ [[ARDUINO Wireless Proto Shield]]

&emsp;➠ [[Arduino MKR WAN 1300 LoRa]]

&emsp;➠ [[Arduino MKR LoRa Gateway Pro]]

== References ==
&emsp;➠ https://www.elektronik-kompendium.de/sites/com/1810231.htm

&emsp;➠ http://myhomearchiv.synology.me/download/Anleitung_Furduino.pdf

&emsp;➠ https://starthardware.org/arduino-uno/

&emsp;➠ https://starthardware.org/category/projekte/arduino-projekte/

&emsp;➠ http://www.netzmafia.de/skripten/hardware/Arduino/Arduino_Programmierhandbuch.pdf

[[Category:Documentation]]

Arduino Board Uno Rev3-Atmega 328: Programming Guide

2020-08-10T20:50:18Z

CCinay: /* Data types */

<div style="max-width: 970px">

== Summary ==
The <b>Arduino IDE</b> is a cross-platform Java application that acts as a program code editor and compiler and is also able to send firmware serially to the board. The development environment is based on Processing, an IDE designed to program artists, who normally do not have much contact with the art world programming environments. The programming language is based on Wiring, a C similar language which has a similar scope for a more restricted board design, whose IDE is also based on processing. Make sure you have an updated version of <b>[https://www.arduino.cc/en/Main/Software Arduino IDE]</b> installed.

== Struktur ==
The basic structure of the Arduino programming language is relatively simple and is divided into at least two parts. These two required parts or functions enclose blocks of statements.

<pre>void setup() { // put your setup code here, to run once:
}
void loop() { // put your main code here, to run repeatedly:
}</pre>

&emsp;➥ Here <b>setup()</b> is the preparation and <b>loop()</b> is the execution. Both functions are necessary to execute the program.

&emsp;➥ The setup function should follow the variable definition, which must be listed before. Setup must be run through as the first function in a program. <br>&emsp;&emsp; It is executed only once and is used to set <b>PinMode</b> or to initiate serial communication.

&emsp;➥ The <b>setup()</b> function is called once when the program starts. Use this function to set PinModes or start serial communication. The <b>setup()</b> function must <br>&emsp;&emsp; appear in every program, even if it does not contain any instructions.

&emsp;➥ After the <b>setup()</b> function follows the <b>loop()</b> function. It contains program code that is executed continuously in an infinite loop - read inputs, trigger <br>&emsp;&emsp; outputs, etc. This function is the core of all Arduino programs and does the main work.

=== setup() ===
The <b>setup()</b> function is called once when the program starts. Use this function to set <b>PinModes</b> or start serial communication.
The <b>setup()</b> function must appear in every program, even if it does not contain any instructions.

<pre>void setup()
{
pinMode(pin, OUTPUT); // 'pin' define as output
}</pre>

=== loop() ===
After running through the <b>setup() function</b>, the <b>loop() function</b> does exactly what its name suggests and runs in an endless loop. This allows the program to interact with the Arduino board via changes, reactions and controls.
<pre>void loop()
{
digitalWrite(pin, HIGH); // switches 'pin' on
delay(1000); // Pause for one second
digitalWrite(pin, LOW); // switches 'pin' off
delay(1000); // Pause for one second
}</pre>

=== Functions ===
A function is a block of program code that has a name and a set of instructions that are executed when the function is called. The functions <b>void setup()</b> and <b>void loop()</b> have already been explained. There are more built-in functions that will be discussed later.

<pre>Type FunctionName(parameter)
{
instructions;
}</pre>

The following integer type function <b>delayVal()</b> is used to insert a delay value into a program by reading a potentiometer. First a local variable <b>'v'</b> is created. Next, <b>'v'</b> is equated with the position of the potentiometer, which can have a value between <b>0 and 1023</b>. The value is then <b>divided by 4 to get a scale from 0 to 255</b> and at the end the result of the function is returned to the main program.

<pre>int delayVal()
{
int v; // create temporary variable 'v
v = analogRead(pot); // read potentiometer Value
v /= 4; // Convert from 0-1023 to 0-255
return v; // return the calculated value
}</pre>

=== {} curly brackets ===
Curly brackets (also called <b>'curly brackets'</b>) define the start and end of function and statement blocks as in the <b>'void loop()'</b> function and also in the <b>'for' and 'if'</b> statement.

<pre>type function()
{
instructions;
}</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: An opening curved bracket '{' must always be followed by a closing curved bracket '}'. Here it is often said that the number of brackets must be balanced. Unbalanced parentheses often lead to cryptic, inscrutable errors in the compiler, which are sometimes hard to find, especially in large programs.

The Arduino programming environment helps to check that the curved brackets are balanced. To do this, simply select a brace or click just behind it, and the logically connected counterpart is highlighted. </div>

=== ;semicolon ===
A semicolon must be used at the end of a statement and is used to separate the elements of a program.
A semicolon is also used to separate the elements of a for loop.

<pre>int x = 13; // declares variable 'x' as integer with value 13</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Forgetting a semicolon at the end of a line leads to an error in the compiler. The error description can be very clear and directly point to the missing semicolon, but this does not have to be the case. If an inscrutable or apparently illogical error is reported, the first thing to do is to add missing semicolons near the reported error. </div>

=== /*... */ block comments ===
Block comments or multiline comments are text areas that are ignored by the program. They are used for longer descriptions or comments and help other authors to understand program parts. They start with /* and end with */ and can cover several lines.

<pre>/* This is an inserted block comment
please do not forget the closing comment -
These must be balanced
*/</pre>

=== // Single line comments ===
Simple single-line comments are defined with a // at the beginning of the line and end with the end of the line. They are ignored by the program and do not consume memory.
<pre>// this is a single line comment</pre>

== Variables ==
A variable is the name of a numeric value with a name and memory location for later use in a program. A variable must be declared and optionally provided with a value. The following example declares a variable 'inputVariable' and assigns the value of analog pin 2 to it:
<pre>int inputVariable = 0; // declares a variable and
// sets its value to 0
inputVariable = analogRead(2); // sets the value of the variable equal
// with the value of analog pin 2 </pre>

'inputVariable' is the variable itself. The first line explains that its data type is 'int', which is the short expression for integer. The second line gives the variable the value of the analog pin 2, making the value of the pin available everywhere in the code.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Variables should always have descriptive names as clearly as possible to make the code easier to read.</div>

=== Declaration of variables: ===
All variables must be declared before use. Declaring a variable means defining its type such as int, long, float, etc., giving it a name and optionally an initial value.This only needs to be done once in the program. Afterwards the value can be changed at any time by calculations or various assignments.

The following example declares 'inputVariable' as 'int', i.e. integer data type and sets the initial value to 0. This is called a 'simple assignment'.
<pre>int inputVariable = 0;</pre>

A variable can be declared at many places in the program. The location of the declaration determines which program parts have access to the variable.

== Data types ==
&emsp;➥ <b>byte</b>: Byte stores an <b>8-bit numeric</b>, integer value without decimal point. The <b>value</b> can be between <b>0 and 255</b>.
<pre>byte someVariable = 180; // declares 'someVariable as a 'byte' data type </pre>

&emsp;➥ <b>int</b>: Integers are the most common data type for storing integer values without decimal point. Its <b>value</b> is <b>16 bits and ranges from -32,767 to 32,768</b>.
<pre>int someVariable = 1500; // declares 'someVariable as an 'integer' data type</pre>

&emsp;➥ <b>long</b>: Data type for long integers with extended size, without decimal point, <b>stored in a 32-bit</b> value in a spectrum from <b>-2,147,483,648 to 2,147,483,647</b>
<pre>long someVariable = 90000; // declares 'someVariable as a 'long' data type </pre>

&emsp;➥ <b>float</b>: A data type for floating point values or numbers with decimal places. Floating point numbers have a better resolution than integers and are<br>&emsp;&emsp; expressed as <b>32-bit values with a spectrum from -3.4028235E+38 to 3.4028235E+38</b>.
<pre>float someVariable = 3.14; // declares 'someVariable' as a 'float' data type </pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Floating point numbers are not precise and may lead to strange results when compared. Also, floating-point calculations are much slower than with integer data types. Calculations with floating-point values should be avoided if possible. </div>

&emsp;➥ <b>arrays</b>: An array is a collection of values that are accessed with an index number.
Each value in the array can be accessed by retrieving the name of<br>&emsp;&emsp; the array and the index number of the value. The index number always starts at 0 for an array.<br>&emsp;&emsp; An array must be declared and optionally assigned values before it can be used.
<pre>int myArray[] = {value0, value1, value2...} </pre>

In the same way it is possible to declare an array first with datatype and size and later to give a value to an index position.
<pre>int myArray[5]; // declare datatype 'integer' as array with 5 Positions
myArray[3] = 10; // gives the 4th index the value 10 </pre>

To read the value of an array you can simply assign it to a variable specifying the array and the index position.
<pre>x = myArray[3]; // x now has the value 10 </pre>

Arrays are often used for loops, where the counter of the loop is also used as index position for the values in the array. The following example uses an array to make an LED flicker. With a for loop and a counter starting at 0 an index position in the array is read, sent to the LED pin, paused for 200ms and then the same is done with the next index position.
<pre>int ledPin = 10; // LED on pin 10
byte flicker[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array with 8 different values
void setup()
{
pinMode(ledPin, OUTPUT); // Sets the OUTPUT pin
}

void loop()
{
for(int i=0; i<7; i++) // loop equals the number
{ // of the values in the array
analogWrite(ledPin, flicker[i]); // writes the index value to the LED
delay(200); // 200ms pause
}
}</pre>

== Digitaler Input - Output ==
=== pinMode(pin,mode) ===
Used in 'void setup()' to configure a specific pin as either input or output.
<pre>pinMode(pin, OUTPUT); // sets 'pin' as output </pre>

Arduino digital pins are inputs by default, so they don't need to be specified as inputs with 'pinMode()'. Pins configured as inputs have a high impedance state.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: There are also comfortable 20 k 'pullup' resistors in the ATmega chip which are accessible via software.</div>

These built-in 'pullup' resistors can be accessed in the following way:
<pre>pinMode(pin, INPUT); // sets 'pin' as input
digitalWrite(pin, HIGH); // switches on the 'Pullup' resistor</pre>

&emsp;➥ Pullup resistors are normally used to connect inputs like switches. In the example shown here it is noticeable that the pin is not defined as an output<br>&emsp;&emsp; although it is written to. It is only the method to activate the internal 'pullup' resistor.

&emsp;➥ Pins configured as output are in a low impedance state and can be loaded with a maximum of 40 mAmpere current from connected elements<br>&emsp;&emsp; and circuits. This is enough to make an LED light up (don't forget the serial resistor), but not enough to drive most relays, solenoids or motors.

&emsp;➥ Short circuits at the Arduino pins as well as too high current can destroy the output pin or even the whole ATmega chip. For this reason it is a good idea<br>&emsp;&emsp; to connect an output pin with external elements in series with a 470 or 1K resistor to
switch.

=== digitalRead(pin) ===
digitalRead(pin)' reads the value from a specified digital pin, with the result either HIGH or LOW. The pin can be set either as a variable or constant (0-13).
<pre>value = digitalRead(Pin); // sets 'value' equal to the input pin </pre>

digitalWrite(pin,value)
Outputs either logic level HIGH or LOW at a specified pin. The pin can be set as a variable or constant (0-13).
<pre>digitalWrite(pin, HIGH); // sets 'pin' to high</pre>

The following example reads a button on a digital input and switches an LED on when the button is pressed:
<pre>int led = 13; // LED connected to pin 13
int pin = 7; // Button connected to pin 7
int value = 0; // Variable to store the readout value

void setup()
{
pinMode(led, OUTPUT); // defines pin 13 as output
pinMode(pin, INPUT); // sets pin 7 as input
}

void loop()
{
value = digitalRead(pin); // sets 'value' equal to
// the input pin
digitalWrite(led, value); // sets 'led' equal to the
} // Value of the button</pre>

== Analoger Input - Output ==
=== analogRead(pin) ===
Reads the value of a specified analog pin with a 10 bit resolution. This function is only available for pins (0-5). The resulting integer values have a spectrum from 0 to 1023.
<pre>value = analogRead(pin); // sets 'value' equal to 'pin</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Unlike digital pins, analog pins do not have to be declared as input or output first. </div>

=== analogWrite(pin, value) ===
Writes pseudo-analog values to an output pin using hardware-based pulse width modulation (PWM). On newer Arduino boards with the ATmega 168 chip this function is applicable to pins 3, 5, 6, 9, 10 and 11. Older Arduinos with the ATmega8 only support pins 9,10 and 11. The value can be set as a variable or constant in the range 0-255.
<pre>analogWrite(pin, value); // writes 'value' to the analog 'pin </pre>

A value of 0 generates a uniform voltage of 0 volts at a fixed pin; a value of 255 generates a uniform voltage of 5 volts at a fixed pin. For values between 0 and 255, the pin changes very quickly between 0 and 5 volts - the higher the value, the longer the pin is HIGH (5 volts). For a value of 64, the pin is at 0 volts for three-quarters of the time and at 5 volts for one-quarter of the time. A value of 128 means that the output voltage is HIGH half of the time and LOW the other half. A value of 192 means that the voltage at the pin measures 0 volts at one quarter of the time and the full 5 volts at three quarters of the time.

Because this is a hardware-based function, the constant wave runs independently of the program until the next change of state via analogWrite (or a call to digitalRead or digitalWrite on the same pin).

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: In contrast to digital pins, analog pins do not have to be declared as input or output before. </div>

&emsp;➥ The following example reads an analog value from 'pin', converts the value by dividing it by 4 and then outputs it as a PWM signal to 'led'.

<pre>int led = 10; // LED with 220 resistor at pin 10
int pin = 0; // Potentiometer at analog pin 0
int value; // Value for readout

void setup(){} // no setup required

void loop()
{
value = analogRead(pin); // sets 'value' equal to 'pin
value /= 4; // converts 0-1023 into 0-255
analogWrite(led, value); // outputs the PWM signal 'led
}</pre>

== Random functions ==
=== randomSeed(seed) ===
Sets a value or 'Seed' as starting point for the random() function.
<pre>randomSeed(value); // sets 'value' as the random seed</pre>

The Arduino itself is not able to produce a truly random value. With randomSeed() a variable can be used as 'seed' to get better random results. For example, millis() or analogRead() can be used as a seed variable or function to use electrical noise through the analog pin as an output for random values.

=== random(min, max) ===
The random function allows the generation of pseudo-random values within a defined range of minimum and maxium values.
<pre>value = random(100, 200); // sets 'value' with a random number
// between 100 and 200 equal </pre>

The following example generates a random value between 0 and 255 and outputs it as PWM signal on a PWM pin.
<pre>int randNumber; // Variable to store the random value
int led = 10; // LED with 220 Ohm resistor at pin 10

void setup() {} // no setup necessary

void loop()
{
randomSeed(millis()); // uses millis() as seed
randNumber = random(255); // Random number in the range 0-255
analogWrite(led, randNumber); // PWM signal as output
delay(500); // half second pause
}</pre>

== Serial communication ==
=== Serial.begin(rate) ===
Serial.begin(rate)' Opens the serial port and sets the baud rate for the serial transmission. The typical baud rate with the computer is 9600 baud. Other speeds are also supported.
<pre>void setup()
{
Serial.begin(9600); // opens serial port
} // sets the data rate to 9600 bps</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: When using serial communication, digital pins 0 (RX) and 1 (TX) cannot be used at the same time. </div>

=== Serial.println(data) ===
Writes data to the serial port, followed by an automatic line break as carrier return and line feed. This function has the same form as 'Serial.print()', but is easier to read on the serial monitor.
<pre>Serial.println(analogValue); // sends the value of 'analogValue'</pre>

More detailed information about the numerous variants of the 'Serial.println()' and 'Serial.print()' functions can be found on the Arduino website.

The following simple example reads a value from analog pin 0 and sends the data to the computer once per second.
<pre>void setup()
{
Serial.begin(9600); // sets the data rate to 9600 bps
}

void loop()
{
Serial.println(analogRead(0)); // sends the analog value
delay(1000); // pauses for 1 second
}</pre>

== Examples ==
=== Digital output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Output.JPG|thumb|none|300px|Arduino-Example-Digital-Output]] </li>
</ul></div>

This is a simple 'Hello World' program and turns something on and off. In this example a LED is connected to PIN 13 and flashes every second. The resistor may be superfluous at this pin because the Arduino has a built-in resistor.
<pre>int ledPin = 13; // LED off digital pin 13

void setup() // will run through once
{
pinMode(ledPin, OUTPUT); // sets pin 13 as output
}

void loop() // Running as endless loop
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}</pre>

=== Digital input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Input.JPG|thumb|none|300px|Arduino-Example-Digital-Input]] </li>
</ul></div>

This is the simplest form of an input with only two possible states: on or off.
This example reads out a simple switch or button at pin 2. When the switch is closed and the input pin is HIGH, the LED is turned on.
<pre>int ledPin = 13; // Output pin for the LED
int inPin = 2; // Input pin for a switch

void setup()
{
pinMode(ledPin, OUTPUT); // declares LED as output
pinMode(inPin, INPUT); // declares switch as input
}
void loop()
if (digitalRead(inPin) == HIGH) // check if this is the HIGH input
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}
}</pre>

=== analog PWM output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

Pulse width modulation (PWM) is a method of simulating analog outputs by pulsing the output voltage. This allows you to make an LED brighter or darker or check a servomotor later. The following example uses a loop to slowly make an LED brighter and darker.

<pre>int ledPin = 9; // PWM Pin for the LED

void setup(){} // No setup necessary

void loop()
{
for (int i=0; i<=255; i++) // ascending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}

for (int i=255; i>=0; i--) // descending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}
}</pre>

=== potentiometer Input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

With a potentiometer and one of the analog-digital converter (ADC) inputs of the Arduino it is possible to read analog values from 0-1024. The following example uses a potentiometer to control the blinking rate of an LED.

<pre>int potPin = 0; // Input pin for the potentiometer
int ledPin = 13; // Output pin for the LED

void setup()
{
pinMode(ledPin, OUTPUT); // declare ledPin as OUTPUT
}

void loop()
{
digitalWrite(ledPin, HIGH); // switches on ledPin
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
digitalWrite(ledPin, LOW); // switches ledPin off
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
}</pre>

== Used Hardware ==
&emsp;➠ [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

&emsp;➠ [[ARDUINO Wireless Proto Shield]]

&emsp;➠ [[Arduino MKR WAN 1300 LoRa]]

&emsp;➠ [[Arduino MKR LoRa Gateway Pro]]

== References ==
&emsp;➠ https://www.elektronik-kompendium.de/sites/com/1810231.htm

&emsp;➠ http://myhomearchiv.synology.me/download/Anleitung_Furduino.pdf

&emsp;➠ https://starthardware.org/arduino-uno/

&emsp;➠ https://starthardware.org/category/projekte/arduino-projekte/

&emsp;➠ http://www.netzmafia.de/skripten/hardware/Arduino/Arduino_Programmierhandbuch.pdf

[[Category:Documentation]]

Arduino Board Uno Rev3-Atmega 328: Programming Guide

2020-08-10T20:48:31Z

CCinay: /* Data types */

<div style="max-width: 970px">

== Summary ==
The <b>Arduino IDE</b> is a cross-platform Java application that acts as a program code editor and compiler and is also able to send firmware serially to the board. The development environment is based on Processing, an IDE designed to program artists, who normally do not have much contact with the art world programming environments. The programming language is based on Wiring, a C similar language which has a similar scope for a more restricted board design, whose IDE is also based on processing. Make sure you have an updated version of <b>[https://www.arduino.cc/en/Main/Software Arduino IDE]</b> installed.

== Struktur ==
The basic structure of the Arduino programming language is relatively simple and is divided into at least two parts. These two required parts or functions enclose blocks of statements.

<pre>void setup() { // put your setup code here, to run once:
}
void loop() { // put your main code here, to run repeatedly:
}</pre>

&emsp;➥ Here <b>setup()</b> is the preparation and <b>loop()</b> is the execution. Both functions are necessary to execute the program.

&emsp;➥ The setup function should follow the variable definition, which must be listed before. Setup must be run through as the first function in a program. <br>&emsp;&emsp; It is executed only once and is used to set <b>PinMode</b> or to initiate serial communication.

&emsp;➥ The <b>setup()</b> function is called once when the program starts. Use this function to set PinModes or start serial communication. The <b>setup()</b> function must <br>&emsp;&emsp; appear in every program, even if it does not contain any instructions.

&emsp;➥ After the <b>setup()</b> function follows the <b>loop()</b> function. It contains program code that is executed continuously in an infinite loop - read inputs, trigger <br>&emsp;&emsp; outputs, etc. This function is the core of all Arduino programs and does the main work.

=== setup() ===
The <b>setup()</b> function is called once when the program starts. Use this function to set <b>PinModes</b> or start serial communication.
The <b>setup()</b> function must appear in every program, even if it does not contain any instructions.

<pre>void setup()
{
pinMode(pin, OUTPUT); // 'pin' define as output
}</pre>

=== loop() ===
After running through the <b>setup() function</b>, the <b>loop() function</b> does exactly what its name suggests and runs in an endless loop. This allows the program to interact with the Arduino board via changes, reactions and controls.
<pre>void loop()
{
digitalWrite(pin, HIGH); // switches 'pin' on
delay(1000); // Pause for one second
digitalWrite(pin, LOW); // switches 'pin' off
delay(1000); // Pause for one second
}</pre>

=== Functions ===
A function is a block of program code that has a name and a set of instructions that are executed when the function is called. The functions <b>void setup()</b> and <b>void loop()</b> have already been explained. There are more built-in functions that will be discussed later.

<pre>Type FunctionName(parameter)
{
instructions;
}</pre>

The following integer type function <b>delayVal()</b> is used to insert a delay value into a program by reading a potentiometer. First a local variable <b>'v'</b> is created. Next, <b>'v'</b> is equated with the position of the potentiometer, which can have a value between <b>0 and 1023</b>. The value is then <b>divided by 4 to get a scale from 0 to 255</b> and at the end the result of the function is returned to the main program.

<pre>int delayVal()
{
int v; // create temporary variable 'v
v = analogRead(pot); // read potentiometer Value
v /= 4; // Convert from 0-1023 to 0-255
return v; // return the calculated value
}</pre>

=== {} curly brackets ===
Curly brackets (also called <b>'curly brackets'</b>) define the start and end of function and statement blocks as in the <b>'void loop()'</b> function and also in the <b>'for' and 'if'</b> statement.

<pre>type function()
{
instructions;
}</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: An opening curved bracket '{' must always be followed by a closing curved bracket '}'. Here it is often said that the number of brackets must be balanced. Unbalanced parentheses often lead to cryptic, inscrutable errors in the compiler, which are sometimes hard to find, especially in large programs.

The Arduino programming environment helps to check that the curved brackets are balanced. To do this, simply select a brace or click just behind it, and the logically connected counterpart is highlighted. </div>

=== ;semicolon ===
A semicolon must be used at the end of a statement and is used to separate the elements of a program.
A semicolon is also used to separate the elements of a for loop.

<pre>int x = 13; // declares variable 'x' as integer with value 13</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Forgetting a semicolon at the end of a line leads to an error in the compiler. The error description can be very clear and directly point to the missing semicolon, but this does not have to be the case. If an inscrutable or apparently illogical error is reported, the first thing to do is to add missing semicolons near the reported error. </div>

=== /*... */ block comments ===
Block comments or multiline comments are text areas that are ignored by the program. They are used for longer descriptions or comments and help other authors to understand program parts. They start with /* and end with */ and can cover several lines.

<pre>/* This is an inserted block comment
please do not forget the closing comment -
These must be balanced
*/</pre>

=== // Single line comments ===
Simple single-line comments are defined with a // at the beginning of the line and end with the end of the line. They are ignored by the program and do not consume memory.
<pre>// this is a single line comment</pre>

== Variables ==
A variable is the name of a numeric value with a name and memory location for later use in a program. A variable must be declared and optionally provided with a value. The following example declares a variable 'inputVariable' and assigns the value of analog pin 2 to it:
<pre>int inputVariable = 0; // declares a variable and
// sets its value to 0
inputVariable = analogRead(2); // sets the value of the variable equal
// with the value of analog pin 2 </pre>

'inputVariable' is the variable itself. The first line explains that its data type is 'int', which is the short expression for integer. The second line gives the variable the value of the analog pin 2, making the value of the pin available everywhere in the code.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Variables should always have descriptive names as clearly as possible to make the code easier to read.</div>

=== Declaration of variables: ===
All variables must be declared before use. Declaring a variable means defining its type such as int, long, float, etc., giving it a name and optionally an initial value.This only needs to be done once in the program. Afterwards the value can be changed at any time by calculations or various assignments.

The following example declares 'inputVariable' as 'int', i.e. integer data type and sets the initial value to 0. This is called a 'simple assignment'.
<pre>int inputVariable = 0;</pre>

A variable can be declared at many places in the program. The location of the declaration determines which program parts have access to the variable.

== Data types ==
&emsp;➥ <b>byte</b>: Byte stores an <b>8-bit numeric</b>, integer value without decimal point. The <b>value</b> can be between <b>0 and 255</b>.
<pre>byte someVariable = 180; // declares 'someVariable
// as a 'byte' data type </pre>

&emsp;➥ <b>int</b>: Integers are the most common data type for storing integer values without decimal point. Its <b>value</b> is <b>16 bits and ranges from -32,767 to 32,768</b>.
<pre>int someVariable = 1500; // declares 'someVariable
// as an 'integer' data type</pre>

&emsp;➥ <b>long</b>: Data type for long integers with extended size, without decimal point, <b>stored in a 32-bit</b> value in a spectrum from <b>-2,147,483,648 to 2,147,483,647</b>
<pre>long someVariable = 90000; // declares 'someVariable
// as a 'long' data type </pre>

&emsp;➥ <b>float</b>: A data type for floating point values or numbers with decimal places. Floating point numbers have a better resolution than integers and are<br>&emsp;&emsp; expressed as <b>32-bit values with a spectrum from -3.4028235E+38 to 3.4028235E+38</b>.
<pre>float someVariable = 3.14; // declares 'someVariable'
// as a 'float' data type </pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Floating point numbers are not precise and may lead to strange results when compared. Also, floating-point calculations are much slower than with integer data types. Calculations with floating-point values should be avoided if possible. </div>

&emsp;➥ <b>arrays</b>: An array is a collection of values that are accessed with an index number.
Each value in the array can be accessed by retrieving the name of<br>&emsp;&emsp; the array and the index number of the value. The index number always starts at 0 for an array.<br>&emsp;&emsp; An array must be declared and optionally assigned values before it can be used.
<pre>int myArray[] = {value0, value1, value2...} </pre>

In the same way it is possible to declare an array first with datatype and size and later to give a value to an index position.
<pre>int myArray[5]; // declare datatype 'integer' as array with 5 Positions
myArray[3] = 10; // gives the 4th index the value 10 </pre>

To read the value of an array you can simply assign it to a variable specifying the array and the index position.
<pre>x = myArray[3]; // x now has the value 10 </pre>

Arrays are often used for loops, where the counter of the loop is also used as index position for the values in the array. The following example uses an array to make an LED flicker. With a for loop and a counter starting at 0 an index position in the array is read, sent to the LED pin, paused for 200ms and then the same is done with the next index position.
<pre>int ledPin = 10; // LED on pin 10
byte flicker[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array with 8 different values
void setup()
{
pinMode(ledPin, OUTPUT); // Sets the OUTPUT pin
}

void loop()
{
for(int i=0; i<7; i++) // loop equals the number
{ // of the values in the array
analogWrite(ledPin, flicker[i]); // writes the index value to the LED
delay(200); // 200ms pause
}
}</pre>

== Digitaler Input - Output ==
=== pinMode(pin,mode) ===
Used in 'void setup()' to configure a specific pin as either input or output.
<pre>pinMode(pin, OUTPUT); // sets 'pin' as output </pre>

Arduino digital pins are inputs by default, so they don't need to be specified as inputs with 'pinMode()'. Pins configured as inputs have a high impedance state.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: There are also comfortable 20 k 'pullup' resistors in the ATmega chip which are accessible via software.</div>

These built-in 'pullup' resistors can be accessed in the following way:
<pre>pinMode(pin, INPUT); // sets 'pin' as input
digitalWrite(pin, HIGH); // switches on the 'Pullup' resistor</pre>

&emsp;➥ Pullup resistors are normally used to connect inputs like switches. In the example shown here it is noticeable that the pin is not defined as an output<br>&emsp;&emsp; although it is written to. It is only the method to activate the internal 'pullup' resistor.

&emsp;➥ Pins configured as output are in a low impedance state and can be loaded with a maximum of 40 mAmpere current from connected elements<br>&emsp;&emsp; and circuits. This is enough to make an LED light up (don't forget the serial resistor), but not enough to drive most relays, solenoids or motors.

&emsp;➥ Short circuits at the Arduino pins as well as too high current can destroy the output pin or even the whole ATmega chip. For this reason it is a good idea<br>&emsp;&emsp; to connect an output pin with external elements in series with a 470 or 1K resistor to
switch.

=== digitalRead(pin) ===
digitalRead(pin)' reads the value from a specified digital pin, with the result either HIGH or LOW. The pin can be set either as a variable or constant (0-13).
<pre>value = digitalRead(Pin); // sets 'value' equal to the input pin </pre>

digitalWrite(pin,value)
Outputs either logic level HIGH or LOW at a specified pin. The pin can be set as a variable or constant (0-13).
<pre>digitalWrite(pin, HIGH); // sets 'pin' to high</pre>

The following example reads a button on a digital input and switches an LED on when the button is pressed:
<pre>int led = 13; // LED connected to pin 13
int pin = 7; // Button connected to pin 7
int value = 0; // Variable to store the readout value

void setup()
{
pinMode(led, OUTPUT); // defines pin 13 as output
pinMode(pin, INPUT); // sets pin 7 as input
}

void loop()
{
value = digitalRead(pin); // sets 'value' equal to
// the input pin
digitalWrite(led, value); // sets 'led' equal to the
} // Value of the button</pre>

== Analoger Input - Output ==
=== analogRead(pin) ===
Reads the value of a specified analog pin with a 10 bit resolution. This function is only available for pins (0-5). The resulting integer values have a spectrum from 0 to 1023.
<pre>value = analogRead(pin); // sets 'value' equal to 'pin</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Unlike digital pins, analog pins do not have to be declared as input or output first. </div>

=== analogWrite(pin, value) ===
Writes pseudo-analog values to an output pin using hardware-based pulse width modulation (PWM). On newer Arduino boards with the ATmega 168 chip this function is applicable to pins 3, 5, 6, 9, 10 and 11. Older Arduinos with the ATmega8 only support pins 9,10 and 11. The value can be set as a variable or constant in the range 0-255.
<pre>analogWrite(pin, value); // writes 'value' to the analog 'pin </pre>

A value of 0 generates a uniform voltage of 0 volts at a fixed pin; a value of 255 generates a uniform voltage of 5 volts at a fixed pin. For values between 0 and 255, the pin changes very quickly between 0 and 5 volts - the higher the value, the longer the pin is HIGH (5 volts). For a value of 64, the pin is at 0 volts for three-quarters of the time and at 5 volts for one-quarter of the time. A value of 128 means that the output voltage is HIGH half of the time and LOW the other half. A value of 192 means that the voltage at the pin measures 0 volts at one quarter of the time and the full 5 volts at three quarters of the time.

Because this is a hardware-based function, the constant wave runs independently of the program until the next change of state via analogWrite (or a call to digitalRead or digitalWrite on the same pin).

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: In contrast to digital pins, analog pins do not have to be declared as input or output before. </div>

&emsp;➥ The following example reads an analog value from 'pin', converts the value by dividing it by 4 and then outputs it as a PWM signal to 'led'.

<pre>int led = 10; // LED with 220 resistor at pin 10
int pin = 0; // Potentiometer at analog pin 0
int value; // Value for readout

void setup(){} // no setup required

void loop()
{
value = analogRead(pin); // sets 'value' equal to 'pin
value /= 4; // converts 0-1023 into 0-255
analogWrite(led, value); // outputs the PWM signal 'led
}</pre>

== Random functions ==
=== randomSeed(seed) ===
Sets a value or 'Seed' as starting point for the random() function.
<pre>randomSeed(value); // sets 'value' as the random seed</pre>

The Arduino itself is not able to produce a truly random value. With randomSeed() a variable can be used as 'seed' to get better random results. For example, millis() or analogRead() can be used as a seed variable or function to use electrical noise through the analog pin as an output for random values.

=== random(min, max) ===
The random function allows the generation of pseudo-random values within a defined range of minimum and maxium values.
<pre>value = random(100, 200); // sets 'value' with a random number
// between 100 and 200 equal </pre>

The following example generates a random value between 0 and 255 and outputs it as PWM signal on a PWM pin.
<pre>int randNumber; // Variable to store the random value
int led = 10; // LED with 220 Ohm resistor at pin 10

void setup() {} // no setup necessary

void loop()
{
randomSeed(millis()); // uses millis() as seed
randNumber = random(255); // Random number in the range 0-255
analogWrite(led, randNumber); // PWM signal as output
delay(500); // half second pause
}</pre>

== Serial communication ==
=== Serial.begin(rate) ===
Serial.begin(rate)' Opens the serial port and sets the baud rate for the serial transmission. The typical baud rate with the computer is 9600 baud. Other speeds are also supported.
<pre>void setup()
{
Serial.begin(9600); // opens serial port
} // sets the data rate to 9600 bps</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: When using serial communication, digital pins 0 (RX) and 1 (TX) cannot be used at the same time. </div>

=== Serial.println(data) ===
Writes data to the serial port, followed by an automatic line break as carrier return and line feed. This function has the same form as 'Serial.print()', but is easier to read on the serial monitor.
<pre>Serial.println(analogValue); // sends the value of 'analogValue'</pre>

More detailed information about the numerous variants of the 'Serial.println()' and 'Serial.print()' functions can be found on the Arduino website.

The following simple example reads a value from analog pin 0 and sends the data to the computer once per second.
<pre>void setup()
{
Serial.begin(9600); // sets the data rate to 9600 bps
}

void loop()
{
Serial.println(analogRead(0)); // sends the analog value
delay(1000); // pauses for 1 second
}</pre>

== Examples ==
=== Digital output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Output.JPG|thumb|none|300px|Arduino-Example-Digital-Output]] </li>
</ul></div>

This is a simple 'Hello World' program and turns something on and off. In this example a LED is connected to PIN 13 and flashes every second. The resistor may be superfluous at this pin because the Arduino has a built-in resistor.
<pre>int ledPin = 13; // LED off digital pin 13

void setup() // will run through once
{
pinMode(ledPin, OUTPUT); // sets pin 13 as output
}

void loop() // Running as endless loop
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}</pre>

=== Digital input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Input.JPG|thumb|none|300px|Arduino-Example-Digital-Input]] </li>
</ul></div>

This is the simplest form of an input with only two possible states: on or off.
This example reads out a simple switch or button at pin 2. When the switch is closed and the input pin is HIGH, the LED is turned on.
<pre>int ledPin = 13; // Output pin for the LED
int inPin = 2; // Input pin for a switch

void setup()
{
pinMode(ledPin, OUTPUT); // declares LED as output
pinMode(inPin, INPUT); // declares switch as input
}
void loop()
if (digitalRead(inPin) == HIGH) // check if this is the HIGH input
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}
}</pre>

=== analog PWM output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

Pulse width modulation (PWM) is a method of simulating analog outputs by pulsing the output voltage. This allows you to make an LED brighter or darker or check a servomotor later. The following example uses a loop to slowly make an LED brighter and darker.

<pre>int ledPin = 9; // PWM Pin for the LED

void setup(){} // No setup necessary

void loop()
{
for (int i=0; i<=255; i++) // ascending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}

for (int i=255; i>=0; i--) // descending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}
}</pre>

=== potentiometer Input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

With a potentiometer and one of the analog-digital converter (ADC) inputs of the Arduino it is possible to read analog values from 0-1024. The following example uses a potentiometer to control the blinking rate of an LED.

<pre>int potPin = 0; // Input pin for the potentiometer
int ledPin = 13; // Output pin for the LED

void setup()
{
pinMode(ledPin, OUTPUT); // declare ledPin as OUTPUT
}

void loop()
{
digitalWrite(ledPin, HIGH); // switches on ledPin
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
digitalWrite(ledPin, LOW); // switches ledPin off
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
}</pre>

== Used Hardware ==
&emsp;➠ [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

&emsp;➠ [[ARDUINO Wireless Proto Shield]]

&emsp;➠ [[Arduino MKR WAN 1300 LoRa]]

&emsp;➠ [[Arduino MKR LoRa Gateway Pro]]

== References ==
&emsp;➠ https://www.elektronik-kompendium.de/sites/com/1810231.htm

&emsp;➠ http://myhomearchiv.synology.me/download/Anleitung_Furduino.pdf

&emsp;➠ https://starthardware.org/arduino-uno/

&emsp;➠ https://starthardware.org/category/projekte/arduino-projekte/

&emsp;➠ http://www.netzmafia.de/skripten/hardware/Arduino/Arduino_Programmierhandbuch.pdf

[[Category:Documentation]]

Arduino Board Uno Rev3-Atmega 328: Programming Guide

2020-08-10T20:45:03Z

CCinay: /* {} curly brackets */

<div style="max-width: 970px">

== Summary ==
The <b>Arduino IDE</b> is a cross-platform Java application that acts as a program code editor and compiler and is also able to send firmware serially to the board. The development environment is based on Processing, an IDE designed to program artists, who normally do not have much contact with the art world programming environments. The programming language is based on Wiring, a C similar language which has a similar scope for a more restricted board design, whose IDE is also based on processing. Make sure you have an updated version of <b>[https://www.arduino.cc/en/Main/Software Arduino IDE]</b> installed.

== Struktur ==
The basic structure of the Arduino programming language is relatively simple and is divided into at least two parts. These two required parts or functions enclose blocks of statements.

<pre>void setup() { // put your setup code here, to run once:
}
void loop() { // put your main code here, to run repeatedly:
}</pre>

&emsp;➥ Here <b>setup()</b> is the preparation and <b>loop()</b> is the execution. Both functions are necessary to execute the program.

&emsp;➥ The setup function should follow the variable definition, which must be listed before. Setup must be run through as the first function in a program. <br>&emsp;&emsp; It is executed only once and is used to set <b>PinMode</b> or to initiate serial communication.

&emsp;➥ The <b>setup()</b> function is called once when the program starts. Use this function to set PinModes or start serial communication. The <b>setup()</b> function must <br>&emsp;&emsp; appear in every program, even if it does not contain any instructions.

&emsp;➥ After the <b>setup()</b> function follows the <b>loop()</b> function. It contains program code that is executed continuously in an infinite loop - read inputs, trigger <br>&emsp;&emsp; outputs, etc. This function is the core of all Arduino programs and does the main work.

=== setup() ===
The <b>setup()</b> function is called once when the program starts. Use this function to set <b>PinModes</b> or start serial communication.
The <b>setup()</b> function must appear in every program, even if it does not contain any instructions.

<pre>void setup()
{
pinMode(pin, OUTPUT); // 'pin' define as output
}</pre>

=== loop() ===
After running through the <b>setup() function</b>, the <b>loop() function</b> does exactly what its name suggests and runs in an endless loop. This allows the program to interact with the Arduino board via changes, reactions and controls.
<pre>void loop()
{
digitalWrite(pin, HIGH); // switches 'pin' on
delay(1000); // Pause for one second
digitalWrite(pin, LOW); // switches 'pin' off
delay(1000); // Pause for one second
}</pre>

=== Functions ===
A function is a block of program code that has a name and a set of instructions that are executed when the function is called. The functions <b>void setup()</b> and <b>void loop()</b> have already been explained. There are more built-in functions that will be discussed later.

<pre>Type FunctionName(parameter)
{
instructions;
}</pre>

The following integer type function <b>delayVal()</b> is used to insert a delay value into a program by reading a potentiometer. First a local variable <b>'v'</b> is created. Next, <b>'v'</b> is equated with the position of the potentiometer, which can have a value between <b>0 and 1023</b>. The value is then <b>divided by 4 to get a scale from 0 to 255</b> and at the end the result of the function is returned to the main program.

<pre>int delayVal()
{
int v; // create temporary variable 'v
v = analogRead(pot); // read potentiometer Value
v /= 4; // Convert from 0-1023 to 0-255
return v; // return the calculated value
}</pre>

=== {} curly brackets ===
Curly brackets (also called <b>'curly brackets'</b>) define the start and end of function and statement blocks as in the <b>'void loop()'</b> function and also in the <b>'for' and 'if'</b> statement.

<pre>type function()
{
instructions;
}</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: An opening curved bracket '{' must always be followed by a closing curved bracket '}'. Here it is often said that the number of brackets must be balanced. Unbalanced parentheses often lead to cryptic, inscrutable errors in the compiler, which are sometimes hard to find, especially in large programs.

The Arduino programming environment helps to check that the curved brackets are balanced. To do this, simply select a brace or click just behind it, and the logically connected counterpart is highlighted. </div>

=== ;semicolon ===
A semicolon must be used at the end of a statement and is used to separate the elements of a program.
A semicolon is also used to separate the elements of a for loop.

<pre>int x = 13; // declares variable 'x' as integer with value 13</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Forgetting a semicolon at the end of a line leads to an error in the compiler. The error description can be very clear and directly point to the missing semicolon, but this does not have to be the case. If an inscrutable or apparently illogical error is reported, the first thing to do is to add missing semicolons near the reported error. </div>

=== /*... */ block comments ===
Block comments or multiline comments are text areas that are ignored by the program. They are used for longer descriptions or comments and help other authors to understand program parts. They start with /* and end with */ and can cover several lines.

<pre>/* This is an inserted block comment
please do not forget the closing comment -
These must be balanced
*/</pre>

=== // Single line comments ===
Simple single-line comments are defined with a // at the beginning of the line and end with the end of the line. They are ignored by the program and do not consume memory.
<pre>// this is a single line comment</pre>

== Variables ==
A variable is the name of a numeric value with a name and memory location for later use in a program. A variable must be declared and optionally provided with a value. The following example declares a variable 'inputVariable' and assigns the value of analog pin 2 to it:
<pre>int inputVariable = 0; // declares a variable and
// sets its value to 0
inputVariable = analogRead(2); // sets the value of the variable equal
// with the value of analog pin 2 </pre>

'inputVariable' is the variable itself. The first line explains that its data type is 'int', which is the short expression for integer. The second line gives the variable the value of the analog pin 2, making the value of the pin available everywhere in the code.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Variables should always have descriptive names as clearly as possible to make the code easier to read.</div>

=== Declaration of variables: ===
All variables must be declared before use. Declaring a variable means defining its type such as int, long, float, etc., giving it a name and optionally an initial value.This only needs to be done once in the program. Afterwards the value can be changed at any time by calculations or various assignments.

The following example declares 'inputVariable' as 'int', i.e. integer data type and sets the initial value to 0. This is called a 'simple assignment'.
<pre>int inputVariable = 0;</pre>

A variable can be declared at many places in the program. The location of the declaration determines which program parts have access to the variable.

== Data types ==
&emsp;➥ <b>byte</b>: Byte stores an 8-bit numeric, integer value without decimal point. The value can be between 0 and 255.
<pre>byte someVariable = 180; // declares 'someVariable
// as a 'byte' data type </pre>

&emsp;➥ <b>int</b>: Integers are the most common data type for storing integer values without decimal point. Its value is 16 bits and ranges from -32,767 to 32,768.
<pre>int someVariable = 1500; // declares 'someVariable
// as an 'integer' data type</pre>

&emsp;➥ <b>long</b>: Data type for long integers with extended size, without decimal point, stored in a 32-bit value in a spectrum from -2,147,483,648 to 2,147,483,647
<pre>long someVariable = 90000; // declares 'someVariable
// as a 'long' data type </pre>

&emsp;➥ <b>float</b>: A data type for floating point values or numbers with decimal places. Floating point numbers have a better resolution than integers and are<br>&emsp;&emsp; expressed as 32-bit values with a spectrum from -3.4028235E+38 to 3.4028235E+38.
<pre>float someVariable = 3.14; // declares 'someVariable'
// as a 'float' data type </pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Floating point numbers are not precise and may lead to strange results when compared. Also, floating-point calculations are much slower than with integer data types. Calculations with floating-point values should be avoided if possible. </div>

&emsp;➥ <b>arrays</b>: An array is a collection of values that are accessed with an index number.
Each value in the array can be accessed by retrieving the name of<br>&emsp;&emsp; the array and the index number of the value. The index number always starts at 0 for an array.<br>&emsp;&emsp; An array must be declared and optionally assigned values before it can be used.
<pre>int myArray[] = {value0, value1, value2...} </pre>

In the same way it is possible to declare an array first with datatype and size and later to give a value to an index position.
<pre>int myArray[5]; // declare datatype 'integer' as array with 5 Positions
myArray[3] = 10; // gives the 4th index the value 10 </pre>

To read the value of an array you can simply assign it to a variable specifying the array and the index position.
<pre>x = myArray[3]; // x now has the value 10 </pre>

Arrays are often used for loops, where the counter of the loop is also used as index position for the values in the array. The following example uses an array to make an LED flicker. With a for loop and a counter starting at 0 an index position in the array is read, sent to the LED pin, paused for 200ms and then the same is done with the next index position.
<pre>int ledPin = 10; // LED on pin 10
byte flicker[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array with 8 different values
void setup()
{
pinMode(ledPin, OUTPUT); // Sets the OUTPUT pin
}

void loop()
{
for(int i=0; i<7; i++) // loop equals the number
{ // of the values in the array
analogWrite(ledPin, flicker[i]); // writes the index value to the LED
delay(200); // 200ms pause
}
}</pre>

== Digitaler Input - Output ==
=== pinMode(pin,mode) ===
Used in 'void setup()' to configure a specific pin as either input or output.
<pre>pinMode(pin, OUTPUT); // sets 'pin' as output </pre>

Arduino digital pins are inputs by default, so they don't need to be specified as inputs with 'pinMode()'. Pins configured as inputs have a high impedance state.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: There are also comfortable 20 k 'pullup' resistors in the ATmega chip which are accessible via software.</div>

These built-in 'pullup' resistors can be accessed in the following way:
<pre>pinMode(pin, INPUT); // sets 'pin' as input
digitalWrite(pin, HIGH); // switches on the 'Pullup' resistor</pre>

&emsp;➥ Pullup resistors are normally used to connect inputs like switches. In the example shown here it is noticeable that the pin is not defined as an output<br>&emsp;&emsp; although it is written to. It is only the method to activate the internal 'pullup' resistor.

&emsp;➥ Pins configured as output are in a low impedance state and can be loaded with a maximum of 40 mAmpere current from connected elements<br>&emsp;&emsp; and circuits. This is enough to make an LED light up (don't forget the serial resistor), but not enough to drive most relays, solenoids or motors.

&emsp;➥ Short circuits at the Arduino pins as well as too high current can destroy the output pin or even the whole ATmega chip. For this reason it is a good idea<br>&emsp;&emsp; to connect an output pin with external elements in series with a 470 or 1K resistor to
switch.

=== digitalRead(pin) ===
digitalRead(pin)' reads the value from a specified digital pin, with the result either HIGH or LOW. The pin can be set either as a variable or constant (0-13).
<pre>value = digitalRead(Pin); // sets 'value' equal to the input pin </pre>

digitalWrite(pin,value)
Outputs either logic level HIGH or LOW at a specified pin. The pin can be set as a variable or constant (0-13).
<pre>digitalWrite(pin, HIGH); // sets 'pin' to high</pre>

The following example reads a button on a digital input and switches an LED on when the button is pressed:
<pre>int led = 13; // LED connected to pin 13
int pin = 7; // Button connected to pin 7
int value = 0; // Variable to store the readout value

void setup()
{
pinMode(led, OUTPUT); // defines pin 13 as output
pinMode(pin, INPUT); // sets pin 7 as input
}

void loop()
{
value = digitalRead(pin); // sets 'value' equal to
// the input pin
digitalWrite(led, value); // sets 'led' equal to the
} // Value of the button</pre>

== Analoger Input - Output ==
=== analogRead(pin) ===
Reads the value of a specified analog pin with a 10 bit resolution. This function is only available for pins (0-5). The resulting integer values have a spectrum from 0 to 1023.
<pre>value = analogRead(pin); // sets 'value' equal to 'pin</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Unlike digital pins, analog pins do not have to be declared as input or output first. </div>

=== analogWrite(pin, value) ===
Writes pseudo-analog values to an output pin using hardware-based pulse width modulation (PWM). On newer Arduino boards with the ATmega 168 chip this function is applicable to pins 3, 5, 6, 9, 10 and 11. Older Arduinos with the ATmega8 only support pins 9,10 and 11. The value can be set as a variable or constant in the range 0-255.
<pre>analogWrite(pin, value); // writes 'value' to the analog 'pin </pre>

A value of 0 generates a uniform voltage of 0 volts at a fixed pin; a value of 255 generates a uniform voltage of 5 volts at a fixed pin. For values between 0 and 255, the pin changes very quickly between 0 and 5 volts - the higher the value, the longer the pin is HIGH (5 volts). For a value of 64, the pin is at 0 volts for three-quarters of the time and at 5 volts for one-quarter of the time. A value of 128 means that the output voltage is HIGH half of the time and LOW the other half. A value of 192 means that the voltage at the pin measures 0 volts at one quarter of the time and the full 5 volts at three quarters of the time.

Because this is a hardware-based function, the constant wave runs independently of the program until the next change of state via analogWrite (or a call to digitalRead or digitalWrite on the same pin).

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: In contrast to digital pins, analog pins do not have to be declared as input or output before. </div>

&emsp;➥ The following example reads an analog value from 'pin', converts the value by dividing it by 4 and then outputs it as a PWM signal to 'led'.

<pre>int led = 10; // LED with 220 resistor at pin 10
int pin = 0; // Potentiometer at analog pin 0
int value; // Value for readout

void setup(){} // no setup required

void loop()
{
value = analogRead(pin); // sets 'value' equal to 'pin
value /= 4; // converts 0-1023 into 0-255
analogWrite(led, value); // outputs the PWM signal 'led
}</pre>

== Random functions ==
=== randomSeed(seed) ===
Sets a value or 'Seed' as starting point for the random() function.
<pre>randomSeed(value); // sets 'value' as the random seed</pre>

The Arduino itself is not able to produce a truly random value. With randomSeed() a variable can be used as 'seed' to get better random results. For example, millis() or analogRead() can be used as a seed variable or function to use electrical noise through the analog pin as an output for random values.

=== random(min, max) ===
The random function allows the generation of pseudo-random values within a defined range of minimum and maxium values.
<pre>value = random(100, 200); // sets 'value' with a random number
// between 100 and 200 equal </pre>

The following example generates a random value between 0 and 255 and outputs it as PWM signal on a PWM pin.
<pre>int randNumber; // Variable to store the random value
int led = 10; // LED with 220 Ohm resistor at pin 10

void setup() {} // no setup necessary

void loop()
{
randomSeed(millis()); // uses millis() as seed
randNumber = random(255); // Random number in the range 0-255
analogWrite(led, randNumber); // PWM signal as output
delay(500); // half second pause
}</pre>

== Serial communication ==
=== Serial.begin(rate) ===
Serial.begin(rate)' Opens the serial port and sets the baud rate for the serial transmission. The typical baud rate with the computer is 9600 baud. Other speeds are also supported.
<pre>void setup()
{
Serial.begin(9600); // opens serial port
} // sets the data rate to 9600 bps</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: When using serial communication, digital pins 0 (RX) and 1 (TX) cannot be used at the same time. </div>

=== Serial.println(data) ===
Writes data to the serial port, followed by an automatic line break as carrier return and line feed. This function has the same form as 'Serial.print()', but is easier to read on the serial monitor.
<pre>Serial.println(analogValue); // sends the value of 'analogValue'</pre>

More detailed information about the numerous variants of the 'Serial.println()' and 'Serial.print()' functions can be found on the Arduino website.

The following simple example reads a value from analog pin 0 and sends the data to the computer once per second.
<pre>void setup()
{
Serial.begin(9600); // sets the data rate to 9600 bps
}

void loop()
{
Serial.println(analogRead(0)); // sends the analog value
delay(1000); // pauses for 1 second
}</pre>

== Examples ==
=== Digital output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Output.JPG|thumb|none|300px|Arduino-Example-Digital-Output]] </li>
</ul></div>

This is a simple 'Hello World' program and turns something on and off. In this example a LED is connected to PIN 13 and flashes every second. The resistor may be superfluous at this pin because the Arduino has a built-in resistor.
<pre>int ledPin = 13; // LED off digital pin 13

void setup() // will run through once
{
pinMode(ledPin, OUTPUT); // sets pin 13 as output
}

void loop() // Running as endless loop
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}</pre>

=== Digital input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Input.JPG|thumb|none|300px|Arduino-Example-Digital-Input]] </li>
</ul></div>

This is the simplest form of an input with only two possible states: on or off.
This example reads out a simple switch or button at pin 2. When the switch is closed and the input pin is HIGH, the LED is turned on.
<pre>int ledPin = 13; // Output pin for the LED
int inPin = 2; // Input pin for a switch

void setup()
{
pinMode(ledPin, OUTPUT); // declares LED as output
pinMode(inPin, INPUT); // declares switch as input
}
void loop()
if (digitalRead(inPin) == HIGH) // check if this is the HIGH input
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}
}</pre>

=== analog PWM output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

Pulse width modulation (PWM) is a method of simulating analog outputs by pulsing the output voltage. This allows you to make an LED brighter or darker or check a servomotor later. The following example uses a loop to slowly make an LED brighter and darker.

<pre>int ledPin = 9; // PWM Pin for the LED

void setup(){} // No setup necessary

void loop()
{
for (int i=0; i<=255; i++) // ascending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}

for (int i=255; i>=0; i--) // descending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}
}</pre>

=== potentiometer Input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

With a potentiometer and one of the analog-digital converter (ADC) inputs of the Arduino it is possible to read analog values from 0-1024. The following example uses a potentiometer to control the blinking rate of an LED.

<pre>int potPin = 0; // Input pin for the potentiometer
int ledPin = 13; // Output pin for the LED

void setup()
{
pinMode(ledPin, OUTPUT); // declare ledPin as OUTPUT
}

void loop()
{
digitalWrite(ledPin, HIGH); // switches on ledPin
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
digitalWrite(ledPin, LOW); // switches ledPin off
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
}</pre>

== Used Hardware ==
&emsp;➠ [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

&emsp;➠ [[ARDUINO Wireless Proto Shield]]

&emsp;➠ [[Arduino MKR WAN 1300 LoRa]]

&emsp;➠ [[Arduino MKR LoRa Gateway Pro]]

== References ==
&emsp;➠ https://www.elektronik-kompendium.de/sites/com/1810231.htm

&emsp;➠ http://myhomearchiv.synology.me/download/Anleitung_Furduino.pdf

&emsp;➠ https://starthardware.org/arduino-uno/

&emsp;➠ https://starthardware.org/category/projekte/arduino-projekte/

&emsp;➠ http://www.netzmafia.de/skripten/hardware/Arduino/Arduino_Programmierhandbuch.pdf

[[Category:Documentation]]

Arduino Board Uno Rev3-Atmega 328: Programming Guide

2020-08-10T20:44:07Z

CCinay: /* Functions */

<div style="max-width: 970px">

== Summary ==
The <b>Arduino IDE</b> is a cross-platform Java application that acts as a program code editor and compiler and is also able to send firmware serially to the board. The development environment is based on Processing, an IDE designed to program artists, who normally do not have much contact with the art world programming environments. The programming language is based on Wiring, a C similar language which has a similar scope for a more restricted board design, whose IDE is also based on processing. Make sure you have an updated version of <b>[https://www.arduino.cc/en/Main/Software Arduino IDE]</b> installed.

== Struktur ==
The basic structure of the Arduino programming language is relatively simple and is divided into at least two parts. These two required parts or functions enclose blocks of statements.

<pre>void setup() { // put your setup code here, to run once:
}
void loop() { // put your main code here, to run repeatedly:
}</pre>

&emsp;➥ Here <b>setup()</b> is the preparation and <b>loop()</b> is the execution. Both functions are necessary to execute the program.

&emsp;➥ The setup function should follow the variable definition, which must be listed before. Setup must be run through as the first function in a program. <br>&emsp;&emsp; It is executed only once and is used to set <b>PinMode</b> or to initiate serial communication.

&emsp;➥ The <b>setup()</b> function is called once when the program starts. Use this function to set PinModes or start serial communication. The <b>setup()</b> function must <br>&emsp;&emsp; appear in every program, even if it does not contain any instructions.

&emsp;➥ After the <b>setup()</b> function follows the <b>loop()</b> function. It contains program code that is executed continuously in an infinite loop - read inputs, trigger <br>&emsp;&emsp; outputs, etc. This function is the core of all Arduino programs and does the main work.

=== setup() ===
The <b>setup()</b> function is called once when the program starts. Use this function to set <b>PinModes</b> or start serial communication.
The <b>setup()</b> function must appear in every program, even if it does not contain any instructions.

<pre>void setup()
{
pinMode(pin, OUTPUT); // 'pin' define as output
}</pre>

=== loop() ===
After running through the <b>setup() function</b>, the <b>loop() function</b> does exactly what its name suggests and runs in an endless loop. This allows the program to interact with the Arduino board via changes, reactions and controls.
<pre>void loop()
{
digitalWrite(pin, HIGH); // switches 'pin' on
delay(1000); // Pause for one second
digitalWrite(pin, LOW); // switches 'pin' off
delay(1000); // Pause for one second
}</pre>

=== Functions ===
A function is a block of program code that has a name and a set of instructions that are executed when the function is called. The functions <b>void setup()</b> and <b>void loop()</b> have already been explained. There are more built-in functions that will be discussed later.

<pre>Type FunctionName(parameter)
{
instructions;
}</pre>

The following integer type function <b>delayVal()</b> is used to insert a delay value into a program by reading a potentiometer. First a local variable <b>'v'</b> is created. Next, <b>'v'</b> is equated with the position of the potentiometer, which can have a value between <b>0 and 1023</b>. The value is then <b>divided by 4 to get a scale from 0 to 255</b> and at the end the result of the function is returned to the main program.

<pre>int delayVal()
{
int v; // create temporary variable 'v
v = analogRead(pot); // read potentiometer Value
v /= 4; // Convert from 0-1023 to 0-255
return v; // return the calculated value
}</pre>

=== {} curly brackets ===
Curly brackets (also called 'curly brackets') define the start and end of function and statement blocks as in the 'void loop()' function and also in the 'for' and 'if' statement.

<pre>type function()
{
instructions;
}</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: An opening curved bracket '{' must always be followed by a closing curved bracket '}'. Here it is often said that the number of brackets must be balanced. Unbalanced parentheses often lead to cryptic, inscrutable errors in the compiler, which are sometimes hard to find, especially in large programs.

The Arduino programming environment helps to check that the curved brackets are balanced. To do this, simply select a brace or click just behind it, and the logically connected counterpart is highlighted. </div>

=== ;semicolon ===
A semicolon must be used at the end of a statement and is used to separate the elements of a program.
A semicolon is also used to separate the elements of a for loop.

<pre>int x = 13; // declares variable 'x' as integer with value 13</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Forgetting a semicolon at the end of a line leads to an error in the compiler. The error description can be very clear and directly point to the missing semicolon, but this does not have to be the case. If an inscrutable or apparently illogical error is reported, the first thing to do is to add missing semicolons near the reported error. </div>

=== /*... */ block comments ===
Block comments or multiline comments are text areas that are ignored by the program. They are used for longer descriptions or comments and help other authors to understand program parts. They start with /* and end with */ and can cover several lines.

<pre>/* This is an inserted block comment
please do not forget the closing comment -
These must be balanced
*/</pre>

=== // Single line comments ===
Simple single-line comments are defined with a // at the beginning of the line and end with the end of the line. They are ignored by the program and do not consume memory.
<pre>// this is a single line comment</pre>

== Variables ==
A variable is the name of a numeric value with a name and memory location for later use in a program. A variable must be declared and optionally provided with a value. The following example declares a variable 'inputVariable' and assigns the value of analog pin 2 to it:
<pre>int inputVariable = 0; // declares a variable and
// sets its value to 0
inputVariable = analogRead(2); // sets the value of the variable equal
// with the value of analog pin 2 </pre>

'inputVariable' is the variable itself. The first line explains that its data type is 'int', which is the short expression for integer. The second line gives the variable the value of the analog pin 2, making the value of the pin available everywhere in the code.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Variables should always have descriptive names as clearly as possible to make the code easier to read.</div>

=== Declaration of variables: ===
All variables must be declared before use. Declaring a variable means defining its type such as int, long, float, etc., giving it a name and optionally an initial value.This only needs to be done once in the program. Afterwards the value can be changed at any time by calculations or various assignments.

The following example declares 'inputVariable' as 'int', i.e. integer data type and sets the initial value to 0. This is called a 'simple assignment'.
<pre>int inputVariable = 0;</pre>

A variable can be declared at many places in the program. The location of the declaration determines which program parts have access to the variable.

== Data types ==
&emsp;➥ <b>byte</b>: Byte stores an 8-bit numeric, integer value without decimal point. The value can be between 0 and 255.
<pre>byte someVariable = 180; // declares 'someVariable
// as a 'byte' data type </pre>

&emsp;➥ <b>int</b>: Integers are the most common data type for storing integer values without decimal point. Its value is 16 bits and ranges from -32,767 to 32,768.
<pre>int someVariable = 1500; // declares 'someVariable
// as an 'integer' data type</pre>

&emsp;➥ <b>long</b>: Data type for long integers with extended size, without decimal point, stored in a 32-bit value in a spectrum from -2,147,483,648 to 2,147,483,647
<pre>long someVariable = 90000; // declares 'someVariable
// as a 'long' data type </pre>

&emsp;➥ <b>float</b>: A data type for floating point values or numbers with decimal places. Floating point numbers have a better resolution than integers and are<br>&emsp;&emsp; expressed as 32-bit values with a spectrum from -3.4028235E+38 to 3.4028235E+38.
<pre>float someVariable = 3.14; // declares 'someVariable'
// as a 'float' data type </pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Floating point numbers are not precise and may lead to strange results when compared. Also, floating-point calculations are much slower than with integer data types. Calculations with floating-point values should be avoided if possible. </div>

&emsp;➥ <b>arrays</b>: An array is a collection of values that are accessed with an index number.
Each value in the array can be accessed by retrieving the name of<br>&emsp;&emsp; the array and the index number of the value. The index number always starts at 0 for an array.<br>&emsp;&emsp; An array must be declared and optionally assigned values before it can be used.
<pre>int myArray[] = {value0, value1, value2...} </pre>

In the same way it is possible to declare an array first with datatype and size and later to give a value to an index position.
<pre>int myArray[5]; // declare datatype 'integer' as array with 5 Positions
myArray[3] = 10; // gives the 4th index the value 10 </pre>

To read the value of an array you can simply assign it to a variable specifying the array and the index position.
<pre>x = myArray[3]; // x now has the value 10 </pre>

Arrays are often used for loops, where the counter of the loop is also used as index position for the values in the array. The following example uses an array to make an LED flicker. With a for loop and a counter starting at 0 an index position in the array is read, sent to the LED pin, paused for 200ms and then the same is done with the next index position.
<pre>int ledPin = 10; // LED on pin 10
byte flicker[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array with 8 different values
void setup()
{
pinMode(ledPin, OUTPUT); // Sets the OUTPUT pin
}

void loop()
{
for(int i=0; i<7; i++) // loop equals the number
{ // of the values in the array
analogWrite(ledPin, flicker[i]); // writes the index value to the LED
delay(200); // 200ms pause
}
}</pre>

== Digitaler Input - Output ==
=== pinMode(pin,mode) ===
Used in 'void setup()' to configure a specific pin as either input or output.
<pre>pinMode(pin, OUTPUT); // sets 'pin' as output </pre>

Arduino digital pins are inputs by default, so they don't need to be specified as inputs with 'pinMode()'. Pins configured as inputs have a high impedance state.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: There are also comfortable 20 k 'pullup' resistors in the ATmega chip which are accessible via software.</div>

These built-in 'pullup' resistors can be accessed in the following way:
<pre>pinMode(pin, INPUT); // sets 'pin' as input
digitalWrite(pin, HIGH); // switches on the 'Pullup' resistor</pre>

&emsp;➥ Pullup resistors are normally used to connect inputs like switches. In the example shown here it is noticeable that the pin is not defined as an output<br>&emsp;&emsp; although it is written to. It is only the method to activate the internal 'pullup' resistor.

&emsp;➥ Pins configured as output are in a low impedance state and can be loaded with a maximum of 40 mAmpere current from connected elements<br>&emsp;&emsp; and circuits. This is enough to make an LED light up (don't forget the serial resistor), but not enough to drive most relays, solenoids or motors.

&emsp;➥ Short circuits at the Arduino pins as well as too high current can destroy the output pin or even the whole ATmega chip. For this reason it is a good idea<br>&emsp;&emsp; to connect an output pin with external elements in series with a 470 or 1K resistor to
switch.

=== digitalRead(pin) ===
digitalRead(pin)' reads the value from a specified digital pin, with the result either HIGH or LOW. The pin can be set either as a variable or constant (0-13).
<pre>value = digitalRead(Pin); // sets 'value' equal to the input pin </pre>

digitalWrite(pin,value)
Outputs either logic level HIGH or LOW at a specified pin. The pin can be set as a variable or constant (0-13).
<pre>digitalWrite(pin, HIGH); // sets 'pin' to high</pre>

The following example reads a button on a digital input and switches an LED on when the button is pressed:
<pre>int led = 13; // LED connected to pin 13
int pin = 7; // Button connected to pin 7
int value = 0; // Variable to store the readout value

void setup()
{
pinMode(led, OUTPUT); // defines pin 13 as output
pinMode(pin, INPUT); // sets pin 7 as input
}

void loop()
{
value = digitalRead(pin); // sets 'value' equal to
// the input pin
digitalWrite(led, value); // sets 'led' equal to the
} // Value of the button</pre>

== Analoger Input - Output ==
=== analogRead(pin) ===
Reads the value of a specified analog pin with a 10 bit resolution. This function is only available for pins (0-5). The resulting integer values have a spectrum from 0 to 1023.
<pre>value = analogRead(pin); // sets 'value' equal to 'pin</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Unlike digital pins, analog pins do not have to be declared as input or output first. </div>

=== analogWrite(pin, value) ===
Writes pseudo-analog values to an output pin using hardware-based pulse width modulation (PWM). On newer Arduino boards with the ATmega 168 chip this function is applicable to pins 3, 5, 6, 9, 10 and 11. Older Arduinos with the ATmega8 only support pins 9,10 and 11. The value can be set as a variable or constant in the range 0-255.
<pre>analogWrite(pin, value); // writes 'value' to the analog 'pin </pre>

A value of 0 generates a uniform voltage of 0 volts at a fixed pin; a value of 255 generates a uniform voltage of 5 volts at a fixed pin. For values between 0 and 255, the pin changes very quickly between 0 and 5 volts - the higher the value, the longer the pin is HIGH (5 volts). For a value of 64, the pin is at 0 volts for three-quarters of the time and at 5 volts for one-quarter of the time. A value of 128 means that the output voltage is HIGH half of the time and LOW the other half. A value of 192 means that the voltage at the pin measures 0 volts at one quarter of the time and the full 5 volts at three quarters of the time.

Because this is a hardware-based function, the constant wave runs independently of the program until the next change of state via analogWrite (or a call to digitalRead or digitalWrite on the same pin).

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: In contrast to digital pins, analog pins do not have to be declared as input or output before. </div>

&emsp;➥ The following example reads an analog value from 'pin', converts the value by dividing it by 4 and then outputs it as a PWM signal to 'led'.

<pre>int led = 10; // LED with 220 resistor at pin 10
int pin = 0; // Potentiometer at analog pin 0
int value; // Value for readout

void setup(){} // no setup required

void loop()
{
value = analogRead(pin); // sets 'value' equal to 'pin
value /= 4; // converts 0-1023 into 0-255
analogWrite(led, value); // outputs the PWM signal 'led
}</pre>

== Random functions ==
=== randomSeed(seed) ===
Sets a value or 'Seed' as starting point for the random() function.
<pre>randomSeed(value); // sets 'value' as the random seed</pre>

The Arduino itself is not able to produce a truly random value. With randomSeed() a variable can be used as 'seed' to get better random results. For example, millis() or analogRead() can be used as a seed variable or function to use electrical noise through the analog pin as an output for random values.

=== random(min, max) ===
The random function allows the generation of pseudo-random values within a defined range of minimum and maxium values.
<pre>value = random(100, 200); // sets 'value' with a random number
// between 100 and 200 equal </pre>

The following example generates a random value between 0 and 255 and outputs it as PWM signal on a PWM pin.
<pre>int randNumber; // Variable to store the random value
int led = 10; // LED with 220 Ohm resistor at pin 10

void setup() {} // no setup necessary

void loop()
{
randomSeed(millis()); // uses millis() as seed
randNumber = random(255); // Random number in the range 0-255
analogWrite(led, randNumber); // PWM signal as output
delay(500); // half second pause
}</pre>

== Serial communication ==
=== Serial.begin(rate) ===
Serial.begin(rate)' Opens the serial port and sets the baud rate for the serial transmission. The typical baud rate with the computer is 9600 baud. Other speeds are also supported.
<pre>void setup()
{
Serial.begin(9600); // opens serial port
} // sets the data rate to 9600 bps</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: When using serial communication, digital pins 0 (RX) and 1 (TX) cannot be used at the same time. </div>

=== Serial.println(data) ===
Writes data to the serial port, followed by an automatic line break as carrier return and line feed. This function has the same form as 'Serial.print()', but is easier to read on the serial monitor.
<pre>Serial.println(analogValue); // sends the value of 'analogValue'</pre>

More detailed information about the numerous variants of the 'Serial.println()' and 'Serial.print()' functions can be found on the Arduino website.

The following simple example reads a value from analog pin 0 and sends the data to the computer once per second.
<pre>void setup()
{
Serial.begin(9600); // sets the data rate to 9600 bps
}

void loop()
{
Serial.println(analogRead(0)); // sends the analog value
delay(1000); // pauses for 1 second
}</pre>

== Examples ==
=== Digital output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Output.JPG|thumb|none|300px|Arduino-Example-Digital-Output]] </li>
</ul></div>

This is a simple 'Hello World' program and turns something on and off. In this example a LED is connected to PIN 13 and flashes every second. The resistor may be superfluous at this pin because the Arduino has a built-in resistor.
<pre>int ledPin = 13; // LED off digital pin 13

void setup() // will run through once
{
pinMode(ledPin, OUTPUT); // sets pin 13 as output
}

void loop() // Running as endless loop
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}</pre>

=== Digital input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Input.JPG|thumb|none|300px|Arduino-Example-Digital-Input]] </li>
</ul></div>

This is the simplest form of an input with only two possible states: on or off.
This example reads out a simple switch or button at pin 2. When the switch is closed and the input pin is HIGH, the LED is turned on.
<pre>int ledPin = 13; // Output pin for the LED
int inPin = 2; // Input pin for a switch

void setup()
{
pinMode(ledPin, OUTPUT); // declares LED as output
pinMode(inPin, INPUT); // declares switch as input
}
void loop()
if (digitalRead(inPin) == HIGH) // check if this is the HIGH input
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}
}</pre>

=== analog PWM output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

Pulse width modulation (PWM) is a method of simulating analog outputs by pulsing the output voltage. This allows you to make an LED brighter or darker or check a servomotor later. The following example uses a loop to slowly make an LED brighter and darker.

<pre>int ledPin = 9; // PWM Pin for the LED

void setup(){} // No setup necessary

void loop()
{
for (int i=0; i<=255; i++) // ascending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}

for (int i=255; i>=0; i--) // descending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}
}</pre>

=== potentiometer Input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

With a potentiometer and one of the analog-digital converter (ADC) inputs of the Arduino it is possible to read analog values from 0-1024. The following example uses a potentiometer to control the blinking rate of an LED.

<pre>int potPin = 0; // Input pin for the potentiometer
int ledPin = 13; // Output pin for the LED

void setup()
{
pinMode(ledPin, OUTPUT); // declare ledPin as OUTPUT
}

void loop()
{
digitalWrite(ledPin, HIGH); // switches on ledPin
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
digitalWrite(ledPin, LOW); // switches ledPin off
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
}</pre>

== Used Hardware ==
&emsp;➠ [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

&emsp;➠ [[ARDUINO Wireless Proto Shield]]

&emsp;➠ [[Arduino MKR WAN 1300 LoRa]]

&emsp;➠ [[Arduino MKR LoRa Gateway Pro]]

== References ==
&emsp;➠ https://www.elektronik-kompendium.de/sites/com/1810231.htm

&emsp;➠ http://myhomearchiv.synology.me/download/Anleitung_Furduino.pdf

&emsp;➠ https://starthardware.org/arduino-uno/

&emsp;➠ https://starthardware.org/category/projekte/arduino-projekte/

&emsp;➠ http://www.netzmafia.de/skripten/hardware/Arduino/Arduino_Programmierhandbuch.pdf

[[Category:Documentation]]

Arduino Board Uno Rev3-Atmega 328: Programming Guide

2020-08-10T20:42:20Z

CCinay: /* Struktur */

<div style="max-width: 970px">

== Summary ==
The <b>Arduino IDE</b> is a cross-platform Java application that acts as a program code editor and compiler and is also able to send firmware serially to the board. The development environment is based on Processing, an IDE designed to program artists, who normally do not have much contact with the art world programming environments. The programming language is based on Wiring, a C similar language which has a similar scope for a more restricted board design, whose IDE is also based on processing. Make sure you have an updated version of <b>[https://www.arduino.cc/en/Main/Software Arduino IDE]</b> installed.

== Struktur ==
The basic structure of the Arduino programming language is relatively simple and is divided into at least two parts. These two required parts or functions enclose blocks of statements.

<pre>void setup() { // put your setup code here, to run once:
}
void loop() { // put your main code here, to run repeatedly:
}</pre>

&emsp;➥ Here <b>setup()</b> is the preparation and <b>loop()</b> is the execution. Both functions are necessary to execute the program.

&emsp;➥ The setup function should follow the variable definition, which must be listed before. Setup must be run through as the first function in a program. <br>&emsp;&emsp; It is executed only once and is used to set <b>PinMode</b> or to initiate serial communication.

&emsp;➥ The <b>setup()</b> function is called once when the program starts. Use this function to set PinModes or start serial communication. The <b>setup()</b> function must <br>&emsp;&emsp; appear in every program, even if it does not contain any instructions.

&emsp;➥ After the <b>setup()</b> function follows the <b>loop()</b> function. It contains program code that is executed continuously in an infinite loop - read inputs, trigger <br>&emsp;&emsp; outputs, etc. This function is the core of all Arduino programs and does the main work.

=== setup() ===
The <b>setup()</b> function is called once when the program starts. Use this function to set <b>PinModes</b> or start serial communication.
The <b>setup()</b> function must appear in every program, even if it does not contain any instructions.

<pre>void setup()
{
pinMode(pin, OUTPUT); // 'pin' define as output
}</pre>

=== loop() ===
After running through the <b>setup() function</b>, the <b>loop() function</b> does exactly what its name suggests and runs in an endless loop. This allows the program to interact with the Arduino board via changes, reactions and controls.
<pre>void loop()
{
digitalWrite(pin, HIGH); // switches 'pin' on
delay(1000); // Pause for one second
digitalWrite(pin, LOW); // switches 'pin' off
delay(1000); // Pause for one second
}</pre>

=== Functions ===
A function is a block of program code that has a name and a set of instructions that are executed when the function is called. The functions <b>void setup()</b> and <b>void loop()</b> have already been explained. There are more built-in functions that will be discussed later.

<pre>Type FunctionName(parameter)
{
instructions;
}</pre>

The following integer type function ''delayVal()'' is used to insert a delay value into a program by reading a potentiometer. First a local variable 'v' is created. Next, 'v' is equated with the position of the potentiometer, which can have a value between 0 and 1023. The value is then divided by 4 to get a scale from 0 to 255 and at the end the result of the function is returned to the main program.

<pre>int delayVal()
{
int v; // create temporary variable 'v
v = analogRead(pot); // read potentiometer Value
v /= 4; // Convert from 0-1023 to 0-255
return v; // return the calculated value
}</pre>

=== {} curly brackets ===
Curly brackets (also called 'curly brackets') define the start and end of function and statement blocks as in the 'void loop()' function and also in the 'for' and 'if' statement.

<pre>type function()
{
instructions;
}</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: An opening curved bracket '{' must always be followed by a closing curved bracket '}'. Here it is often said that the number of brackets must be balanced. Unbalanced parentheses often lead to cryptic, inscrutable errors in the compiler, which are sometimes hard to find, especially in large programs.

The Arduino programming environment helps to check that the curved brackets are balanced. To do this, simply select a brace or click just behind it, and the logically connected counterpart is highlighted. </div>

=== ;semicolon ===
A semicolon must be used at the end of a statement and is used to separate the elements of a program.
A semicolon is also used to separate the elements of a for loop.

<pre>int x = 13; // declares variable 'x' as integer with value 13</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Forgetting a semicolon at the end of a line leads to an error in the compiler. The error description can be very clear and directly point to the missing semicolon, but this does not have to be the case. If an inscrutable or apparently illogical error is reported, the first thing to do is to add missing semicolons near the reported error. </div>

=== /*... */ block comments ===
Block comments or multiline comments are text areas that are ignored by the program. They are used for longer descriptions or comments and help other authors to understand program parts. They start with /* and end with */ and can cover several lines.

<pre>/* This is an inserted block comment
please do not forget the closing comment -
These must be balanced
*/</pre>

=== // Single line comments ===
Simple single-line comments are defined with a // at the beginning of the line and end with the end of the line. They are ignored by the program and do not consume memory.
<pre>// this is a single line comment</pre>

== Variables ==
A variable is the name of a numeric value with a name and memory location for later use in a program. A variable must be declared and optionally provided with a value. The following example declares a variable 'inputVariable' and assigns the value of analog pin 2 to it:
<pre>int inputVariable = 0; // declares a variable and
// sets its value to 0
inputVariable = analogRead(2); // sets the value of the variable equal
// with the value of analog pin 2 </pre>

'inputVariable' is the variable itself. The first line explains that its data type is 'int', which is the short expression for integer. The second line gives the variable the value of the analog pin 2, making the value of the pin available everywhere in the code.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Variables should always have descriptive names as clearly as possible to make the code easier to read.</div>

=== Declaration of variables: ===
All variables must be declared before use. Declaring a variable means defining its type such as int, long, float, etc., giving it a name and optionally an initial value.This only needs to be done once in the program. Afterwards the value can be changed at any time by calculations or various assignments.

The following example declares 'inputVariable' as 'int', i.e. integer data type and sets the initial value to 0. This is called a 'simple assignment'.
<pre>int inputVariable = 0;</pre>

A variable can be declared at many places in the program. The location of the declaration determines which program parts have access to the variable.

== Data types ==
&emsp;➥ <b>byte</b>: Byte stores an 8-bit numeric, integer value without decimal point. The value can be between 0 and 255.
<pre>byte someVariable = 180; // declares 'someVariable
// as a 'byte' data type </pre>

&emsp;➥ <b>int</b>: Integers are the most common data type for storing integer values without decimal point. Its value is 16 bits and ranges from -32,767 to 32,768.
<pre>int someVariable = 1500; // declares 'someVariable
// as an 'integer' data type</pre>

&emsp;➥ <b>long</b>: Data type for long integers with extended size, without decimal point, stored in a 32-bit value in a spectrum from -2,147,483,648 to 2,147,483,647
<pre>long someVariable = 90000; // declares 'someVariable
// as a 'long' data type </pre>

&emsp;➥ <b>float</b>: A data type for floating point values or numbers with decimal places. Floating point numbers have a better resolution than integers and are<br>&emsp;&emsp; expressed as 32-bit values with a spectrum from -3.4028235E+38 to 3.4028235E+38.
<pre>float someVariable = 3.14; // declares 'someVariable'
// as a 'float' data type </pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Floating point numbers are not precise and may lead to strange results when compared. Also, floating-point calculations are much slower than with integer data types. Calculations with floating-point values should be avoided if possible. </div>

&emsp;➥ <b>arrays</b>: An array is a collection of values that are accessed with an index number.
Each value in the array can be accessed by retrieving the name of<br>&emsp;&emsp; the array and the index number of the value. The index number always starts at 0 for an array.<br>&emsp;&emsp; An array must be declared and optionally assigned values before it can be used.
<pre>int myArray[] = {value0, value1, value2...} </pre>

In the same way it is possible to declare an array first with datatype and size and later to give a value to an index position.
<pre>int myArray[5]; // declare datatype 'integer' as array with 5 Positions
myArray[3] = 10; // gives the 4th index the value 10 </pre>

To read the value of an array you can simply assign it to a variable specifying the array and the index position.
<pre>x = myArray[3]; // x now has the value 10 </pre>

Arrays are often used for loops, where the counter of the loop is also used as index position for the values in the array. The following example uses an array to make an LED flicker. With a for loop and a counter starting at 0 an index position in the array is read, sent to the LED pin, paused for 200ms and then the same is done with the next index position.
<pre>int ledPin = 10; // LED on pin 10
byte flicker[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array with 8 different values
void setup()
{
pinMode(ledPin, OUTPUT); // Sets the OUTPUT pin
}

void loop()
{
for(int i=0; i<7; i++) // loop equals the number
{ // of the values in the array
analogWrite(ledPin, flicker[i]); // writes the index value to the LED
delay(200); // 200ms pause
}
}</pre>

== Digitaler Input - Output ==
=== pinMode(pin,mode) ===
Used in 'void setup()' to configure a specific pin as either input or output.
<pre>pinMode(pin, OUTPUT); // sets 'pin' as output </pre>

Arduino digital pins are inputs by default, so they don't need to be specified as inputs with 'pinMode()'. Pins configured as inputs have a high impedance state.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: There are also comfortable 20 k 'pullup' resistors in the ATmega chip which are accessible via software.</div>

These built-in 'pullup' resistors can be accessed in the following way:
<pre>pinMode(pin, INPUT); // sets 'pin' as input
digitalWrite(pin, HIGH); // switches on the 'Pullup' resistor</pre>

&emsp;➥ Pullup resistors are normally used to connect inputs like switches. In the example shown here it is noticeable that the pin is not defined as an output<br>&emsp;&emsp; although it is written to. It is only the method to activate the internal 'pullup' resistor.

&emsp;➥ Pins configured as output are in a low impedance state and can be loaded with a maximum of 40 mAmpere current from connected elements<br>&emsp;&emsp; and circuits. This is enough to make an LED light up (don't forget the serial resistor), but not enough to drive most relays, solenoids or motors.

&emsp;➥ Short circuits at the Arduino pins as well as too high current can destroy the output pin or even the whole ATmega chip. For this reason it is a good idea<br>&emsp;&emsp; to connect an output pin with external elements in series with a 470 or 1K resistor to
switch.

=== digitalRead(pin) ===
digitalRead(pin)' reads the value from a specified digital pin, with the result either HIGH or LOW. The pin can be set either as a variable or constant (0-13).
<pre>value = digitalRead(Pin); // sets 'value' equal to the input pin </pre>

digitalWrite(pin,value)
Outputs either logic level HIGH or LOW at a specified pin. The pin can be set as a variable or constant (0-13).
<pre>digitalWrite(pin, HIGH); // sets 'pin' to high</pre>

The following example reads a button on a digital input and switches an LED on when the button is pressed:
<pre>int led = 13; // LED connected to pin 13
int pin = 7; // Button connected to pin 7
int value = 0; // Variable to store the readout value

void setup()
{
pinMode(led, OUTPUT); // defines pin 13 as output
pinMode(pin, INPUT); // sets pin 7 as input
}

void loop()
{
value = digitalRead(pin); // sets 'value' equal to
// the input pin
digitalWrite(led, value); // sets 'led' equal to the
} // Value of the button</pre>

== Analoger Input - Output ==
=== analogRead(pin) ===
Reads the value of a specified analog pin with a 10 bit resolution. This function is only available for pins (0-5). The resulting integer values have a spectrum from 0 to 1023.
<pre>value = analogRead(pin); // sets 'value' equal to 'pin</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Unlike digital pins, analog pins do not have to be declared as input or output first. </div>

=== analogWrite(pin, value) ===
Writes pseudo-analog values to an output pin using hardware-based pulse width modulation (PWM). On newer Arduino boards with the ATmega 168 chip this function is applicable to pins 3, 5, 6, 9, 10 and 11. Older Arduinos with the ATmega8 only support pins 9,10 and 11. The value can be set as a variable or constant in the range 0-255.
<pre>analogWrite(pin, value); // writes 'value' to the analog 'pin </pre>

A value of 0 generates a uniform voltage of 0 volts at a fixed pin; a value of 255 generates a uniform voltage of 5 volts at a fixed pin. For values between 0 and 255, the pin changes very quickly between 0 and 5 volts - the higher the value, the longer the pin is HIGH (5 volts). For a value of 64, the pin is at 0 volts for three-quarters of the time and at 5 volts for one-quarter of the time. A value of 128 means that the output voltage is HIGH half of the time and LOW the other half. A value of 192 means that the voltage at the pin measures 0 volts at one quarter of the time and the full 5 volts at three quarters of the time.

Because this is a hardware-based function, the constant wave runs independently of the program until the next change of state via analogWrite (or a call to digitalRead or digitalWrite on the same pin).

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: In contrast to digital pins, analog pins do not have to be declared as input or output before. </div>

&emsp;➥ The following example reads an analog value from 'pin', converts the value by dividing it by 4 and then outputs it as a PWM signal to 'led'.

<pre>int led = 10; // LED with 220 resistor at pin 10
int pin = 0; // Potentiometer at analog pin 0
int value; // Value for readout

void setup(){} // no setup required

void loop()
{
value = analogRead(pin); // sets 'value' equal to 'pin
value /= 4; // converts 0-1023 into 0-255
analogWrite(led, value); // outputs the PWM signal 'led
}</pre>

== Random functions ==
=== randomSeed(seed) ===
Sets a value or 'Seed' as starting point for the random() function.
<pre>randomSeed(value); // sets 'value' as the random seed</pre>

The Arduino itself is not able to produce a truly random value. With randomSeed() a variable can be used as 'seed' to get better random results. For example, millis() or analogRead() can be used as a seed variable or function to use electrical noise through the analog pin as an output for random values.

=== random(min, max) ===
The random function allows the generation of pseudo-random values within a defined range of minimum and maxium values.
<pre>value = random(100, 200); // sets 'value' with a random number
// between 100 and 200 equal </pre>

The following example generates a random value between 0 and 255 and outputs it as PWM signal on a PWM pin.
<pre>int randNumber; // Variable to store the random value
int led = 10; // LED with 220 Ohm resistor at pin 10

void setup() {} // no setup necessary

void loop()
{
randomSeed(millis()); // uses millis() as seed
randNumber = random(255); // Random number in the range 0-255
analogWrite(led, randNumber); // PWM signal as output
delay(500); // half second pause
}</pre>

== Serial communication ==
=== Serial.begin(rate) ===
Serial.begin(rate)' Opens the serial port and sets the baud rate for the serial transmission. The typical baud rate with the computer is 9600 baud. Other speeds are also supported.
<pre>void setup()
{
Serial.begin(9600); // opens serial port
} // sets the data rate to 9600 bps</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: When using serial communication, digital pins 0 (RX) and 1 (TX) cannot be used at the same time. </div>

=== Serial.println(data) ===
Writes data to the serial port, followed by an automatic line break as carrier return and line feed. This function has the same form as 'Serial.print()', but is easier to read on the serial monitor.
<pre>Serial.println(analogValue); // sends the value of 'analogValue'</pre>

More detailed information about the numerous variants of the 'Serial.println()' and 'Serial.print()' functions can be found on the Arduino website.

The following simple example reads a value from analog pin 0 and sends the data to the computer once per second.
<pre>void setup()
{
Serial.begin(9600); // sets the data rate to 9600 bps
}

void loop()
{
Serial.println(analogRead(0)); // sends the analog value
delay(1000); // pauses for 1 second
}</pre>

== Examples ==
=== Digital output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Output.JPG|thumb|none|300px|Arduino-Example-Digital-Output]] </li>
</ul></div>

This is a simple 'Hello World' program and turns something on and off. In this example a LED is connected to PIN 13 and flashes every second. The resistor may be superfluous at this pin because the Arduino has a built-in resistor.
<pre>int ledPin = 13; // LED off digital pin 13

void setup() // will run through once
{
pinMode(ledPin, OUTPUT); // sets pin 13 as output
}

void loop() // Running as endless loop
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}</pre>

=== Digital input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Input.JPG|thumb|none|300px|Arduino-Example-Digital-Input]] </li>
</ul></div>

This is the simplest form of an input with only two possible states: on or off.
This example reads out a simple switch or button at pin 2. When the switch is closed and the input pin is HIGH, the LED is turned on.
<pre>int ledPin = 13; // Output pin for the LED
int inPin = 2; // Input pin for a switch

void setup()
{
pinMode(ledPin, OUTPUT); // declares LED as output
pinMode(inPin, INPUT); // declares switch as input
}
void loop()
if (digitalRead(inPin) == HIGH) // check if this is the HIGH input
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}
}</pre>

=== analog PWM output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

Pulse width modulation (PWM) is a method of simulating analog outputs by pulsing the output voltage. This allows you to make an LED brighter or darker or check a servomotor later. The following example uses a loop to slowly make an LED brighter and darker.

<pre>int ledPin = 9; // PWM Pin for the LED

void setup(){} // No setup necessary

void loop()
{
for (int i=0; i<=255; i++) // ascending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}

for (int i=255; i>=0; i--) // descending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}
}</pre>

=== potentiometer Input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

With a potentiometer and one of the analog-digital converter (ADC) inputs of the Arduino it is possible to read analog values from 0-1024. The following example uses a potentiometer to control the blinking rate of an LED.

<pre>int potPin = 0; // Input pin for the potentiometer
int ledPin = 13; // Output pin for the LED

void setup()
{
pinMode(ledPin, OUTPUT); // declare ledPin as OUTPUT
}

void loop()
{
digitalWrite(ledPin, HIGH); // switches on ledPin
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
digitalWrite(ledPin, LOW); // switches ledPin off
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
}</pre>

== Used Hardware ==
&emsp;➠ [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

&emsp;➠ [[ARDUINO Wireless Proto Shield]]

&emsp;➠ [[Arduino MKR WAN 1300 LoRa]]

&emsp;➠ [[Arduino MKR LoRa Gateway Pro]]

== References ==
&emsp;➠ https://www.elektronik-kompendium.de/sites/com/1810231.htm

&emsp;➠ http://myhomearchiv.synology.me/download/Anleitung_Furduino.pdf

&emsp;➠ https://starthardware.org/arduino-uno/

&emsp;➠ https://starthardware.org/category/projekte/arduino-projekte/

&emsp;➠ http://www.netzmafia.de/skripten/hardware/Arduino/Arduino_Programmierhandbuch.pdf

[[Category:Documentation]]

Arduino Board Uno Rev3-Atmega 328: Programming Guide

2020-08-10T20:35:43Z

CCinay: /* Summary */

<div style="max-width: 970px">

== Summary ==
The <b>Arduino IDE</b> is a cross-platform Java application that acts as a program code editor and compiler and is also able to send firmware serially to the board. The development environment is based on Processing, an IDE designed to program artists, who normally do not have much contact with the art world programming environments. The programming language is based on Wiring, a C similar language which has a similar scope for a more restricted board design, whose IDE is also based on processing. Make sure you have an updated version of <b>[https://www.arduino.cc/en/Main/Software Arduino IDE]</b> installed.

== Struktur ==
The basic structure of the Arduino programming language is relatively simple and is divided into at least two parts. These two required parts or functions enclose blocks of statements.

<pre> void setup() {
// put your setup code here, to run once:

}

void loop() {
// put your main code here, to run repeatedly:

} </pre>

&emsp;➥ Here setup() is the preparation and loop() is the execution. Both functions are necessary to execute the program.

&emsp;➥ The setup function should follow the variable definition, which must be listed before. Setup must be run through as the first function in a program. <br>&emsp;&emsp; It is executed only once and is used to set PinMode or to initiate serial communication.

&emsp;➥ The setup() function is called once when the program starts. Use this function to set PinModes or start serial communication. The setup() function must <br>&emsp;&emsp; appear in every program, even if it does not contain any instructions.

&emsp;➥ After the setup() function follows the loop() function. It contains program code that is executed continuously in an infinite loop - read inputs, trigger <br>&emsp;&emsp; outputs, etc. This function is the core of all Arduino programs and does the main work.

=== setup() ===
The setup() function is called once when the program starts. Use this function to set PinModes or start serial communication.
The setup() function must appear in every program, even if it does not contain any instructions.

<pre>void setup()
{
pinMode(pin, OUTPUT); // 'pin' define as output
}</pre>

=== loop() ===
After running through the setup() function, the loop() function does exactly what its name suggests and runs in an endless loop. This allows the program to interact with the Arduino board via changes, reactions and controls.
<pre>void loop()
{
digitalWrite(pin, HIGH); // switches 'pin' on
delay(1000); // Pause for one second
digitalWrite(pin, LOW); // switches 'pin' off
delay(1000); // Pause for one second
}</pre>

=== Functions ===
A function is a block of program code that has a name and a set of instructions that are executed when the function is called. The functions void setup() and void loop() have already been explained. There are more built-in functions that will be discussed later.

<pre>Type FunctionName(parameter)
{
instructions;
}</pre>

The following integer type function ''delayVal()'' is used to insert a delay value into a program by reading a potentiometer. First a local variable 'v' is created. Next, 'v' is equated with the position of the potentiometer, which can have a value between 0 and 1023. The value is then divided by 4 to get a scale from 0 to 255 and at the end the result of the function is returned to the main program.

<pre>int delayVal()
{
int v; // create temporary variable 'v
v = analogRead(pot); // read potentiometer Value
v /= 4; // Convert from 0-1023 to 0-255
return v; // return the calculated value
}</pre>

=== {} curly brackets ===
Curly brackets (also called 'curly brackets') define the start and end of function and statement blocks as in the 'void loop()' function and also in the 'for' and 'if' statement.

<pre>type function()
{
instructions;
}</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: An opening curved bracket '{' must always be followed by a closing curved bracket '}'. Here it is often said that the number of brackets must be balanced. Unbalanced parentheses often lead to cryptic, inscrutable errors in the compiler, which are sometimes hard to find, especially in large programs.

The Arduino programming environment helps to check that the curved brackets are balanced. To do this, simply select a brace or click just behind it, and the logically connected counterpart is highlighted. </div>

=== ;semicolon ===
A semicolon must be used at the end of a statement and is used to separate the elements of a program.
A semicolon is also used to separate the elements of a for loop.

<pre>int x = 13; // declares variable 'x' as integer with value 13</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Forgetting a semicolon at the end of a line leads to an error in the compiler. The error description can be very clear and directly point to the missing semicolon, but this does not have to be the case. If an inscrutable or apparently illogical error is reported, the first thing to do is to add missing semicolons near the reported error. </div>

=== /*... */ block comments ===
Block comments or multiline comments are text areas that are ignored by the program. They are used for longer descriptions or comments and help other authors to understand program parts. They start with /* and end with */ and can cover several lines.

<pre>/* This is an inserted block comment
please do not forget the closing comment -
These must be balanced
*/</pre>

=== // Single line comments ===
Simple single-line comments are defined with a // at the beginning of the line and end with the end of the line. They are ignored by the program and do not consume memory.
<pre>// this is a single line comment</pre>

== Variables ==
A variable is the name of a numeric value with a name and memory location for later use in a program. A variable must be declared and optionally provided with a value. The following example declares a variable 'inputVariable' and assigns the value of analog pin 2 to it:
<pre>int inputVariable = 0; // declares a variable and
// sets its value to 0
inputVariable = analogRead(2); // sets the value of the variable equal
// with the value of analog pin 2 </pre>

'inputVariable' is the variable itself. The first line explains that its data type is 'int', which is the short expression for integer. The second line gives the variable the value of the analog pin 2, making the value of the pin available everywhere in the code.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Variables should always have descriptive names as clearly as possible to make the code easier to read.</div>

=== Declaration of variables: ===
All variables must be declared before use. Declaring a variable means defining its type such as int, long, float, etc., giving it a name and optionally an initial value.This only needs to be done once in the program. Afterwards the value can be changed at any time by calculations or various assignments.

The following example declares 'inputVariable' as 'int', i.e. integer data type and sets the initial value to 0. This is called a 'simple assignment'.
<pre>int inputVariable = 0;</pre>

A variable can be declared at many places in the program. The location of the declaration determines which program parts have access to the variable.

== Data types ==
&emsp;➥ <b>byte</b>: Byte stores an 8-bit numeric, integer value without decimal point. The value can be between 0 and 255.
<pre>byte someVariable = 180; // declares 'someVariable
// as a 'byte' data type </pre>

&emsp;➥ <b>int</b>: Integers are the most common data type for storing integer values without decimal point. Its value is 16 bits and ranges from -32,767 to 32,768.
<pre>int someVariable = 1500; // declares 'someVariable
// as an 'integer' data type</pre>

&emsp;➥ <b>long</b>: Data type for long integers with extended size, without decimal point, stored in a 32-bit value in a spectrum from -2,147,483,648 to 2,147,483,647
<pre>long someVariable = 90000; // declares 'someVariable
// as a 'long' data type </pre>

&emsp;➥ <b>float</b>: A data type for floating point values or numbers with decimal places. Floating point numbers have a better resolution than integers and are<br>&emsp;&emsp; expressed as 32-bit values with a spectrum from -3.4028235E+38 to 3.4028235E+38.
<pre>float someVariable = 3.14; // declares 'someVariable'
// as a 'float' data type </pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Floating point numbers are not precise and may lead to strange results when compared. Also, floating-point calculations are much slower than with integer data types. Calculations with floating-point values should be avoided if possible. </div>

&emsp;➥ <b>arrays</b>: An array is a collection of values that are accessed with an index number.
Each value in the array can be accessed by retrieving the name of<br>&emsp;&emsp; the array and the index number of the value. The index number always starts at 0 for an array.<br>&emsp;&emsp; An array must be declared and optionally assigned values before it can be used.
<pre>int myArray[] = {value0, value1, value2...} </pre>

In the same way it is possible to declare an array first with datatype and size and later to give a value to an index position.
<pre>int myArray[5]; // declare datatype 'integer' as array with 5 Positions
myArray[3] = 10; // gives the 4th index the value 10 </pre>

To read the value of an array you can simply assign it to a variable specifying the array and the index position.
<pre>x = myArray[3]; // x now has the value 10 </pre>

Arrays are often used for loops, where the counter of the loop is also used as index position for the values in the array. The following example uses an array to make an LED flicker. With a for loop and a counter starting at 0 an index position in the array is read, sent to the LED pin, paused for 200ms and then the same is done with the next index position.
<pre>int ledPin = 10; // LED on pin 10
byte flicker[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array with 8 different values
void setup()
{
pinMode(ledPin, OUTPUT); // Sets the OUTPUT pin
}

void loop()
{
for(int i=0; i<7; i++) // loop equals the number
{ // of the values in the array
analogWrite(ledPin, flicker[i]); // writes the index value to the LED
delay(200); // 200ms pause
}
}</pre>

== Digitaler Input - Output ==
=== pinMode(pin,mode) ===
Used in 'void setup()' to configure a specific pin as either input or output.
<pre>pinMode(pin, OUTPUT); // sets 'pin' as output </pre>

Arduino digital pins are inputs by default, so they don't need to be specified as inputs with 'pinMode()'. Pins configured as inputs have a high impedance state.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: There are also comfortable 20 k 'pullup' resistors in the ATmega chip which are accessible via software.</div>

These built-in 'pullup' resistors can be accessed in the following way:
<pre>pinMode(pin, INPUT); // sets 'pin' as input
digitalWrite(pin, HIGH); // switches on the 'Pullup' resistor</pre>

&emsp;➥ Pullup resistors are normally used to connect inputs like switches. In the example shown here it is noticeable that the pin is not defined as an output<br>&emsp;&emsp; although it is written to. It is only the method to activate the internal 'pullup' resistor.

&emsp;➥ Pins configured as output are in a low impedance state and can be loaded with a maximum of 40 mAmpere current from connected elements<br>&emsp;&emsp; and circuits. This is enough to make an LED light up (don't forget the serial resistor), but not enough to drive most relays, solenoids or motors.

&emsp;➥ Short circuits at the Arduino pins as well as too high current can destroy the output pin or even the whole ATmega chip. For this reason it is a good idea<br>&emsp;&emsp; to connect an output pin with external elements in series with a 470 or 1K resistor to
switch.

=== digitalRead(pin) ===
digitalRead(pin)' reads the value from a specified digital pin, with the result either HIGH or LOW. The pin can be set either as a variable or constant (0-13).
<pre>value = digitalRead(Pin); // sets 'value' equal to the input pin </pre>

digitalWrite(pin,value)
Outputs either logic level HIGH or LOW at a specified pin. The pin can be set as a variable or constant (0-13).
<pre>digitalWrite(pin, HIGH); // sets 'pin' to high</pre>

The following example reads a button on a digital input and switches an LED on when the button is pressed:
<pre>int led = 13; // LED connected to pin 13
int pin = 7; // Button connected to pin 7
int value = 0; // Variable to store the readout value

void setup()
{
pinMode(led, OUTPUT); // defines pin 13 as output
pinMode(pin, INPUT); // sets pin 7 as input
}

void loop()
{
value = digitalRead(pin); // sets 'value' equal to
// the input pin
digitalWrite(led, value); // sets 'led' equal to the
} // Value of the button</pre>

== Analoger Input - Output ==
=== analogRead(pin) ===
Reads the value of a specified analog pin with a 10 bit resolution. This function is only available for pins (0-5). The resulting integer values have a spectrum from 0 to 1023.
<pre>value = analogRead(pin); // sets 'value' equal to 'pin</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Unlike digital pins, analog pins do not have to be declared as input or output first. </div>

=== analogWrite(pin, value) ===
Writes pseudo-analog values to an output pin using hardware-based pulse width modulation (PWM). On newer Arduino boards with the ATmega 168 chip this function is applicable to pins 3, 5, 6, 9, 10 and 11. Older Arduinos with the ATmega8 only support pins 9,10 and 11. The value can be set as a variable or constant in the range 0-255.
<pre>analogWrite(pin, value); // writes 'value' to the analog 'pin </pre>

A value of 0 generates a uniform voltage of 0 volts at a fixed pin; a value of 255 generates a uniform voltage of 5 volts at a fixed pin. For values between 0 and 255, the pin changes very quickly between 0 and 5 volts - the higher the value, the longer the pin is HIGH (5 volts). For a value of 64, the pin is at 0 volts for three-quarters of the time and at 5 volts for one-quarter of the time. A value of 128 means that the output voltage is HIGH half of the time and LOW the other half. A value of 192 means that the voltage at the pin measures 0 volts at one quarter of the time and the full 5 volts at three quarters of the time.

Because this is a hardware-based function, the constant wave runs independently of the program until the next change of state via analogWrite (or a call to digitalRead or digitalWrite on the same pin).

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: In contrast to digital pins, analog pins do not have to be declared as input or output before. </div>

&emsp;➥ The following example reads an analog value from 'pin', converts the value by dividing it by 4 and then outputs it as a PWM signal to 'led'.

<pre>int led = 10; // LED with 220 resistor at pin 10
int pin = 0; // Potentiometer at analog pin 0
int value; // Value for readout

void setup(){} // no setup required

void loop()
{
value = analogRead(pin); // sets 'value' equal to 'pin
value /= 4; // converts 0-1023 into 0-255
analogWrite(led, value); // outputs the PWM signal 'led
}</pre>

== Random functions ==
=== randomSeed(seed) ===
Sets a value or 'Seed' as starting point for the random() function.
<pre>randomSeed(value); // sets 'value' as the random seed</pre>

The Arduino itself is not able to produce a truly random value. With randomSeed() a variable can be used as 'seed' to get better random results. For example, millis() or analogRead() can be used as a seed variable or function to use electrical noise through the analog pin as an output for random values.

=== random(min, max) ===
The random function allows the generation of pseudo-random values within a defined range of minimum and maxium values.
<pre>value = random(100, 200); // sets 'value' with a random number
// between 100 and 200 equal </pre>

The following example generates a random value between 0 and 255 and outputs it as PWM signal on a PWM pin.
<pre>int randNumber; // Variable to store the random value
int led = 10; // LED with 220 Ohm resistor at pin 10

void setup() {} // no setup necessary

void loop()
{
randomSeed(millis()); // uses millis() as seed
randNumber = random(255); // Random number in the range 0-255
analogWrite(led, randNumber); // PWM signal as output
delay(500); // half second pause
}</pre>

== Serial communication ==
=== Serial.begin(rate) ===
Serial.begin(rate)' Opens the serial port and sets the baud rate for the serial transmission. The typical baud rate with the computer is 9600 baud. Other speeds are also supported.
<pre>void setup()
{
Serial.begin(9600); // opens serial port
} // sets the data rate to 9600 bps</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: When using serial communication, digital pins 0 (RX) and 1 (TX) cannot be used at the same time. </div>

=== Serial.println(data) ===
Writes data to the serial port, followed by an automatic line break as carrier return and line feed. This function has the same form as 'Serial.print()', but is easier to read on the serial monitor.
<pre>Serial.println(analogValue); // sends the value of 'analogValue'</pre>

More detailed information about the numerous variants of the 'Serial.println()' and 'Serial.print()' functions can be found on the Arduino website.

The following simple example reads a value from analog pin 0 and sends the data to the computer once per second.
<pre>void setup()
{
Serial.begin(9600); // sets the data rate to 9600 bps
}

void loop()
{
Serial.println(analogRead(0)); // sends the analog value
delay(1000); // pauses for 1 second
}</pre>

== Examples ==
=== Digital output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Output.JPG|thumb|none|300px|Arduino-Example-Digital-Output]] </li>
</ul></div>

This is a simple 'Hello World' program and turns something on and off. In this example a LED is connected to PIN 13 and flashes every second. The resistor may be superfluous at this pin because the Arduino has a built-in resistor.
<pre>int ledPin = 13; // LED off digital pin 13

void setup() // will run through once
{
pinMode(ledPin, OUTPUT); // sets pin 13 as output
}

void loop() // Running as endless loop
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}</pre>

=== Digital input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Input.JPG|thumb|none|300px|Arduino-Example-Digital-Input]] </li>
</ul></div>

This is the simplest form of an input with only two possible states: on or off.
This example reads out a simple switch or button at pin 2. When the switch is closed and the input pin is HIGH, the LED is turned on.
<pre>int ledPin = 13; // Output pin for the LED
int inPin = 2; // Input pin for a switch

void setup()
{
pinMode(ledPin, OUTPUT); // declares LED as output
pinMode(inPin, INPUT); // declares switch as input
}
void loop()
if (digitalRead(inPin) == HIGH) // check if this is the HIGH input
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}
}</pre>

=== analog PWM output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

Pulse width modulation (PWM) is a method of simulating analog outputs by pulsing the output voltage. This allows you to make an LED brighter or darker or check a servomotor later. The following example uses a loop to slowly make an LED brighter and darker.

<pre>int ledPin = 9; // PWM Pin for the LED

void setup(){} // No setup necessary

void loop()
{
for (int i=0; i<=255; i++) // ascending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}

for (int i=255; i>=0; i--) // descending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}
}</pre>

=== potentiometer Input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

With a potentiometer and one of the analog-digital converter (ADC) inputs of the Arduino it is possible to read analog values from 0-1024. The following example uses a potentiometer to control the blinking rate of an LED.

<pre>int potPin = 0; // Input pin for the potentiometer
int ledPin = 13; // Output pin for the LED

void setup()
{
pinMode(ledPin, OUTPUT); // declare ledPin as OUTPUT
}

void loop()
{
digitalWrite(ledPin, HIGH); // switches on ledPin
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
digitalWrite(ledPin, LOW); // switches ledPin off
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
}</pre>

== Used Hardware ==
&emsp;➠ [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

&emsp;➠ [[ARDUINO Wireless Proto Shield]]

&emsp;➠ [[Arduino MKR WAN 1300 LoRa]]

&emsp;➠ [[Arduino MKR LoRa Gateway Pro]]

== References ==
&emsp;➠ https://www.elektronik-kompendium.de/sites/com/1810231.htm

&emsp;➠ http://myhomearchiv.synology.me/download/Anleitung_Furduino.pdf

&emsp;➠ https://starthardware.org/arduino-uno/

&emsp;➠ https://starthardware.org/category/projekte/arduino-projekte/

&emsp;➠ http://www.netzmafia.de/skripten/hardware/Arduino/Arduino_Programmierhandbuch.pdf

[[Category:Documentation]]

Arduino Board Uno Rev3-Atmega 328: Programming Guide

2020-08-10T20:34:57Z

CCinay: /* random(min, max) */

<div style="max-width: 970px">

== Summary ==
The Arduino IDE is a cross-platform Java application that acts as a program code editor and compiler and is also able to send firmware serially to the board. The development environment is based on Processing, an IDE designed to program artists, who normally do not have much contact with the art world programming environments. The programming language is based on Wiring, a C similar language which has a similar scope for a more restricted board design, whose IDE is also based on processing. Make sure you have an updated version of [https://www.arduino.cc/en/Main/Software Arduino IDE] installed.

== Struktur ==
The basic structure of the Arduino programming language is relatively simple and is divided into at least two parts. These two required parts or functions enclose blocks of statements.

<pre> void setup() {
// put your setup code here, to run once:

}

void loop() {
// put your main code here, to run repeatedly:

} </pre>

&emsp;➥ Here setup() is the preparation and loop() is the execution. Both functions are necessary to execute the program.

&emsp;➥ The setup function should follow the variable definition, which must be listed before. Setup must be run through as the first function in a program. <br>&emsp;&emsp; It is executed only once and is used to set PinMode or to initiate serial communication.

&emsp;➥ The setup() function is called once when the program starts. Use this function to set PinModes or start serial communication. The setup() function must <br>&emsp;&emsp; appear in every program, even if it does not contain any instructions.

&emsp;➥ After the setup() function follows the loop() function. It contains program code that is executed continuously in an infinite loop - read inputs, trigger <br>&emsp;&emsp; outputs, etc. This function is the core of all Arduino programs and does the main work.

=== setup() ===
The setup() function is called once when the program starts. Use this function to set PinModes or start serial communication.
The setup() function must appear in every program, even if it does not contain any instructions.

<pre>void setup()
{
pinMode(pin, OUTPUT); // 'pin' define as output
}</pre>

=== loop() ===
After running through the setup() function, the loop() function does exactly what its name suggests and runs in an endless loop. This allows the program to interact with the Arduino board via changes, reactions and controls.
<pre>void loop()
{
digitalWrite(pin, HIGH); // switches 'pin' on
delay(1000); // Pause for one second
digitalWrite(pin, LOW); // switches 'pin' off
delay(1000); // Pause for one second
}</pre>

=== Functions ===
A function is a block of program code that has a name and a set of instructions that are executed when the function is called. The functions void setup() and void loop() have already been explained. There are more built-in functions that will be discussed later.

<pre>Type FunctionName(parameter)
{
instructions;
}</pre>

The following integer type function ''delayVal()'' is used to insert a delay value into a program by reading a potentiometer. First a local variable 'v' is created. Next, 'v' is equated with the position of the potentiometer, which can have a value between 0 and 1023. The value is then divided by 4 to get a scale from 0 to 255 and at the end the result of the function is returned to the main program.

<pre>int delayVal()
{
int v; // create temporary variable 'v
v = analogRead(pot); // read potentiometer Value
v /= 4; // Convert from 0-1023 to 0-255
return v; // return the calculated value
}</pre>

=== {} curly brackets ===
Curly brackets (also called 'curly brackets') define the start and end of function and statement blocks as in the 'void loop()' function and also in the 'for' and 'if' statement.

<pre>type function()
{
instructions;
}</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: An opening curved bracket '{' must always be followed by a closing curved bracket '}'. Here it is often said that the number of brackets must be balanced. Unbalanced parentheses often lead to cryptic, inscrutable errors in the compiler, which are sometimes hard to find, especially in large programs.

The Arduino programming environment helps to check that the curved brackets are balanced. To do this, simply select a brace or click just behind it, and the logically connected counterpart is highlighted. </div>

=== ;semicolon ===
A semicolon must be used at the end of a statement and is used to separate the elements of a program.
A semicolon is also used to separate the elements of a for loop.

<pre>int x = 13; // declares variable 'x' as integer with value 13</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Forgetting a semicolon at the end of a line leads to an error in the compiler. The error description can be very clear and directly point to the missing semicolon, but this does not have to be the case. If an inscrutable or apparently illogical error is reported, the first thing to do is to add missing semicolons near the reported error. </div>

=== /*... */ block comments ===
Block comments or multiline comments are text areas that are ignored by the program. They are used for longer descriptions or comments and help other authors to understand program parts. They start with /* and end with */ and can cover several lines.

<pre>/* This is an inserted block comment
please do not forget the closing comment -
These must be balanced
*/</pre>

=== // Single line comments ===
Simple single-line comments are defined with a // at the beginning of the line and end with the end of the line. They are ignored by the program and do not consume memory.
<pre>// this is a single line comment</pre>

== Variables ==
A variable is the name of a numeric value with a name and memory location for later use in a program. A variable must be declared and optionally provided with a value. The following example declares a variable 'inputVariable' and assigns the value of analog pin 2 to it:
<pre>int inputVariable = 0; // declares a variable and
// sets its value to 0
inputVariable = analogRead(2); // sets the value of the variable equal
// with the value of analog pin 2 </pre>

'inputVariable' is the variable itself. The first line explains that its data type is 'int', which is the short expression for integer. The second line gives the variable the value of the analog pin 2, making the value of the pin available everywhere in the code.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Variables should always have descriptive names as clearly as possible to make the code easier to read.</div>

=== Declaration of variables: ===
All variables must be declared before use. Declaring a variable means defining its type such as int, long, float, etc., giving it a name and optionally an initial value.This only needs to be done once in the program. Afterwards the value can be changed at any time by calculations or various assignments.

The following example declares 'inputVariable' as 'int', i.e. integer data type and sets the initial value to 0. This is called a 'simple assignment'.
<pre>int inputVariable = 0;</pre>

A variable can be declared at many places in the program. The location of the declaration determines which program parts have access to the variable.

== Data types ==
&emsp;➥ <b>byte</b>: Byte stores an 8-bit numeric, integer value without decimal point. The value can be between 0 and 255.
<pre>byte someVariable = 180; // declares 'someVariable
// as a 'byte' data type </pre>

&emsp;➥ <b>int</b>: Integers are the most common data type for storing integer values without decimal point. Its value is 16 bits and ranges from -32,767 to 32,768.
<pre>int someVariable = 1500; // declares 'someVariable
// as an 'integer' data type</pre>

&emsp;➥ <b>long</b>: Data type for long integers with extended size, without decimal point, stored in a 32-bit value in a spectrum from -2,147,483,648 to 2,147,483,647
<pre>long someVariable = 90000; // declares 'someVariable
// as a 'long' data type </pre>

&emsp;➥ <b>float</b>: A data type for floating point values or numbers with decimal places. Floating point numbers have a better resolution than integers and are<br>&emsp;&emsp; expressed as 32-bit values with a spectrum from -3.4028235E+38 to 3.4028235E+38.
<pre>float someVariable = 3.14; // declares 'someVariable'
// as a 'float' data type </pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Floating point numbers are not precise and may lead to strange results when compared. Also, floating-point calculations are much slower than with integer data types. Calculations with floating-point values should be avoided if possible. </div>

&emsp;➥ <b>arrays</b>: An array is a collection of values that are accessed with an index number.
Each value in the array can be accessed by retrieving the name of<br>&emsp;&emsp; the array and the index number of the value. The index number always starts at 0 for an array.<br>&emsp;&emsp; An array must be declared and optionally assigned values before it can be used.
<pre>int myArray[] = {value0, value1, value2...} </pre>

In the same way it is possible to declare an array first with datatype and size and later to give a value to an index position.
<pre>int myArray[5]; // declare datatype 'integer' as array with 5 Positions
myArray[3] = 10; // gives the 4th index the value 10 </pre>

To read the value of an array you can simply assign it to a variable specifying the array and the index position.
<pre>x = myArray[3]; // x now has the value 10 </pre>

Arrays are often used for loops, where the counter of the loop is also used as index position for the values in the array. The following example uses an array to make an LED flicker. With a for loop and a counter starting at 0 an index position in the array is read, sent to the LED pin, paused for 200ms and then the same is done with the next index position.
<pre>int ledPin = 10; // LED on pin 10
byte flicker[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array with 8 different values
void setup()
{
pinMode(ledPin, OUTPUT); // Sets the OUTPUT pin
}

void loop()
{
for(int i=0; i<7; i++) // loop equals the number
{ // of the values in the array
analogWrite(ledPin, flicker[i]); // writes the index value to the LED
delay(200); // 200ms pause
}
}</pre>

== Digitaler Input - Output ==
=== pinMode(pin,mode) ===
Used in 'void setup()' to configure a specific pin as either input or output.
<pre>pinMode(pin, OUTPUT); // sets 'pin' as output </pre>

Arduino digital pins are inputs by default, so they don't need to be specified as inputs with 'pinMode()'. Pins configured as inputs have a high impedance state.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: There are also comfortable 20 k 'pullup' resistors in the ATmega chip which are accessible via software.</div>

These built-in 'pullup' resistors can be accessed in the following way:
<pre>pinMode(pin, INPUT); // sets 'pin' as input
digitalWrite(pin, HIGH); // switches on the 'Pullup' resistor</pre>

&emsp;➥ Pullup resistors are normally used to connect inputs like switches. In the example shown here it is noticeable that the pin is not defined as an output<br>&emsp;&emsp; although it is written to. It is only the method to activate the internal 'pullup' resistor.

&emsp;➥ Pins configured as output are in a low impedance state and can be loaded with a maximum of 40 mAmpere current from connected elements<br>&emsp;&emsp; and circuits. This is enough to make an LED light up (don't forget the serial resistor), but not enough to drive most relays, solenoids or motors.

&emsp;➥ Short circuits at the Arduino pins as well as too high current can destroy the output pin or even the whole ATmega chip. For this reason it is a good idea<br>&emsp;&emsp; to connect an output pin with external elements in series with a 470 or 1K resistor to
switch.

=== digitalRead(pin) ===
digitalRead(pin)' reads the value from a specified digital pin, with the result either HIGH or LOW. The pin can be set either as a variable or constant (0-13).
<pre>value = digitalRead(Pin); // sets 'value' equal to the input pin </pre>

digitalWrite(pin,value)
Outputs either logic level HIGH or LOW at a specified pin. The pin can be set as a variable or constant (0-13).
<pre>digitalWrite(pin, HIGH); // sets 'pin' to high</pre>

The following example reads a button on a digital input and switches an LED on when the button is pressed:
<pre>int led = 13; // LED connected to pin 13
int pin = 7; // Button connected to pin 7
int value = 0; // Variable to store the readout value

void setup()
{
pinMode(led, OUTPUT); // defines pin 13 as output
pinMode(pin, INPUT); // sets pin 7 as input
}

void loop()
{
value = digitalRead(pin); // sets 'value' equal to
// the input pin
digitalWrite(led, value); // sets 'led' equal to the
} // Value of the button</pre>

== Analoger Input - Output ==
=== analogRead(pin) ===
Reads the value of a specified analog pin with a 10 bit resolution. This function is only available for pins (0-5). The resulting integer values have a spectrum from 0 to 1023.
<pre>value = analogRead(pin); // sets 'value' equal to 'pin</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Unlike digital pins, analog pins do not have to be declared as input or output first. </div>

=== analogWrite(pin, value) ===
Writes pseudo-analog values to an output pin using hardware-based pulse width modulation (PWM). On newer Arduino boards with the ATmega 168 chip this function is applicable to pins 3, 5, 6, 9, 10 and 11. Older Arduinos with the ATmega8 only support pins 9,10 and 11. The value can be set as a variable or constant in the range 0-255.
<pre>analogWrite(pin, value); // writes 'value' to the analog 'pin </pre>

A value of 0 generates a uniform voltage of 0 volts at a fixed pin; a value of 255 generates a uniform voltage of 5 volts at a fixed pin. For values between 0 and 255, the pin changes very quickly between 0 and 5 volts - the higher the value, the longer the pin is HIGH (5 volts). For a value of 64, the pin is at 0 volts for three-quarters of the time and at 5 volts for one-quarter of the time. A value of 128 means that the output voltage is HIGH half of the time and LOW the other half. A value of 192 means that the voltage at the pin measures 0 volts at one quarter of the time and the full 5 volts at three quarters of the time.

Because this is a hardware-based function, the constant wave runs independently of the program until the next change of state via analogWrite (or a call to digitalRead or digitalWrite on the same pin).

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: In contrast to digital pins, analog pins do not have to be declared as input or output before. </div>

&emsp;➥ The following example reads an analog value from 'pin', converts the value by dividing it by 4 and then outputs it as a PWM signal to 'led'.

<pre>int led = 10; // LED with 220 resistor at pin 10
int pin = 0; // Potentiometer at analog pin 0
int value; // Value for readout

void setup(){} // no setup required

void loop()
{
value = analogRead(pin); // sets 'value' equal to 'pin
value /= 4; // converts 0-1023 into 0-255
analogWrite(led, value); // outputs the PWM signal 'led
}</pre>

== Random functions ==
=== randomSeed(seed) ===
Sets a value or 'Seed' as starting point for the random() function.
<pre>randomSeed(value); // sets 'value' as the random seed</pre>

The Arduino itself is not able to produce a truly random value. With randomSeed() a variable can be used as 'seed' to get better random results. For example, millis() or analogRead() can be used as a seed variable or function to use electrical noise through the analog pin as an output for random values.

=== random(min, max) ===
The random function allows the generation of pseudo-random values within a defined range of minimum and maxium values.
<pre>value = random(100, 200); // sets 'value' with a random number
// between 100 and 200 equal </pre>

The following example generates a random value between 0 and 255 and outputs it as PWM signal on a PWM pin.
<pre>int randNumber; // Variable to store the random value
int led = 10; // LED with 220 Ohm resistor at pin 10

void setup() {} // no setup necessary

void loop()
{
randomSeed(millis()); // uses millis() as seed
randNumber = random(255); // Random number in the range 0-255
analogWrite(led, randNumber); // PWM signal as output
delay(500); // half second pause
}</pre>

== Serial communication ==
=== Serial.begin(rate) ===
Serial.begin(rate)' Opens the serial port and sets the baud rate for the serial transmission. The typical baud rate with the computer is 9600 baud. Other speeds are also supported.
<pre>void setup()
{
Serial.begin(9600); // opens serial port
} // sets the data rate to 9600 bps</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: When using serial communication, digital pins 0 (RX) and 1 (TX) cannot be used at the same time. </div>

=== Serial.println(data) ===
Writes data to the serial port, followed by an automatic line break as carrier return and line feed. This function has the same form as 'Serial.print()', but is easier to read on the serial monitor.
<pre>Serial.println(analogValue); // sends the value of 'analogValue'</pre>

More detailed information about the numerous variants of the 'Serial.println()' and 'Serial.print()' functions can be found on the Arduino website.

The following simple example reads a value from analog pin 0 and sends the data to the computer once per second.
<pre>void setup()
{
Serial.begin(9600); // sets the data rate to 9600 bps
}

void loop()
{
Serial.println(analogRead(0)); // sends the analog value
delay(1000); // pauses for 1 second
}</pre>

== Examples ==
=== Digital output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Output.JPG|thumb|none|300px|Arduino-Example-Digital-Output]] </li>
</ul></div>

This is a simple 'Hello World' program and turns something on and off. In this example a LED is connected to PIN 13 and flashes every second. The resistor may be superfluous at this pin because the Arduino has a built-in resistor.
<pre>int ledPin = 13; // LED off digital pin 13

void setup() // will run through once
{
pinMode(ledPin, OUTPUT); // sets pin 13 as output
}

void loop() // Running as endless loop
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}</pre>

=== Digital input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Input.JPG|thumb|none|300px|Arduino-Example-Digital-Input]] </li>
</ul></div>

This is the simplest form of an input with only two possible states: on or off.
This example reads out a simple switch or button at pin 2. When the switch is closed and the input pin is HIGH, the LED is turned on.
<pre>int ledPin = 13; // Output pin for the LED
int inPin = 2; // Input pin for a switch

void setup()
{
pinMode(ledPin, OUTPUT); // declares LED as output
pinMode(inPin, INPUT); // declares switch as input
}
void loop()
if (digitalRead(inPin) == HIGH) // check if this is the HIGH input
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}
}</pre>

=== analog PWM output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

Pulse width modulation (PWM) is a method of simulating analog outputs by pulsing the output voltage. This allows you to make an LED brighter or darker or check a servomotor later. The following example uses a loop to slowly make an LED brighter and darker.

<pre>int ledPin = 9; // PWM Pin for the LED

void setup(){} // No setup necessary

void loop()
{
for (int i=0; i<=255; i++) // ascending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}

for (int i=255; i>=0; i--) // descending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}
}</pre>

=== potentiometer Input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

With a potentiometer and one of the analog-digital converter (ADC) inputs of the Arduino it is possible to read analog values from 0-1024. The following example uses a potentiometer to control the blinking rate of an LED.

<pre>int potPin = 0; // Input pin for the potentiometer
int ledPin = 13; // Output pin for the LED

void setup()
{
pinMode(ledPin, OUTPUT); // declare ledPin as OUTPUT
}

void loop()
{
digitalWrite(ledPin, HIGH); // switches on ledPin
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
digitalWrite(ledPin, LOW); // switches ledPin off
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
}</pre>

== Used Hardware ==
&emsp;➠ [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

&emsp;➠ [[ARDUINO Wireless Proto Shield]]

&emsp;➠ [[Arduino MKR WAN 1300 LoRa]]

&emsp;➠ [[Arduino MKR LoRa Gateway Pro]]

== References ==
&emsp;➠ https://www.elektronik-kompendium.de/sites/com/1810231.htm

&emsp;➠ http://myhomearchiv.synology.me/download/Anleitung_Furduino.pdf

&emsp;➠ https://starthardware.org/arduino-uno/

&emsp;➠ https://starthardware.org/category/projekte/arduino-projekte/

&emsp;➠ http://www.netzmafia.de/skripten/hardware/Arduino/Arduino_Programmierhandbuch.pdf

[[Category:Documentation]]

Arduino Board Uno Rev3-Atmega 328: Programming Guide

2020-08-10T20:34:34Z

CCinay: /* Serial.println(data) */

Arduino Board Uno Rev3-Atmega 328: Programming Guide

2020-08-10T20:33:08Z

CCinay: Created page with "<div style="max-width: 970px"> == Summary == The Arduino IDE is a cross-platform Java application that acts as a program code editor and compiler and is also able to send fir..."

<div style="max-width: 970px">

== Summary ==
The Arduino IDE is a cross-platform Java application that acts as a program code editor and compiler and is also able to send firmware serially to the board. The development environment is based on Processing, an IDE designed to program artists, who normally do not have much contact with the art world programming environments. The programming language is based on Wiring, a C similar language which has a similar scope for a more restricted board design, whose IDE is also based on processing. Make sure you have an updated version of [https://www.arduino.cc/en/Main/Software Arduino IDE] installed.

== Struktur ==
The basic structure of the Arduino programming language is relatively simple and is divided into at least two parts. These two required parts or functions enclose blocks of statements.

<pre> void setup() {
// put your setup code here, to run once:

}

void loop() {
// put your main code here, to run repeatedly:

} </pre>

&emsp;➥ Here setup() is the preparation and loop() is the execution. Both functions are necessary to execute the program.

&emsp;➥ The setup function should follow the variable definition, which must be listed before. Setup must be run through as the first function in a program. <br>&emsp;&emsp; It is executed only once and is used to set PinMode or to initiate serial communication.

&emsp;➥ The setup() function is called once when the program starts. Use this function to set PinModes or start serial communication. The setup() function must <br>&emsp;&emsp; appear in every program, even if it does not contain any instructions.

&emsp;➥ After the setup() function follows the loop() function. It contains program code that is executed continuously in an infinite loop - read inputs, trigger <br>&emsp;&emsp; outputs, etc. This function is the core of all Arduino programs and does the main work.

=== setup() ===
The setup() function is called once when the program starts. Use this function to set PinModes or start serial communication.
The setup() function must appear in every program, even if it does not contain any instructions.

<pre>void setup()
{
pinMode(pin, OUTPUT); // 'pin' define as output
}</pre>

=== loop() ===
After running through the setup() function, the loop() function does exactly what its name suggests and runs in an endless loop. This allows the program to interact with the Arduino board via changes, reactions and controls.
<pre>void loop()
{
digitalWrite(pin, HIGH); // switches 'pin' on
delay(1000); // Pause for one second
digitalWrite(pin, LOW); // switches 'pin' off
delay(1000); // Pause for one second
}</pre>

=== Functions ===
A function is a block of program code that has a name and a set of instructions that are executed when the function is called. The functions void setup() and void loop() have already been explained. There are more built-in functions that will be discussed later.

<pre>Type FunctionName(parameter)
{
instructions;
}</pre>

The following integer type function ''delayVal()'' is used to insert a delay value into a program by reading a potentiometer. First a local variable 'v' is created. Next, 'v' is equated with the position of the potentiometer, which can have a value between 0 and 1023. The value is then divided by 4 to get a scale from 0 to 255 and at the end the result of the function is returned to the main program.

<pre>int delayVal()
{
int v; // create temporary variable 'v
v = analogRead(pot); // read potentiometer Value
v /= 4; // Convert from 0-1023 to 0-255
return v; // return the calculated value
}</pre>

=== {} curly brackets ===
Curly brackets (also called 'curly brackets') define the start and end of function and statement blocks as in the 'void loop()' function and also in the 'for' and 'if' statement.

<pre>type function()
{
instructions;
}</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: An opening curved bracket '{' must always be followed by a closing curved bracket '}'. Here it is often said that the number of brackets must be balanced. Unbalanced parentheses often lead to cryptic, inscrutable errors in the compiler, which are sometimes hard to find, especially in large programs.

The Arduino programming environment helps to check that the curved brackets are balanced. To do this, simply select a brace or click just behind it, and the logically connected counterpart is highlighted. </div>

=== ;semicolon ===
A semicolon must be used at the end of a statement and is used to separate the elements of a program.
A semicolon is also used to separate the elements of a for loop.

<pre>int x = 13; // declares variable 'x' as integer with value 13</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Forgetting a semicolon at the end of a line leads to an error in the compiler. The error description can be very clear and directly point to the missing semicolon, but this does not have to be the case. If an inscrutable or apparently illogical error is reported, the first thing to do is to add missing semicolons near the reported error. </div>

=== /*... */ block comments ===
Block comments or multiline comments are text areas that are ignored by the program. They are used for longer descriptions or comments and help other authors to understand program parts. They start with /* and end with */ and can cover several lines.

<pre>/* This is an inserted block comment
please do not forget the closing comment -
These must be balanced
*/</pre>

=== // Single line comments ===
Simple single-line comments are defined with a // at the beginning of the line and end with the end of the line. They are ignored by the program and do not consume memory.
<pre>// this is a single line comment</pre>

== Variables ==
A variable is the name of a numeric value with a name and memory location for later use in a program. A variable must be declared and optionally provided with a value. The following example declares a variable 'inputVariable' and assigns the value of analog pin 2 to it:
<pre>int inputVariable = 0; // declares a variable and
// sets its value to 0
inputVariable = analogRead(2); // sets the value of the variable equal
// with the value of analog pin 2 </pre>

'inputVariable' is the variable itself. The first line explains that its data type is 'int', which is the short expression for integer. The second line gives the variable the value of the analog pin 2, making the value of the pin available everywhere in the code.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Variables should always have descriptive names as clearly as possible to make the code easier to read.</div>

=== Declaration of variables: ===
All variables must be declared before use. Declaring a variable means defining its type such as int, long, float, etc., giving it a name and optionally an initial value.This only needs to be done once in the program. Afterwards the value can be changed at any time by calculations or various assignments.

The following example declares 'inputVariable' as 'int', i.e. integer data type and sets the initial value to 0. This is called a 'simple assignment'.
<pre>int inputVariable = 0;</pre>

A variable can be declared at many places in the program. The location of the declaration determines which program parts have access to the variable.

== Data types ==
&emsp;➥ <b>byte</b>: Byte stores an 8-bit numeric, integer value without decimal point. The value can be between 0 and 255.
<pre>byte someVariable = 180; // declares 'someVariable
// as a 'byte' data type </pre>

&emsp;➥ <b>int</b>: Integers are the most common data type for storing integer values without decimal point. Its value is 16 bits and ranges from -32,767 to 32,768.
<pre>int someVariable = 1500; // declares 'someVariable
// as an 'integer' data type</pre>

&emsp;➥ <b>long</b>: Data type for long integers with extended size, without decimal point, stored in a 32-bit value in a spectrum from -2,147,483,648 to 2,147,483,647
<pre>long someVariable = 90000; // declares 'someVariable
// as a 'long' data type </pre>

&emsp;➥ <b>float</b>: A data type for floating point values or numbers with decimal places. Floating point numbers have a better resolution than integers and are<br>&emsp;&emsp; expressed as 32-bit values with a spectrum from -3.4028235E+38 to 3.4028235E+38.
<pre>float someVariable = 3.14; // declares 'someVariable'
// as a 'float' data type </pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Floating point numbers are not precise and may lead to strange results when compared. Also, floating-point calculations are much slower than with integer data types. Calculations with floating-point values should be avoided if possible. </div>

&emsp;➥ <b>arrays</b>: An array is a collection of values that are accessed with an index number.
Each value in the array can be accessed by retrieving the name of<br>&emsp;&emsp; the array and the index number of the value. The index number always starts at 0 for an array.<br>&emsp;&emsp; An array must be declared and optionally assigned values before it can be used.
<pre>int myArray[] = {value0, value1, value2...} </pre>

In the same way it is possible to declare an array first with datatype and size and later to give a value to an index position.
<pre>int myArray[5]; // declare datatype 'integer' as array with 5 Positions
myArray[3] = 10; // gives the 4th index the value 10 </pre>

To read the value of an array you can simply assign it to a variable specifying the array and the index position.
<pre>x = myArray[3]; // x now has the value 10 </pre>

Arrays are often used for loops, where the counter of the loop is also used as index position for the values in the array. The following example uses an array to make an LED flicker. With a for loop and a counter starting at 0 an index position in the array is read, sent to the LED pin, paused for 200ms and then the same is done with the next index position.
<pre>int ledPin = 10; // LED on pin 10
byte flicker[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array with 8 different values
void setup()
{
pinMode(ledPin, OUTPUT); // Sets the OUTPUT pin
}

void loop()
{
for(int i=0; i<7; i++) // loop equals the number
{ // of the values in the array
analogWrite(ledPin, flicker[i]); // writes the index value to the LED
delay(200); // 200ms pause
}
}</pre>

== Digitaler Input - Output ==
=== pinMode(pin,mode) ===
Used in 'void setup()' to configure a specific pin as either input or output.
<pre>pinMode(pin, OUTPUT); // sets 'pin' as output </pre>

Arduino digital pins are inputs by default, so they don't need to be specified as inputs with 'pinMode()'. Pins configured as inputs have a high impedance state.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: There are also comfortable 20 k 'pullup' resistors in the ATmega chip which are accessible via software.</div>

These built-in 'pullup' resistors can be accessed in the following way:
<pre>pinMode(pin, INPUT); // sets 'pin' as input
digitalWrite(pin, HIGH); // switches on the 'Pullup' resistor</pre>

&emsp;➥ Pullup resistors are normally used to connect inputs like switches. In the example shown here it is noticeable that the pin is not defined as an output<br>&emsp;&emsp; although it is written to. It is only the method to activate the internal 'pullup' resistor.

&emsp;➥ Pins configured as output are in a low impedance state and can be loaded with a maximum of 40 mAmpere current from connected elements<br>&emsp;&emsp; and circuits. This is enough to make an LED light up (don't forget the serial resistor), but not enough to drive most relays, solenoids or motors.

&emsp;➥ Short circuits at the Arduino pins as well as too high current can destroy the output pin or even the whole ATmega chip. For this reason it is a good idea<br>&emsp;&emsp; to connect an output pin with external elements in series with a 470 or 1K resistor to
switch.

=== digitalRead(pin) ===
digitalRead(pin)' reads the value from a specified digital pin, with the result either HIGH or LOW. The pin can be set either as a variable or constant (0-13).
<pre>value = digitalRead(Pin); // sets 'value' equal to the input pin </pre>

digitalWrite(pin,value)
Outputs either logic level HIGH or LOW at a specified pin. The pin can be set as a variable or constant (0-13).
<pre>digitalWrite(pin, HIGH); // sets 'pin' to high</pre>

The following example reads a button on a digital input and switches an LED on when the button is pressed:
<pre>int led = 13; // LED connected to pin 13
int pin = 7; // Button connected to pin 7
int value = 0; // Variable to store the readout value

void setup()
{
pinMode(led, OUTPUT); // defines pin 13 as output
pinMode(pin, INPUT); // sets pin 7 as input
}

void loop()
{
value = digitalRead(pin); // sets 'value' equal to
// the input pin
digitalWrite(led, value); // sets 'led' equal to the
} // Value of the button</pre>

== Analoger Input - Output ==
=== analogRead(pin) ===
Reads the value of a specified analog pin with a 10 bit resolution. This function is only available for pins (0-5). The resulting integer values have a spectrum from 0 to 1023.
<pre>value = analogRead(pin); // sets 'value' equal to 'pin</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Unlike digital pins, analog pins do not have to be declared as input or output first. </div>

=== analogWrite(pin, value) ===
Writes pseudo-analog values to an output pin using hardware-based pulse width modulation (PWM). On newer Arduino boards with the ATmega 168 chip this function is applicable to pins 3, 5, 6, 9, 10 and 11. Older Arduinos with the ATmega8 only support pins 9,10 and 11. The value can be set as a variable or constant in the range 0-255.
<pre>analogWrite(pin, value); // writes 'value' to the analog 'pin </pre>

A value of 0 generates a uniform voltage of 0 volts at a fixed pin; a value of 255 generates a uniform voltage of 5 volts at a fixed pin. For values between 0 and 255, the pin changes very quickly between 0 and 5 volts - the higher the value, the longer the pin is HIGH (5 volts). For a value of 64, the pin is at 0 volts for three-quarters of the time and at 5 volts for one-quarter of the time. A value of 128 means that the output voltage is HIGH half of the time and LOW the other half. A value of 192 means that the voltage at the pin measures 0 volts at one quarter of the time and the full 5 volts at three quarters of the time.

Because this is a hardware-based function, the constant wave runs independently of the program until the next change of state via analogWrite (or a call to digitalRead or digitalWrite on the same pin).

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: In contrast to digital pins, analog pins do not have to be declared as input or output before. </div>

&emsp;➥ The following example reads an analog value from 'pin', converts the value by dividing it by 4 and then outputs it as a PWM signal to 'led'.

<pre>int led = 10; // LED with 220 resistor at pin 10
int pin = 0; // Potentiometer at analog pin 0
int value; // Value for readout

void setup(){} // no setup required

void loop()
{
value = analogRead(pin); // sets 'value' equal to 'pin
value /= 4; // converts 0-1023 into 0-255
analogWrite(led, value); // outputs the PWM signal 'led
}</pre>

== Random functions ==
=== randomSeed(seed) ===
Sets a value or 'Seed' as starting point for the random() function.
<pre>randomSeed(value); // sets 'value' as the random seed</pre>

The Arduino itself is not able to produce a truly random value. With randomSeed() a variable can be used as 'seed' to get better random results. For example, millis() or analogRead() can be used as a seed variable or function to use electrical noise through the analog pin as an output for random values.

=== random(min, max) ===
The random function allows the generation of pseudo-random values within a defined range of minimum and maxium values.
<pre>value = random(100, 200); // sets 'value' with a random number
// between 100 and 200 equal </pre>

The following example generates a random value between 0 and 255 and outputs it as PWM signal on a PWM pin.
<pre>int randNumber; // Variable to store the random value
int led = 10; // LED with 220 Ohm resistor at pin 10

void setup() {} // no setup necessary

void loop()
{
randomSeed(millis()); // uses millis() as seed
randNumber = random(255); // Random number in the range 0-255
analogWrite(led, randNumber); // PWM signal as output
delay(500); // half second pause
}</pre>

== Serial communication ==
=== Serial.begin(rate) ===
Serial.begin(rate)' Opens the serial port and sets the baud rate for the serial transmission. The typical baud rate with the computer is 9600 baud. Other speeds are also supported.
<pre>void setup()
{
Serial.begin(9600); // opens serial port
} // sets the data rate to 9600 bps</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: When using serial communication, digital pins 0 (RX) and 1 (TX) cannot be used at the same time. </div>

=== Serial.println(data) ===
Writes data to the serial port, followed by an automatic line break as carrier return and line feed. This function has the same form as 'Serial.print()', but is easier to read on the serial monitor.
<pre>Serial.println(analogValue); // sends the value of
// 'analogValue'</pre>

More detailed information about the numerous variants of the 'Serial.println()' and 'Serial.print()' functions can be found on the Arduino website.

The following simple example reads a value from analog pin 0 and sends the data to the computer once per second.
<pre>void setup()
{
Serial.begin(9600); // sets the data rate to 9600 bps
}

void loop()
{
Serial.println(analogRead(0)); // sends the analog value
delay(1000); // pauses for 1 second
}</pre>

== Examples ==
=== Digital output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Output.JPG|thumb|none|300px|Arduino-Example-Digital-Output]] </li>
</ul></div>

This is a simple 'Hello World' program and turns something on and off. In this example a LED is connected to PIN 13 and flashes every second. The resistor may be superfluous at this pin because the Arduino has a built-in resistor.
<pre>int ledPin = 13; // LED off digital pin 13

void setup() // will run through once
{
pinMode(ledPin, OUTPUT); // sets pin 13 as output
}

void loop() // Running as endless loop
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}</pre>

=== Digital input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Example-Digital-Input.JPG|thumb|none|300px|Arduino-Example-Digital-Input]] </li>
</ul></div>

This is the simplest form of an input with only two possible states: on or off.
This example reads out a simple switch or button at pin 2. When the switch is closed and the input pin is HIGH, the LED is turned on.
<pre>int ledPin = 13; // Output pin for the LED
int inPin = 2; // Input pin for a switch

void setup()
{
pinMode(ledPin, OUTPUT); // declares LED as output
pinMode(inPin, INPUT); // declares switch as input
}
void loop()
if (digitalRead(inPin) == HIGH) // check if this is the HIGH input
{
digitalWrite(ledPin, HIGH); // switches the LED on
delay(1000); // Pause for 1 second
digitalWrite(ledPin, LOW); // switches the LED off
delay(1000); // Pause for 1 second
}
}</pre>

=== analog PWM output ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

Pulse width modulation (PWM) is a method of simulating analog outputs by pulsing the output voltage. This allows you to make an LED brighter or darker or check a servomotor later. The following example uses a loop to slowly make an LED brighter and darker.

<pre>int ledPin = 9; // PWM Pin for the LED

void setup(){} // No setup necessary

void loop()
{
for (int i=0; i<=255; i++) // ascending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}

for (int i=255; i>=0; i--) // descending value for i
{
analogWrite(ledPin, i); // sets the brightness value to i
delay(100); // Pause for 100ms
}
}</pre>

=== potentiometer Input ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino-Analog-PWM-input.JPG|thumb|none|300px|Arduino-Analog-PWM-input]] </li>
</ul></div>

With a potentiometer and one of the analog-digital converter (ADC) inputs of the Arduino it is possible to read analog values from 0-1024. The following example uses a potentiometer to control the blinking rate of an LED.

<pre>int potPin = 0; // Input pin for the potentiometer
int ledPin = 13; // Output pin for the LED

void setup()
{
pinMode(ledPin, OUTPUT); // declare ledPin as OUTPUT
}

void loop()
{
digitalWrite(ledPin, HIGH); // switches on ledPin
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
digitalWrite(ledPin, LOW); // switches ledPin off
delay(analogRead(potPin)); // pauses the program by the value of potentiometers
}</pre>

== Used Hardware ==
&emsp;➠ [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

&emsp;➠ [[ARDUINO Wireless Proto Shield]]

&emsp;➠ [[Arduino MKR WAN 1300 LoRa]]

&emsp;➠ [[Arduino MKR LoRa Gateway Pro]]

== References ==
&emsp;➠ https://www.elektronik-kompendium.de/sites/com/1810231.htm

&emsp;➠ http://myhomearchiv.synology.me/download/Anleitung_Furduino.pdf

&emsp;➠ https://starthardware.org/arduino-uno/

&emsp;➠ https://starthardware.org/category/projekte/arduino-projekte/

&emsp;➠ http://www.netzmafia.de/skripten/hardware/Arduino/Arduino_Programmierhandbuch.pdf

[[Category:Documentation]]

File:Arduino-Analog-PWM-input.JPG

2020-08-10T20:20:23Z

CCinay:

File:Arduino-Example-Digital-Input.JPG

2020-08-10T19:48:15Z

CCinay:

File:Arduino-Example-Digital-Output.JPG

2020-08-10T19:42:34Z

CCinay:

Arduino Board Uno Rev3-Atmega 328: First Steps

2020-08-10T18:47:10Z

CCinay:

Arduino Board Uno Rev3-Atmega 328: First Steps

2020-08-10T16:16:20Z

CCinay: Created page with "<div style="max-width: 970px"> == Summary == The Arduino UNO R3 is the current version of the Arduino UNO. This is the standard Arduino. It is completely sufficient for most..."

<div style="max-width: 970px">

== Summary ==
The Arduino UNO R3 is the current version of the Arduino UNO. This is the standard Arduino. It is completely sufficient for most projects and is very affordable.

<div><ul>
<li style="display: inline-block;"> [[File:Arduino_oard_Uno_Rev3-Atmega_328.jpg|thumb|none|500px|Arduino_oard_Uno_Rev3-Atmega_328]] </li>
</ul></div>

== Arduino UNO Überblick ==
Main component is a microcontroller from ATMEL, the ATMEGA 328P. It contains the Arduino bootloader software. It allows to execute Arduino programs. The Arduino UNO has 14 digital I/O pins, six of which can be used as PWM channels (allow e.g. dimming of LEDs). Six analog input pins are also available. The board handles communication via UART, SPI and I2C (TWI).

For data exchange and programming it is connected to the computer via USB. Since the microcontroller cannot communicate directly via USB, there is a second microcontroller (ATmega8U2) on the Arduino UNO which does the "translation".

== Structure of an Arduino UNO ==
In the following figure the most important components of an Arduino UNO are listed with short descriptions.

<div><ul>
<li style="display: inline-block;"> [[File:Arduino_oard_Uno_Rev3-Atmega_328-Overview.JPG|thumb|none|750px|Arduino_oard_Uno_Rev3-Atmega_328-Overview]] </li>
</ul></div>

The pin strips on both sides of the Arduino can be used to connect the Arduino to external electronic components or a circuit board using jumper cables:

&emsp;➥ <b>The analog pins A0 to A5</b> are suitable as <b>sensor inputs for measuring voltage values between 0V and 5V;</b> a built-in analog-to-digital converter<br>&emsp;&emsp; maps the measured voltage values to a numerical range from <b>0 (no voltage) to 1023 (maximum voltage, i.e. 5V)</b>.

&emsp;➥ <b>The digital pins 0 to 13</b> can also be defined as sensor inputs: An applied voltage of >2.5V is interpreted as <b>HIGH (numerical value 1)</b>, <br>&emsp;&emsp; a lower voltage as <b>LOW (numerical value 0)</b>.

&emsp;➥ <b>The digital pins 0 to 13</b> can also be <b>defined as digital voltage outputs</b>: They output a voltage of about <b>5V in HIGH</b> mode and <b>0V in LOW mode</b>. <br>&emsp;&emsp; However, the <b>current is limited to 40mA</b>; if necessary, the voltage of the pins is automatically reduced to reach this limit.

&emsp;➥ A <b>special feature is the digital pin 13</b>: There the <b>output current is limited to only 20mA</b>, so that an <b>LED can be connected there directly</b> <br>&emsp;&emsp; (without series resistor) (directly <b>next to pin 13 is a GND pin</b>, so that not even a plug-in board is necessary for this). <br>&emsp;&emsp; Newer versions of the Arduino UNO even have an SMD LED permanently installed between pin 13 and GND.

&emsp;➥ <b>The pins (3, 5, 6, 9, 10, 11)</b> marked with the tilde <b>character ~ </b> can, when set as output pins, also switch back and forth <b>between 0V and 5V</b> very<br>&emsp;&emsp; quickly by means of a so-called <b>pulse width modulation (PWM)</b>.<br>&emsp;&emsp; You can specify values between <b>0 and 255</b>, where <b>0 stands for "always off"</b> and <b>255 for "always on"</b>.

&emsp;➥ The other connectors on the board (AREF and ICSP headers) are not important for normal use.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Notes</b>: For example, <b>PWM can be used</b> to drive a motor or a light bulb at a value of 128 with only <b>"half power"</b>, because it is only supplied with voltage for half of the time and the other half of the time is idle.

<b>An LED can also be "dimmed"</b> in this way: The LED is fast enough to blink at the same frequency, but our eye is not. As we can only perceive 25 frames per second, an LED that is only on half of the time appears darker to us than a permanently bright LED. </div>

== Typical Arduino applications ==
&emsp;➥ Electronics

&emsp;➥ Robotics

&emsp;➥ Controls

&emsp;➥ Sensor data acquisition

&emsp;➥ Programming close to the hardware

== Software ==
The Arduino IDE is a cross-platform Java application that acts as a program code editor and compiler and is also able to send firmware serially to the board. The development environment is based on Processing, an IDE designed to program artists, who normally do not have much contact with the art world programming environments. The programming language is based on Wiring, a C similar language which has a similar scope for a more restricted board design, whose IDE is also based on processing. Make sure you have an updated version of [https://www.arduino.cc/en/Main/Software Arduino IDE] installed.

=== Struktur ===
The basic structure of the Arduino programming language is relatively simple and is divided into at least two parts. These two required parts or functions enclose blocks of statements.

<pre> void setup() {
// put your setup code here, to run once:

}

void loop() {
// put your main code here, to run repeatedly:

} </pre>

&emsp;➥ Here setup() is the preparation and loop() is the execution. Both functions are necessary to execute the program.

&emsp;➥ The setup function should follow the variable definition, which must be listed before. Setup must be run through as the first function in a program. <br>&emsp;&emsp; It is executed only once and is used to set PinMode or to initiate serial communication.

&emsp;➥ The setup() function is called once when the program starts. Use this function to set PinModes or start serial communication. The setup() function must <br>&emsp;&emsp; appear in every program, even if it does not contain any instructions.

&emsp;➥ After the setup() function follows the loop() function. It contains program code that is executed continuously in an infinite loop - read inputs, trigger <br>&emsp;&emsp; outputs, etc. This function is the core of all Arduino programs and does the main work.

=== setup() ===
The setup() function is called once when the program starts. Use this function to set PinModes or start serial communication.
The setup() function must appear in every program, even if it does not contain any instructions.

<pre>void setup()
{
pinMode(pin, OUTPUT); // 'pin' define as output
}</pre>

=== loop() ===
After running through the setup() function, the loop() function does exactly what its name suggests and runs in an endless loop. This allows the program to interact with the Arduino board via changes, reactions and controls.
<pre>void loop()
{
digitalWrite(pin, HIGH); // switches 'pin' on
delay(1000); // Pause for one second
digitalWrite(pin, LOW); // switches 'pin' off
delay(1000); // Pause for one second
}</pre>

=== Functions ===
A function is a block of program code that has a name and a set of instructions that are executed when the function is called. The functions void setup() and void loop() have already been explained. There are more built-in functions that will be discussed later.

<pre>Type FunctionName(parameter)
{
instructions;
}</pre>

The following integer type function ''delayVal()'' is used to insert a delay value into a program by reading a potentiometer. First a local variable 'v' is created. Next, 'v' is equated with the position of the potentiometer, which can have a value between 0 and 1023. The value is then divided by 4 to get a scale from 0 to 255 and at the end the result of the function is returned to the main program.

<pre>int delayVal()
{
int v; // create temporary variable 'v
v = analogRead(pot); // read potentiometer Value
v /= 4; // Convert from 0-1023 to 0-255
return v; // return the calculated value
}</pre>

=== {} curly brackets ===
Curly brackets (also called 'curly brackets') define the start and end of function and statement blocks as in the 'void loop()' function and also in the 'for' and 'if' statement.

<pre>type function()
{
instructions;
}</pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: An opening curved bracket '{' must always be followed by a closing curved bracket '}'. Here it is often said that the number of brackets must be balanced. Unbalanced parentheses often lead to cryptic, inscrutable errors in the compiler, which are sometimes hard to find, especially in large programs.

The Arduino programming environment helps to check that the curved brackets are balanced. To do this, simply select a brace or click just behind it, and the logically connected counterpart is highlighted. </div>

=== ;semicolon ===
A semicolon must be used at the end of a statement and is used to separate the elements of a program.
A semicolon is also used to separate the elements of a for loop.

<pre>int x = 13; // declares variable 'x' as integer with value 13</pre>
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Remark</b>: Forgetting a semicolon at the end of a line leads to an error in the compiler. The error description can be very clear and directly point to the missing semicolon, but this does not have to be the case. If an inscrutable or apparently illogical error is reported, the first thing to do is to add missing semicolons near the reported error. </div>

=== /*... */ block comments ===
Block comments or multiline comments are text areas that are ignored by the program. They are used for longer descriptions or comments and help other authors to understand program parts. They start with /* and end with */ and can cover several lines.

<pre>/* This is an inserted block comment
please do not forget the closing comment -
These must be balanced
*/</pre>

=== // Single line comments ===
Simple single-line comments are defined with a // at the beginning of the line and end with the end of the line. They are ignored by the program and do not consume memory.
<pre>// this is a single line comment</pre>

=== Variablen ===
A variable is the name of a numeric value with a name and memory location for later use in a program. A variable must be declared and optionally provided with a value. The following example declares a variable 'inputVariable' and assigns the value of analog pin 2 to it:
<pre>int inputVariable = 0; // declares a variable and
// sets its value to 0
inputVariable = analogRead(2); // sets the value of the variable equal
// with the value of analog pin 2 </pre>

'inputVariable' is the variable itself. The first line explains that its data type is 'int', which is the short expression for integer. The second line gives the variable the value of the analog pin 2, making the value of the pin available everywhere in the code.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Variables should always have descriptive names as clearly as possible to make the code easier to read.</div>

=== Declaration of variables: ===
All variables must be declared before use. Declaring a variable means defining its type such as int, long, float, etc., giving it a name and optionally an initial value.This only needs to be done once in the program. Afterwards the value can be changed at any time by calculations or various assignments.

The following example declares 'inputVariable' as 'int', i.e. integer data type and sets the initial value to 0. This is called a 'simple assignment'.
<pre>int inputVariable = 0;</pre>

A variable can be declared at many places in the program. The location of the declaration determines which program parts have access to the variable.

=== Data types ===
&emsp;➥ <b>byte</b>: Byte stores an 8-bit numeric, integer value without decimal point. The value can be between 0 and 255.
<pre>byte someVariable = 180; // declares 'someVariable
// as a 'byte' data type </pre>

&emsp;➥ <b>int</b>: Integers are the most common data type for storing integer values without decimal point. Its value is 16 bits and ranges from -32,767 to 32,768.
<pre>int someVariable = 1500; // declares 'someVariable
// as an 'integer' data type</pre>

&emsp;➥ <b>long</b>: Data type for long integers with extended size, without decimal point, stored in a 32-bit value in a spectrum from -2,147,483,648 to 2,147,483,647
<pre>long someVariable = 90000; // declares 'someVariable
// as a 'long' data type </pre>

&emsp;➥ <b>float</b>: A data type for floating point values or numbers with decimal places. Floating point numbers have a better resolution than integers and are expressed as 32-bit values with a spectrum from -3.4028235E+38 to 3.4028235E+38.
<pre>float someVariable = 3.14; // deklariert 'someVariable'
// als einen 'float' Datentyp </pre>

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>: Floating point numbers are not precise and may lead to strange results when compared. Also, floating-point calculations are much slower than with integer data types. Calculations with floating-point values should be avoided if possible. </div>

&emsp;➥ <b>arrays</b>:

[[Category:Documentation]]

File:Arduino oard Uno Rev3-Atmega 328.jpg

2020-08-10T14:13:39Z

CCinay:

File:Arduino oard Uno Rev3-Atmega 328-Overview.JPG

2020-08-10T13:43:01Z

CCinay:

Arduino Wireless SD Shield Tutorial: First Steps

2020-08-10T11:40:01Z

CCinay:

<div style="max-width: 970px">

== Summary ==
<b>The Wireless Proto Shield for Arduino</b> is an Arduino Shield that provides wireless communication capabilities to an Arduino board. For this purpose, a chip for wireless communication is attached to the shield. This Wireless Proto Shield is <b>based on Digi's Xbee module</b>, but can be used by any model of the same size. The module can communicate <b>indoors at a distance of up to 30 metres</b> and <b>outdoors at a distance of up to 90 metres</b> (without obstacle).
The module can be used as a replacement for a USB-to-serial adapter or configured in control mode for a wide range of networking options.

The Wireless Proto Shield for Arduino has no SD socket.

An integrated switch on the shield allows the wireless module (Xbee chip) to communicate with the USB to serial converter or the microcontroller.
To learn more about the WireLess Proto Shield, see the product data sheet on the Arduino website: [http://arduino.cc/en/Main/ArduinoWirelessProtoShield ArduinoWirelessProtoShield]

<div><ul>
<li style="display: inline-block;"> [[File:Arduino_Wireless_SD_Shield_Tutorial.jpg|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial]] </li>
</ul></div>

== Description ==
As the name implies, the Arduino Wireless SD shield serves <b>two functions</b>. <b>Foremost</b>, this shield allows you to easily <b>interface with Xbee transceiver modules</b> to create mesh networks, and <b>other wireless devices</b>. <b>Secondly</b>, the micro SD socket allows you to <b>store and access a large amount of data</b>. Whether using these functions by on their own or together, this chip greatly enhances the capabilities of a standard Arduino.
The best part about this shield is how easy it is to use. In no time flat, you can have its various components up and running.

=== Step 1: Plug in the Xbee ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino_Wireless_SD_Shield_Tutorial-Step1.jpg|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step1]] </li>
</ul></div>

&emsp;1. Plug in your Xbee modules in order to use the shield as a wireless transceiver.

&emsp;2. Make sure the module's pointy end is lined up with the edge of the board.

&emsp;3. If you are using the shield for wireless data transfer, you will need two or more of them.

=== Step 2: Plug It In ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino_Wireless_SD_Shield_Tutorial-Step2.jpg|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step2]]</li>
</ul></div>

&emsp;➥ Plug your shields into your Arduinos.

=== Step 3: Features ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino_Wireless_SD_Shield_Tutorial-Step3.JPG|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step3]] </li>
</ul></div>

&emsp;1. The wireless SD shield supports [https://www.digi.com/products/embedded-systems/digi-xbee/rf-modules/2-4-ghz-rf-modules/xbee-zigbee#overview Xbee modules]. These modules allow for easy wireless serial communication. <br>&emsp;&emsp;A standard module has the range of 100 - 300 feet.

&emsp;2. It also boasts a micro SD socket. This can easily be interfaced with the [https://www.arduino.cc/en/Reference/SD Arduino SD library]. Unfortunately, this library<br>&emsp;&emsp; does not come bundled with the Arduino development environment, so you will have to set it up yourself.

&emsp;3. The shield also boasts a perfboard grid for prototyping your own circuit, and a micro switch for toggling between the USB port and micro SD port.

=== Step 4: Program the Receiver ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino_Wireless_SD_Shield_Tutorial-Step4.JPG|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step4]] </li>
</ul></div>

&emsp;➥ Plug one of the Arduinos into the computer. Make certain the micro switch is toggled to the "USB" option.

<b>Upload the following code:</b>
<pre>//Xbee receiver

int sentDat;

void setup() {
Serial.begin(9600);
pinMode(2, OUTPUT);
}

void loop() {
if (Serial.available() > 0) {
sentDat = Serial.read();

if(sentDat == 'h'){
//activate the pumpkin for one second and then stop
digitalWrite(2, HIGH);
delay(1000);
digitalWrite(2, LOW);
}
}
}</pre>

=== Step 5: Setup the Receiver ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino_Wireless_SD_Shield_Tutorial-Step5.JPG|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step5]] </li>
</ul></div>

&emsp;1. Unplug the Arduino from the computer. Toggle the micro switch from "USB" to "MICRO".

&emsp;2. Plug the red wire from a 9V battery connector into the Vin pin. Plug the black wire into the GND pin.

&emsp;3. Connect the positive leg of an LED to pin D2 and the other leg in series with a 220 ohm resistor to ground.

&emsp;4. Plug in your battery.

&emsp;5. It is now a standalone receiver.

=== Step 6: Program the Transmitter ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino Wireless SD Shield Tutorial-Step6.JPG|thumb|none|500px|Arduino Wireless SD Shield Tutorial-Step6]] </li>
</ul></div>

&emsp;1. Plug in the Arduino for the transmitter. Make certain the micro switch is toggled to the "USB" option.

&emsp;2. Before you upload any code to the Arduino, open the serial monitor. Type in "h" and hit the "send" button.
<br>&emsp;&emsp;The LED on your receiver should light up. You have made a wireless connection!

<b>&emsp;3. Now upload the following code:</b>
<pre>/*

Wireless transmitter demo

Based on Button example code
http://www.arduino.cc/en/Tutorial/Button

The circuit:
* pushbutton attached to pin 2 from +5V
* 10K resistor attached to pin 2 from ground

This code is in the public domain.

*/

// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 2; // the number of the pushbutton pin

// variables will change:
int buttonState = 0; // variable for reading the pushbutton status

void setup() {
// initialize serial communication:
Serial.begin(9600);

// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT);
}

void loop(){
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);

// check if the pushbutton is pressed.
// if it is, the buttonState is HIGH:
if (buttonState == HIGH) {
//transmit a High command to the pumpkin and delay a second so that it does not receive more than one command
//per button press
Serial.println('h');
delay(1000);
}
}</pre>

=== Step 7: Setup the Transmitter ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino_Wireless_SD_Shield_Tutorial-Step7.JPG|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step7]] </li>
</ul></div>

&emsp;1. Unplug the Arduino from the computer. Toggle the micro switch from "USB" to "MICRO".

&emsp;2. Plug the red wire from a 9V battery connector into the Vin pin. Plug the black wire into the GND pin.

&emsp;3. Connect a 10K resistor between pin D2 and ground. Also connect a push button switch between pin D2 and 5v.

&emsp;4. Plug in your battery.

&emsp;5. It is now a standalone transmitter.

=== Step 8: Prepare the SD Card ===
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>:
Before you can use the micro SD card, it needs to be formatted to either FAT16 or FAT32.</div>

<div><ul>
<li style="display: inline-block;"> [[File:Arduino Wireless SD Shield Tutorial-Step8.JPG|thumb|none|500px|Arduino Wireless SD Shield Tutorial-Step8]] </li>
</ul></div>

<b>On Windows:</b>

&emsp;➥ Open "My Computer"

&emsp;➥ Right-click on the disk and select "Format"

&emsp;➥ Select "FAT" and click "start"

&emsp;➥ It is now formatted to FAT16

Once the disk is formatted, the next thing you have to do is make sure that you have the [https://github.com/adafruit/SD SD Card Library]. For instructions on how to setup the library, check out the bottom of Adafruit's extremely thorough [http://www.ladyada.net/products/microsd/ micro SD card tutorial].

Plug the SD card into the socket on the shield.

<b>To test the SD card, plug the Arduino into the computer and upload the following code:</b>

<pre>/*
SD card read/write

This example shows how to read and write data to and from an SD card file
The circuit:
* SD card attached to SPI bus as follows:
** MOSI - pin 11
** MISO - pin 12
** CLK - pin 13
** CS - pin 4

*/

#include <SD.h>

File myFile;

void setup()
{
Serial.begin(9600);
Serial.print("Initializing SD card...");
// On the Ethernet Shield, CS is pin 4. It's set as an output by default.
// Note that even if it's not used as the CS pin, the hardware SS pin
// (10 on most Arduino boards, 53 on the Mega) must be left as an output
// or the SD library functions will not work.
pinMode(10, OUTPUT);

if (!SD.begin(4)) {
Serial.println("initialization failed!");
return;
}
Serial.println("initialization done.");

// open the file. note that only one file can be open at a time,
// so you have to close this one before opening another.
myFile = SD.open("test.txt", FILE_WRITE);

// if the file opened okay, write to it:
if (myFile) {
Serial.print("Writing to test.txt...");
myFile.println("testing 1, 2, 3.");
// close the file:
myFile.close();
Serial.println("done.");
} else {
// if the file didn't open, print an error:
Serial.println("error opening test.txt");
}

// re-open the file for reading:
myFile = SD.open("test.txt");
if (myFile) {
Serial.println("test.txt:");

// read from the file until there's nothing else in it:
while (myFile.available()) {
Serial.write(myFile.read());
}
// close the file:
myFile.close();
} else {
// if the file didn't open, print an error:
Serial.println("error opening test.txt");
}
}

void loop()
{
// nothing happens after setup
}</pre>

== Used Hardware ==
&emsp;➠ [[ARDUINO Wireless Proto Shield]]

&emsp;➠ [[Arduino Board Uno Rev3 DIP Version, ATmega328, USB]]

== References ==
&emsp;➠ https://forum.arduino.cc/index.php?board=63.0

&emsp;➠ https://www.arduino.cc/en/Reference/SD

&emsp;➠ https://store.arduino.cc/arduino-wireless-proto-shield

&emsp;➠ https://store.arduino.cc/arduino-wireless-proto-shield

&emsp;➠ http://www.ladyada.net/products/microsd/

&emsp;➠ https://github.com/adafruit/SD

[[Category:Documentation]]

Arduino Wireless SD Shield Tutorial: First Steps

2020-08-10T11:21:35Z

CCinay:

<div style="max-width: 970px">

== Summary ==
<b>The Wireless Proto Shield for Arduino</b> is an Arduino Shield that provides wireless communication capabilities to an Arduino board. For this purpose, a chip for wireless communication is attached to the shield. This Wireless Proto Shield is <b>based on Digi's Xbee module</b>, but can be used by any model of the same size. The module can communicate <b>indoors at a distance of up to 30 metres</b> and <b>outdoors at a distance of up to 90 metres</b> (without obstacle).
The module can be used as a replacement for a USB-to-serial adapter or configured in control mode for a wide range of networking options.

The Wireless Proto Shield for Arduino has no SD socket.

An integrated switch on the shield allows the wireless module (Xbee chip) to communicate with the USB to serial converter or the microcontroller.
To learn more about the WireLess Proto Shield, see the product data sheet on the Arduino website: [http://arduino.cc/en/Main/ArduinoWirelessProtoShield ArduinoWirelessProtoShield]

<div><ul>
<li style="display: inline-block;"> [[File:Arduino_Wireless_SD_Shield_Tutorial.jpg|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial]] </li>
</ul></div>

== Description ==
As the name implies, the Arduino Wireless SD shield serves <b>two functions</b>. <b>Foremost</b>, this shield allows you to easily <b>interface with Xbee transceiver modules</b> to create mesh networks, and <b>other wireless devices</b>. <b>Secondly</b>, the micro SD socket allows you to <b>store and access a large amount of data</b>. Whether using these functions by on their own or together, this chip greatly enhances the capabilities of a standard Arduino.
The best part about this shield is how easy it is to use. In no time flat, you can have its various components up and running.

=== Step 1: Plug in the Xbee ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino_Wireless_SD_Shield_Tutorial-Step1.jpg|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step1]] </li>
</ul></div>

&emsp;1. Plug in your Xbee modules in order to use the shield as a wireless transceiver.

&emsp;2. Make sure the module's pointy end is lined up with the edge of the board.

&emsp;3. If you are using the shield for wireless data transfer, you will need two or more of them.

=== Step 2: Plug It In ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino_Wireless_SD_Shield_Tutorial-Step2.jpg|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step2]]</li>
</ul></div>

&emsp;➥ Plug your shields into your Arduinos.

=== Step 3: Features ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino_Wireless_SD_Shield_Tutorial-Step3.JPG|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step3]] </li>
</ul></div>

&emsp;1. The wireless SD shield supports [https://www.digi.com/products/embedded-systems/digi-xbee/rf-modules/2-4-ghz-rf-modules/xbee-zigbee#overview Xbee modules]. These modules allow for easy wireless serial communication. <br>&emsp;&emsp;A standard module has the range of 100 - 300 feet.

&emsp;2. It also boasts a micro SD socket. This can easily be interfaced with the [https://www.arduino.cc/en/Reference/SD Arduino SD library]. Unfortunately, this library<br>&emsp;&emsp; does not come bundled with the Arduino development environment, so you will have to set it up yourself.

&emsp;3. The shield also boasts a perfboard grid for prototyping your own circuit, and a micro switch for toggling between the USB port and micro SD port.

=== Step 4: Program the Receiver ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino_Wireless_SD_Shield_Tutorial-Step4.JPG|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step4]] </li>
</ul></div>

&emsp;➥ Plug one of the Arduinos into the computer. Make certain the micro switch is toggled to the "USB" option.

<b>Upload the following code:</b>
<pre>//Xbee receiver

int sentDat;

void setup() {
Serial.begin(9600);
pinMode(2, OUTPUT);
}

void loop() {
if (Serial.available() > 0) {
sentDat = Serial.read();

if(sentDat == 'h'){
//activate the pumpkin for one second and then stop
digitalWrite(2, HIGH);
delay(1000);
digitalWrite(2, LOW);
}
}
}</pre>

=== Step 5: Setup the Receiver ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino_Wireless_SD_Shield_Tutorial-Step5.JPG|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step5]] </li>
</ul></div>

&emsp;1. Unplug the Arduino from the computer. Toggle the micro switch from "USB" to "MICRO".

&emsp;2. Plug the red wire from a 9V battery connector into the Vin pin. Plug the black wire into the GND pin.

&emsp;3. Connect the positive leg of an LED to pin D2 and the other leg in series with a 220 ohm resistor to ground.

&emsp;4. Plug in your battery.

&emsp;5. It is now a standalone receiver.

=== Step 6: Program the Transmitter ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino Wireless SD Shield Tutorial-Step6.JPG|thumb|none|500px|Arduino Wireless SD Shield Tutorial-Step6]] </li>
</ul></div>

&emsp;1. Plug in the Arduino for the transmitter. Make certain the micro switch is toggled to the "USB" option.

&emsp;2. Before you upload any code to the Arduino, open the serial monitor. Type in "h" and hit the "send" button.
<br>&emsp;&emsp;The LED on your receiver should light up. You have made a wireless connection!

<b>&emsp;3. Now upload the following code:</b>
<pre>/*

Wireless transmitter demo

Based on Button example code
http://www.arduino.cc/en/Tutorial/Button

The circuit:
* pushbutton attached to pin 2 from +5V
* 10K resistor attached to pin 2 from ground

This code is in the public domain.

*/

// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 2; // the number of the pushbutton pin

// variables will change:
int buttonState = 0; // variable for reading the pushbutton status

void setup() {
// initialize serial communication:
Serial.begin(9600);

// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT);
}

void loop(){
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);

// check if the pushbutton is pressed.
// if it is, the buttonState is HIGH:
if (buttonState == HIGH) {
//transmit a High command to the pumpkin and delay a second so that it does not receive more than one command
//per button press
Serial.println('h');
delay(1000);
}
}</pre>

=== Step 7: Setup the Transmitter ===
<div><ul>
<li style="display: inline-block;"> [[File:Arduino_Wireless_SD_Shield_Tutorial-Step7.JPG|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step7]] </li>
</ul></div>

&emsp;1. Unplug the Arduino from the computer. Toggle the micro switch from "USB" to "MICRO".

&emsp;2. Plug the red wire from a 9V battery connector into the Vin pin. Plug the black wire into the GND pin.

&emsp;3. Connect a 10K resistor between pin D2 and ground. Also connect a push button switch between pin D2 and 5v.

&emsp;4. Plug in your battery.

&emsp;5. It is now a standalone transmitter.

=== Step 8: Prepare the SD Card ===
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>:
Before you can use the micro SD card, it needs to be formatted to either FAT16 or FAT32.</div>

<div><ul>
<li style="display: inline-block;"> [[File:Arduino Wireless SD Shield Tutorial-Step8.JPG|thumb|none|500px|Arduino Wireless SD Shield Tutorial-Step8]] </li>
</ul></div>

<b>On Windows:</b>

&emsp;➥ Open "My Computer"

&emsp;➥ Right-click on the disk and select "Format"

&emsp;➥ Select "FAT" and click "start"

&emsp;➥ It is now formatted to FAT16

Once the disk is formatted, the next thing you have to do is make sure that you have the [https://github.com/adafruit/SD SD Card Library]. For instructions on how to setup the library, check out the bottom of Adafruit's extremely thorough [http://www.ladyada.net/products/microsd/ micro SD card tutorial].

Plug the SD card into the socket on the shield.

<b>To test the SD card, plug the Arduino into the computer and upload the following code:</b>

<pre>/*
SD card read/write

This example shows how to read and write data to and from an SD card file
The circuit:
* SD card attached to SPI bus as follows:
** MOSI - pin 11
** MISO - pin 12
** CLK - pin 13
** CS - pin 4

*/

#include <SD.h>

File myFile;

void setup()
{
Serial.begin(9600);
Serial.print("Initializing SD card...");
// On the Ethernet Shield, CS is pin 4. It's set as an output by default.
// Note that even if it's not used as the CS pin, the hardware SS pin
// (10 on most Arduino boards, 53 on the Mega) must be left as an output
// or the SD library functions will not work.
pinMode(10, OUTPUT);

if (!SD.begin(4)) {
Serial.println("initialization failed!");
return;
}
Serial.println("initialization done.");

// open the file. note that only one file can be open at a time,
// so you have to close this one before opening another.
myFile = SD.open("test.txt", FILE_WRITE);

// if the file opened okay, write to it:
if (myFile) {
Serial.print("Writing to test.txt...");
myFile.println("testing 1, 2, 3.");
// close the file:
myFile.close();
Serial.println("done.");
} else {
// if the file didn't open, print an error:
Serial.println("error opening test.txt");
}

// re-open the file for reading:
myFile = SD.open("test.txt");
if (myFile) {
Serial.println("test.txt:");

// read from the file until there's nothing else in it:
while (myFile.available()) {
Serial.write(myFile.read());
}
// close the file:
myFile.close();
} else {
// if the file didn't open, print an error:
Serial.println("error opening test.txt");
}
}

void loop()
{
// nothing happens after setup
}</pre>

== Used Hardware ==
&emsp;➠ [[ARDUINO Wireless Proto Shield]]

== References ==
&emsp;➠ https://forum.arduino.cc/index.php?board=63.0

&emsp;➠ https://www.arduino.cc/en/Reference/SD

&emsp;➠ https://store.arduino.cc/arduino-wireless-proto-shield

&emsp;➠ https://store.arduino.cc/arduino-wireless-proto-shield

&emsp;➠ http://www.ladyada.net/products/microsd/

&emsp;➠ https://github.com/adafruit/SD

[[Category:Documentation]]

Arduino Wireless SD Shield Tutorial: First Steps

2020-08-10T00:24:39Z

CCinay: Created page with "<div style="max-width: 970px"> == Summary == The Wireless Proto Shield for Arduino is an Arduino Shield that provides wireless communication capabilities to an Arduino board...."

<div style="max-width: 970px">

== Summary ==
The Wireless Proto Shield for Arduino is an Arduino Shield that provides wireless communication capabilities to an Arduino board. For this purpose, a chip for wireless communication is attached to the shield. This Wireless Proto Shield is based on Digi's Xbee module, but can be used by any model of the same size. The module can communicate indoors at a distance of up to 30 metres and outdoors at a distance of up to 90 metres (without obstacle).
The module can be used as a replacement for a USB-to-serial adapter or configured in control mode for a wide range of networking options.

The Wireless Proto Shield for Arduino has no SD socket.

An integrated switch on the shield allows the wireless module (Xbee chip) to communicate with the USB to serial converter or the microcontroller.
To learn more about the WireLess Proto Shield, see the product data sheet on the Arduino website: [http://arduino.cc/en/Main/ArduinoWirelessProtoShield ArduinoWirelessProtoShield]

<div><ul>
<li style="display: inline-block;"> <b>[[File:Arduino_Wireless_SD_Shield_Tutorial.jpg|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial]]</b> </li>
</ul></div>

== Description ==
As the name implies, the Arduino Wireless SD shield serves two functions. Foremost, this shield allows you to easily interface with Xbee transceiver modules to create mesh networks, and other wireless devices. Secondly, the micro SD socket allows you to store and access a large amount of data. Whether using these functions by on their own or together, this chip greatly enhances the capabilities of a standard Arduino.
The best part about this shield is how easy it is to use. In no time flat, you can have its various components up and running.

=== Step 1: Plug in the Xbee ===
<div><ul>
<li style="display: inline-block;"> <b>[[File:Arduino_Wireless_SD_Shield_Tutorial-Step1.jpg|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step1]]</b> </li>
</ul></div>

&emsp;1. Plug in your Xbee modules in order to use the shield as a wireless transceiver.

&emsp;2. Make sure the module's pointy end is lined up with the edge of the board.

&emsp;3. If you are using the shield for wireless data transfer, you will need two or more of them.

=== Step 2: Plug in the Xbee ===
<div><ul>
<li style="display: inline-block;"> <b>[[File:Arduino_Wireless_SD_Shield_Tutorial-Step2.jpg|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step2]]</b> </li>
</ul></div>

&emsp;➥ Plug your shields into your Arduinos.

=== Step 3: Features ===
<div><ul>
<li style="display: inline-block;"> <b>[[File:Arduino_Wireless_SD_Shield_Tutorial-Step3.JPG|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step3]]</b> </li>
</ul></div>

&emsp;1. The wireless SD shield supports [https://www.digi.com/products/embedded-systems/digi-xbee/rf-modules/2-4-ghz-rf-modules/xbee-zigbee#overview Xbee modules]. These modules allow for easy wireless serial communication. <br>&emsp;&emsp;A standard module has the range of 100 - 300 feet.

&emsp;2. It also boasts a micro SD socket. This can easily be interfaced with the [https://www.arduino.cc/en/Reference/SD Arduino SD library]. Unfortunately, this library<br>&emsp;&emsp; does not come bundled with the Arduino development environment, so you will have to set it up yourself.

&emsp;3. The shield also boasts a perfboard grid for prototyping your own circuit, and a micro switch for toggling between the USB port and micro SD port.

=== Step 4: Program the Receiver ===
<div><ul>
<li style="display: inline-block;"> <b>[[File:Arduino_Wireless_SD_Shield_Tutorial-Step4.JPG|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step4]]</b> </li>
</ul></div>

&emsp;➥ Plug one of the Arduinos into the computer. Make certain the micro switch is toggled to the "USB" option.

<b>Upload the following code:</b>
<pre>//Xbee receiver

int sentDat;

void setup() {
Serial.begin(9600);
pinMode(2, OUTPUT);
}

void loop() {
if (Serial.available() > 0) {
sentDat = Serial.read();

if(sentDat == 'h'){
//activate the pumpkin for one second and then stop
digitalWrite(2, HIGH);
delay(1000);
digitalWrite(2, LOW);
}
}
}</pre>

=== Step 5: Setup the Receiver ===
<div><ul>
<li style="display: inline-block;"> <b>[[File:Arduino_Wireless_SD_Shield_Tutorial-Step5.JPG|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step5]]</b> </li>
</ul></div>

&emsp;1. Unplug the Arduino from the computer. Toggle the micro switch from "USB" to "MICRO".

&emsp;2. Plug the red wire from a 9V battery connector into the Vin pin. Plug the black wire into the GND pin.

&emsp;3. Connect the positive leg of an LED to pin D2 and the other leg in series with a 220 ohm resistor to ground.

&emsp;4. Plug in your battery.

&emsp;5. It is now a standalone receiver.

=== Step 6: Program the Transmitter ===
<div><ul>
<li style="display: inline-block;"> <b>[[File:Arduino Wireless SD Shield Tutorial-Step6.JPG|thumb|none|500px|Arduino Wireless SD Shield Tutorial-Step6]]</b> </li>
</ul></div>

&emsp;1. Plug in the Arduino for the transmitter. Make certain the micro switch is toggled to the "USB" option.

&emsp;2. Before you upload any code to the Arduino, open the serial monitor. Type in "h" and hit the "send" button.
<br>&emsp;&emsp;The LED on your receiver should light up. You have made a wireless connection!

<b>&emsp;3. Now upload the following code:</b>
<pre>/*

Wireless transmitter demo

Based on Button example code
http://www.arduino.cc/en/Tutorial/Button

The circuit:
* pushbutton attached to pin 2 from +5V
* 10K resistor attached to pin 2 from ground

This code is in the public domain.

*/

// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 2; // the number of the pushbutton pin

// variables will change:
int buttonState = 0; // variable for reading the pushbutton status

void setup() {
// initialize serial communication:
Serial.begin(9600);

// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT);
}

void loop(){
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);

// check if the pushbutton is pressed.
// if it is, the buttonState is HIGH:
if (buttonState == HIGH) {
//transmit a High command to the pumpkin and delay a second so that it does not receive more than one command
//per button press
Serial.println('h');
delay(1000);
}
}</pre>

=== Step 7: Setup the Transmitter ===
<div><ul>
<li style="display: inline-block;"> <b>[[File:Arduino_Wireless_SD_Shield_Tutorial-Step7.JPG|thumb|none|500px|Arduino_Wireless_SD_Shield_Tutorial-Step7]]</b> </li>
</ul></div>

&emsp;1. Unplug the Arduino from the computer. Toggle the micro switch from "USB" to "MICRO".

&emsp;2. Plug the red wire from a 9V battery connector into the Vin pin. Plug the black wire into the GND pin.

&emsp;3. Connect a 10K resistor between pin D2 and ground. Also connect a push button switch between pin D2 and 5v.

&emsp;4. Plug in your battery.

&emsp;5. It is now a standalone transmitter.

=== Step 8: Prepare the SD Card ===
<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>:
Before you can use the micro SD card, it needs to be formatted to either FAT16 or FAT32.</div>

<div><ul>
<li style="display: inline-block;"> <b>[[File:Arduino Wireless SD Shield Tutorial-Step8.JPG|thumb|none|500px|Arduino Wireless SD Shield Tutorial-Step8]]</b> </li>
</ul></div>

<b>On Windows:</b>

&emsp;➥ Open "My Computer"

&emsp;➥ Right-click on the disk and select "Format"

&emsp;➥ Select "FAT" and click "start"

&emsp;➥ It is now formatted to FAT16

Once the disk is formatted, the next thing you have to do is make sure that you have the [https://github.com/adafruit/SD SD Card Library]. For instructions on how to setup the library, check out the bottom of Adafruit's extremely thorough [http://www.ladyada.net/products/microsd/ micro SD card tutorial].

Plug the SD card into the socket on the shield.

<b>To test the SD card, plug the Arduino into the computer and upload the following code:</b>

<pre>/*
SD card read/write

This example shows how to read and write data to and from an SD card file
The circuit:
* SD card attached to SPI bus as follows:
** MOSI - pin 11
** MISO - pin 12
** CLK - pin 13
** CS - pin 4

*/

#include <SD.h>

File myFile;

void setup()
{
Serial.begin(9600);
Serial.print("Initializing SD card...");
// On the Ethernet Shield, CS is pin 4. It's set as an output by default.
// Note that even if it's not used as the CS pin, the hardware SS pin
// (10 on most Arduino boards, 53 on the Mega) must be left as an output
// or the SD library functions will not work.
pinMode(10, OUTPUT);

if (!SD.begin(4)) {
Serial.println("initialization failed!");
return;
}
Serial.println("initialization done.");

// open the file. note that only one file can be open at a time,
// so you have to close this one before opening another.
myFile = SD.open("test.txt", FILE_WRITE);

// if the file opened okay, write to it:
if (myFile) {
Serial.print("Writing to test.txt...");
myFile.println("testing 1, 2, 3.");
// close the file:
myFile.close();
Serial.println("done.");
} else {
// if the file didn't open, print an error:
Serial.println("error opening test.txt");
}

// re-open the file for reading:
myFile = SD.open("test.txt");
if (myFile) {
Serial.println("test.txt:");

// read from the file until there's nothing else in it:
while (myFile.available()) {
Serial.write(myFile.read());
}
// close the file:
myFile.close();
} else {
// if the file didn't open, print an error:
Serial.println("error opening test.txt");
}
}

void loop()
{
// nothing happens after setup
}</pre>

== Used Hardware ==
&emsp;➠ [[ARDUINO Wireless Proto Shield]]

== References ==
&emsp;➠ https://forum.arduino.cc/index.php?board=63.0

&emsp;➠ https://www.arduino.cc/en/Reference/SD

&emsp;➠ https://store.arduino.cc/arduino-wireless-proto-shield

&emsp;➠ https://store.arduino.cc/arduino-wireless-proto-shield

&emsp;➠ http://www.ladyada.net/products/microsd/

&emsp;➠ https://github.com/adafruit/SD

[[Category:Documentation]]

File:Arduino Wireless SD Shield Tutorial-Step8.JPG

2020-08-10T00:17:38Z

CCinay:

File:Arduino Wireless SD Shield Tutorial-Step7.JPG

2020-08-10T00:16:39Z

CCinay:

File:Arduino Wireless SD Shield Tutorial-Step6.JPG

2020-08-10T00:15:40Z

CCinay:

File:Arduino Wireless SD Shield Tutorial-Step5.JPG

2020-08-10T00:14:53Z

CCinay:

File:Arduino Wireless SD Shield Tutorial-Step4.JPG

2020-08-10T00:14:07Z

CCinay:

File:Arduino Wireless SD Shield Tutorial-Step3.JPG

2020-08-10T00:13:17Z

CCinay:

File:Arduino Wireless SD Shield Tutorial-Step2.jpg

2020-08-10T00:12:18Z

CCinay:

File:Arduino Wireless SD Shield Tutorial-Step1.jpg

2020-08-10T00:11:39Z

CCinay:

File:Arduino Wireless SD Shield Tutorial.jpg

2020-08-10T00:09:49Z

CCinay:

UBIQUITI Ethernet Surge Protector, ETH-SP-G2: First Steps

2020-08-08T03:04:33Z

CCinay:

<div style="max-width: 970px">

== Description ==
<b>ESD protection for outdoor high-speed networks</b>

<div><ul>
<li style="display: inline-block;"> [[File:Ethernet_Surge_Protector.png|thumb|none|350px|Ethernet_Surge_Protector]] </li>
</ul></div>

<b>Ethernet surge protection, model ETH-SP-G2 from Ubiquiti Networks:</b>

The ETH-SP is a cost-effective solution for outdoor Ethernet devices to protect them from harmful electrostatic discharges and overvoltages.

All Ubiquiti airMAX devices already have an ESD built in, adding the ETH-SP can provide even more protection.
The ETH-SP is designed to protect Power over Ethernet (PoE) or non-PoE devices with connection speeds of up to 1Gbps. Two passive surge protectionRJ45 connectors ensure maximum device compatibility.

<b>Ideal für WISP-Netzwerke:</b>

Install two ETH-SPs: one near the terminal and the other at the point of entry into the building.
Harmful ESD discharges and overvoltages will be safely discharged by the ETH-SP and absorbed into the ground.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>:
For best possible protection, we recommend installing two voltage protection adapters. The first surge protector within one meter of the device data port to be protected and the second surge protector at the entry point of the site where the wired network equipment is located.</div>

=== Details ===
<table border frame=box>
<tr>
<td align="left">&emsp;Type</td>
<td align="left">&emsp;&emsp;Overvoltage protection</td>
</tr>
<tr>
<td align="left">&emsp;Colour</td>
<td align="left">&emsp;&emsp;white</td>
</tr>
<tr>
<td align="left">&emsp;EAN</td>
<td align="left">&emsp;&emsp;0817882023900</td>
</tr>
<tr>
<td align="left">&emsp;Manufacturer No.</td>
<td align="left">&emsp;&emsp;ETH-SP-G2</td>
</tr>
<tr>
<td align="left">&emsp;Lightning protection</td>
<td align="left">&emsp;&emsp;up to 10000 Ampere</td>
</tr>
<tr>
<td align="left">&emsp;More information</td>
<td align="left">&emsp;&emsp;Temperature (operating): -30 to 65 °C; Humidity (operating): 10 to 90 % non-condensing</td>
</tr>
</table>

== Overview about the hardware ==

<div><ul>
<li style="display: inline-block;"> [[File:Ethernet_Surge_Protector_ETH-SP-G2.JPG|thumb|none|350px|Ethernet_Surge_Protector_ETH-SP-G2]] </li>
</ul></div>

<b>1. ETH input/output port: </b>
Passive RJ45 Ethernet ports with surge protection.

<b>2. Grounding point: </b>
The ETH-SP-G2 must be grounded in one of the following ways:

&emsp;➥ Use the supplied self-tapping screws to ground the ETH-SP-G2 directly to a grounded metal post or structure. Alternatively

&emsp;➥ use an M5 machine screw and nut (not supplied) to attach a ground wire connected to a remote ground block or other grounded object.

== ESD Protection for Outdoor PoE Devices ==
Damaging electrostatic discharge attacks and surges are diverted to the ETH-SP and safely discharged into the ground, so network devices are protected.

<div><ul>
<li style="display: inline-block;"> [[File:Ethernet_Surge_Protector-Overview.jpg|thumb|none|400px|Ethernet_Surge_Protector-Overview]] </li>
</ul></div>

== Fast Installation ==
The ETH-SP was designed for easy, plug and play installation:

<div><ul>
<li style="display: inline-block;"> [[File:Ethernet_Surge_Protector-Install.jpg|thumb|none|600px|Ethernet_Surge_Protector-Install]] </li>
</ul></div>

== Used Hardware ==

&emsp;➠ [[Ethernet Surge Protector ETH-SP-G2]]

== References ==
&emsp;➠ https://dl.ubnt.com/qsg/ETH-SP-G2/ETH-SP-G2_DE.html

&emsp;➠ https://www.wlan-shop24.de/ubiquiti-ethernet-surge-protector-eth-sp-g2

[[Category:Documentation]]

File:Ethernet Surge Protector-Overview.jpg

2020-08-08T03:03:30Z

CCinay:

UBIQUITI Ethernet Surge Protector, ETH-SP-G2: First Steps

2020-08-08T02:58:50Z

CCinay: Created page with "<div style="max-width: 970px"> == Description == <b>ESD protection for outdoor high-speed networks</b> <div><ul> <li style="display: inline-block;"> File:Ethernet_Surge_P..."

<div style="max-width: 970px">

== Description ==
<b>ESD protection for outdoor high-speed networks</b>

<div><ul>
<li style="display: inline-block;"> [[File:Ethernet_Surge_Protector.png|thumb|none|350px|Ethernet_Surge_Protector]] </li>
</ul></div>

<b>Ethernet surge protection, model ETH-SP-G2 from Ubiquiti Networks:</b>

The ETH-SP is a cost-effective solution for outdoor Ethernet devices to protect them from harmful electrostatic discharges and overvoltages.

All Ubiquiti airMAX devices already have an ESD built in, adding the ETH-SP can provide even more protection.
The ETH-SP is designed to protect Power over Ethernet (PoE) or non-PoE devices with connection speeds of up to 1Gbps. Two passive surge protectionRJ45 connectors ensure maximum device compatibility.

<b>Ideal für WISP-Netzwerke:</b>

Install two ETH-SPs: one near the terminal and the other at the point of entry into the building.
Harmful ESD discharges and overvoltages will be safely discharged by the ETH-SP and absorbed into the ground.

<div style="border: 1px solid #31708f; background-color: #d9edf7; color: #31708f; padding: 5px 10px; margin-bottom: 5px; text-align: justify"><b>Note</b>:
For best possible protection, we recommend installing two voltage protection adapters. The first surge protector within one meter of the device data port to be protected and the second surge protector at the entry point of the site where the wired network equipment is located.</div>

=== Details ===
<table border frame=box>
<tr>
<td align="left">&emsp;Type</td>
<td align="left">&emsp;&emsp;Overvoltage protection</td>
</tr>
<tr>
<td align="left">&emsp;Colour</td>
<td align="left">&emsp;&emsp;white</td>
</tr>
<tr>
<td align="left">&emsp;EAN</td>
<td align="left">&emsp;&emsp;0817882023900</td>
</tr>
<tr>
<td align="left">&emsp;Manufacturer No.</td>
<td align="left">&emsp;&emsp;ETH-SP-G2</td>
</tr>
<tr>
<td align="left">&emsp;Lightning protection</td>
<td align="left">&emsp;&emsp;up to 10000 Ampere</td>
</tr>
<tr>
<td align="left">&emsp;More information</td>
<td align="left">&emsp;&emsp;Temperature (operating): -30 to 65 °C; Humidity (operating): 10 to 90 % non-condensing</td>
</tr>
</table>

== Overview about the hardware ==

<div><ul>
<li style="display: inline-block;"> [[File:Ethernet_Surge_Protector_ETH-SP-G2.JPG|thumb|none|350px|Ethernet_Surge_Protector_ETH-SP-G2]] </li>
</ul></div>

<b>1. ETH input/output port: </b>
Passive RJ45 Ethernet ports with surge protection.

<b>2. Grounding point: </b>
The ETH-SP-G2 must be grounded in one of the following ways:

&emsp;➥ Use the supplied self-tapping screws to ground the ETH-SP-G2 directly to a grounded metal post or structure. Alternatively

&emsp;➥ use an M5 machine screw and nut (not supplied) to attach a ground wire connected to a remote ground block or other grounded object.

== Fast Installation ==
The ETH-SP was designed for easy, plug and play installation:

<div><ul>
<li style="display: inline-block;"> [[File:Ethernet_Surge_Protector-Install.jpg|thumb|none|600px|Ethernet_Surge_Protector-Install]] </li>
</ul></div>

== Used Hardware ==

&emsp;➠ [[Ethernet Surge Protector ETH-SP-G2]]

== References ==
&emsp;➠ https://dl.ubnt.com/qsg/ETH-SP-G2/ETH-SP-G2_DE.html

&emsp;➠ https://www.wlan-shop24.de/ubiquiti-ethernet-surge-protector-eth-sp-g2

[[Category:Documentation]]