timestamp from a microcontroller in millisecond

[asif45]

Hi


when i am checking the timestamp with receivers software, it`s showing 1 event is missing. From the original file i made some change and i put them in bold letters here. but i can't
figure it out why it's missing a event.


i only posted here the part of firmware i modified. Sorry for post a big code but i need some help with this.

Code (C):

typedef struct FifoStack
{
u16 u16EventTimeStampMSPart;        //This variable have only the ms part!!!
    u32 u32EventTimeStamp;                    // This variable have only the s part!!!
    u8 u8EventInput;
} SFIFO_STACK;

// Private function prototypes -------------------------------------------------
void UsbConnect(void);
void StackPush(u32 u32EventTime, u16 u16EventTimeMS, u8 u8Input);
u8 StackPop(SFIFO_STACK *psFifoStack);
void GetMessage(u8 *pu8Buffer);
void TaskFilter(void);

// *****************************************************************************
/// @brief        Function that saves an event in cell
/// @fn            void StackPush(u32 u32EventTime, u16 u16EventTimeMS, u8 u8Input)
/// @param[in]    u32EventTime    @brief Hora do evento
/// @param[in]    u16EventTimeMS  @brief Hora do evento, ms part ASIF
///    @param[in]    u8Input            @brief Número da entrada que gerou o evento
// *****************************************************************************
void StackPush(u32 u32EventTime, u16 u16EventTimeMS, u8 u8Input)
{
    if ((s16StackWriteIndex + 1) != s16StackReadIndex)                                    // verifica se há espaço na pilha
    {
        sFifo[s16StackWriteIndex].u16EventTimeStampMSPart = u16EventTimeMS;        //ASIF salva o time stamp na pilha, part MS

        sFifo[s16StackWriteIndex].u32EventTimeStamp = u32EventTime;                        // salva o time stamp na pilha
        sFifo[s16StackWriteIndex].u8EventInput = u8Input;                                // salva a entrada digital na pilha
        s16StackWriteIndex++;                                                            // incrementa o índice de escrita
        if (s16StackWriteIndex >= STACK_SIZE)                                            // torna o índice de escrita circular
            s16StackWriteIndex = 0;
    }
}

// *****************************************************************************
/// @brief        Function that retrieves a cell event
/// @fn            u8 StackPop(SFIFO_STACK *psFifoStack)
///    @param[out]    psFifoStack        @brief Evento
/// @retval        TRUE, se ok
// *****************************************************************************
u8 StackPop(SFIFO_STACK *psFifoStack)
{
    if (s16StackReadIndex != s16StackWriteIndex)                                        // verifica se há dados na pilha
    {
        psFifoStack->u16EventTimeStampMSPart = sFifo[s16StackReadIndex].u16EventTimeStampMSPart;    //ASIF busca o time stamp da pilha, part MS

        psFifoStack->u32EventTimeStamp = sFifo[s16StackReadIndex].u32EventTimeStamp;    // busca o time stamp da pilha
        psFifoStack->u8EventInput = sFifo[s16StackReadIndex].u8EventInput;                // busca o número da entrada digital da pilha
        s16StackReadIndex++;                                                            // incrementa o índice de leitura
        if (s16StackReadIndex >= STACK_SIZE)                                            // torna o índice de leitura ser circular
            s16StackReadIndex = 0;
        return TRUE;
    }
    else
        return FALSE;
}



// *****************************************************************************
/// @brief        Task of filtering the digital inputs
/// @fn            void TaskFilter(void)
// *****************************************************************************
void TaskFilter(void)
{
    u8 n, u8DigInp;
    static u8 u8DigInpOld;
    static u32 u32FilterTimer[INPUT_NUMBER], u32EventTime[INPUT_NUMBER], u16EventTimeMS[INPUT_NUMBER], u32FilterSample;
    static ESTATE_FILTER eFilterState[INPUT_NUMBER];
//  u32 u32Counter[2];
    if (TimeDiff(u32FilterSample) == 0)
        return;
    u32FilterSample = ReadSysTime();
    u8DigInp = ReadDigInp();                                                            // lê as entradas digitais
    for (n = 0; n < INPUT_NUMBER; n++)
    {
        switch (eFilterState[n])
        {
            case STATE_ACTIVE_EDGE:
                if ((u8DigInp & (1 << n)) ^ (u8DigInpOld & (1 << n)) != 0)                // verifica se houve mudança no nível da entrada
                {
                    if ((sInputFilter[n].u8ActiveEdge << n) == (u8DigInp & (1 << n)))    // verifica se a transição corresponde à borda ativa
                    {
                      u32EventTime[n] = u32Time;                                                // This is exact moment of event, but only in seconds
//                        u16EventTimeMS[n] = TimeDiff(u32Prescaler);                // ASIF This is exact moment of event, but in ms inside the second

                        u32FilterTimer[n] = ReadSysTime();                                // carrega o temporizador do nível ativo
                        eFilterState[n] = STATE_ACTIVE_LEVEL;                            // passa para o estado de verificação do nível ativo
                    }
                }
                break;
            case STATE_ACTIVE_LEVEL:
                if ((sInputFilter[n].u8ActiveEdge << n) != (u8DigInp & (1 << n)))        // verifica se o nível da entrada mudou para o nível inativo
                    eFilterState[n] = STATE_ACTIVE_EDGE;                                // volta para aguardar uma nova transição
                if (TimeDiff(u32FilterTimer[n]) > sInputFilter[n].u16ActiveTime)        // verifica se passou o tempo mínimo de nível ativo
                    eFilterState[n] = STATE_INACTIVE_EDGE;                                // passa para o estado de verificação da borda inativa
                break;
            case STATE_INACTIVE_EDGE:
                if ((u8DigInp & (1 << n)) ^ (u8DigInpOld & (1 << n)) != 0)                // verifica se houve mudança no nível da entrada
                {
                    if ((sInputFilter[n].u8ActiveEdge << n) != (u8DigInp & (1 << n)))    // verifica se a transição corresponde à borda inativa
                    {
                        u32FilterTimer[n] = ReadSysTime();                                // carrega o temporizador do nível inativo
                        eFilterState[n] = STATE_INACTIVE_LEVEL;
                    }
                }
                break;
            case STATE_INACTIVE_LEVEL:
                if ((sInputFilter[n].u8ActiveEdge << n) == (u8DigInp & (1 << n)))        // verifica se o nível da entrada mudou para nível ativo
                {
                    u32FilterTimer[n] = ReadSysTime();                                    // carrega o temporizador do nível ativo
                    eFilterState[n] = STATE_ACTIVE_LEVEL;                                // passa para o estado de verificação do nível ativo
                }
                if (TimeDiff(u32FilterTimer[n]) > sInputFilter[n].u16InactiveTime)        // verifica se passou o tempo mínimo de nível inativo
                {
                   u16EventTimeMS[n]++; // = TimeDiff(u32Prescaler);                // ASIF This is exact moment of event, but in ms inside the second

                    StackPush(u32EventTime[n], u16EventTimeMS[n], n);                                        //ASIF salva o evento na pilha
                    eFilterState[n] = STATE_ACTIVE_EDGE;                                // aguarda o próximo evento
                }
                break;
        }
    }
    u8DigInpOld = ReadDigInp();                                                            // salva o nível atual das entradas digitais
}


// *****************************************************************************
/// @fn            void TaskMain(void)
/// @brief       Task control system
// *****************************************************************************
void TaskMain(void)

{
    if (TimeDiff(u32Prescaler) >= 1000)                    // atualiza o relógio
    {
        u32Prescaler = ReadSysTime();
        u32Time++;
    }
    TaskFilter();                                        // processa o filtro das entrads
    ReadAD();                                            // lê os canais analógicos
    CommLed();                                            // atualiza os LEDs da recepção e transmissão
    BlinkControl();                                        // atualiza o pisca-pisca
    UsbStateControl();                                    // controla o estado da conexão SUB
    if (IsUsbConnected() == TRUE)                        // verifica se está conectado à USB
    {
        SysLed(IsBlink());                                // se há, pisca o LED sinalizador
        if (TimeDiff(u32UsbTimer) > USB_COMM_TIME)        // verifica se passou o período de envio
        {
            u32UsbTimer = ReadSysTime();                // renova o temporizador
            SendUsb(SendMessage());                        // envia os dados pela a interface USB
        }
    }
    else
        SysLed(TRUE);                                    // se não há, liga o LED
}