Pascal Sandrez / FRDM-TFC

Custom version for NXP cup car

Dependents:   NXPCUPcar

Fork of FRDM-TFC by Eli Hughes

TFC.cpp@9:0c6d78c56091, 2017-06-01 (annotated)

Committer:
Clarkk
Date:
Thu Jun 01 13:16:37 2017 +0000
Revision:
9:0c6d78c56091
Parent:
8:24430a0d7fd8 
Few changes

Who changed what in which revision?

UserRevisionLine numberNew contents of line
emh203 1:6f37253dab87 1 #include "mbed.h"
emh203 1:6f37253dab87 2 #include "TFC.h"
emh203 1:6f37253dab87 3
emh203 1:6f37253dab87 4 #define FTM1_CLK_PRESCALE 6// Prescale Selector value - see comments in Status Control (SC) section for more details
emh203 1:6f37253dab87 5 #define SERVO_DEFAULT_PERIOD (float)(.020) // Desired Frequency of PWM Signal - Here 50Hz => 20ms period
emh203 1:6f37253dab87 6 // use these to dial in servo steering to your particular servo
Clarkk 9:0c6d78c56091 7 #define SERVO_MIN_PULSE_WIDTH_DEFAULT (float)(.0005) // The number here should be be *pulse width* in seconds to move servo to its left limit
Clarkk 9:0c6d78c56091 8 #define SERVO_MAX_PULSE_WIDTH_DEFAULT (float)(.00150) // The number here should be be *pulse width* in seconds to move servo to its left limit
emh203 1:6f37253dab87 9
emh203 1:6f37253dab87 10
emh203 1:6f37253dab87 11 #define FTM0_CLOCK (SystemCoreClock/2)
emh203 1:6f37253dab87 12 #define FTM0_CLK_PRESCALE (0) // Prescale Selector value - see comments in Status Control (SC) section for more details
emh203 1:6f37253dab87 13 #define FTM0_DEFAULT_SWITCHING_FREQUENCY (4000.0)
emh203 1:6f37253dab87 14
emh203 1:6f37253dab87 15 #define ADC_MAX_CODE (4095)
emh203 1:6f37253dab87 16
emh203 1:6f37253dab87 17 #define TAOS_CLK_HIGH PTE->PSOR = (1<<1)
emh203 1:6f37253dab87 18 #define TAOS_CLK_LOW PTE->PCOR = (1<<1)
emh203 1:6f37253dab87 19 #define TAOS_SI_HIGH PTD->PSOR = (1<<7)
emh203 1:6f37253dab87 20 #define TAOS_SI_LOW PTD->PCOR = (1<<7)
emh203 1:6f37253dab87 21
emh203 1:6f37253dab87 22 #define ADC_STATE_INIT 0
emh203 1:6f37253dab87 23 #define ADC_STATE_CAPTURE_POT_0 1
emh203 1:6f37253dab87 24 #define ADC_STATE_CAPTURE_POT_1 2
emh203 1:6f37253dab87 25 #define ADC_STATE_CAPTURE_BATTERY_LEVEL 3
emh203 1:6f37253dab87 26 #define ADC_STATE_CAPTURE_LINE_SCAN 4
Clarkk 9:0c6d78c56091 27 #define ADC_STATE_CAPTURE_MOTOR_A_CURRENT 5
Clarkk 9:0c6d78c56091 28 #define ADC_STATE_CAPTURE_MOTOR_B_CURRENT 6
emh203 1:6f37253dab87 29
emh203 1:6f37253dab87 30 #define TFC_POT_0_ADC_CHANNEL 13
emh203 1:6f37253dab87 31 #define TFC_POT_1_ADC_CHANNEL 12
emh203 1:6f37253dab87 32 #define TFC_BAT_SENSE_CHANNEL 4
emh203 1:6f37253dab87 33 #define TFC_LINESCAN0_ADC_CHANNEL 6
emh203 1:6f37253dab87 34 #define TFC_LINESCAN1_ADC_CHANNEL 7
Clarkk 9:0c6d78c56091 35 #define TFC_IFB_MOTA_ADC_CHANNEL 7
Clarkk 9:0c6d78c56091 36 #define TFC_IFB_MOTB_ADC_CHANNEL 3
emh203 1:6f37253dab87 37
emh203 1:6f37253dab87 38
emh203 1:6f37253dab87 39 #define ADC0_irq_no 57
emh203 1:6f37253dab87 40 #define ADC1_irq_no 58
emh203 1:6f37253dab87 41
emh203 1:6f37253dab87 42 #define ADC0_CHANA 19 // set to desired ADC0 channel trigger A
emh203 1:6f37253dab87 43 #define ADC0_CHANB 20 // set to desired ADC0 channel trigger B
emh203 1:6f37253dab87 44
emh203 1:6f37253dab87 45 #define ADC1_CHANA 20 // set to desired ADC1 channel trigger A 20 defaults to potentiometer in TWRK60
emh203 1:6f37253dab87 46 #define ADC1_CHANB 20 // set to desired ADC1 channel trigger B
emh203 1:6f37253dab87 47
emh203 1:6f37253dab87 48 #define ADC0_DLYA 0x2000 // ADC0 trigger A delay
emh203 1:6f37253dab87 49 #define ADC0_DLYB 0x4000 // ADC0 trigger B delay
emh203 1:6f37253dab87 50 #define ADC1_DLYA 0x6000 // ADC1 trigger A delay
emh203 1:6f37253dab87 51 #define ADC1_DLYB 0x7fff // ADC1 trigger B delay
emh203 1:6f37253dab87 52
emh203 1:6f37253dab87 53
emh203 1:6f37253dab87 54 #define ADC0A_DONE 0x01
emh203 1:6f37253dab87 55 #define ADC0B_DONE 0x02
emh203 1:6f37253dab87 56 #define ADC1A_DONE 0x04
emh203 1:6f37253dab87 57 #define ADC1B_DONE 0x08
emh203 1:6f37253dab87 58
emh203 1:6f37253dab87 59
emh203 1:6f37253dab87 60 // Bit shifting of bitfiled is already taken into account so
emh203 1:6f37253dab87 61 // bitfiled values are always represented as relative to their position.
emh203 1:6f37253dab87 62
emh203 1:6f37253dab87 63 /************************* #Defines ******************************************/
emh203 1:6f37253dab87 64
emh203 1:6f37253dab87 65 #define A 0x0
emh203 1:6f37253dab87 66 #define B 0x1
emh203 1:6f37253dab87 67
emh203 1:6f37253dab87 68 /////// NOTE: the following defines relate to the ADC register definitions
emh203 1:6f37253dab87 69 /////// and the content follows the reference manual, using the same symbols.
emh203 1:6f37253dab87 70
emh203 1:6f37253dab87 71
emh203 1:6f37253dab87 72 //// ADCSC1 (register)
emh203 1:6f37253dab87 73
emh203 1:6f37253dab87 74 // Conversion Complete (COCO) mask
emh203 1:6f37253dab87 75 #define COCO_COMPLETE ADC_SC1_COCO_MASK
emh203 1:6f37253dab87 76 #define COCO_NOT 0x00
emh203 1:6f37253dab87 77
emh203 1:6f37253dab87 78 // ADC interrupts: enabled, or disabled.
emh203 1:6f37253dab87 79 #define AIEN_ON ADC_SC1_AIEN_MASK
emh203 1:6f37253dab87 80 #define AIEN_OFF 0x00
emh203 1:6f37253dab87 81
emh203 1:6f37253dab87 82 // Differential or Single ended ADC input
emh203 1:6f37253dab87 83 #define DIFF_SINGLE 0x00
emh203 1:6f37253dab87 84 #define DIFF_DIFFERENTIAL ADC_SC1_DIFF_MASK
emh203 1:6f37253dab87 85
emh203 1:6f37253dab87 86 //// ADCCFG1
emh203 1:6f37253dab87 87
emh203 1:6f37253dab87 88 // Power setting of ADC
emh203 1:6f37253dab87 89 #define ADLPC_LOW ADC_CFG1_ADLPC_MASK
emh203 1:6f37253dab87 90 #define ADLPC_NORMAL 0x00
emh203 1:6f37253dab87 91
emh203 1:6f37253dab87 92 // Clock divisor
emh203 1:6f37253dab87 93 #define ADIV_1 0x00
emh203 1:6f37253dab87 94 #define ADIV_2 0x01
emh203 1:6f37253dab87 95 #define ADIV_4 0x02
emh203 1:6f37253dab87 96 #define ADIV_8 0x03
emh203 1:6f37253dab87 97
emh203 1:6f37253dab87 98 // Long samle time, or Short sample time
emh203 1:6f37253dab87 99 #define ADLSMP_LONG ADC_CFG1_ADLSMP_MASK
emh203 1:6f37253dab87 100 #define ADLSMP_SHORT 0x00
emh203 1:6f37253dab87 101
emh203 1:6f37253dab87 102 // How many bits for the conversion? 8, 12, 10, or 16 (single ended).
emh203 1:6f37253dab87 103 #define MODE_8 0x00
emh203 1:6f37253dab87 104 #define MODE_12 0x01
emh203 1:6f37253dab87 105 #define MODE_10 0x02
emh203 1:6f37253dab87 106 #define MODE_16 0x03
emh203 1:6f37253dab87 107
emh203 1:6f37253dab87 108
emh203 1:6f37253dab87 109
emh203 1:6f37253dab87 110 // ADC Input Clock Source choice? Bus clock, Bus clock/2, "altclk", or the
emh203 1:6f37253dab87 111 // ADC's own asynchronous clock for less noise
emh203 1:6f37253dab87 112 #define ADICLK_BUS 0x00
emh203 1:6f37253dab87 113 #define ADICLK_BUS_2 0x01
emh203 1:6f37253dab87 114 #define ADICLK_ALTCLK 0x02
emh203 1:6f37253dab87 115 #define ADICLK_ADACK 0x03
emh203 1:6f37253dab87 116
emh203 1:6f37253dab87 117 //// ADCCFG2
emh203 1:6f37253dab87 118
emh203 1:6f37253dab87 119 // Select between B or A channels
emh203 1:6f37253dab87 120 #define MUXSEL_ADCB ADC_CFG2_MUXSEL_MASK
emh203 1:6f37253dab87 121 #define MUXSEL_ADCA 0x00
emh203 1:6f37253dab87 122
emh203 1:6f37253dab87 123 // Ansync clock output enable: enable, or disable the output of it
emh203 1:6f37253dab87 124 #define ADACKEN_ENABLED ADC_CFG2_ADACKEN_MASK
emh203 1:6f37253dab87 125 #define ADACKEN_DISABLED 0x00
emh203 1:6f37253dab87 126
emh203 1:6f37253dab87 127 // High speed or low speed conversion mode
emh203 1:6f37253dab87 128 #define ADHSC_HISPEED ADC_CFG2_ADHSC_MASK
emh203 1:6f37253dab87 129 #define ADHSC_NORMAL 0x00
emh203 1:6f37253dab87 130
emh203 1:6f37253dab87 131 // Long Sample Time selector: 20, 12, 6, or 2 extra clocks for a longer sample time
emh203 1:6f37253dab87 132 #define ADLSTS_20 0x00
emh203 1:6f37253dab87 133 #define ADLSTS_12 0x01
emh203 1:6f37253dab87 134 #define ADLSTS_6 0x02
emh203 1:6f37253dab87 135 #define ADLSTS_2 0x03
emh203 1:6f37253dab87 136
emh203 1:6f37253dab87 137 ////ADCSC2
emh203 1:6f37253dab87 138
emh203 1:6f37253dab87 139 // Read-only status bit indicating conversion status
emh203 1:6f37253dab87 140 #define ADACT_ACTIVE ADC_SC2_ADACT_MASK
emh203 1:6f37253dab87 141 #define ADACT_INACTIVE 0x00
emh203 1:6f37253dab87 142
emh203 1:6f37253dab87 143 // Trigger for starting conversion: Hardware trigger, or software trigger.
emh203 1:6f37253dab87 144 // For using PDB, the Hardware trigger option is selected.
emh203 1:6f37253dab87 145 #define ADTRG_HW ADC_SC2_ADTRG_MASK
emh203 1:6f37253dab87 146 #define ADTRG_SW 0x00
emh203 1:6f37253dab87 147
emh203 1:6f37253dab87 148 // ADC Compare Function Enable: Disabled, or Enabled.
emh203 1:6f37253dab87 149 #define ACFE_DISABLED 0x00
emh203 1:6f37253dab87 150 #define ACFE_ENABLED ADC_SC2_ACFE_MASK
emh203 1:6f37253dab87 151
emh203 1:6f37253dab87 152 // Compare Function Greater Than Enable: Greater, or Less.
emh203 1:6f37253dab87 153 #define ACFGT_GREATER ADC_SC2_ACFGT_MASK
emh203 1:6f37253dab87 154 #define ACFGT_LESS 0x00
emh203 1:6f37253dab87 155
emh203 1:6f37253dab87 156 // Compare Function Range Enable: Enabled or Disabled.
emh203 1:6f37253dab87 157 #define ACREN_ENABLED ADC_SC2_ACREN_MASK
emh203 1:6f37253dab87 158 #define ACREN_DISABLED 0x00
emh203 1:6f37253dab87 159
emh203 1:6f37253dab87 160 // DMA enable: enabled or disabled.
emh203 1:6f37253dab87 161 #define DMAEN_ENABLED ADC_SC2_DMAEN_MASK
emh203 1:6f37253dab87 162 #define DMAEN_DISABLED 0x00
emh203 1:6f37253dab87 163
emh203 1:6f37253dab87 164 // Voltage Reference selection for the ADC conversions
emh203 1:6f37253dab87 165 // (***not*** the PGA which uses VREFO only).
emh203 1:6f37253dab87 166 // VREFH and VREFL (0) , or VREFO (1).
emh203 1:6f37253dab87 167
emh203 1:6f37253dab87 168 #define REFSEL_EXT 0x00
emh203 1:6f37253dab87 169 #define REFSEL_ALT 0x01
emh203 1:6f37253dab87 170 #define REFSEL_RES 0x02 /* reserved */
emh203 1:6f37253dab87 171 #define REFSEL_RES_EXT 0x03 /* reserved but defaults to Vref */
emh203 1:6f37253dab87 172
emh203 1:6f37253dab87 173 ////ADCSC3
emh203 1:6f37253dab87 174
emh203 1:6f37253dab87 175 // Calibration begin or off
emh203 1:6f37253dab87 176 #define CAL_BEGIN ADC_SC3_CAL_MASK
emh203 1:6f37253dab87 177 #define CAL_OFF 0x00
emh203 1:6f37253dab87 178
emh203 1:6f37253dab87 179 // Status indicating Calibration failed, or normal success
emh203 1:6f37253dab87 180 #define CALF_FAIL ADC_SC3_CALF_MASK
emh203 1:6f37253dab87 181 #define CALF_NORMAL 0x00
emh203 1:6f37253dab87 182
emh203 1:6f37253dab87 183 // ADC to continously convert, or do a sinle conversion
emh203 1:6f37253dab87 184 #define ADCO_CONTINUOUS ADC_SC3_ADCO_MASK
emh203 1:6f37253dab87 185 #define ADCO_SINGLE 0x00
emh203 1:6f37253dab87 186
emh203 1:6f37253dab87 187 // Averaging enabled in the ADC, or not.
emh203 1:6f37253dab87 188 #define AVGE_ENABLED ADC_SC3_AVGE_MASK
emh203 1:6f37253dab87 189 #define AVGE_DISABLED 0x00
emh203 1:6f37253dab87 190
emh203 1:6f37253dab87 191 // How many to average prior to "interrupting" the MCU? 4, 8, 16, or 32
emh203 1:6f37253dab87 192 #define AVGS_4 0x00
emh203 1:6f37253dab87 193 #define AVGS_8 0x01
emh203 1:6f37253dab87 194 #define AVGS_16 0x02
emh203 1:6f37253dab87 195 #define AVGS_32 0x03
emh203 1:6f37253dab87 196
emh203 1:6f37253dab87 197 ////PGA
emh203 1:6f37253dab87 198
emh203 1:6f37253dab87 199 // PGA enabled or not?
emh203 1:6f37253dab87 200 #define PGAEN_ENABLED ADC_PGA_PGAEN_MASK
emh203 1:6f37253dab87 201 #define PGAEN_DISABLED 0x00
emh203 1:6f37253dab87 202
emh203 1:6f37253dab87 203 // Chopper stabilization of the amplifier, or not.
emh203 1:6f37253dab87 204 #define PGACHP_CHOP ADC_PGA_PGACHP_MASK
emh203 1:6f37253dab87 205 #define PGACHP_NOCHOP 0x00
emh203 1:6f37253dab87 206
emh203 1:6f37253dab87 207 // PGA in low power mode, or normal mode.
emh203 1:6f37253dab87 208 #define PGALP_LOW ADC_PGA_PGALP_MASK
emh203 1:6f37253dab87 209 #define PGALP_NORMAL 0x00
emh203 1:6f37253dab87 210
emh203 1:6f37253dab87 211 // Gain of PGA. Selectable from 1 to 64.
emh203 1:6f37253dab87 212 #define PGAG_1 0x00
emh203 1:6f37253dab87 213 #define PGAG_2 0x01
emh203 1:6f37253dab87 214 #define PGAG_4 0x02
emh203 1:6f37253dab87 215 #define PGAG_8 0x03
emh203 1:6f37253dab87 216 #define PGAG_16 0x04
emh203 1:6f37253dab87 217 #define PGAG_32 0x05
emh203 1:6f37253dab87 218 #define PGAG_64 0x06
emh203 1:6f37253dab87 219
emh203 1:6f37253dab87 220 /////////// The above values fit into the structure below to select ADC/PGA
emh203 1:6f37253dab87 221 /////////// configuration desired:
emh203 1:6f37253dab87 222
emh203 1:6f37253dab87 223 typedef struct adc_cfg {
emh203 1:6f37253dab87 224 uint8_t CONFIG1;
emh203 1:6f37253dab87 225 uint8_t CONFIG2;
emh203 1:6f37253dab87 226 uint16_t COMPARE1;
emh203 1:6f37253dab87 227 uint16_t COMPARE2;
emh203 1:6f37253dab87 228 uint8_t STATUS2;
emh203 1:6f37253dab87 229 uint8_t STATUS3;
emh203 1:6f37253dab87 230 uint8_t STATUS1A;
emh203 1:6f37253dab87 231 uint8_t STATUS1B;
emh203 1:6f37253dab87 232 uint32_t PGA;
emh203 1:6f37253dab87 233 } *tADC_ConfigPtr, tADC_Config ;
emh203 1:6f37253dab87 234
emh203 1:6f37253dab87 235
emh203 1:6f37253dab87 236 #define CAL_BLK_NUMREC 18
emh203 1:6f37253dab87 237
emh203 1:6f37253dab87 238 typedef struct adc_cal {
emh203 1:6f37253dab87 239 uint16_t OFS;
emh203 1:6f37253dab87 240 uint16_t PG;
emh203 1:6f37253dab87 241 uint16_t MG;
emh203 1:6f37253dab87 242 uint8_t CLPD;
emh203 1:6f37253dab87 243 uint8_t CLPS;
emh203 1:6f37253dab87 244 uint16_t CLP4;
emh203 1:6f37253dab87 245 uint16_t CLP3;
emh203 1:6f37253dab87 246 uint8_t CLP2;
emh203 1:6f37253dab87 247 uint8_t CLP1;
emh203 1:6f37253dab87 248 uint8_t CLP0;
emh203 1:6f37253dab87 249 uint8_t dummy;
emh203 1:6f37253dab87 250 uint8_t CLMD;
emh203 1:6f37253dab87 251 uint8_t CLMS;
emh203 1:6f37253dab87 252 uint16_t CLM4;
emh203 1:6f37253dab87 253 uint16_t CLM3;
emh203 1:6f37253dab87 254 uint8_t CLM2;
emh203 1:6f37253dab87 255 uint8_t CLM1;
emh203 1:6f37253dab87 256 uint8_t CLM0;
emh203 1:6f37253dab87 257 } tADC_Cal_Blk ;
emh203 1:6f37253dab87 258
emh203 1:6f37253dab87 259 typedef struct ADC_MemMap {
emh203 1:6f37253dab87 260 uint32_t SC1[2]; /**< ADC Status and Control Registers 1, array offset: 0x0, array step: 0x4 */
emh203 1:6f37253dab87 261 uint32_t CFG1; /**< ADC Configuration Register 1, offset: 0x8 */
emh203 1:6f37253dab87 262 uint32_t CFG2; /**< ADC Configuration Register 2, offset: 0xC */
emh203 1:6f37253dab87 263 uint32_t R[2]; /**< ADC Data Result Register, array offset: 0x10, array step: 0x4 */
emh203 1:6f37253dab87 264 uint32_t CV1; /**< Compare Value Registers, offset: 0x18 */
emh203 1:6f37253dab87 265 uint32_t CV2; /**< Compare Value Registers, offset: 0x1C */
emh203 1:6f37253dab87 266 uint32_t SC2; /**< Status and Control Register 2, offset: 0x20 */
emh203 1:6f37253dab87 267 uint32_t SC3; /**< Status and Control Register 3, offset: 0x24 */
emh203 1:6f37253dab87 268 uint32_t OFS; /**< ADC Offset Correction Register, offset: 0x28 */
emh203 1:6f37253dab87 269 uint32_t PG; /**< ADC Plus-Side Gain Register, offset: 0x2C */
emh203 1:6f37253dab87 270 uint32_t MG; /**< ADC Minus-Side Gain Register, offset: 0x30 */
emh203 1:6f37253dab87 271 uint32_t CLPD; /**< ADC Plus-Side General Calibration Value Register, offset: 0x34 */
emh203 1:6f37253dab87 272 uint32_t CLPS; /**< ADC Plus-Side General Calibration Value Register, offset: 0x38 */
emh203 1:6f37253dab87 273 uint32_t CLP4; /**< ADC Plus-Side General Calibration Value Register, offset: 0x3C */
emh203 1:6f37253dab87 274 uint32_t CLP3; /**< ADC Plus-Side General Calibration Value Register, offset: 0x40 */
emh203 1:6f37253dab87 275 uint32_t CLP2; /**< ADC Plus-Side General Calibration Value Register, offset: 0x44 */
emh203 1:6f37253dab87 276 uint32_t CLP1; /**< ADC Plus-Side General Calibration Value Register, offset: 0x48 */
emh203 1:6f37253dab87 277 uint32_t CLP0; /**< ADC Plus-Side General Calibration Value Register, offset: 0x4C */
emh203 1:6f37253dab87 278 uint8_t RESERVED_0[4];
emh203 1:6f37253dab87 279 uint32_t CLMD; /**< ADC Minus-Side General Calibration Value Register, offset: 0x54 */
emh203 1:6f37253dab87 280 uint32_t CLMS; /**< ADC Minus-Side General Calibration Value Register, offset: 0x58 */
emh203 1:6f37253dab87 281 uint32_t CLM4; /**< ADC Minus-Side General Calibration Value Register, offset: 0x5C */
emh203 1:6f37253dab87 282 uint32_t CLM3; /**< ADC Minus-Side General Calibration Value Register, offset: 0x60 */
emh203 1:6f37253dab87 283 uint32_t CLM2; /**< ADC Minus-Side General Calibration Value Register, offset: 0x64 */
emh203 1:6f37253dab87 284 uint32_t CLM1; /**< ADC Minus-Side General Calibration Value Register, offset: 0x68 */
emh203 1:6f37253dab87 285 uint32_t CLM0; /**< ADC Minus-Side General Calibration Value Register, offset: 0x6C */
emh203 1:6f37253dab87 286 } volatile *ADC_MemMapPtr;
emh203 1:6f37253dab87 287
emh203 1:6f37253dab87 288
emh203 1:6f37253dab87 289
emh203 1:6f37253dab87 290 /* ADC - Register accessors */
emh203 1:6f37253dab87 291 #define ADC_SC1_REG(base,index) ((base)->SC1[index])
emh203 1:6f37253dab87 292 #define ADC_CFG1_REG(base) ((base)->CFG1)
emh203 1:6f37253dab87 293 #define ADC_CFG2_REG(base) ((base)->CFG2)
emh203 1:6f37253dab87 294 #define ADC_R_REG(base,index) ((base)->R[index])
emh203 1:6f37253dab87 295 #define ADC_CV1_REG(base) ((base)->CV1)
emh203 1:6f37253dab87 296 #define ADC_CV2_REG(base) ((base)->CV2)
emh203 1:6f37253dab87 297 #define ADC_SC2_REG(base) ((base)->SC2)
emh203 1:6f37253dab87 298 #define ADC_SC3_REG(base) ((base)->SC3)
emh203 1:6f37253dab87 299 #define ADC_OFS_REG(base) ((base)->OFS)
emh203 1:6f37253dab87 300 #define ADC_PG_REG(base) ((base)->PG)
emh203 1:6f37253dab87 301 #define ADC_MG_REG(base) ((base)->MG)
emh203 1:6f37253dab87 302 #define ADC_CLPD_REG(base) ((base)->CLPD)
emh203 1:6f37253dab87 303 #define ADC_CLPS_REG(base) ((base)->CLPS)
emh203 1:6f37253dab87 304 #define ADC_CLP4_REG(base) ((base)->CLP4)
emh203 1:6f37253dab87 305 #define ADC_CLP3_REG(base) ((base)->CLP3)
emh203 1:6f37253dab87 306 #define ADC_CLP2_REG(base) ((base)->CLP2)
emh203 1:6f37253dab87 307 #define ADC_CLP1_REG(base) ((base)->CLP1)
emh203 1:6f37253dab87 308 #define ADC_CLP0_REG(base) ((base)->CLP0)
emh203 1:6f37253dab87 309 #define ADC_CLMD_REG(base) ((base)->CLMD)
emh203 1:6f37253dab87 310 #define ADC_CLMS_REG(base) ((base)->CLMS)
emh203 1:6f37253dab87 311 #define ADC_CLM4_REG(base) ((base)->CLM4)
emh203 1:6f37253dab87 312 #define ADC_CLM3_REG(base) ((base)->CLM3)
emh203 1:6f37253dab87 313 #define ADC_CLM2_REG(base) ((base)->CLM2)
emh203 1:6f37253dab87 314 #define ADC_CLM1_REG(base) ((base)->CLM1)
emh203 1:6f37253dab87 315 #define ADC_CLM0_REG(base) ((base)->CLM0)
emh203 1:6f37253dab87 316
emh203 1:6f37253dab87 317 #define ADC0_BASE_PTR ((ADC_MemMapPtr)0x4003B000u)
emh203 1:6f37253dab87 318 /** Array initializer of ADC peripheral base pointers */
emh203 1:6f37253dab87 319 #define ADC_BASE_PTRS { ADC0_BASE_PTR }
emh203 1:6f37253dab87 320
emh203 1:6f37253dab87 321
emh203 1:6f37253dab87 322 float _ServoDutyCycleMin;
emh203 1:6f37253dab87 323 float _ServoDutyCycleMax;
emh203 1:6f37253dab87 324 float _ServoPeriod;
emh203 1:6f37253dab87 325
emh203 1:6f37253dab87 326 volatile uint16_t QueuedServo0Val;
emh203 1:6f37253dab87 327 volatile uint16_t QueuedServo1Val;
emh203 1:6f37253dab87 328
emh203 1:6f37253dab87 329 volatile uint16_t *LineScanImage0WorkingBuffer;
emh203 1:6f37253dab87 330 volatile uint16_t *LineScanImage1WorkingBuffer;
emh203 1:6f37253dab87 331
emh203 1:6f37253dab87 332 volatile uint16_t LineScanImage0Buffer[2][128];
emh203 1:6f37253dab87 333 volatile uint16_t LineScanImage1Buffer[2][128];
emh203 1:6f37253dab87 334 volatile uint8_t LineScanWorkingBuffer;
emh203 1:6f37253dab87 335
emh203 3:23cce037011f 336 volatile uint16_t * TFC_LineScanImage0;
emh203 3:23cce037011f 337 volatile uint16_t * TFC_LineScanImage1;
emh203 3:23cce037011f 338 volatile uint8_t TFC_LineScanImageReady;
emh203 3:23cce037011f 339
Clarkk 9:0c6d78c56091 340 volatile uint8_t ConvertionTasks;
emh203 1:6f37253dab87 341 volatile uint16_t PotADC_Value[2];
emh203 1:6f37253dab87 342 volatile uint16_t BatSenseADC_Value;
emh203 1:6f37253dab87 343 volatile uint16_t CurrentADC_State;
Clarkk 9:0c6d78c56091 344 volatile uint16_t MotACurrentADC_Value;
Clarkk 9:0c6d78c56091 345 volatile uint16_t MotBCurrentADC_Value;
emh203 1:6f37253dab87 346 volatile uint8_t CurrentLineScanPixel;
emh203 1:6f37253dab87 347 volatile uint8_t CurrentLineScanChannel;
emh203 1:6f37253dab87 348 volatile uint32_t TFC_ServoTicker;
emh203 3:23cce037011f 349
Clarkk 9:0c6d78c56091 350 volatile uint8_t TFC_Pot0Ready;
Clarkk 9:0c6d78c56091 351 volatile uint8_t TFC_Pot1Ready;
Clarkk 9:0c6d78c56091 352 volatile uint8_t TFC_BatteryVoltageReady;
Clarkk 9:0c6d78c56091 353 volatile uint8_t TFC_MotorCurrentReady;
Clarkk 9:0c6d78c56091 354
Clarkk 9:0c6d78c56091 355 FunctionPointer TFC_ConvertionReadyCallback;
emh203 1:6f37253dab87 356
emh203 1:6f37253dab87 357 void TFC_SetServoDutyCycle(uint8_t ServoNumber, float DutyCycle);
emh203 1:6f37253dab87 358 void TFC_InitLineScanCamera();
emh203 1:6f37253dab87 359 uint8_t ADC_Cal(ADC_MemMapPtr adcmap);
emh203 1:6f37253dab87 360 void ADC_Config_Alt(ADC_MemMapPtr adcmap, tADC_ConfigPtr ADC_CfgPtr);
emh203 1:6f37253dab87 361 void ADC_Read_Cal(ADC_MemMapPtr adcmap, tADC_Cal_Blk *blk);
emh203 1:6f37253dab87 362 void TFC_InitADC0();
emh203 1:6f37253dab87 363 void TFC_InitADC_System();
emh203 1:6f37253dab87 364 void TFC_GPIO_Init();
emh203 1:6f37253dab87 365 void ADC0_Handler();
emh203 1:6f37253dab87 366 void TPM1_Handler();
emh203 1:6f37253dab87 367
emh203 1:6f37253dab87 368
emh203 1:6f37253dab87 369 void TFC_Init()
emh203 1:6f37253dab87 370 {
emh203 1:6f37253dab87 371
emh203 1:6f37253dab87 372 TFC_GPIO_Init();
emh203 1:6f37253dab87 373
emh203 1:6f37253dab87 374 TFC_InitADC_System(); // Always call this before the Servo init function.... The IRQ for the Servo code modifies ADC registers and the clocks need enable to the ADC peripherals 1st!
emh203 1:6f37253dab87 375
emh203 1:6f37253dab87 376 TFC_InitLineScanCamera();
emh203 1:6f37253dab87 377
emh203 1:6f37253dab87 378 TFC_InitServos(SERVO_MIN_PULSE_WIDTH_DEFAULT , SERVO_MAX_PULSE_WIDTH_DEFAULT, SERVO_DEFAULT_PERIOD);
emh203 1:6f37253dab87 379
emh203 1:6f37253dab87 380 TFC_ServoTicker = 0;
emh203 1:6f37253dab87 381
emh203 1:6f37253dab87 382 TFC_InitMotorPWM(FTM0_DEFAULT_SWITCHING_FREQUENCY);
emh203 1:6f37253dab87 383
emh203 1:6f37253dab87 384 }
emh203 1:6f37253dab87 385
emh203 1:6f37253dab87 386
emh203 1:6f37253dab87 387 void TFC_GPIO_Init()
emh203 1:6f37253dab87 388 {
emh203 1:6f37253dab87 389 //enable Clocks to all ports
emh203 1:6f37253dab87 390 SIM->SCGC5 |= SIM_SCGC5_PORTA_MASK | SIM_SCGC5_PORTB_MASK | SIM_SCGC5_PORTC_MASK | SIM_SCGC5_PORTD_MASK | SIM_SCGC5_PORTE_MASK;
emh203 1:6f37253dab87 391
emh203 1:6f37253dab87 392 //Setup Pins as GPIO
emh203 1:6f37253dab87 393 PORTE->PCR[21] = PORT_PCR_MUX(1) | PORT_PCR_DSE_MASK;
emh203 1:6f37253dab87 394 PORTE->PCR[20] = PORT_PCR_MUX(1);
emh203 1:6f37253dab87 395
emh203 1:6f37253dab87 396 //Port for Pushbuttons
emh203 1:6f37253dab87 397 PORTC->PCR[13] = PORT_PCR_MUX(1);
emh203 1:6f37253dab87 398 PORTC->PCR[17] = PORT_PCR_MUX(1);
emh203 1:6f37253dab87 399
emh203 1:6f37253dab87 400 //Ports for DIP Switches
emh203 1:6f37253dab87 401 PORTE->PCR[2] = PORT_PCR_MUX(1);
emh203 1:6f37253dab87 402 PORTE->PCR[3] = PORT_PCR_MUX(1);
emh203 1:6f37253dab87 403 PORTE->PCR[4] = PORT_PCR_MUX(1);
emh203 1:6f37253dab87 404 PORTE->PCR[5] = PORT_PCR_MUX(1);
emh203 1:6f37253dab87 405
emh203 1:6f37253dab87 406 //Ports for LEDs
emh203 1:6f37253dab87 407 PORTB->PCR[8] = PORT_PCR_MUX(1) | PORT_PCR_DSE_MASK;
emh203 1:6f37253dab87 408 PORTB->PCR[9] = PORT_PCR_MUX(1) | PORT_PCR_DSE_MASK;
emh203 1:6f37253dab87 409 PORTB->PCR[10] = PORT_PCR_MUX(1) | PORT_PCR_DSE_MASK;
emh203 1:6f37253dab87 410 PORTB->PCR[11] = PORT_PCR_MUX(1) | PORT_PCR_DSE_MASK;
emh203 1:6f37253dab87 411
emh203 1:6f37253dab87 412 //Setup the output pins
emh203 1:6f37253dab87 413 PTE->PDDR = TFC_HBRIDGE_EN_LOC;
emh203 1:6f37253dab87 414 PTB->PDDR = TFC_BAT_LED0_LOC | TFC_BAT_LED1_LOC | TFC_BAT_LED2_LOC | TFC_BAT_LED3_LOC;
emh203 1:6f37253dab87 415
emh203 1:6f37253dab87 416 TFC_SetBatteryLED(0);
emh203 1:6f37253dab87 417 TFC_HBRIDGE_DISABLE;
emh203 1:6f37253dab87 418 }
emh203 1:6f37253dab87 419
emh203 1:6f37253dab87 420 void TFC_SetBatteryLED(uint8_t Value)
emh203 1:6f37253dab87 421 {
emh203 1:6f37253dab87 422 if(Value & 0x01)
emh203 1:6f37253dab87 423 TFC_BAT_LED0_ON;
emh203 1:6f37253dab87 424 else
emh203 1:6f37253dab87 425 TFC_BAT_LED0_OFF;
emh203 1:6f37253dab87 426
emh203 1:6f37253dab87 427 if(Value & 0x02)
emh203 1:6f37253dab87 428 TFC_BAT_LED1_ON;
emh203 1:6f37253dab87 429 else
emh203 1:6f37253dab87 430 TFC_BAT_LED1_OFF;
emh203 1:6f37253dab87 431
emh203 1:6f37253dab87 432 if(Value & 0x04)
emh203 1:6f37253dab87 433 TFC_BAT_LED2_ON;
emh203 1:6f37253dab87 434 else
emh203 1:6f37253dab87 435 TFC_BAT_LED2_OFF;
emh203 1:6f37253dab87 436
emh203 1:6f37253dab87 437 if(Value & 0x08)
emh203 1:6f37253dab87 438 TFC_BAT_LED3_ON;
emh203 1:6f37253dab87 439 else
emh203 1:6f37253dab87 440 TFC_BAT_LED3_OFF;
emh203 1:6f37253dab87 441 }
emh203 1:6f37253dab87 442
emh203 1:6f37253dab87 443 uint8_t TFC_GetDIP_Switch()
emh203 1:6f37253dab87 444 {
emh203 1:6f37253dab87 445 uint8_t DIP_Val=0;
emh203 1:6f37253dab87 446
emh203 1:6f37253dab87 447 DIP_Val = (PTE->PDIR>>2) & 0xF;
emh203 1:6f37253dab87 448
emh203 1:6f37253dab87 449 return DIP_Val;
emh203 1:6f37253dab87 450 }
emh203 1:6f37253dab87 451
emh203 1:6f37253dab87 452 uint8_t TFC_ReadPushButton(uint8_t Index)
emh203 1:6f37253dab87 453 {
emh203 1:6f37253dab87 454 if(Index == 0) {
emh203 1:6f37253dab87 455 return TFC_PUSH_BUTTON_0_PRESSED;
emh203 1:6f37253dab87 456 } else {
emh203 1:6f37253dab87 457 return TFC_PUSH_BUTTON_1_PRESSED;
emh203 1:6f37253dab87 458 }
emh203 1:6f37253dab87 459 }
emh203 1:6f37253dab87 460
emh203 1:6f37253dab87 461 extern "C" void TPM1_IRQHandler()
emh203 1:6f37253dab87 462 {
emh203 1:6f37253dab87 463 //Clear the overflow mask if set. According to the reference manual, we clear by writing a logic one!
emh203 1:6f37253dab87 464 if(TPM1->SC & TPM_SC_TOF_MASK)
emh203 1:6f37253dab87 465 TPM1->SC |= TPM_SC_TOF_MASK;
emh203 1:6f37253dab87 466
emh203 1:6f37253dab87 467 //Dump the queued values to the timer channels
emh203 1:6f37253dab87 468 TPM1->CONTROLS[0].CnV = QueuedServo0Val;
emh203 1:6f37253dab87 469 TPM1->CONTROLS[1].CnV = QueuedServo1Val;
Clarkk 9:0c6d78c56091 470
Clarkk 9:0c6d78c56091 471 //TFC_StartDataAcquisition();
emh203 1:6f37253dab87 472
Clarkk 9:0c6d78c56091 473 //Flag that a new servo cycle will start
emh203 1:6f37253dab87 474 if (TFC_ServoTicker < 0xffffffff)//if servo tick less than max value, count up...
emh203 1:6f37253dab87 475 TFC_ServoTicker++;
emh203 1:6f37253dab87 476
emh203 1:6f37253dab87 477 }
emh203 1:6f37253dab87 478
emh203 1:6f37253dab87 479 void TFC_InitServos(float PulseWidthMin, float PulseWidthMax, float ServoPeriod)
emh203 1:6f37253dab87 480 {
emh203 1:6f37253dab87 481 SIM->SCGC5 |= SIM_SCGC5_PORTB_MASK;
emh203 1:6f37253dab87 482
emh203 1:6f37253dab87 483 _ServoPeriod = ServoPeriod;
emh203 1:6f37253dab87 484 _ServoDutyCycleMin = PulseWidthMin/ServoPeriod;
emh203 1:6f37253dab87 485 _ServoDutyCycleMax = PulseWidthMax/ServoPeriod;
emh203 1:6f37253dab87 486
emh203 1:6f37253dab87 487 //Clock Setup for the TPM requires a couple steps.
emh203 1:6f37253dab87 488 SIM->SCGC6 &= ~SIM_SCGC6_TPM1_MASK;
emh203 1:6f37253dab87 489 //1st, set the clock mux
emh203 1:6f37253dab87 490 //See Page 124 of f the KL25 Sub-Family Reference Manual, Rev. 3, September 2012
emh203 1:6f37253dab87 491 SIM->SOPT2 |= SIM_SOPT2_PLLFLLSEL_MASK;// We Want MCGPLLCLK/2 (See Page 196 of the KL25 Sub-Family Reference Manual, Rev. 3, September 2012)
emh203 1:6f37253dab87 492 SIM->SOPT2 &= ~(SIM_SOPT2_TPMSRC_MASK);
emh203 1:6f37253dab87 493 SIM->SOPT2 |= SIM_SOPT2_TPMSRC(1);
emh203 1:6f37253dab87 494
emh203 1:6f37253dab87 495 //Enable the Clock to the FTM0 Module
emh203 1:6f37253dab87 496 //See Page 207 of f the KL25 Sub-Family Reference Manual, Rev. 3, September 2012
emh203 1:6f37253dab87 497 SIM->SCGC6 |= SIM_SCGC6_TPM1_MASK;
emh203 1:6f37253dab87 498
emh203 1:6f37253dab87 499 //The TPM Module has Clock. Now set up the peripheral
emh203 1:6f37253dab87 500
emh203 1:6f37253dab87 501 //Blow away the control registers to ensure that the counter is not running
emh203 1:6f37253dab87 502 TPM1->SC = 0;
emh203 1:6f37253dab87 503 TPM1->CONF = 0;
emh203 1:6f37253dab87 504
emh203 1:6f37253dab87 505 //While the counter is disabled we can setup the prescaler
emh203 1:6f37253dab87 506
emh203 1:6f37253dab87 507 TPM1->SC = TPM_SC_PS(FTM1_CLK_PRESCALE);
emh203 1:6f37253dab87 508 TPM1->SC |= TPM_SC_TOIE_MASK; //Enable Interrupts for the Timer Overflow
emh203 1:6f37253dab87 509
emh203 1:6f37253dab87 510 //Setup the mod register to get the correct PWM Period
emh203 1:6f37253dab87 511
emh203 1:6f37253dab87 512 TPM1->MOD = (SystemCoreClock/(1<<(FTM1_CLK_PRESCALE))) * _ServoPeriod;
emh203 1:6f37253dab87 513 //Setup Channels 0 and 1
emh203 1:6f37253dab87 514
emh203 1:6f37253dab87 515 TPM1->CONTROLS[0].CnSC = TPM_CnSC_MSB_MASK | TPM_CnSC_ELSB_MASK;
emh203 1:6f37253dab87 516 TPM1->CONTROLS[1].CnSC = TPM_CnSC_MSB_MASK | TPM_CnSC_ELSB_MASK;
emh203 1:6f37253dab87 517
emh203 1:6f37253dab87 518
emh203 1:6f37253dab87 519 //Set the Default duty cycle to servo neutral
emh203 1:6f37253dab87 520 TFC_SetServo(0, 0.0);
emh203 1:6f37253dab87 521 TFC_SetServo(1, 0.0);
emh203 1:6f37253dab87 522
emh203 1:6f37253dab87 523 //Enable the TPM COunter
emh203 1:6f37253dab87 524 TPM1->SC |= TPM_SC_CMOD(1);
emh203 1:6f37253dab87 525
emh203 1:6f37253dab87 526 //Enable TPM1 IRQ on the NVIC
emh203 1:6f37253dab87 527
emh203 1:6f37253dab87 528 //NVIC_SetVector(TPM1_IRQn,(uint32_t)TPM1_Handler);
emh203 1:6f37253dab87 529 NVIC_EnableIRQ(TPM1_IRQn);
emh203 1:6f37253dab87 530
emh203 1:6f37253dab87 531 //Enable the FTM functions on the the port
emh203 1:6f37253dab87 532
emh203 1:6f37253dab87 533 PORTB->PCR[0] = PORT_PCR_MUX(3);
emh203 1:6f37253dab87 534 PORTB->PCR[1] = PORT_PCR_MUX(3);
emh203 1:6f37253dab87 535
emh203 1:6f37253dab87 536 }
emh203 1:6f37253dab87 537
emh203 1:6f37253dab87 538
emh203 1:6f37253dab87 539 void TFC_SetServoDutyCycle(uint8_t ServoNumber, float DutyCycle)
emh203 1:6f37253dab87 540 {
emh203 1:6f37253dab87 541 switch(ServoNumber) {
emh203 1:6f37253dab87 542 default:
emh203 1:6f37253dab87 543 case 0:
emh203 1:6f37253dab87 544
emh203 1:6f37253dab87 545 QueuedServo0Val = TPM1->MOD * DutyCycle;
emh203 1:6f37253dab87 546
emh203 1:6f37253dab87 547 break;
emh203 1:6f37253dab87 548
emh203 1:6f37253dab87 549 case 1:
emh203 1:6f37253dab87 550
emh203 1:6f37253dab87 551 QueuedServo1Val = TPM1->MOD * DutyCycle;
emh203 1:6f37253dab87 552
emh203 1:6f37253dab87 553 break;
emh203 1:6f37253dab87 554 }
emh203 1:6f37253dab87 555 }
emh203 1:6f37253dab87 556
emh203 1:6f37253dab87 557 void TFC_SetServo(uint8_t ServoNumber, float Position)
emh203 1:6f37253dab87 558 {
emh203 1:6f37253dab87 559 TFC_SetServoDutyCycle(ServoNumber ,
emh203 3:23cce037011f 560 ((Position + 1.0)/2) * ((_ServoDutyCycleMax - _ServoDutyCycleMin))+_ServoDutyCycleMin) ;
emh203 1:6f37253dab87 561
emh203 1:6f37253dab87 562 }
emh203 1:6f37253dab87 563
emh203 1:6f37253dab87 564 //********************************************************************************************************
emh203 1:6f37253dab87 565 //********************************************************************************************************
emh203 1:6f37253dab87 566 //********************************************************************************************************
emh203 1:6f37253dab87 567 // _____ _____ ______ _ _ _ _ _____ _______ _____ ____ _ _ _____
emh203 1:6f37253dab87 568 // /\ | __ \ / ____| | ____| | | | \ | |/ ____|__ __|_ _/ __ \| \ | |/ ____|
emh203 1:6f37253dab87 569 // / \ | | | | | | |__ | | | | \| | | | | | || | | | \| | (___
emh203 1:6f37253dab87 570 // / /\ \ | | | | | | __| | | | | . ` | | | | | || | | | . ` |\___ \
emh203 1:6f37253dab87 571 // / ____ \| |__| | |____ | | | |__| | |\ | |____ | | _| || |__| | |\ |____) |
emh203 1:6f37253dab87 572 // /_/ \_\_____/ \_____| |_| \____/|_| \_|\_____| |_| |_____\____/|_| \_|_____/
emh203 1:6f37253dab87 573 // ********************************************************************************************************
emh203 1:6f37253dab87 574 // ********************************************************************************************************
emh203 1:6f37253dab87 575 // ********************************************************************************************************
emh203 1:6f37253dab87 576
emh203 1:6f37253dab87 577
emh203 1:6f37253dab87 578
emh203 1:6f37253dab87 579
emh203 1:6f37253dab87 580
emh203 1:6f37253dab87 581 uint8_t ADC_Cal(ADC_MemMapPtr adcmap)
emh203 1:6f37253dab87 582 {
emh203 1:6f37253dab87 583
emh203 1:6f37253dab87 584 uint16_t cal_var;
emh203 1:6f37253dab87 585
emh203 1:6f37253dab87 586 ADC_SC2_REG(adcmap) &= ~ADC_SC2_ADTRG_MASK ; // Enable Software Conversion Trigger for Calibration Process - ADC0_SC2 = ADC0_SC2 | ADC_SC2_ADTRGW(0);
emh203 1:6f37253dab87 587 ADC_SC3_REG(adcmap) &= ( ~ADC_SC3_ADCO_MASK & ~ADC_SC3_AVGS_MASK ); // set single conversion, clear avgs bitfield for next writing
emh203 1:6f37253dab87 588 ADC_SC3_REG(adcmap) |= ( ADC_SC3_AVGE_MASK | ADC_SC3_AVGS(AVGS_32) ); // Turn averaging ON and set at max value ( 32 )
emh203 1:6f37253dab87 589
emh203 1:6f37253dab87 590
emh203 1:6f37253dab87 591 ADC_SC3_REG(adcmap) |= ADC_SC3_CAL_MASK ; // Start CAL
emh203 1:6f37253dab87 592 while ( (ADC_SC1_REG(adcmap,A) & ADC_SC1_COCO_MASK ) == COCO_NOT ); // Wait calibration end
emh203 1:6f37253dab87 593
emh203 1:6f37253dab87 594 if ((ADC_SC3_REG(adcmap)& ADC_SC3_CALF_MASK) == CALF_FAIL ) {
emh203 1:6f37253dab87 595 return(1); // Check for Calibration fail error and return
emh203 1:6f37253dab87 596 }
emh203 1:6f37253dab87 597 // Calculate plus-side calibration
emh203 1:6f37253dab87 598 cal_var = 0x00;
emh203 1:6f37253dab87 599
emh203 1:6f37253dab87 600 cal_var = ADC_CLP0_REG(adcmap);
emh203 1:6f37253dab87 601 cal_var += ADC_CLP1_REG(adcmap);
emh203 1:6f37253dab87 602 cal_var += ADC_CLP2_REG(adcmap);
emh203 1:6f37253dab87 603 cal_var += ADC_CLP3_REG(adcmap);
emh203 1:6f37253dab87 604 cal_var += ADC_CLP4_REG(adcmap);
emh203 1:6f37253dab87 605 cal_var += ADC_CLPS_REG(adcmap);
emh203 1:6f37253dab87 606
emh203 1:6f37253dab87 607 cal_var = cal_var/2;
emh203 1:6f37253dab87 608 cal_var |= 0x8000; // Set MSB
emh203 1:6f37253dab87 609
emh203 1:6f37253dab87 610 ADC_PG_REG(adcmap) = ADC_PG_PG(cal_var);
emh203 1:6f37253dab87 611
emh203 1:6f37253dab87 612
emh203 1:6f37253dab87 613 // Calculate minus-side calibration
emh203 1:6f37253dab87 614 cal_var = 0x00;
emh203 1:6f37253dab87 615
emh203 1:6f37253dab87 616 cal_var = ADC_CLM0_REG(adcmap);
emh203 1:6f37253dab87 617 cal_var += ADC_CLM1_REG(adcmap);
emh203 1:6f37253dab87 618 cal_var += ADC_CLM2_REG(adcmap);
emh203 1:6f37253dab87 619 cal_var += ADC_CLM3_REG(adcmap);
emh203 1:6f37253dab87 620 cal_var += ADC_CLM4_REG(adcmap);
emh203 1:6f37253dab87 621 cal_var += ADC_CLMS_REG(adcmap);
emh203 1:6f37253dab87 622
emh203 1:6f37253dab87 623 cal_var = cal_var/2;
emh203 1:6f37253dab87 624
emh203 1:6f37253dab87 625 cal_var |= 0x8000; // Set MSB
emh203 1:6f37253dab87 626
emh203 1:6f37253dab87 627 ADC_MG_REG(adcmap) = ADC_MG_MG(cal_var);
emh203 1:6f37253dab87 628
emh203 1:6f37253dab87 629 ADC_SC3_REG(adcmap) &= ~ADC_SC3_CAL_MASK ; /* Clear CAL bit */
emh203 1:6f37253dab87 630
emh203 1:6f37253dab87 631 return(0);
emh203 1:6f37253dab87 632 }
emh203 1:6f37253dab87 633
emh203 1:6f37253dab87 634
emh203 1:6f37253dab87 635 void ADC_Config_Alt(ADC_MemMapPtr adcmap, tADC_ConfigPtr ADC_CfgPtr)
emh203 1:6f37253dab87 636 {
emh203 1:6f37253dab87 637 ADC_CFG1_REG(adcmap) = ADC_CfgPtr->CONFIG1;
emh203 1:6f37253dab87 638 ADC_CFG2_REG(adcmap) = ADC_CfgPtr->CONFIG2;
emh203 1:6f37253dab87 639 ADC_CV1_REG(adcmap) = ADC_CfgPtr->COMPARE1;
emh203 1:6f37253dab87 640 ADC_CV2_REG(adcmap) = ADC_CfgPtr->COMPARE2;
emh203 1:6f37253dab87 641 ADC_SC2_REG(adcmap) = ADC_CfgPtr->STATUS2;
emh203 1:6f37253dab87 642 ADC_SC3_REG(adcmap) = ADC_CfgPtr->STATUS3;
emh203 1:6f37253dab87 643 //ADC_PGA_REG(adcmap) = ADC_CfgPtr->PGA;
emh203 1:6f37253dab87 644 ADC_SC1_REG(adcmap,A)= ADC_CfgPtr->STATUS1A;
emh203 1:6f37253dab87 645 ADC_SC1_REG(adcmap,B)= ADC_CfgPtr->STATUS1B;
emh203 1:6f37253dab87 646 }
emh203 1:6f37253dab87 647
emh203 1:6f37253dab87 648
emh203 1:6f37253dab87 649 void ADC_Read_Cal(ADC_MemMapPtr adcmap, tADC_Cal_Blk *blk)
emh203 1:6f37253dab87 650 {
emh203 1:6f37253dab87 651 blk->OFS = ADC_OFS_REG(adcmap);
emh203 1:6f37253dab87 652 blk->PG = ADC_PG_REG(adcmap);
emh203 1:6f37253dab87 653 blk->MG = ADC_MG_REG(adcmap);
emh203 1:6f37253dab87 654 blk->CLPD = ADC_CLPD_REG(adcmap);
emh203 1:6f37253dab87 655 blk->CLPS = ADC_CLPS_REG(adcmap);
emh203 1:6f37253dab87 656 blk->CLP4 = ADC_CLP4_REG(adcmap);
emh203 1:6f37253dab87 657 blk->CLP3 = ADC_CLP3_REG(adcmap);
emh203 1:6f37253dab87 658 blk->CLP2 = ADC_CLP2_REG(adcmap);
emh203 1:6f37253dab87 659 blk->CLP1 = ADC_CLP1_REG(adcmap);
emh203 1:6f37253dab87 660 blk->CLP0 = ADC_CLP0_REG(adcmap);
emh203 1:6f37253dab87 661 blk->CLMD = ADC_CLMD_REG(adcmap);
emh203 1:6f37253dab87 662 blk->CLMS = ADC_CLMS_REG(adcmap);
emh203 1:6f37253dab87 663 blk->CLM4 = ADC_CLM4_REG(adcmap);
emh203 1:6f37253dab87 664 blk->CLM3 = ADC_CLM3_REG(adcmap);
emh203 1:6f37253dab87 665 blk->CLM2 = ADC_CLM2_REG(adcmap);
emh203 1:6f37253dab87 666 blk->CLM1 = ADC_CLM1_REG(adcmap);
emh203 1:6f37253dab87 667 blk->CLM0 = ADC_CLM0_REG(adcmap);
emh203 1:6f37253dab87 668
emh203 1:6f37253dab87 669 }
emh203 1:6f37253dab87 670
emh203 1:6f37253dab87 671
emh203 1:6f37253dab87 672 void TFC_InitADC0()
emh203 1:6f37253dab87 673 {
emh203 1:6f37253dab87 674 tADC_Config Master_Adc0_Config;
emh203 1:6f37253dab87 675
emh203 1:6f37253dab87 676
emh203 1:6f37253dab87 677 SIM->SCGC6 |= (SIM_SCGC6_ADC0_MASK);
emh203 1:6f37253dab87 678
emh203 1:6f37253dab87 679 //Lets calibrate the ADC. 1st setup how the channel will be used.
emh203 1:6f37253dab87 680
emh203 1:6f37253dab87 681
emh203 1:6f37253dab87 682 Master_Adc0_Config.CONFIG1 = ADLPC_NORMAL //No low power mode
emh203 1:6f37253dab87 683 | ADC_CFG1_ADIV(ADIV_4) //divide input by 4
emh203 1:6f37253dab87 684 | ADLSMP_LONG //long sample time
emh203 1:6f37253dab87 685 | ADC_CFG1_MODE(MODE_12)//single ended 8-bit conversion
emh203 1:6f37253dab87 686 | ADC_CFG1_ADICLK(ADICLK_BUS);
emh203 1:6f37253dab87 687
emh203 1:6f37253dab87 688 Master_Adc0_Config.CONFIG2 = MUXSEL_ADCA // select the A side of the ADC channel.
emh203 1:6f37253dab87 689 | ADACKEN_DISABLED
emh203 1:6f37253dab87 690 | ADHSC_HISPEED
emh203 1:6f37253dab87 691 | ADC_CFG2_ADLSTS(ADLSTS_2);//Extra long sample Time (20 extra clocks)
emh203 1:6f37253dab87 692
emh203 1:6f37253dab87 693
emh203 1:6f37253dab87 694 Master_Adc0_Config.COMPARE1 = 00000; // Comparators don't matter for calibration
emh203 1:6f37253dab87 695 Master_Adc0_Config.COMPARE1 = 0xFFFF;
emh203 1:6f37253dab87 696
emh203 1:6f37253dab87 697 Master_Adc0_Config.STATUS2 = ADTRG_HW //hardware triggers for calibration
emh203 1:6f37253dab87 698 | ACFE_DISABLED //disable comparator
emh203 1:6f37253dab87 699 | ACFGT_GREATER
emh203 1:6f37253dab87 700 | ACREN_ENABLED
emh203 1:6f37253dab87 701 | DMAEN_DISABLED //Disable DMA
emh203 1:6f37253dab87 702 | ADC_SC2_REFSEL(REFSEL_EXT); //External Reference
emh203 1:6f37253dab87 703
emh203 1:6f37253dab87 704 Master_Adc0_Config.STATUS3 = CAL_OFF
emh203 1:6f37253dab87 705 | ADCO_SINGLE
emh203 1:6f37253dab87 706 | AVGE_ENABLED;
emh203 1:6f37253dab87 707 // | ADC_SC3_AVGS(AVGS_4);
emh203 1:6f37253dab87 708
emh203 1:6f37253dab87 709 Master_Adc0_Config.PGA = 0; // Disable the PGA
emh203 1:6f37253dab87 710
emh203 1:6f37253dab87 711
emh203 1:6f37253dab87 712 // Configure ADC as it will be used, but because ADC_SC1_ADCH is 31,
emh203 1:6f37253dab87 713 // the ADC will be inactive. Channel 31 is just disable function.
emh203 1:6f37253dab87 714 // There really is no channel 31.
emh203 1:6f37253dab87 715
emh203 1:6f37253dab87 716 Master_Adc0_Config.STATUS1A = AIEN_ON | DIFF_SINGLE | ADC_SC1_ADCH(31);
emh203 1:6f37253dab87 717
emh203 1:6f37253dab87 718
emh203 1:6f37253dab87 719 ADC_Config_Alt(ADC0_BASE_PTR, &Master_Adc0_Config); // config ADC
emh203 1:6f37253dab87 720
emh203 1:6f37253dab87 721 // Calibrate the ADC in the configuration in which it will be used:
emh203 1:6f37253dab87 722 ADC_Cal(ADC0_BASE_PTR); // do the calibration
emh203 1:6f37253dab87 723
emh203 1:6f37253dab87 724
emh203 1:6f37253dab87 725 Master_Adc0_Config.STATUS2 = ACFE_DISABLED //disable comparator
emh203 1:6f37253dab87 726 | ACFGT_GREATER
emh203 1:6f37253dab87 727 | ACREN_ENABLED
emh203 1:6f37253dab87 728 | DMAEN_DISABLED //Disable DMA
emh203 1:6f37253dab87 729 | ADC_SC2_REFSEL(REFSEL_EXT); //External Reference
emh203 1:6f37253dab87 730
emh203 1:6f37253dab87 731 Master_Adc0_Config.STATUS3 = CAL_OFF
emh203 1:6f37253dab87 732 | ADCO_SINGLE;
emh203 1:6f37253dab87 733
emh203 1:6f37253dab87 734
emh203 1:6f37253dab87 735
emh203 1:6f37253dab87 736 ADC_Config_Alt(ADC0_BASE_PTR, &Master_Adc0_Config);
emh203 1:6f37253dab87 737 }
emh203 1:6f37253dab87 738
emh203 1:6f37253dab87 739
emh203 1:6f37253dab87 740 void TFC_InitADC_System()
emh203 1:6f37253dab87 741 {
emh203 1:6f37253dab87 742
emh203 1:6f37253dab87 743 TFC_InitADC0();
emh203 1:6f37253dab87 744
emh203 1:6f37253dab87 745
emh203 1:6f37253dab87 746 //All Adc processing of the Pots and linescan will be done in the ADC0 IRQ!
emh203 1:6f37253dab87 747 //A state machine will scan through the channels.
emh203 1:6f37253dab87 748 //This is done to automate the linescan capture on Channel 0 to ensure that timing is very even
emh203 1:6f37253dab87 749 CurrentADC_State = ADC_STATE_INIT;
emh203 1:6f37253dab87 750
emh203 1:6f37253dab87 751 //The pump will be primed with the TPM1 interrupt. upon timeout/interrupt it will set the SI signal high
emh203 1:6f37253dab87 752 //for the camera and then start the conversions for the pots.
emh203 1:6f37253dab87 753
emh203 1:6f37253dab87 754 // NVIC_SetVector(ADC0_IRQn,(uint32_t)ADC0_Handler);
emh203 1:6f37253dab87 755 NVIC_EnableIRQ(ADC0_IRQn);
emh203 1:6f37253dab87 756
emh203 1:6f37253dab87 757 }
emh203 1:6f37253dab87 758
Clarkk 9:0c6d78c56091 759 void TFC_StopCameraExposure()
Clarkk 9:0c6d78c56091 760 {
Clarkk 9:0c6d78c56091 761 TAOS_SI_HIGH;
Clarkk 9:0c6d78c56091 762 }
Clarkk 9:0c6d78c56091 763
Clarkk 9:0c6d78c56091 764 void TFC_StartADC_Pot0()
Clarkk 9:0c6d78c56091 765 {
Clarkk 9:0c6d78c56091 766 // start capturing POT 0
Clarkk 9:0c6d78c56091 767 CurrentADC_State = ADC_STATE_CAPTURE_POT_0;
Clarkk 9:0c6d78c56091 768
Clarkk 9:0c6d78c56091 769 ADC0->CFG2 &= ~ADC_CFG2_MUXSEL_MASK; //Select the A side of the mux
Clarkk 9:0c6d78c56091 770 ADC0->SC1[0] = TFC_POT_0_ADC_CHANNEL | ADC_SC1_AIEN_MASK; //Start the State machine at POT0
Clarkk 9:0c6d78c56091 771 }
Clarkk 9:0c6d78c56091 772
Clarkk 9:0c6d78c56091 773 void TFC_StartADC_Pot1()
Clarkk 9:0c6d78c56091 774 {
Clarkk 9:0c6d78c56091 775 CurrentADC_State = ADC_STATE_CAPTURE_POT_1;
Clarkk 9:0c6d78c56091 776 ADC0->CFG2 &= ~ADC_CFG2_MUXSEL_MASK; //Select the A side of the mux
Clarkk 9:0c6d78c56091 777 ADC0->SC1[0] = TFC_POT_1_ADC_CHANNEL | ADC_SC1_AIEN_MASK;
Clarkk 9:0c6d78c56091 778 }
Clarkk 9:0c6d78c56091 779
Clarkk 9:0c6d78c56091 780 void TFC_StartADC_Battery()
Clarkk 9:0c6d78c56091 781 {
Clarkk 9:0c6d78c56091 782 CurrentADC_State = ADC_STATE_CAPTURE_BATTERY_LEVEL;
Clarkk 9:0c6d78c56091 783 ADC0->CFG2 |= ADC_CFG2_MUXSEL_MASK; //Select the B side of the mux
Clarkk 9:0c6d78c56091 784 ADC0->SC1[0] = TFC_BAT_SENSE_CHANNEL| ADC_SC1_AIEN_MASK;
Clarkk 9:0c6d78c56091 785 }
Clarkk 9:0c6d78c56091 786
Clarkk 9:0c6d78c56091 787 void TFC_StartADC_MotACurrent()
Clarkk 9:0c6d78c56091 788 {
Clarkk 9:0c6d78c56091 789 CurrentADC_State = ADC_STATE_CAPTURE_MOTOR_A_CURRENT;
Clarkk 9:0c6d78c56091 790 ADC0->CFG2 &= ~ADC_CFG2_MUXSEL_MASK; //Select the A side of the mux
Clarkk 9:0c6d78c56091 791 ADC0->SC1[0] = TFC_IFB_MOTA_ADC_CHANNEL| ADC_SC1_AIEN_MASK;
Clarkk 9:0c6d78c56091 792 }
Clarkk 9:0c6d78c56091 793
Clarkk 9:0c6d78c56091 794 void TFC_StartADC_MotBCurrent()
Clarkk 9:0c6d78c56091 795 {
Clarkk 9:0c6d78c56091 796 CurrentADC_State = ADC_STATE_CAPTURE_MOTOR_B_CURRENT;
Clarkk 9:0c6d78c56091 797 //ADC0->CFG2 |= ADC_CFG2_MUXSEL_MASK; //Select the B side of the mux
Clarkk 9:0c6d78c56091 798 ADC0->SC1[0] = TFC_IFB_MOTB_ADC_CHANNEL| ADC_SC1_AIEN_MASK;
Clarkk 9:0c6d78c56091 799 }
Clarkk 9:0c6d78c56091 800
Clarkk 9:0c6d78c56091 801 void TFC_StartADC_LineScan()
Clarkk 9:0c6d78c56091 802 {
Clarkk 9:0c6d78c56091 803 uint8_t i;
Clarkk 9:0c6d78c56091 804 CurrentADC_State = ADC_STATE_CAPTURE_LINE_SCAN;
Clarkk 9:0c6d78c56091 805
Clarkk 9:0c6d78c56091 806 //Prime the next ADC capture cycle
Clarkk 9:0c6d78c56091 807 TAOS_SI_HIGH;
Clarkk 9:0c6d78c56091 808 for(i = 0; i<50; i++) { // 50 counts is ~120ns
Clarkk 9:0c6d78c56091 809 }
Clarkk 9:0c6d78c56091 810 TAOS_CLK_HIGH;
Clarkk 9:0c6d78c56091 811 for(i = 0; i<50; i++) {
Clarkk 9:0c6d78c56091 812 }
Clarkk 9:0c6d78c56091 813 TAOS_SI_LOW;
Clarkk 9:0c6d78c56091 814
Clarkk 9:0c6d78c56091 815 CurrentLineScanPixel = 0;
Clarkk 9:0c6d78c56091 816 CurrentLineScanChannel = 0;
Clarkk 9:0c6d78c56091 817 ADC0->CFG2 |= ADC_CFG2_MUXSEL_MASK; //Select the B side of the mux
Clarkk 9:0c6d78c56091 818 ADC0->SC1[0] = TFC_LINESCAN0_ADC_CHANNEL | ADC_SC1_AIEN_MASK;
Clarkk 9:0c6d78c56091 819 }
Clarkk 9:0c6d78c56091 820
Clarkk 9:0c6d78c56091 821 void TFC_StartNextConvertion()
Clarkk 9:0c6d78c56091 822 {
Clarkk 9:0c6d78c56091 823 if(ConvertionTasks&ADC_MASK_CAPTURE_POT_0)
Clarkk 9:0c6d78c56091 824 {
Clarkk 9:0c6d78c56091 825 TFC_StartADC_Pot0();
Clarkk 9:0c6d78c56091 826 ConvertionTasks ^= ADC_MASK_CAPTURE_POT_0;
Clarkk 9:0c6d78c56091 827 return;
Clarkk 9:0c6d78c56091 828 }
Clarkk 9:0c6d78c56091 829 if(ConvertionTasks & ADC_MASK_CAPTURE_POT_1)
Clarkk 9:0c6d78c56091 830 {
Clarkk 9:0c6d78c56091 831 TFC_StartADC_Pot1();
Clarkk 9:0c6d78c56091 832 ConvertionTasks ^= ADC_MASK_CAPTURE_POT_1;
Clarkk 9:0c6d78c56091 833 return;
Clarkk 9:0c6d78c56091 834 }
Clarkk 9:0c6d78c56091 835 if(ConvertionTasks & ADC_MASK_CAPTURE_BATTERY_LEVEL)
Clarkk 9:0c6d78c56091 836 {
Clarkk 9:0c6d78c56091 837 TFC_StartADC_Battery();
Clarkk 9:0c6d78c56091 838 ConvertionTasks ^= ADC_MASK_CAPTURE_BATTERY_LEVEL;
Clarkk 9:0c6d78c56091 839 return;
Clarkk 9:0c6d78c56091 840 }
Clarkk 9:0c6d78c56091 841 if(ConvertionTasks & ADC_MASK_CAPTURE_MOTOR_CURRENT)
Clarkk 9:0c6d78c56091 842 {
Clarkk 9:0c6d78c56091 843 TFC_StartADC_MotACurrent();
Clarkk 9:0c6d78c56091 844 ConvertionTasks ^= ADC_MASK_CAPTURE_MOTOR_CURRENT;
Clarkk 9:0c6d78c56091 845 return;
Clarkk 9:0c6d78c56091 846 }
Clarkk 9:0c6d78c56091 847 if(ConvertionTasks & ADC_MASK_CAPTURE_LINE_SCAN)
Clarkk 9:0c6d78c56091 848 {
Clarkk 9:0c6d78c56091 849 TFC_StartADC_LineScan();
Clarkk 9:0c6d78c56091 850 ConvertionTasks ^= ADC_MASK_CAPTURE_LINE_SCAN;
Clarkk 9:0c6d78c56091 851 return;
Clarkk 9:0c6d78c56091 852 }
Clarkk 9:0c6d78c56091 853 CurrentADC_State = ADC_STATE_INIT;
Clarkk 9:0c6d78c56091 854 }
Clarkk 9:0c6d78c56091 855
Clarkk 9:0c6d78c56091 856 void TFC_StartDataAcquisition(uint8_t mask)
Clarkk 9:0c6d78c56091 857 {
Clarkk 9:0c6d78c56091 858 ConvertionTasks = mask;
Clarkk 9:0c6d78c56091 859 TFC_StartNextConvertion();
Clarkk 9:0c6d78c56091 860 }
Clarkk 9:0c6d78c56091 861
emh203 1:6f37253dab87 862 extern "C" void ADC0_IRQHandler()
emh203 1:6f37253dab87 863 {
emh203 1:6f37253dab87 864 uint8_t Junk;
emh203 1:6f37253dab87 865
emh203 1:6f37253dab87 866 switch(CurrentADC_State) {
emh203 1:6f37253dab87 867 default:
emh203 1:6f37253dab87 868 Junk = ADC0->R[0];
emh203 1:6f37253dab87 869 break;
emh203 1:6f37253dab87 870
emh203 1:6f37253dab87 871 case ADC_STATE_CAPTURE_POT_0:
emh203 1:6f37253dab87 872 PotADC_Value[0] = ADC0->R[0];
Clarkk 9:0c6d78c56091 873 TFC_StartNextConvertion();
Clarkk 9:0c6d78c56091 874 TFC_Pot0Ready++;
emh203 1:6f37253dab87 875 break;
emh203 1:6f37253dab87 876
emh203 1:6f37253dab87 877 case ADC_STATE_CAPTURE_POT_1:
emh203 1:6f37253dab87 878 PotADC_Value[1] = ADC0->R[0];
Clarkk 9:0c6d78c56091 879 TFC_StartNextConvertion();
Clarkk 9:0c6d78c56091 880 TFC_Pot1Ready++;
emh203 1:6f37253dab87 881 break;
emh203 1:6f37253dab87 882
emh203 1:6f37253dab87 883 case ADC_STATE_CAPTURE_BATTERY_LEVEL:
emh203 1:6f37253dab87 884 BatSenseADC_Value = ADC0->R[0];
Clarkk 9:0c6d78c56091 885 TFC_StartNextConvertion();
Clarkk 9:0c6d78c56091 886 TFC_BatteryVoltageReady++;
Clarkk 9:0c6d78c56091 887 TFC_ConvertionReadyCallback.call();
Clarkk 9:0c6d78c56091 888 break;
emh203 1:6f37253dab87 889
Clarkk 9:0c6d78c56091 890 case ADC_STATE_CAPTURE_MOTOR_A_CURRENT:
Clarkk 9:0c6d78c56091 891 MotACurrentADC_Value = ADC0->R[0];
Clarkk 9:0c6d78c56091 892 TFC_StartADC_MotBCurrent();
Clarkk 9:0c6d78c56091 893 break;
emh203 1:6f37253dab87 894
Clarkk 9:0c6d78c56091 895 case ADC_STATE_CAPTURE_MOTOR_B_CURRENT:
Clarkk 9:0c6d78c56091 896 MotBCurrentADC_Value = ADC0->R[0];
Clarkk 9:0c6d78c56091 897 TFC_StartNextConvertion();
Clarkk 9:0c6d78c56091 898 TFC_MotorCurrentReady++;
Clarkk 9:0c6d78c56091 899 TFC_ConvertionReadyCallback.call();
emh203 1:6f37253dab87 900 break;
emh203 1:6f37253dab87 901
emh203 1:6f37253dab87 902 case ADC_STATE_CAPTURE_LINE_SCAN:
Clarkk 9:0c6d78c56091 903 if(CurrentLineScanPixel<128)
Clarkk 9:0c6d78c56091 904 {
Clarkk 9:0c6d78c56091 905 LineScanImage0WorkingBuffer[CurrentLineScanPixel] = ADC0->R[0];
Clarkk 9:0c6d78c56091 906 ADC0->SC1[0] = TFC_LINESCAN0_ADC_CHANNEL | ADC_SC1_AIEN_MASK;
Clarkk 9:0c6d78c56091 907 CurrentLineScanPixel++;
Clarkk 9:0c6d78c56091 908
Clarkk 9:0c6d78c56091 909 TAOS_CLK_LOW;
Clarkk 9:0c6d78c56091 910 for(Junk = 0; Junk<50; Junk++) {
Clarkk 9:0c6d78c56091 911 }
Clarkk 9:0c6d78c56091 912 TAOS_CLK_HIGH;
Clarkk 9:0c6d78c56091 913
Clarkk 9:0c6d78c56091 914 /* if(CurrentLineScanChannel == 0) // Pixel of camera 0 has been converted
Clarkk 9:0c6d78c56091 915 {
emh203 1:6f37253dab87 916 LineScanImage0WorkingBuffer[CurrentLineScanPixel] = ADC0->R[0];
emh203 1:6f37253dab87 917 ADC0->SC1[0] = TFC_LINESCAN1_ADC_CHANNEL | ADC_SC1_AIEN_MASK;
emh203 1:6f37253dab87 918 CurrentLineScanChannel = 1;
Clarkk 9:0c6d78c56091 919 }
Clarkk 9:0c6d78c56091 920 else // Pixel of camera 1 has been converted
Clarkk 9:0c6d78c56091 921 {
emh203 1:6f37253dab87 922 LineScanImage1WorkingBuffer[CurrentLineScanPixel] = ADC0->R[0];
emh203 1:6f37253dab87 923 ADC0->SC1[0] = TFC_LINESCAN0_ADC_CHANNEL | ADC_SC1_AIEN_MASK;
emh203 1:6f37253dab87 924 CurrentLineScanChannel = 0;
emh203 1:6f37253dab87 925 CurrentLineScanPixel++;
emh203 1:6f37253dab87 926
emh203 1:6f37253dab87 927 TAOS_CLK_LOW;
emh203 1:6f37253dab87 928 for(Junk = 0; Junk<50; Junk++) {
emh203 1:6f37253dab87 929 }
emh203 1:6f37253dab87 930 TAOS_CLK_HIGH;
Clarkk 9:0c6d78c56091 931 }*/
Clarkk 9:0c6d78c56091 932 }
Clarkk 9:0c6d78c56091 933 else
Clarkk 9:0c6d78c56091 934 {
emh203 1:6f37253dab87 935 // done with the capture sequence. we can wait for the PIT0 IRQ to restart
emh203 1:6f37253dab87 936 TAOS_CLK_HIGH;
emh203 1:6f37253dab87 937 for(Junk = 0; Junk<50; Junk++) {
emh203 1:6f37253dab87 938 }
emh203 1:6f37253dab87 939 TAOS_CLK_LOW;
Clarkk 9:0c6d78c56091 940 TFC_StartNextConvertion();
emh203 1:6f37253dab87 941
emh203 1:6f37253dab87 942 //swap the buffer
emh203 1:6f37253dab87 943 if(LineScanWorkingBuffer == 0) {
emh203 1:6f37253dab87 944 LineScanWorkingBuffer = 1;
emh203 1:6f37253dab87 945
emh203 1:6f37253dab87 946 LineScanImage0WorkingBuffer = &LineScanImage0Buffer[1][0];
Clarkk 9:0c6d78c56091 947 //LineScanImage1WorkingBuffer = &LineScanImage1Buffer[1][0];
emh203 1:6f37253dab87 948
emh203 3:23cce037011f 949 TFC_LineScanImage0 = &LineScanImage0Buffer[0][0];
Clarkk 9:0c6d78c56091 950 //TFC_LineScanImage1 = &LineScanImage1Buffer[0][0];
emh203 1:6f37253dab87 951 } else {
emh203 1:6f37253dab87 952 LineScanWorkingBuffer = 0;
emh203 1:6f37253dab87 953 LineScanImage0WorkingBuffer = &LineScanImage0Buffer[0][0];
Clarkk 9:0c6d78c56091 954 //LineScanImage1WorkingBuffer = &LineScanImage1Buffer[0][0];
emh203 1:6f37253dab87 955
emh203 3:23cce037011f 956 TFC_LineScanImage0 = &LineScanImage0Buffer[1][0];
Clarkk 9:0c6d78c56091 957 //TFC_LineScanImage1 = &LineScanImage1Buffer[1][0];
emh203 1:6f37253dab87 958 }
emh203 1:6f37253dab87 959
emh203 3:23cce037011f 960 TFC_LineScanImageReady++;
Clarkk 9:0c6d78c56091 961 TFC_ConvertionReadyCallback.call();
emh203 1:6f37253dab87 962 }
emh203 1:6f37253dab87 963 break;
emh203 1:6f37253dab87 964 }
emh203 1:6f37253dab87 965 }
emh203 1:6f37253dab87 966
emh203 1:6f37253dab87 967 void TFC_InitLineScanCamera()
emh203 1:6f37253dab87 968 {
emh203 1:6f37253dab87 969 SIM->SCGC5 |= SIM_SCGC5_PORTE_MASK | SIM_SCGC5_PORTD_MASK; //Make sure the clock is enabled for PORTE;
emh203 1:6f37253dab87 970 PORTE->PCR[1] = PORT_PCR_MUX(1) | PORT_PCR_DSE_MASK; //Enable GPIO on on the pin for the CLOCK Signal
emh203 1:6f37253dab87 971 PORTD->PCR[7] = PORT_PCR_MUX(1) | PORT_PCR_DSE_MASK; //Enable GPIO on on the pin for SI signal
emh203 1:6f37253dab87 972
emh203 1:6f37253dab87 973 PORTD->PCR[5] = PORT_PCR_MUX(0); //Make sure AO signal goes to an analog input
emh203 1:6f37253dab87 974 PORTD->PCR[6] = PORT_PCR_MUX(0); //Make sure AO signal goes to an analog input
emh203 1:6f37253dab87 975
emh203 1:6f37253dab87 976 //Make sure the Clock and SI pins are outputs
emh203 1:6f37253dab87 977 PTD->PDDR |= (1<<7);
emh203 1:6f37253dab87 978 PTE->PDDR |= (1<<1);
emh203 1:6f37253dab87 979
emh203 1:6f37253dab87 980 TAOS_CLK_LOW;
emh203 1:6f37253dab87 981 TAOS_SI_LOW;
emh203 1:6f37253dab87 982
emh203 1:6f37253dab87 983 LineScanWorkingBuffer = 0;
emh203 1:6f37253dab87 984
emh203 1:6f37253dab87 985 LineScanImage0WorkingBuffer = &LineScanImage0Buffer[LineScanWorkingBuffer][0];
emh203 1:6f37253dab87 986 LineScanImage1WorkingBuffer = &LineScanImage1Buffer[LineScanWorkingBuffer][0];
emh203 1:6f37253dab87 987
emh203 3:23cce037011f 988 TFC_LineScanImage0 = &LineScanImage0Buffer[1][0];
emh203 3:23cce037011f 989 TFC_LineScanImage1 = &LineScanImage1Buffer[1][0];
emh203 1:6f37253dab87 990 }
emh203 1:6f37253dab87 991
emh203 1:6f37253dab87 992 /** Initialized TPM0 to be used for generating PWM signals for the the dual drive motors. This method is called in the TFC constructor with a default value of 4000.0Hz
emh203 1:6f37253dab87 993 *
emh203 1:6f37253dab87 994 * @param SwitchingFrequency PWM Switching Frequency in floating point format. Pick something between 1000 and 9000. Maybe you can modulate it and make a tune.
emh203 1:6f37253dab87 995 */
emh203 1:6f37253dab87 996 void TFC_InitMotorPWM(float SwitchingFrequency)
emh203 1:6f37253dab87 997 {
emh203 1:6f37253dab87 998 //Clock Setup for the TPM requires a couple steps.
emh203 1:6f37253dab87 999
emh203 1:6f37253dab87 1000 //1st, set the clock mux
emh203 1:6f37253dab87 1001 //See Page 124 of f the KL25 Sub-Family Reference Manual, Rev. 3, September 2012
emh203 3:23cce037011f 1002 SIM->SOPT2 |= SIM_SOPT2_PLLFLLSEL_MASK;// We Want MCGPLLCLK/2 (See Page 196 of the KL25 Sub-Family Reference Manual, Rev. 3, September 2012)
emh203 3:23cce037011f 1003 SIM->SOPT2 &= ~(SIM_SOPT2_TPMSRC_MASK);
emh203 3:23cce037011f 1004 SIM->SOPT2 |= SIM_SOPT2_TPMSRC(1); //We want the MCGPLLCLK/2 (See Page 196 of the KL25 Sub-Family Reference Manual, Rev. 3, September 2012)
emh203 1:6f37253dab87 1005
emh203 1:6f37253dab87 1006
emh203 1:6f37253dab87 1007 //Enable the Clock to the FTM0 Module
emh203 1:6f37253dab87 1008 //See Page 207 of f the KL25 Sub-Family Reference Manual, Rev. 3, September 2012
emh203 1:6f37253dab87 1009 SIM->SCGC6 |= SIM_SCGC6_TPM0_MASK;
emh203 1:6f37253dab87 1010
emh203 1:6f37253dab87 1011 //The TPM Module has Clock. Now set up the peripheral
emh203 1:6f37253dab87 1012
emh203 1:6f37253dab87 1013 //Blow away the control registers to ensure that the counter is not running
emh203 1:6f37253dab87 1014 TPM0->SC = 0;
emh203 1:6f37253dab87 1015 TPM0->CONF = 0;
emh203 1:6f37253dab87 1016
emh203 1:6f37253dab87 1017 //While the counter is disabled we can setup the prescaler
emh203 1:6f37253dab87 1018
emh203 1:6f37253dab87 1019 TPM0->SC = TPM_SC_PS(FTM0_CLK_PRESCALE);
emh203 1:6f37253dab87 1020
emh203 1:6f37253dab87 1021 //Setup the mod register to get the correct PWM Period
emh203 1:6f37253dab87 1022
emh203 1:6f37253dab87 1023 TPM0->MOD = (uint32_t)((float)(FTM0_CLOCK/(1<<FTM0_CLK_PRESCALE))/SwitchingFrequency);
emh203 1:6f37253dab87 1024
emh203 1:6f37253dab87 1025 //Setup Channels 0,1,2,3
emh203 1:6f37253dab87 1026 TPM0->CONTROLS[0].CnSC = TPM_CnSC_MSB_MASK | TPM_CnSC_ELSB_MASK;
emh203 1:6f37253dab87 1027 TPM0->CONTROLS[1].CnSC = TPM_CnSC_MSB_MASK | TPM_CnSC_ELSA_MASK; // invert the second PWM signal for a complimentary output;
emh203 1:6f37253dab87 1028 TPM0->CONTROLS[2].CnSC = TPM_CnSC_MSB_MASK | TPM_CnSC_ELSB_MASK;
emh203 1:6f37253dab87 1029 TPM0->CONTROLS[3].CnSC = TPM_CnSC_MSB_MASK | TPM_CnSC_ELSA_MASK; // invert the second PWM signal for a complimentary output;
emh203 1:6f37253dab87 1030
emh203 1:6f37253dab87 1031 //Enable the Counter
emh203 1:6f37253dab87 1032
emh203 1:6f37253dab87 1033 //Set the Default duty cycle to 50% duty cycle
emh203 1:6f37253dab87 1034 TFC_SetMotorPWM(0.0,0.0);
emh203 1:6f37253dab87 1035
emh203 1:6f37253dab87 1036 //Enable the TPM COunter
emh203 1:6f37253dab87 1037 TPM0->SC |= TPM_SC_CMOD(1);
emh203 1:6f37253dab87 1038
emh203 1:6f37253dab87 1039 //Enable the FTM functions on the the port
emh203 1:6f37253dab87 1040 PORTC->PCR[1] = PORT_PCR_MUX(4);
emh203 1:6f37253dab87 1041 PORTC->PCR[2] = PORT_PCR_MUX(4);
emh203 1:6f37253dab87 1042 PORTC->PCR[3] = PORT_PCR_MUX(4);
emh203 1:6f37253dab87 1043 PORTC->PCR[4] = PORT_PCR_MUX(4);
emh203 1:6f37253dab87 1044
emh203 1:6f37253dab87 1045 }
emh203 1:6f37253dab87 1046
emh203 1:6f37253dab87 1047 void TFC_SetMotorPWM(float MotorA , float MotorB)
emh203 1:6f37253dab87 1048 {
emh203 1:6f37253dab87 1049 if(MotorA>1.0)
emh203 1:6f37253dab87 1050 MotorA = 1.0;
emh203 1:6f37253dab87 1051 else if(MotorA<-1.0)
emh203 1:6f37253dab87 1052 MotorA = -1.0;
emh203 1:6f37253dab87 1053
emh203 1:6f37253dab87 1054 if(MotorB>1.0)
emh203 1:6f37253dab87 1055 MotorB = 1.0;
emh203 1:6f37253dab87 1056 else if(MotorB<-1.0)
emh203 1:6f37253dab87 1057 MotorB = -1.0;
emh203 1:6f37253dab87 1058
Clarkk 9:0c6d78c56091 1059 /* TPM0->CONTROLS[2].CnV = (uint16_t) ((float)TPM0->MOD * (float)((MotorA + 1.0)/2.0));
emh203 1:6f37253dab87 1060 TPM0->CONTROLS[3].CnV = TPM0->CONTROLS[2].CnV;
emh203 1:6f37253dab87 1061 TPM0->CONTROLS[0].CnV = (uint16_t) ((float)TPM0->MOD * (float)((MotorB + 1.0)/2.0));
Clarkk 9:0c6d78c56091 1062 TPM0->CONTROLS[1].CnV = TPM0->CONTROLS[0].CnV;*/
emh203 1:6f37253dab87 1063
Clarkk 9:0c6d78c56091 1064 if(MotorA >= 0)
Clarkk 9:0c6d78c56091 1065 {
Clarkk 9:0c6d78c56091 1066 TPM0->CONTROLS[2].CnV = 0xffff; // recirculation by high side to have current measurement
Clarkk 9:0c6d78c56091 1067 TPM0->CONTROLS[3].CnV = (uint16_t) ((float)TPM0->MOD * (float)MotorA); // channel is inverted
Clarkk 9:0c6d78c56091 1068 }
Clarkk 9:0c6d78c56091 1069 else
Clarkk 9:0c6d78c56091 1070 {
Clarkk 9:0c6d78c56091 1071 TPM0->CONTROLS[2].CnV = (uint16_t) ((float)TPM0->MOD * (float)(1.0 + MotorA));
Clarkk 9:0c6d78c56091 1072 TPM0->CONTROLS[3].CnV = 0; // recirculation by high side to have current measurement (channel is inverted)
Clarkk 9:0c6d78c56091 1073 }
Clarkk 9:0c6d78c56091 1074 if(MotorB >= 0)
Clarkk 9:0c6d78c56091 1075 {
Clarkk 9:0c6d78c56091 1076 TPM0->CONTROLS[0].CnV = 0xffff; // recirculation by high side to have current measurement
Clarkk 9:0c6d78c56091 1077 TPM0->CONTROLS[1].CnV = (uint16_t) ((float)TPM0->MOD * (float)MotorB); // channel is inverted
Clarkk 9:0c6d78c56091 1078 }
Clarkk 9:0c6d78c56091 1079 else
Clarkk 9:0c6d78c56091 1080 {
Clarkk 9:0c6d78c56091 1081 TPM0->CONTROLS[0].CnV = (uint16_t) ((float)TPM0->MOD * (float)(1.0 + MotorB));
Clarkk 9:0c6d78c56091 1082 TPM0->CONTROLS[1].CnV = 0; // recirculation by high side to have current measurement (channel is inverted)
Clarkk 9:0c6d78c56091 1083 }
emh203 1:6f37253dab87 1084 }
emh203 1:6f37253dab87 1085
emh203 1:6f37253dab87 1086 //Pot Reading is Scaled to return a value of -1.0 to 1.0
emh203 1:6f37253dab87 1087 float TFC_ReadPot(uint8_t Channel)
emh203 1:6f37253dab87 1088 {
emh203 1:6f37253dab87 1089 if(Channel == 0)
emh203 1:6f37253dab87 1090 return ((float)PotADC_Value[0]/-((float)ADC_MAX_CODE/2.0))+1.0;
emh203 1:6f37253dab87 1091 else
emh203 1:6f37253dab87 1092 return ((float)PotADC_Value[1]/-((float)ADC_MAX_CODE/2.0))+1.0;
emh203 1:6f37253dab87 1093 }
emh203 1:6f37253dab87 1094
Clarkk 9:0c6d78c56091 1095 uint16_t TFC_ReadBatteryVoltageRaw()
Clarkk 9:0c6d78c56091 1096 {
Clarkk 9:0c6d78c56091 1097 return BatSenseADC_Value;
Clarkk 9:0c6d78c56091 1098 }
Clarkk 9:0c6d78c56091 1099
Clarkk 9:0c6d78c56091 1100 uint16_t TFC_ReadMotACurrentRaw()
Clarkk 9:0c6d78c56091 1101 {
Clarkk 9:0c6d78c56091 1102 return MotACurrentADC_Value;
Clarkk 9:0c6d78c56091 1103 }
Clarkk 9:0c6d78c56091 1104
Clarkk 9:0c6d78c56091 1105 uint16_t TFC_ReadMotBCurrentRaw()
Clarkk 9:0c6d78c56091 1106 {
Clarkk 9:0c6d78c56091 1107 return MotBCurrentADC_Value;
Clarkk 9:0c6d78c56091 1108 }
Clarkk 9:0c6d78c56091 1109
emh203 1:6f37253dab87 1110 float TFC_ReadBatteryVoltage()
emh203 1:6f37253dab87 1111 {
Clarkk 9:0c6d78c56091 1112 return (((float)BatSenseADC_Value/(float)(ADC_MAX_CODE)) * 18.81);// * ((47000.0+10000.0)/10000.0*3.3)
emh203 1:6f37253dab87 1113 }
emh203 3:23cce037011f 1114
Clarkk 9:0c6d78c56091 1115 float TFC_ReadMotACurrent()
Clarkk 9:0c6d78c56091 1116 {
Clarkk 9:0c6d78c56091 1117 return (((float)MotACurrentADC_Value/(float)(ADC_MAX_CODE)) * 5.625);// * 3.3 / 220 * 375
Clarkk 9:0c6d78c56091 1118 }
Clarkk 9:0c6d78c56091 1119
Clarkk 9:0c6d78c56091 1120 float TFC_ReadMotBCurrent()
Clarkk 9:0c6d78c56091 1121 {
Clarkk 9:0c6d78c56091 1122 return (((float)MotBCurrentADC_Value/(float)(ADC_MAX_CODE)) * 5.625);// * 3.3 / 220 * 375
Clarkk 9:0c6d78c56091 1123 }
emh203 3:23cce037011f 1124
emh203 3:23cce037011f 1125 void TFC_SetBatteryLED_Level(uint8_t BattLevel)
emh203 3:23cce037011f 1126 {
emh203 3:23cce037011f 1127 switch(BattLevel)
emh203 3:23cce037011f 1128 {
emh203 3:23cce037011f 1129 default:
emh203 3:23cce037011f 1130 case 0:
emh203 3:23cce037011f 1131 TFC_BAT_LED0_OFF;
emh203 3:23cce037011f 1132 TFC_BAT_LED1_OFF;
emh203 3:23cce037011f 1133 TFC_BAT_LED2_OFF;
emh203 3:23cce037011f 1134 TFC_BAT_LED3_OFF;
emh203 3:23cce037011f 1135 break;
emh203 3:23cce037011f 1136
emh203 3:23cce037011f 1137 case 1:
emh203 3:23cce037011f 1138 TFC_BAT_LED0_ON;
emh203 3:23cce037011f 1139 TFC_BAT_LED1_OFF;
emh203 3:23cce037011f 1140 TFC_BAT_LED2_OFF;
emh203 3:23cce037011f 1141 TFC_BAT_LED3_OFF;
emh203 3:23cce037011f 1142 break;
emh203 3:23cce037011f 1143
emh203 3:23cce037011f 1144 case 2:
emh203 3:23cce037011f 1145 TFC_BAT_LED0_ON;
emh203 3:23cce037011f 1146 TFC_BAT_LED1_ON;
emh203 3:23cce037011f 1147 TFC_BAT_LED2_OFF;
emh203 3:23cce037011f 1148 TFC_BAT_LED3_OFF;
emh203 3:23cce037011f 1149 break;
emh203 3:23cce037011f 1150
emh203 3:23cce037011f 1151 case 3:
emh203 3:23cce037011f 1152 TFC_BAT_LED0_ON;
emh203 3:23cce037011f 1153 TFC_BAT_LED1_ON;
emh203 3:23cce037011f 1154 TFC_BAT_LED2_ON;
emh203 3:23cce037011f 1155 TFC_BAT_LED3_OFF;
emh203 3:23cce037011f 1156 break;
emh203 3:23cce037011f 1157
emh203 3:23cce037011f 1158 case 4:
emh203 3:23cce037011f 1159 TFC_BAT_LED0_ON;
emh203 3:23cce037011f 1160 TFC_BAT_LED1_ON;
emh203 3:23cce037011f 1161 TFC_BAT_LED2_ON;
emh203 3:23cce037011f 1162 TFC_BAT_LED3_ON;
emh203 3:23cce037011f 1163 break;
emh203 3:23cce037011f 1164
emh203 3:23cce037011f 1165 }
emh203 3:23cce037011f 1166 }