int switchState = digitalRead(SWITCHPIN);
digitalWrite(LEDPIN, switchState);

int tempRead = analogRead(TEMPPIN);
int tempMapped = map(tempRead, 0, 1023, 0, 255);
analogWrite(MOTORPIN, tempMapped);

void adjustLight(){
    int switchState = digitalRead(SWITCHPIN);
    digitalWrite(LEDPIN, switchState);
}

const int SWITCHPIN = 3;
const int LEDPIN = 6;
const int TEMPPIN = A2;
const int MOTORPIN = 5;

void setup(){
    pinMode(SWITCHPIN, INPUT);
    pinMode(LEDPIN, OUTPUT);
    pinMode(TEMPPIN, INPUT);
    pinMode(MOTORPIN, OUTPUT);
}

void loop(){
    adjustLight(); // this simply calls the adjustLight() function below
    adjustMotor(); // calls the adjustMotor() function below
    delay(10);
}

void adjustLight(){
    int switchState = digitalRead(SWITCHPIN);
    digitalWrite(LEDPIN, switchState);
}

void adjustMotor(){
    int tempRead = analogRead(TEMPPIN);
    int tempMapped = map(tempRead, 0, 1023, 0, 255);
    analogWrite(MOTORPIN, tempMapped);
}

/*
   Blink Without Blocking

   Demonstrates how to use an "event loop" timer to avoid unnecessary delays in code.
   This sort of form allows you to juggle multiple inputs and outputs more easily.

   The code below will blink the on-board LED every 250 milliseconds, and a second LED
   (on pin 10) every 333 milliseconds. Since there are no delay() statements, these two
   differently-timed events do not interfere with each other.

   Robert Zacharias, 2/2017; updated 9/2018
   released to the public domain by the author
*/

// the "global" variables in this top section can be used by any function in the whole sketch

const int QUARTERLEDPIN = 13; // this varialble will always have this value, so it can be a "const" (constant) variable
const int QUARTERWAIT = 250; // this variable, of type integer, is the number of milliseconds to wait between blinks
unsigned long quarterTimer = 0; // this variable, of type "unsigned long," will help keep track of passing time
bool quarterLightState = LOW; // this variable, of type boolean, will keep track of the current quarter-second LED state

const int THIRDLEDPIN = 10; // LED pluggged into pin 10
const int THIRDWAIT = 333; // a third of a second, in milliseconds
unsigned long thirdTimer = 0; // each event loop needs a unique timer variable
bool thirdLightState = LOW;

void setup() {
  pinMode(QUARTERLEDPIN, OUTPUT); // pin 13 is connected to the on-board LED on an Arduino Uno
  pinMode(THIRDLEDPIN, OUTPUT); // pin 10, according to the definition of THIRDLEDPIN above
}

void loop() {

  // if it has at least 250 milliseconds since the quarter-second light last changed:
  if ( (millis() - quarterTimer) >= QUARTERWAIT ) { // millis() is always the number of milliseconds since the Arduino powered up
    quarterLightState = !quarterLightState; // this will "toggle" the value of "quarterStateLight" to its opposite
    quarterTimer = millis(); // reset the timer before exiting the function.
  }
  // (if it has *not* been long enough, the control will just go past the if statement)

  // if it has at least 330 milliseconds since the third-of-a-second light last changed:
  if ( (millis() - thirdTimer) >= THIRDWAIT ) { // millis() is always the number of milliseconds since the Arduino powered up
    thirdLightState = !thirdLightState; // this will "toggle" the value of "quarterStateLight" to its opposite
    thirdTimer = millis(); // reset the timer before exiting the function.
  }

  digitalWrite(QUARTERLEDPIN, quarterLightState); // will make the LED to either go on or off, depending on the value of "quarterLight"
  digitalWrite(THIRDLEDPIN, thirdLightState);
}

void setup(){
    Serial.begin(9600);
}

void loop(){
    int potVal = analogRead(A0);
    Serial.println(potVal);
    delay(50); // just to slow down the torrent of data a bit
}

Serial.print("potVal = ");
Serial.print(potVal);
Serial.print(", lightval = ");
Serial.print(lightVal); // see below for why this one line is iffy!

Serial.print("potVal = ");
Serial.print(potVal);
Serial.print(", lightval = ");
Serial.println(lightVal);

void setup(){
    int val = 10;
}

void loop(){
    int num = val * 5;
}

int val;
int num;

void setup(){
    val = 10;
}

void loop(){
    num = val * 5;
}

void loop(){
    int x = 0;
    x++;
}

void loop(){
    static int x = 0;
    x++;
}

for (int i = 0; i++; i<10)

int i = 0;
for (i; i++; i<10)

