Добавил:
Studfiles2
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Расчетно-графическая работа / ATK ASOI 231 Baimuratov 060126'1 / expSub
.py#-*- coding: cp1251 -*-
# -----------------------------------------------------
# Программа parATKvXXX.py
# Модуль expSub.py
#
# Модуль учебных (экспериментальных) подпрограмм
#
# Данный модуль содержит подпрограммы дополонительных циклов
# конфигурации АТК12 (двенадцать силовых головок)
# автоматизированного технологического комлпекса АТК.
# Модуль предназначен для упрощения экспериментов
# по многопоточному программированию
# с групповыми циклами силовых головок в конфигурации АТК12.
# Для программных экспериментов на основе данного модуля
# в блок переключателей рабочего режима на пульте управления
# дополнительно введены
# второй и третий ряды перецелючателей циклов (радио-кнопки).
#
# ----------------------------------------------------
# Разработчик программы parATK Житников А.П.
# ноябрь 2005г.
# -----------------------------------------------------
import ConfigParser
import tkFileDialog
import thread
import threading
import math, time
import expSub
# -------------------------------------
#----------------------------------
#----------------------------------
#----------------------------------
# Группа задач Э2: Этап 2: Тренаж: Простые примеры
# Первичный тренаж - упаковка в паралльеные потоки отдельных команд
# Используется второй ряд переключателей циклов рабочего режима
# #-----------------------------------------
# Пример A001: Пустой алгоритм - проходная интерпретация
# СФА: Структурная формула алгоритма
# A001 = () = (-) = (->) = (R) = -> = R
# ССА: Структурная схема алгоритма
# A211: R
# ----------> = ------+---->
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A001 = () = R
# A001 = R
# РТА: Рабочий текст алгоритма
# alg A001(): pass
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A001 A001= A001= A001= alg A001():
# = ( ( | R pass
# ( R | R
# R ) )
# )
# ТПР: Текст программной реализации алгоритма
def eA001(ccrt, hCycles): # alg A001():
pass # пустой оператор: R = ->
# Необходимо строго соблюдать стандартные отступы
# #-----------------------------------------
# Пример A002: Пустой алгоритм - непроходная интерпретация
# Для сведения
# СФА: Структурная формула алгоритма
# A002 = (|)
# #-----------------------------------------
# Пример A101: Единичный алгоритм
# СФА: Структурная формула алгоритма
# A101 = (Z7) = Z7
# ССА: Структурная схема алгоритма
# A211: Z7
# ------+----->
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A001 = (Z7) = Z7
# A001 = Z7
# РТА: Рабочий текст алгоритма
# alg A001(): Zh7()
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A001 A001= A001= A001= alg A001( ):
# = ( ( | Z7 Zh7( )
# ( Z7 | Z7
# Z7 ) )
# )
def eA101(ccrt, hCycles): # alg A211():
hCycles.Zh(ccrt.techsys.head7) # Zh7() - типовой цикл СГ7
# Необходимо строго соблюдать стандартные отступы
# #-----------------------------------------
# Пример A211: Последовательность двух команд
# СФА: Структурная формула алгоритма
# A211 = (Z7-Z4)
# ССА: Структурная схема алгоритма
# A211: Z7 Z4
# ------+--+---->
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A211 = (Z7-Z4) = Z7-Z4
# A211 = Z7-Z4
# РТА: Рабочий текст алгоритма
# alg A211(): Zh7( ); Zh4( )
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A211 A211= A211= A211= A211= alg A211( ):
# = ( ( | Z7 - | Z7 Zh17( )
# ( Z7 - | Z7 - | Z4 | Z4 Zh4( )
# Z7 Z4 | Z4
# - ) )
# Z4
# )
# ТПР: Текст программной реализации алгоритма
def eA211(ccrt, hCycles): # alg A211():
hCycles.Zh(ccrt.techsys.head7) # Zh7() - типовой цикл СГ7
hCycles.Zh(ccrt.techsys.head4) # Zh4() - типовой цикл СГ4
# Необходимо строго соблюдать стандартные отступы
# #-----------------------------------------
# Пример A222: Параллельная конъюнкция двух команды (#&).
# Одна команда (Z4) выносится в поток.
# СФА: Структурная формула алгоритма
# A222 = (Z7 & Z4) = (Z7 #& Z4) = #(Z7, Z4)& = #Z7,Z4&
# ССА: Структурная схема алгоритма // Исходная формула
# Исходная схема
# A222: # Z7 &
# ------+--+--+---->
# | Z4 |
# +--+--+
# Модификация схемы
# A222: FZ4 Z7 J&Z4
# ------+-----+----+---->
# Z4
# |-----+-----| команда Z4, упакованная в поток (thread)
# FZi = F(Zi) = Fork(Zi) - оператор узла вилки:
# кпаковка в поток и вызов команды Zi в потоке
# J&Zi = J&(Zi) = Join_&(Zi) - оператор узла сборки:
# ожижание (wait) завершения команды Zi
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A222 = #(Z7, Z4)& = # Z7, Z4 & = # Z7 Z4 & = FZ4 Z7 JZ4 = FZ4-Z7-J&Z4
# * * * метки
# РТА: Рабочий текст алгоритма
# alg A222(): Fork(Zh4()); Zh7(); Join_&(Zh4())
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A222 = alg A222():
# | FZ4 Fork(Zh4())
# | Z7 Zh7()
# | J&Z4 Join_&(Zh4())
# ТПР: Текст программной реализации алгоритма
# Исходный вариант
def eA222a(ccrt, hCycles): # alg A222():
thread.start_new(hCycles.Zh, (ccrt.techsys.head4, )) # Fork(Zh4())
hCycles.Zh(ccrt.techsys.head7) # Zh7()
while not ccrt.techsys.head7.yzh: # Join(Zh4(): ожидание (head4.yzh = 1)
pass # пустой оператор тела цикла
def fffff(ccrt, hCycles):
hCycles.Zh(ccrt.techsys.head4)
def eA222b(ccrt, hCycles): # alg A222():
print '1111111111111111111111'
thread = threading.Thread(target = fffff(ccrt, hCycles))
# tttttt = hCycles.Zh(ccrt.techsys.head4)
# thread = threading.Thread(target = tttttt)
# thread = threading.Thread(target = hCycles.Zh(ccrt.techsys.head4))
# thread = threading.Thread(target = hCycles.Zh(ccrt.techsys.head4),)
# thread = threading.Thread(target = hCycles.Zh(ccrt.techsys.head4,)) thread = threading.Thread(target = hCycles.Zh(ccrt.techsys.head4),)
# thread = threading.Thread(target = hCycles.Zh(ccrt.techsys.head4,),)
# thread = threading.Thread(None, hCycles.Zh(ccrt.techsys.head4), None, args=(), kwargs =())
thread.start() # Fork(Zh4())
print '2222222222222222222222'
hCycles.Zh(ccrt.techsys.head7) # Zh7()
thread.join() # Fork(Zh4())
# Модификация 1: Задержка в цикле - разгрузка процессора
def eA222(ccrt, hCycles): # alg A2221():
thread.start_new(hCycles.Zh, (ccrt.techsys.head4, )) # Fork(Zh4())
hCycles.Zh(ccrt.techsys.head7) # Zh7()
while not ccrt.techsys.head4.yzh: # Join(Zh4(): ожидание (head4.yzh = 1)
time.sleep(0.1) # задержка для разгрузки процессора
# Модификация 2: Задержка в цикле и вывод сообщения (для отладки)
def eA222e(ccrt, hCycles): # alg A2221():
thread.start_new(hCycles.Zh, (ccrt.techsys.head4, )) # Fork(Zh4())
hCycles.Zh(ccrt.techsys.head7) # Zh7()
while not ccrt.techsys.head4.yzh: # Join(Zh4(): ожидание (head4.yzh = 1)
time.sleep(0.1) # задержка для разгрузки процессора
print 'yzh4 = 0' # вывод сообщения - работа узла Join
# #-----------------------------------------
# Пример A222_2: Параллельная конъюнкция двух команд (#&):
# обе команды (Z4, Z7) выносятся в поток.
# Вспомогательный вариант - для подготовки параллельной дизъюнкции (#V)
# СФА: Структурная формула алгоритма
# A222_2 = (Z7 & Z4) = (R &(Z7 & Z4)) = (R #& (Z7 #& Z4)) = #(R, #(Z7, Z4)&)& =
# = (R & Z7 & Z4) = (R #& Z7 #& Z4) = #(R, Z7, Z4)&
# R = -> - пустой оператор (повторитлеь),
# эквивалентный линии простой связи " -> "
# ССА: Структурная схема алгоритма
# Исходная схема
# A222_2: # Z7 & A222_2: # -> = R & A222_2: # (R) &
# --------+--+--+----> = --------+--------------+----> = --------+--+--+---->
# | Z4 | | # Z7 & | | Z7 |
# +--+--+ +--+--+--+--+ +--+--+
# | Z4 | | Z4 |
# +--+--+ +--+--+
# СФА: Структурная формула алгоритма // Продолжение
# A222_2 = (Z7 & Z4) = (R & Z7 & Z4) = ((R & Z7) & Z4))=
# = ((R #& Z7) #& Z4) = #(#(R, Z7)&, Z4)&
# ССА: Структурная схема алгоритма // Продолжение
# Исходная схема
# A222_2: # Z7 & A222_2: # # (R) & & A222_2: # # & &
# --------+--+--+----> = --------+--+--+--+--+----> = --------+--+-----+--+-->
# | Z4 | | | Z7 | | | | Z7 | |
# +--+--+ | +--+--+ | | +--+--+ |
# | Z4 | | Z4 |
# +------+------+ +-----+------+
# Модификация схемы
# A2221: FZ4 FZ7 (R) J&Z7 J&Z4 A2221: FZ4 FZ7 J&Z7 J&Z4
# --------+-----+-----+-----+------+------> = --------+-----+--------+------+------>
# Z7
# |-----+------| команда Z7, упакованная в поток (thread)
# Z4
# |-------------+--------------| команда Z4, упакованная в поток (thread)
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A222_2 = #(#(R, Z7)&, Z4)& = # # R, Z7 &, Z4 & =
# = # # R Z7 & Z4 & = FZ4 # R Z7 & J&Z4 =
# * * * * * *
# = FZ4 FZ7 R J&Z7 J&Z4
# РТА: Рабочий текст алгоритма
# alg A222_2(): Fork(Zh4()); Fork(Zh7()); pass; Join_&(Zh()); Join_&(Zh4())
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A222_1= alg A222_1():
# | FZ4 Fork(Zh4())
# | FZ7 Fork(Zh7(
# | J&Z7 Join_&(Zh7())
# | J&Z4 Join_&(Zh4())
# ТПР: Текст программной реализации алгоритма
def eA222_2(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head4, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head7, ))
# pass # может стоять пустой оператор: pаss = R (может опускаться)
# однако появляется неусточивость в работе - необходима задержка
time.sleep(1) # задержка R(m) - задержанный повторитель (m = 1 sec)
while not ccrt.techsys.head7.yzh: # Join(Zh7(): ожидание (head7.yzh = 1)
time.sleep(0.1) # (необязательная) задержка для разгрузки процессора
# print 'yzh7 = 0' # (необязательный) вывод сообщения - работа узла Join
while not ccrt.techsys.head4.yzh: # Join(Zh4(): ожидание (head4.yzh = 1)
time.sleep(0.1) # (необязательная) задержка для разгрузки процессора
# print 'yzh4 = 0' # (необязательный) вывод сообщения - работа узла Join
# #-----------------------------------------
# Пример A222_3: Параллельная конъюнкция двух команд (#&).
# Обе команды выносятся в поток.
# Модифицируется узел сборки
# Вспомогательный вариант - для подготовки параллельной дизъюнкции (#V)
# СФА: Структурная формула алгоритма // Продолжение
# A222_3 = (Z7 & Z4) = (R & Z7 & Z4) = ((R & Z7) & Z4))=
# = ((R #& Z7) #& Z4) = #(#(R, Z7)&, Z4)&
# ССА: Структурная схема алгоритма // Модификация
# A222_3: # Z7 & A222_3: # # & &
# --------+--+--+----> = --------+--+-----+--+--> =
# | Z4 | | | Z7 | |
# +--+--+ | +--+--+ |
# | Z4 |
# +------+-----+
#
# A222_3: # # &
# = --------+--+--------+--> =
# | | |
# | | ----& Дополнительный узел &-сборки
# | | Z7 | |
# | +--+--+ |
# | Z4 |
# +------+-----+
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма // Модификация
# A222_2 = #(#(R, Z7)&, Z4)& = # # R, Z7 &, Z4 & =
# = # # R Z7 & Z4 & = FZ4 # R Z7 & J&Z4 =
# * * * * * *
# A222_3 = FZ4 FZ7 R J&Z7 J&Z4 = FZ4 FZ7 R J&(Z7' & Z4')
#
# РТА: Рабочий текст алгоритма
# alg A222_3(): Fork(Zh4()); Fork(Zh7()); pass; Join_&(Zh()'and (Zh4()')
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма
# A222_3= alg A222_3():
# | FZ4 Fork(Zh4())
# | FZ7 Fork(Zh7(
# | J&(Z7'& Z4') Join_&(Zh7()' and (Zh4()')
# ТПР: Текст программной реализации алгоритма
def eA222_3(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head4, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head7, ))
# pass # может стоять пустой оператор: pаss = R (может опускаться)
# однако появляется неусточивость в работе - необходима задержка
time.sleep(1) # задержка R(m) - задержанный повторитель (m = 1 sec)
while not(ccrt.techsys.head4.yzh and ccrt.techsys.head7.yzh):
time.sleep(0.1) # задержка для разгрузки процессора
# print 'yzh7 = 0' # (необязательный) вывод сообщения - работа узла Join
pass
# #-----------------------------------------
# Пример A232: Параллельная дизъюнкция двух команд (#&).
# Обе команды выносятся в поток.
# Модифицируется узел сборки
# СФА: Структурная формула алгоритма
# A232 = (Z7 V Z4) = (R & (Z7 V Z4)) = (R #& (Z7 #V Z4)) = #(R, #(Z7, Z4)V)& =
# = (R & Z7 & Z4) = (R #& Z7 #& Z4) = #(R, Z7, Z4)&
# ССА: Структурная схема алгоритма // Модификация
# ССА: Структурная схема алгоритма
# A232: # Z7 V A232: # -> = R &
# --------+--+--+----> = --------+--------------+----> =
# | Z4 | | # Z7 V |
# +--+--+ +--+--+--+--+
# | Z4 |
# +--+--+
# ССА: Структурная схема алгоритма // Модификация
# A232: # # &
# = --------+--+---------+--> =
# | | |
# | | ----V Дополнительный узел V-сборки
# | | Z7 | |
# | +--+--+ |
# | Z4 |
# +-----+-----+
#
# ТПР: Текст программной реализации алгоритма
def eA232(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head4, ))
hCycles.Zh(ccrt.techsys.head7) # Zh7()
while not(ccrt.techsys.head4.yzh or ccrt.techsys.head7.yzh):
time.sleep(0.1) # задержка для разгрузки процессора
# print 'yzh5 = 0' # (необязательный) вывод сообщения - работа узла Join
# #-----------------------------------------
# Пример A323: Параллельная дизъюнкция трех команд (#&).
# Две команды выносятся в поток.
def eA323(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head7, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head4, ))
time.sleep(1)
while not ccrt.techsys.head7.yzh: # Join(Zh7(): ожидание (head7.yzh = 1)
time.sleep(0.1) # задержка для разгрузки процессора
while not ccrt.techsys.head4.yzh: # Join(Zh4(): ожидание (head4.yzh = 1)
time.sleep(0.1) # задержка для разгрузки процессора
# #-----------------------------------------
# Пример A343: Параллельный алгоритм:
def eA342(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head4, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head7, ))
time.sleep(1) # спец. задержка
while not(ccrt.techsys.head4.yzh or ccrt.techsys.head7.yzh):
time.sleep(0.1) # задержка для разгрузки процессора
hCycles.Zh(ccrt.techsys.head5) # цикл силовой головки
while not(ccrt.techsys.head4.yzh and ccrt.techsys.head7.yzh):
time.sleep(0.1) # задержка для разгрузки процессора
#----------------------------------
#----------------------------------
#----------------------------------
# Группа задач Э3: Этап 3: Работа: Самостоятельные разработки
# Применяется упаковка попрограмм в паралльеные потоки
# Используется третий ряд переключателей циклов рабочего режима
# #-----------------------------------------
# Пример A141: Опорный пример: Параллельная конъюнкция
# СФА: Структурная формула алгоритма
# A991 = (Z1 - (( ( Z2 & Z5 ) - Z2) & ((( Z7 - (Z8 &Z3 )) & (Z4 - Z1 ) ) - Z0 ) ) )
# ТПР: Текст программной реализации алгоритма
# Исходный вариант
def A40(ccrt, hCycles):
hCycles.za40 = 0
hCycles.Zh(ccrt.techsys.head5)
hCycles.za40 = 1
def A30(ccrt, hCycles):
hCycles.za30 = 0
hCycles.Zh(ccrt.techsys.head4)
hCycles.Zh(ccrt.techsys.head1)
hCycles.za30 = 1
def A20(ccrt, hCycles):
hCycles.za20 = 0
hCycles.Zh(ccrt.techsys.head3)
hCycles.za20 = 1
def A10(ccrt, hCycles):
hCycles.za10 = 0
thread.start_new(expSub.A30, (ccrt, hCycles, ))
hCycles.Zh(ccrt.techsys.head7)
thread.start_new(expSub.A20, (ccrt, hCycles, ))
hCycles.Zh(ccrt.techsys.head8)
while not hCycles.za20:
time.sleep(0.1)
while not hCycles.za30:
time.sleep(0.1)
hCycles.Zh(ccrt.techsys.head10)
hCycles.za10 = 1
def eAxx1(ccrt, hCycles):
thread.start_new(expSub.A10, (ccrt, hCycles, ))
thread.start_new(expSub.A40, (ccrt, hCycles, ))
hCycles.Zh(ccrt.techsys.head2)
while not hCycles.za40:
time.sleep(0.1)
hCycles.Zh(ccrt.techsys.head2)
while not hCycles.za10:
time.sleep(0.1)
# Модификация 1:
def A20m1(ccrt, hCycles): # подпрограмма дополнитtльного потока
print 'begin A20'
hCycles.za20 = 0
hCycles.Zh(ccrt.techsys.head5) # СГ5 - типовой цикл
hCycles.Zh(ccrt.techsys.head6) # СГ6 - типовой цикл
hCycles.za20 = 1
print 'end A20'
def A10m1(ccrt, hCycles): # подпрограмма дополнитtльного потока
print 'begin A10'
# mutex = thread.allocate_lock() # замок взаимного исключения доступа
hCycles.za10 = 0
hCycles.Zh(ccrt.techsys.head3) # СГ3 - типовой цикл
thread.start_new(expSub.A20, (ccrt, hCycles, )) # поток СГ1
hCycles.Zh(ccrt.techsys.head4) # СГ4 - типовой цикл
print 'begin while A10'
while not hCycles.za20:
# expSub.mutex2.acquire()
time.sleep(0.1) # задержка для разгрузки процессора
print 'A10 -----------'
# expSub.mutex2.release()
print 'end while A10'
hCycles.za10 = 1
print 'end A10'
def eAxx1m1(ccrt, hCycles): # A992
print 'begin eAxx1'
expSub.mutex = thread.allocate_lock() # замок взаимного исключения доступа
thread.start_new(expSub.A10, (ccrt, hCycles, )) # поток СГ1
hCycles.Zh(ccrt.techsys.head1) # СГ1 - типовой цикл
hCycles.Zh(ccrt.techsys.head2) # СГ2 - типовой цикл
print 'begin while eAxx1'
while not hCycles.za10:
expSub.mutex.acquire()
print 'eAxx1 &&&&&&&&&&&'
expSub.mutex.release()
time.sleep(0.1) # задержка для разгрузки процессора
print 'end while eAxx1'
hCycles.Zh(ccrt.techsys.head3) # СГ3 - типовой цикл
hCycles.Zh(ccrt.techsys.head1) # СГ1 - типовой цикл
print 'end eAxx3'
# #-----------------------------------------
# Пример A142: Опорный пример: Параллельная дизъюнкция
# СФА: Структурная формула алгоритма
# A992 = (Z1 - (((Z2 & Z5) – Z2)&(Z7 – ((Z8 & Z3)&(Z4 – Z1)))) – Z0)
# ТПР: Текст программной реализации алгоритма
def A50(ccrt, hCycles): # подпрограмма дополнитtльного потока
print 'begin A30'
hCycles.za30 = 0
hCycles.Zh(ccrt.techsys.head1) # СГ1 - типовой цикл
hCycles.Zh(ccrt.techsys.head2) # СГ2 - типовой цикл
hCycles.za30 = 1
print 'end A30'
def eAxx2(ccrt, hCycles): # A992
print 'begin eAxx2'
expSub.mutex = thread.allocate_lock() # замок взаимного исключения доступа
thread.start_new(expSub.A10, (ccrt, hCycles, )) # поток СГ1
thread.start_new(expSub.A30, (ccrt, hCycles, )) # поток СГ1
time.sleep(1) # спец. задержка
while not (hCycles.za10 or hCycles.za30):
time.sleep(0.1) # задержка для разгрузки процессора
hCycles.Zh(ccrt.techsys.head3) # СГ3 - типовой цикл
hCycles.Zh(ccrt.techsys.head1) # СГ1 - типовой цикл
print 'end eAxx2'
def eAxx2a(ccrt, hCycles): # A992
print 'begin eAxx2'
expSub.mutex = thread.allocate_lock() # замок взаимного исключения доступа
thread.start_new(expSub.A10, (ccrt, hCycles, )) # поток СГ1
thread.start_new(expSub.A30, (ccrt, hCycles, )) # поток СГ1
time.sleep(1) # спец. задержка
while not (hCycles.za10 or hCycles.za30):
expSub.mutex.acquire()
print 'eAxx1 &&&&&&&&&&&'
expSub.mutex.release()
time.sleep(1) # спец. задержка
pass
hCycles.Zh(ccrt.techsys.head3) # СГ3 - типовой цикл
hCycles.Zh(ccrt.techsys.head1) # СГ1 - типовой цикл
print 'end eAxx2'
# #-----------------------------------------
def eAxx3(ccrt, hCycles):
print 'begin eAxx3'
print 'end eAxx3'
pass
def eAxx4(ccrt, hCycles):
print 'begin eAxx4'
thread.start_new(expSub.A10, (ccrt, hCycles, )) # поток СГ1
thread.start_new(expSub.A30, (ccrt, hCycles, )) # поток СГ1
time.sleep(1) # спец. задержка
while not (hCycles.za10 and hCycles.za30):
# expSub.mutex.acquire()
print 'eAxx1 &&&&&&&&&&&'
# expSub.mutex.release()
time.sleep(1) # спец. задержка
pass
hCycles.Zh(ccrt.techsys.head3) # СГ3 - типовой цикл
hCycles.Zh(ccrt.techsys.head1) # СГ1 - типовой цикл
print 'end eAxx4'
def eAxx5(ccrt, hCycles):
print 'begin eAxx5'
print 'end eAxx5'
pass
def eAxx6(ccrt, hCycles):
print 'begin eAxx6'
print 'end eAxx6'
pass
def eAxx7(ccrt, hCycles):
print 'begin eAxx7'
print 'end eAxx7'
pass
def eAxx8(ccrt, hCycles):
print 'begin eAxx8'
print 'end eAxx8'
pass
def eAxx9(ccrt, hCycles):
print 'begin eAxx9'
print 'end eAxx9'
pass