Beyond Arduino

/********************************************************************
Super simple HelloWorld (blink some LEDs) for use with UBW32 hardware
see http:/*www.schmalzhaus.com/UBW32 for more info
 
Modified by Tim of http:/*BeyondArduino.com to include more comments
and explainations.
********************************************************************/
/* 11/13/2011 - updated by Tim to add comments and better explain the inner workings of the UBW32
/* 06/01/2010 - updated to use latest MPLAB and C32 compiler */
/* 08/28/2010 - Changed to use Microchip folder - from Microchip Applications Library USB
				stack v2.7 - updated project to use unchanged MAL Microchip folder - no code changes */
/* 09/02/2011 - Tested with USB stack v2.9a, C32 v2.01, MPLAB v8.76 - no code changes */
 
/*The plib.h library includes the #defines and functions needed to access most all of the PIC32's built 
in features. You will want to #include this in all your PIC32 projects to make using the PIC a pleasant 
experience. This library contains the equivalent of the Arduino built-in Functions, such as digitalWrite() 
and pinMode(), and everything up to controlling your serial pins, USB and all other chip features. It is 
practically essential for PIC32 programming using the MPLAB C32 Compiler.*/
#include <plib.h>
 
/*this is a file made by the UBW32 team that specifies pin definitions and states for the UBW32 board 
specifically, including the user-controlled switches and the LEDs. You'll want to include this whenever 
you're working with the UBW32 board. It includes commands to check switch states, init all the LEDs, and 
to set LED states or toggle them. Very handy for simple UBW32 board controls.*/
#include "HardwareProfile.h"
 
/* NOTE THAT BECAUSE WE USE THE BOOTLOADER, NO CONFIGURATION IS NECESSARY*/
/* THE BOOTLOADER PROJECT ACTUALLY CONTROLS ALL OF OUR CONFIG BITS*/
 
/* Let compile time pre-processor calculate the CORE_TICK_PERIOD*/
#define SYS_FREQ 				(80000000L)	/*this sets the system frequency to 80Mhz*/
#define TOGGLES_PER_SEC			1000 /*This is the number of divisions per second you want the timer to tick at.*/
#define CORE_TICK_RATE	       (SYS_FREQ/2/TOGGLES_PER_SEC) /*this sets the CORE_TICK_RATE, which will control how often a timer-based interrupt occurs based on your TOGGLES_PER_SEC value*/
 
/* Decriments every 1 ms.*/
volatile static uint32 one_ms_timer;
 
/*this is the helper file that contains the user-configured setup() and loop() files, and where most of 
your code should be written. Note that any variables defined before this #include will be accessible to 
you as global variables in your functions, and that any defined after will not, and trying to use them in 
setup() and loop() will result in compile errors.*/
#include "program_functions.h"
 
/*after being reset, the PIC will run this main() function one time and then do nothing. It begins by 
initializing the system variables and then calling a setup() function (Just like the Arduino). After the 
setup function runs, the main() function enabled multi-vector interrupts, and then runs a loop() function 
continuously until the PIC is reset or loses power.*/
int main(void)
{   
	/* Configure the proper PB frequency and the number of wait states*/
	SYSTEMConfigPerformance(80000000L);
 
	/* Turn off JTAG so we get the pins back: JTAG is a debugging system that the PIC32 supports, but we don't need to use it.*/
 	mJTAGPortEnable(0);
 
	/* Open up the core timer at our CORE_TICK_RATE as defined above*/
	OpenCoreTimer(CORE_TICK_RATE);
 
    /* set up the core timer interrupt with a prioirty of 2 and zero sub-priority*/
	mConfigIntCoreTimer((CT_INT_ON | CT_INT_PRIOR_2 | CT_INT_SUB_PRIOR_0));
 
 
	/* Set all analog pins to be digital I/O
	The PIC defaults the analog pins to being analog pins when initially configured. Since in most 
	cases, you'll be using them for digital I/O instead, this line is included when the chip initializes 
	to allow for the use of the analog pins as digital I/O pins. If you want to set them up as Analog 
	input pins, you'll need to change the configuration in setup();*/
    AD1PCFG = 0xFFFF;
 
	/*setup() works just like the setup() function on an arduino board. it will run once at reset, then never again.*/
	setup();
 
    /* enable multi-vector interrupts
	These allow interrupt messages to the PIC to list what type of interrupt they are to make handling 
	them much faster. Look ot future blog posts from beyondarduino.com to explain the interrupt system in 
	greater depth.*/
	INTEnableSystemMultiVectoredInt();
 
    while(1)
    {
		/*the loop function now runs your custom code just like in an arduino. It will run continuously until the PIC is reset.*/
	    loop();
    }
}
 
