<aside> <img src="/icons/movie_pink.svg" alt="/icons/movie_pink.svg" width="40px" /> Början av denna anteckning var utförd på plats, resterande gjordes hemifrån med slides och videor samt kunskap från boken - då jag inte kunde närvara när föreläsningen fortsattes

</aside>

Bifogat

Anki-kort

Videor använda

Snabbanteckningar

Länkprotokoll

• Det krävs regler för att mottagaren skall kunna tolka datan
• Länkprotokollets uppgifter
  • Framing

    • Man kan exempelvis använda flaggor

      • Symboler (bitsekvenser) som ramar in paket

        

    • Bitstuffing (bitutfyllnad)

      • Man tillsätter bitar för att avbryta sekvenser av 1or

        • Dessa bitar tas bort av mottagaren

          • Hur den gör detta definieras i protokollet

          

Feldetektering

Under transmission av data kan bitfel uppstå, vi måste kunna detektera när detta skett, vilket vi kan göra på flera sätt.

• I OSI-modellen hanteras feldetektering i datalagret eller transportlagret
• Typer av fel
  • Bit error (bitfel)
    • Ett enstaka bit har blivit fel i ett segment (exempelvis ett paket)
  • Burst error
    • Flera bitar har blivit fel i ett segment
    • Längden är sträckan mellan första och sista felet
• Sätt att feldetektera

  • Typiskt sett är det mottagaren som bestämmer om meddelandet har blivit korrupterat

    • För att den ska på något sätt ska veta detta skickar vi med data som berättar om karaktären av datan. Dessa kallas redundant bits

      

      • Om dessa redudant bits matchar villkoret satt av metoden/protokollet som använts så accepterar mottagaren paketet

  • Metoder

    CRC och Checksum är vanligast i protokoll, så lägg mest åtanke åt dem

    • Paritetsbit (Simple Parity-Check Code)

      • Vi sänder en bit som berättar om det finns ett jämnt antal ettor (då är pariteten 0) eller ojämnt antal (1)
        • Nackdelen är att om det tycker upp en burst error med jämnt antal fel, så kommer det finnas chans att vi fortfarande får paritet i slutändan
          • D.v.s. om två ettor försvinner eller tillsätts kommer vi fortfarande få ett jämnt antal ettor

    • Cyclic Redundancy Check (CRC)

      • Man kan se metoden ovan med paritetsbit som en implementation av CRC, med bara en paritetsbit
      • Annars är CRC ungefär samma, fast med flera paritetsbitar
      • Man använder polynomdivision samt generatorpolynom, bl.a. för att kolla om kodordet stämmer

        • Hur detta faktiskt sker till är inte riktigt viktigt för kursen och jag kommer välja att lägga mycket vikt i det eftersom jag inte förstår det så väl

          • Det är dock en fortsättning på et begrepp från Digitaltekniken, så om ni forstod det där kommer ni förstå det nu

        • Polynomet M(x) bildas av sekvensen

          

          • Vi dividerar denna (gånger graden av generatorpolynomet) med generatorpolynomet genom polynomdivision (ex. liggande stolen)
            • Eftersom det är Modulo-2 aritmetik så kan vi säga att + är samma som -
            • Resten blir del av kodordet, där den sätts ihop med M(x)

          

          

    • Checksum

      • Man summerar alla segment med en s.k. kontrollsumma (checksum), som i sig är komplementet av summan av segmenten som skickas tillsammans med dem
        • Om summan av segmenten adderat med kontrollsumman (som bör vara dess invers fortfarande) är 0 så antar vi att segmenten kommit fram utan bitfel

    • Vertical Redundancy Check (VRC)

      • Utanför kursinnehållet, iallafall så här långt, men tänkte jag skrev ner den ändå

    • Longitudinal Redundancy Check (LRC)

      • Hittils orelevant

Felhantering

När vi upptäcker fel så måste vi kunna skicka datan igen. Detta gör vi i regel genom att skicka ACK (acknowledgement signaler)

• Sätt att fånga fel
  • NAK
    • Negative acknowledgement
    • Mottagaren skickar en signal då segmentet gått förlorad med indexet (sekvensnumret) av detta segment
  • Time-out
    • Om vi inte fått ACK inom en viss tid skickar vi segmentet igen
• Flera sätt att lösa
  • Vi skickar hela paketet igen
    • Flödeskontroll
      • Olika sätt att skicka paket
        • Exempelvis
          • Stop-and-wait
          • Sliding Window
    • Automatic Repeat Request (ARQ) algoritmer

      • Stop-and-Wait

        • Ett paket skickas en åt gången, man väntar på acknowledgement (ACK) och om man inte får det inom en viss tid (time-out) så skickar man igen

          • Som nämnt i första föreläsningen är detta ett väldigt långsamt sätt att hantera det, då man bland annat inte får reda på något förrän hela paketet skickats, vilket gör att tidsförlusten växer i takt med storleken av paketet

            F01W01: Introduktion

          • Man låter paketet sitta kvar i buffern hos sändaren tills den är färdigskickad

            

      • Go-Back-N

        • Flera paket skickas åt gången, i en s.k. sliding window (sändfönster)

          

          • Man skickar N antal paket, med start i index X
          • Om ett paket i index X misslyckas skickas fönstret om med med början i X

      • Selective Repeat

      • Selective Reject

  • Algoritmer som löser felen åt oss, exempelvis Forward Error Correction (FEC) (ligger utanför denna kursen)