תפריט ראשי ‹ חיישנים ‹ חיישן רטט

חיישן רטט SW-420

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

1. איך החיישן עובד?

📷 המודול

מודול חיישן רטט SW-420
הגליל הכחול הוא החיישן עצמו.

מה יש על הלוח

  • הגליל הכחול (SW-420): בתוכו קפיץ זעיר שנוגע במגע מתכתי. במנוחה המגע סגור. כשיש רטט, הקפיץ רועד ו"מתנתק" לרגע קצר.
  • השבב השחור (LM393): משווה שהופך את ה"ניתוקים" הקטנים לאות דיגיטלי נקי: 0 או 1.
  • הפוטנציומטר הכחול: כיוון רגישות, כלומר כמה חזק צריך להיות הרטט כדי שהחיישן יגיב.
  • שתי נוריות: POWER דולקת כשיש חשמל. DO דולקת כשאין רטט, וכבה לרגע כשמזוהה רטט.
הכלל החשוב: במנוחה היציאה DO נמצאת ב־LOW (0). כשיש רטט היא קופצת ל־HIGH (1) לרגעים קצרים. רטט חזק או ארוך יוצר הרבה "קפיצות" כאלה ברצף.

2. פירוט הפינים

פיןחיבור לארדואינותפקיד
VCC5Vמתח הזנה, 3.3V עד 5V
GNDGNDאדמה (מינוס)
DOD2 (או כל פין דיגיטלי)יציאה דיגיטלית: LOW = שקט, HIGH = רטט

ההדפסה על הלוח קטנה. סדר הפינים בדגם שבתמונה, משמאל לימין כשהפינים פונים אליכם, הוא DO, GND, VCC. תמיד כדאי לבדוק את הכיתוב על הלוח שלכם.

3. תרשים החיבורים

ARDUINO UNO 5VGNDD2D13 L SW-420 DOGNDVCC VCC → 5V GND → GND DO → D2
3 חוטים בלבד: אדום ל־5V, שחור ל־GND, כתום מ־DO ל־D2. הלד המובנה בפין 13 ישמש כנורית התראה.
לא להפוך בין VCC ל־GND, כי חיבור הפוך עלול לשרוף את השבב שעל המודול.

4. סימולציה

בחרו איזה קוד "רץ" על הארדואינו, ולחצו על "נקישה על השולחן". צפו מה קורה ביציאה DO, בנוריות, בלד של הארדואינו וב־Serial Monitor.

SW-420 LM393 DO POWER DO GND VCC
נורית DO במודול: דולקת
DO = LOW (0)
נקישות ברצף: 0
ARDUINO UNO L D2D13GND מהחיישן 220Ω
💡 הלד כבוי
אות היציאה DO לאורך הזמן: הרגע הנוכחי מימין
Serial Monitor 9600 baud
Knock = toggle LED

5. קודים לדוגמה

איך מזהים "נקישה"? נקישה אחת על השולחן גורמת לחיישן לתת כמה פולסים מהירים של HIGH, לאורך עשרות עד מאות מילי־שניות. לכן הקוד סופר נקישה חדשה רק אם לפניה היה שקט של לפחות 200ms (QUIET_MS). כך נקישה אחת נספרת פעם אחת בלבד.

קוד 1: נקישה מדליקה, נקישה שנייה מכבה

כל נקישה הופכת את מצב הלד: אם הוא כבוי, הוא נדלק, ואם הוא דולק, הוא כבה.

knock_toggle.ino
// קוד 1: נקישה אחת מדליקה את הלד, הנקישה הבאה מכבה אותו
const int VIB_PIN = 2;               // DO של חיישן הרטט
const int LED_PIN = 13;              // הלד (או הלד המובנה L)
const unsigned long QUIET_MS = 200;  // שקט מינימלי שמפריד בין נקישות

bool ledOn = false;                  // המצב הנוכחי של הלד
unsigned long lastPulse = 0;         // מתי נראה HIGH בפעם האחרונה

void setup() {
  pinMode(VIB_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  Serial.begin(9600);
  Serial.println("Knock = toggle LED");
}

void loop() {
  if (digitalRead(VIB_PIN) == HIGH) {      // יש רטט
    unsigned long now = millis();
    // נקישה חדשה נחשבת רק אם היה שקט לפניה,
    // כי נקישה אחת יוצרת כמה פולסים מהירים ברצף
    if (now - lastPulse > QUIET_MS) {
      ledOn = !ledOn;                      // הופכים את מצב הלד
      digitalWrite(LED_PIN, ledOn ? HIGH : LOW);
      Serial.println(ledOn ? "Knock -> LED ON" : "Knock -> LED OFF");
    }
    lastPulse = now;                       // כל פולס "מאריך" את אותה נקישה
  }
}

קוד 2: שלוש נקישות מדליקות, שתי נקישות מכבות

הקוד סופר נקישות רצופות. כשיש שנייה של שקט (SEQ_END_MS), הרצף נגמר והקוד בודק: 3 נקישות מדליקות את הלד, 2 נקישות מכבות אותו, וכל מספר אחר לא עושה כלום. כך הלד לא יידלק בטעות מרטט מקרי אחד.

knock_pattern.ino
// קוד 2: 3 נקישות רצופות מדליקות את הלד, 2 נקישות רצופות מכבות אותו
const int VIB_PIN = 2;                 // DO של חיישן הרטט
const int LED_PIN = 13;                // הלד (או הלד המובנה L)
const unsigned long QUIET_MS = 200;    // שקט שמפריד בין נקישות
const unsigned long SEQ_END_MS = 1000; // שקט ארוך שמסיים רצף נקישות

int knocks = 0;                        // כמה נקישות היו ברצף הנוכחי
unsigned long lastPulse = 0;           // מתי נראה HIGH בפעם האחרונה

void setup() {
  pinMode(VIB_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  Serial.begin(9600);
  Serial.println("3 knocks = ON, 2 knocks = OFF");
}

void loop() {
  unsigned long now = millis();

  // 1. זיהוי נקישות
  if (digitalRead(VIB_PIN) == HIGH) {
    if (now - lastPulse > QUIET_MS) {    // נקישה חדשה
      knocks++;
      Serial.print("Knock ");
      Serial.println(knocks);
    }
    lastPulse = now;
  }

  // 2. אחרי שקט של שנייה: הרצף הסתיים, בודקים כמה נקישות היו
  if (knocks > 0 && now - lastPulse > SEQ_END_MS) {
    if (knocks == 3) {
      digitalWrite(LED_PIN, HIGH);
      Serial.println("3 knocks -> LED ON");
    } else if (knocks == 2) {
      digitalWrite(LED_PIN, LOW);
      Serial.println("2 knocks -> LED OFF");
    } else {
      Serial.print(knocks);
      Serial.println(" knocks -> ignored");
    }
    knocks = 0;                          // מתחילים רצף חדש
  }
}

💡 אם נקישה אחת נספרת כשתיים, הגדילו את QUIET_MS, למשל ל־300. אם נקישות מהירות "מתאחדות" לאחת, הקטינו אותו.

טיפים

  1. כיוון רגישות: סובבו את הפוטנציומטר בעדינות עם מברג קטן, עד שהנורית DO נשארת דולקת במנוחה וכבה כשדופקים קלות על השולחן.
  2. החיישן לא מודד עוצמה: הוא רק אומר "יש" או "אין". כדי להעריך עוצמה סופרים כמה פעמים היה HIGH בפרק זמן קצר.
  3. הצמדה: חזקו את המודול היטב למשטח שבודקים, כמו דלת או קופסה, כדי שהרטט יעבור אליו.

חזרה לחיישנים