חיווי, תצוגה וממשק אדם-מכונה

חיווי, התרעה ונוריות חיווי (Indication, Alarm, Indicator Lamps)

אמצעי החיווי הפשוט ביותר הוא נורית חיווי: בלוח החשמל זו נורה במתח 24 V, ובמערכת עם בקר זו דיודה פולטת אור (LED) עם נגד על הדק ספרתי. כדי שכל אדם יבין כל צבע באותה משמעות בכל מכונה, התקן IEC 60204-1 (בטיחות חשמלית של מכונות) קובע את המשמעות של כל צבע:

מפעיל המכונה הוא האדם שעובד עליה ומפעיל אותה. אין לבלבל בינו לבין מפעיל במובן של רכיב (מנוע או שסתום), ולכן כשמדובר באדם נכתוב תמיד "מפעיל המכונה". התקן קובע גם את צבעי הלחצנים: לחצן עצירת חירום אדום על רקע צהוב, לחצן ההפעלה אינו אדום, ולחצן ההפסקה אינו ירוק.

נורית שדולקת באור קבוע מתארת מצב. לעומת זאת הבהוב משמש לפי IEC 60204-1 למשיכת תשומת הלב ולדרישה לפעולה מיידית, וגם לציון הבדל בין הפקודה לבין המצב בפועל (פקדנו על השסתום להיפתח והוא עדיין לא נפתח). מידע בעדיפות גבוהה יותר מהבהב מהר יותר. בפרק הזה נאמץ את הכלל המקובל בתעשייה: אדום מהבהב עם זמזם = התרעה חדשה, אדום קבוע = האדם אישר אותה והמצב עדיין קיים, כבוי = המצב חלף.

זמזם ודפוס התרעה (Buzzer and Alarm Pattern)

למשל הזמזם האקטיבי TMB12A05: 5 V, עד 30 mA, כ-2300 Hz (ערך טיפוסי לפי גיליון הנתונים). הפונקציה tone() מוציאה גל ריבועי שמחזור העבודה שלו 50 % וזמן המחזור שלו T_p = 1f, עד שנקרא ל-noTone(). לפי התיעוד של Arduino: רק צליל אחד בכל רגע, לא פחות מ-31 Hz, וב-Uno היא משבשת את אפנון רוחב הפולס בהדקים 3 ו-11. הזרם 30 mA גבוה מן המומלץ להדק, ולכן נפעיל את הזמזם דרך טרנזיסטור כמפסק עם נגד בסיס 1 kΩ (פרק 10). בזמזם המגנטי יש סליל, ולכן נוסיף לו דיודת חופש.

דפוס התרעה שאינו עוצר את התוכנית. אילו כתבנו את ההבהוב בעזרת delay(250), התוכנית הייתה נעצרת בכל פעם, ולא הייתה רואה את הלחיצה על לחצן האישור בזמן. במקום זאת נחשב את מצב ההבהוב מן השעון: השארית millis() % 500 חוזרת על עצמה כל 500 ms, והיא קטנה מ-250 במחצית מן הזמן. הלולאה רצה אלפי פעמים בשנייה ורואה כל לחצן מיד.

const int SENSOR = A0;                    // LM35: 10 mV per degree C
const int GREEN_LED = 5, YELLOW_LED = 6, RED_LED = 7;
const int BUZZER = 9, ACK_BTN = 2;        // buzzer via NPN, button to GND
const float T_WARN = 45.0, T_ALARM = 50.0;

bool alarmOn = false, acked = false, buzzing = false;
float t = 0;
unsigned long tRead = 0;

void setup() {
  Serial.begin(9600);
  for (int p = 5; p <= 7; p++) pinMode(p, OUTPUT);   // three lamps
  pinMode(ACK_BTN, INPUT_PULLUP);
}

