Arduino:Πάλι μη-γραμμικότητα, κάνω κάτι λάθος?

**selectronic** · 04-04-17, 10:03

Βίντεο, δυστυχώς άθλιας ποιότητας:

Με τον κώδικα που έβαλα στο #57 με τα πολλά και μοιρασμένα delays:

**manolena** · 04-04-17, 10:03

Στο συμμάζεψα λίγο, κάνε μια δοκιμή με 20x2 οθόνη:

Κώδικας:

#include <LiquidCrystal.h>


//===================================================================
// LiquidCrystal lcd(2, 4, 6, 7, 8, 9);
LiquidCrystal lcd(2, 8, 4, 5, 6, 7);
//===================================================================
long Vref11 = 1122000L;  // Boards Internal 1.1Vref
float CalibV = 2.0;    // 'Calibrate' value
int Read1 = A0;
int Read2 = A2;
long readVcc;
float OnePercentADC, percentADC;
float VccReal = (float) readVcc / 1000;
int rawADC0, rawADC1, rawADC2, rawADC3, rawADC4, rawADC5, rawADC6, 
    rawADC7, rawADC8, rawADC9, rawADC10, rawADC11, rawADC12, rawADC13, 
    rawADC14, rawADC15, rawADC16, rawADC17, rawADC18, rawADC19 = 0; 
