Compañeros estoy comunicacando 6 sensores por i2c y todo va bien pero necesito poner un segundo maestro, pero no encuentro mucha informacion por el buscador.
Mi duda es como poner el segundo maestro para que mientras este trabajando el primer maestro no interrumpa y genere conflictos y viceversa.
Segundo maestro? Imposible a menos que de algun modo el primero pase a modo esclavo o se desconecte del bus I2C, lo que requiere comunicación entre tus dos Maestros.
Que raro lo que intentas!!
Porque no explicas bien que quieres hacer en lugar de presentarlo de este modo?
son 6 sensores de presión( celdas de carga) que me envían datos al maestro( que también utiliza un sensor de presión), el maestro se encarga de preguntar cuanto peso hay en cada sensor y lo compara con su peso y toma determinadas acciones si es que la suma corresponde al peso del primer maestro.
Pero quiero poner un segundo maestro para que cuando las combinaciones no concuerden con la suma del primer maestro, entre a trabajar el segundo maestro( el primero tiene que avisar al segundo y desconectarse).
Creo que mientras este trabajando un maestro, el otro sera un esclavo( esperando la orden para trabajar)y viceversa. Uno de ellos tendria que estar desconectado.
Necesito un ejemplo de comunicacion i2c, con 2 maestros, pero no lo encuentro en ningun lado
Es que no la vas a encontrar porque no es posible.
Como te respondí, la topología de la comunicación I2C requiere un maestro y sus esclavos.
Si podrías hacer eso.. que el segundo maestro esté como esclavo esperando la orden para tomar el control y entonces el primero se desconecte y ceda el control al 2do y viceverza.
No he visto como hacerlo pero no me parece dificil.
Lo que no comprendo de tu idea es que un Arduino Maestro por X razón tendra datos digamos malos o equivocados y debe ceder la decisión a otro Arduino. Cual es el problema en manterner la topología tal como está y enviar todos los datos al Arduino Secundario y que este resuelva las cosas?
Complemento mi respuesta luego de informarme debidamente al respecto.
Parece ser que no hay problema alguno en tener MULTIPLES MAESTROS
para resumirlo prueba este código a ver como se comporta en tu enfoque
**
* Implementación ejemplo MULTI MAestro I2C. Envia el estado de un botón a otro
* Arduino, que flashea un led correspondiente al estado del botón.
*
* Conexiones: Arduino pin A4 y A5 conectados entre dos Arduinos,
* con un resistor pull-up de 1k conectados en cada línea. Conectar un botón pulsador entre
* pin 10 and ground, y un LED (con un resistor 330 o 470 ohms) al pin 9.
*/
#include <Wire.h>
#define LED 9
#define BOTON 10
#define ESTA_DIRECCION 0x8
#define OTRA_DIRECCION 0x9
bool estadoAnt = HIGH;
void setup() {
pinMode(LED, OUTPUT);
digitalWrite(LED, LOW);
pinMode(BUTTON, INPUT);
digitalWrite(BUTTON, HIGH);
Wire.begin(ESTA_DIRECCION);
Wire.onReceive(receiveEvent);
}
void loop() {
if (digitalRead(BOTON) != estadoAnt){
last_state = digitalRead(BOTON);
Wire.beginTransmission(OTRA_DIRECCION);
Wire.send(estadoAnt);
Wire.endTransmission();
}
}
void receiveEvent(int valor){
while (Wire.available() > 0){
bool b = Wire.receive();
Serial.print(b, DEC);
digitalWrite(LED, !b);
}
Serial.println();
}
espero comentarios
hola surbyte; disculpa por la demora de la respuesta es que estube de viaje con full trabajo dejando de lado mi proyecto, pero ahora mismo me incorpore y haciendo unas pruebas decidi poner un solo maestro, osea:
Dos balanzas van tener un peso encima( estas 2 van a ser con las que se van a ser las combinaciones). El maestro pregunta el peso a las dos balanzas patron( una ala vez, la que tenga peso mayor)y ese peso lo compara con 10 balanzas mas( aumente un poco el numero de balanzas) y las balanzas que sumen 500gramos( encienden 2 led).
Soy novato en arduino, pero quemando un poco de neuronas ya estoy obteniendo resultados,y funciona correctamente por momentos, pero esta un poco inestable, la verdad que el uso del goto no me da confianza, pero lo tuve que usar porque sino los led encienden correctamente y me parpadean, ademas que aveces al preguntar el peso a la segunda balanza se demora en apagar los led o aveces se cuelga.
Adjunto un poco de mi codigo aver si me hechas una mano.
void loop(){
inicio:
Wire.requestFrom(12,8); // Pedimos 8 bytes al esclavo 12(balanza 1)
pesoBal1(); //lo guardamos en una variable
if(balanza1 > 0.01){ //si es mayor a 0.01g hacemos las comparaciones
apagarLeds();
balanzaUno();
}
else{
//Serial.println("PESO DE ESCLAVO 12 ES BAJO");
goto Bal2; //de lo contrario nos vamos a la segunda balanza
}
if( balanza1 < 0.01) {
Bal2:
Wire.requestFrom(11,8); // Pedimos 8 bytes al esclavo 11(balanza 2)
pesoBal2(); //lo guardamos en una variable
if(balanza2 > 0.01){ //si es mayor a 0.01g hacemos las comparaciones
apagarLeds();
balanzaDos();
}
else{ //de lo contrario regresamos al inicio
goto inicio;
//Serial.println("PESO DE ESCLAVO 12 ES BAJO");
}
}
}
y con este otro codigo hago las sumas combinando solo hasta dos balanzas
uso dos void: balanzaUno(), y Balanza2()
void balanzaUno(){
///ESCLAVO 1 ////
slave1:
if(conta ==1){
Wire.requestFrom(1,8); // Pedimos 8 bytes al esclavo 1
CompararDatos();
if((result >= 0.495) && (result < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo1, HIGH); //encendemos led para el esclavo 1
goto slave1;
}
else{
apagarLeds();
conta++;
}
}
///ESCLAVO 2 ////
slave2:
if(conta ==2){
Wire.requestFrom(2,8); // Pedimos 8 bytes al esclavo 2
CompararDatos();
if((result >= 0.495) && (result < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo2, HIGH); //encendemos led para el esclavo 2
goto slave2;
}
else{
apagarLeds();
conta++;
}
}
///hasta el contador 55, luego vuelve a contador uno
esto es lo mas raro que he visto hasta hoy
goto Bal2; //de lo contrario nos vamos a la segunda balanza
}
if (balanza1 < 0.01) {
Bal2:
sales de un if y te metes dentro de otro? No tiene mucha coherencia.
tienes razon es que la verdad, lo hize algo apurado, pero ya lo corregi:
apagarLeds();
Wire.requestFrom(12,8); // Pedimos 8 bytes al esclavo 12(balanza 1)
pesoBal1(); //lo guardamos en una variable
if(balanza1 > 0.01){ //si es mayor a 0.01g hacemos las comparaciones
apagarLeds();
balanzaUno();
}
else{
Wire.requestFrom(11,8); // Pedimos 8 bytes al esclavo 11(balanza 2)
pesoBal2(); //lo guardamos en una variable
}
if(balanza2 > 0.01){ //si es mayor a 0.01g hacemos las comparaciones
apagarLeds();
balanzaDos();
}
}
Compañeros tengo un problema con este trozo de codigo, lo que hace es preguntar peso a los esclavos y cuando este dentro del rango de peso encender unos led, y funciona bien si saco el peso rapidamente, pero asi no es el procedimiento sino que tengo que sacar el peso de las balanzas que me señalan los led y ponerlo en la balanza patron, y aqui es el problema pues cuando saco el peso de las balanzas y lo pongo en la balanza patron, se cuelga el circuito y se demora en estabilizar.
ejemplo: tengo 100 gramos en la balanza patron numero 1( esclavo11), y tengo 200 gramos en el esclavo 4 y 7; entonces si sumamos tenemos 500gramos en las 3 balanzas yencienden los led del esclavo 1 ,4 y 7 ( asta alli va bien), pero cuando saco el peso del esclavo 4 y 7 y lo pongo en el esclavo 1( lo saco porque la balanza 1 contiene un deposito para poner el resto de peso), el sistema se cuelga y aunque saque el peso los led quedan encendidos y se demora en estabilizar para que entre a funcionar la segunda balanza patron, que tambien contiene peso( esclavo12).
Mi consulta seria, como hacer para que el sistema no trabaje hasta que retire todo el peso).Espero una ayuda
adjunto un trozo de codigo mas.
///ESCLAVO 1 ////
slave1:
if(conta ==1){
Wire.requestFrom(1,8); // Pedimos 8 bytes al esclavo 1
CompararDatos();
if((result >= 0.495) && (result < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo1, HIGH); //encendemos led para el esclavo 1
goto slave1;
}
else{
apagarLeds(); //apagamos todos lo leds
conta++;
}
}
///ESCLAVO 2 ////
slave2:
if(conta ==2){
Wire.requestFrom(2,8); // Pedimos 8 bytes al esclavo 2
CompararDatos();
if((result >= 0.495) && (result < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo2, HIGH); //encendemos led para el esclavo 2
goto slave2;
}
else{
apagarLeds();//apagamos todos lo leds
conta++; //aumento el contador
}
}
///ESCLAVO 3 ////
slave3:
if(conta ==3){
Wire.requestFrom(3,8); // Pedimos 8 bytes al esclavo 3
CompararDatos(); // comparo los datos
if((result >= 0.495) && (result < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo3, HIGH); //encendemos led para el esclavo 3
goto slave3;
}
else{
apagarLeds();
conta++;
}
}
///ESCLAVO 4 ////
slave4:
if(conta ==4){
Wire.requestFrom(4,8); // Pedimos 8 bytes al esclavo 4
CompararDatos();
if((result >= 0.495) && (result < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo4, HIGH); //encendemos led para el esclavo 4
goto slave4;
}
else{
apagarLeds();
conta++;
}
}
/////////ESCLAVO5/////
slave5:
if(conta ==5){
Wire.requestFrom(5,8); // Pedimos 8 bytes al esclavo 5
CompararDatos();
if((result >= 0.495) && (result < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo5, HIGH); //encendemos led para el esclavo 5
goto slave5;
}
else{
apagarLeds();
conta++;
}
}
/////////ESCLAVO6/////
slave6:
if(conta ==6){
Wire.requestFrom(6,8); // Pedimos 8 bytes al esclavo 6
CompararDatos();
if((result >= 0.495) && (result < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo6, HIGH); //encendemos led para el esclavo 6
goto slave6;
}
else{
apagarLeds();
conta++;
}
}
//////////ESCLAVO7/////
slave7:
if(conta ==7){
Wire.requestFrom(7,8); // Pedimos 8 bytes al esclavo 7
CompararDatos();
if((result >= 0.495) && (result < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo7, HIGH); //encendemos led para el esclavo 7
goto slave7;
}
else{
apagarLeds();
conta++;
}
}
/////////ESCLAVO 8/////
slave8:
if(conta ==8){
Wire.requestFrom(8,8); // Pedimos 8 bytes al esclavo 8
CompararDatos();
if((result >= 0.495) && (result < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo8, HIGH); //encendemos led para el esclavo 8
goto slave8;
}
else{
apagarLeds();
conta++;
}
}
/////////ESCLAVO 9/////
slave9:
if(conta ==9){
Wire.requestFrom(9,8); // Pedimos 8 bytes al esclavo 9
CompararDatos();
if((result >= 0.495) && (result < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo9, HIGH); //encendemos led para el esclavo 9
goto slave9;
}
else{
apagarLeds();
conta++;
}
}
/////////ESCLAVO 10/////
slave10:
if(conta ==10){
Wire.requestFrom(10,8); // Pedimos 8 bytes al esclavo 10
CompararDatos();
if((result >= 0.495) && (result < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo10, HIGH); //encendemos led para el esclavo 10
goto slave10;
}
else{
apagarLeds();
conta++;
}
}
///ESCLAVO 1 Y 2 ////(CONTADOR= 11)
slave11:
if(conta ==11){
Wire.requestFrom(1,8); // Pedimos 8 bytes al esclavo 1
CompararDatos2();
Wire.requestFrom(2,8); // Pedimos 8 bytes al esclavo 2
CompararDatos3();
if((result3 >= 0.495) && (result3 < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo2, HIGH); //encendemos led para el esclavo 2 y 1
digitalWrite(ledEsclavo1, HIGH);
goto slave11;
}
else{
apagarLeds();
conta++;
}
}
///ESCLAVO 1 Y 3////CONTADOR =12
slave12:
if(conta ==12){
Wire.requestFrom(1,8); // Pedimos 8 bytes al esclavo 1
CompararDatos2();
Wire.requestFrom(3,8); // Pedimos 8 bytes al esclavo 3
CompararDatos3();
if((result3 >= 0.495) && (result3 < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro y esclavo 1 y 3
digitalWrite(ledEsclavo1, HIGH);
digitalWrite(ledEsclavo3, HIGH);
goto slave12;
}
else{
apagarLeds();
conta++;
}
}
///ESCLAVO 1 Y 4////CONTADOR =13
slave13:
if(conta ==13){
Wire.requestFrom(1,8); // Pedimos 8 bytes al esclavo 1
CompararDatos2();
Wire.requestFrom(4,8); // Pedimos 8 bytes al esclavo 4
CompararDatos3();
if((result3 >= 0.495) && (result3 < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro y esclavo1 y 4
digitalWrite(ledEsclavo1, HIGH);
digitalWrite(ledEsclavo4, HIGH);
goto slave13;
}
else{
apagarLeds();
conta++;
}
}
Primero lo primero, haz probado individualmente cada código del esclavo leyendo la balanza?
Cuando haces el cambio lo reporta bien?
Si todo eso funciona, entonces no comprendo como un simple reflejo de una dato i2c cualque algo.
E probado el codigo sin hacer el cambio a la segunda balanza y funciona correctamente, los esclavos me envian datos correctos, los led encienden y se apagan normal, no se cuelga para nada, todo esto pasa cuando solo hay una balanza patrón. Igualmente cuando pruebo la segunda balanza patrón también todo funciona muy bien.
el problema se presenta cuando enlazo al sistema las dos balanzas patron, en como hacer el cambio de un balanza patrón a otra.
Había escrito algo pero agregaste mas info.
Que hace de raro usar una balanza patrón?
Agregó la segunda balanza patron, para que cuando se este retirando el peso de la primera balanza patrón, rápidamente es sistema haga las combinaciones de la segunda balanza patrón y así mientras se este sacando el peso de la segunda balanza patrón la primera balanza ya esté haciendo combinaciones y viceversa.
Nota: cuando se saca el peso de una balanza, rapidamenete se le vuelve a poner otro peso.
Te entiendes tu solo con esa respuesta. No veo como eso pueda alterar le funcionamiento de la red.
Compañeros solucione el problema de porque se colgaba el sistema, bueno en realidad no se colgaba solo se ponía lento, explico la solución para que alguien en el futuro le pueda servir.
La falla era que no borraba el dato de peso de las balanzas patrón hasta que terminaran las combinaciones, La solución fue consultar el peso de la balanza patrón (esclavo 12 o esclavo 11), a cada momento que se hacia la suma con los esclavos, pues yo solo preguntaba el peso de la balanza madre una sola vez al inicio de las combinaciones y no borraba el dato hasta que terminara toda la lista de combinaciones, así que encendían los led y así sacara el peso de la balanza madre, el sistema creía que todavía había peso en la balanza madre pues no borraba el dato, y el sistema no podía cambiar ala otra balanza madre( esclavo 12).
Ahora pegunto el peso por cada comparación. adjunto:
///ESCLAVO 1 ////
slave1:
if(conta ==1){ //Aumento el contador y pregunto peso a la balanza patron.
Wire.requestFrom(12,8); // Pedimos 8 bytes al esclavo 12(balanza 1)
pesoBal1();
Wire.requestFrom(1,8); // Pedimos 8 bytes al esclavo 1
CompararDatos();
if((result >= 0.495) && (result < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo1, HIGH); //encendemos led para el esclavo 1
goto slave1;
}
else{
apagarLeds(); //apagamos todos lo leds
conta++;
}
}
///ESCLAVO 2 ////
slave2:
if(conta ==2){ //Aumento el contador y pregunto peso a la balanza patron.
Wire.requestFrom(12,8); // Pedimos 8 bytes al esclavo 12(balanza 1)
pesoBal1();
Wire.requestFrom(2,8); // Pedimos 8 bytes al esclavo 2
CompararDatos();
if((result >= 0.495) && (result < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo2, HIGH); //encendemos led para el esclavo 2
goto slave2;
}
else{
apagarLeds();//apagamos todos lo leds
conta++; //aumento el contador
}
}
///ESCLAVO 3 ////
slave3:
if(conta ==3){ //Aumento el contador y pregunto peso a la balanza patron.
Wire.requestFrom(12,8); // Pedimos 8 bytes al esclavo 12(balanza 1)
pesoBal1();
Wire.requestFrom(3,8); // Pedimos 8 bytes al esclavo 3
CompararDatos(); // comparo los datos
if((result >= 0.495) && (result < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo3, HIGH); //encendemos led para el esclavo 3
goto slave3;
}
else{
apagarLeds();
conta++;
}
}
///ESCLAVO 4 ////
slave4:
if(conta ==4){ //Aumento el contador y pregunto peso a la balanza patron.
Wire.requestFrom(12,8); // Pedimos 8 bytes al esclavo 12(balanza 1)
pesoBal1();
Wire.requestFrom(4,8); // Pedimos 8 bytes al esclavo 4
CompararDatos();
if((result >= 0.495) && (result < 0.510)){ //Comparamos si el resultado esta dentro del rango
digitalWrite(ledMaestro, HIGH); //encendemos led maestro
digitalWrite(ledEsclavo4, HIGH); //encendemos led para el esclavo 4
goto slave4;
}
else{
apagarLeds();
conta++;
}
}
//HASTA EL CONTADOR 55 LUEGO PASA ALA SEGUNDA BALANZA PATRON
Doi por solucionado el post..
Bien me da gusto y es por eso que yo te consultaba, como era posible que funcionara bien y que cambiara el comportamiento cuando ponías una pesa en otro lado.