Subversion Repositories Code-Repo

#include "DEFINES.h"

#include "INTERRUPTS.h"

#include "PWM.h"

#include "IOC.h"

#include "EUSART.h"

// <editor-fold defaultstate="collapsed" desc="Configuration Registers">

// CONFIG1

#pragma config FOSC = HS        // Oscillator Selection (HS Oscillator, High-speed crystal/resonator connected between OSC1 and OSC2 pins)

#pragma config WDTE = OFF       // Watchdog Timer Enable (WDT disabled)

#pragma config PWRTE = ON       // Power-up Timer Enable (PWRT enabled)

#pragma config MCLRE = OFF      // MCLR Pin Function Select (MCLR/VPP pin function is digital input)

#pragma config CP = OFF         // Flash Program Memory Code Protection (Program memory code protection is disabled)

#pragma config CPD = OFF        // Data Memory Code Protection (Data memory code protection is disabled)

#pragma config BOREN = ON       // Brown-out Reset Enable (Brown-out Reset enabled)

#pragma config CLKOUTEN = OFF   // Clock Out Enable (CLKOUT function is disabled. I/O or oscillator function on the CLKOUT pin)

#pragma config IESO = OFF       // Internal/External Switchover (Internal/External Switchover mode is disabled)

#pragma config FCMEN = ON       // Fail-Safe Clock Monitor Enable (Fail-Safe Clock Monitor is enabled)

// CONFIG2

#pragma config WRT = OFF        // Flash Memory Self-Write Protection (Write protection off)

#pragma config PLLEN = OFF      // PLL Enable (4x PLL disabled)

#pragma config STVREN = ON      // Stack Overflow/Underflow Reset Enable (Stack Overflow or Underflow will cause a Reset)

#pragma config BORV = LO        // Brown-out Reset Voltage Selection (Brown-out Reset Voltage (Vbor), low trip point selected.)

#pragma config LVP = OFF        // Low-Voltage Programming Enable (High-voltage on MCLR/VPP must be used for programming)

// </editor-fold>

int main() {

    // Initialize oscillator to external crystal (20Mhz)

    OSCCONbits.SCS = 0b00;

    OSCCONbits.SPLLEN = 0b0;

    OSCCONbits.IRCF = 0b1111;

    // Set all pins to digital I/O

    ANSELA = 0x00;

    // Disable pull-ups

    OPTION_REGbits.nWPUEN = 1;

    WPUA = 0x0;

    // Configure alternate pin function register

    APFCONbits.RXDTSEL = 0; // RX on RA1

    APFCONbits.TXCKSEL = 0; // TX on RA0

    APFCONbits.CCP1SEL = 0; // CCP1 on RA2

    // Delay for a bit to ensure oscillator has started

    __delay_ms(10);

    // Configure and enable interrupts

    Interrupt_Enable();

    // Configure and enable peripherals

    PWM_Init();

    IOC_Init();

    UART_Init();

    uint8_t recvBuffer[32];

    uint8_t txOk[] = "Ok!\n";

    uint8_t txError[] = "Error!\n";

    /* Protocol format as follows:

     * Byte 0 = OPCODE

     *      0x1 = Set frequency

     *          Bytes 1-4 = 32 bit unsigned value

     *      0x2 = Set duty cycle

     *          Byte 1 = 8 bit unsigned value (high value)

     *          Byte 2 = 8 bit unsigned value (low value)

     *      0x3 = Set pattern

     *          Bytes 1-2 = 16 bit pattern (transmits MSB first)

     *      Everything else = nop

     */

    while(1) {

        uint8_t recvBytes = UART_Read(recvBuffer);

        if (recvBytes != 0) {

            // Process op-code for setting frequency

            if (recvBuffer[0] == 0x1 && recvBytes == 5) {

                uint32_t byte0 = recvBuffer[1];

                byte0 <<= 24;

                uint32_t byte1 = recvBuffer[2];

                byte1 <<= 16;

                uint32_t byte2 = recvBuffer[3];

                byte2 <<= 8;

                uint32_t freq = 0;

                freq |= byte0;

                freq |= byte1;

                freq |= byte2;

                freq |= recvBuffer[4];

                // Ensure that received value falls within working bounds

                if (freq >= 20000 && freq <= 200000) {

                    Set_PWM_Frequency(freq);

                    UART_Write(txOk, 4);

                } else {

                    UART_Write(txError, 7);

                }

                UART_Reset_RX();

            } else if (recvBuffer[0] == 0x2 && recvBytes == 3) {

                // Ensure that received value falls within working bounds

                if (recvBuffer[1] <= 100 && recvBuffer[2] <= 100) {

                    Set_PWM_Duty_Cycle(recvBuffer[1], recvBuffer[2]);

                    UART_Write(txOk, 4);

                } else {

                    UART_Write(txError, 7);

                }

                UART_Reset_RX();

            } else if (recvBuffer[0] == 0x3 && recvBytes == 3) {

                uint16_t byte0 = recvBuffer[1];

                byte0 <<= 8;

                uint16_t pattern = 0;

                pattern |= byte0;

                pattern |= recvBuffer[2];

                Set_PWM_Pattern(pattern);

                UART_Reset_RX();

                UART_Write(txOk, 4);

            } else if (recvBuffer[0] == 0x0 || recvBuffer[0] > 0x03 || recvBytes > 5) {

                UART_Reset_RX();

            }

        }

    }

}