Arduino.ru

#include <LiquidCrystal.h>
#include "EmonLib.h"
LiquidCrystal lcd(PA0, PA1, PA2, PA3, PA4, PA5);
EnergyMonitor emon1;
#define SAMPLES 57
#define DEBOUNCE_DELAY 10
#define DEBOUNCE_IDLE 0
#define DEBOUNCE_ACTIVE 1
#include <libmaple/dma.h>


struct debounce_info
{
  int start, state;
  int16 shift;
} left, right, up, down;


dma_tube_config dma_cfg, dma_cfg2;


int flag1 = 0;
int flag2 = 0;
int out1 = PB7;
int out2 = PA8;
int val1[SAMPLES];
int val2[SAMPLES];
int ampp = PB13;
int ampn = PB15;


int16 shift = 0;


int amp = 35;
int cnt = 0;
int time_track = 0;
float stp = 6.2831 / SAMPLES;
int ret = 17;


timer_dev *dev1 = PIN_MAP[out1].timer_device;
timer_dev *dev2 = PIN_MAP[out2].timer_device;
uint8 cc_channel1 = PIN_MAP[out1].timer_channel;
uint8 cc_channel2 = PIN_MAP[out2].timer_channel;


void fun()
{
  flag1++;
}


void fun2()
{
  flag2++;
}


void timer_conf()
{


  timer_dma_set_base_addr(dev1, TIMER_DMA_BASE_CCR2);
  timer_dma_set_burst_len(dev1, 1);
  timer_dma_enable_req(dev1, cc_channel1);
  timer_set_reload(dev1, 102);
  timer_set_prescaler(dev1, 0);


  timer_dma_set_base_addr(dev2, TIMER_DMA_BASE_CCR1);
  timer_dma_set_burst_len(dev2, 1);
  timer_dma_enable_req(dev2, cc_channel2);
  timer_set_reload(dev2, 102);
  timer_set_prescaler(dev2, 0);
}


void dma_conf()
{


  /* T1C1 DMA C2 */
  dma_cfg.tube_dst = &(dev2->regs.gen->DMAR);
  dma_cfg.tube_dst_size = DMA_SIZE_32BITS;
  dma_cfg.tube_src = val2;
  dma_cfg.tube_src_size = DMA_SIZE_32BITS;


  dma_cfg.tube_nr_xfers = SAMPLES;
  dma_cfg.tube_flags = DMA_CFG_SRC_INC | DMA_CFG_CIRC | DMA_CFG_CMPLT_IE;


  dma_cfg.tube_req_src = DMA_REQ_SRC_TIM1_CH1;
  dma_cfg.target_data = 0;


  ret = dma_tube_cfg(DMA1, DMA_CH2, &dma_cfg);
}


void dma_start()
{
  dma_attach_interrupt(DMA1, DMA_CH4, fun);


  dma_enable(DMA1, DMA_CH4);
  timer_resume(dev1);


  dma_attach_interrupt(DMA1, DMA_CH2, fun2);


  dma_enable(DMA1, DMA_CH2);
  timer_resume(dev2);
}


void init_wave()
{
  int i;
  for (i = 0; i < SAMPLES; i++)
  {
    val1[i] = 50 + amp * sin(stp * i);
    val2[i] = val1[i];
  }
}


void get_wave(int16 shift)
{
  int i;
  for (i = 0; i < SAMPLES; i++)
  {
    val2[i] = 50 + amp * sin( stp * i + shift * 0.1 * 6.2831 / 360);
  }
}


void setup() {
  ////////////
  pinMode(PB9, INPUT_PULLDOWN);
  pinMode(PA7, INPUT);    // Irms
  ////////////
  int i;
  pinMode(out1, PWM);
  pinMode(out2, PWM);
  pinMode(ampp, INPUT_PULLDOWN);
  pinMode(ampn, INPUT_PULLDOWN);


  memset(&up, 0, sizeof(debounce_info));
  memset(&down, 0, sizeof(debounce_info));


  left.shift = -1;
  right.shift = 1;
  up.shift = 1;
  down.shift = -1;


  Serial.begin(9600);
  ///////////////
  lcd.begin(16, 2);
  emon1.current(PA7, 2.8);
  //////////////


  timer_conf();
  dma_conf();
  dma_start();
  init_wave();
  get_wave(shift);


}


void loop() {


  emon1.calcVI(20, 2);
  float Irms = emon1.Irms;


  /////////////
  if (digitalRead(PB9) == HIGH)
  {
    if (Irms > 1.0)
    {
      ampn--;
      //ampp--;
      // amp--;
      delay (100);
    }
    else
    {
      ampn++;
      //ampp++;
      // amp++;
      delay (100);
    }
  }
  //////////////////


  lcd.setCursor(0, 1);
  lcd.print("U=");
  lcd.print(Irms);


  process_key_amp(digitalRead(ampp), &up);
  process_key_amp(digitalRead(ampn), &down);
  delay(100);
}


void process_key_amp(int val, struct debounce_info *k)
{
  switch (k->state)
  {
    case DEBOUNCE_IDLE:
      if (val == HIGH)
      {
        k->state = DEBOUNCE_ACTIVE;
        k->start = millis();
      }
      break;


    case DEBOUNCE_ACTIVE:
      if (val == HIGH)
      {
        if (millis() - k->start > DEBOUNCE_DELAY)
        {
          amp += (int)k->shift;
          get_wave(shift);
        }
      }
      else
        k->state = DEBOUNCE_IDLE;


      break;
  }
}