Subversion Repositories HomeAutomation

/**

 * CAN Relay.

 *

 *

 * @date    2006-12-17

 * @author  Erik Larsson

 *

 *   ADC=Vin*1024/Vref

 *   Vout=( 10 mV/C )( Temperature C ) + 500 mV

 *

 *  Transmitts: DATA: <temperature low byte> <temperature high byte> <relay status> <failsafe mode>

 *

 *

 */

#define TWO_BUTTON_MODE 0 /* If using two (or just one but nothing more) auxiliary buttons */

/*-----------------------------------------------------------------------------

 * Includes

 *---------------------------------------------------------------------------*/

/* system files */

#include <avr/io.h>

#include <avr/interrupt.h>

#include <stdio.h>

/* lib files */

#include <config.h>

#include <bios.h>

#include <drivers/timer/timebase.h>

//#include <funcdefs.h>

/* defines */

#define RELAY_OFF			0x01

#define RELAY_ON			0x02

#define FAILSAFE_MODE		0x0F

#define FAILSAFE_TRESHOLD	0xFF  /* Degrees when nodeRelay goes into failsafe mode */

#define RELAY_CMD_ON		0x01

#define RELAY_CMD_OFF		0x02

#define RELAY_CMD_TOGGLE	0x03

#define RELAY_CMD_STATUS	0x04

#define RELAY_CMD_RESET		0x05

#define STATUS_SEND_PERIOD	10000UL /* milliseconds */

#define FAILSAFE_SEND_PERIOD	10000UL /* milliseconds */

#define BOUNCE_TIME			10 /* milliseconds */

#define BUTTON1				1

#define BUTTON2				2

#define APP_TYPE    CAN_APPTYPES_RELAY

#define APP_VERSION 0x0001

/*-------------------------------------------------------------------------

 * Global variables

 * -----------------------------------------------------------------------*/

uint8_t relayStatus, failsafe_flag = 0;

uint32_t boardTemperature = 0;

volatile Can_Message_t rxMsg; // Message storage

volatile uint8_t rxMsgFull;   // Synchronization flag

/*----------------------------------------------------------------------------

 * Functions

 * -------------------------------------------------------------------------*/

uint8_t relayOff();

uint8_t relayOn();

void relayFailsafe();

void sendStatus();

void can_receive(Can_Message_t *msg)

{ // CAN callback function

	if (!rxMsgFull) {

		memcpy((void*)&rxMsg, msg, sizeof(rxMsg));

		rxMsgFull = 1;

	}

}

/*----------------------------------------------------------------------------

 * Interrupt routines // FIXME ordna och testa tryckknappar/rotary encoder

 * -------------------------------------------------------------------------*/

#if TWO_BUTTON_MODE

ISR( PCINT2_vect )

{

}

#endif

/*-----------------------------------------------------------------------------

 * Main Program

 *---------------------------------------------------------------------------*/

int main(void) {

	uint32_t timeStamp = Timebase_CurrentTime(), temp = timeStamp;

	adcTemperatureInit();

	// Set up callback for CAN messages

	BIOS_CanCallback = &can_receive;

	sei();

	Timebase_Init();

	Can_Message_t txMsg;

	txMsg.Id = (CAN_NMT_APP_START << CAN_SHIFT_NMT_TYPE) | (NODE_ID << CAN_SHIFT_NMT_SID);

	txMsg.DataLength = 4;

	txMsg.RemoteFlag = 0;

	txMsg.ExtendedFlag = 1;

	txMsg.Data.words[0] = APP_TYPE;

	txMsg.Data.words[1] = APP_VERSION;

	BIOS_CanSend(&txMsg);

	// Turn relay off

	relayStatus = relayOff();

	// Main loop

	while (1) {

		temp = Timebase_CurrentTime();

		if( temp - timeStamp >= STATUS_SEND_PERIOD ){

			timeStamp = temp;

			// Send relay status to CAN

			sendStatus();

		}

		if (rxMsgFull) {

			uint8_t acttype;

			uint16_t servoid;

			if ( ((rxMsg.Id & CAN_MASK_CLASS)>>CAN_SHIFT_CLASS) == CAN_ACT){

				// Actuator package

				acttype =(uint8_t)((rxMsg.Id & CAN_MASK_ACT_FUNCC) >> CAN_SHIFT_ACT_FUNCC);

				servoid = (uint16_t)((rxMsg.Id & CAN_MASK_ACT_NID) >> CAN_SHIFT_ACT_NID);

				if ((acttype == ACT_FUNCC_RELAY) && (servoid == NODE_ID)) {

					// This is a message for this relay

					if (rxMsg.Data.bytes[0] == RELAY_CMD_RESET) {

						// Return to normal operation

						failsafe_flag = 0;

					}

					if (!failsafe_flag) {

						if (rxMsg.Data.bytes[0] == RELAY_CMD_ON ){

							// Turn relay on

							relayStatus = relayOn();

						} else if (rxMsg.Data.bytes[0] == RELAY_CMD_OFF ){

							// Turn relay off

							relayStatus = relayOff();

						} else if (rxMsg.Data.bytes[0] == RELAY_CMD_TOGGLE ){

								// Toggle relay

								if(relayStatus == RELAY_OFF){

									relayStatus = relayOn();

								}else{

									relayStatus = relayOff();

								}

						}else if(rxMsg.Data.bytes[0] == RELAY_CMD_STATUS ){

							// Send relay status to CAN

							sendStatus();

						}

					}

				}

			}

    		rxMsgFull = 0; //  

		}

	}

	return 0;

}

uint8_t relayOff()

{

	// Turn off relay

	PORTC &= ~(1<<PC1);

	DDRC |= (1<<DDC1);

	return RELAY_OFF;

}

uint8_t relayOn()

{

	// Turn on relay

	DDRC &= ~(1<<DDC1);

	PORTC |= (1<<PC1);

	return RELAY_ON;

}

void relayFailsafe()

{

	uint32_t failsafe_timeStamp, temp;

	relayStatus = relayOff();

	failsafe_flag = 1;

	while(1){

		if( !failsafe_flag ){

			// Return from failsafe mode

			return;

		}

// TODO skicka med period

		sendStatus( );

	}

}

void sendStatus()

{

	uint32_t temperature;

	Can_Message_t statusMsg;

	statusMsg.RemoteFlag = 0;

	statusMsg.ExtendedFlag = 1;

	statusMsg.DataLength = 4;

	statusMsg.Id = ( CAN_SNS<<CAN_SHIFT_CLASS )|( SNS_FUNCC_RELAY_STATUS<<CAN_SHIFT_ACT_FUNCC )|( NODE_ID<<CAN_SHIFT_SNS_SID );

	temperature = getTC1047temperature();

	if( (int32_t)temperature >= FAILSAFE_TRESHOLD && !failsafe_flag ){

		// Goto failsafe mode

		relayFailsafe();

	}else{

		// Transmitt node status

		statusMsg.Data.bytes[0] = temperature & 0x00FF;

		statusMsg.Data.bytes[1] = (temperature & 0xFF00)>>8;

		statusMsg.Data.bytes[2] = relayStatus;

		statusMsg.Data.bytes[3] = failsafe_flag;

		BIOS_CanSend( &statusMsg );

	}

}