config.h

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
 
#ifndef _MAIN_H_
#define _MAIN_H_

#define __AVR_ATmega32U4__ 1
 
// Include main Arduino library for basic Arduino functions
#include <Arduino.h>
 
// Include AVR input/output definitions for low-level hardware control
#include <avr/io.h>
 
// Define ISR macro for IntelliSense, else include AVR interrupt handling
// library
#ifdef __INTELLISENSE__
#define ISR(vector) void vector(void)
#else
#include <avr/interrupt.h>
#endif
 
// Define __LPM macro for IntelliSense, else include AVR program space utility
// library
#ifdef __INTELLISENSE__
#define __LPM(x) 0
#else
#include <avr/pgmspace.h>
#endif
 
// Include math definitions
#include <math.h>
 
// Include standard integer type definitions
#include <stdint.h>



#define MOTOR_POLES 8

#define TIM4_FREQ 20000UL
#if TIM4_FREQ > 100000UL
#error "ADVISORY WARNING: TIM4_FREQ should not be set above 100 kHz. If you want to still continue, please uncomment and compile again."
#endif
#if TIM4_FREQ < 7183UL
#error "ADVISORY WARNING: TIM4_FREQ should not be set below 7183 Hz. If you want to still continue, you'll have to modify the code to allow for a higher pre-scaler value for Timer4."
#endif

#define DEAD_TIME 350UL
#if DEAD_TIME < 350
#error "ADVISORY WARNING: DEAD_TIME should not be set below 350 ns. If you want to still continue, please uncomment and compile again."
#endif

#define HALL_PULLUP_ENABLE TRUE

#define EMULATE_HALL FALSE

#define TIM3_FREQ 200UL

#define COMMUTATION_TICKS_STOPPED 6000

#define TURN_OFF_MODE TURN_OFF_MODE_RAMP

#define IPHASE_GAIN 20

#define IPHASE_SENSE_RESISTOR 2500

#define IBUS_GAIN 50

#define IBUS_SENSE_RESISTOR 4000

#define IBUS_WARNING_THRESHOLD 307

#define IBUS_ERROR_THRESHOLD 410

#define IBUS_FAULT_ENABLE TRUE

#define SPEED_CONTROL_METHOD SPEED_CONTROL_OPEN_LOOP

#define SPEED_CONTROLLER_TIME_BASE 200

#define SPEED_CONTROLLER_MAX_DELTA 1

#define SPEED_CONTROLLER_MAX_SPEED 400

#define PID_K_P 100

#define PID_K_I 10

#define PID_K_D_ENABLE TRUE

#define PID_K_D 0

#define VBUS_RTOP 100000

#define VBUS_RBOTTOM 6200

#define REMOTE_DEBUG_MODE FALSE


 
// Boolean values
#define FALSE 0
#define TRUE (!FALSE)

#define F_HST 64000000UL
 
// PWM pin definitions
#define AH_PIN PB6
#define BH_PIN PC7
#define CH_PIN PD7
#define AL_PIN PB5
#define BL_PIN PC6
#define CL_PIN PD6
 
// PWM PORT patterns
#define PWM_PATTERN_PORTB ((1 << AH_PIN) | (1 << AL_PIN))
#define PWM_PATTERN_PORTC ((1 << BH_PIN) | (1 << BL_PIN))
#define PWM_PATTERN_PORTD ((1 << CH_PIN) | (1 << CL_PIN))
#define OC_ENABLE_PORTB ((1 << OC4OE3) | (1 << OC4OE2))
#define OC_ENABLE_PORTC ((1 << OC4OE1) | (1 << OC4OE0))
#define OC_ENABLE_PORTD ((1 << OC4OE5) | (1 << OC4OE4))
 
// Direction macro definitions
#define DIRECTION_FORWARD 0
#define DIRECTION_REVERSE 1
#define DIRECTION_UNKNOWN 3
 
// Hall pins definitions
#define HALL_PIN PINB
#define H1_PIN PB1
#define H2_PIN PB2
#define H3_PIN PB3
 
