Show Posts
Pages: [1]
1  International / Deutsch / Re: BCD codierte Ausgänge on: February 08, 2011, 03:05:25 pm
Hallo Korman,

und zwar folgendes zu meinem Problem.

Ich möchte eine Anzahl Taster (ca.64) an das Arduino anschließen. In der Praxis sind das dann Reissdrähte, also einfache Drähte die bei einer Materialermüdung z.b. Brückenkonstruktionen ausdehnen und reissen... der Taster öffnet also.

Dazu habe ich die Shiftin Funktion genutzt. Mit Shift out bekomm ich genau den Reissdraht angezeigt, der getastet wurde. Soweit so gut.

Das Eingangsregister ist Binär unterteilt von LSB 2^0 bis MSB 2^7.Jedes der 8 Bits wird seriell ins Arduino geschoben und von dort aus seriell zum Ausgangsregister, danach parallel dargestellt. Jetzt liegen 8 bits parallel an z.b an den LEDS.


Aber jetzt kommts, ich habe nur 8 Ausgänge, nicht mehr, und ich, möchte mehr als 8 Reissdrähte anschließen und detektieren.
Das bedeutet ich muss die Ausgänge bcd codieren, also die Eingänge (>smiley-cool auf die Ausgänge binär abbilden!

Nochmal zum Beispiel nur für 8 Reissdrähte!:

Reissdrähte 1, 2 und 8 sprechen an---> der Eingang sieht so aus = 1 0 0 0 0 0 1 1 stimmts?

und jetzt am Ausgang binär codieren 1+2+8 = 11--> die 11 darstellen auf 8 Ausgangsleds--> 0 0 0 0 1 0 1 1 stimmts?

Der Vorteil ist dabei, dass ich 255 Reissdrähte codieren kann (Personalisieren). Doch wie setze ich das als Code um?

Gibt es für meine Problemstellung eine bessere, schnellere (Laufzeit) Lösung?

Ich freue mich über jede Hilfe deinerseits, eurerseits smiley-wink


Grüße
2  International / Deutsch / BCD codierte Ausgänge on: February 08, 2011, 11:27:35 am
Hallo miteinander,

ich werde so langsam depressiv bei dem Problem.

Kurz dazu eine Einleitung:
Ich habe 8 Taster über ein Eingangsregister 4021 BE eingelesen.
Über das Arduino gebe ich die Binärwerte dem Ausgangsregister und dieses lässt parallel dazu acht LED's leuchten, in Abhängigkeit was für Taster gedrückt wurden!!!

Nun mein Problem. Ich möchte die Ausgänge (LED's) binär codieren. Um so 256 Taster anschließen zu können.

Gibt es vielleicht dazu eine elegantere Lösung? Zu beachten ist, das ich ein dauerhaftes paralleles Signal am Ausgangsregister haben muss und ich nicht mehr Ausgänge zur nutzen darf, da danach ein System kommt.

Beispiel:

Taster 1 gedrückt---> LSB LED leuchtet--> übergebener Strom von Eingangsregister 0000 0001

Taster 6 gedrückt---> LED 2, LED 3 leuchten---> übergebener Strom von ER 0000 0110

Taster 8 gedrückt---> LED 4 leuchten---> übergebener Strom von ER 0000 1000

Ich habe alles probiert switch case, und if Abfragen, doch nichts führte zum Ziel.

Gibt es Vielleicht dafür eine Bitoperation?

Weiß jemand wie man das Problem lösen kann?


Ich danke euch im Vorraus für eure Lösungen. smiley


Hier das Listing:

//**********************************
//Pin connected to ST_CP of 74HC595
int latchPin_out = 7;
//Pin connected to SH_CP of 74HC595
int clockPin_out = 8;
//Pin connected to DS of 74HC595
int dataPin_out = 9;
// Pin connected

int latchPin_in = 10;
// Pinconnection to 74HC4021BE
int clockPin_in = 11;
// Pinconnection to 74HC4021BE
int dataPin_in = 12;
// Pinconnection to 74HC4021BE

//**********************************
void setup() {
  //set pins to output so you can control the shift register
  pinMode(latchPin_out, OUTPUT);
  pinMode(clockPin_out, OUTPUT);
  pinMode(dataPin_out, OUTPUT);
 
  pinMode(dataPin_in, INPUT);
  pinMode(clockPin_in, OUTPUT);
  pinMode(latchPin_in, OUTPUT);
 
  Serial.begin(9600);
}
//**********************************
void loop() {
 
 
    int switchVar1 = 0;
    digitalWrite(latchPin_in,1);
    delayMicroseconds(10);
    digitalWrite(latchPin_in,0);
    switchVar1 = shiftIn(dataPin_in, clockPin_in);
    Serial.println(switchVar1, BIN);
    shift_Out (switchVar1, dataPin_out, clockPin_out, latchPin_in);

    //delay(500);
}
   
    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;

  }
   
    byte shift_Out(byte var, int Dpout, int Cpout, int Lpout){
     
    digitalWrite(Lpout, LOW);
    // shift out the bits:
    shiftOut(Dpout, Cpout, LSBFIRST, var); 

    //take the latch pin high so the LEDs will light up:
    digitalWrite(Lpout, HIGH);
    }
   

3  International / Deutsch / Re: Problem shiftin und shift out on: February 04, 2011, 01:55:25 am
Hallo Uwe,


danke für deine schnelle und praktische Antwort.

Ich werde die die Idee mit dem Chip in Erwägung ziehen.

Ich melde mich später nocheinmal, wenn ich den 74HC595 ausprobiert habe.

Grüße

4  International / Deutsch / Re: Problem shiftin und shift out on: February 02, 2011, 08:10:20 am
Hallo,


meine Aufgabenstellung sieht folgendes vor. Ich muss digitale Eingänge einlesen (Taster) und nutze, um Arduino Eingänge zu sparen das 4021 BE Schieberegister. Mit diesem kann ich ins Arduino den Zustand der Taster (8 Stück) einlesen und über Serialprint anzeigen. Das funktioniert einwandfrei.

Nun will ich das Byte seriell->parallel wandeln und habe dazu einen 74HC164 eingesetzt. Hat damit schon jemand experimentiert?
Weise ich der shiftOut funktion einfach das Byte zu so z.B. --> shiftOut(switchVar1, clockPin, latchPin, MSBFIRST, bits)?
Kann ich den Clockpin und den Latchpin des Eingangsregisters für das 74HC164 nutzen?

Ich habe den Code vom Arduino Tut genommen und das shiftout eingefügt, jedoch fällt mir nun nichts mehr ein was ich machen kann.

Ich danke euch im Voraus.

Grüße

hier das listing  vom seriell-->parallel und parallel-->seriell



//define where your pins are
int latchPin = 8;
int dataPin = 9;
int clockPin = 7;
int clockPin_new = 10;
int latchPin_new = 11;


//Define variables to hold the data
//for each shift register.
//starting with non-zero numbers can help
//troubleshoot
byte switchVar1 = 72;  //01001000
byte switchVar2 = 159; //10011111

void setup() {
  //start serial
  Serial.begin(9600);

  //define pin modes
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, INPUT);
}

