1. Opis ogólny
2. Jak poznać moduł mieszalni ?
2.1 Dane branżowe: [SK] Skup zboża Mieszalnia pasz
2.2 Logowanie
3. Receptura paszy
4. Dopisanie danych firmy [SK]
5. Mieszanie paszy. Kolejne kroki
6. Możliwosci rozbudowy programu
7. Bilansowanie parametrów surowców i mieszanek
8. Tematy powiązane
9. Analiza i Projekt: Bilansowanie składników
10. Mieszalnia pasz. Oferta wdrożenia
1. Opis ogólny
W programie Trawers ERP są moduły przydatne w przedsiębiorstwach gospodarki
żywnościowej. W przedsiębiorstwach, które zajmują się skupem i sprzedażą
surowców rolniczych oraz wytwarzaniem mieszanek paszowych dla zwierząt.
Kluczowe korzyści z wdrożenia modułów produkcyjnych i modułu kontroli jakości
w firmach zajmujących się mieszaniem pasz:
- Możliwość ewidencjonowania receptur dla wyrobów gotowych w kartotekach
struktur produktów BOM
- Możliwość wyceny (planowanego kosztu produkcji) wyrobu gotowego na podstawie
wprowadzonej receptury oraz kosztów materiałów zapisanych w systemie magazynowym
- Możliwość tworzenia zleceń produkcyjnych wraz ze specyfikacjami materiałowymi
na podstawie raz utworzonej receptury wyrobu gotowego
- Tracebility (**identyfikowalność**), dzięki wykorzystaniu zleceń produkcyjnych do których
są rejestrowane dokumenty wydania materiałów (z podziałem na serię materiału) oraz
dokumenty przychodu (z podziałem na serię wyrobu)
- Wycena wyrobu gotowego wg faktycznego kosztu wytworzenia na podstawie dokumentów
zarejestrowanych do zlecenia produkcyjnego
- Możliwość ewidencjonowania parametrów kontroli jakości, w tym np. wartości
odżywczych, zarówno dla surowców jak i wyrobów gotowych, wraz z normami min/max
Szczegółowy opis skupu i kontroli jakości surowców:
SK Skup i kontrola jakości surowców
W tym artykule opisano funkcje Trawers ERP, które są przydatne w przedsiębiorstwach
wytwarzających mieszanki paszowe dla zwierząt.
2. Jak poznać moduł mieszalni ?
Funkcje modułu mieszalni można poznać podczas pracy na specjalnie przygotowanych
danych przykładowych: Dane branżowe [SK] Skup zboża. Mieszalnia pasz.
Przygotowano wspólne dane przykładowe dla modułu skupu i modułu mieszalni.
Patrz szczegóły:
Dane branżowe. Profile firm
Kolejne kroki:
2.1 Dane branżowe: [SK] Skup zboża Mieszalnia pasz
Dopisać firmę, utworzyć dla niej zbiory danych i wypełnić zbiory danymi
przykładowymi: [SK] Skup zboża Mieszalnia pasz
Patrz też:
Wielo-firmowość
Funkcja: AD > Firmy > Dopisywanie [AD_TFI10]
Profil: [9] Skup zboża Mieszalnia pasz
Symbol: [SK]
... pozostałe pola wypełnić dowolnie
Program dopisze dane przykładowe:
* karty asortymentu (indeksy KIM): przykładowe zboża, np. pszenica,
surowce i dodatki stosowane przy produkcji mieszanek
* cenniki zakupu
* karty testów jakości
* tabele potrąceń od cen w zależności od wyników testów jakości
* receptury mieszanek paszowych
Program utworzy magazyny:
10 Magazyn Handlowy
W magazynie [10] jest prowadzona ewidencja ilościowo-wartościowa
zboża posiadanego przez firmę.
W magazynie [10] są składniki mieszanek i wyroby gotowe
S1 Silos 1. Przechowywanie D
S2 Silos 2. Przechowywanie D
W magazynach [S1] i [S2] jest prowadzona ewidencja ilościowa
zboża przechowywanego przez firmę.
W kartach dostawców, np. [R00001] Rolnik ryczałtowy dopisać:
Dane podstawowe > Numer weterynaryjny, FOR > Numer weterynaryjny,
np. PL08034001WE
2.2 Logowanie
Zalogować się powtórnie, wybrać firmę: [SK]
Można rozpocząć wytwarzanie mieszanek paszowych.
3. Receptura paszy
Dane przykładowe
W danych przykładowych jest receptura paszy (w kartotece BOM):
BM > BOM > Struktury BOM > Przeglądanie [BM_KKS40]Produkt: [ZZ PASZA] Pasza zwierzęca (mieszanka)
Jednostka miary: [5000] 5000 kg
NOTE: Zlecenie można otworzyć na ilość = 1
Powstanie produkt (pasza) o wadze: 5000 kg
Można otworzyć na ilość = 0.5
Powstanie produkt (pasza) o wadze: 2500 kg
Komponenty:
Nazwa Waga w kg
-----------------------------
Śr.p.sojowa 46% 3950
Śr.p.z rzep.00 34% 125
Fosforan 1-wapniowy 175
Kreda pastewna 400
Weglan sodu 30
Lizyna 65
Metionina 10
NaCl 100
Premiks 100
Zakwaszacz 39
PHYZYME-fitaza 3
Maxarom 3
-----------------------------
Razem: 5000
Waga netto mieszanki
W strukturach (recepturach), które mają takie same jednostki miary (tu: kg)
można podsumować ilości komponentów (klawisz: R)
BM > BOM > Obliczanie wagi netto produktu [BM_OWA50]
Obliczanie wagi produktu jako sumy wagi komponentów wg BOM
Zestawienie komponentów produktu: [ZZ PASZA] Pasza zwierzęca (mieszanka)
------------------------------------------------------------------------------
Waga produktu
- Poziom - --- Komponent -- -- -------- w kg / Jm --- Nazwa -----------------
------------------------------------------------------------------------------
Produkt: ZZ PASZA Pr Pasza zwierzęca (mieszanka)
.1........ ZZ 000001 Mz 3 950.000 kg Śr.p.sojowa 46%
.1........ ZZ 000002 Mz 125.000 kg Śr.p.z rzep.00 34%
.1........ ZZ 000003 Mz 175.000 kg Fosforan 1-wapniowy
.1........ ZZ 000004 Mz 400.000 kg Kreda pastewna
.1........ ZZ 000005 Mz 30.000 kg Weglan sodu
.1........ ZZ 000006 Mz 65.000 kg Lizyna
.1........ ZZ 000007 Mz 10.000 kg Metionina
.1........ ZZ 000008 Mz 100.000 kg NaCl
.1........ ZZ 000009 Mz 100.000 kg Premiks
.1........ ZZ 000010 Mz 39.000 kg Zakwaszacz
.1........ ZZ 000011 Mz 3.000 kg PHYZYME-fitaza
.1........ ZZ 000012 Mz 3.000 kg Maxarom
== Razem =====================================================================
5 000.000 kg/5000
4. Dopisanie danych firmy [SK]
* Dopisać firmę, utworzyć dla niej zbiory danych i wypełnić zbiory danymi
danymi przykładowymi: [SK] Skup zboża Mieszalnia pasz
* Program dopisze dane przykładowe:
[v] Karty asortymentu (indeksy KIM)
-------------------------------------------------------------
---- Indeks ---- ---- Nazwa ---------------------- -Jm- Gr --
-------------------------------------------------------------
ZZ PASZA Pasza zwierzęca (mieszanka) 5000 10 Pr
ZZ 000001 Śr.p.sojowa 46% kg 10 Mz
ZZ 000002 Śr.p.z rzep.00 34% kg 10 Mz
ZZ 000003 Fosforan 1-wapniowy kg 10 Mz
ZZ 000004 Kreda pastewna kg 10 Mz
ZZ 000005 Weglan sodu kg 10 Mz
ZZ 000006 Lizyna kg 10 Mz
ZZ 000007 Metionina kg 10 Mz
ZZ 000008 NaCl kg 10 Mz
ZZ 000009 Premiks kg 10 Mz
ZZ 000010 Zakwaszacz kg 10 Mz
ZZ 000011 PHYZYME-fitaza kg 10 Mz
ZZ 000012 Maxarom kg 10 Mz
-------------------------------------------------------------
[v] Dodatkowo wypełni kartotekę struktury BOM dla produktu (mieszanki):
[ZZ PASZA] Pasza zwierzęca (mieszanka)
Patrz wyżej przykład struktury BOM
5. Mieszanie paszy. Kolejne kroki
Model przepływu danych
MAGAZYNPRODUKCJA
(5.1) (5.2)
o------------- o----------------
| Surowce (5.3) | Zlecenie
| w magazynie o--->----->----> | mieszania
o------------- o----------------
o
|
v (5.4) Mieszalnik
|
v
o------------- o----------------
| Mieszanka (5.5) | Mieszanka
| w magazynie <---<----<------o | na produkcji
o------------- o----------------
(5.1) Przyjęcie surowców do magazynu, np. zakupionych od dostawców
lub wytworzonych we wlasnym zakresie
(5.2) Utworzenie zlecenia mieszania: Z00001/000
(5.3) Wydanie surowców na produkcje, do zlecenia: Z00001/000
(5.4) Mieszanie surowców w mieszalniku
(5.5) Przychód mieszanki do magazynu
5.1 Przyjęcie surowców do magazynu
* Przyjęcie surowców do magazynu, to zapewni możliwość wydania (rozchodu)
na potrzeby produkcji [MG_DPZ1A]. Ceny przykładowe.
- Śr.p.sojowa 46%: 3950 kg, cena 2.00 PLN/kg
- Śr.p.z rzep.00 34%: 125 kg, cena 1.50 PLN/kg
- Fosforan 1-wapniowy: 175 kg, cena 4.00 PLN/kg
- Kreda pastewna: 400 kg, cena 0.50 PLN/kg
- Weglan sodu: 30 kg, cena 3.00 PLN/kg
- Lizyna: 65 kg, cena 6.00 PLN/kg
- Metionina: 10 kg, cena 8.00 PLN/kg
- NaCl: 100 kg, cena 0.20 PLN/kg
- Premiks: 100 kg, cena 5.00 PLN/kg
- Zakwaszacz: 39 kg, cena 7.00 PLN/kg
- PHYZYME-fitaza: 3 kg, cena 50.00 PLN/kg
- Maxarom: 3 kg, cena 10.00 PLN/kg
Pozycje dokumentu [PR] Przychód
o-----------o--------------------o-------o------o--------------o
| Indeks | Nazwa | Ilość | Jm | Cena (PLN/kg)|
o-----------o--------------------o-------o------o--------------o
| ZZ 000001 | Śr.p.sojowa 46% | 3950 | kg | 2.00 |
| ZZ 000002 | Śr.p.z rzep.00 34% | 125 | kg | 1.50 |
| ZZ 000003 | Fosforan 1-wapniowy| 175 | kg | 4.00 |
| ZZ 000004 | Kreda pastewna | 400 | kg | 0.50 |
| ZZ 000005 | Weglan sodu | 30 | kg | 3.00 |
| ZZ 000006 | Lizyna | 65 | kg | 6.00 |
| ZZ 000007 | Metionina | 10 | kg | 8.00 |
| ZZ 000008 | NaCl | 100 | kg | 0.20 |
| ZZ 000009 | Premiks | 100 | kg | 5.00 |
| ZZ 000010 | Zakwaszacz | 39 | kg | 7.00 |
| ZZ 000011 | PHYZYME-fitaza | 3 | kg | 50.00 |
| ZZ 000012 | Maxarom | 3 | kg | 10.00 |
o-----------o--------------------o-------o------o--------------o
5.2 Utworzenie zlecenia produkcyjnego
* Utworzyć (dopisać) zlecenie produkcyjne: [ZP_KZL1A]
NOTE: Zlecenie można utworzyć dowolną liczbę razy, codziennie
lub nawet tylko jeden raz w miesiącu.
Zlecenie: Z00001/000
Produkt: [ZZ PASZA] Pasza zwierzęca (mieszanka)
Zlecono: 0.500 tj. 2500 kg
* Otworzyć [O] zlecenie [ZP_OCP10]
5.3 Wydanie surowców na produkcję
* Wydanie surowców z magazynu na produkcję
ZP > Dokumenty1 > Wydanie materiałów > Seryjnie wg specyfikacji [ZP_DWM1E]
- Śr.p.sojowa 46%: 1975 kg (przy wydaniu 0.5 zlecenia, tj. 2500 kg mieszanki)
- Śr.p.z rzep.00 34%: 62.5 kg
- Fosforan 1-wapniowy: 87.5 kg
- Kreda pastewna: 200 kg
- Weglan sodu: 15 kg
- Lizyna: 32.5 kg
- Metionina: 5 kg
- NaCl: 50 kg
- Premiks: 50 kg
- Zakwaszacz: 19.5 kg
- PHYZYME-fitaza: 1.5 kg
- Maxarom: 1.5 kg
Pozycje dokumentu [RO] Rozchód
o-----------o--------------------o-------o------o--------------o
| Indeks | Nazwa | Ilość | Jm | Cena (PLN/kg)|
o-----------o--------------------o-------o------o--------------o
| ZZ 000001 | Śr.p.sojowa 46% | 1975 | kg | 2.00 |
| ZZ 000002 | Śr.p.z rzep.00 34% | 62.5 | kg | 1.50 |
| ZZ 000003 | Fosforan 1-wapniowy| 87.5 | kg | 4.00 |
| ZZ 000004 | Kreda pastewna | 200 | kg | 0.50 |
| ZZ 000005 | Weglan sodu | 15 | kg | 3.00 |
| ZZ 000006 | Lizyna | 32.5 | kg | 6.00 |
| ZZ 000007 | Metionina | 5 | kg | 8.00 |
| ZZ 000008 | NaCl | 50 | kg | 0.20 |
| ZZ 000009 | Premiks | 50 | kg | 5.00 |
| ZZ 000010 | Zakwaszacz | 19.5 | kg | 7.00 |
| ZZ 000011 | PHYZYME-fitaza | 1.5 | kg | 50.00 |
| ZZ 000012 | Maxarom | 1.5 | kg | 10.00 |
o-----------o--------------------o-------o------o--------------o
NOTE: Zatwierdzenie dokumentu wydania surowców w ZP [ZP_DWM1D],
spowoduje automatyczny rozchód surowców z magazynu (dokument w MG)
5.4 Mieszanie surowców
* Produkcja, tu: operacja mieszania surowców
5.5 Przychód mieszanki do magazynu
* Przychód wyrobu (mieszanki) do magazynu w ZP [ZP_DP110]
z wyceną wg kosztów rzeczywistych [R], wg przyjętej metody wyceny.
Pozycja dokumentu [PR] Przychód
o-----------o------------------------o-------o------o-------------------o
| Indeks | Nazwa | Ilość | Jm | Cena (PLN/kg) |
o-----------o------------------------o-------o------o-------------------o
| ZZ PASZA | Pasza zwierzęca (mix) | 2500 | kg | Koszty rzeczywiste|
o-----------o------------------------o-------o------o-------------------O
* Przykładowe obliczenie kosztów rzeczywistych:
Suma kosztów wszystkich komponentów zużytych do produkcji 2500 kg mieszanki paszowej:
Koszty rzeczywiste = (1975 kg * 2.00 PLN/kg) + (62.5 kg * 1.50 PLN/kg) +
(87.5 kg * 4.00 PLN/kg) + (200 kg * 0.50 PLN/kg) +
(15 kg * 3.00 PLN/kg) + (32.5 kg * 6.00 PLN/kg) +
(5 kg * 8.00 PLN/kg) + (50 kg * 0.20 PLN/kg) +
(50 kg * 5.00 PLN/kg) + (19.5 kg * 7.00 PLN/kg) +
(1.5 kg * 50.00 PLN/kg) + (1.5 kg * 10.00 PLN/kg)
Koszty rzeczywiste = 3950 PLN + 93.75 PLN + 350 PLN + 100 PLN +
45 PLN + 195 PLN + 40 PLN + 10 PLN +
250 PLN + 136.5 PLN + 75 PLN + 15 PLN
Koszty rzeczywiste = 5260.25 PLN
Cena za kg mieszanki paszowej = 5260.25 PLN / 2500 kg = 2.1041 PLN/kg
Przyjęcie wyrobu gotowego (paszy) do magazynu następuje po wycenie wg kosztów rzeczywistych.
6. Możliwosci rozbudowy programu
* Włączenie ewidencjonowania kosztów robocizny i kosztów operacji obcych
Rejestrowanie operacji
* Umożliwienie definiowanie w BOM składników w procentach objętościowych
lub wagowych a nie tylko w jednostkach ilościowych.
Patrz opis rozbudowy BOM --> BOM/Receptury
Tam opisano definiowanie składników (komponentów) w procentach objętościowych lub wagowych.
BOM/Receptury
* Umożliwienie numerowania partii LOT/SER komponentów (surowców) i produktów (mieszanki)
LOT/SER Zastosowania
Przyjęcie surowców do magazynu (MG_DPZ1A) z numerem partii LOT:
Pozycje dokumentu [PR] PrzychódLOT
o-----------o--------------------o-------o------o--------------o------------o
| Indeks | Nazwa | Ilość | Jm | Cena (PLN/kg)| Numer LOT |
o-----------o--------------------o-------o------o--------------o------------o
| ZZ 000001 | Śr.p.sojowa 46% | 3950 | kg | 2.00 | 2025/001 |
| ZZ 000002 | Śr.p.z rzep.00 34% | 125 | kg | 1.50 | 2025/002 |
| ZZ 000003 | Fosforan 1-wapniowy| 175 | kg | 4.00 | 2025/003 |
| ZZ 000004 | Kreda pastewna | 400 | kg | 0.50 | 2025/004 |
| ZZ 000005 | Weglan sodu | 30 | kg | 3.00 | 2025/005 |
| ZZ 000006 | Lizyna | 65 | kg | 6.00 | 2025/006 |
| ZZ 000007 | Metionina | 10 | kg | 8.00 | 2025/007 |
| ZZ 000008 | NaCl | 100 | kg | 0.20 | 2025/008 |
| ZZ 000009 | Premiks | 100 | kg | 5.00 | 2025/009 |
| ZZ 000010 | Zakwaszacz | 39 | kg | 7.00 | 2025/010 |
| ZZ 000012 | Maxarom | 3 | kg | 10.00 | 2025/012 |
o-----------o--------------------o-------o------o--------------o------------o
Wydanie surowców na produkcję (ZP_DWM1E) z numerem partii LOT:
Pozycje dokumentu [RO] RozchódLOT
o-----------o--------------------o-------o------o--------------o------------o
| Indeks | Nazwa | Ilość | Jm | Cena (PLN/kg)| Numer LOT |
o-----------o--------------------o-------o------o--------------o------------o
| ZZ 000001 | Śr.p.sojowa 46% | 1975 | kg | 2.00 | 2025/001 |
| ZZ 000002 | Śr.p.z rzep.00 34% | 62.5 | kg | 1.50 | 2025/002 |
| ZZ 000003 | Fosforan 1-wapniowy| 87.5 | kg | 4.00 | 2025/003 |
| ZZ 000004 | Kreda pastewna | 200 | kg | 0.50 | 2025/004 |
| ZZ 000005 | Weglan sodu | 15 | kg | 3.00 | 2025/005 |
| ZZ 000006 | Lizyna | 32.5 | kg | 6.00 | 2025/006 |
| ZZ 000007 | Metionina | 5 | kg | 8.00 | 2025/007 |
| ZZ 000008 | NaCl | 50 | kg | 0.20 | 2025/008 |
| ZZ 000009 | Premiks | 50 | kg | 5.00 | 2025/009 |
| ZZ 000010 | Zakwaszacz | 19.5 | kg | 7.00 | 2025/010 |
| ZZ 000011 | PHYZYME-fitaza | 1.5 | kg | 50.00 | 2025/011 |
| ZZ 000012 | Maxarom | 1.5 | kg | 10.00 | 2025/012 |
o-----------o--------------------o-------o------o--------------o------------o
Przyjęcie wyrobu gotowego do magazynu (ZP_DP110) z numerem partii LOT:
Pozycja dokumentu [PR] PrzychódLOT
o-----------o------------------------o-------o------o--------------+--------------o
| Indeks | Nazwa | Ilość | Jm | Cena (PLN/kg)| Numer LOT |
o-----------o------------------------o-------o------o--------------+--------------o
| ZZ PASZA | Pasza zwierzęca (mix) | 2500 | kg | K rzeczywiste| 2025/013 |
o-----------o------------------------o-------o------o--------------o--------------o
Numerowanie partii LOT pozwala na śledzenie surowców i produktów na każdym etapie procesu produkcyjnego,
co jest kluczowe dla zarządzania jakością, przejrzystości łańcucha dostaw i ewentualnego procesu
identyfikowania komponentów wyrobu gotowego.
7. Bilansowanie parametrów surowców i mieszanek
Opis ogólny
Kontrola bilansowania składników mieszanek paszowych.
Cel: Dobranie takich składnikow do mieszanki paszowej aby parametry
składników, np. białka odpowiadało parametrom mieszanki tj. produktu gotowego.
Jest to tzw. bilansowanie składników mieszanki paszowej.
W tym procesie chodzi o to, aby składniki paszowe w odpowiednich proporcjach
tworzyły mieszakę o pożądanych właściwościach, takich jak określona zawartość białka.
Przykłady bilansowania składników w hodowli zwierząt:
Bilansowanie paszy dla bydła mlecznego
Cel: Zapewnienie odpowiedniej ilości energii i białka dla krów mlecznych,
aby zwiększyć produkcję mleka.
Składniki:
Kukurydza, soja, lucerna, witaminy i minerały.
Proces:
Analiza wartości odżywczych składników, dostosowanie proporcji,
aby spełnić zapotrzebowanie na energię i białko, monitorowanie
stanu zdrowia i wydajności krów.
Bilansowanie paszy dla trzody chlewnej
Cel:
Optymalizacja wzrostu i zdrowia świń, minimalizacja kosztów paszy.
Składniki:
Zboża, śruta sojowa, tłuszcze, aminokwasy, witaminy i minerały.
Proces:
Określenie zapotrzebowania na energię i białko, bilansowanie aminokwasów
strawnych, monitorowanie przyrostów masy ciała i zdrowotności.
Źródła
Patrz (w sieci): E-book Zasady sporządzania bilansu paszowego.
E-book opisuje zasady sporządzania bilansu paszowego, w tym algorytmy
i metody obliczeń zapotrzebowania na pasze.
Bilansowanie składników w Trawers ERP
Aby umożliwić kontrolę bilansowania, należałoby rozbudować Trawers ERP:
* Dodanie parametrów do indeksów surowców, np. wartości odżywcze
Chodzi o wprowadzenie dodatkowych informacji dot. surowców używanych w produkcji,
takich jak wartości odżywcze.
Przykładowo, dla każdego surowca, takiego jak śruta sojowa, można dodać
informacje o zawartości białka, tłuszczu, witamin itp.
Dzięki tym informacjom, można dokładniej zarządzać surowcami i lepiej dostosować
proces produkcji do określonych wymagań jakościowych.
Można modyfikować receptury aby zbilansować komponenty i produkt..
NOTE: Parametry surowców można zapisać w tabeli:
QA > Wartości parametrów surowców [QA_PQW30]
Patrz też:
Produkcja recepturowa. Bilansowanie
* Dodanie parametrów norm do indeksów wyrobów gotowych
Oznacza wprowadzenie parametrów dotyczących standardów i norm,
które muszą spełniać wyroby gotowe.
Przykładowo, dla paszy zwierzęcej mogą to być normy dotyczące zawartości białka,
energii, mikroelementów itd.
Parametry te pomagają zapewnić, że wyroby gotowe spełniają określone
standardy jakości i są zgodne z regulacjami.
NOTE: Parametry wyrobów można zapisać jako wyniki testów jakości w systemie QA
QA > Karta testów jakości [QA_KQT10]
Patrz też:
QA1_Zlecenia. Kontrola jakości
* Funkcja kontroli zgodności receptury z normami produktów
Bilansowanie składników mieszanek paszowych.
Jest to mechanizm, który pozwala na sprawdzanie, czy receptury (BOM)
używane w produkcji są zgodne z określonymi normami i standardami
dla produktów końcowych.
NOTE: Sugerujemy ustalanie receptur w programach specjalizowanych.
Kroki:
* Ustalać receptury w programach specjalizowanych
* Receptury wpisywać do kartoteki BOM
* Okresowo otwierać zlecenia w systemie ZP, wydawać składniki, przyjmować gotowe mieszanki
* Tworzyć raporty, analizować koszty
NOTE: Dla potrzeb udokumentowania stosowanych receptur i parametrów składników
można wykorzystać karty testów jakości, w których podaje się oczekiwane
parametry jakościowe i zarejestrowane wyniki pomiarów.
Można np. podać zawartość białka w składniku mieszanki oraz w mieszance paszowej.
Wyniki testów można wydrukować (wg wzorców) i dołączyć materiałów
informacyjnych o produktach.
Przykład wzorca w katalogu ftp: qa_qc_certyfikat.xml
Wzorce Pliki na ftp Przeglądanie
Patrz opis testów jakości:
QA Plany testów jakości
NOTE: Karty testów jakości tj. plany testów i wyniki należy powiązać
z surowcami i produktami (mieszankami) identyfikowanymi numerami partii LOT/SER.
To pozwala na precyzyjne ustalenie parametrów jakościowych surowców i mieszanek.
Programy specjalizowane
* https://optipasz.pl/
OptiPasz to komputerowy program służący do opracowywania receptur paszowych
dla różnych gatunków zwierząt
* https://optipasz.pl/
OptiPasz to komputerowy program służący do opracowywania receptur paszowych
dla różnych gatunków zwierząt
* https://smartfeed.com.pl/
Symulator on-line, pomaga ułożyć receptury
* https://djg.pl
Dystrybutor programu:
INRAtion Program wspomagający układanie dawek pokarmowych dla zwierząt
przeżuwających według systemu INRA
Aby umożliwić kontrolę bilansowania, należy rozbudować Trawers ERP:
* Dodanie parametrów do indeksów surowców, np. wartości odżywcze
Chodzi o wprowadzenie dodatkowych informacji dot. surowców używanych
w produkcji, takich jak wartości odżywcze.
Przykładowo, dla każdego surowca, takiego jak śruta sojowa, można dodać
informacje o zawartości białka, tłuszczu, witamin itp.
Dzięki tym informacjom, można dokładniej zarządzać surowcami i lepiej
dostosować proces produkcji do określonych wymagań jakościowych.
Można modyfikować receptury aby zbilansować komponenty i produkt..
* Dodanie parametrów norm do indeksów wyrobów gotowych (mieszanek)
Oznacza wprowadzenie parametrów dotyczących standardów i norm,
które muszą spełniać wyroby gotowe.
Przykładowo, dla paszy zwierzęcej mogą to być normy dotyczące zawartości
białka, energii, mikroelementów itd.
Parametry te pomagają zapewnić, że wyroby gotowe spełniają określone
standardy jakości i są zgodne z regulacjami.
* Funkcja kontroli zgodności receptury z normami produktów
Bilansowanie składników mieszanek paszowych.
Jest to mechanizm, który pozwala na sprawdzanie, czy receptury (BOM)
używane w produkcji są zgodne z określonymi normami i standardami
dla produktów końcowych.
9.2 Rozbudowa Trawers ERP. Kroki
1. Dodanie parametrów do indeksów surowców (np. wartości odżywcze)
1. Rozbudowa bazy danych:
- Dodać pola w tabelach bazy danych, które będą przechowywać wartości
odżywcze surowców, np.:
- Zawartość białka (%)
- Tłuszcz (%)
- Mikroelementy (mg/kg)
- Wprowadzić elastyczność, aby można było łatwo dodawać nowe parametry
w przyszłości.
NOTE: Patrz tabela: QA > [QA_PQW30]
2. Interfejs użytkownika:
- Rozszerzyć formularze edycji indeksów surowców w ERP, dodając sekcję
Wartości odżywcze.
- Umożliwić szybkie wprowadzanie danych lub import parametrów
z plików zewnętrznych (np. Excel).
3. Raportowanie:
- Dodać możliwość generowania raportów o dostępnych surowcach
z uwzględnieniem ich wartości odżywczych.
2. Dodanie parametrów norm do indeksów wyrobów gotowych:
1. Definicja norm w ERP:
- Utworzyć osobną tabelę w bazie danych przechowującą normy dla wyrobów
gotowych.
Przykładowe parametry:
- Minimalna/maksymalna zawartość białka (%)
- Energia (kcal/kg)
- Zawartość mikroelementów (mg/kg)
NOTE: Patrz tabela: QA > Karta testów jakości [QA_KQT10]
2. Powiązanie norm z wyrobami gotowymi:
- Dodać sekcję w interfejsie do przypisywania norm do poszczególnych
produktów końcowych.
3. Walidacja wyrobów gotowych:
- Stworzyć mechanizmy automatycznego sprawdzania, czy wyroby końcowe
spełniają wprowadzone normy.
3. Funkcja kontroli zgodności receptury z normami produktów:
Aby zbudować mechanizm, który sprawdza produkt końcowy i pozwala na korektę
ilości składników receptury:
1. Moduł kalkulacyjny:
- Stworzyć algorytm, który analizuje receptury (BOM) w kontekście
wartości odżywczych surowców. Algorytm powinien:
- Obliczać zawartość parametrów w produkcie końcowym na podstawie
receptury.
- Porównywać uzyskane wartości z normami przypisanymi do produktu
końcowego.
2. System ostrzegawczy:
- Dodać funkcję generowania ostrzeżeń w przypadku niezgodności receptury
z normami.
Na przykład: Zawartość białka w recepturze wynosi 18%, co jest
poniżej minimalnej normy 20%.
3. Korekta ilości składników:
- Wprowadzić mechanizm, który umożliwi użytkownikowi interacyjną korektę
składników w recepturze.
- W oparciu o proponowane zmiany, algorytm przeliczy parametry odżywcze
w czasie rzeczywistym.
4. Interfejs użytkownika:
- Dodać dedykowany moduł w ERP, który umożliwia:
- Przeglądanie szczegółowych wyników bilansowania.
- Sugerowanie zmian proporcji składników w celu dopasowania do norm.
5. Automatyzacja:
- Opcjonalnie wprowadzić funkcję automatycznego dostosowania receptury
w oparciu o wybrane kryteria (np. minimalny koszt surowców,
maksymalizacja zawartości określonych składników).
Przykład działania mechanizmu kontroli receptury:
- Norma produktu końcowego:
- Białko: 20-25%
- Tłuszcz: 5-8%
- Obecna receptura (surowce na 100 kg mieszanki):
- Śruta sojowa (40 kg, białko: 45%, tłuszcz: 2%)
- Kukurydza (50 kg, białko: 9%, tłuszcz: 4%)
- Olej roślinny (10 kg, białko: 0%, tłuszcz: 100%)
- Obliczenie parametrów mieszanki:
- Białko: (40×45% + 50×9% + 10×0%) / 100 = 21,3%
- Tłuszcz: (40×2% + 50×4% + 10×100%) / 100 = 13,8%
- Wynik:
- Białko: OK (w normie)
- Tłuszcz: NIE OK (przekracza normę)
- Działanie mechanizmu:
- Ostrzeżenie: Zawartość tłuszczu w recepturze wynosi 13,8%,
co przekracza maksymalną normę 8%.
- Sugerowana korekta: zmniejszenie ilości oleju roślinnego do 5 kg
i zwiększenie kukurydzy do 55 kg.
9.3 Automatyzacja procedury
Automatyzacja procedury dostosowania receptury do wymogów norm wyrobu gotowego
wymaga stworzenia algorytmu iteracyjnego, który działa w pętli (_loop_)
i w każdym kolejnym kroku analizuje nowy układ parametrów,
aż do osiągnięcia zgodności z normami.
1. Elementy składowe automatyzacji
1. Baza danych surowców:
- Powinna zawierać szczegółowe parametry odżywcze każdego składnika
(np. białko, tłuszcz, mikroelementy).
2. Baza norm produktów końcowych:
- Musi zawierać zakresy wymagań dla produktów końcowych
(np. minimalna/maksymalna zawartość białka, tłuszczu, energii itp.).
3. Algorytm iteracyjny:
- Mechanizm, który w każdym kroku:
- Analizuje recepturę.
- Porównuje parametry mieszanki z normami.
- Proponuje zmiany w składnikach w celu lepszego dopasowania.
4. Interacyjny system dostosowywania:
- Interfejs użytkownika pozwalający na śledzenie kolejnych kroków
i wprowadzanie korekt w recepturze.
- Możliwość akceptacji proponowanych zmian automatycznych
lub ręcznej ingerencji w parametry.
2. Działanie algorytmu w pętli
1. Wejście:
- Receptura (BOM) na podstawie surowców.
- Normy produktu końcowego.
2. Krok iteracyjny:
- Obliczenie parametrów mieszanki:
Algorytm sumuje wartości odżywcze składników w mieszance
(np. białko w % na podstawie ilości surowca).
- Porównanie z normami:
Jeśli którykolwiek parametr wychodzi poza zakres norm, generowane
jest ostrzeżenie.
- Propozycja korekty:
Algorytm sugeruje zwiększenie/zmniejszenie ilości składnika
lub dodanie nowego składnika, aby zbliżyć parametry do wymogów norm.
3. Aktualizacja receptury:
- Wprowadzenie sugerowanych zmian do receptury (automatycznie
lub ręcznie przez użytkownika).
4. Nowa analiza:
- Algorytm ponownie oblicza parametry mieszanki i porównuje je z normami
- Jeśli nadal występują niezgodności, procedura powtarza się.
5. Wyjście:
- Pętla kończy się, gdy parametry mieszanki spełniają wszystkie normy.
3. Przykładowy przebieg iteracji
- Wejście:
- Receptura: 50 kg śruty sojowej (białko: 45%) + 50 kg kukurydzy
(białko: 9%).
- Norma: białko 2025%.
- Iteracja 1:
- Algorytm wylicza białko: (50×45% + 50×9%) / 100 = 27%.
- Ostrzeżenie: Zawartość białka przekracza maksymalną normę 25%.
- Propozycja: zmniejszyć śrutę sojową do 40 kg, zwiększyć kukurydzę do 60 kg.
- Iteracja 2:
- Algorytm wylicza białko: (40×45% + 60×9%) / 100 = 23,4%.
- Wynik: parametry mieszanki są zgodne z normami.
4. Rozszerzenia automatyzacji
- Optymalizacja kosztów:
- Algorytm może dodatkowo uwzględniać koszty surowców, proponując
recepturę o najniższym koszcie spełniającą normy.
- Elastyczność norm:
- Możliwość definiowania priorytetów dla różnych parametrów
(np. białko ważniejsze niż tłuszcz).
- Historia zmian:
- System zapisuje wszystkie kroki i korekty, co pozwala na audyt
i analizę procesu.
9.4 Algorytm. Przykład w języku Pyton
Przykładowy kod algorytmu iteracyjnego w Pythonie, który automatyzuje
dostosowanie receptury do wymogów norm wyrobu gotowego.
Algorytm sprawdza parametry mieszanki, porównuje je z normami
i koryguje ilości składników:
```python
# Przykładowe dane surowców (nazwa, białko w %, tłuszcz w %)
surowce = {
"Śruta sojowa": {"bialko": 45, "tluszcz": 2},
"Kukurydza": {"bialko": 9, "tluszcz": 4},
"Olej roślinny": {"bialko": 0, "tluszcz": 100}
}
# Początkowa receptura (nazwa surowca: ilość w kg)
receptura = {
"Śruta sojowa": 50,
"Kukurydza": 50,
"Olej roślinny": 10
}
# Normy produktu końcowego
normy = {
"bialko": {"min": 20, "max": 25},
"tluszcz": {"min": 5, "max": 8}
}
# Funkcja do obliczenia parametrów mieszanki
def oblicz_parametry(receptura, surowce):
suma_bialka = 0
suma_tluszczu = 0
waga_calkowita = sum(receptura.values())
for surowiec, ilosc in receptura.items():
suma_bialka += ilosc * surowce[surowiec]["bialko"] / 100
suma_tluszczu += ilosc * surowce[surowiec]["tluszcz"] / 100
bialko_procent = (suma_bialka / waga_calkowita) * 100
tluszcz_procent = (suma_tluszczu / waga_calkowita) * 100
return {"bialko": bialko_procent, "tluszcz": tluszcz_procent}
# Funkcja do automatycznej korekty receptury
def dostosuj_recepture(receptura, surowce, normy, max_iteracje=10):
for iteracja in range(max_iteracje):
parametry = oblicz_parametry(receptura, surowce)
print(f"Iteracja {iteracja + 1}: {parametry}")
korekta = False
# Sprawdzenie i korekta białka
if parametry["bialko"] < normy["bialko"]["min"]:
receptura["Śruta sojowa"] += 5 # Zwiększenie ilości białka
korekta = True
elif parametry["bialko"] > normy["bialko"]["max"]:
receptura["Śruta sojowa"] -= 5 # Zmniejszenie ilości białka
korekta = True
# Sprawdzenie i korekta tłuszczu
if parametry["tluszcz"] < normy["tluszcz"]["min"]:
receptura["Olej roślinny"] += 2 # Zwiększenie ilości tłuszczu
korekta = True
elif parametry["tluszcz"] > normy["tluszcz"]["max"]:
receptura["Olej roślinny"] -= 2 # Zmniejszenie ilości tłuszczu
korekta = True
# Jeśli brak korekt, zakończ pętlę
if not korekta:
print('Receptura spełnia normy'.
break
else:
" print("Nie udało się dostosować receptury w maksymalnej liczbie iteracji.
return receptura
# Uruchomienie algorytmu
nowa_receptura = dostosuj_recepture(receptura, surowce, normy)
print("Nowa receptura:", nowa_receptura)
```
Opis działania kodu:
1. Obliczenie parametrów mieszanki: Funkcja `oblicz_parametry`
sumuje procentową zawartość składników i przelicza je na zawartość
w mieszance.
2. Korekta iteracyjna: Funkcja `dostosuj_recepture` analizuje,
czy parametry mieszanki spełniają normy.
Jeśli nie, wprowadza korekty i ponawia obliczenia w kolejnych iteracjach.
3. Kontrola zakończenia pętli: Algorytm zatrzymuje się, gdy receptura
spełni normy lub osiągnie maksymalną liczbę iteracji.
Przykład wyniku:
Dla początkowych wartości receptury, algorytm może wyświetlić:
```
Iteracja 1: {'bialko': 27.0, 'tluszcz': 12.0}
Iteracja 2: {'bialko': 23.4, 'tluszcz': 8.6}
Receptura spełnia normy.
Nowa receptura: {'Śruta sojowa': 40, 'Kukurydza': 50, 'Olej roślinny': 5}
```
9.5 Dodatkowy wariant. Optymalizacja kosztów
Aby wdrożyć optymalizację kosztów w procedurze dostosowywania receptury
algorytm może uwzględniać cenę surowców i znaleźć takie proporcje
składników, które spełniają normy produktu końcowego przy jednoczesnym
obniżeniu kosztów.
Rozbudowa kodu:
Rozszerzenie danych o koszt surowców
Dodanie do surowców informacji o cenie za kilogram:
```python
surowce = {
"Śruta sojowa": {"bialko": 45, "tluszcz": 2, "cena": 2.5}, # Cena w PLN/kg
"Kukurydza": {"bialko": 9, "tluszcz": 4, "cena": 1.8},
"Olej roślinny": {"bialko": 0, "tluszcz": 100, "cena": 5.0}
}
```
Wprowadzenie funkcji do obliczania całkowitego kosztu mieszanki
Dodanie funkcji, która wylicza koszt mieszanki na podstawie receptury:
```python
def oblicz_koszt(receptura, surowce):
koszt_calkowity = 0
for surowiec, ilosc in receptura.items():
koszt_calkowity += ilosc * surowce[surowiec]["cena"]
return koszt_calkowity
```
Rozszerzenie algorytmu o optymalizację kosztów
Korekta funkcji `dostosuj_recepture`, aby uwzględniała koszt i szukała
tańszych kombinacji składników.
Kolejn krok, który analizuje korekty w kontekście minimalizacji kosztów:
```python
def dostosuj_recepture_z_optymalizacja(receptura, surowce, normy, max_iteracje=10):
for iteracja in range(max_iteracje):
parametry = oblicz_parametry(receptura, surowce)
koszt = oblicz_koszt(receptura, surowce)
print(f"Iteracja {iteracja + 1}: Parametry: {parametry}, Koszt: {koszt:.2f} PLN
korekta = False
# Sprawdzenie i korekta białka
if parametry["bialko"] < normy["bialko"]["min"]:
receptura["Śruta sojowa"] += 5 # Dodanie tańszego składnika białkowego
korekta = True
elif parametry["bialko"] > normy["bialko"]["max"]:
receptura["Śruta sojowa"] -= 5 # Redukcja ilości
korekta = True
# Sprawdzenie i korekta tłuszczu
if parametry["tluszcz"] < normy["tluszcz"]["min"]:
receptura["Olej roślinny"] += 2 # Dodanie składnika tłuszczowego
korekta = True
elif parametry["tluszcz"] > normy["tluszcz"]["max"]:
receptura["Olej roślinny"] -= 2 # Redukcja ilości
korekta = True
# Próba zmniejszenia kosztów przez dodanie tańszego składnika
if receptura["Kukurydza"] < 60: # Kukurydza jest tańsza
receptura["Kukurydza"] += 5
korekta = True
# Jeśli brak korekt, zakończ pętlę
if not korekta:
print("Receptura spełnia normy i jest zoptymalizowana kosztowo
break
else:
print("Nie udało się dostosować receptury w maksymalnej liczbie iteracji.
return receptura
```
Przykładowy wynik:
Dla receptury:
- Śruta sojowa: 50 kg,
- Kukurydza: 50 kg,
- Olej roślinny: 10 kg,
algorytm może wyświetlić:
```
Iteracja 1: Parametry: {'bialko': 27.0, 'tluszcz': 12.0}, Koszt: 200.00 PLN
Iteracja 2: Parametry: {'bialko': 23.4, 'tluszcz': 8.6}, Koszt: 180.50 PLN
Receptura spełnia normy i jest zoptymalizowana kosztowo.
Nowa receptura: {'Śruta sojowa': 40, 'Kukurydza': 55, 'Olej roślinny': 5}
```
Uwagi dotyczące optymalizacji:
1. Balans kosztu i norm:
- Algorytm może preferować składniki tańsze, pod warunkiem, że receptura
nadal spełnia normy jakościowe.
2. Elastyczność:
- Można rozszerzyć algorytm o priorytety dla kosztów lub parametrów
na przykład kosztem obniżenia jednego parametru na rzecz drugiego.
3. Rozwój:
- W kolejnych etapach można uwzględnić dodatkowe kryteria, takie jak
dostępność surowców, minimalizacja odpadów czy wpływ na środowisko.
9.6 Rozszerzony algorytm. Optymalizacja kosztów
Rozszerzony algorytm, który uwzględnia koszty składników
i preferuje tańsze składniki podczas dostosowywania receptury.
Algorytm będzie starał się spełnić normy, jednocześnie minimalizując
koszt mieszanki poprzez optymalizację użycia tańszych surowców.
Kod Python uwzględniający koszty składników
```python
# Dane surowców: nazwa, parametry odżywcze i cena (PLN/kg)
surowce = {
"Śruta sojowa": {"bialko": 45, "tluszcz": 2, "cena": 2.5}, # Droższy składnik białkowy
"Kukurydza": {"bialko": 9, "tluszcz": 4, "cena": 1.8}, # Tańszy składnik
"Olej roślinny": {"bialko": 0, "tluszcz": 100, "cena": 5.0} # Składnik tłuszczowy
}
# Początkowa receptura (nazwa surowca: ilość w kg)
receptura = {
"Śruta sojowa": 50,
"Kukurydza": 50,
"Olej roślinny": 10
}
# Normy produktu końcowego
normy = {
"bialko": {"min": 20, "max": 25},
"tluszcz": {"min": 5, "max": 8}
}
# Funkcja obliczająca parametry mieszanki
def oblicz_parametry(receptura, surowce):
suma_bialka = 0
suma_tluszczu = 0
waga_calkowita = sum(receptura.values())
for surowiec, ilosc in receptura.items():
suma_bialka += ilosc * surowce[surowiec]["bialko"] / 100
suma_tluszczu += ilosc * surowce[surowiec]["tluszcz"] / 100
bialko_procent = (suma_bialka / waga_calkowita) * 100
tluszcz_procent = (suma_tluszczu / waga_calkowita) * 100
return {"bialko": bialko_procent, "tluszcz": tluszcz_procent}
# Funkcja obliczająca całkowity koszt mieszanki
def oblicz_koszt(receptura, surowce):
koszt_calkowity = 0
for surowiec, ilosc w receptura.items():
koszt_calkowity += ilosc * surowce[surowiec]["cena"]
return koszt_calkowity
# Algorytm optymalizacji receptury z uwzględnieniem kosztów
def dostosuj_recepture_z_kosztami(receptura, surowce, normy, max_iteracje=10)
for iteracja in range(max_iteracje):
parametry = oblicz_parametry(receptura, surowce)
koszt = oblicz_koszt(receptura, surowce)
print(f"Iteracja {iteracja + 1}: Parametry: {parametry}, Koszt: {koszt:.2f} PLN
korekta = False
# Sprawdzenie i korekta białka
if parametry["bialko"] < normy["bialko"]["min"]:
# Dodanie tańszego składnika białkowego (Kukurydza)
receptura["Kukurydza"] += 5
korekta = True
elif parametry["bialko"] > normy["bialko"]["max"]:
# Zmniejszenie ilości droższego składnika białkowego (Śruta sojowa)
receptura["Śruta sojowa"] -= 5
korekta = True
# Sprawdzenie i korekta tłuszczu
if parametry["tluszcz"] < normy["tluszcz"]["min"]:
# Dodanie tłuszczu (Olej roślinny)
receptura["Olej roślinny"] += 2
korekta = True
elif parametry["tluszcz"] > normy["tluszcz"]["max"]:
# Zmniejszenie tłuszczu (Olej roślinny)
receptura["Olej roślinny"] -= 2
korekta = True
# Jeśli brak korekt, zakończ pętlę
if not korekta:
print("Receptura spełnia normy i jest zoptymalizowana kosztowo
break
else:
print("Nie udało się dostosować receptury w maksymalnej liczbie iteracji.
return receptura
# Uruchomienie algorytmu
nowa_receptura = dostosuj_recepture_z_kosztami(receptura, surowce, normy)
print("Nowa receptura:", nowa_receptura)
```
Co zmienia ten algorytm?
1. Preferowanie tańszych składników:
- Algorytm priorytetowo zwiększa udział tańszej kukurydzy w recepturze, aby obniżyć koszt mieszanki.
- Tam, gdzie jest to możliwe, zmniejsza ilość droższej śruty sojowej
2. Ograniczenie kosztów przy zachowaniu norm:
- Optymalizacja dotyczy zarówno białka, jak i tłuszczu, ale z
uwzględnieniem ceny składników.
3. Elastyczna konfiguracja:
- W przyszłości można wprowadzić dodatkowe kryteria, np. maksymalną
dostępność surowców lub priorytety dla jakości.
Przykład wyniku:
Dla początkowej receptury i danych o kosztach składników, algorytm może wyświetlić:
```
Iteracja 1: Parametry: {'bialko': 27.0, 'tluszcz': 12.0}, Koszt: 200.00 PLN
Iteracja 2: Parametry: {'bialko': 23.4, 'tluszcz': 8.6}, Koszt: 187.00 PLN
Receptura spełnia normy i jest zoptymalizowana kosztowo.
Nowa receptura: {'Śruta sojowa': 40, 'Kukurydza': 55, 'Olej roślinny': 5}
```
Dzięki temu koszty są obniżone, a receptura spełnia wszystkie normy produktu
końcowego.
9.7 Algorytmy z większą liczbą składników
Algorytmy można dostosować do mieszanki z większą liczbą składników.
Struktura kodu jest elastyczna. Pozwala obsłużyć dowolną liczbę składników,
ponieważ operacje w algorytmie działają w pętli na wszystkich elementach
receptury i korzystają z dynamicznie dostarczanych danych.
Dostosowanie algorytmu:
1. Zmiana danych wejściowych
Dodać nowe składniki do słownika `surowce` i `receptura`.
Przykład dla 10 składników:
```python
surowce = {
"Śruta sojowa": {"bialko": 45, "tluszcz": 2, "cena": 2.5},
"Kukurydza": {"bialko": 9, "tluszcz": 4, "cena": 1.8},
"Olej roślinny": {"bialko": 0, "tluszcz": 100, "cena": 5.0},
"Pszenica": {"bialko": 13, "tluszcz": 2, "cena": 2.2},
"Jęczmień": {"bialko": 10, "tluszcz": 1.5, "cena": 1.9},
"Otręby pszenne": {"bialko": 15, "tluszcz": 4, "cena": 2.0},
"Mączka rybna": {"bialko": 65, "tluszcz": 10, "cena": 6.0},
"Mączka kukurydziana": {"bialko": 10, "tluszcz": 2, "cena": 2.8},
"Słonecznik łuskany": {"bialko": 20, "tluszcz": 8, "cena": 3.5},
"Groch łuskany": {"bialko": 25, "tluszcz": 2, "cena": 3.0}
}
receptura = {
"Śruta sojowa": 30,
"Kukurydza": 40,
"Olej roślinny": 5,
"Pszenica": 10,
"Jęczmień": 20,
"Otręby pszenne": 15,
"Mączka rybna": 5,
"Mączka kukurydziana": 10,
"Słonecznik łuskany": 5,
"Groch łuskany": 10
}
```
2. Dostosowanie obliczeń
Wszystkie funkcje (`oblicz_parametry`, `oblicz_koszt` oraz główny algorytm)
automatycznie uwzględnią większą liczbę składników, ponieważ korzystają
z pętli `for`, która przetwarza wszystkie elementy w słowniku `receptura`.
Nie trzeba zmieniać samego kodu algorytmu - działa on dynamicznie
na podstawie danych wejściowych.
Obliczanie parametrów oraz kosztu nadal będzie działać poprawnie.
3. Mechanizm preferowania tańszych składników
Aby zoptymalizować koszty przy większej liczbie składników,
można rozszerzyć algorytm tak, aby dynamicznie analizował,
który składnik jest najtańszy, i proponował jego zwiększenie.
Propozycja rozbudowy kodu:
```python
# Znajdź najtańszy składnik, który dostarcza konkretnego parametru (np. białka)
def znajdz_tanszy_skladnik(receptura, surowce, parametr, minimalna_zawartosc):
najtanszy_skladnik = None
najnizsza_cena = float('inf')
for skladnik, dane in surowce.items():
if dane[parametr] >= minimalna_zawartosc and dane["cena"] < najnizsza_cena:
najtanszy_skladnik = skladnik
najnizsza_cena = dane["cena"]
return najtanszy_skladnik
# Przyklad użycia w algorytmie
tanszy_skladnik = znajdz_tanszy_skladnik(receptura, surowce, "bialko", 10) # Minimum 10% białka
if tanszy_skladnik:
receptura[tanszy_skladnik] += 5 # Zwiększ ilość tańszego składnika
```
4. Interacyjna korekta dla większej liczby składników
Jeśli w recepturze jest wiele składników, algorytm może dynamicznie
wybrać najlepszy składnik do modyfikacji, w oparciu o cenę oraz parametry.
Każdy krok iteracyjny działa na podstawie tego samego schematu:
analiza, propozycja korekty i aktualizacja.
5. Wydajność przy dużej liczbie składników
Przy większej liczbie składników (np. 10 lub więcej) można wprowadzić dodatkowe optymalizacje:
1. Priorytety składników:
Na przykład składniki główne modyfikowane częściej, a pomocnicze rzadziej.
2. Ograniczenie zakresu zmian:
Ustaw maksymalną liczbę kilogramów, o jakie algorytm może zmienić dany składnik w jednym kroku.
3. Sortowanie składników według ceny:
Składniki są analizowane od najtańszego do najdroższego, co pomaga szybciej minimalizować koszty.
Przykład działania przy 10 składnikach
Algorytm iteracyjnie zwiększa ilość tańszych składników (np. kukurydzy lub
jęczmienia) i zmniejsza ilość droższych składników (np. mączki rybnej),
jednocześnie dbając o spełnienie norm jakościowych (np. białko i tłuszcz).
9.8 Algorytm. Uwzględnienie dostępności składnika
Uwzględnienie dostępności składnika w algorytmie wymaga dodania informacji
o jego maksymalnej dostępnej ilości w magazynie.
Algorytm będzie sprawdzał, czy proponowane zmiany w recepturze mieszczą się
w granicach dostępności danego składnika.
Rozszerzenie danych o dostępność składników
Do informacji o surowcach dodać parametr `dostepnosc`, który określa
maksymalną ilość składnika w magazynie (w kilogramach):
```python
surowce = {
"Śruta sojowa": {"bialko": 45, "tluszcz": 2, "cena": 2.5, "dostepnosc": 100},
"Kukurydza": {"bialko": 9, "tluszcz": 4, "cena": 1.8, "dostepnosc": 20")0},
"Olej roślinny": {"bialko": 0, "tluszcz": 100, "cena": 5.0, "dostepnosc": 50},
"Pszenica": {"bialko": 13, "tluszcz": 2, "cena": 2.2, "dostepnosc": 150},
"Jęczmień": {"bialko": 10, "tluszcz": 1.5, "cena": 1.9, "dostepnosc": 120},
"Otręby pszenne": {"bialko": 15, "tluszcz": 4, "cena": 2.0, "dostepnosc": 90},
"Mączka rybna": {"bialko": 65, "tluszcz": 10, "cena": 6.0, "dostepnosc": 30},
"Mączka kukurydziana": {"bialko": 10, "tluszcz": 2, "cena": 2.8, "dostepnosc": 100},
"Słonecznik łuskany": {"bialko": 20, "tluszcz": 8, "cena": 3.5, "dostepnosc": 60},
"Groch łuskany": {"bialko": 25, "tluszcz": 2, "cena": 3.0, "dostepnosc": 80}
}
```
Dodanie kontroli dostępności w algorytmie
Algorytm musi sprawdzać, czy proponowana zmiana w ilości składnika
nie przekracza jego dostępności.
Jeśli zmiana powoduje przekroczenie dostępnej ilości, algorytm powinien
wybrać inny składnik lub zmniejszyć skalę korekty.
Rozbudowany algorytm:
```python
# Sprawdzenie dostępności składnika przed modyfikacją
def czy_mozna_dodac(receptura, surowce, skladnik, ilosc_dodana):
if receptura[skladnik] + ilosc_dodana <= surowce[skladnik]["dostepnosc"]:
return True
return False
def dostosuj_recepture_z_dostepnoscia(receptura, surowce, normy, max_iteracje=10):
for iteracja in range(max_iteracje):
parametry = oblicz_parametry(receptura, surowce)
koszt = oblicz_koszt(receptura, surowce)
print(f"Iteracja {iteracja + 1}: Parametry: {parametry}, Koszt: {koszt:.2f} PLN")
korekta = False
# Sprawdzenie i korekta białka
if parametry["bialko"] < normy["bialko"]["min"]:
tanszy_skladnik = znajdz_tanszy_skladnik(receptura, surowce, "bialko", 10) # Minimum 10% białka
if tanszy_skladnik and czy_mozna_dodac(receptura, surowce, tanszy_skladnik, 5):
receptura[tanszy_skladnik] += 5
korekta = True
elif parametry["bialko"] > normy["bialko"]["max"]:
if czy_mozna_dodac(receptura, surowce, "Śruta sojowa", -5):
receptura["Śruta sojowa"] -= 5
korekta = True
# Sprawdzenie i korekta tłuszczu
if parametry["tluszcz"] < normy["tluszcz"]["min"]:
if czy_mozna_dodac(receptura, surowce, "Olej roślinny", 2):
receptura["Olej roślinny"] += 2
korekta = True
elif parametry["tluszcz"] > normy["tluszcz"]["max"]:
if czy_mozna_dodac(receptura, surowce, "Olej roślinny", -2):
receptura["Olej roślinny"] -= 2
korekta = True
# Jeśli brak korekt, zakończ pętlę
if not korekta:
print("Receptura spełnia normy i uwzględnia dostępność składników.
break
else:
print("Nie udało się dostosować receptury w maksymalnej liczbie iteracji.
return receptura
```
Działanie algorytmu
1. Sprawdzenie dostępności:
- Funkcja `czy_mozna_dodac` sprawdza, czy proponowana zmiana (zwiększenie lub zmniejszenie
ilości składnika) mieści się w dostępnych granicach.
Jeśli nie, zmiana nie zostanie przeprowadzona.
2. Preferowanie składników dostępnych w większej ilości:
- Algorytm wybiera składniki, które są bardziej dostępne, jeśli jest taka
możliwość.
3. Zatrzymanie na braku dostępnych opcji:
- Jeśli żadna zmiana nie jest możliwa ze względu na ograniczenia
dostępności, algorytm przestaje dokonywać korekt.
Przykładowy wynik
Dla receptury i ograniczonej dostępności składników, algorytm może wyświetlić:
```
Iteracja 1: Parametry: {'bialko': 18.0, 'tluszcz': 7.0}, Koszt: 210.00 PLN
Ostrzeżenie: Kukurydza jest tańsza, ale dostępna tylko w ilości 200 kg.
Iteracja 2: Parametry: {'bialko': 22.0, 'tluszcz': 7.0}, Koszt: 190.50 PLN
Receptura spełnia normy i uwzględnia dostępność składników.
```
10. Mieszalnia pasz. Oferta wdrożenia
Oferta wdrożeniowa systemu Trawers ERP dla mieszalni paszCel wdrożenia
Zapewnienie kompleksowego wsparcia dla produkcji recepturowej pasz poprzez
automatyzację procesów magazynowych, kontroli jakości, bilansowania składników
odżywczych oraz dokumentacji produkcyjnej.
Zakres funkcjonalny systemu Trawers ERP
| Moduł | Funkcje | Korzyści |
|----------------------------|-----------------------------------------------------|-----------------------------------------------------------------------------|
| MG - Gospodarka Magazynowa | Kartoteka indeksów, obsługa surowców i mieszanek | Pełna kontrola nad stanami magazynowymi i rozchodem komponentów |
| QA - Kontrola Jakości | Definicja testów, karty testów, wartości parametrów | Monitorowanie jakości surowców i zgodności gotowego produktu z normami |
| BM - Struktury Produktów | BOM, dokumenty receptur | Precyzyjne definiowanie składu mieszanek i kalkulacja kosztów jednostkowych |
Bilansowanie receptur i składników odżywczych
- Tworzenie receptur sumujących się do 1 kg
- Automatyczne obliczanie wartości odżywczych (białko, lizyna, energia, wapń itd.)
- Weryfikacja zgodności z wymaganiami jakościowymi
- Wyróżnianie odchyleń od norm (np. nadmiar fosforu)
Automatyzacja dokumentów rozchodowych
- Generowanie dokumentów rozchodu na podstawie receptury
- Uwzględnienie ilości produkcji i magazynu
- Przykład: rozchód dla 4 000 kg paszy z automatycznym przeliczeniem komponentów
Korzyści biznesowe
- Skrócenie czasu przygotowania produkcji
- Redukcja błędów ludzkich
- Zwiększenie kontroli jakości
- Przejrzystość kosztów i składników
- Możliwość automatyzacji korekt receptur
Opcje wdrożenia
| Pakiet | Zakres | Czas wdrożenia | Cena |
|----------|---------------------------------------------|----------------|-------|
| Start | MG + QA | 4 tygodnie | tel. |
| Standard | MG + QA + BM | 6 tygodni | tel. |
| Premium | Pełna konfiguracja + szkolenia + integracje | 8-10 tygodni | tel. |
NOTE: Cena zależy także od liczby użytkowników i zakresu integracji.
Kontakt i kolejny krok
* demo
* prezentacja zdalna
* szczegóły wdrożenia
Prosimy o kontakt: tres@tres.pl