good evening mjs513
correct, "wire1" can be anything
I could call it "blah"
now if a second thread wanted to use "blah", sorry, its locked, wait for it.
blah is released, and next blah can lock.
basically, the class name itself is locked, no similar locks will work together, and take turns
hope i said it right for you
in my case i could call wire,wire1,wire2 as a mutex class in the sketch
anytime i write to a SHARED wire1 bus, ONLY wire1 mutexes are blocked while wire1 is locked.
so basically, only SAME NAMES cant run, so if one thread locks wire1, another thread won't be able to access wire1, BUT, it could still lock and use wire2
by labelling them something easier to understand, we will know that whenever we do an i2c read/write on wire1, we add a scope lock to wire1, so that nothing else talks to that i2c bus.
so if i use 11 i2c devices on the same bus
they will all use wire1 scope lock
technically, we're only blocking same mutexes and not others. Or in other words, we're locking down the name of the class (wire1) and no one else can use wire1 until it's released, but you can still access other mutexes, only the same name convection ones are locked. this is why you can access serial, serial1, serial2, etc, wire1 wire2, spi1, spi2 all at the same time, but they each get a priority lock, other accesses are blocked, as 2 spi1 locks will never happen, the second one only happens after the first one unlocks.
and yes, im using wire1 in the demo, even im using wire, because my project uses wire1, but it shows you you can name your locks anything you want
Threads::Mutex wire1;
Threads::Mutex spi1;
Threads::Mutex serial;
Threads::Mutex mjs513; <-- new lock
This could also not only be for hardware use, but for regular coding use, variables, etc. You could use atomic or whatever, or use this for specific code you want to run
Code:
{ Threads::Scope scope(mjs513);
//as an example, since theres only 2 scopes, we'll let them run sequentially, with combined commands, because, even with combined serial and i2c in the scope, the 2 scopes will never run together.
Serial.println("This is a test");
Wire.beginTransmission(32); Wire.write(0x0C); Wire.write(0xFF); Wire.write(0xFF); Wire.endTransmission();
Wire.beginTransmission(32); Wire.write(0x12); Wire.endTransmission(); Wire.requestFrom(32, 2);
x = Wire.read();
y = Wire.read();
}
{ Threads::Scope scope(mjs513);
//as an example, since theres only 2 scopes, we'll let them run sequentially, with combined commands, because, even with combined serial and i2c in the scope, the 2 scopes will never run together.
Serial.println("This is a test");
Wire.beginTransmission(32); Wire.write(0x0C); Wire.write(0xFF); Wire.write(0xFF); Wire.endTransmission();
Wire.beginTransmission(32); Wire.write(0x12); Wire.endTransmission(); Wire.requestFrom(32, 2);
x = Wire.read();
y = Wire.read();
}
this is an example of dual serial and i2c inside the same lock using your name, since the same name scopes are set, and theres only 2 scopes, it shows you how each scope can run sequentually, and never together, no matter what bus it accesses
this might give you a better understanding
but the method above your post that i did is the right way to access multiple devices on the same bus without issues.