/*
  Smoothing

  Reads repeatedly from an analog input, calculating a running average and
  printing it to the computer. Keeps ten readings in an array and continually
  averages them.

  The circuit:
  - analog sensor (potentiometer will do) attached to analog input 0

  created 22 Apr 2007
  by David A. Mellis  <dam@mellis.org>
  modified 9 Apr 2012
  by Tom Igoe
  modified 21 Jan 2018
  by Joseph Paetz

  This example code is in the public domain.

  http://www.arduino.cc/en/Tutorial/Smoothing
*/

/*
 * Global variables in this section can be used by any function in the whole sketch
 */
// Define the number of samples to keep track of. The higher the number, the
// more the readings will be smoothed, but the slower the output will respond to
// the input. Using a constant rather than a normal variable lets us use this
// value to determine the size of the readings array.
const int NUM_READINGS = 10;

// the readings from the analog input. This is an array of type int (essentially a list of integers)
// The number of integers the array can hold is between the square brackets, in this case NUM_READINGS
int readings[NUM_READINGS];  

// the index of the current reading (The location in the readings array where we will write the next reading
// (remember that the first element in an array is actually at index 0) 
int readIndex = 0;              
int total = 0;                  // the running total of all readings in the readings array
int average = 0;                // the average
const int SENSOR_PIN = A0;              // the sensor's pin

void setup() {
  // Setup the Serial port at a speed of 9600 baud (bits per second)
  Serial.begin(9600);
  
  pinMode(SENSOR_PIN, INPUT);
  
  // initialize all the integers in the readings array to 0, since values in an array
  // may not be 0 at the start of the sketch. 
  // Since the array will be all zeros at the start of the loop, the filtered value will
  // be influenced by these zeros (and likely innacurate as a result) until we get enough
  // sensor readings to fill the array with actual values.
  for (int thisReading = 0; thisReading < NUM_READINGS; thisReading++) {
    readings[thisReading] = 0;
  }
}

void loop() {
  // subtract the last reading which is at the current readIndex, and which
  // we are about to overwrite:
  total = total - readings[readIndex];
  
  // read from the sensor:
  readings[readIndex] = analogRead(SENSOR_PIN);

  // add the reading to the total
  // If you have more readings, this may cause total to overflow
  total = total + readings[readIndex];
  
  // advance to the next position in the array:
  readIndex = readIndex + 1;

  // if we're at the end of the array (aka readIndex is too large to refer to a position in the readings array)
  if (readIndex >= NUM_READINGS) {
    // wrap around to the beginning:
    readIndex = 0;
  }

  // calculate the average 
  //Since we are dividing two variables with int data types, this will truncate any decimal part of the average 
  //in order to leave us with an integer result
  average = total / NUM_READINGS;
  
  // send it to the computer as ASCII digits
  Serial.println(average);
  delay(50);        // delay in between reads for stability
}

new_average = (previous_average * x) + (sensor_reading * (1 - x))

/*
 * Exponential Decay Filter
 * 
 * Demonstrates how to implement an exponential decay filter.
 * In this example, analog readings from pin A0 will be filtered.
 * 
 * The circuit:
 *  - analog sensor (potentiometer will do) attached to analog input 0
 * 
 * Joseph Paetz 1/2018
 * released to the public domain by the author
 */

// "global" variables in this section can be used by any function in the whole sketch
float filtered_val = 0;  // this variable, of type float (decimal), holds the filtered sensor value
const float PREV_WEIGHT = 0.8; // this variable, of type float (decimal), determines the previously filtered value's weight.
const float CUR_WEIGHT = 1 - PREV_WEIGHT; // this variable, of type float (decimal), determines the current sample's weight.
const int SENSOR_PIN = A0; // this variable, of type int, determines the sensor's pin.

void setup() {
  // Setup the Serial port at a speed of 9600 baud (bits per second)
  Serial.begin(9600);
  
  pinMode(SENSOR_PIN, INPUT);

  // We want to initialize the filtered value with an actual reading (instead of zero) 
  // so the filtered value does not need to "ramp up" from zero to the average reading.
  // We could not do this above since code can only be executed within functions.
  filtered_val = analogRead(SENSOR_PIN);

  // Print the intial value so we can see it
  Serial.print("initial filtered value: ");
  Serial.println(filtered_val);
}

void loop() {
  // This local variable of type float will store the current sensor reading.
  // We use a float because we will be multiplying it by a float later.
  float cur_reading;

  // We can convert the integer value returned by analogRead to a float by casting it
  cur_reading = (float)analogRead(SENSOR_PIN);

  // Calculate the next filtered value
  filtered_val = filtered_val * PREV_WEIGHT + cur_reading * CUR_WEIGHT;

  // Print the filtered value so we can see it
  Serial.print("filtered value: ");
  Serial.println(filtered_val);

  // Delay a little bit so we are not reading the sensor quite so fast
  delay(50);
}