int average;  
float average2 = 0;
int count = 0;
//===================================================================
void setup() 
{  
  lcd.begin(16, 2);// lcd.begin(20, 2);
}
//===================================================================
void loop()
{
  lcd.setCursor(0, 0);
  lcd.print(millis() / 1000);




  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1); 
  delay(10); // Wait for Vref to settle 
  ADCSRA |= _BV(ADSC); // Convert 
  while (bit_is_set(ADCSRA,ADSC)); 
  readVcc = ADCL; 
  readVcc |= ADCH<<8; 
  readVcc = Vref11 / readVcc; // Back-calculate AVcc in mV 


  lcd.setCursor(0, 1);
  lcd.print(VccReal,2);


  measureVoltageAverage();
  measureVoltage_1_Average();
  delay(200);


}
//===================================================================
void measureVoltageAverage()
{
  // Measure multiple times the Analog Pin and make an 'Average':
  //
  // Take multiple measurements of the same AnalogInput
  rawADC0 = analogRead (Read1);
  rawADC1 = analogRead (Read1);
  rawADC2 = analogRead (Read1);
  rawADC3 = analogRead (Read1);
  rawADC4 = analogRead (Read1);
  rawADC5 = analogRead (Read1);
  rawADC6 = analogRead (Read1);
  rawADC7 = analogRead (Read1);
  rawADC8 = analogRead (Read1);
  rawADC9 = analogRead (Read1);
  rawADC10 = analogRead (Read1);
  rawADC11 = analogRead (Read1);
  rawADC12 = analogRead (Read1);
  rawADC13 = analogRead (Read1);
  rawADC14 = analogRead (Read1);
  rawADC15 = analogRead (Read1);
  rawADC16 = analogRead (Read1);
  rawADC17 = analogRead (Read1);
  rawADC18 = analogRead (Read1);
  rawADC19 = analogRead (Read1);
  // Make first average of those values
  average = (rawADC0 + rawADC1 + rawADC2 + rawADC3 + rawADC4 + rawADC5 + rawADC6 + rawADC7 + rawADC8 + rawADC9 + rawADC10 + rawADC11 + rawADC12 + rawADC13 + rawADC14 + rawADC15 + rawADC16 + rawADC17 + rawADC18 + rawADC19) / 20;
  // Make the 'int' average value into a 'float', calc 1/1000 of that average value and select percent under/over to be "discarded"
  OnePercentADC = (float) average / 1000;
  percentADC = OnePercentADC * 6; // Percent of "tolerance" before a value is discarted, in -Thousands- of the average value
  // From the previous values, exclude those that are 10% more/less than made 'average' value, and re-calculate a new average
  average2 = 0;
  count = 0;
  if (rawADC0 <= average+percentADC && rawADC0 >= average-percentADC) {
    average2 = average2 + rawADC0; 
    count++;
  }
  if (rawADC1 <= average+percentADC && rawADC1 >= average-percentADC) {
    average2 = average2 + rawADC1; 
    count++;
  }
  if (rawADC2 <= average+percentADC && rawADC2 >= average-percentADC) {
    average2 = average2 + rawADC2; 
    count++;
  }
  if (rawADC3 <= average+percentADC && rawADC3 >= average-percentADC) {
    average2 = average2 + rawADC3; 
    count++;
  }
  if (rawADC4 <= average+percentADC && rawADC4 >= average-percentADC) {
    average2 = average2 + rawADC4; 
    count++;
  }
  if (rawADC5 <= average+percentADC && rawADC5 >= average-percentADC) {
    average2 = average2 + rawADC5; 
    count++;
  }
  if (rawADC6 <= average+percentADC && rawADC6 >= average-percentADC) {
    average2 = average2 + rawADC6; 
    count++;
  }
  if (rawADC7 <= average+percentADC && rawADC7 >= average-percentADC) {
    average2 = average2 + rawADC7; 
    count++;
  }
  if (rawADC8 <= average+percentADC && rawADC8 >= average-percentADC) {
    average2 = average2 + rawADC8; 
    count++;
  }
  if (rawADC9 <= average+percentADC && rawADC9 >= average-percentADC) {
    average2 = average2 + rawADC9; 
    count++;
  }
  if (rawADC10 <= average+percentADC && rawADC10 >= average-percentADC) {
    average2 = average2 + rawADC10; 
    count++;
  }
  if (rawADC11 <= average+percentADC && rawADC11 >= average-percentADC) {
    average2 = average2 + rawADC11; 
    count++;
  }
  if (rawADC12 <= average+percentADC && rawADC12 >= average-percentADC) {
    average2 = average2 + rawADC12; 
    count++;
  }
  if (rawADC13 <= average+percentADC && rawADC13 >= average-percentADC) {
    average2 = average2 + rawADC13; 
    count++;
  }
  if (rawADC14 <= average+percentADC && rawADC14 >= average-percentADC) {
    average2 = average2 + rawADC14; 
    count++;
  }
  if (rawADC15 <= average+percentADC && rawADC15 >= average-percentADC) {
    average2 = average2 + rawADC15; 
    count++;
  }
  if (rawADC16 <= average+percentADC && rawADC16 >= average-percentADC) {
    average2 = average2 + rawADC16; 
    count++;
  }
  if (rawADC17 <= average+percentADC && rawADC17 >= average-percentADC) {
    average2 = average2 + rawADC17; 
    count++;
  }
  if (rawADC18 <= average+percentADC && rawADC18 >= average-percentADC) {
    average2 = average2 + rawADC18; 
    count++;
  }
  if (rawADC19 <= average+percentADC && rawADC19 >= average-percentADC) {
    average2 = average2 + rawADC19; 
    count++;
  }
  average = average2 / count;
  float voltage = ((float) average + CalibV ) / 1024.0 * VccReal; 


  lcd.setCursor(5, 0);
  lcd.print(voltage,3);
  lcd.print("V");


  lcd.setCursor(12, 0);
  lcd.print(average);


  //   lcd.setCursor(17, 0);
  //   lcd.print("  ");
  //   lcd.setCursor(17, 0);
  //   lcd.print(count);
}
//===================================================================
void measureVoltage_1_Average()
{
  rawADC0 = analogRead (Read2);
  rawADC1 = analogRead (Read2);
  rawADC2 = analogRead (Read2);
  rawADC3 = analogRead (Read2);
  rawADC4 = analogRead (Read2);
  rawADC5 = analogRead (Read2);
  rawADC6 = analogRead (Read2);
  rawADC7 = analogRead (Read2);
  rawADC8 = analogRead (Read2);
  rawADC9 = analogRead (Read2);
  rawADC10 = analogRead (Read2);
  rawADC11 = analogRead (Read2);
  rawADC12 = analogRead (Read2);
  rawADC13 = analogRead (Read2);
  rawADC14 = analogRead (Read2);
  rawADC15 = analogRead (Read2);
  rawADC16 = analogRead (Read2);
  rawADC17 = analogRead (Read2);
  rawADC18 = analogRead (Read2);
  rawADC19 = analogRead (Read2);
  average = (rawADC0 + rawADC1 + rawADC2 + rawADC3 + rawADC4 + rawADC5 + rawADC6 + rawADC7 + rawADC8 + rawADC9 + rawADC10 + rawADC11 + rawADC12 + rawADC13 + rawADC14 + rawADC15 + rawADC16 + rawADC17 + rawADC18 + rawADC19) / 20;
  OnePercentADC = (float) average / 1000;
  percentADC = OnePercentADC * 6; // Percent of "tolerance" before a value is discarted, in -Thousands- of the average value
  average2 = 0;
  count = 0;
  if (rawADC0 <= average+percentADC && rawADC0 >= average-percentADC) {
    average2 = average2 + rawADC0; 
    count++;
  }
  if (rawADC1 <= average+percentADC && rawADC1 >= average-percentADC) {
    average2 = average2 + rawADC1; 
    count++;
  }
  if (rawADC2 <= average+percentADC && rawADC2 >= average-percentADC) {
    average2 = average2 + rawADC2; 
    count++;
  }
  if (rawADC3 <= average+percentADC && rawADC3 >= average-percentADC) {
    average2 = average2 + rawADC3; 
    count++;
  }
  if (rawADC4 <= average+percentADC && rawADC4 >= average-percentADC) {
    average2 = average2 + rawADC4; 
    count++;
  }
  if (rawADC5 <= average+percentADC && rawADC5 >= average-percentADC) {
    average2 = average2 + rawADC5; 
    count++;
  }
  if (rawADC6 <= average+percentADC && rawADC6 >= average-percentADC) {
    average2 = average2 + rawADC6; 
    count++;
  }
  if (rawADC7 <= average+percentADC && rawADC7 >= average-percentADC) {
    average2 = average2 + rawADC7; 
    count++;
  }
  if (rawADC8 <= average+percentADC && rawADC8 >= average-percentADC) {
    average2 = average2 + rawADC8; 
    count++;
  }
  if (rawADC9 <= average+percentADC && rawADC9 >= average-percentADC) {
    average2 = average2 + rawADC9; 
    count++;
  }
  if (rawADC10 <= average+percentADC && rawADC10 >= average-percentADC) {
    average2 = average2 + rawADC10; 
    count++;
  }
  if (rawADC11 <= average+percentADC && rawADC11 >= average-percentADC) {
    average2 = average2 + rawADC11; 
    count++;
  }
  if (rawADC12 <= average+percentADC && rawADC12 >= average-percentADC) {
    average2 = average2 + rawADC12; 
    count++;
  }
  if (rawADC13 <= average+percentADC && rawADC13 >= average-percentADC) {
    average2 = average2 + rawADC13; 
    count++;
  }
  if (rawADC14 <= average+percentADC && rawADC14 >= average-percentADC) {
    average2 = average2 + rawADC14; 
    count++;
  }
  if (rawADC15 <= average+percentADC && rawADC15 >= average-percentADC) {
    average2 = average2 + rawADC15; 
    count++;
  }
  if (rawADC16 <= average+percentADC && rawADC16 >= average-percentADC) {
    average2 = average2 + rawADC16; 
    count++;
  }
  if (rawADC17 <= average+percentADC && rawADC17 >= average-percentADC) {
    average2 = average2 + rawADC17; 
    count++;
  }
  if (rawADC18 <= average+percentADC && rawADC18 >= average-percentADC) {
    average2 = average2 + rawADC18; 
    count++;
  }
  if (rawADC19 <= average+percentADC && rawADC19 >= average-percentADC) {
    average2 = average2 + rawADC19; 
    count++;
  }
  average = average2 / count;
  float voltage2 = ((float) average + CalibV ) / 1024.0 * VccReal; 


  lcd.setCursor(5, 1);
  lcd.print(voltage2,3);
  lcd.print("V");


  lcd.setCursor(12, 1);
  lcd.print(average);


  //   lcd.setCursor(17, 1);
  //   lcd.print("  ");
  //   lcd.setCursor(17, 1);
  //    lcd.print(count);




  //   delay(200); 
  //  lcd.clear();
}
//===================================================================
//===================================================================
//===================================================================
//===================================================================