void loop() {
  unsigned long now = millis();
  if (now - tRead >= 1000) {              // one reading per second
    tRead = now;
    t = analogRead(SENSOR) * 500.0 / 1023.0;
    if (t >= T_ALARM && !alarmOn) { alarmOn = true; acked = false; }
    if (t < T_ALARM && acked) alarmOn = false;
    Serial.print("T = "); Serial.print(t, 1);
    if (!alarmOn) Serial.println(t < T_WARN ? "  GREEN" : "  YELLOW");
    else Serial.println(acked ? "  RED steady" : "  RED flashing + beep");
  }
  if (alarmOn && digitalRead(ACK_BTN) == LOW) acked = true;
  bool blink = (now % 500) < 250;         // 2 Hz, 50 %
  digitalWrite(GREEN_LED, !alarmOn && t < T_WARN);
  digitalWrite(YELLOW_LED, !alarmOn && t >= T_WARN);
  digitalWrite(RED_LED, alarmOn && (acked || blink));
  bool beep = alarmOn && !acked && blink;
  if (beep != buzzing) {                  // call tone() only on a change
    buzzing = beep;
    if (beep) tone(BUZZER, 2000); else noTone(BUZZER);
  }
}

נחמם את החיישן ואחר כך ניתן לו להתקרר. הטמפרטורה האמיתית בכל שנייה (°C): 41, 44, 46, 48, 51, 53, 54, 52, 49, 47, 44, ונלחץ על לחצן האישור ב-t = 7.4 s. הקריאה עוברת דרך הממיר התקבילי-ספרתי, ולכן היא שונה מעט מן האמיתית:

T = 40.6  GREEN
T = 44.0  GREEN
T = 45.9  YELLOW
T = 47.9  YELLOW
T = 50.8  RED flashing + beep
T = 52.8  RED flashing + beep
T = 53.8  RED flashing + beep
T = 51.8  RED steady
T = 48.9  YELLOW
T = 46.9  YELLOW
T = 44.0  GREEN

תצוגת שבעה מקטעים (Seven-Segment Display)

בתצוגה עם קתודה משותפת (CC) נחבר את COM לאדמה, והמקטע נדלק ב-HIGH; בתצוגה עם אנודה משותפת (CA) נחבר את COM ל-5 V, והמקטע נדלק ב-LOW (למשל 5161AS היא בעלת קתודה משותפת ו-5161BS בעלת אנודה משותפת). לכל ספרה נכתוב בית: סיבית 0 למקטע a … סיבית 6 למקטע g, ו-1 = דולק בקתודה משותפת. באנודה משותפת נהפוך את שבע הסיביות:

לכל מקטע נגד משלו: נגד אחד ב-COM היה גורם לספרה 1 להיות בהירה ולספרה 8 להיות עמומה. עם V_F ≈ 2 V (ערך טיפוסי לפי גיליון הנתונים ל-LED אדום) זרם המקטע הוא I = 5 − 2330 ≈ 9.1 mA. בתוכנית, bitRead(x, i) קוראת את הסיבית i, והביטוי on != COMMON_ANODE הופך את הלוגיקה: לאנודה משותפת משנים שורה אחת, COMMON_ANODE = true.

const int SEG_PIN[7] = {2, 3, 4, 5, 6, 7, 8};   // segments a..g
const bool COMMON_ANODE = false;                // 5161AS: common cathode
// bit 0 = a ... bit 6 = g ; 1 = segment lit
const byte DIGIT[10] = {0x3F, 0x06, 0x5B, 0x4F, 0x66,
                        0x6D, 0x7D, 0x07, 0x7F, 0x6F};

void showDigit(int d) {
  for (int i = 0; i < 7; i++) {
    bool on = bitRead(DIGIT[d], i);
    digitalWrite(SEG_PIN[i], on != COMMON_ANODE);  // anode: lit = LOW
  }
}

void setup() {
  for (int i = 0; i < 7; i++) pinMode(SEG_PIN[i], OUTPUT);
}

