Replacing a Rotary Encoder with a Magnetic Sensor and Potentiometer

/*
  MT6701QT EEPROM Programmer for Arduino Nano (5V)

  Generated with the assistance of Claude AI
 
  This program is free software: you can redistribute it and/or modify it under the 
  terms of the MIT License https://opensource.org/license/mit
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND
  
  This sketch programs the AB Resolution in the MT6701's EEPROM
  The Z pulse width is NOT changed - it retains its current value
  
  Hardware Connections:
  - MT6701 VDD      -> Arduino 5V
  - MT6701 GND      -> Arduino GND
  - MT6701 MODE (M) -> Leave unconnected (enables I2C mode)
  - MT6701 A (SCA)  -> Arduino A4 (SDA)
  - MT6701 B (SCL)  -> Arduino A5 (SCL)
  - MT6701 Z        -> Leave unconnected
  
  IMPORTANT: Arduino Nano provides stable 5V which is perfect for EEPROM programming!

  How it works:
  1. Reads current configuration from MT6701 EEPROM
  2. Programs new AB resolution (while preserving Z pulse width and other settings)
  3. Sends programming command sequence per datasheet
  4. Waits 650ms for EEPROM write cycle to complete
  5. Verifies the programming was successful
  6. Requires power cycle for new settings to take effect

  How to use:
  -----------
  1. Change this line at the top of the code to your desired value:

    #define DESIRED_AB_PPR 64  // Change this to your desired value (1-1024)

  2. Uncomment the section in the setup function to enable programming. If left
      commented it the sketch will display the current resolution without updating.

  2. Upload to Arduino Nano/Uno

  3. The sketch will:
    - Show current AB resolution and Z pulse width
    - Program only the AB resolution
    - Leave Z pulse width unchanged
    - Display verification results

  4. Power cycle the MT6701 after successful programming

  5. Re-comment the section in the setup section and run the sketch again after power
      cycle to verify the new settings took effect.

  The code specifically preserves register 0x32 (which contains the Z_PULSE_WIDTH bits) and only modifies the AB 
  resolution bits in registers 0x30 and 0x31. Your Z index pulse configuration will remain exactly as it was!

  MT6701 Data sheet: https://www.novosns.com/enfiles/MT6701_Rev.1.8.pdf   
*/

#include <Wire.h>

// ========== USER CONFIGURATION ==========
// Set your desired AB resolution here (1-1024 PPR)
#define DESIRED_AB_PPR 64  // Change this value as needed
// ========================================

// MT6701 I2C Address (7-bit)
#define MT6701_ADDR 0x06

// EEPROM Register Addresses
#define REG_ABZ_RES_HIGH  0x30  // ABZ_RES[9:8] in bits [1:0], UVW_RES[3:0] in bits [7:4]
#define REG_ABZ_RES_LOW   0x31  // ABZ_RES[7:0]
#define REG_ZERO_MSB      0x32  // Z_PULSE_WIDTH[2:0] in bits [6:4], ZERO[11:8] in bits [3:0]
#define REG_PROG_KEY      0x09  // Programming key register
#define REG_PROG_CMD      0x0A  // Programming command register

// Angle reading registers
#define REG_ANGLE_HIGH    0x03  // Angle[13:6]
#define REG_ANGLE_LOW     0x04  // Angle[5:0]

