Anderson, se usar fonte com espaçamento constante como a Courier os diagramas ficam bem mais legíveis:

;Byte 1:
;   7    6     5     4     3     2     1     0   
; |----S1---|--------M2-------|--------M1--------|
;
;Byte 2:
;   7     6     5     4     3     2     1     0
;  Z-    Z+    L3    L2    L1  |-------M3--------|


Pelo teor das questões receio que vc não tenha ainda compreendido todo o processo ...

1) No programa da unidade de comando vou enviar bit a bit e montar o meu byte no software da unidade de controle ?

Veja, podemos dizer que a transmissão é bit-a-bit pq a transmissão é serial, mas isto pode confundir ... na verdade a UART transmite e recebe byte a byte ... isto é verdade mesmo quando não se dispõe de UART no hardware e se usa bit banging* ...

O habitual é colocar os bytes recebidos em um buffer para processamento posterior, após todo o pacote ter sido transmitido, mas nada impede que sejam processados on the fly se houver handshaking adequado ...

2) Quando faço o mascaramento do meu byte e rotaciono os bits eles não deveriam aparecer para M1, M2 e M3 agrupados ?

Os bits correspondentes a M1 e M2 devem aparecer agrupados no primeiro byte, os de M3 no segundo byte ... ou seja, como os tiver agrupado ...

ou eles são rotacionados bit a bit e transmitidos para depois serem agrupados formando o meu byte de transmissão ?

Vc monta o(s) byte(s) com os grupos de bits e depois transmite. A operação inversa será efetuada no receptor, o(s) byte(s) será(ão) recebido(s) e depois quebrado(s), separando os bits ou grupo de bits componentes, que por sua vez serão processados, redundando na ação desejada.


* Fui espiar o código do projeto original e se bem entendi são transmitidos 16 bits precedidos por um start bit e sucedidos por um stop bit e um delay para sincronismo entre as sucessivas transmissões. Isto foge um pouco do convencional mas o dito acima ainda é válido.

* Fui espiar o código do projeto original e se bem entendi são transmitidos 16 bits precedidos por um start bit e sucedidos por um stop bit e um delay para sincronismo entre as sucessivas transmissões. Isto foge um pouco do convencional mas o dito acima ainda é válido.

Como assim...., eu ainda preciso aprender muito.  Quando você diz que foge do convencional, poderia me dar uma explicação à respeito ?

Grato

Observe que a rotina de leitura do conversor AD é chamada e a leitura retorna em W, uma grandeza de oito bits. A seguir o byte é mascarado, restando apenas os três bits mais significativos ...

Entendo, e sempre utilizaremos os três bits mais significativos ?

Quase sempre os bits mais significativos, não necessariamente três. Isto está ligado à resolução adequada para o caso, aqui o autor entendeu que três bits oferecem resolução suficiente para o controle dos motores, para outras aplicações pode ser necessária uma maior granularidade, pan-tilt de uma cam, por exemplo ...

Então a definição da quantidade de bits é feita pela mascara ?

Como são três bits e os mais significativos, a excursão total do potenciômetro será dividida em oito regiões distintas:

| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |

|<---      curso total      --->|

ou seja, apenas oito valores discretos serão possíveis, pequenos movimentos do joystick não serão percebidos.

Isso pode ser traduzido em precisão de movimentos, correto ?

Os três bits se conjugam para possibilitar os movimentos conforme tabela onde conjugo velocidades e direções, por ex.:

      A---B---C                                           A=0 (à ré)           B------C
      1---1---1      à frente, alta vel.                  A=1 (à frente)       1------1     Alta vel
      1---1---0      à frente, vel. média                                      1------0     vel. média
      1---0---1      à frente, baixa vel.                                      0------1     baixa vel.
      1---0---0      parado                                                    0------0     parado
      0---1---1      à ré, alta vel.                                                 
      0---1---0      à ré, vel. média
      0---0---1      à ré, baixa vel.
      0---0---0      parado

Conforme o que você coloca o curso total do potenciômetro será dividido em oito porções. Considerando que a posição de descanso do potenciômetro no joystick fica a meio curso, pode-se dizer que R/2 equivalerá a inexistência de movimento. Essa equivalência de valores eu é quem determino ? Por ex. Para cada percentual de leitura de curso dos potenciômetros eu atribuo um valor  conforme minha tabela de possibilidades de conjugação de movimentos e velocidades entre os três bits considerados para cada motor e envio esses valores para transmissão ?

Jorge, não posso deixar de agradecer. Sua ajuda tem sido de extrema importância. Obrigado

Bom pessoal, parece que o código da unidade de comando está funcionando. Eu agora vou passar ao código da unidade de controle, onde ficam os motores. Para quem quiser dar uma olhada ficou assim: ;-------------------------------------------------------------
;Software para comando de Joystick e potenciometro
;ROV - Abissal

