Frc Demo.c Ukážkový program
From RoboWiki
/******************************************************************************
*
* Freescale Semiconductor Inc.
* (c) Copyright 2008 Freescale Semiconductor, Inc.
* ALL RIGHTS RESERVED.
*
*******************************************************************************
*
* File main.c
*
* Author Milan Brejl
*
* Version 0.2
*
* Date 19-Nov-2008
*
* Brief Quick start with the Self-Driven Slot Car development
*
*******************************************************************************
* History:
* 0.1 (14-Oct-2008) Initial version
* 0.2 (19-Nov-2008)
*******************************************************************************
*
* This file includes initialization code and macros enabling to quickly start
* with the development of a Self-Driven Slot Car.
*
* At the current state, the application branches into one of 2 modes, based on
* the slot car vertical position. If the car is placed on the track, it slowly
* starts up, drives the car by a 50% voltage, samples all analog signals (motor
* current, X, Y, and Z accelerations, and DC-Bus voltage) and stores the X
* acceleration into the EEPROM. In the wheels-up position, detected using the
* gravitational acceleration in Z axis, the data from EEPROM can be downloaded
* into an Excel sheet using the ReadEEPROM.pmp FreeMASTER project.
*
* Notes:
* 1) The MCU S08JM32 is configured to run at 48MHz CPU clock and 24MHz BUS
* clock.
* The OSBDM debugger can be used to program the flash and run the
* application, but it can not step and break the code at such a high rate.
* 2) The motor is controlled in one direction only, using a motorVoltage
* unsigned int variable (range 0 to 6000) and a PWM signal of corresponding
* duty-cycle.
* In order to control the motor in both directions (active breaking), the
* initialization of the TPM1 module needs to be modified for a generation of
* 2 PWM signals. For more information refer to the MC33887 H-bridge manual.
* 3) The external EEPROM is handled by the Jaroslav Necesany's driver
* eeprom.c/.h, included into the project.
*
******************************************************************************/
#include <hidef.h> /* for EnableInterrupts macro */
#include "derivative.h" /* include peripheral declarations */
#include "slotcarutils.h" /* utilities */
#include "eeprom.h" /* driver for external EEPROM via IIC */
/******************************************************************************
* Constants and macros
******************************************************************************/
/* LEDs */
/*
* There are 4 LEds build into the head and break lights.
* HL = head light - left, HR = head light - right,
* BL = break light - left, BR = break light - right
* The following macros control the LEDs state, ON or OFF.
*/
#define SET_LED_HL_ON PTAD_PTAD0 = 1
#define SET_LED_HL_OFF PTAD_PTAD0 = 0
#define SET_LED_HR_ON PTAD_PTAD1 = 1
#define SET_LED_HR_OFF PTAD_PTAD1 = 0
#define SET_LED_BL_ON PTAD_PTAD2 = 1
#define SET_LED_BL_OFF PTAD_PTAD2 = 0
#define SET_LED_BR_ON PTAD_PTAD3 = 1
#define SET_LED_BR_OFF PTAD_PTAD3 = 0
/* SWITCH */
/*
* There is a 2-position switch.
* The following macro reads the switch position, returning 1 or 0.
*/
#define GET_SWITCH_STATE PTCD_PTCD6
/* ACCELEROMETER */
/*
* There is a 3-axis accelerometer with analog outputs.
* The accelerometer range is configurable for either +/- 1.5g or +/- 6g.
* The accelerometer analog outputs can be sampled by the on-chip Analog-to-
* -Digital Converter.
* The following macros set the accelerometer range and define the ADC
* channels of the X, Y and Z accelerometer outputs:
* X ... left and right (+ left, - right)
* Y ... ahead and back (+ ahead, - back)
* Z ... up and down (+ down, - up)
*/
#define SET_ACC_RANGE_1_5_G PTCD_PTCD2 = 0
#define SET_ACC_RANGE_6_G PTCD_PTCD2 = 1
#define ACC_X 2
#define ACC_Y 1
#define ACC_Z 0
/* MOTOR */
/*
* There is an H-brigde driving the DC motor.
* The motor drive can be enabled or disabled. When enabled, the applied motor
* voltage is controlled by a PWM duty-cycle.
* The H-brigde circuit returns a fault status in case of undervoltage,
* short circuit, or overtemperature condition.
* The motor current feedback can be sampled by the on-chip Analog-to-Digital
* Converter.
* The following macros enable or disable the motor drive, set the motor
* voltage, get the motor fault status and define the ADC channel of
* the motor current.
*/
#define MOTOR_ENABLE PTCD_PTCD4 = 1
#define MOTOR_DISABLE PTCD_PTCD4 = 0
#define SET_MOTOR_VOLTAGE(x) TPM1C2V = (x)
#define GET_MOTOR_VOLTAGE TPM1C2V
#define GET_MOTOR_FAULT_STATUS PTGD_PTGD2
#define MOTOR_STATUS_OK 1
#define MOTOR_STATUS_FAULT 0
#define MOTOR_CURRENT 5
/* DC-BUS VOLTAGE */
/*
* There is a circuit which enables to measure the DC-Bus voltage.
* The DC-Bus Voltage Compensation technique enables to set a correct motor
* voltage and keep it independent of a the actual DC-Bus voltage.
* The following macros defines the ADC channel of the DC-Bus voltage.
*/
#define DC_BUS_VOLTAGE 11
/* ADC */
/*
* The following macros enable to initializes the sampling and
* conversion of an analog signal a defined read a conversion result - a 12-bit sample,
* to check if the Analog-to-Digital Converter is busy by an active conversion, and
* switch conversion resolution (8/10/12-bit mode)
*/
#define START_CONV(channel) ADCSC1 = ADCSC1_AIEN_MASK | (channel)
#define READ_ADC_SAMPLE ADCR
#define GET_ADC_ACTIVE_FLAG ADCSC2_ADACT
#define SET_ADC_MODE_8_BIT ADCCFG_MODE = 0
#define SET_ADC_MODE_10_BIT ADCCFG_MODE = 2
#define SET_ADC_MODE_12_BIT ADCCFG_MODE = 1
/* OUTAGE */
/*
* There is a circuit which enables to detect a power supply outage
* on the line change or crossover track pieces.
*/
#define GET_OUTAGE_DIR1 PTGD_PTGD0
#define GET_OUTAGE_DIR2 PTGD_PTGD1
/******************************************************************************
* Global variables
******************************************************************************/
/* application */
enum {
APP_MODE_RUN,
APP_MODE_DOWNLOAD
} appMode;
/* accelerometer */
unsigned int accX, accY, accZ; /* 12-bit unsigned samples */
/* motor */
unsigned int motorVoltage; /* range 0 to 6000 */
unsigned int motorCurrent; /* 12-bit unsigned sample */
/* dc-bus */
unsigned int dcBus; /* 12-bit unsigned sample */
/* global time */
unsigned int timeCounter; /* global free-running 1/2ms counter */
/* extern global variables */
extern enum SEMAPHORE semaphore1;
/******************************************************************************
* Functions
******************************************************************************/
/******************************************************************************
* Interrupt Handlers
******************************************************************************/
/* Timer/PWM Interrupt */
interrupt VectorNumber_Vtpm1ovf void Vtpm1ovf_isr(void)
{
/* clear interrupt flag */
TPM1SC_TOF = 0;
/* update PWM duty-cycle according to the global variable motorVoltage */
SET_MOTOR_VOLTAGE(motorVoltage);
/* Start sequence of analog inputs sampling */
START_CONV(MOTOR_CURRENT);
/* Update the global 1/2ms timeCounter */
timeCounter++;
}
/* ADC Conversion Complete Interrupt */
interrupt VectorNumber_Vadc void Vadc_isr(void)
{
/*
* Read the new sample using GET_ADC_SAMPLE macro.
* The reading also clears the interrupt flag.
* Put all samples into the buffer.
*/
switch(ADCSC1_ADCH)
{
case MOTOR_CURRENT:
motorCurrent = READ_ADC_SAMPLE;
START_CONV(ACC_X);
break;
case ACC_X:
accX = READ_ADC_SAMPLE;
START_CONV(ACC_Y);
PutToBuffer16(accX); /* store accX to EEPROM */
break;
case ACC_Y:
accY = READ_ADC_SAMPLE;
START_CONV(ACC_Z);
break;
case ACC_Z:
accZ = READ_ADC_SAMPLE;
START_CONV(DC_BUS_VOLTAGE);
break;
case DC_BUS_VOLTAGE:
dcBus = READ_ADC_SAMPLE;
break;
}
}
/* Keyboard Interrupt */
interrupt VectorNumber_Vkeyboard void Vkeyboard_isr(void)
{
/* clear interrupt flag */
KBISC_KBACK=1;
}
/******************************************************************************
* Main
******************************************************************************/
void main(void)
{
/********** Device Initialization **********/
/* initialize the Multi-Purpose Clock Generator (MCG)
for 48MHz CPU clock and 24MHz bus clock */
MCGC2 = 0x36; /* MCGC2: BDIV=0,RANGE=1,HGO=1,LP=0,EREFS=1,ERCLKEN=1,EREFSTEN=0 */
MCGC1 = 0xB8; /* MCGC1: CLKS=2,RDIV=7,IREFS=0,IRCLKEN=0,IREFSTEN=0 */
while(!MCGSC_OSCINIT); /* Wait until external reference is stable */
while(MCGSC_IREFST); /* Wait until external reference is selected */
while((MCGSC & 0x0C) != 0x08); /* Wait until external clock is selected as a bus clock reference */
MCGC2 = 0x3E; /* MCGC2: BDIV=0,RANGE=1,HGO=1,LP=1,EREFS=1,ERCLKEN=1,EREFSTEN=0 */
MCGC1 = 0x88; /* MCGC1: CLKS=2,RDIV=1,IREFS=0,IRCLKEN=0,IREFSTEN=0 */
MCGC3 = 0x46; /* MCGC3: LOLIE=0,PLLS=1,CME=0,VDIV=6 */
MCGC2 &= (unsigned char)~0x08; /* MCGC2: LP=0 */
while(!MCGSC_PLLST); /* Wait until PLL is selected */
while(!MCGSC_LOCK); /* Wait until PLL is locked */
MCGC1 = 0x08; /* MCGC1: CLKS=0,RDIV=1,IREFS=0,IRCLKEN=0,IREFSTEN=0 */
while((MCGSC & 0x0C) != 0x0C); /* Wait until PLL clock is selected as a bus clock reference */
/* disable the COP watchdog */
SOPT1_COPT = 0;
/* initialize the LEDs as outputs */
PTADD_PTADD0 = 1; /* output to LED1 */
PTADD_PTADD1 = 1; /* output to LED2 */
PTADD_PTADD2 = 1; /* output to LED3 */
PTADD_PTADD3 = 1; /* output to LED4 */
/* initialize the SWITCH as an input with pull-up */
PTCDD_PTCDD6 = 0; /* input from switch */
PTCPE_PTCPE6 = 1; /* pull-up enable */
/* initialize the ACCELEROMETER range select as an output */
PTCDD_PTCDD2 = 1; /* output to G-select */
/* initialize the MOTOR driver inputs as outputs */
PTCDD_PTCDD4 = 1; /* output to EN */
PTADD_PTADD5 = 1; /* output to D1 */
PTADD_PTADD4 = 1; /* output to D2 */
PTFDD_PTFDD2 = 1; /* output to IN2 */
/* initialize the MOTOR driver fault status output as an input */
PTFDD_PTFDD1 = 0; /* input from fault status */
/* initialize TPM1 for PWM generation */
TPM1SC = 0;
TPM1MOD = 6000; /* Modulo = 6000 => f = 24MHz/1/(6000*2) = 2kHz */
TPM1SC_CLKSx = 1; /* clock source = bus clock */
TPM1SC_PS = 0; /* prescaler divider = 1 */
TPM1SC_CPWMS = 1; /* center-aligned PWM */
TPM1C2SC_ELS2x = 2; /* low-true pulses */
TPM1SC_TOIE = 1; /* enable overflow interrupt */
/* initialize the ADC */
ADCCFG_ADICLK = 1;/* input clock = bus clock divided by 2 */
ADCCFG_ADIV = 1; /* input clock div = 2 */
ADCCFG_ADLSMP = 1;/* long sample time enabled */
ADCCFG_MODE = 1; /* 12-bit mode */
ADCSC2_ADTRG = 0; /* software trigger */
APCTL1_ADPC0 = 1; /* pin ADP0 is ADC input - accelerometer Z */
APCTL1_ADPC1 = 1; /* pin ADP1 is ADC input - accelerometer Y */
APCTL1_ADPC2 = 1; /* pin ADP2 is ADC input - accelerometer X */
APCTL1_ADPC5 = 1; /* pin ADP5 is ADC input - motor current */
APCTL2_ADPC11 = 1; /* pin ADP11 is ADC input - dc-bus voltage */
/* initialize Keyboard Interrupt to detect outage */
KBIES_KBEDG0 = 0; /* detect falling edge from OUTAGE_DIR1 */
KBIES_KBEDG1 = 0; /* detect falling edge from OUTAGE_DIR2 */
KBISC_KBMOD = 0; /* detect edge only */
KBIPE_KBIPE0 = 1; /* enable OUTAGE_DIR1 pin interrupt */
KBIPE_KBIPE1 = 1; /* enable OUTAGE_DIR2 pin interrupt */
KBISC_KBIE = 1; /* enable interrupts */
/* enable interrupts */
EnableInterrupts;
/************ Board HW Initialization *************/
/* initialize the Accelerometr */
SET_ACC_RANGE_1_5_G;
/* initialize the Motor H-bridge driver */
PTAD_PTAD5 = 0; /* set D1 low */
PTAD_PTAD4 = 1; /* set D2 high */
PTFD_PTFD2 = 0; /* set IN2 low */
MOTOR_DISABLE;
motorVoltage = 0;
/* initialize EEPROM */
EepromInit(0x45); /* 400kbit/sec at 24MHz Bus clock */
/************* Start-up *************/
/* indicate the actual switch position */
Wait(1000);
if(GET_SWITCH_STATE == 1)
{
/* blink front lights once */
SET_LED_HL_ON;
SET_LED_HR_ON;
Wait(300);
}
else
{
/* blink front lights twice */
SET_LED_HL_ON;
SET_LED_HR_ON;
Wait(100);
SET_LED_HL_OFF;
SET_LED_HR_OFF;
Wait(100);
SET_LED_HL_ON;
SET_LED_HR_ON;
Wait(100);
}
SET_LED_HL_OFF;
SET_LED_HR_OFF;
/* test if the car is in the wheels up position and set application mode */
if (accZ > 2048)
{
appMode = APP_MODE_DOWNLOAD;
DisableInterrupts;
}
else
{
appMode = APP_MODE_RUN;
/* slowly speed up */
MOTOR_ENABLE;
while(motorVoltage <= 3000)
{
motorVoltage++;
Wait(1);
}
}
/************* Background Loop *************/
for(;;)
{
switch(appMode)
{
case APP_MODE_DOWNLOAD:
/* Download buffer from EEPROM if empty */
LoadBufferFromEeprom();
/* Show page-by-page downloading on break LEDs */
if (semaphore1)
{
SET_LED_BR_ON;
SET_LED_BL_OFF;
}
else
{
SET_LED_BR_OFF;
SET_LED_BL_ON;
}
break;
case APP_MODE_RUN:
/* Upload buffer to EEPROM if filled up */
StoreBufferToEeprom();
/* Check motor fault status */
if(GET_MOTOR_FAULT_STATUS == MOTOR_STATUS_FAULT)
{
motorVoltage = 0;
SET_LED_BL_ON;
SET_LED_BR_ON;
}
break;
}
} /* loop forever */
}