void setup() {
  Serial.begin(9600);
  delay(2000);
  
  // Print header information
  Serial.println(F("MT6701 EEPROM Programmer"));
  Serial.println(F("========================"));
  Serial.println(F("Arduino Nano (5V) Version"));
  Serial.print(F("Target AB Resolution: "));
  Serial.print(DESIRED_AB_PPR);
  Serial.println(F(" PPR"));
  
  // Validate that the user has entered a valid PPR value
  // PPR must be between 1 and 1024 per datasheet specifications
  if (DESIRED_AB_PPR < 1 || DESIRED_AB_PPR > 1024) {
    Serial.println(F("\nERROR: DESIRED_AB_PPR must be between 1 and 1024!"));
    Serial.println(F("Please update the value in the code and re-upload."));
    while(1); // Halt
  }
  
  // Initialize I2C (Arduino Nano uses A4=SDA, A5=SCL by default)
  Wire.begin();
  Wire.setClock(100000); // Set I2C clock to 100kHz (standard speed)
  
  // Scan the I2C bus to find all connected devices
  // This helps diagnose connection issues
  Serial.println(F("\nScanning I2C bus..."));
  scanI2C();
  
  // Check specifically for MT6701 at address 0x06
  Serial.println(F("\nChecking MT6701 at address 0x06..."));
  
  // Attempt to communicate with MT6701
  if (!checkConnection()) {
    // If MT6701 not found, print detailed troubleshooting info
    Serial.println(F("\nERROR: MT6701 not detected at address 0x06!"));
    Serial.println(F("\nTroubleshooting checklist:"));
    Serial.println(F("  1. VDD (Pin 13) -> Arduino 5V"));
    Serial.println(F("  2. GND (Pin 16) -> Arduino GND"));
    Serial.println(F("  3. MODE (Pin 14) -> Leave unconnected (CRITICAL!)"));
    Serial.println(F("  4. A/SDA (Pin 6) -> Arduino A4 (with 4.7k pullup to 5V)"));
    Serial.println(F("  5. B/SCL (Pin 7) -> Arduino A5 (with 4.7k pullup to 5V)"));
    Serial.println(F("\nIf device shows at 0x66, check MODE pin connection!"));
    while(1); // Halt
  }
  
  Serial.println(F("MT6701 detected successfully\n"));
  
  // Read and display the current configuration stored in EEPROM
  Serial.println(F("=== Current Configuration ==="));
  displayCurrentConfig();
  
  /*// ****** This section updates the EEPROM ******
  // ****** Uncomment this section to enable programming ******

  // Program the new AB resolution into EEPROM
  Serial.println(F("\n=== Programming AB Resolution ==="));
  Serial.println(F("NOTE: Z pulse width will NOT be changed"));
  
  // Call the main programming function
  if (programABResolution(DESIRED_AB_PPR)) {
    Serial.println(F("\n=== Programming Successful! ==="));
    Serial.println(F("Please power cycle the MT6701 for changes to take effect."));
    Serial.println(F("After power cycle, run this sketch again to verify."));
  } else {
    Serial.println(F("\nERROR: Programming failed!"));
  }
  */
}

void loop() {
  // Nothing to do - programming happens once in setup()
  delay(1000);
}

/**
 * Check if MT6701 is responding on I2C bus
 * Returns true if device acknowledges at address 0x06
 */
bool checkConnection() {
  Wire.beginTransmission(MT6701_ADDR);
  return (Wire.endTransmission() == 0); // 0 = success
}

/**
 * Scan all I2C addresses from 0x01 to 0x7F
 * Prints any devices found to help with troubleshooting
 */
void scanI2C() {
  byte error, address;
  int nDevices = 0;
  
  Serial.println(F("Scanning I2C addresses 0x01-0x7F..."));
  
  // Loop through all possible 7-bit I2C addresses
  for(address = 1; address < 127; address++) {
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
    
    // If device acknowledges (error == 0), it's present
    if (error == 0) {
      Serial.print(F("  Device found at 0x"));
      if (address < 16) Serial.print(F("0")); // Print leading zero for single digit hex
      Serial.println(address, HEX);
      nDevices++;
    }
  }
  
  // Print summary
  if (nDevices == 0) {
    Serial.println(F("  No I2C devices found!"));
    Serial.println(F("  Check wiring and pull-up resistors."));
  } else {
    Serial.print(F("  Total devices found: "));
    Serial.println(nDevices);
  }
}

/**
 * Display current MT6701 configuration from EEPROM
 * Shows AB resolution, Z pulse width, and current angle
 */
void displayCurrentConfig() {
  // Read raw register values for diagnostic purposes
  uint8_t reg30 = readRegister(REG_ABZ_RES_HIGH);
  uint8_t reg31 = readRegister(REG_ABZ_RES_LOW);
  uint16_t abRes = readABResolution();
  uint8_t zWidth = readZPulseWidth();
  
  // Display raw register values in hexadecimal
  Serial.print(F("Raw Register 0x30: 0x"));
  if (reg30 < 16) Serial.print(F("0")); // Print leading zero for single digit
  Serial.println(reg30, HEX);
  
  Serial.print(F("Raw Register 0x31: 0x"));
  if (reg31 < 16) Serial.print(F("0"));
  Serial.println(reg31, HEX);
  
  // Display human-readable AB resolution
  Serial.print(F("Current AB Resolution: "));
  if (abRes == 0) {
    // Handle special case where register reads as 0
    Serial.println(F("1 PPR (register value = 0)"));
  } else {
    Serial.print(abRes);
    Serial.println(F(" PPR"));
  }
  
  // Display Z pulse width configuration
  Serial.print(F("Current Z Pulse Width: "));
  switch(zWidth) {
    case 0: Serial.println(F("1 LSB")); break;
    case 1: Serial.println(F("2 LSB")); break;
    case 2: Serial.println(F("4 LSB")); break;
    case 3: Serial.println(F("8 LSB")); break;
    case 4: Serial.println(F("12 LSB")); break;
    case 5: Serial.println(F("16 LSB")); break;
    case 6: Serial.println(F("180°")); break;
    case 7: Serial.println(F("1 LSB")); break;
    default: Serial.println(F("Unknown")); break;
  }
  
  // Read and display current angle measurement
  float angle = readAngle();
  Serial.print(F("Current Angle: "));
  Serial.print(angle, 2);
  Serial.println(F("°"));
}

