Утилизация твердых отходов

Разработанный проект предусматривает применение вычислительных устройств. Данные устройства предусматривают в среднем 6 лет работы, после чего списываются. Применяемые в работе ЭВМ состоят, как правило, из трех основных материалов: пластик, металл и стекло. Наиболее утилизируемым считается металл.

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

 

,

 

где – масса утилизируемых (подлежащих вторичной переработке) деталей и узлов;

– общая масса установки.

 

 

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

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

 

,

 

где – масса бумаги используемой при одной заправке картриджа;

– масса заправленного картриджа.


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

Вывод

 

Из всех выше перечисленных факторов наибольшее влияние на окружающую среду при работе компьютера оказывают твердые отходы, так как компьютеры подлежат повторной переработке лишь на 37%. Меньшее влияние оказывают тепловые и электромагнитные излучения, так как компенсируются конструктивными элементами здания, а загрязнение атмосферы и гидросферы отсутствуют.


Заключение

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

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

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

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

Данный проект соответствует экологическим нормам и его влияние на окружающую среду незначительно.

Результаты данной дипломной работы явились составной частью научного проекта «Разработка алгоритмического и программного обеспечения задач управления манипуляционными роботами в среде с неизвестными препятствиями» (Грант Российского фонда фундаментальных исследований №05-08-01199-а, руководитель проекта доцент кафедры ИВТ Лопатин П.К.).


Список литературы

1. Безопасность жизнедеятельности. Безопасность технологических процессов и производств (Охрана труда): Учебное пособие для студентов вузов / Лапин В. Л., Пономарев Н. Л., Кукин П. П. и др.. – 2-е издание, исправленное и дополненное. – М.: Высшая школа, 2001. – 319с.

2. Васильев П. П. Безопасность жизнедеятельности. Экология и охрана труда. Количественная оценка и примеры: Учебное пособие для студентов вузов. – М.: ЮНИТИ-ДАНА, 2003.- 188с.

3. Зенкевич С.Л., Ющенко А.С. (2000) Управление роботами. Основы управления манипуляционными роботами: учеб. для вузов. – М: Изд-во МГТУ, 2000.

4. Зенкевич С.Л. (2004) Основы управления манипуляционными роботами [Текст]: учебник / В.Л. Зенкевич, А.С. Ющенко. - 2-е изд., исп. и доп. – М: Изд-во МГТУ, 2004.- 480с: ил (Робототехника).

5. Ильин В.А. Интеллектуальные роботы. Теория и алгоритмы.- Красноярск: САА 1995.-334с.

6. Ильин В.А., Лопатин П.К. Манипуляционные роботы: Кинематика. Динамика. Управление. / В.А. Ильин, П.К. Лопатин.- Красноярск: СибГАУ, 2002.-124с. (ИВТ).

7. Лопатин П.К. Применение точного и упрощенного алгоритмов к задаче управления двухзвенным манипулятором в среде с неизвестными статическими препятствиями. Информатика и процессы управления. — Красноярск. КГТУ. 2004 (в печати).

8. Накано Э. Введение в робототехнику: Пер. с япон. – М.: Мир,1988. – 334 с., ил.

9. Нильсон Н. Д. Искусственный интеллект. Методы поиска решений.- М.: Мир, 1973.

10. Barraquand J., Latombe J.-C. Robot Motion Planning: A Distributed Representation Approach // Int. J. of Rob. Res., Vol. 10, No. 6, December 1991. — Pp. 628–649.

11. S.M.LaValle, “Planning Algorithms, 1999-2003”. – http://msl.cs.uiuc.edu/planning.

12. Lopatin Р. К. Algorithm of a manipulator movement amidst unknown obstacles. Proceedings of the 10th International Conference on Advanced Robotics (ICAR 2001), August 22-25, 2001, Hotel Mercure Buda, Budapest, Hungary. pp. 327-331.

13. N.J.Nilsson, “Problem-Solving Methods in Artificial Intelligence”. McGraw-Hill Book Company, New York, 1971.

 

14.


Приложения

Приложение 1

 

Приведенный ниже алгоритм принадлежит научному руководителю Лопатину П.К.

Разработано программное обеспечение (ПО) на основе точного алгоритма. Рассмотрим рабочую сцену (рис. 1). Необходимо передвинуть плоский двухзвенный манипулятор из стартовой конфигурации q0=(1.57;0.8)(радиан) в целевую конфигурацию qT=(3.2;0.8)(радиан). Манипулятор движется в плоскости xOy. Длина каждого звена составляет 60 пикселов. В рабочей зоне имеется три прямоугольных препятствия: O1, O2 и O3. Координаты начал систем координат, привязанных к препятствиям, равны следующим величинам в базовой системе координат:

1) первое препятствие:

(1)

 

2) второе препятствие:

(2)

 

 

3) третье препятствие:

(3)

 

 

Координаты точки 2 каждого из препятствий определены в системе координат, привязанной к препятствию, и в каждой из таких систем равны:

 

(1.1.3)

(4)

 

 

Гиперпараллелепипед для данного случая предстает в виде (в радианах).

(5)

 

 

Рис. 1 Декартовая система координат. Препятствия О123. Стартовая конфигурация q0=(1.57;0.8)(радиан), целевая конфигурация qT=(3.2;0.8)(радиан).

 

Задача управления манипуляторами в неизвестной среде сводится к решению конечного числа задач планирования траектории манипулятора в среде с известными препятствиями. В качестве алгоритма для решения задачи планирования траектории в среде с известными препятствиями выбран алгоритм полного перебора. Поскольку этот алгоритм может быть применен только для дискретизированного пространства конфигураций, введем дискретизацию. Величина delta дискрета по каждой обобщенной координате qi, i=1,2, вычисляется следующим образом:

 

delta = (0+6.28)/количество дискретов (6)

 

 

то есть мы суммируем минимальную и максимальную величины по i-той обобщенной координате и делим результат на количество дискретов, лежащих между минимальной и максимальной величинами по i-той (i=1,2) обобщенной координате. Время работы точного алгоритма для различных delta приведено в (табл. 1).

Таблица 1

 

delta, Количество дискретов Время, секунд
4.5
1.5

 

Программное обеспечение написано с использованием Microsoft Visual C++ 6.0 и тестировалось на процессоре Intel Pentium Celeron 1.3 GHz. Как можно видеть, цель достигалась во всех случаях, но использование алгоритма полного перебора ведет к существенным временным затратам с уменьшением delta.


Приложение 2

Код программы реализующей модифицированный алгоритм движения манипулятора в среде с известными препятствиями.

 

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

/*

* Файл Finish_optimized.cpp реализует функцию алгоритма нахождения пути

* от стартовой до целовой конфигурации манипулятора движущегося

* в среде с известными препятствиями.

*

* Входные данные: q0 - стартовая конфигурация

* qT - целевая конфигурация

* mZap[] - массив запрещенных точек

* z - количество запрещенных точек

* border - количество точек границы

* delta - шаг дискретизации

* qL и qH - предельные конфигурации

*

*

* Выходные данные: mRez[] - массив точек конфигураций искомого пути

* n - количество точек конфигураций искомого пути

*/

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

 

#include<iostream.h>

#include <except.h>

#include<stdlib.h>

#include<math.h>

#define NUM 2000

#include<systdate.h>

 

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

// Функция для определения времени работы программы в мсек.

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

 

Word MillisecondsBetween (TDateTime a,TDateTime b)

{

Word A1,B1,C1,D1,E1;

Word A2,B2,C2,D2,E2;

 

DecodeTime(a,A2,B2,C2,D2);

DecodeTime(b,A1,B1,C1,D1);

 

E1=D1+C1*1000+B1*60*1000+A1*60*60*1000;

E2=D2+C2*1000+B2*60*1000+A2*60*60*1000;

 

return E2-E1;

}

TDateTime T1,T2;

 

class point

{

public:

int x;

int y;

 

public:

 

float Distance(point a,point b) ;

 

float Normal(point t1,point t2,point t);

 

point Best_point(point qi,point qT,int delta);

 

void Liberation(point **data, int m);

 

void Route(point q0,point qT,

point mZap[],int z,int border,

point *mRez,int &n,

int delta,

point qL,point qH,Word Time);

 

};

 

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

// Функция вычисления расстояния между лвумя точками

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

 

float point :: Distance(point a,point b)

{

return sqrt(pow(b.x-a.x,2)+pow(b.y-a.y,2));

}

 

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

// Функция вычисления расстояния от точки до прямой

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

 

float point :: Normal(point t1,point t2,point t)

{ // t1 - первая точка прямой

// t2 - вторая точка прямой

int A = t2.y - t1.y; // t - точка

int B = t1.x - t2.x;

int C = -t1.x*A - t1.y*B; // коэффициенты прямой Ax+By+C=0

float M = 1/sqrt(pow(A,2)+pow(B,2));

 

(C <= 0) ? M:-M;

 

return A*M*t.x + B*M*t.y + C*M;

}

 

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

// Функция определяет наиболее выгодную точку из окрестных

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

 

point point :: Best_point(point qi,point qT,int delta)