// ADC ADMUX selections
#define ADC_MUX_L_SPEED ADC_MUX_L_ADC4
#define ADC_MUX_H_SPEED ADC_MUX_H_ADC4
#define ADC_MUX_L_IBUS ADC_MUX_L_ADC5
#define ADC_MUX_H_IBUS ADC_MUX_H_ADC5
#define ADC_MUX_L_IPHASE_U ADC_MUX_L_ADC1
#define ADC_MUX_H_IPHASE_U ADC_MUX_H_ADC1
#define ADC_MUX_L_IPHASE_V ADC_MUX_L_ADC7
#define ADC_MUX_H_IPHASE_V ADC_MUX_H_ADC7
#define ADC_MUX_L_IPHASE_W ADC_MUX_L_ADC0
#define ADC_MUX_H_IPHASE_W ADC_MUX_H_ADC0
#define ADC_MUX_L_VBUSVREF ADC_MUX_L_ADC6
#define ADC_MUX_H_VBUSVREF ADC_MUX_H_ADC6
 
// ADC configurations
#define ADC_PRESCALER ADC_PRESCALER_DIV_128
#define ADC_REFERENCE_VOLTAGE ADC_REFERENCE_VOLTAGE_VCC
#define ADC_TRIGGER ADC_TRIGGER_TIMER0_OVF
 
// Input pin definitions
#define DIRECTION_COMMAND_PIN PD2
#define ENABLE_PIN PD0
#define REMOTE_PIN PD3
 
// Speed Input Source definitions (only during remote mode)
#define SPEED_INPUT_SOURCE_LOCAL 0
#define SPEED_INPUT_SOURCE_REMOTE 1
 
// Fault pin definitions
#define FAULT_PIN_1 PD4
#define FAULT_PIN_2 PB4
#define FAULT_PIN_3 PB7
 
// Waveform macro definitions
#define WAVEFORM_BLOCK_COMMUTATION 0
#define WAVEFORM_UNDEFINED 3
 
// Turn off mode macro definitions
#define TURN_OFF_MODE_COAST 0
#define TURN_OFF_MODE_RAMP 1
 
// Speed control macro definitions
#define SPEED_CONTROL_OPEN_LOOP 0
#define SPEED_CONTROL_CLOSED_LOOP 1

#define SPEED_CONTROLLER_MAX_INPUT 255

#define CHOOSE_TIM4_PRESCALER(tim4Freq) ((tim4Freq) < 15625 ? 4 : ((tim4Freq) < 31250 ? 2 : 1))

#define CHOOSE_DT_PRESCALER(deadTime)             \
   ((deadTime) <= 234 ? 1 : (deadTime) <= 468 ? 2 \
                        : (deadTime) <= 937   ? 4 \
                        : (deadTime) <= 1875  ? 8 \
                                              : 0)

#if defined(__INTELLISENSE__) || defined(__DOXYGEN__)
#define FORCE_INLINE inline
#else
#define FORCE_INLINE inline __attribute__((always_inline))
#endif

#if defined(__INTELLISENSE__) || defined(__DOXYGEN__)
#define FAST_ACCESS(register_address)
#else
#define FAST_ACCESS(register_address) __attribute__((address(register_address)))
#endif
 
#ifdef __INTELLISENSE__
#define sei() ((void)0)

#define cli() ((void)0)
#endif

#define PLL_POSTSCALER_OFF ((0 << PLLTM1) | (0 << PLLTM0))
#define PLL_POSTSCALER_DIV_1_0 ((0 << PLLTM1) | (1 << PLLTM0))
#define PLL_POSTSCALER_DIV_1_5 ((1 << PLLTM1) | (0 << PLLTM0))
#define PLL_POSTSCALER_DIV_2_0 ((1 << PLLTM1) | (1 << PLLTM0))

#define DT_PRESCALER_DIV_1 ((0 << DTPS41) | (0 << DTPS40))
#define DT_PRESCALER_DIV_2 ((0 << DTPS41) | (1 << DTPS40))
#define DT_PRESCALER_DIV_4 ((1 << DTPS41) | (0 << DTPS40))
#define DT_PRESCALER_DIV_8 ((1 << DTPS41) | (1 << DTPS40))