/**
 * Read AB Resolution from EEPROM registers
 * Returns the actual PPR value (1-1024)
 * Note: Register stores (PPR - 1), so we add 1 to get actual value
 */
uint16_t readABResolution() {
  uint8_t highByte = readRegister(REG_ABZ_RES_HIGH);
  uint8_t lowByte = readRegister(REG_ABZ_RES_LOW);
  
  // ABZ_RES is 10 bits total:
  // - Bits [1:0] of register 0x30 are the high 2 bits
  // - Register 0x31 is the low 8 bits
  uint16_t resolution = ((highByte & 0x03) << 8) | lowByte;
  
  // Register stores PPR-1, so add 1 for actual PPR
  // Example: Register value 0 = 1 PPR, Register value 999 = 1000 PPR
  return resolution + 1;
}

/**
 * Read Z Pulse Width configuration from EEPROM
 * Returns a 3-bit value (0-7) representing pulse width
 */
uint8_t readZPulseWidth() {
  uint8_t reg32 = readRegister(REG_ZERO_MSB);
  
  // Z_PULSE_WIDTH is stored in bits [6:4] of register 0x32
  // Shift right 4 bits and mask to get 3-bit value
  return (reg32 >> 4) & 0x07;
}

/**
 * Read current angle position from MT6701
 * Returns angle in degrees (0.00 to 360.00)
 */
float readAngle() {
  uint8_t highByte = readRegister(REG_ANGLE_HIGH);
  uint8_t lowByte = readRegister(REG_ANGLE_LOW);
  
  // Combine to 14-bit angle value
  // Register 0x03 contains bits [13:6] (8 bits)
  // Register 0x04 contains bits [5:0] in upper 6 bits [7:2]
  uint16_t rawAngle = (highByte << 6) | (lowByte >> 2);
  
  // Convert 14-bit value (0-16383) to degrees (0-360)
  // Formula: angle = (rawValue / 16384) * 360
  float angle = (rawAngle * 360.0) / 16384.0;
  
  return angle;
}

/**
 * Main programming function - writes new AB resolution to EEPROM
 * 
 * This follows the programming sequence from the MT6701 datasheet:
 * 1. Write configuration registers
 * 2. Write programming key (0xB3)
 * 3. Write programming command (0x05)
 * 4. Wait >600ms for EEPROM write cycle
 * 5. Verify the data
 * 
 * @param ppr - Desired pulses per revolution (1-1024)
 * @return true if programming successful, false otherwise
 */