**selectronic** · 04-04-17, 10:04

Με ένα μόνο delay(200) στο τέλος και καπάκι lcd.clear() }

**manolena** · 04-04-17, 10:05

Αρχικό μήνυμα από selectronic

Βίντεο, δυστυχώς άθλιας ποιότητας:

Με τον κώδικα που έβαλα στο #57 με τα πολλά και μοιρασμένα delays:

Έλα, αυτό στο κάνει γιατί στο τέλος κάτω κάτω έχεις βάλει να σου σβήνει όλη την οθόνη με lcd.clear(); Κάντην σχόλιο με //
Αν δείς παραπάνω στον κώδικα που έστειλα την έχω κάνει σχόλιο.

**selectronic** · 04-04-17, 10:10

Αρχικό μήνυμα από manolena

Στο συμμάζεψα λίγο, κάνε μια δοκιμή με 20x2 οθόνη:

Κώδικας:

#include <LiquidCrystal.h>


//===================================================================
// LiquidCrystal lcd(2, 4, 6, 7, 8, 9);
LiquidCrystal lcd(2, 8, 4, 5, 6, 7);
//===================================================================
long Vref11 = 1122000L;  // Boards Internal 1.1Vref
float CalibV = 2.0;    // 'Calibrate' value
int Read1 = A0;
int Read2 = A2;
long readVcc;
float OnePercentADC, percentADC;
float VccReal = (float) readVcc / 1000;
int rawADC0, rawADC1, rawADC2, rawADC3, rawADC4, rawADC5, rawADC6, 
    rawADC7, rawADC8, rawADC9, rawADC10, rawADC11, rawADC12, rawADC13, 
    rawADC14, rawADC15, rawADC16, rawADC17, rawADC18, rawADC19 = 0; 
