Easyelectronics.ru

#include <mega328p.h>
#include "indicator_2f.h"

  unsigned char counter_adc=0;
unsigned char flag=0;
  unsigned int adc_data=0;
  unsigned char flag1=0;

void AVR_Init(void)
{
TCCR0A=(0<<COM0A1) | (0<<COM0A0) | (0<<COM0B1) | (0<<COM0B0) | (0<<WGM01) | (0<<WGM00);
TCCR0B=(0<<WGM02) | (1<<CS02) | (0<<CS01) | (1<<CS00);
TCNT0=0;
OCR0A=0x00;
OCR0B=0x00;
// Timer/Counter 0 Interrupt(s) initialization
TIMSK0=(0<<OCIE0B) | (0<<OCIE0A) | (1<<TOIE0);
//ацп
ACSR=(1<<ACD) | (0<<ACBG) | (0<<ACO) | (0<<ACI) | (0<<ACIE) | (0<<ACIC) | (0<<ACIS1) | (0<<ACIS0);
ADMUX=(0<<REFS1) | (0<<REFS0) | (0<<ADLAR) | (0<<MUX3) | (0<<MUX2) | (1<<MUX1) | (1<<MUX0);      //c3
ADCSRA=(1<<ADEN) | (0<<ADSC) | (0<<ADATE) | (0<<ADIF) | (1<<ADIE) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0);
ADCSRB=(0<<ADTS2) | (0<<ADTS1) | (0<<ADTS0);
  }

// ADC interrupt service routine
interrupt [ADC_INT] void adc_isr(void)
{
adc_data=0;
adc_data=ADCW;
ADMUX= (0<<MUX3) | (0<<MUX2) | (1<<MUX1) | (1<<MUX0);
ADCSRA= (1<<ADSC) | (1<<ADEN) | (1<<ADIE);
counter_adc++;
if (counter_adc==254)
{
counter_adc=0;
flag=1;
}
}

interrupt [TIM0_OVF] void timer0_ovf_isr(void)
{
flag1=1; //обновление индикатора
TCNT0=100;
} 


void main(void)
{
#asm("sei")
AVR_Init();
ADCSRA= (1<<ADSC) | (1<<ADEN) | (1<<ADIE);
IND_Init();

while (1)
      { 
     if (flag1){flag1=0; IND_Update();}  //обновление индикатора  ok 
     if (flag)       
     {   
       
        IND_OutUint(adc_data,0); flag=0;   // запись в индикатор  ok
        adc_data=0;
     
        DDRB.1=1;
        PORTB.1 = ~PINB.1; //ок  600гц
     
     } 
}
}

//========================================================================
#include "meter.h"
//========================================================================

//========================================================================
bool adc_complete;

static u08 phase;
static u16 sample;

static u32 phase_a_summ_sqr;
static u32 phase_b_summ_sqr;
static u32 phase_c_summ_sqr;

static bool measure_complete;
//========================================================================

//========================================================================
#pragma vector = TIMER0_COMP_vect
__interrupt void meter_timer_comp (void)
{
   u16 adc = 0;
   u16 temp = 0;

   u32 a = 0;

   METER_OCR += METER_OCR_VAL;

   adc = read_adc (PHASE_Usm);

   temp = adc;

   adc = read_adc (phase);

   if (adc >= temp)
      adc -= temp;
   else
      adc = (temp - adc);

   a = (long) (adc * adc);

   switch (phase)
   {
      case PHASE_A:
         phase_a_summ_sqr += a;
         phase = PHASE_B;
         break;

      case PHASE_B:
         phase_b_summ_sqr += a;
         phase = PHASE_C;
         break;

      case PHASE_C:
         phase_c_summ_sqr += a;
         phase = PHASE_A;

         if (++sample > SAMPLES)
         {
            meter_off ();

            measure_complete = true;
         }
         break;
   }
}
//========================================================================