void loop() {
  for (int d = 0; d < 10; d++) {
    showDigit(d);
    delay(1000);
  }
}

לארבע ספרות נצטרך 7 + 4 = 11 הדקים במקום 28. הדק ה-COM של כל ספרה עובר דרך טרנזיסטור: הזרם של הספרה 8 הוא 7·9.09 ≈ 63.6 mA, יותר מ-40 mA, הגבול המרבי המוחלט להדק של Uno.

למשל, בתצוגה של ארבע ספרות שבה כל ספרה דולקת 4 ms, כל ספרה חוזרת אחרי 4·4 = 16 ms, כלומר כ-62.5 פעמים בשנייה: מהר יותר ממה שהעין מבחינה, ולכן לא נראה ריצוד. אבל כל ספרה דולקת רק רבע מן הזמן, ולכן היא נראית עמומה יותר מהדלקה קבועה. בתוכנית אמיתית נעבור לספרה הבאה בעזרת millis() ולא בעזרת delay(), או נשתמש בשבב סריקה מוכן כמו MAX7219.

צג גביש נוזלי 16×2 באפיק I2C (Character LCD over I2C)

מאחורי הצג יש כרטיס עם השבב PCF8574, ולכן מספיקים ארבעה חוטים: ההזנה, האדמה ואפיק I2C — שני חוטים בלבד, SDA לנתונים ו-SCL לשעון, שכמה רכיבים חולקים וכל אחד מהם עם כתובת משלו; ב-Uno SDA הוא A4 ו-SCL הוא A5. הכתובת של הכרטיס היא 0x27 עם PCF8574 ו-0x3F עם PCF8574A (ערך טיפוסי לפי גיליון הנתונים). הפקודות: init(), backlight() לתאורה, setCursor(c, r) לעמודה c ולשורה r (הספירה מ-0), ו-print().

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

const int SENSOR = A0;                // LM35: 10 mV per degree C
const float SET_POINT = 30.0;         // [C]
LiquidCrystal_I2C lcd(0x27, 16, 2);   // 0x3F on some modules

void setup() {
  lcd.init();
  lcd.backlight();
}

void loop() {
  float t = analogRead(SENSOR) * 500.0 / 1023.0;
  bool heat = t < SET_POINT;          // heater demand
  lcd.setCursor(0, 0);                // column 0, row 0
  lcd.print("T  = "); lcd.print(t, 1);
  lcd.print((char)223); lcd.print("C    ");   // 223 = degree sign
  lcd.setCursor(0, 1);
  lcd.print("SP = "); lcd.print(SET_POINT, 1);
  lcd.print((char)223); lcd.print(heat ? "C  ON " : "C  OFF");
  delay(500);
}

צג OLED גרפי 128×64 (Graphic OLED Display)

הנקודה (0, 0) נמצאת בפינה השמאלית העליונה; x גדל ימינה עד 127, ו-y גדל כלפי מטה עד 63. הספרייה Adafruit_SSD1306 (עם Adafruit_GFX) מציירת קודם בזיכרון של הבקר, ואחר כך שולחת את כל התמונה בעזרת display(). כל פיקסל הוא סיבית, ולכן התמונה תופסת 128·648 = 1024 בתים: מחצית מזיכרון ה-Uno (2048 בתים). הספרייה מקצה אותה בתוך begin(), ולכן היא אינה מופיעה בדוח ההידור, ואם לא נשאר מקום begin() מחזירה false.

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

const int SENSOR = A0;                      // potentiometer as a level sensor
Adafruit_SSD1306 oled(128, 64, &Wire, -1);  // -1: no reset pin

void setup() {
  if (!oled.begin(SSD1306_SWITCHCAPVCC, 0x3C))
    while (true) {}                         // no screen or no RAM: stop
}

