Arduino.ru

Добрый день! Есть код написанный для МК на базе Atmega32. Есть ли возможность прошить Arduino Nano V3 таким же способом? Или надо с нуля код писать?

#include <mega32.h>

#include <delay.h>
#include <math.h>
#include <stdlib.h>

#ifndef RXB8
#define RXB8 1
#endif

#ifndef TXB8
#define TXB8 0
#endif

#ifndef UPE
#define UPE 2
#endif

#ifndef DOR
#define DOR 3
#endif

#ifndef FE
#define FE 4
#endif

#ifndef UDRE
#define UDRE 5
#endif

#ifndef RXC
#define RXC 7
#endif

#define FRAMING_ERROR (1<<FE)
#define PARITY_ERROR (1<<UPE)
#define DATA_OVERRUN (1<<DOR)
#define DATA_REGISTER_EMPTY (1<<UDRE)
#define RX_COMPLETE (1<<RXC)

// Declare your global variables here

int  ae, d, snd, f , sndL, rs0, Ypor;
unsigned char info1, info2, rs1,rs2,rs3,rs4,  ps, pc, sm , smL, Yz;
float avg0, acc , avg1, avg2, sf1, sf2;
int si[50];
long a, a0, Ysi, Yco, Y, Yw, a_si, a_co ,c, c1, sdvc ;

 eeprom int f_eep, sndL_eep, smL_eep, Ypor_eep  ;

// USART Receiver buffer
#define RX_BUFFER_SIZE 16
char rx_buffer[RX_BUFFER_SIZE];

#if RX_BUFFER_SIZE<256
unsigned char rx_wr_index,rx_rd_index,rx_counter;
#else
unsigned int rx_wr_index,rx_rd_index,rx_counter;
#endif

// This flag is set on USART Receiver buffer overflow
bit rx_buffer_overflow;

