cnc-club.ru

Код: Выделить всё

/*****************************************************
This program was produced by the
CodeWizardAVR V2.05.3 Standard
Automatic Program Generator
© Copyright 1998-2011 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com

Project : 
Version : 
Date    : 03.02.2014
Author  : Termzon
Company : 
Comments: 


Chip type               : ATmega8
Program type            : Application
AVR Core Clock frequency: 16,000000 MHz
Memory model            : Small
External RAM size       : 0
Data Stack size         : 256
*****************************************************/

#include <mega8.h>

// Alphanumeric LCD functions
#include <alcd.h>
int i=0;
bit sec=0;
bit start=0;
long int t=0;
long int k=0;
long int step=0;
long int stepin=0;
long int rpm=0;
long int rpmin=0;
int p=0;
char lcd_buffer[33]; 


 
// External Interrupt 0 service routine
interrupt [EXT_INT0] void ext_int0_isr(void)
{
step++;
}

// External Interrupt 1 service routine
interrupt [EXT_INT1] void ext_int1_isr(void)
{
stepin++;
}

#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)

// USART Receiver buffer
#define RX_BUFFER_SIZE 12
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_BUFFER_SIZE == 256
   // special case for receiver buffer size=256
   if (++rx_counter == 0) rx_buffer_overflow=1;
#else
   if (rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0;
   if (++rx_counter == RX_BUFFER_SIZE)
      {
      rx_counter=0;
      rx_buffer_overflow=1;
      }
#endif
   }
}

#ifndef _DEBUG_TERMINAL_IO_
#define _ALTERNATE_GETCHAR_
#pragma used+
char getchar(void)
{
char data;
while (rx_counter==0);
data=rx_buffer[rx_rd_index++];
#if RX_BUFFER_SIZE != 256
if (rx_rd_index == RX_BUFFER_SIZE) rx_rd_index=0;
#endif
#asm("cli")
--rx_counter;
#asm("sei")
return data;
}
#pragma used-
#endif
#include <stdio.h>

interrupt [TIM0_OVF] void timer0_ovf_isr(void)
{
TCNT0=0x64;

if (i>4) {
sec=1;
i=0;
    }
else  {
i++;    
    };
}

void main(void)
{
PORTB=0x00;
DDRB=0x02;
PORTD=0x00;
DDRD=0x20;
TCCR0=0x05;
TCNT0=0x64;
TCCR1A=0x82;
TCCR1B=0x1A;
ICR1H=0x9C;
ICR1L=0x3F;
GICR|=0xC0;
MCUCR=0x0A;
GIFR=0xC0;
TIMSK=0x01;
// USART initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART Receiver: On
// USART Transmitter: On
// USART Mode: Asynchronous
// USART Baud Rate: 9600
UCSRA=0x00;
UCSRB=0x98;
UCSRC=0x86;
UBRRH=0x00;
UBRRL=0x67;
ACSR=0x80;
lcd_init(16);
lcd_clear();
// Global enable interrupts
#asm("sei")
 OCR1A=2000;
while (1)
      {

        if (sec==1) { 
                if (rpmin==0) {
                start=0;
                }
                else  {
                start=1;    
                 };

                 
                        
                        rpm=step*44;
                        step=0;
                        sec=0;
                            if (start==1) {
                                        if (rpmin>rpm && OCR1A<4800 ) { 
                                            k=rpmin-rpm;
                                                if (k>7000) {
                                                t=10;
                                                goto outcalc;
                                                };
                                                if (k>5000) {
                                                t=30;
                                                goto outcalc;
                                                };
                                                if (k>4000) {
                                                t=22;
                                                goto outcalc;
                                                };
                                                if (k>3000) {
                                                t=17;
                                                goto outcalc;
                                                };
                                                if (k>2000) {
                                                t=14;
                                                goto outcalc;
                                                };
                                                if (k>1000) {
                                                t=4;
                                                goto outcalc;
                                                };
                                                if (k>300) {
                                                t=1;
                                                goto outcalc;
                                                }
                                                if (k<300) {
                                                t=0;
                                                };
                                        outcalc:
                                        OCR1A=OCR1A+t;
                                        };
                                        
                                        if (rpmin<rpm && OCR1A>2000 ) {
                                        k=rpm-rpmin;
                                                if (k>8000) {
                                                t=15;
                                                goto outcalc1;
                                                };
                                                if (k>3000) {
                                                t=5;
                                                goto outcalc1;
                                                };
                                                if (k>2000) {
                                                t=2;
                                                goto outcalc1;
                                                };
                                                if (k>600) {
                                                t=1;
                                                goto outcalc1;
                                                };
                                                if (k>400) {
                                                t=1;
                                                goto outcalc1;
                                                }
                                                if (k<400) {
                                                t=0;
                                                };
                                        outcalc1:
                                        OCR1A=OCR1A-t;
                                        };
                                        
                            }
                            
                                else  {
                            OCR1A=2000;    
                            };
                             
                       if (p==3) {
                        rpmin=stepin*43.48;
                        stepin=0;
                        sprintf(lcd_buffer,"RPM=%i",rpm); 
                        lcd_clear();             
                        lcd_puts(lcd_buffer);
                        sprintf(lcd_buffer,"RPMIN=%i",rpmin); 
                        lcd_gotoxy(0, 1);      
                        lcd_puts(lcd_buffer);
                        p=0;  
                        }

                       else  {
                       p++;    
                        };
                        
                        

             
        };

      }
}