Расчетно-графическая работа (3 части)1 / ATK asoi-232 Ahmadullin B.R / expSub

#-*- 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 = (Z2) = Z2
# ССА: Структурная схема алгоритма
# A211: Z2
# ------+----->
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A001 = (Z2) = Z2
# A001 = Z2
# РТА: Рабочий текст алгоритма
# alg A001(): Zh2()
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма

# A001 A001= A001= A001= alg A001():
# = ( ( | Z2 Zh2()
# ( Z2 | Z2
# Z2 ) )
# )

def eA101(ccrt, hCycles): # alg A211():
hCycles.Zh(ccrt.techsys.head2) # Zh2() - типовой цикл СГ2

# Необходимо строго соблюдать стандартные отступы




# #-----------------------------------------
# Пример A211: Последовательность двух команд

# СФА: Структурная формула алгоритма
# A211 = (Z2-Z4)
# ССА: Структурная схема алгоритма
# A211: Z2 Z4
# ------+--+---->
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A211 = (Z2-Z4) = Z2-Z4
# A211 = Z2-Z4
# РТА: Рабочий текст алгоритма
# alg A211(): Zh2(); Zh4()
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма

# A211 A211= A211= A211= A211= alg A211():
# = ( ( | Z2- | Z2 Zh2()
# ( Z2- | Z2- | Z4 | Z4 Zh4()
# Z2 Z4 | Z4
# - ) )
# Z4
# )
# ТПР: Текст программной реализации алгоритма

def eA211(ccrt, hCycles): # alg A211():
hCycles.Zh(ccrt.techsys.head2) # Zh2() - типовой цикл СГ2
hCycles.Zh(ccrt.techsys.head4) # Zh4() - типовой цикл СГ4
# Необходимо строго соблюдать стандартные отступы



# #-----------------------------------------
# Пример A222: Параллельная конъюнкция двух команды (#&).
# Одна команда (Z6) выносится в поток.

# СФА: Структурная формула алгоритма
# A222 = (Z2 & Z4) = (Z2 #& Z4) = #(Z2, Z4)& = #Z2,Z4&
# ССА: Структурная схема алгоритма // Исходная формула
# Исходная схема
# A222: # Z2 &
# ------+--+--+---->
# | Z4 |
# +--+--+
# Модификация схемы

# A222: FZ4 Z2 J&Z4
# ------+---+---+---->
# Z4
# |---+---| команда Z4, упакованная в поток (thread)

# FZi = F(Zi) = Fork(Zi) - оператор узла вилки:
# кпаковка в поток и вызов команды Zi в потоке
# J&Zi = J&(Zi) = Join_&(Zi) - оператор узла сборки:
# ожижание (wait) завершения команды Zi

# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A222 = = #(Z2, Z4)& = # Z2, Z4 & = # Z2 Z4 & = FZ4 Z2 JZ4 = FZ4-Z2-J&Z4
# * * * метки
# РТА: Рабочий текст алгоритма
# alg A222(): Fork(Zh4()); Zh2(); Join_&(Zh4())
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма

# A222 = alg A222():
# | FZ4 Fork(Zh4())
# | Z2 Zh2()
# | J&Z4 Join_&(Zh4())

# ТПР: Текст программной реализации алгоритма

# Исходный вариант

def eA222d(ccrt, hCycles): # alg A222():
thread.start_new(hCycles.Zh, (ccrt.techsys.head4, )) # Fork(Zh4())
hCycles.Zh(ccrt.techsys.head2) # Zh2()
while not ccrt.techsys.head4.yzh: # Join(Zh4(): ожидание (head4.yzh = 1)
pass # пустой оператор тела цикла

def fffff(ccrt, hCycles):
hCycles.Zh(ccrt.techsys.head4)

def eA222(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.head3),)
# 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.head2) # Zh2()
thread.join() # Fork(Zh4())

# Модификация 1: Задержка в цикле - разгрузка процессора

def eA222m1(ccrt, hCycles): # alg A2221():
thread.start_new(hCycles.Zh, (ccrt.techsys.head4, )) # Fork(Zh4())
hCycles.Zh(ccrt.techsys.head2) # Zh2()
while not ccrt.techsys.head4.yzh: # Join(Zh4(): ожидание (head4.yzh = 1)
time.sleep(0.1) # задержка для разгрузки процессора

