Absolute encoder and offsets

Question

I want to implement an RS485 absolute encoder, values 0-2048, on a canvas rapid door. The controller MCU that reads the encoder, which I will programm, may not be powered all the time, but it should be aware of door position on power on. Limit switches will not be installed. The door's movement will never translate to more than 360 degrees revolution on the encoder. It is expected that maximum movement will have a span of around 1600 values.

The installer will set the lowest and highest positions during a setup procedure: Move the door to its lowest position, store the encoder value, move the door to its highest position, store the encoder value, setup completed.

The lowest position can translate to any value on the encoder due to the fact that the canvas is fitted on the roll bar without knowledge of encoder position. So it can have a lowest position at encoder value of 100 or 1000 or 2000. This means that in normal movement, the value will wrap around 2048. Moreover the installer can fit the motor on the left or right side of the roll bar, so the encoder value might increment while the door goes up, or vice versa. To complicate matters even more, the door might move further from the lowest position, due to break heating, gear oil temperature change etc, so if its lowest value was 50, it could wrap over zero and reach a bottom value of 1950.

Considering the above description and scenarios where lowest (Lxxx) and highest (Hxxx) position have corresponding value pairs of: L200-H1400, L800-H300, L10-H1500 and the reverse movement of those L1400-H200, L300-H800, L1500-H10.

What algorithm - conditions would you use to stop the motor at the lowest and highest positions?

Answer 1

Variable list.

• H: door high. (Stored in EEPROM.)
• L: door low. (Stored in EEPROM.)
• Z: zero offset. (Stored in EEPROM.)
• TL: temp low.
• TM: temp mid.
• TH: temp high.
• E: encoder reading.
• P: position (corrected encoder reading).
• D: direction (boolean). 0 = increasing count means up. 1 = decreasing count is up. (Stored in EEPROM.)

---

• Move door to bottom. Press TEACH.
• TL = E.
• Move door to middle. Press TEACH.
• TM = E.
• Move door to top. Press TEACH.
• TH = E.

Figure 1. There are four possible results from the teach procedure. (a) and (b) are clockwise for up. (c) and (d) are anti-clockwise for up. Note that (a) and (c) do not rollover the zero point whereas (b) and (d) do. (Diagram shows 2000 steps per revolution whereas encoder actually has 2048.)

Since you will have to store H and L values you can also store an Z (zero-offset) position.

if (TH > TL) {                          // it's (a) or (d)
  if ( (TM > TL) && (TM < TH) ) {       // it's (a)
    D = 0;                              // increasing count is up
  } else {                              // it's (d)
    D = 1;                              // increasing count is down
  }
  Z = TH - 200;                         // Save to eeprom.
} else {                                // it's (b) or (c)
  if ( (TM > TH) && (TM < TL) ) {       // it's (c)
    D = 1;                              // increasing count is down
  } else {                              // it's (b)
    D = 0;                              // increasing count is up
  }
  Z = TH - 200;                         // save to eeprom.
}

do {
  P = (E + 2048 - Z) MODULO 2048        // bring into range and avoid rollover.
}

The do loop will bring all readings into range 0 to 2047 with a comfortable 200 count safety margin at the top and bottom.

The rest is up to you!