void loop() {
  int pct = map(analogRead(SENSOR), 0, 1023, 0, 100);
  int w = map(pct, 0, 100, 0, 124);           // bar width [pixels]
  oled.clearDisplay();
  oled.setTextColor(SSD1306_WHITE);
  oled.setTextSize(1); oled.setCursor(0, 0);
  oled.print("TANK LEVEL");
  oled.setTextSize(2); oled.setCursor(0, 16);
  oled.print(pct); oled.print(" %");
  oled.drawRect(0, 40, 128, 20, SSD1306_WHITE);  // frame
  oled.fillRect(2, 42, w, 16, SSD1306_WHITE);    // bar
  oled.display();                           // send the buffer
  delay(200);
}

ממשק קטן: שלושה לחצנים וערך רצוי ב-EEPROM (Mini HMI with EEPROM)

בתרמוסטט, מפעיל המכונה רוצה לשנות את הערך הרצוי בלי מחשב, ושהערך יישמר גם אחרי הפסקת חשמל. נבנה ממשק בשלושה לחצנים, UP, DOWN, OK, נתאר תחילה את התנהגותו בתרשים מצבים, ואחר כך נכתוב ממנו את התוכנית:

• RUN: הצג מציג את הטמפרטורה ואת הערך הרצוי. OK עובר לעריכה.
• EDIT: UP ו-DOWN משנים עותק זמני, spEdit, בצעדים של 0.5 °C (הכוכבית ב-"SP*" מראה שמתבצעת עריכה), ו-OK שומר וחוזר.
• זמן קצוב: אם לא נלחץ דבר במשך 10 שניות חוזרים ל-RUN בלי שמירה: ערך שנשאר באמצע עריכה אינו נכנס לתהליך.

נשמור את הערך בעשיריות מעלה, כמספר שלם int (שני בתים): 25.5 °C נשמר כ-255. הפונקציה EEPROM.get() קוראת, ו-EEPROM.put() כותבת רק את הבתים שהשתנו. בזיכרון חדש הקריאה מחזירה −1, ולכן נבדוק את התחום ונציב ערך ברירת מחדל.

#include <Wire.h>
#include <EEPROM.h>
#include <LiquidCrystal_I2C.h>

const int BTN[3] = {2, 3, 4};             // UP, DOWN, OK (to GND)
const int SENSOR = A0, ADDR = 0;          // LM35 ; EEPROM address
const int SP_MIN = 100, SP_MAX = 600, STEP = 5;   // tenths of C
const unsigned long TIMEOUT = 10000;      // ms without a key
LiquidCrystal_I2C lcd(0x27, 16, 2);
int sp, spEdit;                           // set-point x 10: 255 = 25.5 C
bool editing = false;
unsigned long tKey = 0;
int last[3] = {HIGH, HIGH, HIGH};

bool pressed(int i) {                     // HIGH -> LOW edge
  int now = digitalRead(BTN[i]);
  bool edge = (last[i] == HIGH && now == LOW);
  last[i] = now;
  return edge;
}

void setup() {
  Serial.begin(9600);
  for (int i = 0; i < 3; i++) pinMode(BTN[i], INPUT_PULLUP);
  lcd.init(); lcd.backlight();
  EEPROM.get(ADDR, sp);
  if (sp < SP_MIN || sp > SP_MAX) sp = 250;   // new EEPROM reads -1
  Serial.print("SP from EEPROM = "); Serial.println(sp / 10.0, 1);
}