void loop() {

  //Pulse the latch pin:
  //set it to 1 to collect parallel data
  digitalWrite(latchPin,1);
  //set it to 1 to collect parallel data, wait
  delayMicroseconds(20);
  //set it to 0 to transmit data serially 
  digitalWrite(latchPin,0);

  //while the shift register is in serial mode
  //collect each shift register into a byte
  //the register attached to the chip comes in first
  switchVar1 = shiftIn(dataPin, clockPin);
 // switchVar2 = shiftIn(dataPin, clockPin);
 
  for (int vers = 0; vers < 2; vers++){ //Für was ist die Zählschleife da?
  digitalWrite(latchPin, LOW);
  shiftOut(switchVar1, clockPin, MSBFIRST, vers);
  digitalWrite(latchPin, HIGH);
}
 
 

  //Print out the results.
  //leading 0's at the top of the byte
  //(7, 6, 5, etc) will be dropped before
  //the first pin that has a high input
  //reading 
  Serial.println(switchVar1, BIN);
  //Serial.println(switchVar2, BIN);

//white space
Serial.println("-------------------");
//delay so all these print satements can keep up.
delay(500);

}

//------------------------------------------------end main loop

////// ----------------------------------------shiftIn function
///// just needs the location of the data pin and the clock pin
///// it returns a byte with each bit in the byte corresponding
///// to a pin on the shift register. leftBit 7 = Pin 7 / Bit 0= Pin 0

byte shiftIn(int myDataPin, int myClockPin) {
  int i;
  int temp = 0;
  int pinState;
  byte myDataIn = 0;

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

//we will be holding the clock pin high 8 times (0,..,7) at the
//end of each time through the for loop

//at the begining of each loop when we set the clock low, it will
//be doing the necessary low to high drop to cause the shift
//register's DataPin to change state based on the value
//of the next bit in its serial information flow.
//The register transmits the information about the pins from pin 7 to pin 0
//so that is why our function counts down
  for (i=7; i>=0; i--)
  {
    digitalWrite(myClockPin, 0);
    delayMicroseconds(2);
    temp = digitalRead(myDataPin);
    if (temp) {
      pinState = 1;
      //set the bit to 0 no matter what
      myDataIn = myDataIn | (1 << i);
    }
    else {
      //turn it off -- only necessary for debuging
     //print statement since myDataIn starts as 0
      pinState = 0;
    }

    //Debuging print statements
    //Serial.print(pinState);
    //Serial.print("     ");
    //Serial.println (dataIn, BIN);

    digitalWrite(myClockPin, 1);

  }
  //debuging print statements whitespace
  //Serial.println();
  //Serial.println(myDataIn, BIN);
  return myDataIn;
}
5  International / Deutsch / Problem shiftin und shift out on: February 02, 2011, 07:27:39 am
Hallo,


meine Aufgabenstellung sieht folgendes vor. Ich muss digitale Eingänge einlesen (Taster) und nutze, um Arduino Eingänge zu sparen das 4021 BE Schieberegister. Mit diesem kann ich ins Arduino den Zustand der Taster (8 Stück) einlesen und über Serialprint anzeigen. Das funktioniert einwandfrei.

Nun will ich das Byte seriell->parallel wandeln und habe dazu einen 74HC164 eingesetzt. Hat damit schon jemand experimentiert?
Weise ich der shiftOut funktion einfach das Byte zu so z.B. --> shiftOut(switchVar1, clockPin, latchPin, MSBFIRST, bits)?
Kann ich den Clockpin und den Latchpin des Eingangsregisters für das 74HC164 nutzen?

Ich habe den Code vom Arduino Tut genommen und das shiftout eingefügt, jedoch fällt mir nun nichts mehr ein was ich machen kann.

Ich danke euch im Voraus.

Grüße
Pages: [1]