int average;  
float average2 = 0;
int count = 0;
//===================================================================
void setup() 
{  
  lcd.begin(16, 2);// lcd.begin(20, 2);
}
//===================================================================
void loop()
{
  lcd.setCursor(0, 0);
  lcd.print(millis() / 1000);




  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1); 
  delay(10); // Wait for Vref to settle 
  ADCSRA |= _BV(ADSC); // Convert 
  while (bit_is_set(ADCSRA,ADSC)); 
  readVcc = ADCL; 
  readVcc |= ADCH<<8; 
  readVcc = Vref11 / readVcc; // Back-calculate AVcc in mV 


  lcd.setCursor(0, 1);
  lcd.print(VccReal,2);


  measureVoltageAverage();
  measureVoltage_1_Average();
  delay(200);


}
//===================================================================
void measureVoltageAverage()
{
  // Measure multiple times the Analog Pin and make an 'Average':
  //
  // Take multiple measurements of the same AnalogInput
  rawADC0 = analogRead (Read1);
  rawADC1 = analogRead (Read1);
  rawADC2 = analogRead (Read1);
  rawADC3 = analogRead (Read1);
  rawADC4 = analogRead (Read1);
  rawADC5 = analogRead (Read1);
  rawADC6 = analogRead (Read1);
  rawADC7 = analogRead (Read1);
  rawADC8 = analogRead (Read1);
  rawADC9 = analogRead (Read1);
  rawADC10 = analogRead (Read1);
  rawADC11 = analogRead (Read1);
  rawADC12 = analogRead (Read1);
  rawADC13 = analogRead (Read1);
  rawADC14 = analogRead (Read1);
  rawADC15 = analogRead (Read1);
  rawADC16 = analogRead (Read1);
  rawADC17 = analogRead (Read1);
  rawADC18 = analogRead (Read1);
  rawADC19 = analogRead (Read1);
  // Make first average of those values
  average = (rawADC0 + rawADC1 + rawADC2 + rawADC3 + rawADC4 + rawADC5 + rawADC6 + rawADC7 + rawADC8 + rawADC9 + rawADC10 + rawADC11 + rawADC12 + rawADC13 + rawADC14 + rawADC15 + rawADC16 + rawADC17 + rawADC18 + rawADC19) / 20;
  // Make the 'int' average value into a 'float', calc 1/1000 of that average value and select percent under/over to be "discarded"
  OnePercentADC = (float) average / 1000;
  percentADC = OnePercentADC * 6; // Percent of "tolerance" before a value is discarted, in -Thousands- of the average value
  // From the previous values, exclude those that are 10% more/less than made 'average' value, and re-calculate a new average
  average2 = 0;
  count = 0;
  if (rawADC0 <= average+percentADC && rawADC0 >= average-percentADC) {
    average2 = average2 + rawADC0; 
    count++;
  }
  if (rawADC1 <= average+percentADC && rawADC1 >= average-percentADC) {
    average2 = average2 + rawADC1; 
    count++;
  }
  if (rawADC2 <= average+percentADC && rawADC2 >= average-percentADC) {
    average2 = average2 + rawADC2; 
    count++;
  }
  if (rawADC3 <= average+percentADC && rawADC3 >= average-percentADC) {
    average2 = average2 + rawADC3; 
    count++;
  }
  if (rawADC4 <= average+percentADC && rawADC4 >= average-percentADC) {
    average2 = average2 + rawADC4; 
    count++;
  }
  if (rawADC5 <= average+percentADC && rawADC5 >= average-percentADC) {
    average2 = average2 + rawADC5; 
    count++;
  }
  if (rawADC6 <= average+percentADC && rawADC6 >= average-percentADC) {
    average2 = average2 + rawADC6; 
    count++;
  }
  if (rawADC7 <= average+percentADC && rawADC7 >= average-percentADC) {
    average2 = average2 + rawADC7; 
    count++;
  }
  if (rawADC8 <= average+percentADC && rawADC8 >= average-percentADC) {
    average2 = average2 + rawADC8; 
    count++;
  }
  if (rawADC9 <= average+percentADC && rawADC9 >= average-percentADC) {
    average2 = average2 + rawADC9; 
    count++;
  }
  if (rawADC10 <= average+percentADC && rawADC10 >= average-percentADC) {
    average2 = average2 + rawADC10; 
    count++;
  }
  if (rawADC11 <= average+percentADC && rawADC11 >= average-percentADC) {
    average2 = average2 + rawADC11; 
    count++;
  }
  if (rawADC12 <= average+percentADC && rawADC12 >= average-percentADC) {
    average2 = average2 + rawADC12; 
    count++;
  }
  if (rawADC13 <= average+percentADC && rawADC13 >= average-percentADC) {
    average2 = average2 + rawADC13; 
    count++;
  }
  if (rawADC14 <= average+percentADC && rawADC14 >= average-percentADC) {
    average2 = average2 + rawADC14; 
    count++;
  }
  if (rawADC15 <= average+percentADC && rawADC15 >= average-percentADC) {
    average2 = average2 + rawADC15; 
    count++;
  }
  if (rawADC16 <= average+percentADC && rawADC16 >= average-percentADC) {
    average2 = average2 + rawADC16; 
    count++;
  }
  if (rawADC17 <= average+percentADC && rawADC17 >= average-percentADC) {
    average2 = average2 + rawADC17; 
    count++;
  }
  if (rawADC18 <= average+percentADC && rawADC18 >= average-percentADC) {
    average2 = average2 + rawADC18; 
    count++;
  }
  if (rawADC19 <= average+percentADC && rawADC19 >= average-percentADC) {
    average2 = average2 + rawADC19; 
    count++;
  }
  average = average2 / count;
  float voltage = ((float) average + CalibV ) / 1024.0 * VccReal; 


  lcd.setCursor(5, 0);
  lcd.print(voltage,3);
  lcd.print("V");


  lcd.setCursor(12, 0);
  lcd.print(average);


  //   lcd.setCursor(17, 0);
  //   lcd.print("  ");
  //   lcd.setCursor(17, 0);
  //   lcd.print(count);
}
//===================================================================
void measureVoltage_1_Average()
{
  rawADC0 = analogRead (Read2);
  rawADC1 = analogRead (Read2);
  rawADC2 = analogRead (Read2);
  rawADC3 = analogRead (Read2);
  rawADC4 = analogRead (Read2);
  rawADC5 = analogRead (Read2);
  rawADC6 = analogRead (Read2);
  rawADC7 = analogRead (Read2);
  rawADC8 = analogRead (Read2);
  rawADC9 = analogRead (Read2);
  rawADC10 = analogRead (Read2);
  rawADC11 = analogRead (Read2);
  rawADC12 = analogRead (Read2);
  rawADC13 = analogRead (Read2);
  rawADC14 = analogRead (Read2);
  rawADC15 = analogRead (Read2);
  rawADC16 = analogRead (Read2);
  rawADC17 = analogRead (Read2);
  rawADC18 = analogRead (Read2);
  rawADC19 = analogRead (Read2);
  average = (rawADC0 + rawADC1 + rawADC2 + rawADC3 + rawADC4 + rawADC5 + rawADC6 + rawADC7 + rawADC8 + rawADC9 + rawADC10 + rawADC11 + rawADC12 + rawADC13 + rawADC14 + rawADC15 + rawADC16 + rawADC17 + rawADC18 + rawADC19) / 20;
  OnePercentADC = (float) average / 1000;
  percentADC = OnePercentADC * 6; // Percent of "tolerance" before a value is discarted, in -Thousands- of the average value
  average2 = 0;
  count = 0;
  if (rawADC0 <= average+percentADC && rawADC0 >= average-percentADC) {
    average2 = average2 + rawADC0; 
    count++;
  }
  if (rawADC1 <= average+percentADC && rawADC1 >= average-percentADC) {
    average2 = average2 + rawADC1; 
    count++;
  }
  if (rawADC2 <= average+percentADC && rawADC2 >= average-percentADC) {
    average2 = average2 + rawADC2; 
    count++;
  }
  if (rawADC3 <= average+percentADC && rawADC3 >= average-percentADC) {
    average2 = average2 + rawADC3; 
    count++;
  }
  if (rawADC4 <= average+percentADC && rawADC4 >= average-percentADC) {
    average2 = average2 + rawADC4; 
    count++;
  }
  if (rawADC5 <= average+percentADC && rawADC5 >= average-percentADC) {
    average2 = average2 + rawADC5; 
    count++;
  }
  if (rawADC6 <= average+percentADC && rawADC6 >= average-percentADC) {
    average2 = average2 + rawADC6; 
    count++;
  }
  if (rawADC7 <= average+percentADC && rawADC7 >= average-percentADC) {
    average2 = average2 + rawADC7; 
    count++;
  }
  if (rawADC8 <= average+percentADC && rawADC8 >= average-percentADC) {
    average2 = average2 + rawADC8; 
    count++;
  }
  if (rawADC9 <= average+percentADC && rawADC9 >= average-percentADC) {
    average2 = average2 + rawADC9; 
    count++;
  }
  if (rawADC10 <= average+percentADC && rawADC10 >= average-percentADC) {
    average2 = average2 + rawADC10; 
    count++;
  }
  if (rawADC11 <= average+percentADC && rawADC11 >= average-percentADC) {
    average2 = average2 + rawADC11; 
    count++;
  }
  if (rawADC12 <= average+percentADC && rawADC12 >= average-percentADC) {
    average2 = average2 + rawADC12; 
    count++;
  }
  if (rawADC13 <= average+percentADC && rawADC13 >= average-percentADC) {
    average2 = average2 + rawADC13; 
    count++;
  }
  if (rawADC14 <= average+percentADC && rawADC14 >= average-percentADC) {
    average2 = average2 + rawADC14; 
    count++;
  }
  if (rawADC15 <= average+percentADC && rawADC15 >= average-percentADC) {
    average2 = average2 + rawADC15; 
    count++;
  }
  if (rawADC16 <= average+percentADC && rawADC16 >= average-percentADC) {
    average2 = average2 + rawADC16; 
    count++;
  }
  if (rawADC17 <= average+percentADC && rawADC17 >= average-percentADC) {
    average2 = average2 + rawADC17; 
    count++;
  }
  if (rawADC18 <= average+percentADC && rawADC18 >= average-percentADC) {
    average2 = average2 + rawADC18; 
    count++;
  }
  if (rawADC19 <= average+percentADC && rawADC19 >= average-percentADC) {
    average2 = average2 + rawADC19; 
    count++;
  }
  average = average2 / count;
  float voltage2 = ((float) average + CalibV ) / 1024.0 * VccReal; 


  lcd.setCursor(5, 1);
  lcd.print(voltage2,3);
  lcd.print("V");


  lcd.setCursor(12, 1);
  lcd.print(average);


  //   lcd.setCursor(17, 1);
  //   lcd.print("  ");
  //   lcd.setCursor(17, 1);
  //    lcd.print(count);




  //   delay(200); 
  //  lcd.clear();
}
//===================================================================
//===================================================================
//===================================================================
//===================================================================

