Adição de mais 4 sensores, dois ADCs, 8 canais em simultâneo

Firmware/ADS1115.ino/ADS1115.ino.ino

 #include <Wire.h>
 #include <Adafruit_ADS1015.h>
 
-Adafruit_ADS1115 ads;  
-int16_t adc0, adc1, adc2, adc3;
-  float val0;
+Adafruit_ADS1115 ads0(0x48);
+Adafruit_ADS1115 ads1(0x49);
+  
+int16_t adc0, adc1, adc2, adc3, adc4, adc5, adc6, adc7;
 void setup(void) 
 {
   Serial.begin(115200);
@@ -12,16 +13,20 @@ void setup(void)
   //Serial.println("Getting single-ended readings from AIN0..3");
   //Serial.println("ADC Range: +/- 6.144V (1 bit = 3mV/ADS1015, 0.1875mV/ADS1115)");
   
-  ads.setGain(GAIN_TWOTHIRDS);        // ganho 1x   +/- 4.096V  1 bit = 2mV      0.125mV
-  ads.begin();
+  ads0.begin();
+  ads1.begin();
 }
 
 void loop(void) 
 {
-  adc0 = ads.readADC_SingleEnded(0);
-  adc1 = ads.readADC_SingleEnded(1);
-  adc2 = ads.readADC_SingleEnded(2);
-  adc3 = ads.readADC_SingleEnded(3);;
+  adc0 = ads0.readADC_SingleEnded(0);
+  adc1 = ads0.readADC_SingleEnded(1);
+  adc2 = ads0.readADC_SingleEnded(2);
+  adc3 = ads0.readADC_SingleEnded(3);
+  adc4 = ads1.readADC_SingleEnded(0);
+  adc5 = ads1.readADC_SingleEnded(1);
+  adc6 = ads1.readADC_SingleEnded(2);
+  adc7 = ads1.readADC_SingleEnded(3);
   Serial.print(adc0);
   Serial.print(" ");
   Serial.print(adc1);
@@ -29,8 +34,18 @@ void loop(void)
   Serial.print(adc2);
   Serial.print(" ");
   Serial.print(adc3);
+  Serial.print(" ");
+  Serial.print(adc4);
+  Serial.print(" ");
+  Serial.print(adc5);
+  Serial.print(" ");
+  Serial.print(adc6);
+  Serial.print(" ");
+  Serial.print(adc7);
+  Serial.print(" ");
+  Serial.print(millis());
   Serial.print("\n");
-  while(millis()%20!=0)
-  {}
+  while(millis()%100!=0);
+ 
   
 }

Firmware/HX711-sampling/HX711-sampling.ino