#define TIM1_CLOCK_OFF ((0 << CS12) | (0 << CS11) | (0 << CS10))
#define TIM1_CLOCK_DIV_1 ((0 << CS12) | (0 << CS11) | (1 << CS10))
#define TIM1_CLOCK_DIV_8 ((0 << CS12) | (1 << CS11) | (0 << CS10))
#define TIM1_CLOCK_DIV_64 ((0 << CS12) | (1 << CS11) | (1 << CS10))
#define TIM1_CLOCK_DIV_256 ((1 << CS12) | (0 << CS11) | (0 << CS10))
#define TIM1_CLOCK_DIV_1024 ((1 << CS12) | (0 << CS11) | (1 << CS10))
#define TIM1_CLOCK_EXT_FALLING ((1 << CS12) | (1 << CS11) | (0 << CS10))
#define TIM1_CLOCK_EXT_RISING ((1 << CS12) | (1 << CS11) | (1 << CS10))

#define TIM4_PRESCALER_OFF ((0 << CS43) | (0 << CS42) | (0 << CS41) | (0 << CS40))
#define TIM4_PRESCALER_DIV_1 ((0 << CS43) | (0 << CS42) | (0 << CS41) | (1 << CS40))
#define TIM4_PRESCALER_DIV_2 ((0 << CS43) | (0 << CS42) | (1 << CS41) | (0 << CS40))
#define TIM4_PRESCALER_DIV_4 ((0 << CS43) | (0 << CS42) | (1 << CS41) | (1 << CS40))

#define ADC_MUX_L_BITS ((1 << MUX4) | (1 << MUX3) | (1 << MUX2) | (1 << MUX1) | (1 << MUX0))
#define ADC_MUX_H_BITS (1 << MUX5)
#define ADC_MUX_L_ADC0 ((0 << MUX4) | (0 << MUX3) | (0 << MUX2) | (0 << MUX1) | (0 << MUX0))
#define ADC_MUX_H_ADC0 (0 << MUX5)
#define ADC_MUX_L_ADC1 ((0 << MUX4) | (0 << MUX3) | (0 << MUX2) | (0 << MUX1) | (1 << MUX0))
#define ADC_MUX_H_ADC1 (0 << MUX5)
#define ADC_MUX_L_ADC4 ((0 << MUX4) | (0 << MUX3) | (1 << MUX2) | (0 << MUX1) | (0 << MUX0))
#define ADC_MUX_H_ADC4 (0 << MUX5)
#define ADC_MUX_L_ADC5 ((0 << MUX4) | (0 << MUX3) | (1 << MUX2) | (0 << MUX1) | (1 << MUX0))
#define ADC_MUX_H_ADC5 (0 << MUX5)
#define ADC_MUX_L_ADC6 ((0 << MUX4) | (0 << MUX3) | (1 << MUX2) | (1 << MUX1) | (0 << MUX0))
#define ADC_MUX_H_ADC6 (0 << MUX5)
#define ADC_MUX_L_ADC7 ((0 << MUX4) | (0 << MUX3) | (1 << MUX2) | (1 << MUX1) | (1 << MUX0))
#define ADC_MUX_H_ADC7 (0 << MUX5)
#define ADC_MUX_L_ADC8 ((0 << MUX4) | (0 << MUX3) | (0 << MUX2) | (0 << MUX1) | (0 << MUX0))
#define ADC_MUX_H_ADC8 (1 << MUX5)
#define ADC_MUX_L_ADC9 ((0 << MUX4) | (0 << MUX3) | (0 << MUX2) | (0 << MUX1) | (1 << MUX0))
#define ADC_MUX_H_ADC9 (1 << MUX5)
#define ADC_MUX_L_ADC10 ((0 << MUX4) | (0 << MUX3) | (0 << MUX2) | (1 << MUX1) | (0 << MUX0))
#define ADC_MUX_H_ADC10 (1 << MUX5)
#define ADC_MUX_L_ADC11 ((0 << MUX4) | (0 << MUX3) | (0 << MUX2) | (1 << MUX1) | (1 << MUX0))
#define ADC_MUX_H_ADC11 (1 << MUX5)
#define ADC_MUX_L_ADC12 ((0 << MUX4) | (0 << MUX3) | (1 << MUX2) | (0 << MUX1) | (0 << MUX0))
#define ADC_MUX_H_ADC12 (1 << MUX5)
#define ADC_MUX_L_ADC13 ((0 << MUX4) | (0 << MUX3) | (1 << MUX2) | (0 << MUX1) | (1 << MUX0))
#define ADC_MUX_H_ADC13 (1 << MUX5)
#define ADC_MUX_L_TEMP_SENSOR ((0 << MUX4) | (0 << MUX3) | (1 << MUX2) | (1 << MUX1) | (1 << MUX0))
#define ADC_MUX_H_TEMP_SENSOR (1 << MUX5)
#define ADC_MUX_L_1V1 ((1 << MUX4) | (1 << MUX3) | (1 << MUX2) | (1 << MUX1) | (0 << MUX0))
#define ADC_MUX_H_1V1 (0 << MUX5)
#define ADC_MUX_L_0V ((1 << MUX4) | (1 << MUX3) | (1 << MUX2) | (1 << MUX1) | (1 << MUX0))
#define ADC_MUX_H_0V (0 << MUX5)

#define ADC_PRESCALER_DIV_2 ((0 << ADPS2) | (0 << ADPS1) | (0 << ADPS0))
#define ADC_PRESCALER_DIV_4 ((0 << ADPS2) | (1 << ADPS1) | (0 << ADPS0))
#define ADC_PRESCALER_DIV_8 ((0 << ADPS2) | (1 << ADPS1) | (1 << ADPS0))
#define ADC_PRESCALER_DIV_16 ((1 << ADPS2) | (0 << ADPS1) | (0 << ADPS0))
#define ADC_PRESCALER_DIV_32 ((1 << ADPS2) | (0 << ADPS1) | (1 << ADPS0))
#define ADC_PRESCALER_DIV_64 ((1 << ADPS2) | (1 << ADPS1) | (0 << ADPS0))
#define ADC_PRESCALER_DIV_128 ((1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0))

#define ADC_REFERENCE_VOLTAGE_AREF ((0 << REFS1) | (0 << REFS0))
#define ADC_REFERENCE_VOLTAGE_VCC ((0 << REFS1) | (1 << REFS0))
#define ADC_REFERENCE_VOLTAGE_INTERNAL ((1 << REFS1) | (1 << REFS0))

#define ADC_TRIGGER_FREE ((0 << ADTS3) | (0 << ADTS2) | (0 << ADTS1) | (0 << ADTS0))
#define ADC_TRIGGER_ANALOG_COMP ((0 << ADTS3) | (0 << ADTS2) | (0 << ADTS1) | (1 << ADTS0))
#define ADC_TRIGGER_INT0 ((0 << ADTS3) | (0 << ADTS2) | (1 << ADTS1) | (0 << ADTS0))
#define ADC_TRIGGER_TIMER0_COMPA ((0 << ADTS3) | (0 << ADTS2) | (1 << ADTS1) | (1 << ADTS0))
#define ADC_TRIGGER_TIMER0_OVF ((0 << ADTS3) | (1 << ADTS2) | (0 << ADTS1) | (0 << ADTS0))
#define ADC_TRIGGER_TIMER1_COMPB ((0 << ADTS3) | (1 << ADTS2) | (0 << ADTS1) | (1 << ADTS0))
#define ADC_TRIGGER_TIMER1_OVF ((0 << ADTS3) | (1 << ADTS2) | (1 << ADTS1) | (0 << ADTS0))
#define ADC_TRIGGER_TIMER1_CAPT ((0 << ADTS3) | (1 << ADTS2) | (1 << ADTS1) | (1 << ADTS0))
#define ADC_TRIGGER_TIMER4_OVF ((1 << ADTS3) | (0 << ADTS2) | (0 << ADTS1) | (0 << ADTS0))
#define ADC_TRIGGER_TIMER4_COMPA ((1 << ADTS3) | (0 << ADTS2) | (0 << ADTS1) | (1 << ADTS0))
#define ADC_TRIGGER_TIMER4_COMPB ((1 << ADTS3) | (0 << ADTS2) | (1 << ADTS1) | (0 << ADTS0))
#define ADC_TRIGGER_TIMER4_COMPD ((1 << ADTS3) | (0 << ADTS2) | (1 << ADTS1) | (1 << ADTS0))
 
// Typedefs
typedef struct motorflags
{
   uint8_t reserved : 7;
   uint8_t speedControllerRun : 1;
   uint8_t remote : 1;
   uint8_t enable : 1;
   uint8_t actualDirection : 2;
   uint8_t desiredDirection : 1;
   uint8_t driveWaveform : 2;
   uint8_t fatalFault : 1;
} motorflags_t;

typedef struct faultflags
{
   uint8_t reserved : 1;
   uint8_t reverseDirection : 1;
   uint8_t motorStopped : 1;
   uint8_t overCurrent : 1;
   uint8_t noHallConnections : 1;
   uint8_t userFlag1 : 1;
   uint8_t userFlag2 : 1;
   uint8_t userFlag3 : 1;
} faultflags_t;

typedef enum
{
   FAULT_RESERVED,
   FAULT_REVERSE_DIRECTION,
   FAULT_MOTOR_STOPPED,
   FAULT_OVER_CURRENT,
   FAULT_NO_HALL_CONNECTIONS,
   FAULT_USER_FLAG1,
   FAULT_USER_FLAG2,
   FAULT_USER_FLAG3
} fault_flag_t;

typedef struct motorconfigs
{
   uint32_t tim4Freq : 17; // max value 131071
   uint16_t tim4Top : 10; // max value 1023
   uint16_t tim4DeadTime : 11; // max value 2047
   uint8_t speedInputSource : 1;
} motorconfigs_t;



#define TIM4_PRESCALER_DIV_PATTERN(tim4Prescaler)                                             \
   ((tim4Prescaler) == 1 ? TIM4_PRESCALER_DIV_1 : (tim4Prescaler) == 2 ? TIM4_PRESCALER_DIV_2 \
                                              : (tim4Prescaler) == 4   ? TIM4_PRESCALER_DIV_4 \
                                                                       : 0)

#define TIM4_TOP(tim4Freq) (((F_HST / ((uint32_t)tim4Freq * CHOOSE_TIM4_PRESCALER(tim4Freq))) >> 1) - 1)

#define TIM4_TOP_MAX 0x03ff

#define DT_PRESCALER_DIV_PATTERN(dtPrescaler)                                         \
   ((dtPrescaler) == 1 ? DT_PRESCALER_DIV_1 : (dtPrescaler) == 2 ? DT_PRESCALER_DIV_2 \
                                          : (dtPrescaler) == 4   ? DT_PRESCALER_DIV_4 \
                                          : (dtPrescaler) == 8   ? DT_PRESCALER_DIV_8 \
                                                                 : 0)

#define DEAD_TIME_HALF(deadTime) (((uint8_t)(ceil((double)deadTime * F_HST / ((double)CHOOSE_DT_PRESCALER(deadTime) * 1000000000)))))

#define TIM3_TOP (((F_CPU / TIM3_FREQ / 3) >> 4) - 1)

#define TIM3_TOP_MAX 0xffff
#if TIM3_TOP_ > TIM3_TOP_MAX
#error "Invalid TIM3_FREQ set"
#endif
 
#if ((EMULATE_HALL == TRUE) && (SPEED_CONTROL_METHOD == SPEED_CONTROL_CLOSED_LOOP))
#error "Invalid combination of EMULATE_HALL and SPEED_CONTROL_METHOD"
#endif







 
#endif /* _MAIN_H_ */