Ich habe ein simpel gestricktes Programm, welches über A0 Spannungen einliest und über die serielle Schnittstelle an den PC weiterleitet.
Bislang habe ich die Meßwerte einzeln übertragen. Nachdem sich nun heraus gestellt hat, dass im realen Betrieb Echtzeitfähigkeit nicht erforderlich ist und ich stattdessen lieber die Verarbeitunsggeschwindigkeit erhöhen sollte, habe ich nun vor immer 1000 Messungen blockweise zu übertragen.
Da strings hier wohl unpraktikabel sind, lautet meine Frage wie ich den Block aus 1000 Messwerten (bei negativen Werten mit Vorzeichen) am elegantesten und speicherschonensten übertrage.
Hardwareseitig wird eine Offsetspannung von ca. 1.5V zugeführt, so dass auch negative Ergebnisse in diesem Bereich möglich sind.
Insgesamt sollen die Bildschirmausgabe minimiert werden und die Verarbeitungsgeschwindigkeit so gesteigert werden, dass evtl. auch bis zu 50600 bei der Datenrate drin sind. Derzeit ist bei 9600 Schluß, wobei auch der PC an Grenzen stoßen könnte, da er jeden Wert samt Overhead und dann Visualisierung einzeln abarbeiten muss.
// Adafruit SSD1306 - Version: 1.3.0
#include <Adafruit_SSD1306.h>
#include <splash.h>
// Adafruit GFX Library - Version: 1.5.6
#include <Adafruit_GFX.h>
#include <Adafruit_SPITFT.h>
#include <Adafruit_SPITFT_Macros.h>
#include <gfxfont.h>
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define OLED_RESET 4 // not used
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
//Adafruit_SSD1306 display(OLED_RESET);
void setup()
{
Serial.begin(9600);
// initialize with the I2C addr 0x3C / mit I2C-Adresse 0x3c initialisieren
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
// SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3C for 128x32
Serial.println(F("SSD1306 allocation failed. Not enough RAM"));
for(;;); // Don't proceed, loop forever
}
}
// Voltage
// Flags
bool DebuggingMode = false;
bool ExperimentalMode = false;
#define PIN_TEST A0
#define PIN_OFFSET A1
#define REF_VOLTAGE 5.0
#define PIN_STEPS 1024.0
int Volt=0; // Current Voltage
int Volt0=0; // Last Voltage
int VoltAVtotal=0;
int MinProbe=300;
int HitProbe=100;
int MaxProbe=3000;
int counter1 = 0; // Total number of samples
int counter2 = 0; // Total number of hits
int Result[30];
int VOffset=1646; // Voltage offset to avoid negative voltage
int VOffsetTemp=0; //Temp storage for VOffset
int VCalibrate=-0;// Measurement error correction
char ResultE [15][3] = {
{"XX"},
{"Aa"},
{"Ab"},
{"Ac"},
{"Ad"},
{"Ae"},
{"Af"},
{"Ag"},
{"Ah"},
{"Ai"},
{"Aj"},
{"??"},
{"XX"},
{"XX"},
{"XX"},
};
//if (ExperimentalMode == true) {
// https://majenko.co.uk/blog/making-accurate-adc-readings-arduino
// Using internal 1.2V reference
long readVcc() {
long result;
// Read 1.1V reference against AVcc
ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
delay(2); // Wait for Vref to settle
ADCSRA |= _BV(ADSC); // Convert
while (bit_is_set(ADCSRA,ADSC));
result = ADCL;
result |= ADCH<<8;
result = 1125300L / result; // Back-calculate AVcc in mV
return result;
//};
}
void loop() {
if (counter1=1){
display.clearDisplay(); // Clear Adafruit Logo
};
// set text color
display.setTextColor(WHITE);
// set text size
display.setTextSize(1);
// set text cursor position
display.setCursor(1,0);
// show text
display.println(F("Tester"));
display.setCursor(2,56);
display.println(F("2020"));
display.setTextSize(2);
display.setCursor(2,34);
display.println(Volt);
Volt=(int)analogRead(PIN_TEST)*REF_VOLTAGE/PIN_STEPS*1000; // Read new Value
if (ExperimentalMode == true) {
// Measure Voltage & add offset
Volt0=Volt; // Save old Value first
// https://majenko.co.uk/blog/making-accurate-adc-readings-arduino
// Using 1.1V internal reference to increase precision
unsigned int ADCValue; //
double Voltage; //
double Vcc; //
// Measure Voltage
Vcc = readVcc();//10.0 ; // was /1000.0;
ADCValue=(int)analogRead(PIN_TEST)*REF_VOLTAGE/PIN_STEPS*1000; // Read new Value
Volt = (ADCValue / 1023.0) * Vcc;
};
counter1++;
Volt=Volt-VOffset; // add hardware offset
Volt=Volt+VCalibrate; // add additional offset after calibration (not implemented yet)
if (counter1<MaxProbe) {
VoltAVtotal=(VoltAVtotal*(counter1-1)+Volt)/counter1; // Average Voltage
Serial.println(Volt);
if (DebuggingMode == true) {
Serial.print(F(" Average: "));
Serial.println(VoltAVtotal);
Serial.print(F(" Counter: "));
Serial.println(counter1);
Serial.print(F(" Offset : "));
Serial.println(VOffset);
Serial.print(",");
}
// Calculations and empiric data
//display.setCursor(2,15);
if (Volt > 520 && Volt <= 530){
Result[2]++;
}
else if (Volt >= 420 && Volt <= 425){ // 453 MAx wie Ta!!
Result[1]++;
}
else if (Volt > 265 && Volt <= 275){ //
Result[6]++;
}
else if (Volt > 451 && Volt <= 455){ // 453 Max wie Ag !!!
Result[10]++;
}
else if (Volt > 157 && Volt <= 167){ //
Result[5]++;
}
else if (Volt > 167 && Volt <= 177){ //
Result[3]++;
}
else if (Volt > 57 && Volt <= 67){ //
Result[7]++;
}
else if (Volt > 108 && Volt <= 114){ //
Result[8]++;
}
else if (Volt < -285 && Volt >= -295){ //
Result[9]++;
}
else if (Volt < -636 && Volt >=-646){ //
Result[4]++;
}
else {
Result[11]++;
}
counter2++;
}
if (counter1<MaxProbe && counter1>MinProbe|| counter2==HitProbe){
Serial.println(F(" "));
Serial.println(F(" ** Results ** "));
display.clearDisplay();
for (byte i = 0; i < 15; i = i + 1) {
Serial.print(ResultE[i]);
Serial.print(F(" "));
Serial.print(Result[i]);
Serial.print(F(" "));
float a=Result[i]; //percentage
int c=HitProbe;
float b=0.00;
b=(float)c/100;
a=a/b;
Serial.print(a);
Serial.println(F("%"));
if (a>1){
display.print(ResultE[i]);
display.print(F(" "));
display.setTextSize(1);
display.print((int)a);
display.setTextSize(2);
display.print(F(" "));
display.display();
}
Result[i]=0;
counter1=0;
counter2=0;
//maxprobe==minprobe;
}
delay(25);
}
}
Für Hinweise auf Verbrechen gegen C die ich hier begangen habe, bin ich natürlich auch dankbar. Der Sketch arbeitet aber ansonsten wunschgemäß. 8)
Bisher erschien mir array typ char als das Mittel der Wahl, aber evtl. geht das hier anders besser?