function [rx,err,errstr]=sendmessage2(H,message)

i=0;

% Tipos de erros
OK=0;
ERROR_SOF     =1;
ERROR_INV_RECV=2;
ERROR_INV_SEND=3;
ERROR_BCC_RECV=4;
ERROR_BCC_SEND=5;
ERROR_OPCODE  =6;
ERROR_INVREQ  =7;
ERROR_UNKNOWN =-1;

% Load global data
data;

% Validação dos argumentos
if (length(message)~=USART_SEND_LENGTH || (message(1)~=MESSAGE_REQ && message(1)~=MESSAGE_TEST));
    error('Mensagem a transmitir inválida!');
end

% Adicionar byte BCC
message=[message mod(sum(message),256)];

% Converter a mensagem a enviar para o formato adequado
message=uint8(message);

% Inicialização de variáveis
rx=[];
err=OK;              % Sem erro no inicio
errstr='OK';

% A transmissão da mensagem de solicitação é repetida sempre que um erro
% ocorra
tries=0;             % Número de tentativas
maxtries=1;         % Número máximo de tentativas
err=ERROR_UNKNOWN;
while (err~=OK && tries<maxtries)
    
    % Reinicialização do estado de Erro
    err=OK;
    
    % Se na segunda tentativa (ou mais), reinicializar os buffers série
    if (tries>0), comreset(H);; end

    % Contagem do número de tentativas
    tries=tries+1;

    % Envio da mensagem de pedido
    fwrite(H,message,'uint8');

    % Recepção da mensagem de resposta

    %keyboard;
    
    % Detecção do primeiro byte da frame
    rx0=0;
    tries2=0;
    maxtries2=20;
    % Apenas sai deste ciclo quando o número máximo de tentativas foi
    % esgotado, ou se o SOF é válido com mais 6 bytes disponíveis
    while (tries2<maxtries2 && (rx0<MESSAGE_MINTYPE || H.BytesAvailable<USART_RECV_LENGTH))
        if (rx0<MESSAGE_MINTYPE)
            rx0=fread(H,1,'uint8');
            if (isempty(rx0)), rx0=0; end
        end
        tries2=tries2+1;
    end
    if (tries2==maxtries2)
        err=ERROR_SOF;
        continue
    end

    % Recepção de um array de bytes (bytes seguintes ao primeiro)
    rx=fread(H,USART_RECV_LENGTH,'uint8');
    rx=[rx0; rx];

    % Neste ponto do programa, é garantido que uma mensagem série foi
    % obtida

    % Ajuste da mensagem recebida
    rx = rx';

    % Cálculo do BCC da mensagem recebida
    bcc=mod(sum(rx(1:end-1)),256);
    % Comparando o BCC code da mensagem com o último byte
    bcc_err=(bcc~=rx(end));

    % Erro de BCC na mensagem de resposta
    if (bcc_err==1)
        err=ERROR_BCC_RECV;
    % Erro de OpCode não coincidente
    elseif (rx(2)~=message(2))
        err=ERROR_OPCODE;
    % Mensagem transmitida com parâmetros inválidos
    elseif (rx(1)==MESSAGE_INVREQ)
        err=ERROR_INVREQ;
    % Mensagem transmitida com erro de BCC
    elseif (rx(1)==MESSAGE_INVALID)
        err=ERROR_BCC_SEND;
    % Master não consegue ler a mensagem de solicitação
    elseif (rx(1)==MESSAGE_ERROR)
        err=ERROR_INV_SEND;
    % Mensagem de natureza desconhecida
    elseif (rx(1)~=MESSAGE_SUCESS && rx(1)~=MESSAGE_TEST)
        err=ERROR_INV_RECV;
    end       
end

% if (tries>1)
%     disp 'XXXXXXXXXXXXXXXXXXXXXX TRIES>1 XXXXXXXXXXXXXXXXXXXX'
%     tries
% end

% Preparação da mensagem de saída
rx=rx(1:end-1);

% Mensagem de erro
if (err~=OK)
    switch err
        case ERROR_SOF
            errstr='Primeiro byte não detectado!';
        case ERROR_INV_RECV
            errstr='Mensagem de resposta inválida!';
        case ERROR_INV_SEND
            errstr='Mensagem de solicitação não recebida com sucesso pelo Master!';
        case ERROR_BCC_RECV
            errstr='Mensagem de resposta com erro de BCC!';
        case ERROR_BCC_SEND
            errstr='Mensagem de solicitação com erro de BCC no Master!';
        case ERROR_OPCODE
            errstr='Byte de tipo (OpCode) não coincidente!';
        case ERROR_INVREQ
            errstr='Mensagem com parametros invalidos!';
        otherwise
            errstr='Erro desconhecido!';
    end
    
    % Reinicializar comunicações
    comreset(H);
end