+#include "HX711.h"
+double a=0,b=0;
+// HX711.DOUT	- pin #A1
+// HX711.PD_SCK	- pin #A0
+
+HX711 channelA(A1, A0,32);		//Instancia um objeto da classe HX711 vinculado ao canal A 
+//HX711 channelB(A1, A0,128);    //Instancia um objeto da classe HX711 vinculado ao canal B
+void setup() {
+  Serial.begin(9600); //Inicia a Serial com taxa de tranferência de 115200 bps
+  
+
+  channelA.set_scale();       //Reseta a escala do canal A
+  channelA.tare();				    //
+
+  //channelB.set_scale();       //Reseta a escala do canal B
+  //channelB.tare();
+  
+  //channelA.set_offset(0);
+  //channelB.set_offset(0);
+  Serial.print("Primeira Leitura do Canal A: \t\t");
+  Serial.print(channelA.read());                 // Primeira leitura do canal A
+  Serial.print("\n\n");
+
+  /*Serial.print("Primeira Leitura do Canal B: \t\t");
+  Serial.print(channelB.read());                 // Primeira leitura do canal B
+  Serial.print("\n\n");*/
+  
+ /* Serial.print("Primeira média do canal A (20): \t\t");
+  Serial.print(channelA.read_average(20));       // Imprime a média de 20 leituras do canal A
+  Serial.print("\n\n");
+
+  Serial.print("Primeira média do canal B (20): \t\t");
+  Serial.print(channelB.read_average(20));       // Imprime a média de 20 leituras do canal B
+  Serial.print("\n\n");*/
+}
+
+void loop() {
+  //channelA.set_gain(128);
+  //Serial.print("\nLeitura (Canal A):"); //Realiza uma leitura do canal A e imprime na serial
+  a=channelA.read();
+  Serial.println(a);
+  while(!channelA.is_ready())
+  {}
+  /*if(a<b)
+  {Serial.print("\n\n");
+  Serial.print("ESSE:");
+  Serial.print(b);
+  Serial.print("\n\n");}*/
+  
+  //while(millis()%100!=0);
+  //Serial.println(millis());
+  
+  /*Serial.print("   ");
+  Serial.print(millis());
+  Serial.println();*/
+  //Serial.print("\n\n");
+  
+  /*channelA.set_gain(32);
+  Serial.print("Leitura (Canal B):"); //Realiza uma leitura do canal B e imprime na serial
+  Serial.print(channelA.read_average(5));*/
+  
+  /*Serial.print("\n\n");
+  a=analogRead(A3);
+  a=a*5/1023;
+  Serial.println(a);
+  Serial.println(channelA.get_scale());
+  //Serial.println(channelB.get_scale());
+  Serial.println(channelA.get_offset());
+  //Serial.println(channelB.get_offset());*/
+  /*channelA.power_down();
+  delay(500);
+  channelA.power_up();*/
+}
+

Firmware/HX711.cpp

+#include <Arduino.h>
+#include <HX711.h>
+
+#if ARDUINO_VERSION <= 106
+    // "yield" is not implemented as noop in older Arduino Core releases, so let's define it.
+    // See also: https://stackoverflow.com/questions/34497758/what-is-the-secret-of-the-arduino-yieldfunction/34498165#34498165
+    void yield(void) {};
+#endif
+
+HX711::HX711(byte dout, byte pd_sck, byte gain) {
+	begin(dout, pd_sck, gain);
+}
+
+HX711::HX711() {
+}
+
+HX711::~HX711() {
+}
+
+void HX711::begin(byte dout, byte pd_sck, byte gain) {
+	PD_SCK = pd_sck;
+	DOUT = dout;
+
+	pinMode(PD_SCK, OUTPUT);
+	pinMode(DOUT, INPUT);
+
+	set_gain(gain);
+}
+
+bool HX711::is_ready() {
+	return digitalRead(DOUT) == LOW;
+}
+
+void HX711::set_gain(byte gain) {
+	switch (gain) {
+		case 128:		// channel A, gain factor 128
+			GAIN = 1;
+			break;
+		case 64:		// channel A, gain factor 64
+			GAIN = 3;
+			break;
+		case 32:		// channel B, gain factor 32
+			GAIN = 2;
+			break;
+	}
+
+	digitalWrite(PD_SCK, LOW);
+	read();
+}
+
+long HX711::read() {
+	// wait for the chip to become ready
+	while (!is_ready()) {
+		// Will do nothing on Arduino but prevent resets of ESP8266 (Watchdog Issue)
+		yield();
+	}
+
+	unsigned long value = 0;
+	uint8_t data[3] = { 0 };
+	uint8_t filler = 0x00;
+
+	// pulse the clock pin 24 times to read the data
+	data[2] = shiftIn(DOUT, PD_SCK, MSBFIRST);
+	data[1] = shiftIn(DOUT, PD_SCK, MSBFIRST);
+	data[0] = shiftIn(DOUT, PD_SCK, MSBFIRST);
+
+	// set the channel and the gain factor for the next reading using the clock pin
+	for (unsigned int i = 0; i < GAIN; i++) {
+		digitalWrite(PD_SCK, HIGH);
+		digitalWrite(PD_SCK, LOW);
+	}
+
+	// Replicate the most significant bit to pad out a 32-bit signed integer
+	if (data[2] & 0x80) {
+		filler = 0xFF;
+	} else {
+		filler = 0x00;
+	}
+
+	// Construct a 32-bit signed integer
+	value = ( static_cast<unsigned long>(filler) << 24
+			| static_cast<unsigned long>(data[2]) << 16
+			| static_cast<unsigned long>(data[1]) << 8
+			| static_cast<unsigned long>(data[0]) );
+
+	return static_cast<long>(value);
+}
+
+long HX711::read_average(byte times) {
+	long sum = 0;
+	for (byte i = 0; i < times; i++) {
+		sum += read();
+		yield();
+	}
+	return sum / times;
+}
+
+double HX711::get_value(byte times) {
+	return read_average(times) - OFFSET;
+}
+
+float HX711::get_units(byte times) {
+	return get_value(times) / SCALE;
+}
+
+void HX711::tare(byte times) {
+	double sum = read_average(times);
+	set_offset(sum);
+}
+
+void HX711::set_scale(float scale) {
+	SCALE = scale;
+}
+
+float HX711::get_scale() {
+	return SCALE;
+}
+
+void HX711::set_offset(long offset) {
+	OFFSET = offset;
+}
+
+long HX711::get_offset() {
+	return OFFSET;
+}
+
+void HX711::power_down() {
+	digitalWrite(PD_SCK, LOW);
+	digitalWrite(PD_SCK, HIGH);
+}
+
+void HX711::power_up() {
+	digitalWrite(PD_SCK, LOW);
+}

