Published November 9, 2022 © GPL3+

Connecting BlueBus Technology photocells to Arduino

Let Arduino pilot photocells and other home automation sensors connected via the BlueBus Technology.

IntermediateShowcase (no instructions)549

Connecting BlueBus Technology photocells to Arduino

Things used in this project

Hardware components

Arduino UNO

Arduino Mega 2560

Breadboard (generic)

Resistor 1k ohm

Resistor 10k ohm

MOSFET Transistor, Switching

Resistor 4.7 ohm

General Purpose Transistor PNP

Test Accessory, AC Power Adaptor

Software apps and online services

Arduino IDE

Story

A well know home automation system provider uses the BlueBus Technology to connect its sensors (pair of photocells...) to the Controlling Unit. Let's re-use these sensors for any kind of Arduino project.

The challenge is to get the Arduino behave like the controlling unit and be able to get the status of the sensors.

The BlueBus is made of only a pair of 2 wires, all sensors are plugged in derivation on these 2 wires. This is both the power supply and the communication media.

I haven't found any useful documentation on the Internet, describing the type of electric signal and transmission protocole for this bus. No problem, let's investigate...

For the time being, this project is just a proof-of-concept.

Bus concepts

The bus shows a 12V DC voltage which is used to power the devices connected (typically a pair of TX and RX photocells).

It allows as well a bidirectional communication between the controlling unit and the devices by modulating voltage and current with pulses.

Communication from controlling unit to devices: every 32ms, the controlling unit shut down the power supply of the bus for short time pulses, building a 8-bit message. This message is mainly the address code of one of the connected devices. These pulses are received by all the devices, only the addressed device should then reply to the controller.

Communication from a device to the controlling unit: the addressed device start to reply immediately after the end of the controlling unit message. It uses the same type of pulses to form a 8-bit reply message. But in this case, these pulses do not change the voltage but the current circulating in the bus. Each pulse causes the current to increase to about 160mA. The controlling unit monitor the current consumption on the bus and can get the reply message.

The base frequency for sending bits is 600Hz, meaning about 1.66ms per bit. This duration is split in 3 thirds where each bit is coded as a sequence of a LOW level and a HIGH level:

                      _0.56_ 
bit "1"  |___1.1ms___|      |
                 ___1.1ms___ 
bit "0"  |_0.56_|           |

the full message is made of 8 bits of data (MSB first) + 1 stop bit (0):

 |------------32ms-------------|      xxxxxxxx: message from ctrlling unit
 |xxxxxxxx0-------16.9ms-------|      yyyyyyyy: message from device
 |xxxxxxxx0yyyyyyyy0---1.8ms---|      0 are the stop bits

The sequence question/reply is repeated every 32ms.

transmission of 00000110 (0x06) + 1 stop bit

transmission of 00010111(0) followed by the reply from device 11110011(0)

During a recognition phase, the controlling unit queries each of the possible address codes of devices, listen for a reply (if any) and build a list of connected devices on the bus. Then, it queries each of these devices, one after the other, and gets their replies.

Message from Controlling Unit to Devices : aabcccfp
     aa : address extension (0 ?)
     b  : address modifier (A bridge on the board)
     ccc : addr as configured with the jumpers
     f : reset flag ? should be 1 for normal operation
     p : parity bit

Devices have jumpers on their board where their address code can be configured, from 1 (ccc=001) to 15 (ccc=111).

The reply message is somehow scrambled in order to detect any collision (2 devices having the same address on the bus):

Reply mmessage from Devices : xxxxyyyy
     xxxx xor yyyy xor bccc --> effective data (4 bits)
(bccc is the address code of the device + its address modifier)

Hardware part

In order to let the Arduino send the messages (acting as the Bus Controlling Unit) and read the reply from the devices, a very small piece of hardware is required.

hardware needed to send and read signals over the bus

Vin  : 12V supply from the Arduino (using a DC adapter)
OC2B : output from Arduino,
        - when LOW : MOSFET is blocked, power is cut on the bus
        - when HIGH: MOSFET is conducting, bus is powered with Vin
IN   : input of Arduino for reading the replies
        - when device increase the current to 160mA, the voltage on
          the 4.7ohm resistor is enough to activate the transistor
          and pull down the IN line to GND
        - when device is in standby, current is quite low, transistor is
          blocked, the IN line is pulled up to Vcc (5V) coming
          from the OC2B line
As a consequence, the IN line is showing both the sent message (available on OC2B) and the reply.

Software part

The software intensively uses the integrated TIMER/COUNTER of the Arduino processor to generate the desired waveform and the interrupt mechanism.

The 8-bit timer TIMER2/COUNTER2 is used, setup in the fast-PWM mode, and using the OC2B output signal available on pin D3 (UNO) or D9 (MEGA):

