tc.c

Go to the documentation of this file.

/*
 * Support and FAQ: visit <a href="https://www.microchip.com/support/">Microchip Support</a>
 */

#include <assert.h>
#include "tc.h"


#ifdef __cplusplus
extern "C" {
#endif


#ifndef TC_WPMR_WPKEY_PASSWD
#define TC_WPMR_WPKEY_PASSWD TC_WPMR_WPKEY((uint32_t)0x54494D)
#endif

void tc_init(
                Tc *p_tc,
                uint32_t ul_channel,
                uint32_t ul_mode)
{
        TcChannel *tc_channel;

        /* Validate inputs. */
        Assert(p_tc);
        Assert(ul_channel <
                        (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
        tc_channel = p_tc->TC_CHANNEL + ul_channel;

        /*  Disable TC clock. */
        tc_channel->TC_CCR = TC_CCR_CLKDIS;

        /*  Disable interrupts. */
        tc_channel->TC_IDR = 0xFFFFFFFF;

        /*  Clear status register. */
        tc_channel->TC_SR;

        /*  Set mode. */
        tc_channel->TC_CMR = ul_mode;
}

void tc_sync_trigger(
                Tc *p_tc)
{
        /* Validate inputs. */
        Assert(p_tc);
        
        p_tc->TC_BCR = TC_BCR_SYNC;
}

void tc_set_block_mode(
                Tc *p_tc,
                uint32_t ul_blockmode)
{
        /* Validate inputs. */
        Assert(p_tc);
        
        p_tc->TC_BMR = ul_blockmode;
}

#if (!SAM3U) || defined(__DOXYGEN__)

uint32_t tc_init_2bit_gray(
                Tc *p_tc,
                uint32_t ul_channel,
                uint32_t ul_steppermode)
{
        /* Validate inputs. */
        Assert(p_tc);
        Assert(ul_channel <
                        (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));

        p_tc->TC_CHANNEL[ul_channel].TC_SMMR = ul_steppermode;
        return 0;
}

#endif /* (!SAM3U) || defined(__DOXYGEN__) */

void tc_start(
                Tc *p_tc,
                uint32_t ul_channel)
{
        /* Validate inputs. */
        Assert(p_tc);
        Assert(ul_channel <
                        (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));

        p_tc->TC_CHANNEL[ul_channel].TC_CCR = TC_CCR_CLKEN | TC_CCR_SWTRG;
}

void tc_stop(
                Tc *p_tc,
                uint32_t ul_channel)
{
        /* Validate inputs. */
        Assert(p_tc);
        Assert(ul_channel <
                        (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));

        p_tc->TC_CHANNEL[ul_channel].TC_CCR = TC_CCR_CLKDIS;
}

uint32_t tc_read_cv(
                Tc *p_tc,
                uint32_t ul_channel)
{
        /* Validate inputs. */
        Assert(p_tc);
        Assert(ul_channel <
                        (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));

        return p_tc->TC_CHANNEL[ul_channel].TC_CV;
}

uint32_t tc_read_ra(
                Tc *p_tc,
                uint32_t ul_channel)
{
        /* Validate inputs. */
        Assert(p_tc);
        Assert(ul_channel <
                        (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));

        return p_tc->TC_CHANNEL[ul_channel].TC_RA;
}

uint32_t tc_read_rb(
                Tc *p_tc,
                uint32_t ul_channel)
{
        /* Validate inputs. */
        Assert(p_tc);
        Assert(ul_channel <
                        (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));

        return p_tc->TC_CHANNEL[ul_channel].TC_RB;
}

uint32_t tc_read_rc(
                Tc *p_tc,
                uint32_t ul_channel)
{
        /* Validate inputs. */
        Assert(p_tc);
        Assert(ul_channel <
                        (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));

        return p_tc->TC_CHANNEL[ul_channel].TC_RC;
}

void tc_write_ra(
                Tc *p_tc,
                uint32_t ul_channel,
                uint32_t ul_value)
{
        /* Validate inputs. */
        Assert(p_tc);
        Assert(ul_channel <
                        (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));

        p_tc->TC_CHANNEL[ul_channel].TC_RA = ul_value;
}

void tc_write_rb(
                Tc *p_tc,
                uint32_t ul_channel,
                uint32_t ul_value)
{
        /* Validate inputs. */
        Assert(p_tc);
        Assert(ul_channel <
                        (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));

        p_tc->TC_CHANNEL[ul_channel].TC_RB = ul_value;
}

void tc_write_rc(
                Tc *p_tc,
                uint32_t ul_channel,
                uint32_t ul_value)
{
        /* Validate inputs. */
        Assert(p_tc);
        Assert(ul_channel <
                        (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));

        p_tc->TC_CHANNEL[ul_channel].TC_RC = ul_value;
}

void tc_enable_interrupt(
                Tc *p_tc,
                uint32_t ul_channel,
                uint32_t ul_sources)
{
        TcChannel *tc_channel;

        /* Validate inputs. */
        Assert(p_tc);
        Assert(ul_channel <
                        (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
        tc_channel = p_tc->TC_CHANNEL + ul_channel;
        tc_channel->TC_IER = ul_sources;
}

void tc_disable_interrupt(
                Tc *p_tc,
                uint32_t ul_channel,
                uint32_t ul_sources)
{
        TcChannel *tc_channel;

        /* Validate inputs. */
        Assert(p_tc);
        Assert(ul_channel <
                        (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
        tc_channel = p_tc->TC_CHANNEL + ul_channel;
        tc_channel->TC_IDR = ul_sources;
}

uint32_t tc_get_interrupt_mask(
                Tc *p_tc,
                uint32_t ul_channel)
{
        TcChannel *tc_channel;

        /* Validate inputs. */
        Assert(p_tc);
        Assert(ul_channel <
                        (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
        tc_channel = p_tc->TC_CHANNEL + ul_channel;
        return tc_channel->TC_IMR;
}

uint32_t tc_get_status(
                Tc *p_tc,
                uint32_t ul_channel)
{
        TcChannel *tc_channel;

        /* Validate inputs. */
        Assert(p_tc);
        Assert(ul_channel <
                        (sizeof(p_tc->TC_CHANNEL) / sizeof(p_tc->TC_CHANNEL[0])));
                        
        tc_channel = p_tc->TC_CHANNEL + ul_channel;
        return tc_channel->TC_SR;
}

/* TC divisor used to find the lowest acceptable timer frequency */
#define TC_DIV_FACTOR 65536

#if (!SAM4L) && !defined(__DOXYGEN__)

#ifndef FREQ_SLOW_CLOCK_EXT
#define FREQ_SLOW_CLOCK_EXT 32768 /* External slow clock frequency (hz) */
#endif

uint32_t tc_find_mck_divisor(
                uint32_t ul_freq,
                uint32_t ul_mck,
                uint32_t *p_uldiv,
                uint32_t *p_ultcclks,
                uint32_t ul_boardmck)
{
        const uint32_t divisors[5] = { 2, 8, 32, 128,
                        ul_boardmck / FREQ_SLOW_CLOCK_EXT };
        uint32_t ul_index;
        uint32_t ul_high, ul_low;

        /*  Satisfy frequency bound. */
        for (ul_index = 0;
                        ul_index < (sizeof(divisors) / sizeof(divisors[0]));
                        ul_index++) {
                ul_high = ul_mck / divisors[ul_index];
                ul_low  = ul_high / TC_DIV_FACTOR;
                if (ul_freq > ul_high) {
                        return 0;
                } else if (ul_freq >= ul_low) {
                        break;
                }
        }
        if (ul_index >= (sizeof(divisors) / sizeof(divisors[0]))) {
                return 0;
        }

        /*  Store results. */
        if (p_uldiv) {
                *p_uldiv = divisors[ul_index];
        }

        if (p_ultcclks) {
                *p_ultcclks = ul_index;
        }

        return 1;
}

#endif /* (!SAM4L) */

#if (SAM4L) || defined(__DOXYGEN__)

uint32_t tc_find_mck_divisor(
                uint32_t ul_freq,
                uint32_t ul_mck,
                uint32_t *p_uldiv,
                uint32_t *p_ultcclks,
                uint32_t ul_boardmck)
{
        const uint32_t divisors[5] = { 0, 2, 8, 32, 128};
        uint32_t ul_index;
        uint32_t ul_high, ul_low;

        UNUSED(ul_boardmck);

        /*  Satisfy frequency bound. */
        for (ul_index = 1;
                        ul_index < (sizeof(divisors) / sizeof(divisors[0]));
                        ul_index++) {
                ul_high = ul_mck / divisors[ul_index];
                ul_low  = ul_high / TC_DIV_FACTOR;
                if (ul_freq > ul_high) {
                        return 0;
                } else if (ul_freq >= ul_low) {
                        break;
                }
        }
        if (ul_index >= (sizeof(divisors) / sizeof(divisors[0]))) {
                return 0;
        }

        /*  Store results. */
        if (p_uldiv) {
                *p_uldiv = divisors[ul_index];
        }

        if (p_ultcclks) {
                *p_ultcclks = ul_index;
        }

        return 1;
}

#endif /* (SAM4L) || defined(__DOXYGEN__) */

#if (!SAM4L && !SAMG) || defined(__DOXYGEN__)

void tc_enable_qdec_interrupt(
                Tc *p_tc,
                uint32_t ul_sources)
{
        /* Validate inputs. */
        Assert(p_tc);
        
        p_tc->TC_QIER = ul_sources;
}

void tc_disable_qdec_interrupt(
                Tc *p_tc,
                uint32_t ul_sources)
{
        /* Validate inputs. */
        Assert(p_tc);
        
        p_tc->TC_QIDR = ul_sources;
}

uint32_t tc_get_qdec_interrupt_mask(
                Tc *p_tc)
{
        /* Validate inputs. */
        Assert(p_tc);
        
        return p_tc->TC_QIMR;
}

uint32_t tc_get_qdec_interrupt_status(
                Tc *p_tc)
{
        /* Validate inputs. */
        Assert(p_tc);
        
        return p_tc->TC_QISR;
}

#endif /* (!SAM4L && !SAMG) || defined(__DOXYGEN__) */

#if (!SAM3U) || defined(__DOXYGEN__)

void tc_set_writeprotect(
                Tc *p_tc,
                uint32_t ul_enable)
{
        /* Validate inputs. */
        Assert(p_tc);
        
        if (ul_enable) {
                p_tc->TC_WPMR = TC_WPMR_WPKEY_PASSWD | TC_WPMR_WPEN;
        } else {
                p_tc->TC_WPMR = TC_WPMR_WPKEY_PASSWD;
        }
}

#endif /* (!SAM3U) || defined(__DOXYGEN__) */

#if SAM4L || defined(__DOXYGEN__)

uint32_t tc_get_feature(
                Tc *p_tc)
{
        /* Validate inputs. */
        Assert(p_tc);
        
        return p_tc->TC_FEATURES;
}

uint32_t tc_get_version(
                Tc *p_tc)
{
        /* Validate inputs. */
        Assert(p_tc);
        
        return p_tc->TC_VERSION;
}

#endif /* SAM4L || defined(__DOXYGEN__) */


#ifdef __cplusplus
}
#endif

---

inertial_sense_ros
Author(s):
autogenerated on Sat Sep 19 2020 03:19:05