Subversion Repositories svnkaklik

/* 
 * Copyright (C) 2004 Darren Hutchinson (dbh@gbdt.com.au)
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
 * License for more details.
 * 
 * You should have received a copy of the GNU Library General Public License
 * along with this software; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA. 
 *
 * $Id: driver.c,v 1.4 2004/04/04 06:54:05 dbh Exp $
 */

/* This file contains the code that takes the excitation values for each
 * coil (determined by the stepper module) and performs a crude PWM
 * and generates the output values for the stepper drivers.
 *
 * This module has it's own timer at a high frequency timer, so efficiency
 * is an important issue.
 */

#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

#include "eq6.h"
#include "stepper.h"
#include "driver.h"

/* Like the stepper.h module this one is heavily table-driven. Basically
 * each excitation value corresponds to 4, 8 bit lists of values are used
 * for 8 clock cycles. This gives a crude PWM system.
 *
 * The hardware is orginized such that both "ends" of a coil are in
 * adjacent bits, so each pair of 8 bits is interleaved into a single
 * 16 bit word where the bits are used two at a time.
 *
 * Note: The high side and low side tables here were different - basically if
 * a high side was driven for one coil, the low side should be driven for the
 * other.
 *
 * However the low side bits are reversed because of the bit numbers running
 * in the opposite direction for Port A (low side) vs Port C (high side), so
 * it turns out that the same table can be used for both!
 *
 * Of course the bits for the coils are composed in the opposite direction
 * too, but that happens below
 */
uint8_t driveTbl[] =
{
    [EX_M_1] = 0xaa,
    [EX_M_0_67] = 0x2a,
    [EX_M_0_4] = 0x22,
    [EX_M_0_2] = 0x02,
    [EX_0] = 0x00,
    [EX_P_0_2] = 0x01,
    [EX_P_0_4] = 0x11,
    [EX_P_0_67] = 0x15,
    [EX_P_1] = 0x55
};

#define PWM_RATE        48000           /* PWM update speed */
#define PWM_STEPS       4               /* Steps per PWM cycle */

/* driverInit() initializes the port used by the stepper motors and the timer
 * used to update the stepper driver state
 *
 * Passed:
 *      Nothing
 *
 * Returns:
 *      Nothing
 *
 */
void
driverInit(void)
{
    /* Set up port A and C as outputs and set them to a safe default state
     * i.e. no outputs driven
     */
    PORTA = 0x00;               // Disable high-side drivers
    DDRA = 0xff;                // Set as outputs

    PORTC = 0xff;               // Disable low-side drivers
    DDRC = 0xff;                // Set as outputs

    /* Setup the "magic" relay bit as an output */

    MAGIC_PORT &= ~_BV(MAGIC_BIT);
    MAGIC_DDR |= _BV(MAGIC_BIT);

    /* Setup timer 0 to generate interrupts for PWM */
    OCR0 = (CLK_RATE / PWM_RATE / 8);
    TCCR0 = _BV(WGM01) | _BV(CS01);     // Divied by 8, CTC mode

    /* Enable interrupt generation from timer 0 */
    TIMSK |= _BV(OCIE0);
}

/* driverInt() is called whenever a timer 0 overflow interrupt occurs
 *
 * Passed:
 *      Nothing
 *
 * Returns:
 *      Nothing
 */
SIGNAL(SIG_OUTPUT_COMPARE0)
{
    static uint8_t      raCoil1States;
    static uint8_t      raCoil2States;
    
    static uint8_t      decCoil1States;
    static uint8_t      decCoil2States;

    static uint8_t      ctr = PWM_STEPS - 1;

    uint8_t             highSidePort;
    uint8_t             lowSidePort;

// PORTA = ~excitation.ra;
// PORTC = ~excitation.dec;

    /* Increment the step count. Reinitialize the states entries
     * if the counter wraps around
     */
    if (++ctr == PWM_STEPS)
    {
        uint8_t         tmp;

        ctr = 0;

        /* Update states */
        tmp = _GET_C1(raExcitation.excitation);
        raCoil1States = driveTbl[tmp];

        tmp = _GET_C2(raExcitation.excitation);
        raCoil2States = driveTbl[tmp];

        tmp = _GET_C1(decExcitation.excitation);
        decCoil1States = driveTbl[tmp];

        tmp = _GET_C2(decExcitation.excitation);
        decCoil2States = driveTbl[tmp];

        /* Update magic relay state */
        if (raExcitation.useRelay)
            MAGIC_PORT &= ~_BV(MAGIC_BIT);
        else
            MAGIC_PORT |= _BV(MAGIC_BIT);
    }

    /* Build the high_side driver output value */
    highSidePort = decCoil2States & 0x3;
    highSidePort <<= 2;

    highSidePort |= decCoil1States & 0x3;
    highSidePort <<= 2;

    highSidePort |= raCoil2States & 0x3;
    highSidePort <<= 2;

    highSidePort |= raCoil1States & 0x3;

    /* Build the low-side driver states. Note that, due to the
     * reverse pin pordering for Port A vs Port C that these are built in
     * the opposite direction
     */
    lowSidePort = raCoil1States & 0x3;
    lowSidePort <<= 2;
    raCoil1States >>= 2;

    lowSidePort |= raCoil2States & 0x3;
    lowSidePort <<= 2;
    raCoil2States >>= 2;

    lowSidePort |= decCoil1States & 0x3;
    lowSidePort <<= 2;
    decCoil1States >>= 2;

    lowSidePort |= decCoil2States & 0x3;
    decCoil2States >>= 2;

    /* Potential safety check: rev (PortA) & PortC == 0 */

    /* Write the values to the output ports */
    PORTC = highSidePort;
    PORTA = ~lowSidePort;
}