* The input clock for TIMER2 is set as CPU clock divided by 128, giving
  a 8µs time interval
* TCNT counter is incremented every 8µs and is reset when reaching the
  value in register OCRA, set to 210:
    210 * 8µs -> 1.68ms, duration of 1 bit
* When counter resets, the OC2B output is set to LOW.
* OCR2B is set to either 210/3 (for a "0" bit) or 210*2/3 (for a "1" bit)
* at the time TCNT counter reaches OCR2B value, after 0.56ms or 1.1ms
   o the OC2B output is set to HIGH
   o an interupt is generated and the ISR routine sets the next value
     for the OCR2B register
When no data is to be sent, the OC2B output is disconnected from the pin, the signal available on the pin is then basically a normal digial output.

The ISR routine is also used for reading the reply from the IN pin.

* OCR2B is set to 210/2 (right at the middle of the bit)
* interrupt calls ISR at this time
* ISR read the status of the IN pin and decide if the bit is "0" or "1"
time scale in...    ms             number of 8µs ticks
                        _0.56_                 __70__
bit "1"    |___1.1ms___|      |     |___140___|      |
                    ^                        ^
                   ___1.1ms___              ___140___
bit "0"    |_0.56_|           |     |__70__|         |
                    ^                        ^
interrupt here    __|                      __|

The source file is well commented, many additional information available there.

To be really easy-to-use, the code provides simple functions (all names are prefixed with "BB_"). They can be easily called by a real application program. A typical application could be:

... insert here the library code, or #include it ...
void setup() {
 BB_init(3);       // read bus on port D3
 BB_on();          // activate bus and communication
 delay(1000);      // wait for the devices to power-up
 BB_recognition(); // initiate a recognition phase
}
void loop() {
 BB_Event* e;
 while ((e=BB_event_pop())->evt) {
   Serial.print("Device ");
   Serial.print(e->addr, HEX);
   Serial.print(", new status ");
   Serial.print(e->status, HEX);
   Serial.print(", timestamp ");
   Serial.println(e->timestamp);
 }
 delay(200);
}

Conclusion

Yes, Arduino can act as a BlueBus controlling Unit and gets the status of the photocells or sensors connected!

Code

bluebus.ino

/* Project: BlueBus
 * Date   : 2022-10-31
 * Author : Serge
 */

//============================================================================================
// BB module
//============================================================================================

// OC2B, on MEGA2560 : PH6 = D9
// OC2B, on UNO : PD3 = D3
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define OC2B        9  /* Arduino Mega */
#elif defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644__)
#define OC2B        14 /* Sanguino */
#else
#define OC2B        3  /* Arduino Duemilanove, Diecimila, LilyPad, etc */
#endif

// digitalWrite(OC2B, LOW);  => MOSFET blocked => both bus lines pulled up to +Vin => 0V on the bus (active signal)
#define BB_ACTIVE LOW  // MOSFET blocked

// digitalWrite(OC2B, HIGH); => MOSFET conducting => 1 bus line connected to GND => Vin on the Bus (idle)
#define BB_IDLE HIGH   // MOSFET conducting

byte BB_in;                 // port number for reading the bus
volatile byte BB_reco = 0;  // trigger recognition phase
byte BB_addr;               // current addr being scanned

#define BB_EVENTS 32        // max number of events waiting in the queue
typedef struct {
  byte evt;
  unsigned long timestamp;
  byte addr;
  byte status;
} BB_Event;
volatile BB_Event BB_events[BB_EVENTS];  // event queue
BB_Event BB_event;                       // one event
volatile byte BB_event_in = 0;           // index of next event to write to the queue
volatile byte BB_event_out = 0;          // index of next event to read from the queue

// presence of devices on the bus, updated by the recognition phase
byte BB_device[16] = {
  false, true,  false, false, false, false, false, false, // device #1 is always scanned
  false, false, false, false, false, false, false, false,
};

// last status of each device (0xff = no answer)
byte BB_status[16] = {
  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
};

void BB_init(byte in);    // initialize and use port "in" to read the bus status
void BB_on();             // activate the bus, querying devices
void BB_idle();           // power the bus, but don't query any device
void BB_off();            // power off the bus
void BB_recognition();    // initiate the recognition phase
BB_Event* BB_event_pop(); // get next event
void BB_event_push(byte reply);   // add new event to queue (called by ISR)