Νομίζω μόλις τον έψησα αυτόν που είναι στην πράσινη όταν σκούντησα το καλωδιομάνι για να βάλω την κάμερα να πάρω βίντεο XD
Πρόλαβε και μέτρησε (αργά ή μου φάνηκε?) μέχρι το 8 στον timer πάντως, δούλεψε...

**Fire Doger** · 04-04-17, 10:18

Χμμμ με τις επαναλήψεις δεν τα πας πολύ καλά ε? :P

Οι πρώτες 20 γραμμές:
int rawADC[20];
for(byte i =0; i<20; i ++)
rawADC[i] = analogRead (Read1);

Οι επόμενες 20 γραμμές
for(byte i=0; i<20; i++)
if (rawADC[i] <= average+percentADC && rawADC[i] >= average-percentADC) {
average2 = average2 + rawADC[i];
count++;
}

Παραπάνω αντί να έχω 20 μεταβλητές με 20 ονόματα έχω ένα πίνακα με 20 θέσεις και κάθε θέση είναι 1 μεταβλητή. Άρα με το ίδιο όνομα αλλάζοντας την θέση μέσω της επανάληψης αλλάζει και η μεταβλητή στην οποία αναφέρομαι. Τα υπόλοιπα παραμένουν ίδια.
Το ίδιο μπορεί να επαναληφθεί και για τις επόμενες 40 γραμμές.
Δηλαδή στις 200 μετρήσεις τι θα έκανες? :P
Αν σε βολεύει το κρατάς, το ίδιο πράγμα είναι σχεδόν.

Edit: και για το average:
int average =0;
for(byte i=0; i<20; i++){
average+=rawADC[i];
}
average = average/20;

**Μου είχε ξεφύγει κάτι πριν το edit

**selectronic** · 04-04-17, 10:21

Ναι, δεν σαλεύει η πράσινη (ο πράσινος?). Έλεγα μήπως πέρασα το "LiquidCrystal lcd(2, 8, 4, 5, 6, 7);" που είναι της μπλε LCD, γιατί είμαι και μαζοχιστής και δεν έβαλα τα ίδια πιν, αλλά όχι...
Meh, κίνδυνοι του επαγγέλματος είναι αυτοί lol.