/*
   Frequency finder: assumes a square-wave digital signal on an input pin
   (pin 2 specifically) and computes an exponential running average of the
   frequency of the oscillation of that signal, reported in hertz.

   Because it's using the Arduino's interrupt capability, this counter is
   able to run fairly quickly, and should be able to be used for signals
   in the ~kilohertz range. (This is not tested as of this writing!)

   How it works:
   An "interrupt" pin (a pin with the ability to detect electrical changes at a
   high rate, even while other code is running) is assigned. Whenever pin 2's
   signal goes from 0V to 5V, the "Interrupt Service Routine" (ISR) is immediately
   called, which here runs a function called readPulse(). That function simply
   increments a counter. Every TIMERWAIT milliseconds (the user can change this value),
   the number of increments since the last check is calculated; the instantaneous
   frequency is simply the number of pulses divided by TIMERWAIT in seconds.

   The running average of the frequency of oscillation (in hertz) is stored in
   the variable called "averagedFreq." If the global variable "SERIALFEEDBACK" is
   declared as "true" then the value of "averagedFreq" will be reported to the
   serial monitor every "WAIT" milliseconds, which is useful for debugging. You may
   also use a different piece of software (such as Matlab, Mathematica, etc.) to read
   this value for analysis, storage, control, etc.

   by Robert Zacharias, rzachari@andrew.cmu.edu
   Carnegie Mellon University, Pittsburgh, Pennsylvania
   released to the public domain by the author, 2018
*/

// set SERIALFEEDBACK to true to return serial feedback (optional)
const bool SERIALFEEDBACK = true;

const int SERIALWAIT = 100; // milliseconds between serial prints

// milliseconds between: 1) calculating new instanteous frequency and 2) performing
// exponential smoothing operation including that new data point
const int TIMERWAIT = 100;

// This variable is used to calculate the exponential running average:
// higher OLDWEIGHT means *more* smoothing operates, and lower OLDWEIGHT means
// the newly arrived data points have more weight, i.e. *less* smoothing.
// (0 ≤ OLDWEIGHT ≤ 1)
const float OLDWEIGHT = 0.9;

// do not reassign this pin casually; it needs to be an interrupt-capable pin
const byte READPIN = 2;

// volatile data type needed for the count because its value will be affected by the ISR
volatile unsigned long count;

float averagedFreq, instantaneousFreq; // variables to store frequency data
unsigned long timer; // variable to store last time the frequency calculator ran

void setup() {

  // setup pin 2 as the input for the device
  pinMode(READPIN, INPUT);

  //  assign pin 2 as an "interrupt" pin. In this case, every time a "rising"
  //  signal is seen on pin 2 (i.e. going from 0V to 5V), the function called
  //  readPulse() will immediately run. That function is defined below the loop().
  attachInterrupt(digitalPinToInterrupt(READPIN), readPulse, RISING);

  Serial.begin(115200);
  delay(200);
}

void loop() {

  // every TIMERWAIT milliseconds, calculate new instantaneous frequency
  // and run the exponential smoothing operation with that new data
  if (millis() - timer > TIMERWAIT) {
    static unsigned long lastCount;

    // the variable "count" will be incremented by the ISR function, "readPulse()"
    unsigned long countDiff = count - lastCount;

    // convert from frequency per TIMERWAIT milliseconds to frequency per second
    instantaneousFreq = countDiff * (1000 / TIMERWAIT);

    // the exponential smoothing operation
    averagedFreq = (averagedFreq * OLDWEIGHT) + (instantaneousFreq * (1.0 - OLDWEIGHT));

    // reset counter and timer for next time this if() runs
    lastCount = count;
    timer = millis();
  }

  /*
     User can insert whatever function(s) they'd like based on averagedFreq.
     For instance:

     To calculate a flow rate through a pipe with a hall-effect flow sensor:

        float flowrate = averagedFreq * VALUE;

      where VALUE is an empirically determined constant associated with that particular
      piece of hardware.

      Or:

        if (averagedFreq > 150) {
          something that is triggered at any higher frequency than 150Hz
        }
        else if (averagedFreq > 100) {
          something that's triggered when (100Hz < averagedFreq ≤ 150Hz)
        }
        else {
          something that's triggered when (averagedFreq ≤ 100Hz)
        }

  */

  // optional serial feedback will print the averageFreq every SERIALWAIT milliseconds
  if (SERIALFEEDBACK) {
    static unsigned long lastDebugPrint = 0;
    if (millis() - lastDebugPrint > SERIALWAIT) {
      Serial.println(averagedFreq);
      lastDebugPrint = millis();
    }
  }
}

// the Interrupt Service Routine (ISR) that is called whenever pin 2 transitions 0V -> 5V
void readPulse() {
  count++;
}