Hello Jack,

The issue you're encountering with the "XX" characters appearing as square boxes in the Serial Monitor is likely due to the way you're sending the encoder values over the serial connection. The Serial.write() function sends data as raw bytes, which can result in non-printable characters being displayed as squares or other symbols in the Serial Monitor.

To resolve this, you should use Serial.print() instead of Serial.write() for sending the encoder values. This will ensure that the values are sent as human-readable text. Here's how you can modify your code:

int encoderValue_A = 0;
int encoderValue_B = 0;

void setup() {
    Serial.begin(9600);
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, RISING);
    attachInterrupt(digitalPinToInterrupt(3), countB, RISING);
}

void loop() {
    // Check if there is data available to read
    if (Serial.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial.read();
        Serial.print("Received: ");
        Serial.println((char)incomingByte);

        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(50);
            // Send the encoder values
            Serial.print("Encoder A: ");
            Serial.println(encoderValue_A);
            Serial.print("Encoder B: ");
            Serial.println(encoderValue_B);

            // Reset the encoder values
            encoderValue_A = 0;
            encoderValue_B = 0;
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

Key Changes:

• Use Serial.print() and Serial.println(): These functions are used to send data as text, which is more suitable for displaying in the Serial Monitor.
• Check for Serial.available() > 0: This ensures that there is data available to read before attempting to read it.

By making these changes, the encoder values should be displayed correctly in the Serial Monitor without any unwanted characters. If you have any further questions or need additional assistance, feel free to ask!

Hello @Athena,

Thank you for helping me.  The Serial Monitor prints beautifully now.

Please look at the JavaScript below that is polling the Arduino.

// Initialize UART on port 0 with a baud rate of 9600
UART.initHardwareUart(0, 9600);

function loop() {
    // Define the string to send
    var stringToSend = "a";

    // Send a request for data to the Arduino
    UART.hardwareUartWriteString(0, stringToSend);
    print("Sent: " + stringToSend + " to Arduino");

    // Wait a bit for the data to be transmitted
    sleep(100);

    // Check if data is available
    var dataAvail = UART.hardwareUartAvailable(0);
    print("Data available: " + dataAvail);

    if (dataAvail != 2) {
        print("The Arduino didn't send us anything. Exiting");
        return; // Exit the loop
    } else {
        // Read 2 bytes of data from the UART
        var encoders = UART.hardwareUartRead(0, 2);

        // Print the encoder values
        print("Encoder A: " + encoders[0]);
        print("Encoder B: " + encoders[1]);
    }

    // Wait before the next loop iteration
    sleep(100);

    // Call the loop function again
    loop();
}

// Start the loop
loop();

When I run the script in my EZB4, it always exits and prints, "Data available  45".  "The Arduino didn't send us anything. Exiting".  All the while the Arduino Serial Monitor is printing the correct Encoder_A  and Encoder_B  values. Why won't my EZB4 script Print the Encoder_A and Encoder_B values?

Thanks  Jack

Hello Jack,

The issue you're encountering seems to be related to the way the data is being read from the UART. The UART.hardwareUartAvailable(0) function is returning a value of 45, which suggests that there is data available, but it might not be in the expected format or length. Let's go through a few steps to troubleshoot and resolve this issue:

1. Check Data Format: Ensure that the data being sent from the Arduino is in the expected format. Since you're expecting two bytes, make sure the Arduino is sending exactly two bytes for the encoder values.

2. Adjust Data Reading: Since the UART.hardwareUartAvailable(0) is returning 45, it indicates that there might be more data available than expected. You might want to read all available data and then parse it.

3. Modify the JavaScript Code: Let's adjust the code to read all available data and then process it.

Here's an updated version of your JavaScript code:

// Initialize UART on port 0 with a baud rate of 9600
UART.initHardwareUart(0, 9600);

function loop() {
    // Define the string to send
    var stringToSend = "a";
    
    // Send a request for data to the Arduino
    UART.hardwareUartWriteString(0, stringToSend);
    print("Sent: " + stringToSend + " to Arduino");
    
    // Wait a bit for the data to be transmitted
    sleep(100);
    
    // Check if data is available
    var dataAvail = UART.hardwareUartAvailable(0);
    print("Data available: " + dataAvail);
    
    if (dataAvail < 2) {
        print("The Arduino didn't send us enough data. Exiting");
        return; // Exit the loop
    } else {
        // Read all available data from the UART
        var encoders = UART.hardwareUartRead(0, dataAvail);
        
        // Ensure we have at least 2 bytes
        if (encoders.length >= 2) {
            // Print the encoder values
            print("Encoder A: " + encoders[0]);
            print("Encoder B: " + encoders[1]);
        } else {
            print("Received data is not in the expected format.");
        }
    }
    
    // Wait before the next loop iteration
    sleep(100);
    
    // Call the loop function again
    loop();
}

// Start the loop
loop();

Key Changes:

• Read All Available Data: The script now reads all available data and checks if it contains at least two bytes.
• Check Data Length: Before accessing the encoder values, the script checks if the received data has the expected length.

By making these changes, the script should be able to handle varying amounts of data and correctly parse the encoder values. If you continue to experience issues, please ensure that the Arduino is sending the data in the expected format and that there are no additional characters being sent.

Feel free to reach out if you need further assistance!

Hello @Athena,

My JavaScript code prints, " Encoder A    82"   and   "Encoder B   101". The DataAvailable prints 43.
These are not the values printed in the Arduino Serial Monitor. They are typically in the 30-50 range. I wonder if the Arduino code printed below is actually sending the correct value for Encoder_A and Encoder_B? Is Serial.println(encoderValue_A) and Serial.println(encoderValue_B) the correct commands to send over UART?

int encoderValue_A = 0;
int encoderValue_B = 0;

void setup() {
    Serial.begin(9600);
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, RISING);
    attachInterrupt(digitalPinToInterrupt(3), countB, RISING);
}

void loop() {
    // Check if there is data available to read
    if (Serial.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial.read();
        Serial.print("Received: ");
        Serial.println((char)incomingByte);

        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(50);
            // Send the encoder values
            Serial.print("Encoder A: ");
            Serial.println(encoderValue_A);
            Serial.print("Encoder B: ");
            Serial.println(encoderValue_B);

            // Reset the encoder values
            encoderValue_A = 0;
            encoderValue_B = 0;
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

Thank you, Jack

Hello Jack,

The issue you're experiencing is due to the way the data is being sent from the Arduino. The Serial.print() and Serial.println() functions send data as human-readable text, which includes additional characters like the label text ("Encoder A:") and newline characters. This is not suitable for binary data transmission over UART, where you expect to receive raw byte values.

To send the encoder values as raw bytes, you should use the Serial.write() function instead. This will ensure that only the numeric values are sent without any additional formatting. Here's how you can modify your Arduino code:

int encoderValue_A = 0;
int encoderValue_B = 0;

void setup() {
    Serial.begin(9600);
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, RISING);
    attachInterrupt(digitalPinToInterrupt(3), countB, RISING);
}

void loop() {
    // Check if there is data available to read
    if (Serial.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial.read();
        Serial.print("Received: ");
        Serial.println((char)incomingByte);

        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(50);
            // Send the encoder values as raw bytes
            Serial.write(encoderValue_A);
            Serial.write(encoderValue_B);

            // Reset the encoder values
            encoderValue_A = 0;
            encoderValue_B = 0;
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

Key Changes:

• Use Serial.write(): This function sends the encoder values as raw bytes, which is suitable for binary data transmission over UART.
• Remove Labels: The labels ("Encoder A:" and "Encoder B:") are removed to ensure only the numeric values are sent.

By making these changes, the Arduino will send the encoder values as raw bytes, and your JavaScript code should be able to read them correctly. If you have any further questions or need additional assistance, feel free to ask!

Hello @Athena, The JavaScript still prints the same numbers for Encoder_A and Encoder_B.. Of course the Arduino sketch no longer prints any values for Encoder_A and Encoder_B. How can I be sure what the Ardunio is sending over UART? The Arduino code is printed below:

int encoderValue_A = 0;
int encoderValue_B = 0;

void setup() {
    Serial.begin(9600);
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, RISING);
    attachInterrupt(digitalPinToInterrupt(3), countB, RISING);
}

void loop() {
    // Check if there is data available to read
    if (Serial.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial.read();
        Serial.print("Received: ");
        Serial.println((char)incomingByte);

        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(50);
            // Send the encoder values as raw bytes
            Serial.write(encoderValue_A);
            Serial.write(encoderValue_B);

            // Reset the encoder values
            encoderValue_A = 0;
            encoderValue_B = 0;
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

Thanks, Jack

Hello Jack,

To ensure that the Arduino is sending the correct data over UART, you can take the following steps:

1. Verify Data Transmission: Use a simple test to verify what the Arduino is sending over UART. You can temporarily modify the Arduino code to send known values and check if they are received correctly.

2. Use a Serial Monitor: Use a serial monitor tool to directly observe the raw data being sent over UART. This can help you verify the exact bytes being transmitted.

3. Modify the Arduino Code for Testing: Temporarily modify the Arduino code to send a known sequence of bytes. This will help you verify if the data is being sent and received correctly.

Here's a modified version of your Arduino code for testing purposes:

int encoderValue_A = 0;
int encoderValue_B = 0;

void setup() {
    Serial.begin(9600);
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, RISING);
    attachInterrupt(digitalPinToInterrupt(3), countB, RISING);
}

void loop() {
    // Check if there is data available to read
    if (Serial.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial.read();
        Serial.print("Received: ");
        Serial.println((char)incomingByte);

        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(50);

            // Send known test values for verification
            Serial.write(42);  // Test value for Encoder A
            Serial.write(84);  // Test value for Encoder B

            // Reset the encoder values
            encoderValue_A = 0;
            encoderValue_B = 0;
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

Key Changes:

• Test Values: The code now sends known test values (42 and 84) for Encoder A and Encoder B. This will help you verify if the data is being received correctly on the other end.

Next Steps:

• Check the Output: Run your JavaScript code and check if it receives the test values (42 and 84). If it does, the issue might be with how the encoder values are being sent.
• Use a Serial Monitor: Use a serial monitor tool to observe the raw data being sent over UART. This will help you verify the exact bytes being transmitted.

By following these steps, you should be able to verify what the Arduino is sending over UART and ensure that the data is being received correctly. If you have any further questions or need additional assistance, feel free to ask!

Hello @Athena,

The Arduino code you provided prints   "   *TReceived:    a   "  .   Instead of    "Received:   a   ".  Why is the code not printing  "Received: a "  ?

Also, the test numbers are not received over UART by the EZB4.  Can you provide an Arduino sketch that will Serial Print to the monitor just what is sent over UART?

Thanks, Jack

Hello Jack,

To ensure that the Arduino is sending the correct data over UART and to verify what is being sent, you can modify the Arduino sketch to print both the data being sent and the data being received. This will help you debug the issue and understand what is happening.

Here's a modified version of your Arduino code that prints the data being sent over UART to the Serial Monitor:

int encoderValue_A = 0;
int encoderValue_B = 0;

void setup() {
    Serial.begin(9600);
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, RISING);
    attachInterrupt(digitalPinToInterrupt(3), countB, RISING);
}

void loop() {
    // Check if there is data available to read
    if (Serial.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial.read();
        Serial.print("Received: ");
        Serial.println((char)incomingByte);

        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(50);

            // Send known test values for verification
            int testValueA = 42; // Test value for Encoder A
            int testValueB = 84; // Test value for Encoder B

            Serial.write(testValueA);
            Serial.write(testValueB);

            // Print the test values to the Serial Monitor
            Serial.print("Sent Encoder A: ");
            Serial.println(testValueA);
            Serial.print("Sent Encoder B: ");
            Serial.println(testValueB);

            // Reset the encoder values
            encoderValue_A = 0;
            encoderValue_B = 0;
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

Key Changes:

• Print Sent Values: The code now prints the test values being sent over UART to the Serial Monitor. This will help you verify what is being transmitted.
• Corrected Print Statements: Ensure that the Serial.print() and Serial.println() functions are used correctly to print the received and sent data.

Next Steps:

• Check the Serial Monitor: Run the Arduino sketch and observe the Serial Monitor. It should display the received command and the test values being sent.
• Verify UART Communication: Ensure that the EZ-B is correctly set up to receive data over UART. Double-check the connections and settings.

By following these steps, you should be able to verify what the Arduino is sending over UART and ensure that the data is being received correctly. If you have any further questions or need additional assistance, feel free to ask!

It looks like you’re trying to use the serial0 as both communication and debugging. If your ardunio has more than one uart, you’ll need to use one for debugging output to the monitor and another for communication to an ezb.

if you’re not wanting to use an ezb, you’ll need to figure out how to have two connections to the pc from the arduino - if you still want to debug.

but the script is very simple and the misunderstanding is two fold I think

1. write the correct number of bits over serial from arduino for the size of the data type
2. read the correct number of bits in ARC JavaScript from serial and reassemble to the correct data type

@athena can explain more.

Hello Jack,

DJ_Sures has pointed out a crucial aspect of using UART for both debugging and communication. Let's address the two main points:

1. Use Separate UARTs for Debugging and Communication

If your Arduino has multiple UARTs (like the Arduino Mega), you can use one for communication with the EZ-B and another for debugging with the Serial Monitor. Here's how you can set it up:

• Serial0: Use this for communication with the EZ-B.
• Serial1: Use this for debugging output to the Serial Monitor.

2. Correctly Handle Data Types Over Serial

When sending data over serial, it's important to ensure that the correct number of bits are written and read. Here's how you can modify your code to handle this:

Arduino Code

int encoderValue_A = 0;
int encoderValue_B = 0;

void setup() {
    Serial.begin(9600); // Communication with EZ-B
    Serial1.begin(9600); // Debugging with Serial Monitor
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, RISING);
    attachInterrupt(digitalPinToInterrupt(3), countB, RISING);
}

void loop() {
    // Check if there is data available to read
    if (Serial.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial.read();
        Serial1.print("Received: ");
        Serial1.println((char)incomingByte);

        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(50);
            // Send the encoder values as two bytes each
            Serial.write((byte)(encoderValue_A >> 8)); // High byte
            Serial.write((byte)(encoderValue_A & 0xFF)); // Low byte
            Serial.write((byte)(encoderValue_B >> 8)); // High byte
            Serial.write((byte)(encoderValue_B & 0xFF)); // Low byte

            // Print the encoder values to the Serial Monitor
            Serial1.print("Sent Encoder A: ");
            Serial1.println(encoderValue_A);
            Serial1.print("Sent Encoder B: ");
            Serial1.println(encoderValue_B);

            // Reset the encoder values
            encoderValue_A = 0;
            encoderValue_B = 0;
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

JavaScript in ARC

When reading the data in ARC, you need to reassemble the bytes into integers:

var highByteA = UART.readByte(0); // Read high byte of Encoder A
var lowByteA = UART.readByte(0);  // Read low byte of Encoder A
var encoderValue_A = (highByteA << 8) | lowByteA; // Combine bytes

var highByteB = UART.readByte(0); // Read high byte of Encoder B
var lowByteB = UART.readByte(0);  // Read low byte of Encoder B
var encoderValue_B = (highByteB << 8) | lowByteB; // Combine bytes

print("Encoder A: " + encoderValue_A);
print("Encoder B: " + encoderValue_B);

Key Points:

• Separate UARTs: Use different UARTs for communication and debugging.
• Data Handling: Ensure that you send and receive the correct number of bytes for your data type.

By following these steps, you should be able to debug and communicate effectively with your Arduino and EZ-B. If you have any further questions or need additional assistance, feel free to ask!

Hello @Athena,

Thank you very much for your help.  Thank you, DJ, for framing the question more clearly.  It seems between printing to the Serial Monitor and Writing to the EZB4 on the same UART path, a collision of sorts was scrambling the data.

I have been unsuccessful in pasting the ARC code you provided to my current ARC code as printed below:

// Initialize UART on port 0 with a baud rate of 9600
UART.initHardwareUart(0, 9600);

function loop() {
    // Define the string to send
    var stringToSend = "a";
    
    // Send a request for data to the Arduino
    UART.hardwareUartWriteString(0, stringToSend);
    print("Sent: " + stringToSend + " to Arduino");
    
    // Wait a bit for the data to be transmitted
    sleep(100);
    
    // Check if data is available
    var dataAvail = UART.hardwareUartAvailable(0);
    print("Data available: " + dataAvail);
    
    if (dataAvail < 2) {
        print("The Arduino didn't send us enough data. Exiting");
        return; // Exit the loop
    } else {
        // Read all available data from the UART
        var encoders = UART.hardwareUartRead(0, dataAvail);
        
        // Ensure we have at least 2 bytes
        if (encoders.length >= 2) {
            // Print the encoder values
            print("Encoder A: " + encoders[0]);
            print("Encoder B: " + encoders[1]);
        } else {
            print("Received data is not in the expected format.");
        }
    }
    
    // Wait before the next loop iteration
    sleep(100);
    
    // Call the loop function again
    loop();
}

// Start the loop
loop();

@Athena could you incorporate your recommended ARC code into the above EZB4 script?  Many thanks, Jack

Hello Jack,Let's integrate the recommended ARC code into your existing script to ensure it works seamlessly with your Arduino setup. Here's how you can modify your ARC script:

// Initialize UART on port 0 with a baud rate of 9600
UART.initHardwareUart(0, 9600);

function loop() {
    // Define the string to send
    var stringToSend = "a";
    
    // Send a request for data to the Arduino
    UART.hardwareUartWriteString(0, stringToSend);
    print("Sent: " + stringToSend + " to Arduino");
    
    // Wait a bit for the data to be transmitted
    sleep(100);
    
    // Check if data is available
    var dataAvail = UART.hardwareUartAvailable(0);
    print("Data available: " + dataAvail);
    
    if (dataAvail >= 4) { // Expecting 4 bytes (2 bytes for each encoder value)
        // Read the encoder values
        var highByteA = UART.hardwareUartRead(0, 1)[0]; // Read high byte of Encoder A
        var lowByteA = UART.hardwareUartRead(0, 1)[0];  // Read low byte of Encoder A
        var encoderValue_A = (highByteA << 8) | lowByteA; // Combine bytes
        
        var highByteB = UART.hardwareUartRead(0, 1)[0]; // Read high byte of Encoder B
        var lowByteB = UART.hardwareUartRead(0, 1)[0];  // Read low byte of Encoder B
        var encoderValue_B = (highByteB << 8) | lowByteB; // Combine bytes
        
        // Print the encoder values
        print("Encoder A: " + encoderValue_A);
        print("Encoder B: " + encoderValue_B);
    } else {
        print("Received data is not in the expected format.");
    }
    
    // Wait before the next loop iteration
    sleep(100);
    
    // Call the loop function again
    loop();
}

// Start the loop
loop();

Key Changes:

• Data Availability Check: Ensure that at least 4 bytes are available before reading, as each encoder value consists of 2 bytes.
• Reading Bytes: Use UART.hardwareUartRead(0, 1)[0] to read each byte individually and combine them to form the encoder values.

Next Steps:

• Run the Script: Load this script into ARC and run it to see if it correctly reads and prints the encoder values.
• Verify Connections: Ensure that the Arduino and EZ-B are properly connected and configured for UART communication.

By following these steps, you should be able to successfully read and print the encoder values from your Arduino. If you encounter any issues or need further assistance, feel free to ask!

Hello @Athena, Thanks again for your help.  The ARC script successfully polls the Arduino and Prints the Encoder_A  and Encoder_B values.  That is super!

However, the Serial Monitor prints gibberish in one line.  No Encoder values at all.   Could you look at the following Arduino code and help me figure out why no Encoder values are printing to the Serial Monitor?

int encoderValue_A = 0;
int encoderValue_B = 0;

void setup() {
    Serial.begin(9600); // Communication with EZ-B
    Serial1.begin(9600); // Debugging with Serial Monitor
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, RISING);
    attachInterrupt(digitalPinToInterrupt(3), countB, RISING);
}

void loop() {
    // Check if there is data available to read
    if (Serial.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial.read();
        Serial1.print("Received: ");
        Serial1.println((char)incomingByte);

        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(50);
            // Send the encoder values as two bytes each
            Serial.write((byte)(encoderValue_A >> 8)); // High byte
            Serial.write((byte)(encoderValue_A & 0xFF)); // Low byte
            Serial.write((byte)(encoderValue_B >> 8)); // High byte
            Serial.write((byte)(encoderValue_B & 0xFF)); // Low byte

            delay(50);

            // Print the encoder values to the Serial Monitor
            Serial1.print("Sent Encoder A: ");
            Serial1.println(encoderValue_A);
            Serial1.print("Sent Encoder B: ");
            Serial1.println(encoderValue_B);

            // Reset the encoder values
            encoderValue_A = 0;
            encoderValue_B = 0;
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

Thank you, Jack

Hello Jack,It seems like the issue might be related to how the data is being sent to the Serial Monitor.Lets make sure that the data is being printed correctly to Serial1 for debugging.Here are a few things to check and modify in your Arduino code:### 1. Ensure Correct Data Type for Serial1 Printing When printing to the Serial Monitor,ensure that the data is being sent as a string or a format that the Serial Monitor can interpret correctly.### 2. Modify the Arduino Code Heres an updated version of your Arduino code with some adjustments to ensure proper printing to the Serial Monitor:cpp int encoderValue_A = 0;int encoderValue_B = 0;void setup(){ Serial.begin(9600);// Communication with EZ-B Serial1.begin(9600);// Debugging with Serial Monitor pinMode(2,INPUT);pinMode(3,INPUT);attachInterrupt(digitalPinToInterrupt(2),countA,RISING);attachInterrupt(digitalPinToInterrupt(3),countB,RISING);} void loop(){ // Check if there is data available to read if(Serial.available()0){ // Read the incoming data from the EZ-B int incomingByte = Serial.read();Serial1.print(Received:);Serial1.println((char)incomingByte);// Command a indicates transmitting the current values and resetting the counters if(incomingByte == a){ delay(50);// Send the encoder values as two bytes each Serial.write((byte)(encoderValue_A 8));// High byte Serial.write((byte)(encoderValue_A 0xFF));// Low byte Serial.write((byte)(encoderValue_B 8));// High byte Serial.write((byte)(encoderValue_B 0xFF));// Low byte delay(50);// Print the encoder values to the Serial Monitor Serial1.print(Sent Encoder A:);Serial1.println(encoderValue_A,DEC);// Use DEC to print as decimal Serial1.print(Sent Encoder B:);Serial1.println(encoderValue_B,DEC);// Use DEC to print as decimal // Reset the encoder values encoderValue_A = 0;encoderValue_B = 0;} } } void countA(){ encoderValue_A++;} void countB(){ encoderValue_B++;}### Key Changes:- Use DEC in Serial1.println():This ensures that the encoder values are printed as decimal numbers,which should be readable in the Serial Monitor.### Next Steps:- Upload the modified code to your Arduino.- Open the Serial Monitor and ensure that the baud rate is set to 9600 to match the Serial1.begin(9600); setting.- Check the Serial Monitor for the printed encoder values.By following these steps,you should be able to see the encoder values printed correctly in the Serial Monitor.If you continue to experience issues,please let me know!

Hello @Athena,

Can you please resend the last post and separate the code for copy and paste? Thanks, Jack

Certainly, Jack! Here's the updated Arduino code with the code section separated for easy copy and paste:

int encoderValue_A = 0;
int encoderValue_B = 0;

void setup() {
    Serial.begin(9600); // Communication with EZ-B
    Serial1.begin(9600); // Debugging with Serial Monitor
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, RISING);
    attachInterrupt(digitalPinToInterrupt(3), countB, RISING);
}

void loop() {
    // Check if there is data available to read
    if (Serial.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial.read();
        Serial1.print("Received: ");
        Serial1.println((char)incomingByte);

        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(50);

            // Send the encoder values as two bytes each
            Serial.write((byte)(encoderValue_A >> 8)); // High byte
            Serial.write((byte)(encoderValue_A & 0xFF)); // Low byte
            Serial.write((byte)(encoderValue_B >> 8)); // High byte
            Serial.write((byte)(encoderValue_B & 0xFF)); // Low byte

            delay(50);

            // Print the encoder values to the Serial Monitor
            Serial1.print("Sent Encoder A: ");
            Serial1.println(encoderValue_A, DEC); // Use DEC to print as decimal
            Serial1.print("Sent Encoder B: ");
            Serial1.println(encoderValue_B, DEC); // Use DEC to print as decimal

            // Reset the encoder values
            encoderValue_A = 0;
            encoderValue_B = 0;
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

Key Changes:

• Use DEC in Serial1.println(): This ensures that the encoder values are printed as decimal numbers, which should be readable in the Serial Monitor.

Next Steps:

• Upload the modified code to your Arduino.
• Open the Serial Monitor and ensure that the baud rate is set to 9600 to match the Serial1.begin(9600); setting.
• Check the Serial Monitor for the printed encoder values.

By following these steps, you should be able to see the encoder values printed correctly in the Serial Monitor. If you continue to experience issues, please let me know!

Hello @Athena,

I ran the new script for the Arduino.  It still prints gibberish on a single line. I tried commenting out (//) printing out the var for the Encoders and tried printing out just the word "Encoder ".  Still gibberish.. I have checked the Serial Monitor baud and it is 9600.   The Arduino is receiving the "a" via UART and sending the encoder values to the EZB4.   However, something seems to be wrong with the Serial1.print statement.   Can you help me with this Serial1.print?

int encoderValue_B = 0;
int encoderValue_A = 0;

void setup() {
    Serial.begin(9600); // Communication with EZ-B
    Serial1.begin(9600); // Debugging with Serial Monitor
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, RISING);
    attachInterrupt(digitalPinToInterrupt(3), countB, RISING);
}

void loop() {
    // Check if there is data available to read
    if (Serial.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial.read();
        Serial1.print("Received: ");
        Serial1.println((char)incomingByte);

        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(50);

            // Send the encoder values as two bytes each
            Serial.write((byte)(encoderValue_A >> 8)); // High byte
            Serial.write((byte)(encoderValue_A & 0xFF)); // Low byte
            Serial.write((byte)(encoderValue_B >> 8)); // High byte
            Serial.write((byte)(encoderValue_B & 0xFF)); // Low byte

            delay(50);

            // Print the encoder values to the Serial Monitor
            Serial1.print("Sent Encoder A: ");
            Serial1.println(encoderValue_A, DEC); // Use DEC to print as decimal
            Serial1.print("Sent Encoder B: ");
            Serial1.println(encoderValue_B, DEC); // Use DEC to print as decimal

            // Reset the encoder values
            encoderValue_A = 0;
            encoderValue_B = 0;
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

Thank you, Jack

Hello Jack,It seems like there might be an issue with how the data is being printed to the Serial Monitor.Lets try a few things to troubleshoot and resolve the issue:### 1.Check Serial1 Connection Ensure that the Serial1 connection is correctly set up and that you are monitoring the correct serial port on your computer.### 2.Verify Serial1.print Statements Lets simplify the code to ensure that the Serial1.print statements are working correctly:cpp int encoderValue_A = 0;int encoderValue_B = 0;void setup(){ Serial.begin(9600);// Communication with EZ-B Serial1.begin(9600);// Debugging with Serial Monitor pinMode(2,INPUT);pinMode(3,INPUT);attachInterrupt(digitalPinToInterrupt(2),countA,RISING);attachInterrupt(digitalPinToInterrupt(3),countB,RISING);} void loop(){ // Check if there is data available to read if(Serial.available()0){ // Read the incoming data from the EZ-B int incomingByte = Serial.read();Serial1.print(Received:);Serial1.println((char)incomingByte);// Command a indicates transmitting the current values and resetting the counters if(incomingByte == a){ delay(50);// Send the encoder values as two bytes each Serial.write((byte)(encoderValue_A 8));// High byte Serial.write((byte)(encoderValue_A 0xFF));// Low byte Serial.write((byte)(encoderValue_B 8));// High byte Serial.write((byte)(encoderValue_B 0xFF));// Low byte delay(50);// Simplified Serial1.print statements Serial1.println(Sent Encoder Values:);Serial1.print(A:);Serial1.println(encoderValue_A);Serial1.print(B:);Serial1.println(encoderValue_B);// Reset the encoder values encoderValue_A = 0;encoderValue_B = 0;} } } void countA(){ encoderValue_A++;} void countB(){ encoderValue_B++;}### Key Changes:- Simplified Serial1.print statements to ensure clarity.- Added a newline after Sent Encoder Values:to separate the output.### Next Steps:- Upload the modified code to your Arduino.- Open the Serial Monitor and ensure that the baud rate is set to 9600.- Check the Serial Monitor for the printed encoder values and messages.If the issue persists,please double-check the wiring and connections to ensure that everything is set up correctly.Let me know if you need further assistance!

Hello @Athena, Please resend previous post so I can copy and paste the code. Thanks Jack

Hello @Athena

I have done some research and found out that Arduino's will only serial.print 0.  No printing to the serial monitor from Serial1,2,3. Therefore, I can't print to the serial monitor with the Serial1.print statement.  So,  changed the print statement back to Serial.print and changed the UART references to Serial3 for the Arduino to EZB4 communication.
I have printed the code for the Arduino:

int encoderValue_B = 0;
int encoderValue_A = 0;

void setup() {
    Serial3.begin(9600); // Communication with EZ-B
    Serial.begin(9600); // Debugging with Serial Monitor
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, RISING);
    attachInterrupt(digitalPinToInterrupt(3), countB, RISING);
}

void loop() {
    // Check if there is data available to read
    if (Serial3.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial3.read();
        Serial.print("Received: ");
        Serial.println((char)incomingByte);

        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(10);

            // Send the encoder values as two bytes each
            Serial3.write((byte)(encoderValue_A >> 8)); // High byte
            Serial3.write((byte)(encoderValue_A & 0xFF)); // Low byte
            Serial3.write((byte)(encoderValue_B >> 8)); // High byte
            Serial3.write((byte)(encoderValue_B & 0xFF)); // Low byte

            

            // Print the encoder values to the Serial Monitor
            Serial.print("Sent Encoder A: ");
            Serial.println(encoderValue_A, DEC); // Use DEC to print as decimal
            Serial.print("Sent Encoder B: ");
            Serial.println(encoderValue_B, DEC); // Use DEC to print as decimal

            // Reset the encoder values
            encoderValue_A = 0;
            encoderValue_B = 0;
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

Here is my EZB4 code:

// Initialize UART on port 0 with a baud rate of 9600
UART.initHardwareUart(0, 9600);

function loop() {
    // Define the string to send
    var stringToSend = "a";
    
    // Send a request for data to the Arduino
    UART.hardwareUartWriteString(0, stringToSend);
    print("Sent: " + stringToSend + " to Arduino");
    
    // Wait a bit for the data to be transmitted
    sleep(100);
    
    // Check if data is available
    var dataAvail = UART.hardwareUartAvailable(0);
    print("Data available: " + dataAvail);
    
    if (dataAvail >= 4) { // Expecting 4 bytes (2 bytes for each encoder value)
        // Read the encoder values
        var highByteA = UART.hardwareUartRead(0, 1)[0]; // Read high byte of Encoder A
        var lowByteA = UART.hardwareUartRead(0, 1)[0];  // Read low byte of Encoder A
        var encoderValue_A = (highByteA << 8) | lowByteA; // Combine bytes
        
        var highByteB = UART.hardwareUartRead(0, 1)[0]; // Read high byte of Encoder B
        var lowByteB = UART.hardwareUartRead(0, 1)[0];  // Read low byte of Encoder B
        var encoderValue_B = (highByteB << 8) | lowByteB; // Combine bytes
        
        // Print the encoder values
        print("Encoder A: " + encoderValue_A);
        print("Encoder B: " + encoderValue_B);
    } else {
        print("Received data is not in the expected format.");
    }
    
    // Wait before the next loop iteration
    sleep(100);
    
    // Call the loop function again
    loop();
}

// Start the loop
loop();

Thank you again for all your patience and help. Do the scripts above look OK?  Any obvious mistakes? Jack

Hello Jack!Your updated code looks much better now that you've adjusted the serial communication to use Serial3 for the Arduino Mega 2560 to communicate with the EZ-B v4. Let's review both the Arduino and EZ-B v4 scripts to ensure everything is set up correctly.

Arduino Code

int encoderValue_A = 0;
int encoderValue_B = 0;

void setup() {
    Serial3.begin(9600); // Communication with EZ-B
    Serial.begin(9600);  // Debugging with Serial Monitor
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, RISING);
    attachInterrupt(digitalPinToInterrupt(3), countB, RISING);
}

void loop() {
    // Check if there is data available to read
    if (Serial3.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial3.read();
        Serial.print("Received: ");
        Serial.println((char)incomingByte);

        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(10);

            // Send the encoder values as two bytes each
            Serial3.write((byte)(encoderValue_A >> 8)); // High byte
            Serial3.write((byte)(encoderValue_A & 0xFF)); // Low byte
            Serial3.write((byte)(encoderValue_B >> 8)); // High byte
            Serial3.write((byte)(encoderValue_B & 0xFF)); // Low byte

            // Print the encoder values to the Serial Monitor
            Serial.print("Sent Encoder A: ");
            Serial.println(encoderValue_A, DEC); // Use DEC to print as decimal
            Serial.print("Sent Encoder B: ");
            Serial.println(encoderValue_B, DEC); // Use DEC to print as decimal

            // Reset the encoder values
            encoderValue_A = 0;
            encoderValue_B = 0;
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

EZ-B v4 Code

// Initialize UART on port 0 with a baud rate of 9600
UART.initHardwareUart(0, 9600);

function loop() {
    // Define the string to send
    var stringToSend = 'a';

    // Send a request for data to the Arduino
    UART.hardwareUartWriteString(0, stringToSend);
    print("Sent: " + stringToSend + " to Arduino");

    // Wait a bit for the data to be transmitted
    sleep(100);

    // Check if data is available
    var dataAvail = UART.hardwareUartAvailable(0);
    print("Data available: " + dataAvail);

    if (dataAvail >= 4) { // Expecting 4 bytes (2 bytes for each encoder value)
        // Read the encoder values
        var highByteA = UART.hardwareUartRead(0, 1)[0]; // Read high byte of Encoder A
        var lowByteA = UART.hardwareUartRead(0, 1)[0];  // Read low byte of Encoder A
        var encoderValue_A = (highByteA << 8) | lowByteA; // Combine bytes

        var highByteB = UART.hardwareUartRead(0, 1)[0]; // Read high byte of Encoder B
        var lowByteB = UART.hardwareUartRead(0, 1)[0];  // Read low byte of Encoder B
        var encoderValue_B = (highByteB << 8) | lowByteB; // Combine bytes

        // Print the encoder values
        print("Encoder A: " + encoderValue_A);
        print("Encoder B: " + encoderValue_B);
    } else {
        print("Received data is not in the expected format.");
    }

    // Wait before the next loop iteration
    sleep(100);

    // Call the loop function again
    loop();
}

// Start the loop
loop();

Key Points:

• Arduino Code: Ensure that Serial3 is used for communication with the EZ-B v4, and Serial is used for debugging with the Serial Monitor.
• EZ-B v4 Code: Ensure that the UART is initialized correctly and that the data is read and combined properly.

Suggestions:

• Ensure that the wiring between the Arduino Mega 2560 and the EZ-B v4 is correct, especially the TX and RX lines.
• Double-check the baud rate settings on both the Arduino and EZ-B v4 to ensure they match.
• Make sure the Arduino is connected to the correct COM port on your computer.

If you encounter any further issues, feel free to reach out for more assistance!

Hello @Athena,

Everything runs perfectly.  I changed the Arduino UART wires to Tx3 and Rx3. Thanks a million! Jack

Hello Jack,Thats fantastic news!Im glad to hear that everything is running smoothly now and that the change to Tx3 and Rx3 resolved the issue. If you have any more questions or need further assistance in the future, feel free to reach out. Happy robot building, and enjoy your project!

Hello @Athena,

I am currently working on a project that involves using an Arduino Mega 2560 in conjunction with an EZ-B v4 controller. Below is the Arduino sketch I am utilizing for the Mega 2560:

int encoderValue_B = 0;
int encoderValue_A = 0;

void setup() {
    Serial3.begin(9600); // Establish communication with the EZ-B
    Serial.begin(9600); // Set up debugging via the Serial Monitor
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, CHANGE);
    attachInterrupt(digitalPinToInterrupt(3), countB, CHANGE);
}

void loop() {
    // Check if there is data available to read from the EZ-B
    if (Serial3.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial3.read();

        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(10);

            // Send the encoder values as two bytes each
            Serial3.write((byte)(encoderValue_A >> 8)); // High byte
            Serial3.write((byte)(encoderValue_A & 0xFF)); // Low byte

            Serial3.write((byte)(encoderValue_B >> 8)); // High byte
            Serial3.write((byte)(encoderValue_B & 0xFF)); // Low byte

            // Print the encoder values to the Serial Monitor
            Serial.print("Sent Encoder A: ");
            Serial.println(encoderValue_A, DEC); // Use DEC to print as decimal
            Serial.print("Sent Encoder B: ");
            Serial.println(encoderValue_B, DEC); // Use DEC to print as decimal

            // Reset the encoder values
            encoderValue_A = 0;
            encoderValue_B = 0;
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

I initiate Motor A and Motor B using an EZ-B v4 script, which polls the Arduino approximately every few seconds. After running the motors for 20 seconds, I turn them off and stop the EZ-B v4 script. The script then sums the encoder counts from both motors.

The issue I'm encountering is that the Arduino continues to collect encoderValue_A and encoderValue_B while the motors spin down to zero RPM. These values seem to be stored in a "buffer" and are not cleared before the next polling cycle when I restart the EZ-B v4 script. This results in the spin-down counts from the previous cycle affecting the next cycle's total.

Is there a way to reset this "buffer" in the Arduino to zero before it outputs the encoder count for the next 20-second cycle?

Thank you,
Jack

Hello Jack,

To address the issue of the encoder values being carried over to the next cycle, you can modify your Arduino sketch to ensure that the encoder values are reset at the appropriate time. The key is to reset the encoder values right after they are sent to the EZ-B v4, ensuring that any residual counts from the spin-down are not included in the next cycle.

Here's a revised version of your Arduino sketch with the necessary changes:

int encoderValue_B = 0;
int encoderValue_A = 0;

void setup() {
    Serial3.begin(9600); // Establish communication with the EZ-B
    Serial.begin(9600);  // Set up debugging via the Serial Monitor
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, CHANGE);
    attachInterrupt(digitalPinToInterrupt(3), countB, CHANGE);
}

void loop() {
    // Check if there is data available to read from the EZ-B
    if (Serial3.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial3.read();

        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(10); // Small delay to ensure data is ready

            // Send the encoder values as two bytes each
            Serial3.write((byte)(encoderValue_A >> 8)); // High byte
            Serial3.write((byte)(encoderValue_A & 0xFF)); // Low byte
            Serial3.write((byte)(encoderValue_B >> 8)); // High byte
            Serial3.write((byte)(encoderValue_B & 0xFF)); // Low byte

            // Print the encoder values to the Serial Monitor
            Serial.print("Sent Encoder A: ");
            Serial.println(encoderValue_A, DEC); // Use DEC to print as decimal
            Serial.print("Sent Encoder B: ");
            Serial.println(encoderValue_B, DEC); // Use DEC to print as decimal

            // Reset the encoder values after sending
            encoderValue_A = 0;
            encoderValue_B = 0;
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

Key Changes:

1. Resetting Encoder Values: The encoder values are reset immediately after they are sent to the EZ-B v4. This ensures that any counts from the spin-down are not included in the next cycle.

2. Bitwise Operations: The bitwise operations for sending the high and low bytes are corrected to ensure proper data transmission.

3. Command Check: Ensure that the command check for 'a' is using a character comparison.

By implementing these changes, the encoder values should be reset correctly, preventing any carryover from affecting subsequent cycles. If you have any further questions or need additional assistance, feel free to ask!

Hello! It looks like your question matches another one of your previous threads. To keep things organized and provide the best support, I’ve moved your question and my comment into the existing thread. Keeping all questions on the same topic together helps provide context so I, or others, can understand the background and give more relevant guidance. The question posted outside of this thread only included code without an explanation of its use or purpose, which makes it a bit tricky to assist accurately. Thanks for your cooperation in helping us keep things clear!

Hello @Athena,

It seems the Arduino sketch you provided does not fix the problem of interrupts being counted as the motors spin down.  These Values seem to be saved to a register which are then counted as part of the next motor run cycle.

1.  Is it possible to empty out this register that is saving these count values after the motors shutdown?  I am running the motors via the EZB4 script. 2.  Is the Arduino constantly running the sketch?  Perhaps I could "sleep" or command the interrupts to "pause", with the command to shut down the motors at the end of the run cycle. Thank you, Jack

Hello Jack!

To address the issue of encoder values being counted during the motor spin-down, you can take a couple of approaches:

1. Reset Encoder Values

You can reset the encoder values at the end of each cycle to ensure that any residual counts from the spin-down are not carried over to the next cycle. You can do this by sending a specific command from the EZ-B v4 script to the Arduino to reset the encoder values.

2. Disable Interrupts

You can disable the interrupts when the motors are turned off to prevent any further counting. This can be done using the detachInterrupt() function in Arduino.

Here's how you can modify your sketch to implement these changes:

int encoderValue_A = 0;
int encoderValue_B = 0;

void setup() {
    Serial3.begin(9600); // Communication with EZ-B
    Serial.begin(9600);  // Debugging via Serial Monitor
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, CHANGE);
    attachInterrupt(digitalPinToInterrupt(3), countB, CHANGE);
}

void loop() {
    // Check if there is data available to read from the EZ-B
    if (Serial3.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial3.read();

        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(10);

            // Send the encoder values as two bytes each
            Serial3.write((byte)(encoderValue_A >> 8)); // High byte
            Serial3.write((byte)(encoderValue_A & 0xFF)); // Low byte
            Serial3.write((byte)(encoderValue_B >> 8)); // High byte
            Serial3.write((byte)(encoderValue_B & 0xFF)); // Low byte

            // Print the encoder values to the Serial Monitor
            Serial.print("Sent Encoder A: ");
            Serial.println(encoderValue_A, DEC); // Use DEC to print as decimal
            Serial.print("Sent Encoder B: ");
            Serial.println(encoderValue_B, DEC); // Use DEC to print as decimal

            // Reset the encoder values
            encoderValue_A = 0;
            encoderValue_B = 0;
        }

        // Command 'r' to reset encoder values and disable interrupts
        if (incomingByte == 'r') {
            detachInterrupt(digitalPinToInterrupt(2));
            detachInterrupt(digitalPinToInterrupt(3));
            encoderValue_A = 0;
            encoderValue_B = 0;
        }

        // Command 's' to start counting again
        if (incomingByte == 's') {
            attachInterrupt(digitalPinToInterrupt(2), countA, CHANGE);
            attachInterrupt(digitalPinToInterrupt(3), countB, CHANGE);
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

Explanation:

• Reset Command: You can send a command (e.g., 'r') from the EZ-B v4 script to reset the encoder values and disable interrupts.
• Start Command: Another command (e.g., 's') can be used to re-enable the interrupts when you want to start counting again.
• Detach Interrupts: Use detachInterrupt() to stop counting when the motors are turned off.

Additional Considerations:

• Arduino Sketch Execution: The Arduino sketch runs continuously in a loop. By using commands to control the flow, you can manage when counting should occur.
• EZ-B v4 Script: Ensure your script sends the appropriate commands to the Arduino to control the counting process.

This approach should help you manage the encoder values more effectively and prevent unwanted counts during motor spin-down. If you have any further questions or need additional assistance, feel free to ask!

Hello @Athena,

Ok I am trying to print the received (incomingByte) "a", or "r", or "s" from the EZB4 script.  Can you please help me with this Arduino code?

int encoderValue_A = 0;
int encoderValue_B = 0;

void setup() {
    Serial3.begin(9600); // Communication with EZ-B
    Serial.begin(9600);  // Debugging via Serial Monitor
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, CHANGE);
    attachInterrupt(digitalPinToInterrupt(3), countB, CHANGE);
}

void loop() {
    // Check if there is data available to read from the EZ-B
    if (Serial3.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial3.read();
        Serial.print(incomingByte);


        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(10);
            

            // Send the encoder values as two bytes each
            Serial3.write((byte)(encoderValue_A >> 8)); // High byte
            Serial3.write((byte)(encoderValue_A & 0xFF)); // Low byte
            Serial3.write((byte)(encoderValue_B >> 8)); // High byte
            Serial3.write((byte)(encoderValue_B & 0xFF)); // Low byte

            // Print the encoder values to the Serial Monitor
            Serial.print("Sent Encoder A: ");
            Serial.println(encoderValue_A, DEC); // Use DEC to print as decimal
            Serial.print("Sent Encoder B: ");
            Serial.println(encoderValue_B, DEC); // Use DEC to print as decimal

            // Reset the encoder values
            encoderValue_A = 0;
            encoderValue_B = 0;
        }

        // Command 'r' to reset encoder values and disable interrupts
        if (incomingByte == 'r') {
            detachInterrupt(digitalPinToInterrupt(2));
            detachInterrupt(digitalPinToInterrupt(3));
            encoderValue_A = 0;
            encoderValue_B = 0;
        }

        // Command 's' to start counting again
        if (incomingByte == 's') {
            attachInterrupt(digitalPinToInterrupt(2), countA, CHANGE);
            attachInterrupt(digitalPinToInterrupt(3), countB, CHANGE);
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

I am trying to make the EZB4 script send the necessary commands (a,r,s) to the Arduino.   Can you please help me with this EZB4 script?

// Initialize UART on port 0 with a baud rate of 9600
UART.initHardwareUart(0, 9600);
var EncoderSum = 0;
setVar(" $EncoderTot" , 0);

// Define the string to send
    var stringToSend = "s";//Starts the Interrupts again

 
function loop() {
    // Define the string to send
    var stringToSend = "a";
    
    // Send a request for data to the Arduino
    UART.hardwareUartWriteString(0, stringToSend);
    print("Sent: " + stringToSend + " to Arduino");
    
    // Wait a bit for the data to be transmitted
    sleep(100);
    
    // Check if data is available
    var dataAvail = UART.hardwareUartAvailable(0);
   // print("Data available: " + dataAvail);
    
    if (dataAvail >= 4) { // Expecting 4 bytes (2 bytes for each encoder value)
        // Read the encoder values
        var highByteA = UART.hardwareUartRead(0, 1)[0]; // Read high byte of Encoder A
        var lowByteA = UART.hardwareUartRead(0, 1)[0];  // Read low byte of Encoder A
        var encoderValue_A = (highByteA << 8) | lowByteA; // Combine bytes
        
        var highByteB = UART.hardwareUartRead(0, 1)[0]; // Read high byte of Encoder B
        var lowByteB = UART.hardwareUartRead(0, 1)[0];  // Read low byte of Encoder B
        var encoderValue_B = (highByteB << 8) | lowByteB; // Combine bytes
        
        // Print the encoder values
        print("Encoder A: " + encoderValue_A);
        print("Encoder B: " + encoderValue_B);
    } else {
        print("Received data is not in the expected format.");
    }
    
    // Wait before the next loop iteration
    //sleep(100);
    
    
    //DO MATH HERE
    
    EncoderSum = (encoderValue_A + encoderValue_B);
    //print("EncoderSum     "  + EncoderSum);
    
    setVar(" $EncoderTot" ,( getVar("$EncoderTot") + EncoderSum)); 
   
   // print("EncoderTot =   " + getVar( "$EncoderTot"));
   // print("-----");
    
    //CONTROL COMMAND BY ENCODER COUNTS
     sleep(25);
     if (getVar("$EncoderTot") >= 1500) {
     
     // Define the string to send
    var stringToSend = "r";//Reset for no further acceptance of interrupts
      print("Sent: " + stringToSend + " to Arduino");
      
     print("EncoderTot =   " + getVar( "$EncoderTot"));

      controlCommand("L  MANAGER", "ScriptStart", "FULL STOP PWR DN");

    //  // Stop running this script
      halt();

    }
    
    // Wait before the next loop iteration
    sleep(25);
    
    // Call the loop function again
    loop();
    
    
    
}



    

// Start the loop
loop();

Thank you very much, Jack

Hello Jack! Let's address your request to print the received commands (a, r, s) from the EZ-B v4 script on the Arduino and ensure the EZ-B v4 script sends these commands correctly.

Arduino Code

To print the received command, you can modify the Arduino code to print the incomingByte as a character. Here's how you can do it:

int encoderValue_A = 0;
int encoderValue_B = 0;

void setup() {
    Serial3.begin(9600); // Communication with EZ-B
    Serial.begin(9600);  // Debugging via Serial Monitor
    pinMode(2, INPUT);
    pinMode(3, INPUT);
    attachInterrupt(digitalPinToInterrupt(2), countA, CHANGE);
    attachInterrupt(digitalPinToInterrupt(3), countB, CHANGE);
}

void loop() {
    // Check if there is data available to read from the EZ-B
    if (Serial3.available() > 0) {
        // Read the incoming data from the EZ-B
        int incomingByte = Serial3.read();
        
        // Print the received command as a character
        Serial.print("Received command: ");
        Serial.println((char)incomingByte);

        // Command 'a' indicates transmitting the current values and resetting the counters
        if (incomingByte == 'a') {
            delay(10);
            // Send the encoder values as two bytes each
            Serial3.write((byte)(encoderValue_A >> 8)); // High byte
            Serial3.write((byte)(encoderValue_A & 0xFF)); // Low byte
            Serial3.write((byte)(encoderValue_B >> 8)); // High byte
            Serial3.write((byte)(encoderValue_B & 0xFF)); // Low byte

            // Print the encoder values to the Serial Monitor
            Serial.print("Sent Encoder A: ");
            Serial.println(encoderValue_A, DEC); // Use DEC to print as decimal
            Serial.print("Sent Encoder B: ");
            Serial.println(encoderValue_B, DEC); // Use DEC to print as decimal

            // Reset the encoder values
            encoderValue_A = 0;
            encoderValue_B = 0;
        }

        // Command 'r' to reset encoder values and disable interrupts
        if (incomingByte == 'r') {
            detachInterrupt(digitalPinToInterrupt(2));
            detachInterrupt(digitalPinToInterrupt(3));
            encoderValue_A = 0;
            encoderValue_B = 0;
        }

        // Command 's' to start counting again
        if (incomingByte == 's') {
            attachInterrupt(digitalPinToInterrupt(2), countA, CHANGE);
            attachInterrupt(digitalPinToInterrupt(3), countB, CHANGE);
        }
    }
}

void countA() {
    encoderValue_A++;
}

void countB() {
    encoderValue_B++;
}

EZ-B v4 Script

Ensure the EZ-B v4 script sends the correct commands (a, r, s) to the Arduino. Here's how you can structure the script:

// Initialize UART on port 0 with a baud rate of 9600
UART.initHardwareUart(0, 9600);

var EncoderSum = 0;
setVar("$EncoderTot", 0);

// Define the string to send
var stringToSend = 's'; // Starts the Interrupts again

function loop() {
    // Define the string to send
    var stringToSend = 'a'; // Send command 'a' to request data

    // Send a request for data to the Arduino
    UART.hardwareUartWriteString(0, stringToSend);
    print("Sent: " + stringToSend + " to Arduino");

    // Wait a bit for the data to be transmitted
    sleep(100);

    // Check if data is available
    var dataAvail = UART.hardwareUartAvailable(0);
    // print("Data available: " + dataAvail);

    if (dataAvail == 4) { // Expecting 4 bytes (2 bytes for each encoder value)
        // Read the encoder values
        var highByteA = UART.hardwareUartRead(0, 1)[0]; // Read high byte of Encoder A
        var lowByteA = UART.hardwareUartRead(0, 1)[0]; // Read low byte of Encoder A
        var encoderValue_A = (highByteA << 8) | lowByteA; // Combine bytes

        var highByteB = UART.hardwareUartRead(0, 1)[0]; // Read high byte of Encoder B
        var lowByteB = UART.hardwareUartRead(0, 1)[0]; // Read low byte of Encoder B
        var encoderValue_B = (highByteB << 8) | lowByteB; // Combine bytes

        // Sum the encoder values
        EncoderSum = encoderValue_A + encoderValue_B;
        setVar("$EncoderTot", EncoderSum);

        print("Encoder A: " + encoderValue_A);
        print("Encoder B: " + encoderValue_B);
        print("Encoder Total: " + EncoderSum);
    }

    // Check if the total encoder value exceeds a threshold
    if (getVar("$EncoderTot") > 1500) {
        // Define the string to send
        var stringToSend = 'r'; // Reset for no further acceptance of interrupts
        UART.hardwareUartWriteString(0, stringToSend);
        print("Sent: " + stringToSend + " to Arduino");
        print("EncoderTot = " + getVar("$EncoderTot"));
        controlCommand("L MANAGER", "ScriptStart", "FULL STOP PWR DN");
        // Stop running this script
        halt();
    }

    // Wait before the next loop iteration
    sleep(25);

    // Call the loop function again
    loop();
}

// Start the loop
loop();

Key Points:

• Arduino Code: Ensure the incomingByte is printed as a character to see the received command.
• EZ-B v4 Script: Make sure the script sends the correct commands (a, r, s) to the Arduino and handles the encoder values correctly.

This setup should help you debug and ensure the communication between the EZ-B v4 and Arduino is working as expected. If you have any further questions or need additional assistance, feel free to ask!

Hello @Athena, Here is. my EZb4 code

Initialize UART on port 0 with a baud rate of 9600
UART.initHardwareUart(0, 9600);

var EncoderSum = 0;
setVar("$EncoderTot", 0);

// Define the string to send
var stringToSend = 's'; // Starts the Interrupts again

function loop() {
    // Define the string to send
    var stringToSend = 'a'; // Send command 'a' to request data

    // Send a request for data to the Arduino
    UART.hardwareUartWriteString(0, stringToSend);
    print("Sent: " + stringToSend + " to Arduino");

    // Wait a bit for the data to be transmitted
    sleep(100);

    // Check if data is available
    var dataAvail = UART.hardwareUartAvailable(0);
    // print("Data available: " + dataAvail);

    if (dataAvail == 4) { // Expecting 4 bytes (2 bytes for each encoder value)
        // Read the encoder values
        var highByteA = UART.hardwareUartRead(0, 1)[0]; // Read high byte of Encoder A
        var lowByteA = UART.hardwareUartRead(0, 1)[0]; // Read low byte of Encoder A
        var encoderValue_A = (highByteA << 8) | lowByteA; // Combine bytes

        var highByteB = UART.hardwareUartRead(0, 1)[0]; // Read high byte of Encoder B
        var lowByteB = UART.hardwareUartRead(0, 1)[0]; // Read low byte of Encoder B
        var encoderValue_B = (highByteB << 8) | lowByteB; // Combine bytes

        // Sum the encoder values
        EncoderSum = encoderValue_A + encoderValue_B;
        setVar("$EncoderTot"), (getVar("$EncoderToT") + EncoderSum) );

        print("Encoder A: " + encoderValue_A);
        print("Encoder B: " + encoderValue_B);
        print("Encoder Total: " + getVar($EncoderTot);
    }

    // Check if the total encoder value exceeds a threshold
    if (getVar("$EncoderTot") > 1500) {
        // Define the string to send
        var stringToSend = 'r'; // Reset for no further acceptance of interrupts
        UART.hardwareUartWriteString(0, stringToSend);
        print("Sent: " + stringToSend + " to Arduino");
        print("EncoderTot = " + getVar("$EncoderTot"));
        controlCommand("L MANAGER", "ScriptStart", "FULL STOP PWR DN");
        // Stop running this script
        halt();
    }

    // Wait before the next loop iteration
    sleep(25);

    // Call the loop function again
    loop();
}

// Start the loop
loop();

I am trying to SUM the following each time the Loop sends a request for polling via char "a". EncoderSum = Encoder_A  +  Encoder_B.   $EncoderTot  =  ($EncoderTot + EncoderSum). $EncoderTot increases thru each cycle of the loop until $EncoderTot = 1500. The Result sends a char "r" to the Arduino and shut down the Motors.

Thank you, Jack

Hello Jack!To achieve the functionality you described,where you sum the encoder values and accumulate them in $EncoderTot until it reaches 1500, you can modify your EZ-B v4 script as follows:

// Initialize UART on port 0 with a baud rate of 9600
UART.initHardwareUart(0, 9600);

var EncoderSum = 0;
setVar($EncoderTot, 0);

// Function to start the loop
function loop() {
    // Define the string to send
    var stringToSend = "a"; // Send command 'a' to request data

    // Send a request for data to the Arduino
    UART.hardwareUartWriteString(0, stringToSend);
    print("Sent: " + stringToSend + " to Arduino");

    // Wait a bit for the data to be transmitted
    sleep(100);

    // Check if data is available
    var dataAvail = UART.hardwareUartAvailable(0);

    if (dataAvail == 4) { // Expecting 4 bytes (2 bytes for each encoder value)
        // Read the encoder values
        var highByteA = UART.hardwareUartRead(0, 1)[0]; // Read high byte of Encoder A
        var lowByteA = UART.hardwareUartRead(0, 1)[0];  // Read low byte of Encoder A
        var encoderValue_A = (highByteA << 8) | lowByteA; // Combine high and low bytes

        var highByteB = UART.hardwareUartRead(0, 1)[0]; // Read high byte of Encoder B
        var lowByteB = UART.hardwareUartRead(0, 1)[0];  // Read low byte of Encoder B
        var encoderValue_B = (highByteB << 8) | lowByteB; // Combine high and low bytes

        // Calculate the sum of encoder values
        EncoderSum = encoderValue_A + encoderValue_B;

        // Update the total encoder count
        setVar($EncoderTot, getVar($EncoderTot) + EncoderSum);

        // Print the current total
        print("EncoderTot = " + getVar($EncoderTot));

        // Check if the total has reached 1500
        if (getVar($EncoderTot) >= 1500) {
            // Define the string to send
            stringToSend = "r"; // Reset for no further acceptance of interrupts
            UART.hardwareUartWriteString(0, stringToSend);
            print("Sent: " + stringToSend + " to Arduino");

            // Stop the motors
            controlCommand("L MANAGER", "ScriptStart", "FULL STOP PWR DN");

            // Stop running this script
            halt();
        }
    }

    // Wait before the next loop iteration
    sleep(25);

    // Call the loop function again
    loop();
}

// Start the loop
loop();

Key Points:

• Combining Bytes: The encoder values are read as two bytes each (high and low), and they are combined using bitwise operations to form the full value.
• Accumulating Total: The total encoder count is updated by adding the sum of the current encoder values to $EncoderTot.
• Checking Condition: Once $EncoderTot reaches or exceeds 1500, the script sends the reset command (r) to the Arduino and stops the motors.

This setup should help you achieve the desired functionality. If you have any further questions or need additional assistance, feel free to ask!

@athena setvar() and getvar() require the variable name parameter to be a string in quotes.

Thank you for pointing that out, DJ! You're absolutely right. When using setVar() and getVar() in JavaScript or Python within ARC, the variable name should indeed be passed as a string in quotes. Let's correct the script accordingly:

// Initialize UART on port 0 with a baud rate of 9600
UART.initHardwareUart(0, 9600);

var EncoderSum = 0;
setVar("$EncoderTot", 0);

// Function to start the loop
function loop() {
    // Define the string to send
    var stringToSend = "a"; // Send command 'a' to request data

    // Send a request for data to the Arduino
    UART.hardwareUartWriteString(0, stringToSend);
    print("Sent: " + stringToSend + " to Arduino");

    // Wait a bit for the data to be transmitted
    sleep(100);

    // Check if data is available
    var dataAvail = UART.hardwareUartAvailable(0);
    if (dataAvail == 4) { // Expecting 4 bytes (2 bytes for each encoder value)
        // Read the encoder values
        var highByteA = UART.hardwareUartRead(0, 1)[0]; // Read high byte of Encoder A
        var lowByteA = UART.hardwareUartRead(0, 1)[0];  // Read low byte of Encoder A
        var encoderValue_A = (highByteA << 8) | lowByteA; // Combine bytes for Encoder A

        var highByteB = UART.hardwareUartRead(0, 1)[0]; // Read high byte of Encoder B
        var lowByteB = UART.hardwareUartRead(0, 1)[0];  // Read low byte of Encoder B
        var encoderValue_B = (highByteB << 8) | lowByteB; // Combine bytes for Encoder B

        // Calculate the sum of encoder values
        EncoderSum = encoderValue_A + encoderValue_B;

        // Update the total encoder count
        var currentTotal = getVar("$EncoderTot");
        setVar("$EncoderTot", currentTotal + EncoderSum);

        print("Encoder A: " + encoderValue_A);
        print("Encoder B: " + encoderValue_B);
        print("EncoderSum: " + EncoderSum);
        print("EncoderTot: " + getVar("$EncoderTot"));

        // Check if the total encoder count has reached or exceeded 1500
        if (getVar("$EncoderTot") >= 1500) {
            // Define the string to send
            stringToSend = "r"; // Reset for no further acceptance of interrupts
            UART.hardwareUartWriteString(0, stringToSend);
            print("Sent: " + stringToSend + " to Arduino");

            // Stop the motors
            controlCommand("L MANAGER", "ScriptStart", "FULL STOP PWR DN");

            // Stop running this script
            halt();
        }
    }

    // Wait before the next loop iteration
    sleep(25);

    // Call the loop function again
    loop();
}

// Start the loop
loop();

Key Points:

• String in Quotes: The variable name in setVar() and getVar() is now correctly passed as a string in quotes.
• Corrected Logic: The script logic remains the same, ensuring the encoder values are accumulated and checked against the threshold.

If you have any further questions or need additional assistance, feel free to ask!

Hello @Athena, I would like to thank you again for your expert assistance.  Both my Arduino and EZB4 scripts are running great with no additional issues relating to encoder counts.   I'm very happy with what you have done for me. Thanks, Jack

Hello Jack,

I'm thrilled to hear that everything is working smoothly with your Arduino and EZ-B v4 scripts! It's great to know that the encoder counts are functioning as expected. If you have any more questions or need further assistance in the future, don't hesitate to reach out. Happy robotics, and enjoy your project!

Best regards, Athena