Блок управления для автоматизированной системы проверки межблочного монтажа

Современный пользователь ПЭВМ предъявляет всё более возрастающие требования не только к надёжности, безопасности, но и к экологичности своего рабочего места.

Процесс разработки и использования системы не нанесет какого-либо вреда экологическому состоянию окружающей среды и не требует дополнительных мер по её защите.

9. ЭКОНОМИЧЕСКАЯ ЧАСТЬ

9.1 Ленточный график проведения НИР

Основной целью планирования НИР является определение общей продолжительности их проведения. В этом случае наиболее простым и наглядным будет ленточный график проведения НИР. Он представляет собой таблицу, где перечислены наименования видов работ, должности исполнителей, трудоемкость, численность и длительность выполнения каждого вида работ.

Продолжением таблицы является ленточный график, отображающий зависимость продолжительности каждого вида работ в виде отрезков времени, которые располагаются в соответствии с последовательностью выполнения работ. Продолжительность каждой работы Тп определяется:

где Т - трудоемкость работ, чел./дн.;

r - численность исполнителей, чел.

Таблица 9.1 - Сроки выполнения разработки автоматизированного устройства

В соответствии с полученными данными строим ленточный график. Он отражает продолжительность каждого вида работ в виде отрезков времени.

Рисунок 9.1 - Ленточный график

9.2 Составление сметы затрат на разработку

Цена для НИР рассчитывается по следующей формуле:

,

где НДС - налог на добавленную стоимость,

Пр - прибыль.

Пусть прибыль составит 30%, получим:

,

НДС сейчас составляет 18%, и цена НИР будет рассчитываться по следующей формуле:

9.4 Экономическая эффективность проекта

Понятие эффективности является комплексным. Любой технический прибор имеет ряд особенностей, в том числе таких, как специфика его труда по его созданию, определение цены на него, обоснование затрат на разработку и тому подобные. В большинстве случаев суммарные затраты на разработку прибора и дальнейшее его использование значительны, поэтому требуется тщательный анализ качества и эффективности его использования.

Показатель эффекта определяет все положительные результаты, достигаемые при использовании системы автоматизированного контроля межблочного монтажа. Оценим эффективность разработки данного устройства.

Экономический эффект от использования системы за расчетный период Т определяется по формуле, руб.:

,

где ПТ - стоимостная оценка результатов применения системы в течение периода Т, руб.;

ЗТ -стоимостная оценка затрат на создание (п. 9.2.), руб.

Стоимостная оценка результатов применения системы (ПТ) за расчётный период Т определяется по формуле:

,

где k - количество лет, в течение которых будет эксплуатироваться данная система;

pt - стоимостная оценка результатов года t расчетного периода, руб.;

i - расчётный период;

- дисконтирующая функция, которая вводится для приведения всех затрат и результатов к одному моменту времени;

en - коэффициент дисконтирования (en = 0,2 - нормативный коэффициент эффективности капитальных вложений).

Таким образом

.

Применительно к данному проекту система проверки монтажа заменяет ручной труд, следовательно, набор полезных результатов в основном не меняется. Для оценки итогов применения системы в год берется разница издержек, возникающая в результате её использования, т.е рt = Эу.

Экономия от замены ручного контроля монтажа на автоматизированный образуется за счёт снижения затрат на контроль по формуле, руб.:

,

где ЗР - затраты на ручной контроль монтажа, руб.;

ЗА - затраты на автоматизированный контроль монтажа, руб.

Затраты на ручной контроль монтажа определяются следующим образом:

,

где tР - время ручного контроля одного изделия, час;

Ц - стоимость одного часа работы оператора, руб./час;

ЦЭЛ - стоимость одного часа электроэнергии, руб./час.

На основании всего вышеизложенного можно произвести приближенную оценку эффективности от внедрения данной системы.

.

Стоимость одного часа работы определяется исходя из средней зарплаты рабочего в размере 15000 рублей, 21 рабочего дня в месяц и восьмичасового рабочего дня.

,

Следовательно, затраты на ручной контроль будут равны:

Затраты на автоматизированный контроль рассчитываются по следующей формуле:

,

где tА - время автоматического контроля одного изделия, ч.;

to - время работы оператора во время контроля изделия, ч.

