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: sr.c,v 1.4 2004/04/04 10:32:50 dbh Exp $
 */

/* This file contains the code to save and restore the "configurable
 * parameters" of the program. These are held in the internal EEPROM
 *
 * These functions are expected to be executed with interrupts enabled and
 * will not return until complete.
 */

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

#include "stepper.h"
#include "paddle.h"

/* Define the staging structure used to save configurable parameters */
struct sr_s
{
    uint8_t     raFinPos;
    uint8_t     raFinNeg;
    uint16_t    raBacklash;

    uint8_t     decFinPos;
    uint8_t     decFinNeg;
    uint16_t    decBacklash;

    uint8_t     paddleGuideRate;

    int8_t      trackingRate;
    uint8_t     transRatio;

    uint8_t     csum;   // Two's complement of other fields
};

volatile uint8_t        doSave;

/* srSaveState() collects the configurable parameters from all over the
 * system and saves them into the EEPROM
 *
 * Passed
 *      Nothing
 *
 * Returns
 *      Nothing
 *
 * Notes:
 *      This function assumes that the interrupts are enabled on
 *      entry.
 */
void
srSaveState(void)
{
    struct sr_s         state;
    uint8_t             i;
    uint8_t             *p;

    /* Turn off the interrupts while we "snapshot" the current
     * state
     */
    cli();

    /* Copy the current state */
    state.raFinPos = raState.finPos;
    state.raFinNeg = raState.finNeg;
    state.raBacklash = raState.backlash;

    state.decFinPos = decState.finPos;
    state.decFinNeg = decState.finNeg;
    state.decBacklash = decState.backlash;

    state.paddleGuideRate = paddleGuideRate;
    state.trackingRate = trackingRate;
    state.transRatio = transRatio;

    /* Reenable interrupts */
    sei();

    /* Calculate the checksum of the structure */
    for (p = (uint8_t *)&state, i = 0 ; p != (uint8_t *)&state.csum ; )
         i += *p++;
    state.csum = i;

    /* Write the complete structure into the EEPROM */
    for (i = 0, p = (uint8_t *)&state ; i < sizeof(state) ; ++i, ++p)
    {
        /* Wait for EEWE to become zero (ie. EEPROM not writting) */
        while (EECR & _BV(EEWE))
            ;
        
        /* Setup the address */
        EEARH = 0;
        EEARL = i;
        
        /* Put the data in place */
        EEDR = *p;

        /* Perform the write */
        cli();
        EECR = _BV(EEMWE);
        EECR = _BV(EEMWE) | _BV(EEWE);
        sei();
    }

    /* All done */
}

/* srLoadState() reads the configurable parameters from EEPROM and copies
 * them to where they need to do.
 *
 * The data is protected by a checksum calculated when the data was
 * saved.
 *
 * Passed
 *      Nothing
 *
 * Returns
 *      Nothing
 *
 * Notes:
 *      This interrupt does not change the interrupt state and does
 *      not return until all the data is read
 */
void
srLoadState(void)
{
    struct sr_s         state;
    uint8_t             i;
    uint8_t             *p;

    /* Read the state data from the EEPROM */
    for (i = 0, p = (uint8_t *)&state ; i < sizeof(state) ; ++i, ++p)
    {
        /* Wait for EEWE to become zero (ie. EEPROM not writting) */
        while (EECR & _BV(EEWE))
            ;
        
        /* Setup the address */
        EEARH = 0;
        EEARL = i;

        /* Read the data. The device will stall until the data is
         * ready
         */
        EECR = _BV(EERE);

        /* Get the data */
        *p = EEDR;
    }

    /* Calculate the checksum of the structure. If it doesn't
     * match then the data is either corrupt or not initialized
     *
     * Either way keep the current data
     */
    for (p = (uint8_t *)&state, i = 0 ; p != (uint8_t *)&state.csum ; )
         i += *p++;
    if (state.csum != i)
        return;
    
    /* Copy the restored data to the current state */
    raState.finPos = state.raFinPos;
    raState.finNeg = state.raFinNeg;
    raState.backlash = state.raBacklash;

    decState.finPos = state.decFinPos;
    decState.finNeg = state.decFinNeg;
    decState.backlash = state.decBacklash;
    
    paddleGuideRate = state.paddleGuideRate;
    trackingRate = state.trackingRate;
    transRatio = state.transRatio;

    /* All done */
}