// called by ISR in case of status change on a device
void BB_event_push(byte reply) {
  byte status;

  if (reply==0 || reply==0xff) {
    status = 0xff;
  } else {
    status = ((reply ^ (reply>>4) ^ BB_addr) & 0b1111);
    if (!BB_device[BB_addr]) {
      BB_device[BB_addr] = true;
      BB_status[BB_addr] = 0xff;
    }
  }
  if (status != BB_status[BB_addr]) {
    volatile BB_Event* e;
    BB_status[BB_addr] = status;
    e = &BB_events[BB_event_in];
    e->evt = true;
    e->timestamp = micros();
    e->addr = BB_addr;
    e->status = status;
    if (BB_event_in>=BB_EVENTS-1) {
      BB_event_in = 0;
    } else {
      BB_event_in++;
    }
    if (BB_event_in == BB_event_out) {
      BB_event_pop();
    }
  }
}

// get next event from the queue
BB_Event* BB_event_pop() {
  volatile BB_Event* out;
  if (BB_event_in == BB_event_out) {
    BB_event.evt = false;
  } else {
    out = &BB_events[BB_event_out];
    BB_event.evt = out->evt;
    BB_event.timestamp = out->timestamp;
    BB_event.addr = out->addr;
    BB_event.status = out->status;
    if (BB_event_out>=BB_EVENTS-1) {
      BB_event_out = 0;
    } else {
      BB_event_out++;
    }
  }
  return &BB_event;
}

void BB_init(byte in) {

  BB_in = in; // port used for reading the bus
  pinMode(OC2B, OUTPUT);
  pinMode(BB_in, INPUT);

  // no power on the bus
  BB_off();

  // CPU clock is 16MHz (MEGA2560)
  // CS2 = 0b101 = clock divided by 128
  // TCNT incremented every 8µs (128/16M = 8µ)
  TCCR2B &= 0xff ^ (_BV(CS22) | _BV(CS21) | _BV(CS20)) ;
  TCCR2B |= _BV(CS22) | _BV(CS20) ;

  // EXCLK = 0, internal clock
  ASSR &= 0xff ^ _BV(EXCLK);

  // AS2 = 0, asynchrone mode
  ASSR &= 0xff ^ _BV(AS2);

  // COM2A = COM2B = 00 : normal port operation
  TCCR2A &= 0xff ^ (_BV(COM2A1) | _BV(COM2A0) | _BV(COM2B1) | _BV(COM2B0));

  // COM2B = 11 : inverted output (LOW at start, HIGH when OCR2B is reached
#define BB_ACTIVATE_SIGNAL() TCCR2A |= _BV(COM2B1) | _BV(COM2B0);

  // COM2B = 00 : normal port operation
#define BB_DEACTIVATE_SIGNAL() TCCR2A &= 0xff ^ (_BV(COM2B1) | _BV(COM2B0));
  BB_DEACTIVATE_SIGNAL();

  // WGM2 = 0b111 => fast PWM mode, TOP=OCRA
  TCCR2A |= (_BV(WGM21) | _BV(WGM20));
  TCCR2B |= _BV(WGM22);

// |------------32ms-------------|  |------------19-------|
// |xxxxxxxx0-------16.9ms-------|  |xxxxxxxx0-------10---|
// |xxxxxxxx0yyyyyyyy0---1.8ms---|  |xxxxxxxx0yyyyyyyy0-1-|
//
// 19-bit frame (8 bits + stop + 8 bits + stop + 1 idle bit) lasting 32ms => 1.68ms/bit => 210 ticks of 8µs
// very little delay measured before the start of the first bit of yyyyyyyy, about 0.3ms (210/6=35 ticks)

#define BB_FRAME 210
  OCR2A = BB_FRAME;

//                 _0.56_                 __70__
// 1  |___1.1ms___|      |     |___140___|      |
//
//            ___1.1ms___              ___140___
// 0  |_0.56_|           |     |__70__|         |
//             ^                        ^
// read      __|                      __|
//
// Bit 0 transmitted as 1/3 LOW + 2/3 HIGH
#define BB_BIT0 (BB_FRAME/3)
// Bit 1 transmitted as 2/3 LOW + 1/3 HIGH
#define BB_BIT1 ((BB_FRAME/3)*2)
// middle of a bit for reading its state (+estimated delay for reply to start)
#define BB_BITR (BB_FRAME/2 + BB_FRAME/6)
  OCR2B = BB_BITR;

}

#define PARITY(x) (((x) + ((x)>>1) + ((x)>>2) + ((x)>>3) + ((x)>>4) + ((x)>>5) + ((x)>>6) + ((x)>>7)) & 0b1)