Для данной системы:

Следовательно, затраты на автоматизированный контроль монтажа одного корпуса:

В год контролируется приблизительно 5000 шт. Таким образом, годовая экономия от внедрения системы составит:

Кроме того, если предположить, что система контроля без изменений и доработок будет использоваться в течение пяти лет, тогда стоимостная оценка результатов её применения (экономия) за расчётный период Т = 5 лет составит:

Экономический эффект от использования системы автоматизированного контроля межблочного монтажа за расчётный период Т =5 лет составит:

На основании полученных значений экономических показателей можно сделать вывод, что разработка системы автоматизированного контроля межблочного монтажа является экономически эффективной.

ЗАКЛЮЧЕНИЕ

омметр микроконтроллер электромагнитный поле

Программное обеспечение

#include <mega64.h>

#include <interupt_AKM03.h>

#include <message_PC.h>

#include <function_adc.h>

#include <function_AKM03.h>

//==================================================

void main(void)

{

flag_t0 = 0;

flag_t1 = 0;

init_mc();

setRange5V(1);

rx_counter1 = 0;

//--------------------------------------------------------

// Global enable interrupts

#asm("sei")

//--------------------------------------------------------

while (1)

{

if(rx_counter1 != 0)

{

iter_Processing_massage_PC1();

}

};

}

Interrupt_AKM03.h

//=====================================

#include <mega64.h>

//=====================================

extern char flag_t1;

extern char flag_t0;

extern unsigned int time_t0;

//=====================================

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

//=====================================

// USART1 Receiver buffer

#define RX_BUFFER_SIZE1 16

char rx_buffer1[RX_BUFFER_SIZE1];

#if RX_BUFFER_SIZE1<256

unsigned char rx_wr_index1,rx_rd_index1,rx_counter1;

#else

unsigned int rx_wr_index1,rx_rd_index1,rx_counter1;

#endif

//=====================================

// This is set on USART1 Receiver buffer overflow

bit rx_buffer_overflow1;

// USART1 Receiver interrupt service routine

interrupt [USART1_RXC] void usart1_rx_isr(void)

{

char status,data;

status=UCSR1A;

data=UDR1;

if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)

{

rx_buffer1[rx_wr_index1]=data;

if (++rx_wr_index1 == RX_BUFFER_SIZE1) rx_wr_index1=0;

if (++rx_counter1 == RX_BUFFER_SIZE1)

{

rx_counter1=0;

rx_buffer_overflow1=1;

};

};

}

// Get a character from the USART1 Receiver buffer

#pragma used+

char getchar1(void)

{

char data;

while (rx_counter1==0);

data=rx_buffer1[rx_rd_index1];

if (++rx_rd_index1 == RX_BUFFER_SIZE1) rx_rd_index1=0;

#asm("cli")

--rx_counter1;

#asm("sei")

return data;

}

#pragma used-

//=====================================

// USART1 Transmitter buffer

#define TX_BUFFER_SIZE1 16

char tx_buffer1[TX_BUFFER_SIZE1];

#if TX_BUFFER_SIZE1<256

unsigned char tx_wr_index1,tx_rd_index1,tx_counter1;

#else

unsigned int tx_wr_index1,tx_rd_index1,tx_counter1;

#endif

//=====================================

// USART1 Transmitter interrupt service routine

interrupt [USART1_TXC] void usart1_tx_isr(void)

{

if (tx_counter1)

{

--tx_counter1;

UDR1=tx_buffer1[tx_rd_index1];

if (++tx_rd_index1 == TX_BUFFER_SIZE1) tx_rd_index1=0;

};

}

// Write a character to the USART1 Transmitter buffer

#pragma used+

void putchar1(char c)

{

while (tx_counter1 == TX_BUFFER_SIZE1);

#asm("cli")

if (tx_counter1 || ((UCSR1A & DATA_REGISTER_EMPTY)==0))

{

tx_buffer1[tx_wr_index1]=c;

if (++tx_wr_index1 == TX_BUFFER_SIZE1) tx_wr_index1=0;

++tx_counter1;

}

else

UDR1=c;

#asm("sei")

}

#pragma used-

//=====================================

// Timer1 output compare A interrupt service routine

