Утилизация твердых отходов
Разработанный проект предусматривает применение вычислительных устройств. Данные устройства предусматривают в среднем 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 Декартовая система координат. Препятствия О1,О2,О3. Стартовая конфигурация 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] ВДУ – временной допустимый уровень