CD4021BE & 74HC595

Buongiorno a tutti… nuovo del forum.

Sto approntando un sistema per pilotare, tramite 16 pulsanti capacitivi illuminati (LED RGB), un motore.
Su sfioramento di un pulsante il motore viene azionato in un senso, il pulsante “chiamante cambia colore” ed i restanti 15 assumono un colore diverso. Su successivo sfioramento di un qualsiasi pulsante il motore si ferma ed il colore dei pulsanti è uguale per tutti. Ancora su sfioramento il motore viene azionato nel senso contrario e il pulsante “chiamante cambia colore” ed i restanti 15 assumono un colore diverso… e così via.

Per realizzare ciò ho usato 6 * 74HC595 + 6 * ULN2803A (per controllare il colore dei LED) + 2 * CD4021BE per acquisire le chiamate dai pulsanti.

Il sistema funziona (sinceramente ho collegato solo due dei sei 74HC595), ma, tra lo sfioramento di un pulsante e il cambio colore + attivazione relè c’è un apprezzabile ritardo (quantificabile in circa 1 secondo) che vorrei eliminare.

Vorrei sapere se qualcuno ha già avuto questo problema e come lo ha risolto.

Non essendo esperto né di programmazione né di elettronica in generale, ho scritto un codice ispirandomi a vari esempi trovati nel forum. Lo allego qui di seguito.

Saluto.

code.ino (3.24 KB)

fau_pozzi:
Buongiorno a tutti... nuovo del forum.

Ti invitiamo a presentarti (dicci quali conoscenze hai di elettronica e di programmazione) qui: Presentazioni
e a leggere il regolamento: Regolamento

Aggiungo qualche informazione.
Le mie conoscenze di elettronica sono base e quelle di programmazione ancora più primitive: ho cominciato con l'acquisto della scheda Arduino UNO che sto utilizzando per l'applicazione di cui parlavo sopra.

posta il codice fra i code è più visibile

Eccolo…

const int ShiftPWM_latchPin=8;

const bool ShiftPWM_invertOutputs = false; 

const bool ShiftPWM_balanceLoad = false;

#define SHIFTPWM_USE_TIMER2  // for Arduino Uno and earlier (Atmega328)
#include <ShiftPWM.h>   // include ShiftPWM.h after setting the pins!

unsigned char maxBrightness = 255;
unsigned char pwmFrequency = 75;
int numRegisters = 6;
int numRGBleds = numRegisters*8/3;

int x = 0;
boolean action = false;
boolean rotat = false;
int L = 0;
int REL1 = 3;
int REL2 = 5;

int latchPin = 2;
int dataPin = 6;
int clockPin = 4;

byte SW1 = 72;
byte prSW1 = 0;
byte SW2 = 159;
byte prSW2 = 0;

void setup(){

  ShiftPWM.SetAmountOfRegisters(numRegisters);
  
  ShiftPWM.Start(pwmFrequency,maxBrightness);
  
  ShiftPWM.SetAllRGB(35,160,255);
   
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT); 
  pinMode(dataPin, INPUT);
  pinMode(3, OUTPUT);
  pinMode(5, OUTPUT);
  
  digitalWrite(REL1, LOW);
  digitalWrite(REL2, LOW);
}



void loop()
{    
  digitalWrite(latchPin,1);
  delayMicroseconds(20);
  digitalWrite(latchPin,0);
        
  SW1 = shiftIn(dataPin, clockPin);
  SW2 = shiftIn(dataPin, clockPin);
  
  delay(50);  
    
  if (SW1 != prSW1){
   if (SW1 != 0){
     action = !action; 
     if (action == true){
      rotat = !rotat;
      for (int n=0 ; n<=7; n++){
        if (SW1 & (1 << n) ){
          ShiftPWM.SetRGB(n,170,80,50);
          int L = n;
            for (int p = 0; p<=15; p++){
              if (p != L){
              ShiftPWM.SetRGB(p,20,220,10);
              }
            }              
        }
      }
      if (rotat == true){  
       digitalWrite(3, HIGH);   
       delay(500);              
       digitalWrite(3, LOW);
      }
      else{
       digitalWrite(5, HIGH);   
       delay(500);              
       digitalWrite(5, LOW);
      }
     }
     else{
      ShiftPWM.SetAllRGB(35,160,255);
      digitalWrite(3, HIGH);
      delay(500); 
      digitalWrite(3, LOW);
     }
   }
  }
  
  if (SW2 != prSW2){
   if (SW2 != 0){
     action = !action; 
     if (action == true){
      rotat = !rotat;
      for (int n=0 ; n<=7; n++){
        if (SW2 & (1 << n) ){
          ShiftPWM.SetRGB(n+8,170,80,50);
          int L = n+8;
            for (int p = 0; p<=15; p++){
              if (p != L){
              ShiftPWM.SetRGB(p,20,220,10);
              }
            }              
        }
      }
      if (rotat == true){  
       digitalWrite(3, HIGH);   
       delay(500);              
       digitalWrite(3, LOW);
      }
      else{
       digitalWrite(5, HIGH);   
       delay(500);              
       digitalWrite(5, LOW);
      }
     }
     else{
      ShiftPWM.SetAllRGB(35,160,255);
      digitalWrite(3, HIGH);
      delay(500); 
      digitalWrite(3, LOW);
     }
   }
  }
  
  prSW1 = SW1;
  prSW2 = SW2;
  Serial.println(rotat);
}


//******************************// 
// shift in Function            //
//******************************//
  byte shiftIn(int myDataPin, int myClockPin) { 
  int i;
  int temp = 0;
  int pinState;
  byte myDataIn = 0;

  pinMode(myClockPin, OUTPUT);
  pinMode(myDataPin, INPUT);

  for (i=7; i>=0; i--)
  {
    digitalWrite(myClockPin, 0);
    delayMicroseconds(0.2);
    temp = digitalRead(myDataPin);
    if (temp) {
      pinState = 1;
      myDataIn = myDataIn | (1 << i);
    }
    else {
      pinState = 0;
    }
    digitalWrite(myClockPin, 1);

  }
   return myDataIn;
}

Nessuna idea?

Sì, una. Togli i delay. Durante un delay il programma resta bloccato per il numero di ms indicato. Ne vedo un pò troppi. E' normale che ci sia del ritardo tra le pressioni.

Grazie leo72 per l'idea!

Avevo già provato, ma non cambia nulla...

Saluto.

Qualche altra idea?

Grazie!