Firmware/HX711.h

+#ifndef HX711_h
+#define HX711_h
+
+#include "Arduino.h"
+#else
+#include "WProgram.h"
+#endif
+
+class HX711
+{
+	private:
+		byte PD_SCK;	// Power Down and Serial Clock Input Pin
+		byte DOUT;		// Serial Data Output Pin
+		byte GAIN;		// amplification factor
+		long OFFSET = 0;	// used for tare weight
+		float SCALE = 1;	// used to return weight in grams, kg, ounces, whatever
+
+	public:
+		// define clock and data pin, channel, and gain factor
+		// channel selection is made by passing the appropriate gain: 128 or 64 for channel A, 32 for channel B
+		// gain: 128 or 64 for channel A; channel B works with 32 gain factor only
+		HX711(byte dout, byte pd_sck, byte gain = 128);
+
+		HX711();
+
+		virtual ~HX711();
+
+		// Allows to set the pins and gain later than in the constructor
+		void begin(byte dout, byte pd_sck, byte gain = 128);
+
+		// check if HX711 is ready
+		// from the datasheet: When output data is not ready for retrieval, digital output pin DOUT is high. Serial clock
+		// input PD_SCK should be low. When DOUT goes to low, it indicates data is ready for retrieval.
+		bool is_ready();
+
+		// set the gain factor; takes effect only after a call to read()
+		// channel A can be set for a 128 or 64 gain; channel B has a fixed 32 gain
+		// depending on the parameter, the channel is also set to either A or B
+		void set_gain(byte gain = 128);
+
+		// waits for the chip to be ready and returns a reading
+		long read();
+
+		// returns an average reading; times = how many times to read
+		long read_average(byte times = 10);
+
+		// returns (read_average() - OFFSET), that is the current value without the tare weight; times = how many readings to do
+		double get_value(byte times = 1);
+
+		// returns get_value() divided by SCALE, that is the raw value divided by a value obtained via calibration
+		// times = how many readings to do
+		float get_units(byte times = 1);
+
+		// set the OFFSET value for tare weight; times = how many times to read the tare value
+		void tare(byte times = 10);
+
+		// set the SCALE value; this value is used to convert the raw data to "human readable" data (measure units)
+		void set_scale(float scale = 1.f);
+
+		// get the current SCALE
+		float get_scale();
+
+		// set OFFSET, the value that's subtracted from the actual reading (tare weight)
+		void set_offset(long offset = 0);
+
+		// get the current OFFSET
+		long get_offset();
+
+		// puts the chip into power down mode
+		void power_down();
+
+		// wakes up the chip after power down mode
+		void power_up();
+};
+
+#endif /* HX711_h */

Firmware/makefile

