Всем привет! На Хабре я новичок, решила поделиться своими скромными идеями и выслушать ваше мнение, возможно, вы дадите мне дельные советы.

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

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

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

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

где  L – расчётная длина пути режущего инструмента в направлении подачи, мм; i – число проходов; S – подача, мм/об.

где l – расчетная длина обрабатываемой поверхности, мм; l₁ = t * ctg угла φ – величина врезания резца, мм; t – глубина резания, мм; φ - главный угол в плане резца; l₂ = 1–3 мм – выход (перебег) резца.

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

Теперь перейдем непосредственно к коду. Импортируем все необходимые библиотеки.

import numpy as np
import pandas as pd
import openpyxl

Укажем путь к нашему Excel-файлу и считаем данные в DataFrame с помощью `pandas`. Выведем первые пять строк таблицы, чтобы мы могли убедиться, что данные загружены правильно.

file_path = 'time.xlsx'
df = pd.read_excel(file_path)
print(df.head())

Произведем расчет машинного времени в минутах на единицу продукции, предварительно проверив, что все необходимые столбцы присутствуют в данных. Если какой-то столбец отсутствует, выбрасывается ошибка. Затем мы приводим значения этих столбцов к числовому типу, используя `pd.to_numeric()`. Полученные значения машинного времени выводим в массив.

columns_to_extract = ['L', 'i', 'S']
missing_columns = [col for col in columns_to_extract if col not in df.columns]
if missing_columns:
    raise KeyError(f"The following columns are missing from the DataFrame: {missing_columns}")
df[columns_to_extract] = df[columns_to_extract].apply(pd.to_numeric, errors='coerce')
df['Tm'] = (df['L'] * df['i']) /  df['S']
Tm_array = df['Tm'].values
print(Tm_array)

Теперь необходимо рассчитать поправочные коэффициенты: коэффициент партийности, коэффициент в зависимости от количества обслуживаемых станков и организации рабочего места. Данные коэффициенты представлены в таблицах в нормативном документе "Общемашиностроительные укрупненные нормативы времени на работы, выполняемые на металлорежущих станках".

Рассчитаем коэффициент партийности, написав следующую функцию*:

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

В результате получаем массив данных со значением коэффициента партийности в зависимости от количества деталей.

data_n = {
    'Число деталей в партии': ['1..2', '3..5', '6..10', '11..20', '21..40', '41..90', 'свыше 90'],
    'при обработке на станках с ручным управлением': [1, 0.9, 0.8, 0.75, 0.7, 0.6, 0.55],
    'при обработке на станках с полуавтоматическим циклом (зубообрабатывающие, дисковые пилы и т.д.)': [1, 0.98, 0.95, 0.92, 0.9, 0.86, 0.85]
}
df_codes = pd.DataFrame(data_n)
def get_n_value(part_counts, col_name):
    if part_counts <= 2:
        return df_codes.loc[df_codes['Число деталей в партии'] == '1..2', col_name].values[0]
    elif 3 <= part_counts <= 5:
        return df_codes.loc[df_codes['Число деталей в партии'] == '3..5', col_name].values[0]
    elif 6 <= part_counts <= 10:
        return df_codes.loc[df_codes['Число деталей в партии'] == '6..10', col_name].values[0]
    elif 11 <= part_counts <= 20:
        return df_codes.loc[df_codes['Число деталей в партии'] == '11..20', col_name].values[0]
    elif 21 <= part_counts <= 40:
        return df_codes.loc[df_codes['Число деталей в партии'] == '21..40', col_name].values[0]
    elif 41 <= part_counts <= 90:
        return df_codes.loc[df_codes['Число деталей в партии'] == '41..90', col_name].values[0]
    else:
        return df_codes.loc[df_codes['Число деталей в партии'] == 'свыше 90', col_name].values[0]
number = ['Кол-во']
data_num = df[number].values
part_counts = data_num # количество деталей в партии
kn = [get_n_value(count, 'при обработке на станках с ручным управлением') for count in part_counts]
print(kn)     

Рассчитаем коэффициент обслуживания станков в зависимости от числа станков и формы организации труда. Коды 1,2,3 означают значения коэффициентов занятости (таблица 2, Карта 1 лист 1 "Общемашиностроительные укрупненные нормативы времени на работы, выполняемые на металлорежущих станках". )

