Steuerung des Relais-Addierers mit einem alten Tintenstrahler + Arduino
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

199 lines
5.6KB

  1. /*
  2. Es gibt 6 Positionen die vom Druckkopf angefahren werden müssen.
  3. für jede Position 1-6 wird in einem Array die genaue Position angegeben.
  4. boundRight wird durch eine Zahl im Array ersetzt.
  5. Wird diese Position erreicht stoppt der Kopf und das
  6. Programm Schalter umlegen wird aufgerufen.
  7. Der Zähler wird auf die nächste Position gesetzt und der Druckkopf wieder gestartet
  8. Hat der Kopf die letzte Position erreicht wird der Druckkopf zur Ausgangsposition
  9. zurückgefahren und die Position bei erreichen der Lichtschranke auf 0 gesetzt.
  10. Damit beim Umlegen der Schalter die richtige Bewegung ausgeführt wird müssen
  11. die Positionen aller Schalter bekannt sein
  12. (Alternativ wird die Position durch ein LDR vor der jeweiligen Statuslampe oder
  13. einem elektrischen Kontakt am Hebel ermittelt)
  14. Welche Schalter umgelegt werden wird über ein Array Schalter 2*6 über die Serielle
  15. Verbindung übertragen. Wenn in Arduino keine 2D Arrays möglich sind wird ein 1D Array
  16. mit doppelter Länge gewählt. (Ist auch einfacher für die Datenübertragung)
  17. Der Abgleich der Position wird aus dem ArraySchalter ermittelt
  18. ArraySchalter ( position 1 ) wenn einer der beiden Werte 1 ist wird die Position (1)
  19. an das Array Position über geben um in einen Wert für die Position umgerechnet
  20. Bsp 1 = 254.
  21. Nach Umlegen der Schalter wird der Zähler hochgesetzt bis eine Spalte im Array erreicht wird
  22. deren Wert nicht 0 ist.
  23. Initialisierung zur Positionsbestimmung?
  24. */
  25. int in1 = 9; //Motortreiber Pins
  26. int in2 = 10;
  27. const int servo1 = 4; // Steuerpins Servos
  28. const int servo2 = 5;
  29. int servoStart = 127; //Ruheposition Servos
  30. int down = 255;
  31. int up = 0;
  32. int servoT = 300; //Schaltzeit für Servos
  33. int velo = 33; //Kopfgeschwindigkeit
  34. volatile int pos = 0; //Zähler Positionssensor Kopf
  35. int NrSchalter = 0; // Spalte Schalter
  36. byte ArraySchalter[12];
  37. byte ArraySchalteralt[12];
  38. int ArrayPosition[6];
  39. const int boundLeft = 0;
  40. int boundRight = 200;
  41. const byte sigPin = 3; // Pins Zähler Positionssensor Kopf
  42. const byte interruptPin = 2;
  43. volatile byte interruptPinChanged = 0;
  44. int spos = 0;
  45. byte readarr[11];
  46. volatile bool inputflag = true; //Freigabe für neue Eingabe
  47. void setup () {
  48. pinMode(in1, OUTPUT);
  49. pinMode(in2, OUTPUT);
  50. attachInterrupt(0, interruptPositionUpdate, RISING);
  51. Serial.begin(19200);
  52. updateboundRight();
  53. flipswitch();
  54. }
  55. void loop() {
  56. if(interruptPinChanged) {
  57. interruptPinChanged = 0;
  58. Serial.println(pos);
  59. if(pos <= boundLeft) {
  60. Serial.println("Start Position reached");// und warten auf neue Eingabe durch Nutzer
  61. digitalWrite(in1, LOW);
  62. digitalWrite(in2, LOW);
  63. inputflag = true; //
  64. } else if (pos >= boundRight) {
  65. Serial.println("Position reached");//Motor anhalten und Schalterprogramm ausführen
  66. digitalWrite(in1, LOW);
  67. digitalWrite(in2, LOW);
  68. flipswitch();
  69. } else {
  70. }
  71. }
  72. }
  73. void interruptPositionUpdate() {
  74. interruptPinChanged = 1;
  75. if(digitalRead(sigPin))
  76. pos--;
  77. else
  78. pos++;
  79. }
  80. void updateboundRight() {
  81. /*
  82. Es wird bestimmt welche Position als nächstes angefahren wird.
  83. Dann wird der Kopf wieder gestartet
  84. */
  85. while(!(ArraySchalter[NrSchalter]&&ArraySchalter[NrSchalter+6])){
  86. NrSchalter++; // Überspringen leerer Spalten
  87. }
  88. if(NrSchalter==7){
  89. NrSchalter=0;
  90. analogWrite(in1, LOW); //Kopf geht nach links
  91. digitalWrite(in2, velo);
  92. //Warteposition anfahren und Positionsvariable pos bei erreichen der
  93. //Lichtschranke auf 0 setzen
  94. }
  95. else{
  96. boundRight=ArrayPosition[NrSchalter];
  97. NrSchalter++;
  98. analogWrite(in1, velo); //Kopf geht nach rechts
  99. digitalWrite(in2, LOW);
  100. }
  101. }
  102. void flipswitch(){
  103. /*
  104. Über Array Schalter wird entschieden welcher Schalter betätigt wird
  105. aus ArraySchalteralt wird ermittelt in welche Richtung der Servo
  106. den Schalter umlegen muss.
  107. Danach wird updateboundRight ausgeführt und die nächste Kopfposition bestimmt.
  108. Die Servos sind in Mittelstellung analogWrite(127) von dort dann ca 45°
  109. nach oben oder unten und wieder in Ausgangsstellung.
  110. Genaue Servopositionen sind dabei noch abhängig der Einbauposition zu ermitteln.
  111. */
  112. if(ArraySchalter[NrSchalter]){//Schalterreihe oben servo 1
  113. if(ArraySchalteralt[NrSchalter]){
  114. //Schalter nach unten kippen
  115. analogWrite (servo1, down);
  116. delay(servoT);
  117. }
  118. else{
  119. //Schalter nach oben kippen
  120. analogWrite (servo1, up);
  121. delay(servoT);
  122. }
  123. analogWrite (servo1, servoStart);
  124. delay(servoT);
  125. digitalWrite (servo1 ,LOW);
  126. }
  127. if(ArraySchalter[NrSchalter+6]){//Schalterreihe unten servo 2
  128. if(ArraySchalteralt[NrSchalter]){
  129. //Schalter nach unten kippen
  130. analogWrite (servo2, down);
  131. delay(servoT);
  132. }
  133. else{
  134. //Schalter nach oben kippen
  135. analogWrite (servo2, up);
  136. delay(servoT);
  137. }
  138. analogWrite (servo2, servoStart);
  139. delay(servoT);
  140. digitalWrite (servo2 ,LOW);
  141. }
  142. updateboundRight();
  143. }
  144. void serialEvent(){
  145. /*
  146. Wenn eine Eingabe abgearbeitet wurde inputflag=1 wird der Controller frei für die
  147. nächste Eingabe. Vorherige Eingaben werden somit verworfen. Die Eingabe wird aus
  148. dem EingabeArray in ArraySchalter geschrieben und der Kopf nach rechts gestartet.
  149. */
  150. while (Serial.available()) {
  151. // get the new byte:
  152. byte inChar = Serial.read();
  153. if (inChar == 'A') {
  154. spos = 0;
  155. continue;
  156. }
  157. if (inChar != 'E' && spos < 11) {
  158. readarr[spos] = inChar;
  159. spos++;
  160. }
  161. else {
  162. if (inChar == 'E') {
  163. int posi = 0;
  164. if ( inputflag ) {
  165. // TODO:
  166. // ArraySchalter fuellen
  167. } // else: discard input
  168. }
  169. }
  170. }
  171. }