interrupt [TIM1_COMPA] void timer1_compa_isr(void)

{

TCNT1H=0x00;

TCNT1L=0x00;

flag_t1 = 1;

}

interrupt [TIM0_COMP] void timer0_comp_isr(void)

{

static int count = 0;

TCNT0=0x00;

count++;

if(time_t0 == count)

{

flag_t0 = 1;

count = 0;

}

}

//=====================================

//=====================================

#ifndef _MESSAGE_PC_INCLUDED_

#define _MESSAGE_PC_INCLUDED_

#include <mega64.h>

#include <function_lcd.h>

#include <function_adc.h>

#include <function_AKM03.h>

//=====================================

unsigned int N1;

unsigned int N2;

unsigned int N3;

//=====================================

char iter_Processing_massage_PC1();

//=====================================

char iter_Processing_massage_PC1()

{

char code_command = getchar1();

if(code_command == 0)

{

putchar1(25);

delay_us(40);

}

//============================

else if(code_command == 1)//

{

char DSH1,DSH2,DSH3,DSH4;

float fD;

long unsigned int iD;

unsigned int n,t;

DSH1 = getchar1();

DSH2 = getchar1();

DSH3 = getchar1();

DSH4 = getchar1();

n = getchar1();

n += getchar1()*256;

t = getchar1();

t += getchar1()*256;

//-------------------------

mensMode5V4s();

writeDSH1(DSH1);

writeDSH2(DSH2);

writeDSH3(DSH3);

writeDSH4(DSH4);

//-------------------------

delay_ms(t);

//-------------------------

setRange5V(1);

fD = mens_adc_U5V4s(n,1);

//-------------------------

iD = fD;

//-------------------------

putchar1(iD);

putchar1(iD/256);

putchar1(iD/65536);

putchar1(iD/16777216);

setRange5V(1);

putchar1(1);

}

//============================

else if(code_command == 2)

{

char DSH1,DSH2;

long unsigned int D;

DSH1 = getchar1();

DSH2 = getchar1();

//-------------------------

mensMode5V2s();

if(DSH1 < 200)

{

clrDSH4();

writeDSH1(DSH1);

}

else

{

clrDSH1();

writeDSH4(DSH1 % 200);

}

if(DSH2 < 200)

{

clrDSH3();

writeDSH2(DSH2);

}

else

{

clrDSH2();

writeDSH3(DSH2 % 200);

}

//-------------------------

delay_ms(5);

//-------------------------

D = mens_adc_U5V2s(5,1);

if(D < N1)

D = mens_adc_U5V2s(50,1);

else

{

setRange5V(2);

delay_ms(5);

D = mens_adc_U5V2s(5,2);

if(D < N2)

D = mens_adc_U5V2s(50,2);

else

{

setRange5V(3);

delay_ms(5);

D = mens_adc_U5V2s(50,3);

}

}

//-------------------------

putchar1(D);

putchar1(D/256);

putchar1(D/65536);

putchar1(D/16777216);

putchar1(2);

}

//============================

else if(code_command == 3)//проверка 100В

{

char DSH1,DSH2,range;

float fD;

long unsigned int iD;

unsigned int n,t;

DSH1 = getchar1();

DSH2 = getchar1();

n = getchar1();

n += getchar1()*256;

t = getchar1();

t += getchar1()*256;

range = getchar1();

//-------------------------

mensMode100V();

if(DSH1 < 200)

{

clrDSH4();

writeDSH1(DSH1);

}

else

{

clrDSH1();

writeDSH3(DSH1 - 200);

}

if(DSH2 < 200)

{

clrDSH3();

writeDSH2(DSH2);

}

else

{

clrDSH2();

writeDSH4(DSH2 - 200);

}

//-------------------------

delay_ms(t);

//-------------------------

fD = mens_adc_U100V(n,range);

if(D < N1)

D = mens_adc_U100V(50,1);

else

{

setRange100V(2);

delay_ms(5);

D = mens_adc_U100V(5,2);

if(D < N2)

D = mens_adc_U100V(50,2);

}

}

//-------------------------

iD = fD;

//-------------------------

putchar1(iD);

putchar1(iD/256);

putchar1(iD/65536);

putchar1(iD/16777216);

putchar1(3); }