Τριπλο-τσεκάρω και δοκιμάζω μπλε, και θα ξανα-ανεβάσω τον κώδικα γιατί δεν είχα καταλάβει ότι είχα αφήσει και τα δύο "LiquidCrystal lcd(.........);" μέσα.

**selectronic** · 04-04-17, 10:24

Αρχικό μήνυμα από Fire Doger

Χμμμ με τις επαναλήψεις δεν τα πας πολύ καλά ε? :P

Οι πρώτες 20 γραμμές:
int rawADC[20];
for(byte i =0; i<20; i ++)
rawADC[i] = analogRead (Read1);

Οι επόμενες 20 γραμμές
for(byte i=0; i<20; i++)
if (rawADC[i] <= average+percentADC && rawADC[i] >= average-percentADC) {
average2 = average2 + rawADC0;
count++;
}

Παραπάνω αντί να έχω 20 μεταβλητές με 20 ονόματα έχω ένα πίνακα με 20 θέσεις και κάθε θέση είναι 1 μεταβλητή. Άρα με το ίδιο όνομα αλλάζοντας την θέση μέσω της επανάληψης αλλάζει και η μεταβλητή στην οποία αναφέρομαι. Τα υπόλοιπα παραμένουν ίδια.
Το ίδιο μπορεί να επαναληφθεί και για τις επόμενες 40 γραμμές.
Δηλαδή στις 200 μετρήσεις τι θα έκανες? :P
Αν σε βολεύει το κρατάς, το ίδιο πράγμα είναι σχεδόν.

Χα! Το ήξερα ότι σίγουρα υπήρχε τέτοιος τρόπος (for 20, do that shit) αλλά δεν ήξερα πως να το κάνω, και όταν έκανα το κομμάτι με τις 20 επαναλήψεις copy-paste από όπου το βρήκα, δεν είχα κάτσει να βρω καλύτερο τρόπο...
Thanks!

**selectronic** · 04-04-17, 10:34

Τέλειο !!!

Καθόλου, μα ΚΑΘΟΛΟΥ flicker στην 16x2 μπλε!

Άσε μου 5 λεπτά να δω τι μαγεία έκανες στον κώδικα...

Κώδικας:

#include <LiquidCrystal.h>


//===================================================================
LiquidCrystal lcd(2, 8, 4, 5, 6, 7);
//===================================================================
long Vref11 = 1122000L;  // Boards Internal 1.1Vref
float CalibV = 2.0;    // 'Calibrate' value
int Read1 = A0;
int Read2 = A2;
long readVcc;
float OnePercentADC, percentADC;
float VccReal = (float) readVcc / 1000;
int rawADC0, rawADC1, rawADC2, rawADC3, rawADC4, rawADC5, rawADC6, 
    rawADC7, rawADC8, rawADC9, rawADC10, rawADC11, rawADC12, rawADC13, 
    rawADC14, rawADC15, rawADC16, rawADC17, rawADC18, rawADC19 = 0; 