//========================================================================
#pragma inline = forced
void meter_timer_init (void)
{
   METER_TCNT = 0;
   METER_OCR = METER_OCR_VAL;
   set_bit (METER_TIMSK, METER_OCIE);
   set_bit (SFIOR, PSR10);
   METER_TCCR |= ((1<<METER_CS1) | (1<<METER_CS0));
}
//------------------------------------------------------------------------
#pragma inline = forced
void meter_timer_off (void)
{
   METER_TCCR = 0;
   clr_bit (METER_TIMSK, METER_OCIE);
   METER_TCNT = 0;
   METER_OCR = 0;
}
//========================================================================

//========================================================================
//#pragma inline = forced
u16 read_adc (u08 channel)
{
   ADMUX = ((0<<REFS1) | (0<<REFS0) | (0<<ADLAR) | channel);

   set_bit (ADCSRA, ADSC);

   while (1)
   {
      __enable_interrupt ();

      sleep_mode_enable ();

      if (adc_complete)
      {
         adc_complete = false;
         break;
      }
   }

   return ADC;
}
//========================================================================

//========================================================================
#pragma vector = ADC_vect
__interrupt void adc_interrupt_handler (void)
{
   adc_complete = true;
}
//========================================================================

//========================================================================
void meter_init (void)
{
   phase = PHASE_A;

   phase_a_summ_sqr = 0;
   phase_b_summ_sqr = 0;
   phase_c_summ_sqr = 0;

   sample = 0;

   measure_complete = false;

   meter_timer_init ();
}
//------------------------------------------------------------------------
#pragma inline = forced
void meter_off (void)
{
//   ADCSRA = 0;
//   ADMUX = 0;

   meter_timer_off ();
}
//========================================================================

//========================================================================
static u08 _proc_meter;

void set_proc_meter_on (void)
{
   ACSR = (1<<ACD);

   ADCSRA = ((1<<ADEN) | (0<<ADSC) | (0<<ADATE) | (1<<ADIF) | (1<<ADIE) | (1<<ADPS2) | (0<<ADPS1) | (0<<ADPS0));

   _proc_meter = 1;
}
//------------------------------------------------------------------------
void set_proc_meter_off (void)
{
   meter_off ();

   _proc_meter = 0;
}
//------------------------------------------------------------------------
void proc_meter (void)
{
   switch (_proc_meter)
   {
      case 0:
         break;

      case 1:
         meter_init ();
         _proc_meter = 2;
         break;

      case 2:
         if (get_measure_complete ())
         {
            phase = PHASE_A;
            _proc_meter = 3;
         }
         break;

      case 3:
         switch (phase)
         {
            case PHASE_A:
               set_i_ph_a (calc_adc_result (phase_a_summ_sqr));
               phase = PHASE_B;
               break;

            case PHASE_B:
               set_i_ph_b (calc_adc_result (phase_b_summ_sqr));
               phase = PHASE_C;
               break;

            case PHASE_C:
               set_i_ph_c (calc_adc_result (phase_c_summ_sqr));
               Set_Event (EV_ID_MEASURE_I_ABC_COMPLETE, USER_EVENT);
               _proc_meter = 1;
               break;
         }
         break;
   }
}
//========================================================================

//========================================================================
u32 calc_adc_result (u32 sqr_summ)
{
   float a;
   u16 temp;

   sqr_summ /= sample;

   a = sqrt (sqr_summ);
   temp = (int) a;

   a = (float) a * (V_REF / ADC_RES);

   if (temp <= 50)
      a = (float) a * K_1;
   if (temp > 50 && temp < 100)
      a = (float) a * K_2;
   if (temp >= 100)
      a = (float) a * K_3;

   a = a * 10000;
   return (long) a;
}
//========================================================================

//========================================================================
bool get_measure_complete (void)
{
   if (measure_complete == true)
      {
         measure_complete = false;
         return true;
      }
   else
      return false;
}
//========================================================================