// USART Receiver interrupt service routine
interrupt [USART_RXC] void usart_rx_isr(void)
{
char status,data;
status=UCSRA;
data=UDR;
if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
   {
   rx_buffer[rx_wr_index]=data;
   if (++rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0;
   if (++rx_counter == RX_BUFFER_SIZE)
      {
      rx_counter=0;
      rx_buffer_overflow=1;
      };
   };
}

#ifndef _DEBUG_TERMINAL_IO_
// Get a character from the USART Receiver buffer
#define _ALTERNATE_GETCHAR_
#pragma used+
char getchar(void)
{
char data;
while (rx_counter==0);
data=rx_buffer[rx_rd_index];
if (++rx_rd_index == RX_BUFFER_SIZE) rx_rd_index=0;
#asm("cli")
--rx_counter;
#asm("sei")
return data;
}
#pragma used-
#endif

// USART Transmitter buffer
#define TX_BUFFER_SIZE 16
char tx_buffer[TX_BUFFER_SIZE];

#if TX_BUFFER_SIZE<256
unsigned char tx_wr_index,tx_rd_index,tx_counter;
#else
unsigned int tx_wr_index,tx_rd_index,tx_counter;
#endif

// USART Transmitter interrupt service routine
interrupt [USART_TXC] void usart_tx_isr(void)
{
if (tx_counter)
   {
   --tx_counter;
   UDR=tx_buffer[tx_rd_index];
   if (++tx_rd_index == TX_BUFFER_SIZE) tx_rd_index=0;
   };
}

#ifndef _DEBUG_TERMINAL_IO_
// Write a character to the USART Transmitter buffer
#define _ALTERNATE_PUTCHAR_
#pragma used+
void putchar(char c)
{
while (tx_counter == TX_BUFFER_SIZE);
#asm("cli")
if (tx_counter || ((UCSRA & DATA_REGISTER_EMPTY)==0))
   {
   tx_buffer[tx_wr_index]=c;
   if (++tx_wr_index == TX_BUFFER_SIZE) tx_wr_index=0;
   ++tx_counter;
   }
else
   UDR=c;
#asm("sei")
}
#pragma used-
#endif

// Standard Input/Output functions
#include <
>


#define FIRST_ADC_INPUT 0
#define LAST_ADC_INPUT 1
unsigned int adc_data[LAST_ADC_INPUT-FIRST_ADC_INPUT+1];
#define ADC_VREF_TYPE 0x40

// ADC interrupt service routine
// with auto input scanning
interrupt [ADC_INT] void adc_isr(void)
{
static unsigned char input_index=0;
// Read the AD conversion result
adc_data[input_index]=ADCW;
// Select next ADC input
if (++input_index > (LAST_ADC_INPUT-FIRST_ADC_INPUT))
   input_index=0;
ADMUX=(FIRST_ADC_INPUT | (ADC_VREF_TYPE & 0xff))+input_index;
// Delay needed for the stabilization of the ADC input voltage
//delay_us(10);
// Start the AD conversion
ADCSRA|=0x40;
}



// Timer1 output compare A interrupt service routine    400 Гц
interrupt [TIM1_COMPA] void timer1_compa_isr(void)
{
// Генератор  400 Гц для передачи данных по RS-232  (используется для контроля обрабатываемых данных)
   
       // стоп таймера 0
       TCCR0=0;
               
       putchar(42);      
       putchar(42);      
     
       
       info1 = Y & 255;
       info2 = Y >> 8;
       
       putchar(info2);        
       putchar(info1);    
            
      info1 = (char) Yz;
      info2 = (char) (f / 5);     //42
      putchar(info2);        
      putchar(info1);   
 
      info1 = snd & 255;
      info2 = snd >> 8;
 
      putchar(info2);        
      putchar(info1);   

      
       TCNT0A=0x00;
       TCCR0A=0x0D;        // старт таймера 0
   
   
   
}





// Timer 0 output compare interrupt service routine
interrupt [TIM0_COMP] void timer0_comp_isr(void)
{
// генератор (14 кГц / 6) = 1600 Гц        между вызовами 9800 тактов
// вызов занимает 1024 такта

    a =  adc_data[0]  << 2 ; // умножение на 4 для перевода сигнала в 0...4096   
     
    a0 = (a0*63 + a+ 63) >> 6;    // усреднение  сход до 10% за 150 отсчётов (t = 0,1 сек)    63 / 64
    ae =  (int)(a - a0);      //  
    a = ae;   // нормализованное значение к среднему (-127...+127)
    ae = abs(ae);   // абсолютное значение как уровень громкости
    if (ae < 32) { //слабый сигнал считается нулём 
      ae = 0;
    };
    
    d = (int)((15 * (long int) d + ae + 15) >> 4);    // усреднённая громкость  сход до 10% за 35 отсчётов    15 / 16
               
    
    if (d > 100)  {   // уровень громкости больше 100 ед.
        if (snd == 0) {  Yz=0;   snd++; } // первый приход громкого сигнала
       PORTB.1 = 1;    // светодиод для контроля
    };
   
 if (snd > 0) {    //есть сигнал
    
    c = ((long int) f *  (long int) (snd)) >> 5;     //  номер отсчёта в графике sin(f) для текущего времени snd  800/24  = 32;   
    
    if ( (c - sdvc) > 48) {sdvc = sdvc+48 ;};
    c1 = c - sdvc;
    ps = (char) c1 ; // номер отсчёта в графике sin
    snd++;   
    sm++;
     
    if (ps > 48) 
    {
     ps = ps - 48;
    };
    
    pc = ps + 12 ;    // номер отсчёта в графике cos (тот же sin, сдвинутый на четверть периода)
    if (pc > 48) 
    {
     pc = pc - 48;
    };    
     // Фурье
    a_si =   (long int) (a * si[ps]) >> 4;
    a_co =  (long int) (a * si[pc]) >> 4;
    Ysi = Ysi + a_si  ;  
    Yco = Yco + a_co;   
    Y = (labs(Ysi) + labs(Yco)) >> 7;      // уровень частотной линии f = сумма модулей и  деление на 128 чтобы не было больших чисел  
    
    if (sm == smL) {    // 1 сэмпл меньше чем sndL
     Ysi = 0;
     Yco = 0;
      if ( (int) Y > Ypor)   //  // уровень частотной линии f  больше порога
      {
         Yz++;  // счётчик превышений уровня
         PORTB.1 = ! PORTB.1; 
      };
     sm=0;
    }
    
    
    if (snd == sndL) {       // 1 секунда
     snd = 0;              // обнуление данных
     sm=0;                 // обнуление данных
     PORTB.1 = 0;    
     Ysi = 0;
     Yco = 0;
     Y = 0;               // обнуление данных
     sdvc=0;
     if ( (int) Yz >= 3)   // // уровень частотной линии f  больше порога > 3 из 5 сэмлов 
     {
       PORTB.2 = ! PORTB.2;   //переключение выхода для реле 
     };
     Yw=0;   
     Yz=0;
     
    
    };   
    
} ;

} ;   // конец таймера



void main(void)
{

  f =  128  ;     // 166 Гц   
 sndL = 675;   //  422 мс
 smL = 135;  // 84,3 мс
 Ypor = 150;    // порог  уровня частотной линии f        
 
    snd = 0; 
    sm=0;
     PORTB.2 = 0;    
     Ysi = 0;
     Yco = 0;
     Y = 0;
     Yw=0;
     
     sdvc=0;

  
// Input/Output Ports initialization
// Port A initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTA=0x00;
DDRA=0x00;

// Port B initialization
// Func7=In Func6=In Func5=In Func4=In Func3=Out Func2=Out Func1=Out Func0=Out 
// State7=T State6=T State5=T State4=T State3=0 State2=0 State1=0 State0=0 
PORTB=0x00;
DDRB=0x0F;

// Port C initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTC=0x00;
DDRC=0x00;

// Port D initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In 
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T 
PORTD=0x00;
DDRD=0x00;



// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 14.399 kHz
// Mode: CTC top=OCR0
// OC0 output: Disconnected
TCCR0=0x0D;
TCNT0=0x00;
OCR0=9; // 1600 Гц



// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: 14.399 kHz
// Mode: CTC top=OCR1A
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: On
// Compare B Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x0D;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=144;      // 100 Hz
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer2 Stopped
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
// INT2: Off
MCUCR=0x00;
MCUCSR=0x00;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIMSK=0x12;

// USART initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART Receiver: On
// USART Transmitter: On
// USART Mode: Asynchronous
// USART Baud Rate: 38400
UCSRA=0x00;
UCSRB=0xD8;
UCSRC=0x86;
UBRRH=0x00;
UBRRL=0x17;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
SFIOR=0x00;

// ADC initialization
// ADC Clock frequency: 115.195 kHz
// ADC Voltage Reference: AVCC pin
ADMUX=FIRST_ADC_INPUT | (ADC_VREF_TYPE & 0xff);
ADCSRA=0xCF;

//создание sin 48


si[0] = 0;
si[1] = 17;
si[2] = 33;
si[3] = 49;
si[4] = 64;
si[5] = 77;
si[6] = 90;
si[7] = 101;
si[8] = 110;
si[9] = 117;
si[10] = 123;
si[11] = 126;
si[12] = 127;
si[13] = 126;
si[14] = 123;
si[15] = 117;
si[16] = 110;
si[17] = 101;
si[18] = 90;
si[19] = 77;
si[20] = 64;
si[21] = 49;
si[22] = 33;
si[23] = 17;
si[24] = 0;
si[25] = -17;
si[26] = -33;
si[27] = -49;
si[28] = -64;
si[29] = -77;
si[30] = -90;
si[31] = -101;
si[32] = -110;
si[33] = -117;
si[34] = -123;
si[35] = -126;
si[36] = -127;
si[37] = -126;
si[38] = -123;
si[39] = -117;
si[40] = -110;
si[41] = -101;
si[42] = -90;
si[43] = -77;
si[44] = -64;
si[45] = -49;
si[46] = -33;
si[47] = -17;
si[48] = 0;
}