{

point best; // best - вспомогательная переменная

 

float p=0; // p - расстояние от точки до прямой

float d=0; // d - расстояние между двумя точками

float sum=NUM; // sum = p + d

 

point neighbor[8]; // координаты точек окрестности

 

neighbor[0].x = qi.x - delta; // [0] [1] [2]

neighbor[0].y = qi.y + delta;

// [3] qi [4]

neighbor[1].x = qi.x;

neighbor[1].y = qi.y + delta; // [5] [6] [7]

 

neighbor[2].x = qi.x + delta;

neighbor[2].y = qi.y + delta;

 

neighbor[3].x = qi.x - delta;

neighbor[3].y = qi.y;

 

neighbor[4].x = qi.x + delta;

neighbor[4].y = qi.y;

 

neighbor[5].x = qi.x - delta;

neighbor[5].y = qi.y - delta;

 

neighbor[6].x = qi.x;

neighbor[6].y = qi.y - delta;

 

neighbor[7].x = qi.x + delta;

neighbor[7].y = qi.y - delta;

for (int i=0;i<8;i++)

{

d=Distance(neighbor[i],qT); // d всегда > 0

p=Normal(qi,qT,neighbor[i]); // p и > и < 0

 

 

if (fabs(p)+d < sum)

{

best = neighbor[i];

sum = fabs(p)+d;

}

}

 

return best;

}

 

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

// Функция освобождения динамической памяти

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

 

void point :: Liberation (point **data, int e)

{

for (int i = 0; i < e; i++)

delete[] data[i];

 

delete[] data;

}

 

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

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

// функция генерирования траектории

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

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

 

void point :: Route(point q0, point qT, point mZap[], int z, int border,

point *mRez, int &n, int delta, point qL, point qH,Word Time)