# Модификация 2: Задержка в цикле и вывод сообщения

def eA222m2(ccrt, hCycles): # alg A2221():
thread.start_new(hCycles.Zh, (ccrt.techsys.head4, )) # Fork(Zh4())
hCycles.Zh(ccrt.techsys.head2) # Zh2()
while not ccrt.techsys.head4.yzh: # Join(Zh4(): ожидание (head4.yzh = 1)
time.sleep(0.1) # задержка для разгрузки процессора
print 'yzh4 = 0' # вывод сообщения - работа узла Join


# #-----------------------------------------
# Пример A222_2: Параллельная конъюнкция двух команд (#&):
# обе команды (Z2, Z4) выносятся в поток.
# Вспомогательный вариант - для подготовки параллельной дизъюнкции (#V)

# СФА: Структурная формула алгоритма
# A222_2 = (Z2 & Z4) = (R &(Z2 & Z4)) = (R #& (Z2 #& Z4)) = #(R, #(Z2, Z4)&)& =
# = (R & Z2 & Z4) = (R #& Z2 #& Z4) = #(R, Z2, Z4)&
# R = -> - пустой оператор (повторитлеь),
# эквивалентный линии простой связи " -> "
# ССА: Структурная схема алгоритма
# Исходная схема
# A222_2: # Z2 & A222_2: # -> = R & A222_2: # (R) &
# --------+--+--+----> = --------+-----------+----> = --------+--+--+---->
# | Z4 | | # Z2 & | | Z2 |
# +--+--+ +--+--+--+--+ +--+--+
# | Z4 | | Z4 |
# +--+--+ +--+--+
# СФА: Структурная формула алгоритма // Продолжение
# A222_2 = (Z2 & Z4) = (R & Z2 & Z4) = ((R & Z2) & Z4))=
# = ((R #& Z2) #& Z4) = #(#(R, Z2)&, Z4)&
# ССА: Структурная схема алгоритма // Продолжение
# Исходная схема
# A222_2: # Z2 & A222_2: # # (R) & & A222_2: # # & &
# --------+--+--+----> = --------+--+--+--+--+----> = --------+--+-----+--+-->
# | Z4 | | | Z2 | | | | Z2 | |
# +--+--+ | +--+--+ | | +--+--+ |
# | Z4 | | Z4 |
# +-----+-----+ +-----+-----+
# Модификация схемы
# A2221: FZ4 FZ2 (R) J&Z2 J&Z4 A2221: FZ4 FZ2 J&Z2 J&Z4
# --------+---+----+---+----+------> = --------+---+------+----+------>
# Z2
# |----+---| команда Z2, упакованная в поток (thread)
# Z4
# |--------+--------| команда Z4, упакованная в поток (thread)

# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма
# A222_2 = #(#(R, Z2)&, Z4)& = # # R, Z2 &, Z4 & =
# = # # R Z2 & Z4 & = FZ6 # R Z2 & J&Z4 =
# * * * * * *
# = FZ4 FZ2 R J&Z4 J&Z2

# РТА: Рабочий текст алгоритма
# alg A222_2(): Fork(Zh4()); Fork(Zh2()); pass; Join_&(Zh()); Join_&(Zh4())
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма

# A222_1= alg A222_1():
# | FZ4 Fork(Zh4())
# | FZ2 Fork(Zh2(
# | J&Z2 Join_&(Zh2())
# | J&Z4 Join_&(Zh4())

# ТПР: Текст программной реализации алгоритма

def eA222_2(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head4, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head2, ))
# pass # может стоять пустой оператор: pаss = R (может опускаться)
# однако появляется неусточивость в работе - необходима задержка
time.sleep(1) # задержка R(m) - задержанный повторитель (m = 1 sec)
while not ccrt.techsys.head2.yzh: # Join(Zh2(): ожидание (head2.yzh = 1)
# time.sleep(1) # (необязательная) задержка для разгрузки процессора
# print 'yzh2 = 0' # (необязательный) вывод сообщения - работа узла Join
pass
while not ccrt.techsys.head4.yzh: # Join(Zh4(): ожидание (head4.yzh = 1)
# time.sleep(1) # (необязательная) задержка для разгрузки процессора
# print 'yzh4 = 0' # (необязательный) вывод сообщения - работа узла Join
pass



