Lab 4 Exercises

Hi world,

Long time, no post (kind of...)! Here are Lab 4 exercises...


Storing in non-volatile memory.


One approach:


#include <EEPROM.h>

int readvalue;
int command;
int input;
int buffer;
int address = 0;
int valueArray[] = {255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255}; // Used only for testing code

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

void loop() {
command = Serial.read();

if (command == 'w')
{
Serial.print("What would you like to store in address #");
Serial.print(address);
Serial.println("?");
Serial.flush();
input = Serial.read();
//Serial.println(input);
while (input == -1) {
if(Serial.available()>0){
delay(15);
buffer = 0;
input = 0;
 
while(Serial.available()>0){
buffer = Serial.read();
input = input*10 + (buffer-'0');
}
}
}

EEPROM.write(address,input);
valueArray[address] = input;
Serial.println(address);
Serial.println(input);
Serial.println("Okay!");
address++;
if (address == 512)
{
  address = 0;
}
}

if (command == 'r') {

readvalue = 0;
for (int i = 0; readvalue != 255; i++) {
readvalue = EEPROM.read(i);
//readvalue = valueArray[i];

if (readvalue != 255){
Serial.println(readvalue);
}
else if (readvalue == 255)
{
 Serial.println("The address #");
 Serial.print(i);
 Serial.println(" is empty");
}
}
}

This one doesn't have a clear-all feature :(

And another approach (arguably superior, haha):


#include <EEPROM.h>

int buffer = 0;
int value = 0;
byte valueByte;
int address = 1;
int counterAddress = 0;
int keyPress = 0;
//int valueArray[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; // Used only for testing code

void setup(){
Serial.begin(9600);
Serial.println("Start:");
}

void loop(){
keyPress = 0;
if(Serial.available()>0){
delay(5);
keyPress = Serial.read();
if(keyPress == 'w'){
Serial.print("Enter number to address ");
Serial.println(address);
while(1){
if(Serial.available()>0){
delay(15);
value = 0;
valueByte = 0;
while(Serial.available()>0){
buffer = Serial.read();
value = value*10 + (buffer-'0');
}
       
valueByte = byte(value);
Serial.print("saving ");
Serial.print(value);
Serial.print(" at ");
Serial.println(address);
//valueArray[address] = value; // Used only for testing code
EEPROM.write(address, valueByte); // EEPROM writing
address++;
EEPROM.write(counterAddress, byte(address));
break;
}
}
//Serial.println("Out of loop"); // Used for testing only
}
 
else if(keyPress == 'r'){
Serial.println("Reading all values in EEPROM array:");
for(int i=1;i<EEPROM.read(counterAddress);i++){
Serial.print(i);
Serial.print(" ");
//Serial.println(valueArray[i]); // Used only for testing
Serial.println(int(EEPROM.read(i)));
}
}
 
 else if(keyPress == 'q'){
 Serial.println("Do you want to reset the addresses? (y/n)");
 while(1){
 if(Serial.available()>0){
 delay(5);
 keyPress = Serial.read();
 if(keyPress == 'y'){
 address = 1;
 EEPROM.write(counterAddress,byte(0));
 break;
 }

if(keyPress == 'n'){
break;
}
}
}
}
 
else{
Serial.println("Unrecognized Key");
}
}
}

...........

And here's Winslow's massive code for the data-logger portion of the lab @_@...........

Build a data-logger.

#include <EEPROM.h>

int sensorPin = 3;

unsigned long time;

unsigned long startTime;

unsigned long endTime;

unsigned long testDuration = 180000;

unsigned long takeSample = 15000;

int counter = 0;

int value = 0;

byte valueByte;

int address = 1;

int counterAddress = 0;

int keyPress = 0;

int valueArray[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; // Used only for testing code

void setup(){

  Serial.begin(9600);

  Serial.println("Start:");

  Serial.println("Press w to record data or Press r to read data.");

}

void loop(){

  keyPress = 0;

  if(Serial.available()>0){

    delay(5);

    keyPress = Serial.read();

    if(keyPress == 'w'){

      startTime = millis();

      time = startTime;

      endTime = time + testDuration;

      while(time<=endTime){

        time = millis();

        if(time>=(counter*takeSample+startTime)){

          value = RCtime(sensorPin);

          valueByte = byte(value);

          Serial.print("saving "); 

          Serial.print(int(valueByte)); 

          Serial.print(" at "); 

          Serial.println(address);

          valueArray[address] = valueByte; // Used only for testing code

//          EEPROM.write(address, valueByte); // EEPROM writing

          address++;

          counter++;

//          EEPROM.write(counterAddress, byte(address));

          valueArray[0] = address; // Used only for testing code

        }

      }

      Serial.println("Finished Testing!"); // Used for testing only

    }

    else if(keyPress == 'r'){

      Serial.println("Reading all values from previous test:");

      for(int i=1;i<valueArray[0];i++){ // In actual code i<EEPROM.read(counterAddress)

        Serial.print(i);

        Serial.print(" ");

        Serial.println(int(valueArray[i])); // Used only for testing

//        Serial.println(EEPROM.read(i));

      }

    }

    else if(keyPress == 'q'){

      Serial.println("Do you want to reset the data? (y/n)");

      while(1){

        if(Serial.available()>0){

          delay(5);

          keyPress = Serial.read();

          if(keyPress == 'y'){

            address = 1;

            //EEPROM.write(counterAddress,byte(0));

            valueArray[0] = 0; // Used for testing code

            break;

          }

          if(keyPress == 'n'){

            break;

          }

        }

      }

    }

    else{

      Serial.println("Unrecognized Key");

    }

  }

}

long RCtime(int sensPin){

long result = 0;

pinMode(sensPin, OUTPUT); // make pin OUTPUT

digitalWrite(sensPin, HIGH); // make pin HIGH to discharge capacitor - study the schematic

delay(1); // wait a ms to make sure cap is discharged

pinMode(sensPin, INPUT); // turn pin into an input and time till pin goes low

digitalWrite(sensPin, LOW); // turn pullups off - or it won't work

while(digitalRead(sensPin)){ // wait for pin to go low

result++;

}

return result; // report results

}

.
.
.
.
.


And then, fun with servos:
.
.
.
.
.


unsigned long time;
unsigned int pulseTime = 1500;
unsigned int currentPulse = 1500;
unsigned long waitTime = 20000;
unsigned long stamp;
int servoPin = 6;
int buffer;
int modSub;

void setup(){
  Serial.begin(9600);
  pinMode(servoPin, OUTPUT);
  digitalWrite(servoPin, LOW);
  Serial.println("Start:");
  Serial.println("Enter pulse time in microseconds:");
}

void loop(){
  if(Serial.available()>0){
    delay(15);
    buffer = 0;
    currentPulse = pulseTime;
    pulseTime= 0;
    while(Serial.available()>0){
      buffer = Serial.read();
      pulseTime = pulseTime*10 + (buffer-'0');
    }
    if(pulseTime%10!=0){
      modSub = pulseTime%10;
      pulseTime -= modSub;
    }
    Serial.print("Pulse time is ");
    Serial.println(pulseTime);
  }
  if(micros() >= stamp+waitTime){
    stamp = micros();
    if(currentPulse!=pulseTime){
      if(currentPulse<pulseTime){
        currentPulse+=10;
      }
      if(currentPulse>pulseTime){
        currentPulse-=10;
      }
    }
    digitalWrite(servoPin, HIGH);
    delayMicroseconds(currentPulse);
    digitalWrite(servoPin, LOW);
    delay(10);
  }





.
.
.
.
.



unsigned int pulseTime = 1000;
unsigned long waitTime = 20000;
unsigned long waitTimeChange = 100;
unsigned long stamp;
unsigned long stampChange;
int servoPin = 6;
int buffer;
int changer;

void setup(){
  Serial.begin(9600);
  pinMode(servoPin, OUTPUT);
  digitalWrite(servoPin, LOW);
  Serial.println("Start:");
  Serial.println("Enter rotation speed in milliseconds:");
}

void loop(){
  if(Serial.available()>0){
    delay(15);
    waitTimeChange= 0;
    while(Serial.available()>0){
      buffer = Serial.read();
      waitTimeChange = waitTimeChange*10 + (buffer-'0');
    }
    if(waitTimeChange < 20){
      waitTimeChange = 20;
    }
    if(waitTimeChange > 1000){
      waitTimeChange = 1000;
    }
    Serial.print("Wait time between rotations is ");
    Serial.println(waitTimeChange);
  }
  if(pulseTime == 1000){
    changer = 0;
  }
  if(pulseTime == 2000){
    changer = 1;
  }
  if(micros() >= stamp+waitTime){
    stamp = micros();
    if(millis() >= stampChange+waitTimeChange){
      stampChange = millis();
      if(changer==0){
        pulseTime++;
      }
      if(changer==1){
        pulseTime--;
      }
    }
    digitalWrite(servoPin, HIGH);
    delayMicroseconds(pulseTime);
    digitalWrite(servoPin, LOW);
    delay(10);
  }
}