//============================

else if(code_command == 12)//

{

K13 = 0;

clrK17();//K17 = 0;

K11 = 0;

K12 = 0;

K9 = 0;

K10 = 0;

K1 = 0;

K2 = 0;

K3 = 0;

K4 = 0;

K5 = 0;

K6 = 0;

K7 = 0;

K8 = 0;

clrDSH1();

clrDSH2();

clrDSH3();

clrDSH4();

putchar1(12);

}

//============================

Function_AKM03.h

#include <mega64.h>

#include <delay.h>

//=====================================

#ifndef _FUNCTION_AKM03_INCLUDED_

#define _FUNCTION_AKM03_INCLUDED_

//=====================================

#define DH1 PORTE.2

#define DH2 PORTE.3

#define DH3 PORTE.6

#define DH4 PORTE.7

#define K1 PORTB.0

#define K2 PORTB.2

#define K3 PORTB.3

#define K4 PORTB.4

#define K5 PORTC.0

#define K6 PORTC.1

#define K7 PORTC.2

#define K8 PORTC.3

#define K9 PORTC.4

#define K10 PORTC.5

#define K11 PORTC.6

#define K12 PORTC.7

#define K13 PORTD.0

#define K14 PORTD.1

#define K15 PORTD.4

#define K18 PORTD.5

#define K19 PORTD.6

#define K20 PORTD.7

//#define K16 PORTG.0

//#define K17 PORTG.1

//#define K21 PORTG.2

//#define K22 PORTG.3

//=====================================

// char menu;

char flag_t0;

unsigned int time_t0;

//=====================================

void writeDSH1(char DH);

void writeDSH2(char DH);

void clrDSH1();

void clrDSH2();

void mensMode100V();

void mensMode5V4s();

void mensMode5V2s();

void setRange5V(char N);

void setRange100V(char N);

void setK17();

void clrK17();

void setK16();

void clrK16();

void setK21();

void clrK21();

void setK22();

void clrK22();

void start_timer0();

void stop_timer0();

//=====================================

void writeDSH1(char DH)

{

PORTA = DH;

delay_us(5);

DH1 = 1;

delay_us(1);

DH1 = 0;

}

//------------------------------------------

void writeDSH2(char DH)

{

PORTA = DH;

delay_us(5);

DH2 = 1;

delay_us(1);

DH2 = 0;

}

//------------------------------------------

void writeDSH3(char DH)

{

PORTA = DH;

delay_us(5);

DH3 = 1;

delay_us(1);

DH3 = 0;

}

//------------------------------------------

void writeDSH4(char DH)

{

PORTA = DH;

delay_us(5);

DH4 = 1;

delay_us(1);

DH4 = 0;

}

//------------------------------------------

void clrDSH1()

{

PORTA = 0x80;

delay_us(5);

DH1 = 1;

delay_us(1);

DH1 = 0;

}

//------------------------------------------

void clrDSH2()

{

PORTA = 0x80;

delay_us(5);

DH2 = 1;

delay_us(1);

DH2 = 0;

}

//------------------------------------------

void clrDSH3()

{

PORTA = 0x80;

delay_us(5);

DH3 = 1;

delay_us(1);

DH3 = 0;

}

//------------------------------------------

void clrDSH4()

{

PORTA = 0x80;

delay_us(5);

DH4 = 1;

delay_us(1);

DH4 = 0;

}

//------------------------------------------

void mensMode100V()

{

//отключить режим 5В

clrK17();//K17 = 0;

K9 = 0;

K10 = 0;

K1 = 0;

K2 = 0;

K3 = 0;

K4 = 0;

K5 = 0;

K6 = 0;

clrK21();//K21 = 0;

//----------

K7 = 0;

K8 = 0;

K11 = 0;

K12 = 0;

//----------

clrDSH1();

clrDSH2();

clrDSH3();

clrDSH4();

delay_ms(5);

//----------

//наименьший диапазон сопротивлений

K14 = 1;

K15 = 0;

clrK16();//K16 = 0;

//----------

//включить режим 100В

setK22();//K22 = 1;

delay_ms(5);

K13 = 1;

}

//------------------------------------------

void setRange100V(char N)