bool programABResolution(uint16_t ppr) {
  // Validate range
  if (ppr < 1 || ppr > 1024) {
    return false;
  }
  
  // Convert PPR to register value
  // Register stores (PPR - 1), so 1000 PPR = register value 999
  uint16_t regValue = ppr - 1;
  
  // STEP 1: Read existing register values to preserve other settings
  Serial.println(F("\nStep 1: Reading existing registers..."));
  uint8_t reg30 = readRegister(REG_ABZ_RES_HIGH);
  uint8_t reg32 = readRegister(REG_ZERO_MSB);
  
  // Calculate new register values
  // Register 0x30 bit layout: [UVW_RES(7:4)] [reserved(3:2)] [ABZ_RES(1:0)]
  // We preserve UVW_RES bits [7:4] and only modify ABZ_RES bits [1:0]
  uint8_t newReg30 = (reg30 & 0xFC) | ((regValue >> 8) & 0x03);
  uint8_t newReg31 = regValue & 0xFF;
  
  // Display what we're about to write
  Serial.print(F("  Register 0x30 (contains UVW_RES and AB_RES high bits)"));
  Serial.print(F("\n    Original: 0x"));
  Serial.print(reg30, HEX);
  Serial.print(F(" -> New: 0x"));
  Serial.println(newReg30, HEX);
  
  Serial.print(F("  Register 0x31 (AB_RES low byte): 0x"));
  Serial.println(newReg31, HEX);
  
  Serial.print(F("  Register 0x32 (Z_PULSE_WIDTH unchanged): 0x"));
  Serial.println(reg32, HEX);
  
  // STEP 2: Write the new resolution values to registers
  Serial.println(F("\nStep 2: Writing AB resolution to registers..."));
  if (!writeRegister(REG_ABZ_RES_HIGH, newReg30)) {
    Serial.println(F("  Failed to write register 0x30"));
    return false;
  }
  if (!writeRegister(REG_ABZ_RES_LOW, newReg31)) {
    Serial.println(F("  Failed to write register 0x31"));
    return false;
  }
  Serial.println(F("  Registers written successfully"));
  
  // STEP 3: Write programming key
  // This unlocks the EEPROM for writing (security feature
  Serial.println(F("\nStep 3: Writing programming key (0xB3)..."));
  if (!writeRegister(REG_PROG_KEY, 0xB3)) {
    Serial.println(F("  Failed to write programming key"));
    return false;
  }
  Serial.println(F("  Key written"));
  
  // STEP 4: Send programming command
  // This triggers the actual EEPROM write cycle
  Serial.println(F("\nStep 4: Sending programming command (0x05)..."));
  if (!writeRegister(REG_PROG_CMD, 0x05)) {
    Serial.println(F("  Failed to write programming command"));
    return false;
  }
  Serial.println(F("  Command sent"));
  
  // STEP 5: Wait for EEPROM programming to complete
  // Datasheet requires >600ms, we use 650ms for safety margin
  Serial.println(F("\nStep 5: Waiting 650ms for EEPROM programming..."));
  Serial.println(F("  DO NOT disconnect power!"));
  delay(650); // Wait >600ms as per datasheet
  
  // STEP 6: Verify the programming was successful
  Serial.println(F("\nStep 6: Verifying written data..."));
  uint16_t verifyRes = readABResolution();
  uint8_t verifyZ = readZPulseWidth();
  
  Serial.print(F("  Read back AB Resolution: "));
  Serial.print(verifyRes);
  Serial.println(F(" PPR"));
  
  // Verify Z pulse width wasn't changed
  Serial.print(F("  Z Pulse Width still: "));
  switch(verifyZ) {
    case 0: Serial.println(F("1 LSB")); break;
    case 1: Serial.println(F("2 LSB")); break;
    case 2: Serial.println(F("4 LSB")); break;
    case 3: Serial.println(F("8 LSB")); break;
    case 4: Serial.println(F("12 LSB")); break;
    case 5: Serial.println(F("16 LSB")); break;
    case 6: Serial.println(F("180°")); break;
    case 7: Serial.println(F("1 LSB")); break;
  }
  
  // Check if verification matches what we programmed
  if (verifyRes == ppr) {
    Serial.println(F("  Verification successful!"));
    return true;
  } else {
    Serial.println(F("  WARNING: Verification failed!"));
    Serial.println(F("  This is normal - power cycle required for EEPROM changes."));
    return true; // Still return true as programming command was sent successfully
  }
}

/**
 * Read a single register from MT6701 via I2C
 * 
 * @param regAddr - Register address to read (0x00-0xFF)
 * @return Register value (0x00-0xFF), or 0 if read fails
 */
uint8_t readRegister(uint8_t regAddr) {
  // Start I2C transmission to MT6701
  Wire.beginTransmission(MT6701_ADDR);
  Wire.write(regAddr); // Send register address we want to read
  Wire.endTransmission(false); // End transmission but keep bus active (repeated start)
  
  // Request 1 byte from the specified register
  Wire.requestFrom(MT6701_ADDR, 1);
  
  // If data is available, read and return it
  if (Wire.available()) {
    return Wire.read();
  }
  
  // Return 0 if no data received (shouldn't happen if device is connected)
  return 0;
}

/**
 * Write a single register to MT6701 via I2C
 * 
 * @param regAddr - Register address to write (0x00-0xFF)
 * @param data - Data byte to write (0x00-0xFF)
 * @return true if write successful, false if I2C error occurred
 */
bool writeRegister(uint8_t regAddr, uint8_t data) {
  // Start I2C transmission to MT6701
  Wire.beginTransmission(MT6701_ADDR);
  Wire.write(regAddr);
  Wire.write(data);
  
  // End transmission and check for errors
  // Returns 0 if successful, non-zero if error
  return (Wire.endTransmission() == 0);
}