rekenen met 8 bit pic

Een iets duidelijkere uitleg over de precieze berekeningen zou wel handig zijn. Negatieve getallen kun je met signed integers of longs doen...

Ook wel handig is te weten welk ontwikkelplatform je gebruikt.

Onderzoek eerst je type absolute encoders.Het kan zijn dat de absolute encoder ook een AB of ABCD uitgang heeft.
Een normale encoder heeft AB waarbij de "fases AB" 90 graden zijn gedraaid.Hieruit kun je de richting bepalen(tussen old_AB en new_AB).Bij absolute encoders doen ze dat ook. Dat scheelt heel wat 24bit rekenwerk.

Huh?

 positie = (1 << 21) - gelezen_getal; // om het teken goed te krijgen. 
 positie_mm = positie * OMREKENFACTOR; // float, of ga rekenen in micrometers. 

de encoder stuurt alleen een string van 21 bit uit.
bij het aanleggen van de voedingsspanning start deze met een willekeurig nummer dat kan liggen tussen 0 en 2097151.
elke stap komt overeen met een verplaatsing van de encoder van 0.01mm.
waar ik op dit moment even geen raad mee weet is:
als het meetpunt van de encoder van 0 naar 2097151 gaat, dan maakt hij een stap van 1 (eigenlijk -1)
als het meetpunt van de encoder van 2097151 naar 0 gaat maakt hij een stap van 1 (eigenlijk +1)
ik weet niet hoe ik dit moet gaan testen.

stel: dat de encoder halverwege zou zitten, dat trek je de nieuwe waarde af van de oude.
als de nieuwe waarde hoger is dan de oude, dan hou je het verschil over als positief.
als de nieuwe waarde lager is dan de oude, dan hou je het verschil over als negatief.

alleen gaat dit verhaal niet op als de encoder op zijn minimale/maximale waarde staat te pingelen.
ik zal deze overgang dus moeten testen, maar ik weet niet hoe ik dat moet gaan doen.

ik gebruik asm.

Als je te dicht bij 2.097.151 of bij 0 zit, dan tel je bij beide getallen bijv. 1.000.000 op. Als de uitkomst groter wordt dan 2.097.151 (het grootst mogelijke getal) dan trek je van dat getal 1.000.000 af. Met deze gevonden uitkomsten ga je rekenen. Vb: Het eerst gemeten getal is 2.000.000. Het tweede gemeten getal is 1.000. We zien dat we te dicht bij 2.097.151 zitten. Bij beide metingen tellen we dus 1.000.000 op. Dit geeft de volgende twee nieuwe getallen 3.000.000 en 1.001.000. Het eerste getal is groter dan 2.097.151, dus dat moet eraf. Dat geeft dus een nieuw getal 902.849. Daar moet 1.001.000 er van af. De uitkomst wordt dan −98151.
Dit is klokrekenen.
De klok wijst 10 over 11 aan. Wat is de "afstand" tussen de kleine en de grote wijzer? Dat wordt dus: Wat is de "afstand" tussen de "11" en de "2" van een analoge klok? We zitten te dicht bij de "12". Beide getallen verhogen we met bijvoorbeeld "6". De "11" wordt dan "17" en de "2" wordt dan "8". "17" is groter dan "12" dus trekken we "12" er van af. Dat geeft "5". De "afstand" tussen de "5" en de "8" is "5"-"8" = -"3".
Als je de klok in handen hebt dan kan je de wijzerplaat een halve slag linksom draaien (is verhogen met "6"). Dan staat de kleine wijzer op de "5" en de grote wijzer op de "8".

Ik zou gewoon een sign-extend doen naar 32 bits. Als je dan gewoon een verschil uitrekent in een 32bit variabele, dan klopt het gewoon.

int32 gelezen_getal;
...
if (gelezen_getal & (1 << 20)) gelezen_getal |= -1 << 21;

Kun je bij het inschakelen de tellers niet initialiseren op bijvoorbeeld 1 000 000, of 1 048 576?
Dan kun je naar beide kanten tien meter bewegen voordat je in de buurt van 0 of 2 097 151 komt.

heb wel ergens op het internet routines gevonden om te rekenen. Wellicht heb je er wat aan. Mail maar even. Dit zit er b.v. in:

;/*======================================================================*/
! 24 bit routines
;/*======================================================================*/
; negate24 // r24 = -b24
; negate24a // b24 = -b24
; negate24b // INDF = -INDF

; add24 // r24 = a24 + b24
; add24a // a24 += b24
; add24b // INDF += b24

; sub24 // r24 = a24 - b24
; sub24a // a24 -= b24
; sub24b // INDF -= b24

; mpy24x16 // r40 = a24 * b16
; mpy24x16a // r40 = a24 * b16
; mpy24x8 // r32 = a24 * b8
; mpy24x8a // INDF = a24 * b8

; div24x8 // q16,r8 = a24 / b8
; div24x16 // q8,r8 = a24 / b16

Wat voor encoders heb je?

Het is van belang of je relatieve of absolute encoders hebt. (Het lijkt dat je een relatieve encoder hebt).

Heb je een relatieve encoder zul je moeten zorgen dat de positie bepaald wordt door een "homeing" van de kop. MAW langzaam naar een stop positie bewegen en als deze tegen ene mechanische aanslag zit de positie nullen. Dit geld voor alle 3 de assen.
Zit zou je CNC machine dus zelf al moeten doen denk ik?

Vanaf dat punt is je uitlezing altijd hetzelfde en hoef je alleen de tellerwaarde te scalen naar mm of iets wat je wilt.