Vad ska man tänka på om man isolerar SPI genom optokopplare?

[Andax]

EDIT: Måste bara få fråga dig Micke_s om ADUM-IC:n. Är det av någon speciell anledning som du tycker jag ska välja 4-kanalers interfacet? Då jag bara behöver en kanal så ser jag ingen direkt skillnad i "performance" till den mindre 2-kanalers, i samma serie. ADUM1201

Ofta brukar spi ha typ 4 signaler:
CLK, MISO, MOSI och SS.
Alla dessa vill man ju isolera så därav fyra kanaler. Om man bara har data ut från en enhet minskar behovet med en kanal.

[Magnus_K]

Du kommer att få ta emot 16 bitar, en byte i taget och du hinner spara undan den höga byten (den första) i den vänstra halvan av en 16-bitars variabel som du deklarerat. När den lägre byten kommer, sparar du den i den högra halvan av din variabel och sen skiftar du allt ett steg till höger innan du vid behov slutligen AND:ar med 0xfff.

Det här var exakt det jag jag undrade, och har funderat på under låååååång tid. Jag har lagt till lite kommentarer i din kod och vore hemskt tacksam om ni vill se om dessa stämmer, så jag förstått precis vad som händer.

• val = BUF; Spara buffer-datan i val-variablen
  val <<= 8; Då den första byten som kommer är MSB:s så flyttar vi dessa 8 steg åt vänster och gör dessa de höga bits:en
  val |= BUF; Har sökt och läst om denna operand men förstår inte riktigt. Tror det fungerar som: val = spara val och lägg till BUF?
  val >>= 1; Skifta allt ett steg åt höger då sista/högra biten är skräp
  val &= 0xfff; Inte en aning men verkar som att man här placerar 1:or i de nedre 9 bitarna?

EDIT: Hmm nej, förstår inte detta fastän jag läst en del nu. Varför inte tex bara göra val = BUF; igen på tredje raden? Om BUF är 8 bitar så finns det väl ingen risk att man rör de 8 övre bitarna?

@Andax: Gud vad korkad jag känner mig nu...

[hanzibal]

Det stämmer bra, nästan alltihop.

Pipe-tecken är bitvis OR (plus hade också funkat här). Om du gjort en vanlig tilldelning hade du skrivit över hela variabeln och inte bara de nedre 8 bitarna.

Talet 0xfff har samtliga 12 nedre bitar satta så genom att maska (bitvis AND) med detta rensar man alltså de övre 4 för den eventualitet att det skulle finnas skräp där.

Tänk på att koden skall inte köras sammanhängande utan vid respektive interrupttillfälle.

[Micke_s]

Jo precis som andax skriver så brukar man vilja ha 4kanaler. 3kanaler har jag dessutom inte sett innan heller tror jag. 1, 2och 4 kanaler verkar vara standard...

[Magnus_K]

@hanzibal:
Ja just det! Och tack vare att vi skiftat en byte uppåt så är den nedre byte:n redan "rensad", dvs 0000 0000. Då går det bra med |= eller +=.
Om det hade varit risk för skräp-data där så hade vi först fått rensa den och sedan skriva?

Hänger inte med på 0xfff-biten än men jag ska inte ta mer tid från dig än jag redan gjort på att förklara detta. Nu har jag nog kött på benen för att grotta själv

Du ska ha en eloge för assistansen!

@Micke_s: Jo precis, det blir en 4-kanalers och kanske en 6:a beroende på om jag vill ha något mer isolerat. Förhoppningsvis hinner någon löpare till ELFA under veckan så jag kan koppla ihop och testa under helgen. Tack för tipset än en gång.

[hanzibal]

Ja just det! Och tack vare att vi skiftat en byte uppåt så är den nedre byte:n redan "rensad", dvs 0000 0000. Då går det bra med |= eller +=.
Om det hade varit risk för skräp-data där så hade vi först fått rensa den och sedan skriva?

Precis och ja, då hade man först "maskat av" de lägre 8 bitarna genom att AND:a med 0xff00 som är ett 16-bitars tal i hexadecimal notation med samtliga sina övre 8 bitar satta. Sen hade man OR:at in BUF.

Hänger inte med på 0xfff-biten än men jag ska inte ta mer tid från dig än jag redan gjort på att förklara detta. Nu har jag nog kött på benen för att grotta själv

Varje grupp om 4 bitar av ett tal (kallas "nibble") motsvarar, från vänster till höger 0xf000, 0x0f00, 0x00f0 och 0x000f i ett 16-bitars tal. Om du kombinerar (summera eller OR:a) de sista tre får du 0x0fff (eller kompaktare skrivet 0xfff) som alltså omfattar de tre lägsta nibblarna, dvs de lägsta 4 + 4 + 4 = 3 x 4 = 12 bitarna.