int average;  
float average2 = 0;
int count = 0;
//===================================================================
void setup() 
{  
  lcd.begin(16, 2);//
}
//===================================================================
void loop()
{
  lcd.setCursor(0, 0);
  lcd.print(millis() / 1000);




  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1); 
  delay(10); // Wait for Vref to settle 
  ADCSRA |= _BV(ADSC); // Convert 
  while (bit_is_set(ADCSRA,ADSC)); 
  readVcc = ADCL; 
  readVcc |= ADCH<<8; 
  readVcc = Vref11 / readVcc; // Back-calculate AVcc in mV 


  lcd.setCursor(0, 1);
  lcd.print(VccReal,2);


  measureVoltageAverage();
  measureVoltage_1_Average();
  delay(200);


}
//===================================================================
void measureVoltageAverage()
{
  // Measure multiple times the Analog Pin and make an 'Average':
  //
  // Take multiple measurements of the same AnalogInput
  rawADC0 = analogRead (Read1);
  rawADC1 = analogRead (Read1);
  rawADC2 = analogRead (Read1);
  rawADC3 = analogRead (Read1);
  rawADC4 = analogRead (Read1);
  rawADC5 = analogRead (Read1);
  rawADC6 = analogRead (Read1);
  rawADC7 = analogRead (Read1);
  rawADC8 = analogRead (Read1);
  rawADC9 = analogRead (Read1);
  rawADC10 = analogRead (Read1);
  rawADC11 = analogRead (Read1);
  rawADC12 = analogRead (Read1);
  rawADC13 = analogRead (Read1);
  rawADC14 = analogRead (Read1);
  rawADC15 = analogRead (Read1);
  rawADC16 = analogRead (Read1);
  rawADC17 = analogRead (Read1);
  rawADC18 = analogRead (Read1);
  rawADC19 = analogRead (Read1);
  // Make first average of those values
  average = (rawADC0 + rawADC1 + rawADC2 + rawADC3 + rawADC4 + rawADC5 + rawADC6 + rawADC7 + rawADC8 + rawADC9 + rawADC10 + rawADC11 + rawADC12 + rawADC13 + rawADC14 + rawADC15 + rawADC16 + rawADC17 + rawADC18 + rawADC19) / 20;
  // Make the 'int' average value into a 'float', calc 1/1000 of that average value and select percent under/over to be "discarded"
  OnePercentADC = (float) average / 1000;
  percentADC = OnePercentADC * 6; // Percent of "tolerance" before a value is discarted, in -Thousands- of the average value
  // From the previous values, exclude those that are 10% more/less than made 'average' value, and re-calculate a new average
  average2 = 0;
  count = 0;
  if (rawADC0 <= average+percentADC && rawADC0 >= average-percentADC) {
    average2 = average2 + rawADC0; 
    count++;
  }
  if (rawADC1 <= average+percentADC && rawADC1 >= average-percentADC) {
    average2 = average2 + rawADC1; 
    count++;
  }
  if (rawADC2 <= average+percentADC && rawADC2 >= average-percentADC) {
    average2 = average2 + rawADC2; 
    count++;
  }
  if (rawADC3 <= average+percentADC && rawADC3 >= average-percentADC) {
    average2 = average2 + rawADC3; 
    count++;
  }
  if (rawADC4 <= average+percentADC && rawADC4 >= average-percentADC) {
    average2 = average2 + rawADC4; 
    count++;
  }
  if (rawADC5 <= average+percentADC && rawADC5 >= average-percentADC) {
    average2 = average2 + rawADC5; 
    count++;
  }
  if (rawADC6 <= average+percentADC && rawADC6 >= average-percentADC) {
    average2 = average2 + rawADC6; 
    count++;
  }
  if (rawADC7 <= average+percentADC && rawADC7 >= average-percentADC) {
    average2 = average2 + rawADC7; 
    count++;
  }
  if (rawADC8 <= average+percentADC && rawADC8 >= average-percentADC) {
    average2 = average2 + rawADC8; 
    count++;
  }
  if (rawADC9 <= average+percentADC && rawADC9 >= average-percentADC) {
    average2 = average2 + rawADC9; 
    count++;
  }
  if (rawADC10 <= average+percentADC && rawADC10 >= average-percentADC) {
    average2 = average2 + rawADC10; 
    count++;
  }
  if (rawADC11 <= average+percentADC && rawADC11 >= average-percentADC) {
    average2 = average2 + rawADC11; 
    count++;
  }
  if (rawADC12 <= average+percentADC && rawADC12 >= average-percentADC) {
    average2 = average2 + rawADC12; 
    count++;
  }
  if (rawADC13 <= average+percentADC && rawADC13 >= average-percentADC) {
    average2 = average2 + rawADC13; 
    count++;
  }
  if (rawADC14 <= average+percentADC && rawADC14 >= average-percentADC) {
    average2 = average2 + rawADC14; 
    count++;
  }
  if (rawADC15 <= average+percentADC && rawADC15 >= average-percentADC) {
    average2 = average2 + rawADC15; 
    count++;
  }
  if (rawADC16 <= average+percentADC && rawADC16 >= average-percentADC) {
    average2 = average2 + rawADC16; 
    count++;
  }
  if (rawADC17 <= average+percentADC && rawADC17 >= average-percentADC) {
    average2 = average2 + rawADC17; 
    count++;
  }
  if (rawADC18 <= average+percentADC && rawADC18 >= average-percentADC) {
    average2 = average2 + rawADC18; 
    count++;
  }
  if (rawADC19 <= average+percentADC && rawADC19 >= average-percentADC) {
    average2 = average2 + rawADC19; 
    count++;
  }
  average = average2 / count;
  float voltage = ((float) average + CalibV ) / 1024.0 * VccReal; 


  lcd.setCursor(5, 0);
  lcd.print(voltage,3);
  lcd.print("V");


  lcd.setCursor(12, 0);
  lcd.print(average);


  //   lcd.setCursor(17, 0);
  //   lcd.print("  ");
  //   lcd.setCursor(17, 0);
  //   lcd.print(count);
}
//===================================================================
void measureVoltage_1_Average()
{
  rawADC0 = analogRead (Read2);
  rawADC1 = analogRead (Read2);
  rawADC2 = analogRead (Read2);
  rawADC3 = analogRead (Read2);
  rawADC4 = analogRead (Read2);
  rawADC5 = analogRead (Read2);
  rawADC6 = analogRead (Read2);
  rawADC7 = analogRead (Read2);
  rawADC8 = analogRead (Read2);
  rawADC9 = analogRead (Read2);
  rawADC10 = analogRead (Read2);
  rawADC11 = analogRead (Read2);
  rawADC12 = analogRead (Read2);
  rawADC13 = analogRead (Read2);
  rawADC14 = analogRead (Read2);
  rawADC15 = analogRead (Read2);
  rawADC16 = analogRead (Read2);
  rawADC17 = analogRead (Read2);
  rawADC18 = analogRead (Read2);
  rawADC19 = analogRead (Read2);
  average = (rawADC0 + rawADC1 + rawADC2 + rawADC3 + rawADC4 + rawADC5 + rawADC6 + rawADC7 + rawADC8 + rawADC9 + rawADC10 + rawADC11 + rawADC12 + rawADC13 + rawADC14 + rawADC15 + rawADC16 + rawADC17 + rawADC18 + rawADC19) / 20;
  OnePercentADC = (float) average / 1000;
  percentADC = OnePercentADC * 6; // Percent of "tolerance" before a value is discarted, in -Thousands- of the average value
  average2 = 0;
  count = 0;
  if (rawADC0 <= average+percentADC && rawADC0 >= average-percentADC) {
    average2 = average2 + rawADC0; 
    count++;
  }
  if (rawADC1 <= average+percentADC && rawADC1 >= average-percentADC) {
    average2 = average2 + rawADC1; 
    count++;
  }
  if (rawADC2 <= average+percentADC && rawADC2 >= average-percentADC) {
    average2 = average2 + rawADC2; 
    count++;
  }
  if (rawADC3 <= average+percentADC && rawADC3 >= average-percentADC) {
    average2 = average2 + rawADC3; 
    count++;
  }
  if (rawADC4 <= average+percentADC && rawADC4 >= average-percentADC) {
    average2 = average2 + rawADC4; 
    count++;
  }
  if (rawADC5 <= average+percentADC && rawADC5 >= average-percentADC) {
    average2 = average2 + rawADC5; 
    count++;
  }
  if (rawADC6 <= average+percentADC && rawADC6 >= average-percentADC) {
    average2 = average2 + rawADC6; 
    count++;
  }
  if (rawADC7 <= average+percentADC && rawADC7 >= average-percentADC) {
    average2 = average2 + rawADC7; 
    count++;
  }
  if (rawADC8 <= average+percentADC && rawADC8 >= average-percentADC) {
    average2 = average2 + rawADC8; 
    count++;
  }
  if (rawADC9 <= average+percentADC && rawADC9 >= average-percentADC) {
    average2 = average2 + rawADC9; 
    count++;
  }
  if (rawADC10 <= average+percentADC && rawADC10 >= average-percentADC) {
    average2 = average2 + rawADC10; 
    count++;
  }
  if (rawADC11 <= average+percentADC && rawADC11 >= average-percentADC) {
    average2 = average2 + rawADC11; 
    count++;
  }
  if (rawADC12 <= average+percentADC && rawADC12 >= average-percentADC) {
    average2 = average2 + rawADC12; 
    count++;
  }
  if (rawADC13 <= average+percentADC && rawADC13 >= average-percentADC) {
    average2 = average2 + rawADC13; 
    count++;
  }
  if (rawADC14 <= average+percentADC && rawADC14 >= average-percentADC) {
    average2 = average2 + rawADC14; 
    count++;
  }
  if (rawADC15 <= average+percentADC && rawADC15 >= average-percentADC) {
    average2 = average2 + rawADC15; 
    count++;
  }
  if (rawADC16 <= average+percentADC && rawADC16 >= average-percentADC) {
    average2 = average2 + rawADC16; 
    count++;
  }
  if (rawADC17 <= average+percentADC && rawADC17 >= average-percentADC) {
    average2 = average2 + rawADC17; 
    count++;
  }
  if (rawADC18 <= average+percentADC && rawADC18 >= average-percentADC) {
    average2 = average2 + rawADC18; 
    count++;
  }
  if (rawADC19 <= average+percentADC && rawADC19 >= average-percentADC) {
    average2 = average2 + rawADC19; 
    count++;
  }
  average = average2 / count;
  float voltage2 = ((float) average + CalibV ) / 1024.0 * VccReal; 


  lcd.setCursor(5, 1);
  lcd.print(voltage2,3);
  lcd.print("V");


  lcd.setCursor(12, 1);
  lcd.print(average);


  //   lcd.setCursor(17, 1);
  //   lcd.print("  ");
  //   lcd.setCursor(17, 1);
  //    lcd.print(count);




  //   delay(200); 
  //  lcd.clear();
}
//===================================================================
//===================================================================
//===================================================================
//===================================================================