# #-----------------------------------------
# Пример A222_3: Параллельная конъюнкция двух команд (#&).
# Обе команды выносятся в поток.
# Модифицируется узел сборки
# Вспомогательный вариант - для подготовки параллельной дизъюнкции (#V)

# СФА: Структурная формула алгоритма // Продолжение
# A222_3 = (Z2 & Z4) = (R & Z2 & Z4) = ((R & Z2) & Z4))=
# = ((R #& Z2) #& Z4) = #(#(R, Z2)&, Z4)&
# ССА: Структурная схема алгоритма // Модификация
# A222_3: # Z2 & A222_3: # # & &
# --------+--+--+----> = --------+--+-----+--+--> =
# | Z4 | | | Z2 | |
# +--+--+ | +--+--+ |
# | Z4 |
# +-----+-----+
#
# A222_3: # # &
# = --------+--+--------+--> =
# | | |
# | | ----& Дополнительный узел &-сборки
# | | Z2 | |
# | +--+--+ |
# | Z4 |
# +-----+-----+
# ВТА: Вербальный текст алгоритма / ПиПТ: Питон-подобный текст
# ГИ: Горизонтальное исполнение
# ШТА: Шаблон текста алгоритма // Модификация
# A222_2 = #(#(R, Z2)&, Z4)& = # # R, Z2 &, Z4 & =
# = # # R Z2 & Z4 & = FZ4 # R Z2 & J&Z4 =
# * * * * * *
# A222_3 = FZ4 FZ2 R J&Z2 J&Z4 = FZ4 FZ2 R J&(Z2' & Z4')
#
# РТА: Рабочий текст алгоритма
# alg A222_3(): Fork(Zh4()); Fork(Zh2()); pass; Join_&(Zh()'and (Zh4()')
# ВИ: Вертикальное исполнение
# ШТА: Шаблон текста алгоритма РТА: Рабочий текст алгоритма

# A222_3= alg A222_3():
# | FZ4 Fork(Zh4())
# | FZ2 Fork(Zh2(
# | J&(Z2'& Z4') Join_&(Zh2()' and (Zh4()')

# ТПР: Текст программной реализации алгоритма

def eA222_3(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head4, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head2, ))
# pass # может стоять пустой оператор: pаss = R (может опускаться)
# однако появляется неусточивость в работе - необходима задержка
time.sleep(1) # задержка R(m) - задержанный повторитель (m = 1 sec)
while not(ccrt.techsys.head4.yzh and ccrt.techsys.head2.yzh):
# time.sleep(1) # (необязательная) задержка для разгрузки процессора
# print 'yzh2 = 0' # (необязательный) вывод сообщения - работа узла Join
pass



# #-----------------------------------------
# Пример A232: Параллельная дизъюнкция двух команд (#&).
# Обе команды выносятся в поток.
# Модифицируется узел сборки

# СФА: Структурная формула алгоритма
# A232 = (Z7 V Z6) = (R & (Z7 V Z6)) = (R #& (Z7 #V Z6)) = #(R, #(Z7, Z6)V)& =
# = (R & Z7 & Z6) = (R #& Z7 #& Z6) = #(R, Z7, Z6)&
# ССА: Структурная схема алгоритма // Модификация
# ССА: Структурная схема алгоритма
# A232: # Z7 V A232: # -> = R &
# --------+--+--+----> = --------+-----------+----> =
# | Z6 | | # Z7 V |
# +--+--+ +--+--+--+--+
# | Z6 |
# +--+--+
# ССА: Структурная схема алгоритма // Модификация
# A232: # # &
# = --------+--+--------+--> =
# | | |
# | | ----V Дополнительный узел V-сборки
# | | Z7 | |
# | +--+--+ |
# | Z6 |
# +-----+-----+
#
# ТПР: Текст программной реализации алгоритма

def eA232(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head4, ))
hCycles.Zh(ccrt.techsys.head2) # Zh7()
while not(ccrt.techsys.head4.yzh or ccrt.techsys.head2.yzh):
# time.sleep(1) # (необязательная) задержка для разгрузки процессора
# print 'yzh7 = 0' # (необязательный) вывод сообщения - работа узла Join
pass
#