Testa t.ex. att mata in vart och ett av 0x0f00, 0x00f0 och 0x000f i miniräknaren i Hex-läget och växla till binärläge mellan varje så ser du vilka bitar som är satta i respektive fall.

[Magnus_K]

Lite svårt att skriva nu men varför vill man inte rensa alla 16 bitar istället för bara 12?

[sodjan]

Man vill rensa 4 högsta bitarna.
Resten (12 bitar) vill man så klart behålla...

[hanzibal]

Låt säga att du av någon anledning har värdet 32156 (0x7d9c) och endast vill behålla de nedre 12 bitarna av det - om du då ställer upp talen mot varandra och utför bitvis AND skulle det bli såhär:

Kod: Markera allt

0x7d9c = 0111 1101 1001 1100 
0x0fff = 0000 1111 1111 1111
----------------------------
0x0d9c = 0000 1101 1001 1100 

Som du ser ovan så nollades de övre 4 bitarna och kvar blev endast 3484 (0xd9c) och du ser också en av fördelarna med hexadecimal representation - det är kompakt och blir lättare att hålla ordning på bitarna.

[Magnus_K]

Å vad trög jag är. Man vill ju givetvis spara dom 12 bitarna som var hela syftet från början, även när jag lämnar interrupt-rutinen. Genom att AND:a med 0 på den högsta nibbeln så kommer denna bli just 0 och min variabel är ren från skräp.

Jag lyckas nog skruva till det i skallen med uttrycken "AND:a", "maskas av" och "rensa". Nu blev allt klart som korvspad!

Ja, tack än en gång för att du inte gav upp och orkade förklara det här om och om igen hanzibal. Du har i alla fall lyckats klargöra något för mig som jag undrat över i låååång tid!

[hanzibal]

Bara trevligt, ursäkta begreppsredundansen.

[Magnus_K]

Nu kommer ni sucka men det är bara en sak till jag undrar om det här ämnet:

Hur gör man om man vill skriva enstaka bitar till ett 8-bitars register, dvs ändra delar av en nibble?

Kod: Markera allt

Exempel 1:

Register A = 1010 10XX
De två LSB's vill jag ändra (XX).
Kan jag då först skifta två åt höger med >>2 sedan skifta tillbaka med <<2, därefter OR:a in de två sista bitarna på något sätt?

Kod: Markera allt

Exempel 2:

Register A = 10XX 1011
De två XX vill jag ändra.
Kan jag då först AND:a med 1100 1111 (0xcf) och sedan OR:a in de två bitarna på något sätt?

I båda exemplen ovan har jag en teori om att jag kan OR:a in mina två bitar genom att skapa en byte som ser ut tex som 1. 0000 0011 eller 2. 0011 0000 (om jag vill skriva 11 vill säga) men om det skulle vara sättet man verkligen gör det på vet jag inte.

[Icecap]

Jag brukar göra såhär:

A = byte där jag vill ändra ett par bit
B = byte med de bit jag vill ändra till

I C:
A &= 0xFC; // Detta nollställer de två lägsta bits
A |= (B & 0x03); // Detta ställer de två lägsta bits till 1 om de är ställda till 1 i B
Klart.

[Magnus_K]

Skitkul! Innan denna tråden skapades så hade jag inte förstått ett ord om vad du skrev Icecap men nu förstod jag varenda litet tecken.

Det känns som att jag var på rätt spår med exempel 2. Att skifta fram och tillbaka som jag skrev i exempel 1 kanske fungerar men om man istället AND:ar som du gjorde där så kan man ju skriva likadant oavsett om det är sista/första eller bitarna mitt i vilket känns mer logiskt.

Tack!

[Icecap]

Och sedan bara för att vara övertydlig: orsaken till att det OR'as med (B & 0x03) är att jag vill säkra mot att andra bits i B än just de två understa (0x03) är med i leken. Är man tvärsäker på att B enbart består av 0, 1, 2 eller 3 kan man hoppa över denna AND-funktion.

Och det går såklart att använda detta princip på andra bits, precis som du skriver.

OBS: Om det är t.ex. en port man vill göra detta på kan det vara olämpligt att göra så. Dels finns RMW-problematiken men dels kan en av de bit som ska ställas till '1' redan vara '1'. Då kommer den att gå '1' -> '0' -> '1' vilket kan vara olämpligt, tänk bara vad det kan göra om man ska klocka några pulser...

Hur löser man det då? Jo, man läser status på porten till en byte i minnet, flipprar med bitsen i den byte och sedan skriver man tillbaka den till porten.