Manchester Decoding PIC16lf1509

[Seto (Gast)]

Hallo Leute,

ich versuche eine Manchester Decodierung zu programmieren. Dabei wird
eine Binäre 1 als 01 Bits dargestellt und eine Binäre 0 als 10 Bits.
Dabei möchte ich mit 10 kHz decodieren. Ich verwende einen PIC16lf1509.
Ich habe zurzeit leider keine Möglichkeit mein Programm zu testen.
Außerdem bin ich noch nicht ganz fertig.

Für die Decodierung soll erst eine Präambel empfangen werden, damit man
weiß, dass Daten gesendet werden. Einfach 8-Bits bei denen die Flanke
wechselt 10101010. Dabei soll jeder Flankenwechsel 50 us dauern, was ich
mit einem Flankeninterrupt messe. Danach sollen 14 Datenbits empfangen
werden, wobei vor den Daten ein Startbit (1) und dahinter ein Stopbit
(0) empfangen wird.
Die Präambel und die Nutzdaten werden in einem Buffer gespeichert.
Anschließend werden die empfangenen Data encoded.

Kann man das auf diese weise machen?!

CODE:

/* 
 * File:                Init.h
 * Author:              Max
 * Comments:
 * Revision history: 
 */

// This is a guard condition so that contents of this file are not included
// more than once.  
#ifndef Init_H
#define  Init_H

#include <xc.h> // include processor files - each processor file is guarded.  

typedef unsigned int uint;
/***** CONFIGURATION *****/
//  ext reset, internal oscillator (no clock out), no watchdog timer
#pragma config MCLRE = ON, FOSC = INTOSC, CLKOUTEN = OFF, WDTE = OFF
//  brownout resets enabled, low brownout voltage, no low-power brownout reset
#pragma config BOREN = ON, BORV = LO, LPBOR = OFF
//  no power-up timer, no code protect, no write protection
#pragma config PWRTE = OFF, CP = OFF, WRT = OFF
//  stack resets on, high-voltage programming
#pragma config STVREN = ON, LVP = OFF

#define Send LATAbits.LATA1                 // Turn's LED on/off
#define logic_lvl LATAbits.LATA2            // current logic level of Input-Bit
#define IntTrigger OPTION_REGbits.INTEDG    // if 1 interrupt on rising edge else on falling edge


// Clockfrequency = 2 MHz / 4  = 500 kHz ---> 2 us per tick
// Timeperiod 10 kHz = 100 us
// Mid-bit time = 50 us
    // default values for 10 kHz frequency at 2 MHz clockfrequency
struct DecodeTime {
    uint midbit_low;    // for avarage of T= 50 us = 25 ticks +-50%
    uint midbit_high;
    uint period_low;    // for avarage of 2T = 100 us = 50 ticks +-50%
    uint period_high;
};

struct DecodeTime ManDecode;

    // variable initialisation
uint decode_buffer = 0b00000000;        // assuming that payload has 8 Bits
uint M_Time;                            // Measured Time
uint Preamble = 0b00000000;             // Buffer for Preamble request
uint Payload = 0b0000000000000000;      // Buffer for Payload
uint PreDetect = 0;                     // true if preamble was received
uint Pcounter = 0;                      // Counts Payload size
uint data_send = 0;                     // True if Data was received successfull

    // function declaration
void SetPreCounter(void);
void GetPayload(void);


#endif

/************************************************************************
*                                                                       *
*   Filename:      Main.c                                               *
*   Created on 28. Dezember 2017, 17:31                                 *
*   File Version:  1.0                                                 *
*                                                                       *
*   Author:        Max                                                  *
*                                                                       *
*************************************************************************
*                                                                       *
*   Architecture:  Mid-range PIC                                        *
*   Processor:     16LF1509                                             *
*   Compiler:      MPLAB XC8 v1.44 (Free mode)                          *
*                                                                       *
*************************************************************************/

#include "Init.h"

//Functions---------------------------------------------------------------------
// Initialisation
void init(void) {
    
        // default value's
    ManDecode.midbit_low = 13;
    ManDecode.midbit_high = 37;
    ManDecode.period_high = 38;
    ManDecode.period_high = 62;
    
    TRISA = 0b111101;               // configure RA1 (only) as an output (0 -> output, 1 -> input)
    LATA = 0;                       // set RA1 low
    ANSELA = 0;                     // disable analog input mode for all pins
                                    // --> RA2 is a digital input
        // configure oscillator
    OSCCONbits.SCS1 = 1;            // select internal clock -- OSCCON oscillator control register
    OSCCONbits.IRCF = 0b1100;       // internal oscillator = 2 MHz
        // configure Timer0
    OPTION_REGbits.TMR0CS = 0;      // select timer mode
    OPTION_REGbits.PSA = 1;         // if '0' assign's prescaler to Timer0
//    OPTION_REGbits.PS = 0b111;      // prescale 1:128
                                    // -> increment TMR0 every 4 us
        // configure Interrupt on changing edge
    OPTION_REGbits.INTEDG = 1;      // interrupt on rising edge
    
        // enable interrupts
    INTCONbits.INTF = 0;            // clearing external interrupt flags
    INTCONbits.TMR0IF = 0;          // clearing Timer0 flag
    INTCONbits.INTE = 1;            // enable external interrupt
    INTCONbits.TMR0IE = 1;          // enable Timer0 interrupt
    ei();                           // enable global interrupts
    

}
/***** INTERRUPT SERVICE ROUTINE *****/
void interrupt isr(void)
{
    static uint time;
    //*** Service external interrupt
    //
    //  Triggered on changing edge on INT pin
    // 
    //   
    
    if(INTCONbits.INTF && !INTCONbits.TMR0IF) {
        time=TMR0;
        M_Time = time;
        TMR0=0;                         // start counting
        if (M_Time >= ManDecode.midbit_low) {
            if (M_Time <= ManDecode.midbit_high) {
                // Count Bit in Preamble Buffer
                if(!PreDetect) {
                    SetPreCounter();  
                }
                else if(PreDetect) {
                // Read Start-/Stopbit and Payload
                    GetPayload();
                    
                }
            }
        }
        else {                          // reset Preamble and Payload Buffer
            Preamble = 0b00000000;
            Payload = 0b0000000000000000;
        }
        IntTrigger = ~IntTrigger;       // change interrupt to falling/rising edge        
    }
    else if (INTCONbits.TMR0IF) {           // if Timer overflows -> reset 
        INTCONbits.TMR0IF = 0;
        IntTrigger = 1;                 // change interrupt to rising edge
        Preamble = 0b00000000;
        Payload = 0b0000000000000000;
    }                   
    INTCONbits.INTF = 0;                // clear interrupt flag
    
}
void GetPayload(void) {
    Payload <<= 1;
    if(IntTrigger && (Pcounter != 16)) {
        Payload |= 1;
        Pcounter++;
    }
    // Test if Payload is True
    if(Pcounter == 16) {
            // Test if Startbit and Stopbit are sent
        uint check = 0b10000000000000001;
        uint data_complete = 0b10000000000000000;
        if((Payload&check)== data_complete) {
            // wait for guardtime and decode
            data_send = 1;
//            Man_Decode(); /// Not yet implemented
        }
    }
}
void SetPreCounter(void) {
    Preamble <<= 1;
    if(IntTrigger) {
        Preamble |= 1;
        if(Preamble == 170) {
            PreDetect = 1;
        }
    }
}

void main(){
    init();
    if(data_send) {
//        Man_Encode();     Not yet implemented -- decodes received Data
    }
}