Edit: δεν είναι καλή η μέρα αυτή έτσι?

**selectronic** · 04-04-17, 10:51

Για κάτσε μία στιγμή, δηλαδή τώρα δεν σβήνει ΠΟΤΕ ότι γράφει? Έτσι έκανα και στα πρώτα βήματα με την LCD, αλλά όταν άλλαζε μία τιμή στην οθόνη σε πιο μεγάλη σε μήκος στην οθόνη και μετά σε μικρότερη πάλι, μέναν τα "εξτρά" ψηφία στην οθόνη: πχ οι τιμές rawADC είναι 1-4 ψηφία. Δεν θα έχω πάλι το ίδιο θέμα αν έχω τιμές που αλλάζουν "μέγεθος" στην LCD (που δεν ξέρω να θα έχω, αλλά ρωτάω για να μαθαίνω!)

Μου έφτιαξες και functions είδα και δεν είναι όλα χύμα μέσα στο loop, θα το μελετήσω πως το έκανες να μάθω. Ήταν στο πρόγραμμα και αυτό να το ψάξω, αλλά ήθελα πρώτα να φτάσω κοντά στο να μου δείχνει πρώτα μία τάση σωστά στην οθόνη και μετά, γιατί πάντα υπήρχε και η περίπτωση να τα πέταγα όλα στον κάδο XD

Τώρα μετράνε τα πάντα πλην του timer/rawADC μηδέν πάντως, αλλά θα το βρω αυτό πιστεύω

Το Youtube δεν ξέρω γιατί μουλάρωσε :/

Ευχαριστώ !!!

Θέμα: Arduino:Πάλι μη-γραμμικότητα, κάνω κάτι λάθος?

Εργαλεία Θεμάτων

Εμφάνιση

Ένα μέλος ευχαρίστησε τον manolena για αυτό το χρήσιμο μήνυμα:

Ένα μέλος ευχαρίστησε τον Fire Doger για αυτό το χρήσιμο μήνυμα:

Παρόμοια Θέματα

Εργαλείο πρεσαρίσματος UTP (Κάνω κάτι λάθος;)

Τι κάνω λάθος και δεν πιάνω το κανάλι ΤΕΙ Θεσ/νίκης (?)

Λάθος IP σε PC. Τι να κάνω;

Μετρήσεις-Κάνω κάτι λάθος

Σκέφτηκα κάτι.. Πώς θα το κάνω?

Δικαιώματα - Επιλογές