+help:
+	@echo 'Help details:'
+	@echo 'hex: compile hex file'
+	@echo 'flash: install hex file'
+	@echo 'program: compile hex and install'
+
+hex:
+	avr-gcc -Os -DF_CPU=16000000 -mmcu=atmega328p -c main.cpp
+	avr-gcc -DF_CPU=16000000 -mmcu=atmega328p -o main.elf main.o
+	avr-objcopy -O ihex main.elf main.hex
+	rm main.o
+	rm main.elf
+
+flash:
+		avrdude -c arduino -p atmega328p -P /dev/ttyUSB0 -U flash:w:main.hex

Interface/SerialGraph.py

@@ -4,7 +4,7 @@ import serial
 import time
 from mainwindow import Ui_MainWindow
 
-ser = serial.Serial('/dev/ttyUSB1', 115200)  #Inicialização da Serial com baudrate 115200bps
+ser = serial.Serial('/dev/ttyUSB0', 115200)  #Inicialização da Serial com baudrate 115200bps
 ser.setDTR(False)                            #Reset do arduino para reinicio da leitura
 time.sleep(0.022)
 ser.setDTR(True)
@@ -29,13 +29,21 @@ curve1 = p1.plot(pen='r',name="Sensor 1")
 curve2 = p1.plot(pen='g',name="Sensor 2")
 curve3 = p1.plot(pen='w',name="Sensor 3")
 curve4 = p1.plot(pen='y',name="Sensor 4")
-curve1.name="Sensor 1"
+curve5 = p1.plot(pen='b',name="Sensor 5")
+curve6 = p1.plot(pen='m',name="Sensor 6")
+curve7 = p1.plot(pen='c',name="Sensor 7")
+curve8 = p1.plot(name="Sensor 8")
+
 window.CentralGraph.setFixedSize(690,550)
 layout.setPreferredSize(640,500)
 y1 = []                                     #Inicialização da lista dinâmica dos valores de y
 y2 = []
 y3 = []
 y4 = []
+y5 = []
+y6 = []
+y7 = []
+y8 = []
 x1 = []                                     #Inicialização da lista dinâmica dos valores de x
 x_max = 200                                  #Variável que define o tamanho do eixo
 indx = 0                                    #Variável auxiliar de contagem
@@ -56,12 +64,16 @@ def update():                               #Método para atualizar os arrays co
         pass
     readData = ser.readline()       #Lê o dado da serial
     readData=readData.decode('utf8')
-    dado=readData.split(' ',3)
-    print(dado[0])
+    dado=readData.split(' ',8)
+    print(dado[3])
     y1.append(float(dado[0])*5/32767)                     #Armazena o dado na lista do eixo y
     y2.append(float(dado[1])*5/32767)
     y3.append(float(dado[2])*5/32767)
     y4.append(float(dado[3])*5/32767)
+    y5.append(float(dado[4])*5/32767)
+    y6.append(float(dado[5])*5/32767)
+    y7.append(float(dado[6])*5/32767)
+    y8.append(float(dado[7])*5/32767)
 
     indx += 1                               #Adiciona um na variavel auxiliar
     if len(y1) > x_max-1:                   #Verifica se foi excedido o tamanho máximo do eixo x para o array
@@ -69,6 +81,10 @@ def update():                               #Método para atualizar os arrays co
         del y2[0]
         del y3[0]
         del y4[0]
+        del y5[0]
+        del y6[0]
+        del y7[0]
+        del y8[0]
         indx = x_max                        #impede indx de divergir
     else:
         x1.append(indx)                     #Vai adicionando valores de 0 a x_max no eixo x até que a lista x lote e tenha mesmo tamanho da lista y
@@ -77,6 +93,10 @@ def update():                               #Método para atualizar os arrays co
     curve2.setData(x1,y2)
     curve3.setData(x1,y3)
     curve4.setData(x1,y4)
+    curve5.setData(x1, y5)
+    curve6.setData(x1, y6)
+    curve7.setData(x1, y7)
+    curve8.setData(x1, y8)
 
 
     #app.processEvents()                     #