void loop() {
  bool up = pressed(0), down = pressed(1), ok = pressed(2);
  if (up || down || ok) tKey = millis();
  if (!editing) {
    if (ok) { editing = true; spEdit = sp; Serial.println("EDIT"); }
  } else {
    if (up)   spEdit = min(spEdit + STEP, SP_MAX);
    if (down) spEdit = max(spEdit - STEP, SP_MIN);
    if (up || down) {
      Serial.print("SP* = "); Serial.println(spEdit / 10.0, 1);
    }
    if (ok) {                             // save only on OK
      sp = spEdit; editing = false; EEPROM.put(ADDR, sp);
      Serial.print("SAVED SP = "); Serial.println(sp / 10.0, 1);
    } else if (millis() - tKey > TIMEOUT) {
      editing = false; Serial.println("TIMEOUT: no change");
    }
  }
  float t = analogRead(SENSOR) * 500.0 / 1023.0;
  lcd.setCursor(0, 0); lcd.print("T  = "); lcd.print(t, 1); lcd.print(" C  ");
  lcd.setCursor(0, 1); lcd.print(editing ? "SP*= " : "SP = ");
  lcd.print((editing ? spEdit : sp) / 10.0, 1); lcd.print("  ");
  delay(20);                              // 20 ms sampling: no bounce
}

נפעיל את הבקר בפעם הראשונה (EEPROM חדש) ונלחץ לפי הסדר: OK ‏← UP ‏← UP ‏← UP ‏← DOWN ‏← OK ‏← OK ‏← UP ‏← המתנה 11 s:

SP from EEPROM = 25.0
EDIT
SP* = 25.5
SP* = 26.0
SP* = 26.5
SP* = 26.0
SAVED SP = 26.0
EDIT
SP* = 26.5
TIMEOUT: no change

אחרי ניתוק ההזנה והחזרתה התוכנית מדפיסה "SP from EEPROM = 26.0": הערך נשמר. הלולאה ממתינה 20 ms בכל מחזור; זה ארוך מקפיצות המגע ולכן מספיק לסינון קפיצות, ועדיין מהיר מאוד לאדם.

ממשק אדם-מכונה וממשק מכונה-מכונה (HMI and M2M)

ממשק הוא הגבול שדרכו עובר מידע בין שני צדדים במערכת בקרה. נתאר אותו בארבע שאלות: מי הצדדים? איזה מידע עובר ובאיזה כיוון? באיזה אמצעי (חוטים, מתח, פרוטוקול)? ובאיזו מהירות ואמינות?

פנל HMI / מסך מגע תעשייתי הוא צג צבעוני בדלת של לוח החשמל, שמחובר ל-PLC. מוצג עליו ציור פשוט של המכונה שצבעיו משתנים עם המצב, לחצנים, ערכים רצויים ודף התרעות. מערכת SCADA – פיקוח ואיסוף נתונים היא תוכנה במחשב שבחדר הבקרה, שאוספת נתונים מבקרים רבים במפעל או בתחנות מרוחקות, מציגה אותם, שומרת עליהם תיעוד לאורך זמן, מנהלת את ההתרעות ושולחת פקודות. הבקרה המהירה נשארת ב-PLC: אם הרשת מתנתקת, המכונה ממשיכה לפעול באופן בטוח.

עקרונות תכנון ממשק:

1. בהירות ומשוב: כל מסך עונה על שאלה אחת, הערכים מוצגים עם היחידות שלהם (°C, bar), וכל לחיצה נראית או נשמעת.
2. צבעים עקביים: אדום לסכנה בלבד וירוק למצב תקין בלבד, בכל המסכים והנוריות. ולא נסתמך על הצבע לבדו: נוסיף טקסט או סמל, כי יש אנשים שאינם מבחינים בין אדום לירוק.
3. אישור פעולות מסוכנות: פקודה שעלולה לגרום נזק ("ריקון המיכל") דורשת שני צעדים: הפקודה, ואחריה "האם אתם בטוחים?". ועצירת חירום לעולם אינה על המסך: זה לחצן נפרד במעגל הבטיחות.
4. אישור התרעות: התרעה חדשה מהבהבת ונשמעת עד שמאשרים אותה, ומספרת מה קרה, איפה, ומה עושים. ומספר ההתרעות קטן ומדורג לפי עדיפויות: מאה התרעות בדקה — איש אינו קורא אותן.

סיכום נוסחאות הפרק:

מילון מונחים:

שאלות לתרגול: