pca.h

Go to the documentation of this file.

#ifndef STC15_PCAH
#define STC15_PCAH
 
#include <bits.h>
 
#define PCA_CPS0_BIT 1
#define PCA_CPS_MASK 0x0E
#define PCA_PWM_EBS0_BIT 6
#define PCA_PWM_EBS_MASK 0xC0
 
#define PCA_CCP_S0_BIT 4
#define PCA_CCP_S0_MSK 0x10
#define PCA_CCP_S1_MSK 0x20
#define PCA_CCP_SW_MASK (uint8_t)(PCA_CCP_S0_MSK | PCA_CCP_S1_MSK)
 
typedef enum
{
    PCA_PIN_GROUP_1 = 0,
    PCA_PIN_GROUP_2 = 1,
    PCA_PIN_GROUP_3 = 2
} pca_pin_group_t;
 
typedef enum
{
    PCA_CLOCK_SYS_12 = 0,
    PCA_CLOCK_SYS_2 = 1,
    PCA_CLOCK_TIMER0 = 2,
    PCA_CLOCK_ECI = 3,
    PCA_CLOCK_SYS = 4,
    PCA_CLOCK_SYS_4 = 5,
    PCA_CLOCK_SYS_6 = 6,
    PCA_CLOCK_SYS_8 = 7
} pca_clock_source_t;
 
typedef enum
{
    PCA_PWM_8BIT = 0,
    PCA_PWM_7BIT = 1,
    PCA_PWM_6BIT = 2
} pca_pwm_resolution_t;
 
 
 
#define pca_set_pin_group(group)                                       \
do {                                                                   \
    bit_clr(P_SW1, PCA_CCP_SW_MASK);                                    \
    bit_set(P_SW1, (uint8_t)((group) << PCA_CCP_S0_BIT));              \
} while(0)
 
#define pca_get_pin_group() ((pca_pin_group_t)(bit_shift_right(get_reg(P_SW1, (PCA_CCP_S0_MSK | PCA_CCP_S1_MSK)), PCA_CCP_S0_BIT)))
 
 
 
#define pca_set_clock_source(src)                                      \
do {                                                                   \
    bit_clr(CMOD, PCA_CPS_MASK);                                        \
    bit_set(CMOD, (uint8_t)((src) << PCA_CPS0_BIT));                   \
} while(0)
 
#define pca_get_clock_source() ((pca_clock_source_t)(bit_shift_right(get_reg(CMOD, PCA_CPS_MASK), PCA_CPS0_BIT)))
 
#define pca_set_counter(value)                                         \
do {                                                                   \
    CH = (uint8_t)bit_shift_right((uint16_t)(value), 8);               \
    CL = (uint8_t)(value);                                             \
} while(0)
 
#define pca_get_counter() ((uint16_t)(bit_shift_left((uint16_t)CH, 8) | (uint16_t)CL))
 
#define pca_start() (CR = 1)
 
#define pca_stop() (CR = 0)
 
#define is_pca_running() (CR)
 
#define pca_counter_run_in_idle() (bit_clr(CMOD,SBIT7))
 
#define pca_counter_gate_off_in_idle() (bit_set(CMOD, SBIT7))
 
#define is_pca_counter_gated_off_in_idle() (test_if_bit_set(CMOD, SBIT7))
 
 
 
#define pca_clear_overflow_flag() (CF = 0)
 
#define is_pca_overflow() (CF)
 
#define pca_enable_overflow_interrupt() (bit_set(CMOD, SBIT0))
 
#define pca_disable_overflow_interrupt() (bit_clr(CMOD, SBIT0))
 
#define is_pca_overflow_interrupt_enabled() (test_if_bit_set(CMOD, SBIT0))
 
 
 
#define pca_clear_module_flag(module) (CCF ## module = 0)
 
#define is_pca_module_flag_set(module) (CCF ## module)
 
#define pca_module_enable_interrupt(module) (bit_set(CCAPM ## module, SBIT0))
 
#define pca_module_disable_interrupt(module) (bit_clr(CCAPM ## module, SBIT0))
 
#define is_pca_module_interrupt_enabled(module) (test_if_bit_set(CCAPM ## module, SBIT0))
 
 
 
#define pca_module_enable_comparator(module) (bit_set(CCAPM ## module, SBIT6))
 
#define pca_module_disable_comparator(module) (bit_clr(CCAPM ## module, SBIT6))
 
#define pca_module_enable_capture_positive(module) (bit_set(CCAPM ## module, SBIT5))
 
#define pca_module_disable_capture_positive(module) (bit_clr(CCAPM ## module, SBIT5))
 
#define pca_module_enable_capture_negative(module) (bit_set(CCAPM ## module, SBIT4))
 
#define pca_module_disable_capture_negative(module) (bit_clr(CCAPM ## module, SBIT4))
 
#define pca_module_enable_match(module) (bit_set(CCAPM ## module, SBIT3))
 
#define pca_module_disable_match(module) (bit_clr(CCAPM ## module, SBIT3))
 
#define pca_module_enable_toggle(module) (bit_set(CCAPM ## module, SBIT2))
 
#define pca_module_disable_toggle(module) (bit_clr(CCAPM ## module, SBIT2))
 
#define pca_module_set_compare(module, value)                          \
do {                                                                   \
    CCAP ## module ## H = (uint8_t)bit_shift_right((uint16_t)(value), 8); \
    CCAP ## module ## L = (uint8_t)(value);                            \
} while(0)
 
#define pca_module_get_capture(module) ((uint16_t)(bit_shift_left((uint16_t)CCAP ## module ## H, 8) | (uint16_t)CCAP ## module ## L))
 
 
 
#define pca_module_pwm_init(module, resolution)                        \
do {                                                                   \
    bit_clr(PCA_PWM ## module, PCA_PWM_EBS_MASK);                       \
    bit_set(PCA_PWM ## module, (uint8_t)((resolution) << PCA_PWM_EBS0_BIT)); \
    bit_set(CCAPM ## module, SBIT1);                                   \
} while(0)
 
#define pca_module_pwm_disable(module) (bit_clr(CCAPM ## module, SBIT1))
 
#define is_pca_module_pwm_enabled(module) (test_if_bit_set(CCAPM ## module, SBIT1))
 
#define pca_module_pwm_set_duty(module, duty)                          \
do {                                                                   \
    CCAP ## module ## H = (uint8_t)(duty);                             \
    CCAP ## module ## L = (uint8_t)(duty);                             \
} while(0)
 
#define pca_module_pwm_set_duty_on_overflow(module, duty) (CCAP ## module ## H = (uint8_t)(duty))
 
 
#endif