/*this is the function that runs every CORE_TICK_RATE for controlling a timer. It is an interrupt 
function, so it will stop executing code in your loop() function and run this function immediately. 
It should be noted that interrupts should be kept as short as possible to avoid bogging your 
program down.*/
void __ISR(_CORE_TIMER_VECTOR, ipl2) CoreTimerHandler(void)
{
    /* clear the interrupt flag
	/*clearing this flag allows the normal code to resume after this interrupt function has run, and allows the interrupt to be called again*/
    mCTClearIntFlag();
 
	/*the way the timer is setup is similar to the arduino example "blink without delay". In "Blink 
	Without Delay" the number of miliseconds is counted from when the arduino starts, and the value 
	is compared to the last time the LED changed states. In this code, a 'countdown timer' (one_ms_timer) 
	is assigned in your loop() function which tells the program to count down every CORE_TICK_RATE 
	until the timer value is 0. So in the loop() function, it will check to see if the timer has run 
	out, and if it has, it will reset the timer to start over after preforming an action. This is 
	basically backwards from the arduino, but it should be fairly simple once you get the hang of it.*/
	if (one_ms_timer)
	{
		one_ms_timer--;
	}
 
    /*this tells the core timer how many ticks to wait before triggering the interrupt again. If you do not 
	set this, the core timer will not continue to be triggered.*/
    UpdateCoreTimer(CORE_TICK_RATE);
}

/*
Program_functions.h by Tim Anderson as part of a UBW32 Hello World Project
This should look roughly like an Arduino IDE function now. The PIC will 
call setup() once upon reset and then call loop() forever more.
*/
 
/*Once you get used to using the PIC, you'll probably not need to modify 
the main.c file very much. All your program code can be handled in the 
setup() and loop() functions just like with the Arduino. The only 
difference is you get to peek at some of what's happening in the 
background and have the ability to easily modify it while using the UBW32.*/
 
/*as with the Arduino, setup() is called once and runs only after a reset.*/
void setup(){
    /*Initialize all of the LED pins on the UBW32. This is one of the 
	built-in functions of HardwareProfile.h It configures all 4 of the 
	user-controlled LED pins to be outputs, and sets them all to the 
	LOW state, turning them off.*/
	mInitAllLEDs();
 
	/*This is another HardwareProfile.h function that will set LED2 (
	The white LED) to be on when the system is first initialized.*/
	mLED_2_On();
 
	/*this will initialize the one_ms_timer to trigger after 1000ms, or 1
	second, has passed.*/
	one_ms_timer = 1000;
}
 
/*this loop function will be called continuously for as long as the PIC 
is running. it works just like the loop() function on the Arduino.*/
void loop(){
	/*Since our goal is simply to blink an LED, all we'll be doing is 
	checking to see if our countdown timer has run out, then toggling 
	the LED and resetting it.*/
	if(!one_ms_timer){
		mLED_2_Toggle();/*this is a HardwareProfiles.h function for changing the state of an LED on the UBW32.*/
		one_ms_timer = 1000; /*this resets the timer so that the LED will toggle again in one second.*/
	}
}