;Byte 1:
;   7    6     5     4     3     2     1     0   
; |----S1---|--------M2-------|--------M1--------|
;
;Byte 2:
;   7     6     5     4     3     2     1     0
;  Z-    Z+  |--------L--------|-------M3--------|
;
;
; M1 - controle do motor 1 (estados RR,MR,LR,P,LF,MF,RF)
; M2 - controle do motor 2 (estados RR,MR,LR,P,LF,MF,RF)
; M3 - controle do motor 3 (estados RB,MB,LB,P,LC,MC,RC)
; S1 - aciona servo 1
; L - controle da iluminação (estado 50%  -  75%   -  100%)
; Z+ - aproximar Zoom
; Z- - afastar Zoom
;---------------------------------------------------------------

   list P=16F877A
   #include "P16F877A.INC"

   __CONFIG _CP_OFF & _WDT_OFF & _XT_OSC & _PWRTE_ON
   
   errorlevel -302      ; turn off bank bits warning

;
; Seleção de entradas do MUX (ADDCON0)
;
#DEFINE  EAN_0 B'01000001'    ; f/8, AN0, DONE, A/D On -  Eixo X
#DEFINE  EAN_1 B'01001001'    ; f/8, AN1, DONE, A/D On -  Eixo Y
#DEFINE  EAN_2 B'01010001'    ; f/8, AN2, DONE, A/D On -  Eixo Z
#DEFINE  EAN_3 B'01011001'    ; f/8, AN3, DONE, A/D On -  Iluminação
#DEFINE SERVO B'01100001' ; f/8, AN5, DONE, A/D On -  Servo Motor 0º - 45º  -  90° -  135° = pressionado  1 = liberado
#DEFINE ZOOM_AP PORTB,6 ; porta do zoom+ 0 = liberado 1 = pressionado
#DEFINE ZOOM_AF PORTB,5 ; porta do zoom- 0 = liberado 1 = pressionado

;
; Saídas
;

#DEFINE LED2 PORTD,6 ;Porta do LED_D2    0 = apagado   1 = aceso
#DEFINE LED1 PORTD,5 ;Porta do LED_D1    0 = apagado   1 = aceso

;
;   Variáveis da RAM internas
;   
   cblock H'20'
        ld_loop_ex
      ld_loop_in
Valor_AN0
Valor_AN1
Valor_AN2
Valor_AN3
Valor_DIG_0
Valor_ZOOM_AP
Valor_ZOOM_AF
SER_DATA_1
SER_DATA_2
    endc
;
; Inicio do Programa
;
   ORG   0h         

; Inicializaçao do PIC e da porta serial
    bcf     STATUS,RP1
    bsf     STATUS,RP0 ; Habilita banco 1
    movlw b'00000000' ; PORTD todo como saída
movwf TRISD
    movlw   B'00000010'    ; setup do conversor A/D
    movwf   ADCON1          ; left justify result, 6 least significant bits are read as "0"
                      ; port A: [D D D A,  A A A A] (digital and analog inputs)
;
; Ajusta parametros da UART (usando cristal externo de 4MHz)
; Baud Rate = 9600 bps, No Parity, 1 Stop Bit
;
    movlw   0x19              ; 0x19=9600 bps / 0x0C=19200 bps
    movwf   SPBRG
    movlw   b'00100100'      ; TX_Enable, assync. mode, brgh = high (2)
    movwf   TXSTA            ; enable Async Transmission, BRGH=1
    movlw   b'10111111'      ; RC6 saida, outros bits da PORTC sao de entrada
    movwf   TRISC
  bcf     STATUS,RP0      ; Habilita banco 0
    clrf    PORTD          ; zera saídas do display
    movlw   b'01000000'    ; Setup Port C
    movwf   PORTC          ; RC6(TX)=1 others are 0
    movlw   b'10000000'    ; habilita a UART
    movwf   RCSTA
movlw b'11111111' ; PORTB todo como entrada
movwf TRISB

;
; Loop principal
;
start:

;-------Ler entradas Analógicas  e ...
;-------  ...  preparar BYTE 1 para transmissão

bcf     STATUS,RP0      ; Habilita banco 0

    movlw   EAN_0 ; lendo entrada analógica 0, colocando valor em W
call    read_ad ; chama a rotina de conversão AD

andlw 0xE0 ; mascara os três bits mais significativos e coloca o resultado em W

movwf SER_DATA_1 ; SER_DATA_1 = [X7 X6 X5 0,   0  0  0  0]
rrf SER_DATA_1,F ; SER_DATA_1 = [0 X7 X6 X5,   0  0  0  0]
rrf SER_DATA_1,F ; SER_DATA_1 = [0  0 X7 X6,   X5 0  0  0]
rrf SER_DATA_1,F ; SER_DATA_1 = [0  0 0  X7,   X6 X5 0  0]

movlw   EAN_1 ; lendo entrada analógica 1
  call    read_ad ; chama a rotina de conversão AD

andlw 0xE0 ; mascara os três bits mais significativos e coloca o resultado em W

addwf SER_DATA_1,F ; SER_DATA_1 = [Y7  Y6  Y5  X7,   X6  X5   0   0]
rrf SER_DATA_1,F ; SER_DATA_1 = [ 0  Y7  Y6  Y5,   X7  X6   X5  0]
rrf SER_DATA_1,F ; SER_DATA_1 = [ 0   0  Y7  Y6,   Y5  X7  X6  X5]

