Read 80 3.3v or 5.0v Sensors and report to PC via Serial string

BowDown · January 30, 2018, 8:07pm

I thought I had this shield prototyped and working well until it was put into service. It appears to be a timing issue with how fast the serial string is requested vs reading the shift registers?

Anyway... I have 2 pins configured for an encoder, and 80 sensors to read. I want to read the sensor bank from start to finish and then report a binary string via serial to my GUI software running on a Windows 10 machine.

What's the best way to read (80) 3.3v or 5.0v + DC inputs based on an encoder click count?

I had a pretty decent setup before running 2 arduino mega boards and using 2 com ports on a PC before... but I wanted to make the software a bit simpler and easier to use by running 1 arduino. So i prototyped a board using (10) CD4021B shift registers and a RedBoard. Worked great in testing on the bench, but in service it gives very erratic data.

Thoughts on how to pull off reading that many high/low sensor inputs?

BowDown · January 30, 2018, 8:12pm

Removed the source code, didn't realize...

Grumpy_Mike · January 30, 2018, 8:14pm

Thoughts on how to pull off reading that many high/low sensor inputs?

Review your schematic and see why it is erratic.
Review your software and see if you can speed it up.
Define how quickly you want to have the sensors read.
Send the data in a more efficient way than a binary string.
Read How to use this forum
Because your post is breaking the rules about posting code.
Don't print in an interrupt service routine.

BowDown · January 30, 2018, 8:24pm

Grumpy_Mike:

Review your schematic and see why it is erratic.

Review your software and see if you can speed it up.

Define how quickly you want to have the sensors read.

Send the data in a more efficient way than a binary string.

Read How to use this forum
Because your post is breaking the rules about posting code.

Don't print in an interrupt service routine.

My knowledge with small electronics and shift registers is enough to be dangerous.. when it comes to troubleshooting my circuit of registers I'm a bit lost. Seems like that was the best route to go with, but in service it's not working out. A bit lost.

So leads me back to my original question of.. Is there a better way?

Running a serial string input at 250000 baud seems like it would be more than fast enough for what I'm doing...

Robin2 · January 30, 2018, 8:49pm

BowDown:
Removed the source code, didn't realize...

How about reinstating it ... if you really want help.

...R

BowDown · January 30, 2018, 9:01pm

Robin2:
How about reinstating it ... if you really want help.

...R

I was told this wasn't the correct forum for it?

//********************************************************************************
// BUILD FLAGS
//********************************************************************************

//Debugging
const boolean enableTestMode = true;


//********************************************************************************
// ARDUINO PINS
//********************************************************************************

//Encoder Input Pins
#define PINA       2
#define PINB       3
#define INTERRUPT  0 

//Shift Register Pins
int clockPin        = 7; 
int latchPin        = 8; 
int dataPin         = 9; 


//********************************************************************************
// GLOBALS
//********************************************************************************

//Constants
#define encCountDelay           2   //4.5" Diameter Roller x [Pi] = 14.135" / 120 encoder clicks = 0.118"/click * 2 = 0.236" per scan (1/4")
#define numOfRegisters          10 
#define numOfSensors            numOfRegisters * 8

//Variables
volatile boolean runThis          = false; 
volatile boolean up               = false;
volatile unsigned int encCount    = 0;


//********************************************************************************
// SETUP
//********************************************************************************

void setup()
{
  Serial.begin(250000);   
  
  //Shift Registers
  pinMode(clockPin,        OUTPUT);
  pinMode(latchPin,        OUTPUT);
  pinMode(dataPin,          INPUT);

  //Interrupt Pin Setup
  digitalWrite (PINA, HIGH);     
  digitalWrite (PINB, HIGH); 
  attachInterrupt (INTERRUPT, doThis, CHANGE);  

  if (enableTestMode) { Serial.println("TEST MODE ENABLED"); }
}


//********************************************************************************
// LOOP
//********************************************************************************

void loop()
{
  if (runThis) 
  {
    //Disable Encoder Input
    stopEncoder();
      
    //Read Shift Registers & Format Register Data, Send to Serial (Machine Formatted)
    readShiftRegisters();
            
    //Enable Encoder Input
    resumeEncoder();    
  }
}


//********************************************************************************
// FUNCTIONS
//********************************************************************************

//Do This on Interrupt
void doThis(void)
{
  if (!runThis)
  {
    //Check Rotation, only count if going forward
    if (digitalRead(PINA)) { up = digitalRead(PINB); }
    else { up = !digitalRead(PINB); }
    
    if (up) { encCount++; }
        
    //Time to run logic?
    if (encCount >= encCountDelay) 
    { 
      if (enableTestMode) { Serial.print("Forward Encoder Count = "); Serial.println(encCount); }
      runThis = true;
    }
  }  
}