# #-----------------------------------------
# Пример A323: Параллельная дизъюнкция трех команд (#&).
# Две команды выносятся в поток.

def eA323(ccrt, hCycles):
thread.start_new(hCycles.Zh, (ccrt.techsys.head4, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head2, ))
thread.start_new(hCycles.Zh, (ccrt.techsys.head5, ))
time.sleep(1)
while not ccrt.techsys.head4.yzh: # Join(Zh6(): ожидание (head6.yzh = 1)
time.sleep(0.1) # задержка для разгрузки процессора
while not ccrt.techsys.head5.yzh: # Join(Zh5(): ожидание (head5.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.head2, ))
time.sleep(1) # спец. задержка
while not(ccrt.techsys.head4.yzh or ccrt.techsys.head2.yzh):
pass
hCycles.Zh(ccrt.techsys.head5) # цикл силовой головки
while not(ccrt.techsys.head4.yzh and ccrt.techsys.head2.yzh):
pass





#----------------------------------
#----------------------------------
#----------------------------------
# Группа задач Э3: Этап 3: Работа: Самостоятельные разработки
# Применяется упаковка попрограмм в паралльеные потоки
# Используется третий ряд переключателей циклов рабочего режима


# #-----------------------------------------
# Пример A091: Опорный пример: Параллельная конъюнкция


# СФА: Структурная формула алгоритма
# A091 = (Z1-((Z3-Z1)&((Z5&(Z2-(Z4&Z0)))-(Z6&(Z5-Z2)))))

# ТПР: Текст программной реализации алгоритма

# Исходный вариант

def A10(ccrt, hCycles): # подпрограмма дополнительного потока
hCycles.za10 = 0 # Введение индикации окончания A20
hCycles.Zh(ccrt.techsys.head7) # СГ10 - типовой цикл
hCycles.Zh(ccrt.techsys.head4)
hCycles.za10 = 1 # Окончание процесса A20

def A11(ccrt, hCycles): # подпрограмма дополнительного потока
hCycles.za11 = 0 # Введение индикации окончания A10
hCycles.Zh(ccrt.techsys.head3)
hCycles.Zh(ccrt.techsys.head5)
hCycles.za11 = 1 # Окончание процесса A10

def A12(ccrt, hCycles):
hCycles.za12 = 0
hCycles.Zh(ccrt.techsys.head8)
hCycles.za12 = 1

def A13 (ccrt, hCycles):
hCycles.za13 = 0
hCycles.Zh(ccrt.techsys.head1)
hCycles.za13 = 1

def eAxx1(ccrt, hCycles): # alg A141() программа основного потока
hCycles.Zh(ccrt.techsys.head2) # СГ1 - типовой цикл
thread.start_new(expSub.A10, (ccrt, hCycles, ))
thread.start_new(expSub.A11, (ccrt, hCycles, ))
thread.start_new(expSub.A12, (ccrt, hCycles, ))
thread.start_new(expSub.A13, (ccrt, hCycles, ))
hCycles.Zh(ccrt.techsys.head10) # СГ2 - типовой цикл
hCycles.Zh(ccrt.techsys.head2)
while not hCycles.za13: # Контроль окончания A10
time.sleep(1)# задержка в цикле ожидания
hCycles.Zh(ccrt.techsys.head10)
while not hCycles.za12:
time.sleep(1)
while not hCycles.za11:
time.sleep(1)
while not hCycles.za10:
time.sleep(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()
print 'A10 -----------'
# expSub.mutex2.release()
time.sleep(1) # спец. задержка
pass
print 'end while A10'
hCycles.za10 = 1
print 'end A10'


def eAxx1m1(ccrt, hCycles): # A141
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(1) # спец. задержка
pass
print 'end while eAxx1'
hCycles.Zh(ccrt.techsys.head3) # СГ3 - типовой цикл
hCycles.Zh(ccrt.techsys.head1) # СГ1 - типовой цикл
print 'end eAxx3'





# #-----------------------------------------
# Пример A142: Опорный пример: Параллельная дизъюнкция

# СФА: Структурная формула алгоритма
# A142 = (((Z1 – Z2) V (Z3 – (Z4 & (Z5 – Z6)))) – Z3 – Z1)

# ТПР: Текст программной реализации алгоритма


def A30d(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): # A142
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