{

switch(N)

{

case 1:

K14 = 1;

K15 = 0;

clrK16();//K16 = 0;

break;

case 2:

K15 = 1;

K14 = 0;

clrK16();//K16 = 0;

break;

case 3:

setK16();//K16 = 1;

K14 = 0;

K15 = 0;

break;

}

}

//------------------------------------------

void mensMode5V4s()

{

//отключить режим 100В

K13 = 0;

K12 = 0;

K9 = 0;

K7 = 0;

K8 = 0;

K6 = 0;

K4 = 0;

K3 = 0;

K1 = 0;

clrK22();

//отключение всех точек

clrDSH1();

clrDSH2();

clrDSH3();

clrDSH4();

delay_ms(5);

//----------

//наименьший коэффициент усиления

K18 = 1;

//----------

//включить режим 5В4c

K2 = 1;//подключаем измеритель

K5 = 1;

K10 = 1;//подключаем землю GNDA

setK21();

setK17();//K17 = 1;//подключаем источник тока к +St

K11 = 1;//подключаем +St к линии L1

delay_ms(5);

}

//------------------------------------------

void setRange5V(char N)

{

switch(N)

{

case 1:

K18 = 1;

K19 = 0;

K20 = 0;

break;

case 2:

K19 = 1;

K18 = 0;

K20 = 0;

break;

}

}

//------------------------------------------

void setK16()

{

PORTG |= 0b00000001;

}

void clrK16()

{

PORTG &= 0b11111110;

}

//------------------------------------------

void setK17()

{

PORTG |= 0b00000010;

}

void clrK17()

{

PORTG &= 0b11111101;

}

//------------------------------------------

void setK21()

{

PORTF |= 0b00000010;

}

void clrK21()

{

PORTF &= 0b11111101;

}

//------------------------------------------

void setK22()

{

PORTF |= 0b00000001;

}

void clrK22()

{

PORTF &= 0b11111110;

}

//------------------------------------------

void start_timer0()

{

flag_t0 = 0;

TCCR0=0x07;

}

//------------------------------------------

void stop_timer0()

{

TCCR0=0x00;

flag_t0 = 0;

}

//------------------------------------------

void meandr()

{

static char flag = 0;

flag++;

if(flag & 0b00000001)

{

setK17();

//flag = 0;

}

else

{

clrK17();

//flag = 1;

}

}

//------------------------------------------

//------------------------------------------

void init_mc()

{

//--------------------------------------------------------

// Input/Output Ports initialization

// Port A initialization

PORTA=0x00;

DDRA=0xFF;

//--------------------------------------------------------

// Port B initialization

PORTB=0b00000000;

DDRB =0b10111101;

//--------------------------------------------------------

// Port C initialization

PORTC=0b00000000;

DDRC=0xFF;

//--------------------------------------------------------

// Port D initialization

PORTD=0b00000000;

DDRD =0b11110011;

//--------------------------------------------------------

// Port E initialization

PORTE=0b00000000;

DDRE=0b11111100;

//--------------------------------------------------------

// Port F initialization

PORTF=0x00;

DDRF=0xFF;

//--------------------------------------------------------

// Port G initialization

PORTG=0b00000000;

DDRG =0b00011111;

//--------------------------------------------------------

// Timer/Counter 0 initialization

//ASSR=0x00;

TCCR0=0x00;

//TCNT0=0x00;

//OCR0=0x00;

ASSR=0x00;

//TCCR0=0x07;

TCNT0=0x00;

OCR0=0x6C;

//--------------------------------------------------------

// Timer/Counter 1 initialization

TCCR1A=0x00;

TCCR1B=0x01;

TCNT1H=0x00;

TCNT1L=0x00;

ICR1H=0x00;

ICR1L=0x00;

OCR1AH=0x15;

OCR1AL=0x99;

OCR1BH=0x00;

OCR1BL=0x00;

OCR1CH=0x00;

OCR1CL=0x00;

//--------------------------------------------------------

// Timer/Counter 2 initialization

TCCR2=0x00;

TCNT2=0x00;

OCR2=0x00;

//--------------------------------------------------------

// Timer/Counter 3 initialization

TCCR3A=0x00;

TCCR3B=0x00;

TCNT3H=0x00;

TCNT3L=0x00;

ICR3H=0x00;

ICR3L=0x00;

OCR3AH=0x00;

OCR3AL=0x00;

OCR3BH=0x00;

OCR3BL=0x00;

OCR3CH=0x00;

OCR3CL=0x00;

//--------------------------------------------------------

// External Interrupt(s) initialization

EICRA=0x00;

EICRB=0x00;

EIMSK=0x00;

//--------------------------------------------------------

// Timer(s)/Counter(s) Interrupt(s) initialization

TIMSK=0x12;

ETIMSK=0x00;

//--------------------------------------------------------

// USART1 initialization

//UCSR1A=0x00;

//UCSR1B=0xD8;

//UCSR1C=0x06;

//UBRR1H=0x00;

//UBRR1L=0x47;

UCSR1A=0x00;

UCSR1B=0xD8;

UCSR1C=0x06;

UBRR1H=0x00;

UBRR1L=0x05;

//--------------------------------------------------------

// Analog Comparator initialization

ACSR=0x80;

SFIOR=0x00;

}