movlw SERVO ; lendo entrada analógica do servo motor
call read_ad ;chama a rotina de conversão AD
andlw 0XC0
addwf SER_DATA_1,F ; SER_DATA_1 = [S2  S1  Y7  Y6,  Y5  X7  X6  X5]

movlw   EAN_2 ; lendo entrada analógica 2
call    read_ad ; chama a rotina de conversão AD
andlw 0xE0 ; mascara os três bits mais significativos e coloca o resultado em W
movwf SER_DATA_2 ; SER_DATA_2 = [Z7  Z6  Z5  0,   0   0   0    0]
rrf SER_DATA_2,F ; SER_DATA_2 = [ 0  Z7  Z6  Z5,  0   0   0    0]
rrf SER_DATA_2,F ; SER_DATA_2 = [ 0   0  Z7  Z6,  Z5  0   0    0]
rrf SER_DATA_2,F ; SER_DATA_2 = [ 0   0   0  Z7,  Z6  Z5  0    0]

movlw   EAN_3 ; lendo entrada analógica 3
  call    read_ad ; chama a rotina de conversão AD
andlw 0xE0 ; mascara os três bits mais significativos e coloca o resultado em W
addwf SER_DATA_2,F ; SER_DATA_2 = [L7  L6  L5   Z7,    Z6    Z5    0   0]
rrf SER_DATA_2,F ; SER_DATA_2 = [ 0  L7  L6   L5,    Z7    Z6    Z5  0]
rrf SER_DATA_2,F ; SER_DATA_2 = [ 0   0  L7   L6,    L5    Z7    Z6   Z5]


;-------Ler entradas Digitais

btfss   ZOOM_AP ; lendo entrada digital RB6. O botão está pressionado ?
call zoom_ap_mais ; Sim, então vá para rotina zoom_ap_mais.

btfss   ZOOM_AF ; lendo entrada digital RB5. O botão está pressionado ?
call zoom_af_mais ; Sim, então vá para rotina zoom_menos.

goto envia

;-------Rotinas

;
; Conversor A/D, palavra ADDCON0 em W
;
read_ad:
    movwf    ADCON0
bsf STATUS,RP0
movlw 0x02
movwf ADCON1
bcf STATUS,RP0
    bsf      ADCON0,GO ; Iniciar conversao
wait:
  btfsc    ADCON0,GO ; Testa se terminou conversao
  goto    wait


; movlw b'11111100' ;*************************************************** esta linha deverá ser retirada daquí.
;movwf ADRESH
     movf    ADRESH,W
     return

zoom_ap_mais:
bsf LED2
bsf SER_DATA_2,6
movlw b'01000000' ;acende o LED
movwf Valor_ZOOM_AP ;carrega o valor de LED2 em Valor_ZOOM_AP
movwf   PORTD
return

zera_zoom_ap_mais:
call waitx400
bcf LED2
movlw b'00000000'
movwf Valor_ZOOM_AP
bcf PORTD,6
return

zoom_af_mais:
bsf LED1
bsf SER_DATA_2,7
movlw b'00100000' ;apaga o LED
movwf Valor_ZOOM_AF ;carrega o valor de LED1 em Valor_ZOOM_AP
return

zera_zoom_af_mais:
call waitx400
bcf LED1
movlw b'00000000'
movwf Valor_ZOOM_AF
bcf PORTD,5
return


;-------Enviando dados pela serial

envia:
movfw SER_DATA_1 ; recupera o valor convertido para ser enviado
call send ; chama a rotina de envio pela serial

movfw SER_DATA_2 ; recupera o valor convertido para ser enviado
call send ; chama a rotina de envio pela serial
call    delay1s ; chama as rotinas de tempo para aguardar o termino da transmissão
call zera_zoom_ap_mais
call zera_zoom_af_mais
    goto    start

;
; Envia byte (contido em W) pela UART e espera terminar
;
send:
    movwf    TXREG          ; send data in W
TransWt:
    bsf    STATUS,RP0      ; banco 1
WtHere:
    btfss    TXSTA,TRMT     ; Transmissao terminou se TRUE
    goto    WtHere      ; Senao, espera
    bcf    STATUS,RP0      ; banco 0
return

;
; Display de LEDs
;
display:
   movwf   PORTD
   return
   
;
;-----------------------------------------------------------------------------
;
;   Delay for about 1s
;
delay1s:
    movlw   D'250'
    call    waitx400
    movlw   D'250'
    call    waitx400
    movlw   D'250'
    goto    waitx400

;
;-----------------------------------------------------------------------------
;
;   Delay for about 250 ms
;
delay250ms:
    movlw   D'250'
    goto   waitx400
;
;-----------------------------------------------------------------------------
;
;   Delay for about 400x cycles
;
;    Se w=1, temporiza 1ms @ fck = 4MHz
;
waitx400:
    movwf   ld_loop_ex
ld_loopex:
    movlw   (400-4)/4
    movwf   ld_loop_in
ld_loopin:
    decf    ld_loop_in,F
    skpz
    goto    ld_loopin
    decf    ld_loop_ex,F
    skpz
    goto    ld_loopex
    return

END