//Read Shift Registers
void readShiftRegisters(void)
{
  //Prepare Registers
  digitalWrite(latchPin, 1);
  delayMicroseconds(20);
  digitalWrite(latchPin, 0);

  int sensorNum = 1;

  //Read Data & Output to Serial
  for (int x = 0; x < numOfRegisters; x++)   //Loop number of registers
  {
    for (int i = 7; i >= 0; i--)   //Loops number of inputs on register
    {
      digitalWrite(clockPin, 0);
      delayMicroseconds(2);
    
      if (digitalRead(dataPin) == HIGH) { Serial.print("1"); }
      else { Serial.print("0"); }
    
      digitalWrite(clockPin, 1);

      sensorNum++;
      if (sensorNum > numOfSensors) { Serial.print("\n"); }
    }
  } 
}


//Stop Encoder Input
void stopEncoder(void)
{
  noInterrupts();
}


//Resume Encoder Input
void resumeEncoder(void)
{
  encCount = 0;
  runThis = false;

  interrupts(); 
}

Grumpy_Mike · January 30, 2018, 9:10pm

I was told this wasn't the correct forum for it?

Who told you that not me. I told you it was not posted correctly.

If you want help you have to tell us what you have done, you have given us very little to go on so far.

So a schematic of your hardware, a photograph showing the wiring, information about what you are sending the data into (GUI on a PC doesn't cut it ), and what transfer time are you aiming for.

I also told you not to print in an ISR so why have you not tried removing it and seeing if that improves the matter?

BowDown · January 30, 2018, 9:30pm

Ok I'll get a schematic tomorrow when I'm back at work. Let's eliminate the custom software. From using the serial monitor I can tell the data is in correct. What is printed to the serial monitor is a single line with 80 values 0 or 1 depending on pin state. 3.8v DC + is fed into each input of the shift register. Max read interval is 3 encoder revolutions per second. I will do the math tomorrow as well... Sorry.

BowDown · January 30, 2018, 9:36pm

Grumpy_Mike:
I also told you not to print in an ISR so why have you not tried removing it and seeing if that improves the matter?

I don't quite follow. If I don't print the data to the screen (serial monitor) how am I going to know if it's correct?

BowDown · January 30, 2018, 9:42pm

Or are you suggesting I build some kind of array with the pin values then output it after the read routine?

Robin2 · January 30, 2018, 9:43pm

You can't use the noInterrupts() function like that. You are pausing interrupts for far too long. Also Serial.print() require interrupts to be active. Normally you would halt interrupts for a few microseconds to read a value that is updated within an ISR.

You also have a print() statement inside your ISR and interrupts are automatically off inside an ISR. As well as which print() is much too slow to put it inside an ISR even if it would work properly.

And I don't understand what is your purpose in halting interrupts. Why bother to stop the encoder?

...R

Grumpy_Mike · January 30, 2018, 9:47pm

If I don't print the data to the screen (serial monitor) how am I going to know if it's correct?

You can print it but not in an interrupt routine. Once you know the data is correct comment it out and connect up this mystery top secret Windows program.

BowDown · January 30, 2018, 9:49pm

Robin2:
You can't use the noInterrupts() function like that. You are pausing interrupts for far too long. Also Serial.print() require interrupts to be active. Normally you would halt interrupts for a few microseconds to read a value that is updated within an ISR.

You also have a print() statement inside your ISR and interrupts are automatically off inside an ISR. As well as which print() is much too slow to put it inside an ISR even if it would work properly.

And I don't understand what is your purpose in halting interrupts. Why bother to stop the encoder?

...R

I stopped the interrupt because it would continue to tick and interrupt my code for reading and printing. I only run the read and print every so many clicks to not send any more serial data than needed...

May be on to something here though. I really appreciate the feedback here.

Robin2 · January 31, 2018, 8:39am

BowDown:
I stopped the interrupt because it would continue to tick and interrupt my code for reading and printing.

What harm would that be - your ISR should not contain any printing code.

...R

wvmarle · January 31, 2018, 10:19am

If you want to stop reading an encoder, you can disable the interrupt for that encoder. No need to disable ALL interrupts (there is much more to interrupts than those produced by the pins).

Switching off interrupts altogether will mess up things like timers and Serial communications.

BowDown · January 31, 2018, 12:50pm

All good information here. I did some google research and I now understand the fault in my ISR and disabling of all interrupts. Not understanding the full scope of the functions used would surely create the behavior I've been seeing. This is some great information here and I really appreciate the help!

I have made the changes to my program and soon I'll have some new data to evaluate.

BowDown · January 31, 2018, 1:45pm

More testing is needed but I think we got it! Awesome. Thanks guys for the help!

//********************************************************************************
// BUILD FLAGS
//********************************************************************************

//Debugging
const boolean enableTestMode = true;


//********************************************************************************
// ARDUINO PINS
//********************************************************************************

//Encoder Input Pins
#define encPinA    2
#define encPinB    3
#define INTERRUPT  0 

//Shift Register Pins
int clockPin        = 7; 
int latchPin        = 8; 
int dataPin         = 9; 


//********************************************************************************
// GLOBALS
//********************************************************************************

//Constants
#define encCountDelay           2   //4.5" Diameter Roller x [Pi] = 14.135" / 120 encoder clicks = 0.118"/click * 2 = 0.236" per scan (1/4")
#define numOfRegisters          10 
#define numOfSensors            numOfRegisters * 8

//Variables
volatile boolean runThis          = false; 
volatile boolean up               = false;
volatile unsigned int encCount    = 0;
volatile int readThis[numOfSensors];


//********************************************************************************
// SETUP
//********************************************************************************

void setup()
{
  Serial.begin(250000);   
  
  //Shift Registers
  pinMode(clockPin,        OUTPUT);
  pinMode(latchPin,        OUTPUT);
  pinMode(dataPin,          INPUT);

  //Interrupt Pin Setup
  digitalWrite (encPinA, HIGH);     
  digitalWrite (encPinB, HIGH); 
  attachInterrupt (INTERRUPT, doThis, CHANGE);  

  if (enableTestMode) { Serial.println("TEST MODE ENABLED"); }
}


//********************************************************************************
// LOOP
//********************************************************************************

void loop()
{
  if (runThis) 
  {
    //Clear Encoder Flags
    clearEncoderFlags();
      
    //Read Shift Registers & Format Register Data
    readShiftRegisters();

    //Send to Live Viewer
    sendToSerial();  
  }
}


//********************************************************************************
// FUNCTIONS
//********************************************************************************

//Do This on Interrupt
void doThis(void)
{
  if (!runThis)
  {
    //Check Rotation, only count if going forward
    if (digitalRead(encPinA)) { up = digitalRead(encPinB); }
    else { up = !digitalRead(encPinB); }
    
    if (up) { encCount++; }
        
    //Time to run logic?
    if (encCount >= encCountDelay) { runThis = true; }
  }  
}


//Read Shift Registers
void readShiftRegisters(void)
{
  //Disable Interrupts
  noInterrupts();
  
  //Prepare Registers
  digitalWrite(latchPin, 1);
  delayMicroseconds(20);
  digitalWrite(latchPin, 0);

  int sensorNum = 0;

  //Read Data
  for (int x = 0; x < numOfRegisters; x++)   //Loop number of registers
  {
    for (int i = 7; i >= 0; i--)   //Loops number of inputs on register
    {
      digitalWrite(clockPin, 0);
      delayMicroseconds(2);
    
      if (digitalRead(dataPin) == HIGH) { readThis[sensorNum] = 1; }
      else { readThis[sensorNum] = 0; }
    
      digitalWrite(clockPin, 1);

      sensorNum++;
    }
  } 

  //Enable Interrupts
  interrupts();
}


//Clear Encoder Flags
void clearEncoderFlags(void)
{
  encCount = 0;
  runThis = false;
}


//Send to Live Viewer
void sendToSerial(void)
{
  for (int i = 0; i < numOfSensors; i++) { Serial.print(readThis[i]); }  
  Serial.print("\n");
}

Robin2 · January 31, 2018, 2:05pm

If this was my project my ISR would be much simpler - like this

void doThis(void)  {
        //Check Rotation, only count if going forward
    byte encAval = digitalRead(encPinA);
    byte encBval = digitalRead(encPinB);
    
    if (encAval == HIGH and encBval == LOW) { // I may have this backwards
       encCount++;
       newEncVal = true; // signal to loop() that there is a new value
    }
}

And I cannot see any need to reset the value of encCount - in loop() just compare the current value with the previous value.

...R

BowDown · January 31, 2018, 2:51pm

Robin2:
If this was my project my ISR would be much simpler - like this
void doThis(void)  {

//Check Rotation, only count if going forward
byte encAval = digitalRead(encPinA);
byte encBval = digitalRead(encPinB);

if (encAval == HIGH and encBval == LOW) { // I may have this backwards
encCount++;
newEncVal = true; // signal to loop() that there is a new value
}
}




And I cannot see any need to reset the value of encCount - in loop() just compare the current value with the previous value.

...R

I do agree there are more ways to do it.. Not too sure storing the prevEncVal is any more efficient than just resetting the current one back to 0. But I'm sure either way would get the job done.

Thanks again. She seems to be working rather well now. Glad it wasn't a hardware issue..

Robin2 · January 31, 2018, 3:25pm

BowDown:
Not too sure storing the prevEncVal is any more efficient than just resetting the current one back to 0.

It would mean that the ISR is the only part of the code that changes the value of the counter

...R

Topic		Replies	Views
Multiple CD4021BE Shift Registers Programming	24	257	April 12, 2025
Schieberegistersteuerung Deutsch	34	257	January 16, 2026
Sensori hall e Serial.read() Generale	28	579	September 14, 2024
Rotation speed using photoelectric beam sensors Sensors	13	415	March 6, 2025
How to read more than 8 cascaded shift registers with SPI? General Guidance	66	4357	November 1, 2023

Read 80 3.3v or 5.0v Sensors and report to PC via Serial string

Related topics