def get_valor(количество_станков, тип):
    # Извлечение данных из таблицы
    data_os = {
        'Количество станков': ['2', '3', '4'],
        'Индивидуальная_1': [0.56, 0.39, 0.33],
        'Индивидуальная_2': [0.65, 0.48, 0.39],
        'Индивидуальная_3': [0.75, 0.55, 0.47],
        'Бригадная_1': [0.53, 0.37, 0.30],
        'Бригадная_2': [0.60, 0.44, 0.37],
        'Бригадная_3': [0.67, 0.51, 0.45],
    }
    # Проверка наличия входных данных в таблице
    if количество_станков not in data_os['Количество станков'] or тип + '_1' not in data_os:
        return "Неверные данные"

    # Нахождение индекса в списке количества станков
    index = data_os['Количество станков'].index(количество_станков)

    # Возвращение значения в зависимости от количества станков и типа
    return data_os[тип + '_1'][index]
kos = get_valor('2', 'Индивидуальная')
print(kos)

Далее рассчитаем значение коэффициента организации труда в зависимости от группы станков ( в моем случае группа станков 1):

data_org = {
        'Группа станков': ['1', '2'],
        'Коэффициент организации': [1, 0.80],
        
    }
def get_coeff(группа_станков):
    # Извлечение данных из таблицы
    data_org = {
        'Группа станков': ['1', '2'],
        'Коэффициент организации': [1, 0.80],
    }

    # Проверка наличия входных данных в таблице
    if группа_станков not in data_org['Группа станков']:
        return "Неверные данные"

    # Нахождение индекса в списке группы станков
    index = data_org['Группа станков'].index(группа_станков)

    # Возвращение значения в зависимости от группы станков
    return data_org['Коэффициент организации'][index]

# Пример использования функции
korg = get_coeff('1')
print(korg)

На основании тех же самых "Общемашиностроительных нормативов ..." формула для расчета штучного времени будет выглядеть следующим образом:

Норма штучного времени  определяется путем суммирования времени на установку и снятие детали и неполного штучного времени на обработку поверхностей.

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

Нормативы неполного штучного времени на обработку поверхности включают:

- основное время (в нашем случае машинное время)

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

- вспомогательное время на изменение режима работы станка и смену инструмента;

- время на обслуживание рабочего места, перерывы на отдых и личные потребности.

Так как накладки в моем примере имеют маленькие размеры и обрабатываются на одном и том же станке, будем учитывать только время на обслуживание рабочего места. Данные будут считываться из таблицы Excel

df1 = pd.read_excel(file_path, sheet_name ='t_обсл')
print(df1.head())

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

Tobsl = df1.loc[df1['Код'] == 1, 'Время_обсл,%'].iloc[0]
print(Tobsl)
Tnsht=Tm_array+Tobsl/100
print(Tnsht)

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

df2 = pd.read_excel(file_path, sheet_name ='t_вспом')
print(df2.head())
t_vc = df2.loc[df2['Код'] == 1, 'Время_вспом,мин'].iloc[0]
print(t_vc)

Рассчитываем значение штучного времени по формуле, указанной выше:

Tsht=(t_vc+Tnsht)*kn*kos*korg
print(Tsht)

Наконец, норма времени на работы, выполняемые на металлорежущих станках, состоит из штучного времени Т_ш и подготовительно-заключительного времени t_п.з и определяется по формуле:

# Расчет подготовительно-заключительного времени
df3 = pd.read_excel(file_path, sheet_name ='t_пзв')
print(df3.head())
Tpz = df3.loc[df3['Позиция'] == 2, 'Пзв,%'].iloc[0]
print(Tpz)
# Расчет нормы времени
N_vr=Tsht*(1 + Tpz/100)
print(N_vr)

В заключении рассчитаем время на партию в часах и выгрузим полученные значения в файл Excel.

col=np.transpose(data_num)
print(col)
#Норма времени на партию, в часах
N_part=(N_vr*col)/60
print(N_part)
# Создание нового файла Excel
workbook = openpyxl.Workbook()
sheet = workbook.active
# Запись данных в ячейки
for row_idx, row in enumerate(N_part, start=1):
    for col_idx, value in enumerate(row, start=1):
        sheet.cell(row=col_idx, column=row_idx, value=value) 
# Сохранение файла Excel
workbook.save("Расчет_времени.xlsx")

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