//------------------------------------------

//=====================================

#endif

//=====================================

Function_adc.h

include <delay.h>

//#include <math.h>

//=====================================

#ifndef _FUNCTION_ADC_INCLUDED_

#define _FUNCTION_ADC_INCLUDED_

#include <mega64.h>

//=====================================

#define CS PORTB.5

#define SDATA PINB.6

#define SCLK PORTB.7

char flag_t1;

//=====================================

float mens_adc_U100V(unsigned int N,char Range);

float mens_adc_U5V4s(unsigned int N,char Range);

long unsigned int mens_adc_U5V2s(unsigned int N,char Range);

unsigned int adc(void);

float adcN(unsigned int N);

//void watch_bit_iter_timer3(void);

//=====================================

unsigned int adc(void)

{

unsigned int U = 0;

unsigned char i;

CS = 0;

for(i = 0; i < 16; ++i)

{

U <<= 1;

SCLK = 0;

//delay_us(1);

SCLK = 1;

if(SDATA)

{

++U;

}

//delay_us(1);

}

U >>= 1;

CS = 1;

return U;

}

//=====================================

float adcN(unsigned int N)

{

unsigned int i;

float D = 0;

for(i = 0; i < N; ++i)

{

D += adc();

}

D /= N;

return D;

}

//--------------------------------------------------

float mens_adc_U100V(unsigned int N, char Range)

{

float Rizm,R;

unsigned int Rogr = 100;

//----------------------------------------------------

D = adcN(N);

//----------------------------------------------------

switch(Range)

{

case 1:

Rizm = 4;

break;

case 2:

Rizm = 50;

break;

}

D = (Rizm*6553200)/D - 10*(Rogr + Rizm);//0.1 кОм

//----------------------------------------------------

return D;

}

//--------------------------------------------------

long unsigned int mens_adc_U5V2s(unsigned int N,char Range)

{

unsigned int i, ky;

long unsigned int D = 0,R;

for(i = 0; i < N; ++i)

{

D += adc();

}

D /= N;

//D -= Dk;

//D = (5000*D/ky)*100/16383;// 10 мОм

switch(Range)

{

case 1:

ky = 1;//25

break;

case 2:

ky = 40;//1000

break;

}

D = ((200000/ky)*D)/16383;// 0.1 мОм

//----------------------------------------------------

return D;

}

//--------------------------------------------------

float mens_adc_U5V4s(unsigned int N,char Range)

{

unsigned int i, ky;

float D = 0,R,SS;

for(i = 0; i < N; ++i)

{

//while( == 0);

D += adc();

// = 0;

}

D /= N;

switch(Range)

{

case 1:

ky = 25;//25

D = ((5000000*D)/ky)/16383;// 0.1 мОм

break;

case 2:

ky = 8;//1000

D = ((50000000*D)/ky)/16383;// 0.0001 мОм

break;

case 3:

//ky = 2000;//50000

break;

}

//----------------------------------------------------

return D;

}

float mens_adc_U_N4s(unsigned int N)

{

unsigned int i, ky;

float D = 0;

for(i = 0; i < N; ++i)

D += adc();

D /= N;

return D;

}

//=====================================

#endif

//=====================================

Размещено на Allbest.ru