basic.c

circuit calculation program

#include <stdio.h>
#include <stdlib.h>

#include "component.h"
#include "eq.h"
#include "drive.h"

static int resistor_init (comp_t *comp, void *f);
        /* volatge between pins,return constant item      */
static VA_value_t resistor_U_eq (struct compinfo *comp,int pin1,int pin2,void * ); 
        /* current eqation entering pin                   */
static VA_value_t resistor_I_eq (struct compinfo *comp,int pin, void * ); 

static int capacitor_init (comp_t *comp, void *f);
        /* volatge between pins,return constant item      */
static VA_value_t capacitor_U_eq (struct compinfo *comp,int pin1,int pin2,void * ); 
        /* current eqation entering pin                   */
static VA_value_t capacitor_I_eq (struct compinfo *comp,int pin, void * ); 

static int inductor_init (comp_t *comp, void *f);
        /* volatge between pins,return constant item      */
static VA_value_t inductor_U_eq (struct compinfo *comp,int pin1,int pin2,void * ); 
        /* current eqation entering pin                   */
static VA_value_t inductor_I_eq (struct compinfo *comp,int pin, void * ); 

        /* current eqation entering pin                   */
static VA_value_t basic_I_eq (struct compinfo *comp,int pin, void * ); 
	/* map a digit  named pin                         */
static int basic_pin_gid (struct compinfo *comp,int pin);
	/* enumerate pins belong to a same network        */
static int basic_sibling_first (struct compinfo *comp, int pin );
static int basic_sibling_next (struct compinfo *comp, int pin, int last );

	/* whether voltage eq applicable between two pins    */
static int basic_voltage_eq_ok (struct compinfo *comp, int pin1, int pin2 );

typedef struct resistor_state_def {
	float_t r;
} resistor_state_t;

typedef struct capacitor_state_def {
	float_t c;
	VA_value_t i;	
	VA_value_t Q;  /* U=Q/C */
} capacitor_state_t;

typedef struct inductor_state_def {
	float_t l;
	VA_value_t i;	
} inductor_state_t;

compclass_t resistor  = {"Resistor", resistor_init, NULL,basic_pin_gid, 
		                resistor_U_eq, basic_I_eq, NULL,1,2, sizeof (resistor_state_t),
		                basic_sibling_first, basic_sibling_next,NULL };
compclass_t capacitor = {"Capacitor",capacitor_init,NULL,basic_pin_gid, 
				capacitor_U_eq,basic_I_eq, NULL,1,2, sizeof (capacitor_state_t),
		                basic_sibling_first, basic_sibling_next,NULL };
compclass_t inductor  = {"Inductor", inductor_init, NULL,basic_pin_gid, 
				inductor_U_eq, basic_I_eq, NULL,1,2, sizeof (inductor_state_t),
		                basic_sibling_first, basic_sibling_next,NULL };

///////////////////////////////resisitor/////////////////////////////	
int resistor_init (comp_t *comp, void *f)
{
	((resistor_state_t *)(comp+1))->r = *(float_t *)f ;
	return 1;
}
        /* volatge between pins,return constant item      */
VA_value_t resistor_U_eq (struct compinfo *comp,int pin_gid1,int pin_gid2,void *e )
{
	float_t r = ((resistor_state_t *)(comp+1))->r;
	
	((EQ_item_t *)e)->var_index = comp->vars_start;
	((EQ_item_t *)e)->coef = (pin_gid1 == comp->pins_start) ? r : -r;
	((EQ_item_t *)e)->next = NULL;
	return 0;
}

        /* current eqation entering pin                   */
//VA_value_t resistor_I_eq (struct compinfo *comp,int pin, void *e )
//{
//	((EQ_item_t *)e)->var_index = comp->vars_start;
//	((EQ_item_t *)e)->coef = (pin == comp->pins_start) ? 1 : -1;
//	((EQ_item_t *)e)->next = NULL;	
//	return 0;	
//}

///////////////////////////////capacitor/////////////////////////////
int capacitor_init (comp_t *comp, void *f)
{
	((capacitor_state_t *)(comp+1))->c = *(float_t *)f ;
	((capacitor_state_t *)(comp+1))->i =
	((capacitor_state_t *)(comp+1))->Q = 0;
	return 1;	
}
        /* volatge between pins,return constant item      */
        /* C U = Q,   Q = i * t                           */ 
VA_value_t capacitor_U_eq (struct compinfo *comp,int pin_gid1,int pin_gid2,void *e )
{
	VA_value_t u;
	
	((EQ_item_t *)e)->next = (EQ_item_t *)-1;
			
	u =((capacitor_state_t *)(comp+1))->Q /
	   ((capacitor_state_t *)(comp+1))->c;
	return pin_gid1 = comp->pins_start ? u : -u;
}
        /* current eqation entering pin                   */
//VA_value_t capacitor_I_eq (struct compinfo *comp,int pin, void *e )
//{
//	return 0;
//}
///////////////////////////////inductor/////////////////////////////
int inductor_init (comp_t *comp, void *f)
{
	((inductor_state_t *)(comp+1))->l = *(float_t *)f ;	
	((inductor_state_t *)(comp+1))->i = 0;
	return 1;
}
        /* volatge between pins,return constant item      */
        /* L di/dt = U => LIx/dt - Li/dt = U              */                                  
VA_value_t inductor_U_eq (struct compinfo *comp,int pin_gid1,int pin_gid2,void *e )
{
	VA_value_t u;
	float_t temp = ((inductor_state_t *)(comp+1))->l/delta_time();
	
	((EQ_item_t *)e)->next = (EQ_item_t *)0;
	((EQ_item_t *)e)->coef = (pin_gid1 == comp->pins_start) ? temp : -temp;
	((EQ_item_t *)e)->var_index = comp->vars_start;	
			
	u =((inductor_state_t *)(comp+1))->i * temp;
	return pin_gid1 = comp->pins_start ? -u : u;
}
        /* current eqation entering pin                   */
//VA_value_t inductor_I_eq (struct compinfo *comp,int pin, void *e )
//{
//}
//////////////////////////general/////////////////////////////////
int basic_pin_gid (struct compinfo *comp,int pin)
{ 
	return pin > 1? -1 : comp ? comp->pins_start + pin : -1;
}	

        /* current eqation entering pin                   */
VA_value_t basic_I_eq (struct compinfo *comp,int pin_gid, void *e )
{
	((EQ_item_t *)e)->var_index = comp->vars_start;
	((EQ_item_t *)e)->coef = (pin_gid == comp->pins_start) ? 1 : -1;
	((EQ_item_t *)e)->next = NULL;	
	return 0;	
}

int basic_voltage_eq_ok (struct compinfo *comp, int pin_gid1, int pin_gid2 )
{
	return 1;
}
int basic_sibling_first (struct compinfo *comp, int pin_gid )
{
	int pin = pin_gid - comp->pins_start;
	return comp->pins_start + (pin ^ 1 );  /* 1->0->1 */
}
int basic_sibling_next (struct compinfo *comp, int pin_gid, int last_gid )
{
	return pin_gid;          /* no more */
}