// called by ISR to get next BB_addr to query, in recognition phase and in norml operation phase
byte BB_sequence() {
  static byte addr = 0;
  static byte reco_count = 0;
  byte byteQ;
  byte flag;

  // normal operation, query each recognized device
  if (BB_reco==0) {
    flag = 1;
    do { 
      addr = (addr+1) & 0b1111;
    }
    while (!BB_device[addr]);
  }

  // start recognition phase, starting with addr #1
  if (BB_reco==1) {
    addr = 1;
    reco_count = 2;
    BB_reco++;
  }
  
  // recognition phase running, test twice each address from 1 to 15
  if (BB_reco>1) {
    flag = 0;
    if (reco_count) {
      reco_count--;
    } else {
      addr++;
      reco_count = 2;
      if (addr>15) {
        BB_reco = 0;
        addr = 0;
      }
    }
  }

  // data to send : aabcccfp
  //    aa : address extension (0 ?)
  //    b  : address modifier (A bridge on the board)
  //    ccc : addr as configured with the jumpers
  //    f : reset flag ? should be 1 for normal operation
  //    p : parity bit
  BB_addr = addr;
  byteQ = (addr<<2) | (flag<<1);
  // set parity bit
  byteQ ^= PARITY(byteQ);
  return byteQ;
}

// Interrupt service routine triggered when TIMER2 reach OCR2B value
ISR(TIMER2_COMPB_vect) {
  static byte bit_count = 0;
  static byte data = 0;

  // ========== send the query ==========
  // activate timer signal
  if (bit_count==0) {
    data = BB_sequence();
    BB_ACTIVATE_SIGNAL();
  }

  // Q 8bits + stop bit (zero)
  if (bit_count<9) {
    OCR2B = (data & _BV(7)) ? BB_BIT1 : BB_BIT0;
    data <<= 1;
  }

  // end of byteQ, deactivate
  if (bit_count==9) {
    BB_DEACTIVATE_SIGNAL();
    OCR2B = BB_BITR;
    data = 0;
  }

  // ========== read the status ==========
  // start to read 8 bits on **next** cycle
  if (bit_count>=10 && bit_count<18) {
    data = (data<<1) + (digitalRead(BB_in) ? 0 : 1);
  }

  // stop bit (should be zero)
  if (bit_count==18) {
    BB_event_push(data);
  }

  // one frame (32ms) = 9+9+1 bits
  if (bit_count<18) {
    bit_count++;
  } else {
    bit_count = 0;
  }
}

void BB_on() {
  
  // Interrupt on Comparator B only: OCIE2B=1, OCIE2A=0, TOIE2=0
  TIMSK2 &= 0xff ^ (_BV(OCIE2A) | _BV(OCIE2B) | _BV(TOIE2));
  TIMSK2 |= _BV(OCIE2B);
  // bus powered
  digitalWrite(OC2B, BB_IDLE);
}

void BB_idle() {
  
  // No interrupt: OCIE2B=0, OCIE2A=0, TOIE2=0
  TIMSK2 &= 0xff ^ (_BV(OCIE2A) | _BV(OCIE2B) | _BV(TOIE2));
  // no query but bus still powered
  digitalWrite(OC2B, BB_IDLE);

}

void BB_off() {
  
  // No interrupt: OCIE2B=0, OCIE2A=0, TOIE2=0
  TIMSK2 &= 0xff ^ (_BV(OCIE2A) | _BV(OCIE2B) | _BV(TOIE2));
  // no power on the bus
  digitalWrite(OC2B, BB_ACTIVE);

}

// initiate recognition phase. It will last about 15*2*32ms = 1 second
void BB_recognition() {
  BB_reco = 1;
}

//============================================================================================

void setup() {                      // setup(): put your setup code here, to run once:

  Serial.begin(2e6);
  Serial.println("\n\n\n\nINIT...");

  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, HIGH);

  BB_init(3);       // read bus on port D3
  BB_on();          // activate bus and communication
  delay(1000);      // wait for the devices to power-up
  BB_recognition(); // initiate a recognition phase

  digitalWrite(LED_BUILTIN, LOW);
  Serial.println("INIT... Completed!");
}

void loop() {                       // loop(): put your main code here, to run repeatedly:

  BB_Event* e;

  while ((e=BB_event_pop())->evt) {
    Serial.print("Device ");
    Serial.print(e->addr, HEX);
    Serial.print(", status ");
    Serial.print(e->status, HEX);
    Serial.print(", timestamp ");
    Serial.println(e->timestamp);
    digitalWrite(LED_BUILTIN, e->status & 0b0010 ? HIGH : LOW);
  }
  delay(200);
}

Credits

serge-45

0 projects • 0 followers

Connecting BlueBus Technology photocells to Arduino

Things used in this project

Hardware components

Software apps and online services

Story

Bus concepts

Hardware part

Software part

Conclusion

Schematics

Schematics of the small hardware piece

Code

bluebus.ino

Credits

serge-45

Comments

Embed the widget on your own site

Connecting BlueBus Technology photocells to Arduino

Connecting BlueBus Technology photocells to Arduino

Things used in this project

Hardware components

Software apps and online services

Story

Bus concepts

Hardware part

Software part

Conclusion

Schematics

Schematics of the small hardware piece

Code

bluebus.ino

Credits

serge-45

Comments

Related channels and tags