{

T1=Now();

 

int i=0; // переменные для циклов for

int j=0;

int k=0;

int v=0;

int u=0;

int r=0;

 

// int f=0;

// int g=0;

// int w=0;

 

bool flag = false;

bool Flag = false;

 

n=0;

 

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

// 1. Плучаем массив предворительного маршрута mPr[]

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

 

point qi;

qi=q0;

 

int s=1; // s - количество элементов предворительного маршрута

 

point *mPr;

mPr = new point [(int)Distance(q0,qT)+10];

if(mPr == NULL)

{

cout << "Динамический массив не создан";

exit(7);

}

 

mPr[0]=q0; // mPr[] - массив предворительного маршрута

 

while (qi.x != qT.x || qi.y != qT.y) // Цикл будет выполняться пока текущая

{ // точка не совпадет с целевой

qi=Best_point(qi,qT,delta);

mPr[s++] = qi;

}

 

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

// 2. Точки прямого пути проверяются на запрещенность

// и формируется массив запрещенных точек

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

 

int temp=0;

int a=0; // a - количество запрещенных областей

int aa=0; // если a != aa, то решение будет неверным

 

point mTemp[30]; // mTemp[] - помогает формировать mCol[] и mEnd[]

point mCol[30]; // mCol[] - первая точка запрещенной области

point mEnd[30]; // mEndE[] - разрешенная точка после запрещенной области

 

for (i=1;i<s;i++)

for (j=border;j<z;j++)

if (mPr[i].x == mZap[j].x && mPr[i].y == mZap[j].y )

mTemp[temp++]=mPr[i];

 

for (i=1;i<s;i++)

for (j=0;j<temp;j++)

{

 

if(mPr[i].x == mTemp[j].x && mPr[i].y == mTemp[j].y &&

(mPr[i-1].x != mTemp[j-1].x || mPr[i-1].y != mTemp[j-1].y))

 

mCol[a++] = mPr[i];

 

if(mPr[i].x == mTemp[j].x && mPr[i].y == mTemp[j].y &&

(mPr[i+1].x != mTemp[j+1].x || mPr[i+1].y != mTemp[j+1].y))

 

mEnd[aa++] = mPr[i+1];

}

 

if (a != 0)

{

 

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

// 3. Формирование массивов областей запрещенных точек

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

 

point qj; // qj - запрещенная точка

 

point **zap; // zap[i][j] - массивы точек запрещенных областей

// i - номер области

zap = new point* [a]; // j - элемент области

 

if(zap == NULL)

{

cout << "Динамический массив не создан";

exit(1);

}

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

{

zap[i] = new point[(z - border)*2]; // *2 не обязательно

 

if(zap[i] == NULL)

{

cout << "Динамический массив не создан";

exit(2);

}

}

 

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

{

zap[i][0] = mCol[i];

}

 

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

 

int b=1; // b - количество запрещенных точек области

 

int *B; // B[i] - количество запрещенных точек

B = new int [(z - border)*2]; // в i - той области

if(B == NULL)

{

cout << "Динамический массив не создан";

exit(6);

}

 

point neighborZap[8]; // окрестные (запрещенные) точки

 

flag = false;

 

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

{

for (v=0;v<b;v++)

{

qj = zap[i][v];

 

neighborZap[0].x = qj.x - delta; // [0] [1] [2]

neighborZap[0].y = qj.y + delta;

// [3] qj [4]

neighborZap[1].x = qj.x;

neighborZap[1].y = qj.y + delta; // [5] [6] [7]

 

neighborZap[2].x = qj.x + delta;

neighborZap[2].y = qj.y + delta;

 

neighborZap[3].x = qj.x - delta;

neighborZap[3].y = qj.y;

 

neighborZap[4].x = qj.x + delta;

neighborZap[4].y = qj.y;

 

neighborZap[5].x = qj.x - delta;

neighborZap[5].y = qj.y - delta;

 

neighborZap[6].x = qj.x;

neighborZap[6].y = qj.y - delta;

 

neighborZap[7].x = qj.x + delta;

neighborZap[7].y = qj.y - delta;

 

for (j=0;j<8;j++)

for (k=border;k<z;k++)

{

if (neighborZap[j].x == mZap[k].x && neighborZap[j].y == mZap[k].y )

{

for (u=0;u<b;u++)

if (mZap[k].x == zap[i][u].x && mZap[k].y == zap[i][u].y)

{

flag = true;

break;

}

 

if (flag == false)

zap[i][b++]=mZap[k];

 

flag = false;

}

 

}

}

B[i]=b;

}

 

// На случай, если препятствие имеет сложную структуру

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

 

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

for (j=0;j<B[i];j++)

for (k=i+1;k<a;k++)

if (zap[i][j].x == mCol[k].x && zap[i][j].y == mCol[k].y)

{

mEnd[i]=mEnd[k];

}

 

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

// 4. Каждую точку массивов областей запрещенных точек охватываем

// разрешенными

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

 

point **raz;

 

raz = new point* [a];

 

if(raz == NULL)

{

cout << "Динамический массив не создан";

exit(3);

}

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

{

raz[i] = new point [(z - border)*4];

 

if(raz[i] == NULL)

{

cout << "Динамический массив не создан";

exit(4);

}

}

 

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

{

raz[i][0] = mEnd[i];

}

 

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

 

int c=1; // c - количество разрешенных точек области

 

int *C; // C[i] - количество разрешенных точек

C = new int [(z - border)*4]; // в i - той области

if(C == NULL)

{

cout << "Динамический массив не создан";

exit(5);

}

point qk;

 

flag = false;

 

point neighborRaz[4];

 

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

{

 

for (j=0;j<B[i];j++)

{

qk = zap[i][j];

 

neighborRaz[0].x = qk.x; // ... [0] ...

neighborRaz[0].y = qk.y + delta;

// [1] qk [2]

neighborRaz[1].x = qk.x - delta;

neighborRaz[1].y = qk.y; // ... [3] ...

 

neighborRaz[2].x = qk.x + delta;

neighborRaz[2].y = qk.y;

 

neighborRaz[3].x = qk.x;

neighborRaz[3].y = qk.y - delta;

 

for (k=0;k<4;k++)

{

for (v=0;v<z;v++)

if (neighborRaz[k].x == mZap[v].x && neighborRaz[k].y == mZap[v].y)

{

flag = true;

break;

}

 

for (u=0;u<c;u++)

if (raz[i][u].x == neighborRaz[k].x && raz[i][u].y == neighborRaz[k].y)

{

flag = true;

break;

}

 

if (flag == false)

raz[i][c++]=neighborRaz[k];

 

flag = false;

 

}

}

C[i]=c;

}

 

// Последняя точка находится так

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

 

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

for (j=0;j<B[i];j++)

{

if (raz[i][j].x == qT.x && raz[i][j].y == qT.y)

mEnd[i]=qT;

}

 

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

// 5. Манипулятор осуществляет движение с обходом препятствий

// Результат - искомый массив mRez[]

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

 

int number=0; // number - номер выбранного массива M[L]

int H,h; // H - номер ответвления массива m

point **m; // h - элемент массива m

point qim; // m - массив обхода

// qim - текущая точка массива обхода

bool T[NUM]; // T[i] = true, если i-ый обход достиг точки mEnd[j]

// T[i] = false, если i-ый обход попал в тупик

 

int M[NUM]; // M[i] - запоминает номера ответвления массива обхода

M[0]=0;

int L; // L - количество ответвлений массива m

 

point neighbor[8]; // neighbor[] - координаты точек окрестности

 

qi=q0;

 

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

{

qi= mPr[i];

 

flag = false;

 

for (j=0;j<a;j++)

if (qi.x == mCol[j].x && qi.y == mCol[j].y)

{

flag = true;

break;

}

if (flag == true)

{

m = new point* [C[j]*100];

 

if(m == NULL)

{

cout << "Динамический массив не создан";

exit(8);

}

 

H=0;

h=0;

L=0;

 

for (r=0;r<NUM;r++)

{

T[r]=true;

}

 

qi=mPr[i-1];

 

m[H] = new point [C[j]]; // m[0] = new point [C[j]];

 

if(m[H] == NULL)

{

cout << "Динамический массив не создан";

exit(9);

}

 

m[H][h] = qi; // m[0][0] = qi;

 

qim=qi;

 

while (1)

{

 

while (qim.x != mEnd[j].x || qim.y != mEnd[j].y)

{

 

neighbor[0].x = qim.x - delta; // [0] [1] [2]

neighbor[0].y = qim.y + delta;

// [3] qim [4]

neighbor[1].x = qim.x;

neighbor[1].y = qim.y + delta; // [5] [6] [7]

 

neighbor[2].x = qim.x + delta;

neighbor[2].y = qim.y + delta;

 

neighbor[3].x = qim.x - delta;

neighbor[3].y = qim.y;

 

neighbor[4].x = qim.x + delta;

neighbor[4].y = qim.y;

 

neighbor[5].x = qim.x - delta;

neighbor[5].y = qim.y - delta;

 

neighbor[6].x = qim.x;

neighbor[6].y = qim.y - delta;

 

neighbor[7].x = qim.x + delta;

neighbor[7].y = qim.y - delta;

 

// Есть ли ХОТЬ ОДНА окрестная разрешенная неповторяющаяся точка ?

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

 

flag = false;

 

for (v=0;v<8;v++)

{

for (u=0;u<C[j];u++)

{

if (neighbor[v].x == raz[j][u].x && neighbor[v].y == raz[j][u].y)

 

flag=true;

 

for (k=0;k<=M[H];k++)

if (neighbor[v].x == m[H][k].x && neighbor[v].y == m[H][k].y)

{

flag=false;

break;

}

if (flag == true) break;

}

if (flag == true) break;

}

// Алгоритм разветвления обхода препятствия

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

 

if (flag == true)

{

Flag = false;

flag = false;

 

h++;

 

for (v=0;v<8;v++)

for (u=0;u<C[j];u++)

{

if (neighbor[v].x == raz[j][u].x && neighbor[v].y == raz[j][u].y)

Flag = true;

 

for (k=0;k<=M[H];k++)

if (neighbor[v].x == m[H][k].x && neighbor[v].y == m[H][k].y)

{

Flag = false;

break;

}

 

if (Flag == true)

{

if (flag == true)

{

 

M[++L]=h;

m[L] = new point [C[j]];

if(m[H] == NULL)

{

cout << "Динамический массив не создан";

exit(10);

}

 

for (r=0;r<h;r++)

m[L][r]=m[H][r];

 

m[L][h] = raz[j][u];

 

}

if (flag == false)

{

M[H]=h;

m[H][h]=raz[j][u];

qim=raz[j][u];

 

flag = true;

}

Flag=false;

}

}

}

else

{

T[H]=false;

break;

}

}

if (H < L)

{

H++;

h=M[H];

qim=m[H][h];

}

else break;

 

}

 

// Выбираем кратчайший путь из M[L]

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

 

int min = 9999;

 

for (k=0;k<=L;k++)

if (T[k]==true && M[k] < min)

{

number = k;

min = M[k];

}

if (min != 9999)

{

for (k=1;k<=M[number];k++)

mRez[n++]=m[number][k];

}

 

qi=mEnd[j];

 

Liberation(m,L+1);

 

for (k=0;k<s;k++)

if (qi.x == mPr[k].x && qi.y == mPr[k].y) i=k;

 

} //if close

else

{

mRez[n++] = mPr[i];

qi = mPr[i];

}

} // for s close

 

 

Liberation(zap,a);

Liberation(raz,a);

 

delete [] mPr;

delete [] B;

delete [] C;

 

}

 

else

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

mRez[n++] = mPr[i];

T2=Now();

 

Time=MillisecondsBetween (T1,T2);

}

 

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


[1] ВДУ – временной допустимый уровень