‫בס"ד‬

‫תרגול כתה ‪13‬‬
‫נכון‪ /‬לא נכון‬
‫‪ B0‬ו‪ B1 -‬נותנים תמיד את אותו הקידוד‪.‬‬
‫לא נכון‪ .‬דוגמא נגדית‪:‬‬
‫ניקח את מילת האינפורמציה ‪000‬‬
‫מועד ב'‪ -‬תשס"ד‪:‬‬

‫מועד א ‪:2004‬‬

‫בעיה ‪(25%) 2‬‬

‫נתונות קבוצות המילים ‪ Wi‬ביציאת מכונת המצבים‪:‬‬
‫;}‪W1= {00000, 11111‬‬
‫;}‪W2= {00011, 00110, 01010, 01101, 10010, 10101, 11001, 11100‬‬
‫‪W3= {00001, 00010, 00100, 01000, 10000, 00000, 11110, 11101, 11011,‬‬
‫;}‪10111, 01111, 11111‬‬
‫‪W4= {00001, 00110, 11000, 11111}.‬‬
‫א()‪ ( 10%‬סמנו בטבלה ‪) 2‬ב‪ (V -‬באלו מקבוצות המלים ניתן לגלות מבלי‬
‫לקודד מחדש‪:‬‬
‫‪.1‬‬

‫שגיאה בביט אחד‬

‫‪.2‬‬

‫שגיאה בשני ביטים ) כל שהם (‬

‫‪.3‬‬

‫שגיאות חד כיווניות ) ‪ ( unidirectional errors‬של מספר שרירותי של‬
‫ביטים‪.‬‬
‫‪Table 2‬‬

‫שגיאות חד‬
‫כיווניות‬

‫שגיאה בשני‬
‫ביטים‬

‫שגיאה בביט‬
‫אחד‬

‫‪+‬‬

‫‪+‬‬

‫‪W1‬‬

‫‪+‬‬

‫‪W2‬‬

‫‪+‬‬

‫‪W3‬‬
‫‪+‬‬

‫‪+‬‬

‫‪W4‬‬

‫ב( )‪ (15%‬לקבוצות בהן ניתן לגלות שגיאות חד כיווניות‪ ,‬בנו בודקים )‪(checkers‬‬

‫‪Full‬‬
‫‪adder c‬‬

‫‪x1‬‬
‫‪x2‬‬
‫‪x3‬‬

‫‪s‬‬

‫‪x4‬‬

‫‪x5‬‬

‫אפשרות נוספת‪:‬‬
‫‪:SOM checker‬‬
‫זהו מעגל בדיקה שניתן להשתמש בו עבור ‪ 0B‬וגם עבור סמית‪ ,‬הוא ‪:SOM‬‬
‫מחלקים את מילות האינפורמציה החוקיות לשתי קבוצות‪ .‬בכל פעם מתקבלת רק מילה אחת‪.‬‬

‫אם המוצא הוא ‪ 10‬או ‪ 01‬אזי המצב תקין‪ ,‬אם המוצא הוא ‪ ,00‬אזי לא קיבלנו שום מילה חוקית‪,‬‬
‫כלומר קיבלנו מילת שגיאה‪ .‬מוצא ‪ 11‬לא אפשרי ומעיד על בעיה בבודק‪.‬‬

‫מועד א'‪:2011 -‬‬

‫את הטבלה אפשר למלא על ידי מעקב אחרי המעגל או על ידי כתיבת המשוואות של המוצאים‪:‬‬
‫‪f3‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬

‫‪f2‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬

‫‪f1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬

‫‪d‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬

‫‪c‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬

‫‪b‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬

‫‪a‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬

‫‪f1 = bd + ab‬‬
‫‪f 2 = ab + c + bcd = ab + c‬‬
‫‪f 3 = a + bcd‬‬
‫לכן אוסף המילים היכולות להופיע במוצא המערכת הוא }‪{000, 010,100,111, 001, 011‬‬
‫המילים שאינן בקוד הן }‪{101,110‬‬

‫ניקח ‪ a = 0, b = 0, c = 1, d = 0‬למשל‪.‬‬
‫אם קרתה התקלה המתוארת‪ f 2 ,‬ייתן ‪ 0‬במקום ‪.1‬‬

‫הגדרה‪ :‬מערכת היא ‪ fault secure‬אם כאשר חלה שגיאה בהכרח המוצא יחזיר מילה לא חוקית או‬
‫את המילה הנכונה‪) .‬לא ימופה למילה חוקית אחרת(‬
‫המערכת הזו אינה ‪ ,fault secure‬למשל אם המילה מקורית הייתה ‪ a = 1, b = 0, c = 0, d = 0‬ושער‬
‫‪ 8‬נתקע על ‪ 0‬אזי נקבל במוצא ‪ 000‬במקום ‪001‬‬

‫הגדרה‪:‬‬
‫המערכת היא ‪ self-testing‬אם לכל שגיאה קיימת לכל הפחות כניסה אחת שתגלה אותה ותחזיר‬
‫מילה שאינה מילת קוד‬
‫הגדרה‪ -totally self checking :‬מקיים את שתי הדרישות )כלומר או שהשגיאה תזוהה או שלא‬
‫תגרום נזק(‬
‫המערכת אינה ‪:self-testing‬‬
‫אם חלה שגיאה של ‪ stuck at 1‬בשער ‪ 6‬אזי ערכי המוצאים ‪ f2,f3‬יהיו תמיד ‪ 1‬לכן תמיד תתקבל או‬
‫המילה ‪ 111‬או המילה ‪ 011‬ששתיהן חוקיות‪.‬‬

‫מועד ב‪:2010-‬‬

‫עבור קוד ברגר‪ 1‬נזדקק ל ‪ log 2 (3 + 1) = 2‬ביטי יתירות‪.‬‬
‫‪b1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬

‫‪b2‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬

‫‪y1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬
‫‪1‬‬
‫‪0‬‬

‫‪y2‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬

‫‪y3‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪1‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬
‫‪0‬‬

‫‪digit‬‬
‫‪0‬‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪5‬‬
‫‪6‬‬
‫‪7‬‬

‫‪Y3‬‬
‫‪adder‬‬

‫‪Y2‬‬
‫‪Y1‬‬
‫‪B2‬‬

‫‪B1‬‬

‫ניקח לדוגמא את המילה ‪11100‬‬

‫ומוצאים הפוכים זה לזה אכן מעידים על מצב תקין‪.‬‬

‫נניח שחלה שגיאה בביט ‪ y2‬למשל כתוצאה מ‪:stuck at 0‬‬

‫הצ'קר מוציא ‪ 00‬וזה אכן מעיד על כך שקרה כשל‪.‬‬

‫‪ Berger cheker‬הוא ‪) )fault secure‬עבור שגיאה או מספר שגיאות חד כיווניות או ‪ stuck at‬יחיד‪ (.‬ולכן‬
‫בהנתן שחלה תקלה‪ ,‬לא נמופה למילת קוד חוקית שאינה המילה הנכונה!‬

‫כמות הביטים הכי קטנה שאפשר להוסיף היא ‪ .1‬ידוע שהוספת ביט זוגיות יכולה לגלות רק שגיאות‬
‫במשקל אי זוגי‪ .‬במקרה שלנו‪ ,‬המשקל של השגיאה יכול להיות רק ‪ ,1‬לכן ביט זוגיות יחיד יגלה תמיד‬
‫כשל מסוג זה‪.‬‬