Gestió òptima de l’estoc en la unitat d'emmagatzematge ...deeea.urv.cat/public/PROPOSTES/pub/pdf/922pub.pdf · Projecte Final de Carrera TITULACIÓ: Enginyeria Tècnica Industrial

Gestió òptima de l’estoc en la unitat d'emmagatzematge integrada en la cèl·lula de fabricació flexible

Projecte Final de Carrera

TITULACIÓ: Enginyeria Tècnica Industrial especialitat Electrònica Industrial

AUTOR: Víctor Manuel Vega Hoyo

DIRECTOR: Esteban del Castillo Pérez

DATA: Juny 2008.

2

1 INDEX

1 INDEX........................................................................................................................... 2

2 INTRODUCCIÓ............................................................................................................ 4

2.1 Situació i Emplaçament .......................................................................................... 5

2.2 Titular, Autor i Director.......................................................................................... 6

3 CÈL·LULA DE FABRICACIÓ FLEXIBLE ................................................................ 8

4 EL MAGATZEM AUTOMÀTIC ............................................................................... 10

4.1 Safata d’alimentació.............................................................................................. 12

4.2 Prestatgeria............................................................................................................ 12

4.3 Robot cartesià........................................................................................................ 13

4.3.1 Els eixos......................................................................................................... 13

4.3.2 Els motors ...................................................................................................... 14

4.3.3 Els sensors ..................................................................................................... 15

4.3.4 La safata central............................................................................................. 16

4.4 Quadre elèctric i condicionadors de senyals......................................................... 16

5 EL SOFTWARE.......................................................................................................... 20

5.1 Generalitats ........................................................................................................... 20

5.2 Manual de referència tècnica ................................................................................ 22

5.2.1 Gestió del magatzem ..................................................................................... 22

5.2.1.1 Funció Buscar( ) ..................................................................................... 26

5.2.1.2 Funció BuscarPeces( )............................................................................ 28

5.2.1.3 Funció Combinacio( ) ............................................................................ 29

5.2.2 Programació d’ordres .................................................................................... 36

5.2.3 Gestió d’informació....................................................................................... 37

5.2.3.1 Funció OnEstoc() ................................................................................... 38

5.2.3.2 Funció Historial() ................................................................................... 38

5.2.3.3 Gràfics .................................................................................................... 39

5.2.4 Control del moviment.................................................................................... 41

5.2.4.1 Configuració dels ports .......................................................................... 42

5.2.4.2 Lectura i control dels sensors ................................................................. 44

5.2.4.3 Lectura del chip FPGA........................................................................... 48

5.2.4.4 Control de motors................................................................................... 50

5.3 Manual d’usuari .................................................................................................... 52

5.3.1 Informació prèvia .......................................................................................... 52

3

5.3.2 Pantalla principal ........................................................................................... 53

5.3.3 Sortir .............................................................................................................. 54

5.3.4 Entrada de palets............................................................................................ 54

5.3.5 Treure palets o peces ..................................................................................... 55

5.3.6 Modificar el magatzem.................................................................................. 56

5.3.7 Control d’estoc .............................................................................................. 56

5.3.8 Historial de moviments.................................................................................. 58

5.3.9 Gràfics ........................................................................................................... 59

5.3.10 Planificació de treball .................................................................................... 60

5.3.10.1 Afegir una nova ordre. ........................................................................... 61

5.3.10.2 Eliminar una ordre.................................................................................. 62

5.3.10.3 Indicar la hora d’inici i confirmar les accions........................................ 62

5.3.10.4 Opcions de la planificació de treball. ..................................................... 62

5.3.11 “Menú” .......................................................................................................... 62

5.3.12 Funcions extres .............................................................................................. 63

5.3.13 Missatges d’error ........................................................................................... 64

5.4 Aplicacions del software....................................................................................... 65

6 PRESSUPOST............................................................................................................. 67

6.1 Consideracions inicials ......................................................................................... 67

6.2 Preus unitaris......................................................................................................... 67

6.3 Descomposició de tasques .................................................................................... 67

6.4 Descomposició del projecte .................................................................................. 67

6.4.1 C001 - Creació de la interfície d’usuari ........................................................ 68

6.4.2 C002 - Gestió del magatzem ......................................................................... 68

6.4.3 C003 - Comunicació amb la prestatgeria ...................................................... 69

6.4.4 C004 – Finalització del contracte i garantia .................................................. 69

6.5 Resum de pressupost............................................................................................. 70

7 PLEC DE CONDICIONS ........................................................................................... 72

7.1 Contracte ............................................................................................................... 72

8 ANNEX 1 – CODI DEL PROGRAMA...................................................................... 77

4

2 INTRODUCCIÓ

Aquest document descriu amb detall la part fonamental del projecte titulat “Gestió òptima de l’estoc en la unitat d’emmagatzematge integrada en la cèl·lula de fabricació flexible”.

Es pretén crear un software capaç de gestionar un magatzem matricial de dos mòduls. El magatzem gestionarà palets, que són plataformes on es col·loca el producte fabricat en la cèl·lula de fabricació flexible.

Aquests software ha de permetre a l’usuari:

• Gestionar moviments de palets al magatzem de manera manual i automàtica, tant les entrades com les sortides. A més les sortides de palets es gestionaran en funció del tipus de palet o de producte.

• Organitzar el magatzem de forma manual:

• Escollir les caselles que s’han de buidar o omplir.

• Gestionar el magatzem entre dos modes de gestió: Ràpid i econòmic .

• Moure els palets buscant un ordre que millori l’eficiència del sistema.

• Crear un llista d’ordres que realitzarà a una hora definida per l’usuari (procés batch)

• Donar informació a l’usuari:

• Control d’estoc

• Estat del magatzem.

• Emmagatzemar en un registre tots el moviments que s’hagin fet en la planta a mode d’historial, i que pugui ser fàcilment visualitzat.

• Visualitzar de manera gràfica la freqüència d’usos (histograma) de cada tipus de moviment, palet o peces.

Per poder realitzar aquest projecte s’utilitzarà un PC amb el sistema operatiu Windows 2000, amb una targeta d’adquisició de dades connectada al magatzem.

En aquest software trobarem les dues parts de l’automatització d’un magatzem: el control de motors i sensors i la gestió de les entrades i sortides del magatzem.

Partirem de dos projectes anteriors que s’han encarregat del control del moviment del robot cartesià, i ens centrarem en la gestió del magatzem en funció d’uns paràmetres que l’usuari preestablirà.

Aquest projecte estarà dividit en 5 apartats:

• La memòria descriptiva: on introduirem els magatzems automàtics i les seves aplicacions. Explicarem també el funcionament de la planta de fabricació flexible i el funcionament del magatzem.

• El programa: on començarem explicant el programa a nivell tècnic, entrant en detall en aquelles funcions més importants i com el programa realitza la

5

gestió del magatzem. Després hi haurà un manual d’usuari. I per acabar, usos d’aquest software en altres magatzems i modificacions a fer.

• El pressupost: On detallem un petit càlcul del cost del projecte.

• El plec de condicions: En aquest apartat hi haurà un petit contracte amb l’empresa que compri el programa, condicions, clàusules, garanties,...

• L’annex: on hi ha haurà una copia completa de tot el codi del programa comentat.

2.1 Situació i Emplaçament El magatzem que s’ha controlat i optimitzat, és la última estació de treball dins d’una

cèl·lula de fabricació flexible que la Universitat Rovira i Virgili disposa en el laboratori 113 de les instal·lacions de l’Escola Tècnica Superior d’Enginyeria de la Universitat Rovira i Virgili de Tarragona, ubicades al Campus Sescel·lades, amb adreça Av. Països Catalans 26 de Sant Pere i Sant Pau (Tarragona), CP: 43007. Telf. Secretaria: 977 559 708.

Figura 1. Fotografia de la universitat

Figura 2. Fotografia de la Cèl·lula de Fabricació Flexible.

6

2.2 Titular, Autor i Director El titular del projecte és la Universitat Rovira i Virgili de Tarragona; amb adreça a

C/ Escorxador, s/n de Tarragona (CP: 43003). Telèfon 977 588000 y Fax 977 588022.

L’autor del projecte és el Víctor Manuel Vega Hoyo amb NIF: 39888927-G i amb domicili a C/Ventura Gassol 12 1è 2a de La Selva del Camp (Tarragona) amb CP 43470.

El director del projecte és l’Esteban del Castillo Pérez amb adreça a l’Escola Tècnica Superior d’Enginyeria de la Universitat Rovira i Virgili de Tarragona; situada al Campus Sescel·lades; amb adreça: Av. Països Catalans núm. 26; CP 43007 de Tarragona. Telèfon 977 559628.

8

3 CÈL·LULA DE FABRICACIÓ FLEXIBLE

Una cèl·lula de fabricació flexible(CFF) és un grup de màquines que treballen sobre un producte o diversos, és a dir, que diferents màquines realitzen parts en la fabricació d’un producte. En el nostre cas, disposem d’una CFF encarregada de fabricar pistons de simple efecte, verificar el correcte funcionament i emmagatzemar-los en un magatzem automàtic.

La CFF està dividida en 3 mòduls, tal i com es pot veure en la Figura 3:

Figura 3. Esquema de la CFF

• MÒDUL DE FABRICACIÓ: Aquest mòdul es l’encarregat de fabricar els pistons de simple efecte. Està dividit en 4 estacions de treball. La primera estació s’encarrega de col·locar damunt de la cinta transportadora una de les tres classes de camises dels pistons. La segona estació hi col·loca un dels dos tipus d’èmbols en funció del color i material de la camisa, i una molla. La tercera estació de treball s’encarrega de posar la culata amb tancament de baioneta. La darrera estació és l’encarregada de verificar el funcionament del pistó. La Figura 4 mostra el diagrama de muntatge dels 3 tipus de pistons.

Figura 4. Esquema de muntatge dels pistons

9

• MÒDUL D’ENLLAÇ: El mòdul d’enllaç, és l’encarregat d’identificar i emmagatzemar els diferents pistons que hagin passat la prova de verificació. A més, també serà l’encarregat de subministrar els pistons necessaris en funció de la demanda de l’usuari. Aquests pistons, els col·locarà dins d’una cinta transportadora que els durà al mòdul d’emmagatzematge.

Figura 5. Fotografia del mòdul d’enllaç

• MÒDUL D’EMMAGATZEMATGE: Aquest és l’últim mòdul del procés i està dividit en dues zones. La primera zona és la encarregada de paletitzar els pistons, és a dir, col·locar-los en grups de, com a màxim, 3 pistons i dipositar-los en un palet que serà transportat a la segona zona, un magatzem automàtic. Aquest magatzem ha de ser capaç de tenir un control de tot el material que hi ha dins i gestionar les entrades i les sortides dels palets per tal de poder tenir un sistema eficient i ràpid.

Figura 6. Fotografia del mòdul d’emmagatzematge

10

4 EL MAGATZEM AUTOMÀTIC

Des de sempre, l’home ha tingut la necessitat de fer-se la vida més fàcil i còmode, és per això que la història es ha donat a molts científics que gràcies als seus invents, avui disposem de tots els avenços tecnològics que coneixem.

Amb la invenció dels primers transistors i a posteriorment, els primers ordinadors, l’home ha volgut deixar a aquests aparells, fer una gran quantitat de tasques pesades, repetitives i complexes, ja que el seu disseny els permet fer en segons operacions que per als humans ens suposaria una gran despesa de temps.

Una de les últimes aplicacions dels ordinadors és el control de processos industrial i de certs serveis del sector terciari. Aquests sistemes de gestió i control també han arribat a la logística i, com és el cas i objectiu d’aquest projecte, a controlar i gestionar un magatzem.

Un magatzem automàtic, respecte un de convencional, ens dona unes clares avantatges com són, entre d’altres:

• Reducció de personal.

• Reducció de temps.

• Major eficàcia en el control d’estocs i una gestió més precisa.

• Augment de la competitivitat.

• Reducció de despeses energètiques.

Tot i que un magatzem automàtic, sembla tot avantatges, s’ha de reconèixer que la despesa inicial és molt superior a un sistema manual, però les avantatges fan que el sistema pugui ser fàcilment amortitzades.

Veient aquestes avantatges, no és d’estranyar que cada cop més puguem veure més magatzems automàtics, no només en la aplicació industrial, sinó que també en certs serveis del sector terciari. Els podem trobar pel carrer per controlar un supermercat, una farmàcia, o fins i tot un aparcament de cotxes o de bicicletes o fins i tot, com és el cas de l’aeroport del Japó, per controlar els equipatges i carregues dels avions.

Figura 7. Fotografia d’un magatzem automàtic en la indústria

11

Figura 8. Fotografia d’un magatzem automàtic per a un aparcament

Figura 9. Fotografia d’un magatzem automàtic per a una farmàcia

Centrant-nos més en l’objectiu d’aquest projecte, disposem d’un magatzem automàtic que gestionarà les entrades i sortides de palets format per dues prestatgeries de 6 alçades cadascuna i 6 caselles en cada alçada, és a dir, 72 posicions en total.

En la part central, entre les dues prestatgeries hi ha un robot cartesià, capaç de moure’s en els dos eixos X i Y, per tal de situar-se en qualsevol punt de la prestatgeria. A més la safata central, també es pot moure en l’eix Z per poder agafar palets d’ambdós costats.

Aquesta safata és la encarregada de moure els palets per dins del magatzem, però per entrar i treure els palets de la cinta transportadora, es disposa d’un sistema pneumàtic de dos pistons de doble efecte.

A continuació veurem totes aquestes parts amb una mica més de detall.

12

4.1 Safata d’alimentació Per tal de poder agafar els palets de la cinta transportadora o deixar-los, el magatzem

té un sistema pneumàtic format per dos pistons de doble efecte, un per cada eix de moviment (x i y), i amb un parell de sensors magnètics per determinar la posició i poder fer un correcte funcionament.

Figura 10. Fotografia de la safata d’alimentació

4.2 Prestatgeria En la Figura 11, es pot veure un esquema de la planta on es poden veure les 72

caselles possibles on emmagatzemar palets, distribuïdes en dos mòduls de 6 alçades i 6 posicions en cada alçada.

Figura 11. Fotografia de la prestatgeria

A més totes les caselles estan numerades des de l’1, fins al 36 per al mòdul 1 i del 37 al 72 per al mòdul 2.

La forma de cada casella, està pensada per a que la safata central pugui dipositar o treure els palets de les caselles.

13

4.3 Robot cartesià Com ja s’ha comentat anteriorment, entre els dos mòduls de prestatgeries, existeix un

robot capaç de moure’s lliurement en l’espai X,Y del magatzem, gràcies a un sistema de dos eixos amb un motor en cadascun d’ells.

Figura 12. Fotografia del robot cartesià

Per al control de posició, cada motor disposa d’un encoder per controlar la posició i d’un reductor per reduir la velocitat i guanyar parell motor i precisió. A més, en els eixos, trobem un seguit de sensors de presència, sensors magnètics i micro-interruptors, que ens serviran per al control del sistema.

Vegem a continuació les diferents parts.

4.3.1 Els eixos Dos eixos de desplaçament són els encarregats de moure la safata central per tot

l’espai del magatzem. Aquest espai be definit per un conjunt de sensors als finals de cada eix, que el delimiten.

Aquests eixos capaços de moure la safata central, gracies a un sistema de corretges dentades que corren per l’interior de cada eix.

Cada eix està controlat per un motor situat en un dels extrems de cada eix. A més en l’eix X , l’encarregat de moure l’eix vertical, trobem que els extrems de l’eix Y està unit per un sistema de corretges i politges per tal de que els dos extrem de l’eix vertical rebin la força del desplaçament i s’evitin així el possible mal funcionament en la part superior. En la Figura 13 es pot veure el funcionament d’aquestes corretges.

14

Figura 13. Fotografia de les corretges i politges

4.3.2 Els motors En cadascun dels eixos trobem un motor per donar moviment al sistema, tal i com

hem dit anteriorment. Cada motor està format pel motor pròpiament dit, un encoder i un reductor. En la Figura 14 podem veure una imatge del motor i les tres parts.

Figura 14. Fotografia del motor

Comencem a parlar del motor de corrent continua que és l’encarregat del moviment de cada eix. Aquests motors que trobem en cada eix, tenen una velocitat nominal de 3100 revolucions per minut. Però tota aquesta velocitat angular no es transfereix directament als eixos, ja que primer trobem un reductor.

La missió del reductor és, com la pròpia paraula indica, reduir la velocitat del motor i a la vegada, es guanya força i de manera indirecta, el sistema esdevé més eficaç en la precisió de moviments. En el cas d’aquest magatzem, la reducció és de 20.25, és a dir, que per cada 20,25 voltes del motor, l’eix de sortida del reductor, girarà 1 volta.

15

Els encoders1 són els encarregats d’informar-nos de la canvi de posició dels motors i, a conseqüència, del moviment dels eixos. En el cas d’aquest projecte, aquest encoder te una resolució de 500 polsos per volta en els dos canals que té. Aquestes senyals estan desfasades 90º elèctrics, per tant, en una volta tenim 2000 polsos.

Amb tot això, podem calcular que aproximadament el sistema te una precisió de 1.551µm en els dos eixos.

4.3.3 Els sensors Cada eix disposa de diversos sensors de presència col·locats en els extrems. Primer

trobem dos sensors magnètics en cada extrem.

Com s’ha comentat abans, els encoders del sistema són del tipus incrementals, per tant només ens informen del desplaçament, però no de la posició, és per això que aquests sensors s’utilitzen per a la calibració del sistema.

En el cas de que els sensors fallin o que el programa no gestioni bé la informació, existeixen uns micro-interruptors al final, encarregats de controlar la posició màxima de cada eix. Aquests estan connectats directament a la alimentació del magatzem, d’aquesta manera afegeixen una seguretat en el sistema. Aquesta distància és la màxima de cada eix, el sistema no hauria d’arribar mai a aquesta posició, en el cas de que detectin, els motors es desconnecten automàticament.

En la Figura 15 podem veure una imatge dels dos tipus de sensors.

Figura 15. Fotografia dels sensors magnètics i el micro-interruptor

1 Un encoder és un sensor capaç de convertir el moviment angular d’un eix en polsos elèctrics. En el

cas específic d’aquest projecte, l’encoder és de tipus òptic incremental.

16

4.3.4 La safata central Enganxat a l’eix vertical, trobem la safata central. Una safata que es pot moure cap

als dos costats per a poder agafar i deixar palets a ambdós mòduls. Aquesta safata està formada per una plataforma que corre per damunt de dues guies telescòpiques que s’estenen per tal de fer arribar la plataforma a la posició desitjada.

Per al control de moviment d’aquesta safata, tenim un motor DC i per al control de posició tenim 3 sensors de presència distribuïts al llarg de la guia telescòpica, per poder saber si la safata es troba al centre o en un dels laterals, i a més, dos sensors òptics, encarregats d’informar de l’estat de la casella en la que es vol actuar.

Figura 16. Fotografia de la safata central

Figura 17. Fotografia dels sensors de la safata central

4.4 Quadre elèctric i condicionadors de senyals Com en tota màquina que funcioni amb energia elèctrica, existeix un quadre on es

connecten totes les entrades, sortides, etc, per tal de poder tenir en un mateix lloc tot el necessari per al control de la màquina.

17

Figura 18. Fotografia del quadre elèctric

En el nostre cas, sota del magatzem tenim aquest quadre on hi arriben totes les senyals dels sensors i les alimentacions dels motors, distribuïdors pneumàtics,... A més, tal i com s’ha dit anteriorment, també trobem els circuits de condicionament de senyals per als encoders i la targeta controladora en 4 quadrants per als motors.

També trobem un seguit de relés, encarregats del moviment de la safata central del robot cartesià.

Un cop tenim totes les entrades i sortides, les senyals que ens interessen, les connectem al ordinador per tal de poder fer el control amb el PC. Per fer-ho, existeix una targeta de connexió PCI-DAS6025 per entrades i sortides analògiques i digitals.

Figura 19. Fotografia de la targeta PCI i les targes de connexió CIO-MINI50

Abans de poder connectar les entrades i sortides necessàries, necessitem un circuit de condicionament de les senyals per tal de que la targeta pugui funcionar sense cap mena de perill a fer-se mal bé.

18

Figura 20. Fotografia dels circuits de condicionament

Tenim 3 circuits de condicionament:

• Pels actuadors: Aquest circuit fa que a partir d’un ‘1’ lògic, obtinguem 24V que és la tensió necessària per activar les electrovàlvules o els relés.

• Pels sensors: Al revés que el circuit anterior, aquest converteix els 24V provinents dels sensors, a una tensió màxima de 5V per a l’1 lògic.

• Pels encoders: Com ja havíem comentat abans, els encoders passen per un circuit condicionador que transforma les dues senyals de l’encoder (0-24V) en 4 senyals (0-5V). El circuit de condicionament, el que fa es comptar els polsos provinents de l’encoder i donar al ordinador, un número de 16 bits per a cada motor. Aquestes senyals no es connecten directament a la targeta, sinó que primer hi ha un chip FPGA encarregat de contar polsos i descomptar. Més endavant es parlarà amb més detall d’aquest circuit. En el nostre cas, s’ha reduït el comptatge de polsos2 obtenint una precisió al final d’aproximadament 0.1mm

Com s’ha comentat en el punt 4.3.2, el magatzem te una precisió de moviment de 1.551µm per cada pols de l’encoder.

2 Només es compta una senyal d’encorder (500polsos) i del comptatge perdem les 16 primers comptes

20

5 EL SOFTWARE

5.1 Generalitats Ara que coneixem ja tota la planta, començarem amb el programa que s’ha creat per

tal de poder fer una correcte gestió del magatzem.

Es pretén fer un programa que sigui capaç de gestionar un magatzem automàtic. Aquest magatzem funcionarà de manera matricial, és a dir, les caselles es reparteixen en files i columnes i en aquest cas, distribuïdes en dos mòduls. S’ha de crear un programa que permeti a l’usuari interactuar amb el programa amb una interfície senzilla i intuïtiva, que li deixi entrar els palets, treure’ls, i moure’ls.

Figura 21. Fotografia de connexió PC-Magatzem

A més el programa ha de poder informar a l’usuari en tot moment de l’estoc actual del magatzem i dels moviments realitzats en un període de temps concret i, de manera gràfica, uns diagrames on es pugui veure la freqüència dels moviments, de l’ús dels palets i de les peces, en un període de temps definit per l’usuari. Tota aquesta informació, ha de permetre a l’usuari millorar la gestió del magatzem així com facilitar la presa de decisions i fins i tot corregir errades en la gestió.

El programa també ha de permetre a l’usuari programar unes tasques a realitzar a partir d’una hora concreta que serà definida per l’usuari.

Per últim el programa ha de permetre a l’usuari escollir el mode de gestió del magatzem entre dos modes:

Gestió ràpida: Aquest mode de funcionament, configura al programa per a que realitzi les gestions per obtenir un sistema ràpid quan es treuen o entren palets. Per fer-ho el sistema buscarà sempre el recorregut més curt.

Gestió econòmica: Aquest segon mode de funcionament, configura al programa per a que gestioni el magatzem de manera que el consum energètic sigui el menor possible. Això ho farà buscant el recorregut que suposi una despesa energètica menor.

Per a la realització d’aquest software s’ha utilitzat un PC amb el sistema operatiu Windows 2000. El software dissenyat s’encarrega del control i gestió del magatzem tot i que aquest sistema operatiu no seria el més adequat per a la realització de projectes de control perquè és un sistema operatiu incapaç de garantir els temps, a més per a un correcte

21

funcionament de la planta, el temps de mostreig de la planta, hauria de ser inferior al que el Windows ens pot oferir. Per a un control de posició més precís i fiable, seria interessant utilitzar un sistema més eficaç en el control de temps (RTOS). Per a la part de gestió del programa, aquest sistema operatiu no ha suposat cap impediment.

El software que s’ha creat, ha estat programat utilitzant el compilador Visual C++. S’ha escollit aquest compilador perquè permet crear programes amb els que es pot treballar a molt baix nivell i a la vegada crear entorns gràfics per a l’usuari del programa. A més, com que Windows és un sistema operatiu bastant utilitzat, s’ha escollit el Visual C++ com a llenguatge, perquè permet crear interfícies d’usuari molt senzilles i intuïtives.

Com ja s’ha comentat anteriorment, totes les senyals dels sensors i actuadors necessàries, estan connectades a l’ordinador mitjançant la targeta d’adquisició de dades PCI-DAS6025.

Figura 22. Esquema de connexió PC-Magatzem

Aquesta targeta està connectada als sensors i actuadors necessaris mitjançant els circuits comentat en el punt 4.4. i dels quals obtenim tota la informació necessària de la planta i donem totes les ordres oportunes.

Ja que actualment, no funciona correctament la comunicació entre els diferents mòduls de la CFF, s’ha optat per fer un programa manual, on l’usuari del programa serà l’encarregat de donar tota la informació necessària pel programa provinent de l’exterior. Per exemple s’haurà d’informar si la bandeja de sortida està buida o quin és el tipus de palet que entrarà al magatzem.

En un sistema automàtic, seria el propi sistema qui gestionaria de manera autònoma aquestes dades. La planta de Sescel·lades està preparada per a què el sistema SCADA gestioni el magatzem, però actualment no està operativa la comunicació entre els diversos mòduls i és per això que s’ha optat per fer el programa manual.

Aquesta part de la memòria es divideix en tres apartats. El primer apartat serà una explicació del programa a nivell de codi. S’explicaran les funcions més importants utilitzades en aquest programa que fan possible el funcionament. El segon apartat serà un manual d’usuari on s’explicarà el funcionament del programa a nivell d’usuari, la funcionalitat de tots els botons i de tot el que l’usuari del programa ha de saber. Per últim es troba un apartat on es parla de les aplicacions d’aquests programa i com s’hauria de modificar perquè pogués servir per un altre magatzem.

22

5.2 Manual de referència tècnica En aquest apartat es parlarà del programa a nivell de codi. Es farà una explicació de

les funcions més importants que fan possible el funcionament d’aquest programa i del magatzem.

Aquest manual s’ha estructurat en 5 parts:

• Gestió del magatzem

• Programació d’ordres

• Gestió d’informació

• Control del moviments

5.2.1 Gestió del magatzem Aquest programa s’ha dissenyat per a un magatzem matricial on les caselles es

distribueixen en forma de files i columnes. Per treballar amb totes elles, s’ha creat una matriu de 3 dimensions. La primera indica el numero del mòdul (0 o 1), la segona dimensió indica la fila i la tercera la columna. D’aquesta manera amb una variable tenim totes les dades necessàries del magatzem. En cada posició de la variable es guarda el tipus de palet que s’hi troba.

Existeixen 64 tipus de palets resultat de la combinació dels 3 tipus de pistons. En la següent taula es mostra la codificació utilitzada en el programa i una representació gràfica de cadascun dels palets.

Tipus Contingut Tipus Contingut Tipus Contingut Tipus Contingut

de del de Del de del de del

Palets palet

Palets Palet Palets palet Palets palet

0 16 32 48 1 17 33 49 2 18 34 50 3 19 35 51 4 20 36 52 5 21 37 53 6 22 38 54 7 23 39 55 8 24 40 56 9 25 41 57 10 26 42 58 11 27 43 59 12 28 44 60 13 29 45 61 14 30 46 62 15 31 47 63

Taula 1. Tipus de palets

23

A més a més dels 64 tipus de palets descrits en la figura anterior, s’ha reservat el tipus 64 per indicar una posició buida. Cal diferenciar-ho del tipus de palet 0, ja que aquest tipus de palet si que conté un palet, però no hi ha cap pistó en ell.

Una altra cosa a tenir en compte és el sistema de referència del programa. Ja que el software ha estat dissenyat per a la gestió del magatzem, el sistema de referència que s’ha pres, ha estat des del punt de vista d’aquest. Per tant, quan es parla d’entrar palets, vol dir, que un palet entra de l’exterior al magatzem i el cas invers es definiria com a sortida de palets.

A partir d’aquestes dades com a punt de partida, comencem amb l’organització del magatzem. Com ja s’ha comentat abans, el programa està dissenyat per permetre, entre d’altres funcions, entrar palets al sistema, treure’n i moure’n

Entrar palets Una de les opcions més importants a controlar, és l’entrada de palets al magatzem.

En un sistema de fabricació totalment automatitzat, les entrades de palets, serien controlades pel propi sistema. Ja que ara mateix no es pot realitzar la comunicació amb la resta de la CFF, la informació necessària l’haurà de facilitar l’usuari del programa.

Aquesta part del software és l’encarregada de gestionar les entrades al magatzem i per fer-ho segueix el següent diagrama de flux.

Diagrama 1. Funcionament d’entrada de palets

Usuari

Verificar el tipus de palet

Automàtic / Manual?

Buscar casella buida

Verificar la casella destí

Introduir palet

Usuari

Correcte

Incorrecte

Correcte

Incorrecte

Manual Automàtic

Inici

FI

Introdueixi el tipus de palet

Introdueixi la casella destí

24

Com es pot veure en el diagrama anterior el programa dona l’opció a l’usuari entre una entrada de palets automàtica o manual.

En la opció “manual”, l’usuari introdueix la casella on s’ha de guardar el palet que entra i el tipus de palet que entra segons la taula. El programa verificarà que la informació introduïda sigui correcte i la casella estigui buida. En el cas que tota la informació sigui correcte, enviarà les ordres al magatzem per moure el robot.

En canvi, si s’escull la opció “automàtic”, l’usuari només ha d’informar del tipus de palet que entra, ja que el programa serà el responsable de buscar una casella buida on col·locar el palet. Per realitzar aquesta tasca s’ha creat la funció Buscar() que més endavant es detallarà.

Treure palets Ja hem vist com el programa controla les entrades de palets al magatzem, vegem ara

el cas contrari, com el programa s’encarrega de gestionar la sortida de palets. Al igual que en el apartat anterior, el codi creat necessita que l’usuari li doni tota la informació necessària.

Donat els diversos tipus d’indústria i la manera de treballar de cadascuna d’elles, aquesta part del codi permet a l’usuari definir que vol treure del magatzem. Pot escollir entre treure un palet situat en una casella concreta, treure un tipus de palet, però la ubicació d’aquest ens és igual o demanar al programa que necessitem una quantitat de pistons d’una classe concreta i el programa buscarà una combinació de palets en els que trobem la quantitat de pistons demanada. L’ús d’una opció o d’una altra dependrà del funcionament de l’empresa, ja que per exemple, si una empresa treballa per productes, interessarà més buscar en el magatzem el producte que es vol vendre. En canvi si l’empresa treballa per paquets o lots de productes, interessarà més buscar en el magatzem per tipus de palets.

A continuació podem veure un diagrama del funcionament d’aquesta part del programa per a cada opció possible.

• OPCIÓ 1: Treure palets d’una casella concreta.

Diagrama 2. Opció 1

Usuari

Verificar la casella

Correcte

Incorrecte

Opció 1: Treure palet de casella

Treure palet

Inici

Introdueixi la casella

Fi

25

Per treure un palet d’una casella concreta, el codi simplement verifica que la casella seleccionada contingui un palet. Si tot es correcte, el programa dona les ordres per treure aquell palet.

• OPCIÓ 2: Treure palets en funció del tipus no de la ubicació.


En aquesta part del codi, el programa s’encarrega de treure un palet d’un tipus concret, independentment de la ubicació del palet. Per fer-ho es torna a cridar a la funció Buscar( ) (comentada una mica més endavant), a la qual li donem el tipus de palet a buscar i treu el palet més proper del tipus desitjat.

Usuari


Correcte

Incorrecte

Opció 2: Treure tipus palet

Buscar el tipus de palet

Trobat

No Trobat

Treure palet

Inici

Introdueixi el tipus de palet

Fi

26

• OPCIÓ 3: Treure una quantitat de productes


Aquesta part de codi és una de les més complertes i alhora complicades del programa. Funciona en dos parts.

La primera, al igual que en la opció 2, el programa busca palets, la diferència es que ara busca tots els tipus de palets que continguin algun del tipus de pistó demanat. Aquesta funció s’anomena BuscarPeces( ).

La segona part s’encarrega de buscar una combinació del menor nombre possible de palets, per tal d’obtenir la quantitat de peces desitjada. Per fer-ho existeixen dues funcions combinacio ( ) i minim( ).

A continuació s’explicaran millor aquestes funcions que s’han anomenat en aquest apartat

5.2.1.1 Funció Buscar( ) int CMAGATZEM1Dlg::Buscar(int palet)

Codi 1. Declaració de la funció Buscar()

Aquesta funció és l’encarregada de buscar totes les caselles que hi hagin del tipus indicat. Per cridar aquesta funció, se li donarà el palet que busquem i ella retornarà un 1 si ha trobat palets o un 0 si no ha trobat cap palet. A més, omplirà un vector d’enters (CasellesTrobades[72] variable global) amb totes les caselles que siguin del tipus desitjat.

Usuari


Correcte

Incorrecte

Opció 3: Treure tipus peces

Buscar palets i combinar-los

Correcte

No hi ha combinació

possible

Treure palet

Introdueixi el tipus de peces i

quantitat

Fi

Inici

27

Aquesta funció està dissenyada per a què a més de buscar les caselles que continguin el palet, les guardi de manera ordenada segons el mode de funcionament. És a dir, si el mode de funcionament seleccionat és un sistema ràpid, el programa ordenarà les caselles de menor a major distància respecte a la safata d’entrada i sortida, en canvi, si el sistema està en mode econòmic, ordenarà els palets en funció del consum necessari per anar fins a aquella casella.

En canvi, si el mode de funcionament és un sistema econòmic, el programa ordenarà els palets en funció del consum dels motors, de menor a major consum. En aquest cas l’ordre respecte el cas anterior, pot variar. L’ordre en aquest cas depèn de la relació entre els consum dels motors en moviment sobre l’eix X respecte al moviment sobre l’eix Y. Aquesta relació també pot ser programada per l’usuari del programa.

El codi d’aquesta funció és el següent: int CMAGATZEM1Dlg::Buscar(int palet) { int i,j,m,dist,c=0,a,ni,nj,nm,vi,vm,vj,min,max,trobat=0; int DIMX=6,DIMY=6; int x=13,y=13; CString text,nr; min=-1; max=DIMX*x+DIMY*y; for(c=0;c<(2*DIMX*DIMY);c++){ //nº d'iteracions for(i=0;i<DIMY;i++){ //files for(j=0;j<DIMX;j++){ //columnes for(m=0;m<2;m++){ // modul 1 i 2 if(magatzem[m][i][j]==palet){ dist = Distancia(i,j,m); // es calula la distància if(dist==min){ if(i!=vi||j!=vj||m!=vm){ CasellesTrobades[c]=casella(i,j,m); //guardem la casella if(trobat==0){ trobat=1; } c++; } }else if(dist>min){ if(dist<=max){ max=dist; ni=i; nj=j; nm=m; } } } } } } min=Distancia(ni,nj,nm); max=DIMX*x+DIMY*y; if(vi==ni&&vj==nj&&vm==nm){ for(a=c;a<72;a++){ CasellesTrobades[a]=0; //omplim la resta del vector amb 0 } c=72; }else{ vi=ni; vj=nj; vm=nm;

28

if(magatzem[nm][ni][nj]==palet){ if(trobat==0){ trobat=1; } CasellesTrobades[c]=casella(ni,nj,nm); //guardem la casella } } if(min==-1) c=72; } return(trobat); }

Codi 2. Codi de la funció Buscar()

Si ens hi fixem, veiem que el programa recorre totes les posicions de les dues matrius buscant la distancia o el consum més petit. Aquesta passada la realitza tantes vegades com el màxim de caselles té el magatzem, en aquest cas 72.

5.2.1.2 Funció BuscarPeces( ) int CMAGATZEM1Dlg::BuscarPeces(int producte)

Codi 3. Declaració de la funció BuscarPeces()

La base d’aquesta funció és exactament igual a la funció Buscar( ), però aquesta funció no busca un palet concret, sinó que busca tots els palets que continguin el tipus de pistó demanat.

int CMAGATZEM1Dlg::BuscarPeces(int producte) { int i,j,m,dist,c=0,a,ni,nj,nm,vi,vm,vj,min,max,trobat=0,quantitat; int DIMX=6,DIMY=6; int x=13,y=13; CString text,nr; min=-1; max=DIMX*x+DIMY*y; for(c=0;c<(2*DIMX*DIMY);c++){ //nº d'iteracions for(i=0;i<DIMY;i++){ //files for(j=0;j<DIMX;j++){ //columnes for(m=0;m<2;m++){ // modul 1 i 2 quantitat=coincideix(magatzem[m][i][j],producte); // mirem si el palet conté pistons dels desitjats if(quantitat){ dist = Distancia(i,j,m); //calculem distància if(dist==min){ if(i!=vi||j!=vj||m!=vm){ CasellesTrobades[c]=casella(i,j,m); //guardem la casella en el vector QuantitatCasellesTrobades[c]=quantitat; //guardem la quantitat de peces en el vector if(trobat==0){ trobat=1; } c++; } }else if(dist>min){ if(dist<=max){ max=dist; ni=i; nj=j; nm=m;

29

} } } } } } min=Distancia(ni,nj,nm); max=DIMX*x+DIMY*y; if(vi==ni&&vj==nj&&vm==nm){ for(a=c;a<72;a++){ //omplim la resta del vector amb 0 CasellesTrobades[a]=0; QuantitatCasellesTrobades[a]=0; } c=72; }else{ vi=ni; vj=nj; vm=nm; quantitat=coincideix(magatzem[nm][ni][nj],producte); if(quantitat){ if(trobat==0){ trobat=1; } //Guardem en el vector la nova casella CasellesTrobades[c]=casella(ni,nj,nm); QuantitatCasellesTrobades[c]=quantitat; } } if(min==-1) c=72; } return(trobat); }

Codi 4. Codi de la funció BuscarPeces()

Si ens hi fixem be, veiem que el programa retorna un 1 o 0 depenen si ha trobat palets o no amb el tipus de pistó demanat respectivament.

Tots els palets que troba els guarda, al igual que la funció Buscar( ), en el vector d’enters (CasellesTrobades[64]), però a més també utilitza un segon vector d’enters de forma paral·lela (QuantitatCasellesTrobades[64] variable Global). En aquest segon vector guarda, amb el mateix índex que en el vector CasellesTrobades, la quantitat de pistons que hi han en la casella que ha trobat.

5.2.1.3 Funció Combinacio( ) int CMAGATZEM1Dlg::combinacio(int index1, int index2, int

*VectTreure, int *VectAux, int falten, int necesari, int primari)

Codi 5. Declaració de la funció Combinacio()

Una vegada hem s’ha executat la funció BuscarPeces(), podem començar a buscar una combinació de palets que amb la menor distància o consum, s’obtingui com a mínim el nombre de peces indicat.

Per trobar la combinació de palets, no s’ha atacat aquesta tasca de cop, sinó que el problema s’ha dividit en petits codis. En el següent diagrama de flux, es detalla quina és el funcionament del programa per trobar la combinació idònia.

30

Diagrama 5. Funcionament de la funció Combinació()

En un primer pas, busquem combinacions d’1 palet, de dos,..., de 15 palets que ens donin les peces que volem amb la menor distància possible. Després comparem totes aquestes combinacions en busca de la que tingui la menor distància o consum i és aquesta combinació la que farem servir.

En aquest punt és on entra en joc la funció Combinació(). Aquesta funció és l’encarregada de trobar una combinació donat un nombre de palets i un nombre de peces.

Per trobar aquesta combinació s’ha creat una funció redundant que redueix el problema fins a la mínima expressió per resoldre-la.

…

Inici

Buscar combinació d’1 palet

Buscar combinació d’2 palets




Buscar de les combinacions anteriors la de la

Fi

31

Diagrama 6. Funcionament de la funció Combinacio()

Aquest funció parteix d’un vector (CasellesTrobades[64]) on estan totes les caselles que es poden utilitzar per trobar la millor combinació de palets. El primer pas, és esbrinar quina quantitat de peces es necessiten en la combinació. Llavors tenim dos opcions, que necessitem una peça o que necessitem més d’una.

En el cas de només necessitar una peça, el programa crida a la funció mínim( ) que retorna quina es la casella de tot el vector, amb la distància més petita i que tingui la quantitat, com a mínim, de peces que volem.

En canvi, si el programa necessita trobar una combinació amb més d’una peça, guarda la primera casella del vector en un vector auxiliar i s’autocrida (funció redundant) per resoldre un nou problema. En aquest cas, la nova funció Combinació( ), repetirà els passos anterior, però ara la informació que rebrà serà diferent. El vector que utilitzarà, serà el mateix però amb la casella que hem guardat de menys, d’aquesta manera evitem que repeteixi caselles el programa. La quantitat de peces que necessitarem ara serà, les que necessitàvem abans menys las que té la casella que hem guardat. I finalment, la nova funció haurà de buscar una combinació d’un palet menys que la funció master.

Vegem-ho amb un petit exemple.

Imaginem un vector de 3 caselles:

Informació necesaria:

- quantitat de palets en la combinació

- peces necesaries

- vector de caselles trobades

La quantitat de peces

= =1?

Buscar el palet amb la menor distancia que tingui les peces

necessàries en el vector que reb. (funció mínim)

Retorna el palet trobat

(FI)

Es guarda la primera casella i es crida a la funció combinació:

DADES:

- Quantitat de palets = quantitat de palets -1

- Peces necesaries = Peces necesaries – peces de la casella guardada

- Vector de caselles trobades = Tot el vector de caselles trobades – casella guardada

Guarda el vector de palets i el retorna com a resultat de la crida.

(FI)

Inici

32

Índex 0 1 2

Casella 15 26 36

Quantitat de peces 2 1 3

Distància(cm) 52 65 130

Taula 2. Vector d’exemple

Ara buscarem una combinació de 2 palets amb 3 peces i cridem a la funció combinació( ), amb el vector descrit abans.

El primer que fa la funció és mirar quina quantitat de peces necessitem per la combinació. En el nostre cas és de 2, per tant tornem a cridar a la funció combinacio3( ) Abans guardarem la primera casella (15) en un vector auxiliar i enviarem aquest nou vector.

Índex 1 2

Casella 26 36

Quantitat de peces 1 3

Distància(cm) 65 130

Taula 3. Vector que es passa a la funció combinacio2()

En realitat, no es passa tot el vector, sinó que es passa només un índex que recorre tot el vector. La nova funció utilitzarà del vector sencer, només des de l’índex fins al final de la variable.

Un cop cridada la funció combinació2( ), realitzarà el mateix que la funció master, però aquest cop el programa haurà de buscar en aquest nou vector, una combinació d’1 palet amb 1 peça com a mínim4.

A partir d’aquí tornem a repetir el procés. Primer mirem si la quantitat de peces necessària és igual a 1. En aquest cas, com és afirmatiu, cridarem a la funció minim( ), que ens donarà la casella amb la distància més petita i que tingui com a mínim les peces que vulguem. En el nostre cas, la funció mínim() ens donarà la casella 26.

Finalment el vector final que tindrem serà:

Índex 0 1

Casella 15 26

Quantitat de peces 2 1

Distància(cm) 52 65

Taula 4. Vector final resultat de la combinació de 2 palets.

Si es repeteix la funció Combinació() amb el mateix vector, per una combinació d’1 i de 3 palets, es tindran aquestes 3 combinacions.

3 La segona funció combinacio(), s’anomenarà combinacio2 per diferenciar-les. 4 Les peces necessàries són una menys que en la funció anterior, i la quantitat de peces actuals són les

de la funció anterior menys la quantitat de la casella que ens hem guardat.

33

Combinació de peces 1 2 3

Caselles 36 15-26 15-26-36

Distància total 130 117 247

Nº peces totals 3 3 6

Taula 5. Combinacions trobades

Veient aquest resultat, podem dir que la millor combinació la aconseguim amb 2 palets el 15 i el 26, però si s’observa amb detall el programa, es veurà que, tal i com s’ha comentat el programa, elimina moltes combinacions possible. Unes ja estan assumides com innecessàries5, en canvi en el exemple anterior, existeix una combinació que és interessant tenir-la en compte.

En el cas de cridar a la funció combinacio( ) per 2 palets, hem guardat la primera casella, però en realitat el programa repeteix el codi agafant el segon, ... fins a només quedar una combinació possible amb el nombre de peces. En el nostre cas hauríem de cridar a la funció combinacio( )guardant la segona casella (26) i buscant una combinació d’1 palet amb la última posició del vector original. D’aquesta manera totes les combinacions que obtindrem seran les següents:

Combinació de peces 1 2 3 4

Caselles 36 15-26 26-36 15-26-36

Distància total 130 117 195 247

Nº peces totals 3 3 4 6

Taula 6. Combinacions trobades

Encara que la millor combinació, segueix sent la mateixa, no es pot permetre perdre aquestes combinacions.

A continuació trobem els codis d’aquestes dues funcions: combinacio ( ) i mínim ( ). int CMAGATZEM1Dlg::minim(int index, int falten) { int i,j,m,a,ind=0,min=10000,dist,MAX; int quantitat; a=index; while(CasellesTrobades[a]!=0&&a<72){ a++; } MAX=a; for(a=(index);a<MAX;a++){ //CALCULEM LA POSICIÓ DE LA MATRIU MAGATZEM SEGONS LA CASELLA if(CasellesTrobades[a]<=36&&CasellesTrobades[a]>0){ i=(36-CasellesTrobades[a])/6; j=(36-CasellesTrobades[a])%6; m=0; }else{ i=5-((CasellesTrobades[a]-37)/6); j=CasellesTrobades[a]-(37+((5-i)*6));

5 Aquestes combinacions, les elimina la funció minim(), ja que al cridar-la, aquesta funció busca la

combinació amb la distància més petita.

34

m=1; } quantitat=QuantitatCasellesTrobades[a]; dist = Distancia(i,j,m); if(quantitat>=falten){ if(dist<min){ //si la quantitat es suficient i la distancia mínima, es retorna aquesta casella min=dist; ind=a; } } } return(ind); }

Codi 6. Codi de la funció minim()

int CMAGATZEM1Dlg::combinacio(int index1, int index2,int *VectTreure,int *VectAux, int falten, int necesari, int primari) { int faltenaux,i,j,m,a,b,quantitat,dist,distaux=10000,num,enc=0,enc2=0; int r; int x=10,y=15; int MAX; CString nr,text; a=index1; while(CasellesTrobades[a]!=0&&a<72){ a++; } MAX=a; //si la quantitat de peces necesaries és més d'una if(necesari>1){ for(a=index1;a<(MAX-necesari+1);a++){ //CALCULEM LA POSICIÓ DE LA MATRIU MAGATZEM SEGONS LA CASELLA if(CasellesTrobades[a]<=36&&CasellesTrobades[a]>0){ i=(36-CasellesTrobades[a])/6; j=(36-CasellesTrobades[a])%6; m=0; }else{ i=5-((CasellesTrobades[a]-37)/6); j=CasellesTrobades[a]-(37+((5-i)*6)); m=1; } //guaredem la 1a casella del vector quantitat=QuantitatCasellesTrobades[a]; *(VectTreure+index2)=a; faltenaux=falten-quantitat; //cridem a la funció combinar amb els nous paràmetres combinacio(a+1,index2+1,VectTreure,VectAux,faltenaux,necesari-1,0); dist=0; distaux=100000; num=0; enc2=0; for(b=0;b<MAX;b++){ //CALCULEM LA POSICIÓ DE LA MATRIU MAGATZEM SEGONS LA CASELLA r=*(VectTreure+b); if(r!=100){ if(CasellesTrobades[r]<=36&&CasellesTrobades[r]>0){ i=(36-CasellesTrobades[r])/6; j=(36-CasellesTrobades[r])%6; m=0; }else{

35

i=5-((CasellesTrobades[r]-37)/6); j=CasellesTrobades[r]-(37+((5-i)*6)); m=1; } quantitat=QuantitatCasellesTrobades[r]; dist+=Distancia(i,j,m); num+=quantitat; enc2=1; } } //comparem la nova combinació amb l'anterior per guardar la millor if(enc2==0) dist=100000; if(dist!=0){ for(b=0;b<MAX;b++){ if(*(VectAux+b)!=100){ enc=1; } } } if(enc==1){ for(b=0;b<MAX;b++){ if(*(VectAux+b)!=100){ if(distaux==100000)distaux=0; //CALCULEM LA POSICIÓ DE LA MATRIU MAGATZEM SEGONS LA CASELLA if(CasellesTrobades[*(VectAux+b)]<=36&& CasellesTrobades[*(VectAux+b)]>0){ i=(36-CasellesTrobades[*(VectAux+b)])/6; j=(36-CasellesTrobades[*(VectAux+b)])%6; m=0; }else{ i=5-((CasellesTrobades[*(VectAux+b)]-37)/6); j=CasellesTrobades[*(VectAux+b)]-(37+((5-i)*6)); m=1; } quantitat=QuantitatCasellesTrobades[*(VectAux+b)]; distaux+=Distancia(i,j,m); } if(dist<distaux&&primari==1||distaux==100000){ for(b=0;b<MAX;b++){ *(VectAux+b)=*(VectTreure+b); } } } }else{ for(b=0;b<MAX;b++){ *(VectAux+b)=*(VectTreure+b); } } } } //si la quantitat de peces necesaries és d'una if(necesari==1){ //cridem a la funció minim amb les caselles entre les que ha de buscar i=minim(index1,falten); if(QuantitatCasellesTrobades[i]<falten){ for(b=0;b<MAX;b++){ *(VectTreure+b)=100; } }else{ *(VectTreure+index2)=i; } } return(0);

36

}

Codi 7. Codi de la funció Combinacio()

5.2.2 Programació d’ordres Una de les accions més interessants que permet aquest programa, és la possibilitat de

poder crear un seguit d’ordres que el programa executarà a la hora assenyalada (procés batch)

Gracies a la interfície creada, l’usuari és capaç de poder crear un vector amb les ordres(màxim 10) que el programa farà a l’hora que l’usuari determini. A més l’usuari serà el responsable de determinar el mode d’actuació del programa durant l’execució de les ordres, en el cas de no pogués complir alguna ordre.

Existeixen dos modes de funcionament quan una ordre no es pot dur a terme. El primer és que el programa continuï amb la següent instrucció, però sempre informant a l’usuari que no ha pogut realitzar aquella ordre, guardant-ho en l’historial de moviments. En canvi, el segon mode de funcionament, fa que el programa acabi amb totes les ordres restants de la seqüència.

A partir d’aquest moment, i amb tota aquesta informació definida per l’usuari, el programa comença a controlar el temps fins a l’hora marcada.

El funcionament general d’aquesta part del codi, s’explica en el següent diagrama de flux.

37

Diagrama 7. Funcionament de la programació d’ordres

Per fer possible aquesta aplicació, s’ha creat un temporitzador que cada 10 segons mira l’hora actual i la compara amb l’hora programada. En el cas que aquestes hores coincideixin, comença la execució d’ordres.

Per activar el començament de les ordres, el que s’activa és un temporitzador que periòdicament executa una nova ordre si l’anterior ja s’ha acabat. Primer de tot, revisa que la ordre es pugui realitzar amb l’estat actual del magatzem i en cas afirmatiu comença la següent ordre. En el cas de no poder realitzar-la, el programa actuarà segons l’usuari ho hagi preestablert.

5.2.3 Gestió d’informació Durant l’execució d’aquest programa, pot ser que l’usuari necessiti informació del

magatzem, com pot ser un control d’estoc o un histograma sobre la freqüència d’us d’un tipus de palet concret. Tota aquesta informació, té un propòsit clar, que és millorar la gestió del magatzem, ja que aquesta informació pot determinar una decisió o resoldre un problema.

Per tant, s’han creat 3 fonts d’informació:

• Control d’estoc

• Historial de moviments

• Histogrames

Llegir hora actual i es igual a la programada

Es pot realitzar l’ordre?

Continuar

Fi

Inici

• Programació d’ordres • Definir el mode de

funcionament en cas d’error

• Programar l’hora d’inici

Usuari

Mode de funciona-

ment

Hi ha més ordres?

Acabar No

No

Sí

Sí

Sí

No

38

5.2.3.1 Funció OnEstoc() void CMAGATZEM1Dlg::OnEstoc()

Codi 8. Declaració de la funció OnEstoc()

Una de les coses més important de tota empresa, és la necessitat de poder tenir controlat tot el material de que disposa, és per això que s’ha creat la possibilitat de permet a l’usuari saber la quantitat de pistons de cada tipus que hi ha en el magatzem, la quantitat de palets de cada tipus i la seva ubicació i les caselles que estan buides i les que no ho estan.

Per fer-ho, el programa, fa una passada per tot el magatzem incrementant les variables corresponents, que després seran mostrades per pantalla.

El codi que es mostra a continuació és l’encarregat de gestionar l’estoc. void CMAGATZEM1Dlg::OnEstoc() { EstocDlg m_dEstocDlg; int i,j,m; //pasem el vector de magatzem al dialeg ESTOCDLG for(m=0;m<2;m++){ for(i=0;i<6;i++){ for(j=0;j<6;j++){ m_dEstocDlg.magatzem[m][i][j]=magatzem[m][i][j]; } } } //cridem al dialeg ESTOCDLG m_dEstocDlg.DoModal(); }

Codi 9. Codi de la funció OnEstoc()

5.2.3.2 Funció Historial() void CMAGATZEM1Dlg::OnHistorial()

Codi 10. Declaració de la funció OnHistorial()

Una altra de la informació que tota empresa necessita tenir controlada, és un registre de tot el moviments que hi ha hagut en el magatzem. Això pot ajudar a millorar el control dels productes en l’empresa, ja sigui per traçabilitat del producte o per esbrinar possibles errors en el sistema de gestió de l’empresa.

És per això que aquest programa, disposa d’un historial de moviments on apareixen totes les accions i errors que han succeït en el magatzem. Assegurant-nos que en cada moviment o error, el programa ho escriu en un arxiu de text, només cal que es llegeixi aquest arxiu i es mostri tota la informació per pantalla.

Aquest programa també permet l’opció de filtrar la informació que es mostra. Es pot filtrar en funció de dos paràmetres: per moviments i per franja de temps, d’aquesta manera, per exemple, es pot saber totes les entrades al magatzem que hi va haver un mes concret.

39

Aquesta part del codi, llegeix d’un fitxer cada registre de moviment que hi va haver. És alhora de mostrar per pantalla cada registre, que el programa verifica que no estigui filtrada aquesta informació.

A continuació es mostra la part de codi encarregada de la lectura de fitxer i presentació per pantalla.

if(Archi.Open ("Historial.txt", CFile::modeRead)){ //es llegeix un registre while(pos<Archi.GetLength()){ Archi.Read (&acc,sizeof(acc)); Archi.Read (&Cas1,sizeof(Cas1)); Archi.Read (&Cas2,sizeof(Cas2)); Archi.Read (&dia,sizeof(dia)); Archi.Read (&mes,sizeof(mes)); Archi.Read (&any,sizeof(any)); Archi.Read (&hora,sizeof(hora)); Archi.Read (&min,sizeof(min)); Archi.Read (&tip,sizeof(tip)); //es prepara el text que surtirà per pantalla if(tip==100){ if(acc==0){ b.Format(" %02i# %02i/%02i/%4i - %02i:%02i ERROR AL TREURE de la casella %02i (%02i) a la casella %02i ",i,dia,mes,any,hora,min,Cas1,tip,Cas2); }else if(acc==1){ b.Format(" %02i# %02i/%02i/%4i - %02i:%02i ERROR AL ENTRAR de la casella %02i (%02i) a la casella %02i ",i,dia,mes,any,hora,min,Cas1,tip,Cas2); }else{ b.Format(" %02i# %02i/%02i/%4i - %02i:%02i ERROR AL MOURE de la casella %02i a la casella %02i ",i,dia,mes,any,hora,min,Cas1,Cas2); } }else{ if(acc==0){ b.Format(" %02i# %02i/%02i/%4i - %02i:%02i TREURE de la casella %02i (%02i) a la casella %02i: ",i,dia,mes,any,hora,min,Cas1,tip,Cas2); }else if(acc==1){ b.Format(" %02i# %02i/%02i/%4i - %02i:%02i ENTRAR de la casella %02i (%02i) a la casella %02i: ",i,dia,mes,any,hora,min,Cas1,tip,Cas2); }else{ b.Format(" %02i# %02i/%02i/%4i - %02i:%02i MOURE de la casella %02i (%02i) a la casella %02i: ",i,dia,mes,any,hora,min,Cas1,tip,Cas2); } } //s’afegeix el registre al llistat m_lstLlista.AddString(b); pos+=(9*sizeof(int)); i++; } Archi.Close (); }

Codi 11. Codi de la funció OnHistorial()

5.2.3.3 Gràfics

Per acabar d’arrodonir la informació de la que pot disposar l’usuari, s’han creat un seguit de 3 histogrames per tal que l’usuari, a simple vista, pugui rebre una petita estadística del magatzem.

40

S’han creat tres gràfics:

- Freqüència de moviments

Figura 24. Exemple d’histograma de moviments

- Freqüència de l’ús dels diversos tipus de palets

Figura 25. Exemple d’histograma de tipus de palets

- Freqüència de l’ús dels diversos tipus de pistons.

41

Figura 26. Exemple d’histograma de pistons

Per a realitzar aquests gràfics s’ha seguit el següent diagrama.

Diagrama 8. Funcionament de la representació d’un histograma

5.2.4 Control del moviment Una vegada ja està el programa encarregat de la gestió i control, només falta

programar la comunicació entre el programa i la planta per controlar els moviments del

Dibuixar fons del gràfic i eixos

Inicio

Cerca de dades en funció del tipus de gràfic i del temps

Cerca de la variable amb més freqüència

Cerca de l’escala de l’eix Y, l’interval entre divisions i el nombre d’elles

Representar variables a escala

Fi

42

motors i la posició del robot cartesià. Aquest control del moviment de la planta, es pot separar en els següents apartats:

• Configuració dels ports

• Lectura i control dels sensors

• Lectura del chip FPGA

• Control de motors

Com que l’objectiu principal d’aquest projecte no és el control del moviment, es donarà unes visió global sobre aquest apartat. En la bibliografia es pot trobar més informació.

5.2.4.1 Configuració dels ports

Cal recordar que tots els sensors i actuadors, estaven connectats a l’ordinador mitjançant una targeta d’adquisició de dades PCI-DAS6025. Aquesta targeta, disposa de 100 pins amb el següent esquema de connexió.

Figura 27. Esquema de connexió de la targeta PCI

43

En el nostre cas, els pins de connexió estan definits en la següent taula:

Pin Nombre de la señal

36 D/A OUT 0* S. consigna para servo-amplificador motor eje X 37 D/A GND* Masa 38 D/A OUT 1* S. consigna para servo-amplificador motor eje Y 51 FIRSTPORTA Bit 0* Defectuoso. 52 FIRSTPORTA Bit 1* E. Cargador de palés recogido (cable verde) 53 FIRSTPORTA Bit 2* E. Cargador de palés bajado (cable amarillo) 54 FIRSTPORTA Bit 3* E. Cargador de palés extendido (cable gris) 55 FIRSTPORTA Bit 4* E. Cargador de palés subido (cable marrón) 56 FIRSTPORTA Bit 5* E. Bandeja telescópica centro (azul) 57 FIRSTPORTA Bit 6* E. Bandeja telescópica derecha 37-72 (rojo) 58 FIRSTPORTA Bit 7* E. Bandeja telescópica izquierda 1-36 (blanco) 59 FIRSTPORTB Bit 0* 60 FIRSTPORTB Bit 1* 61 FIRSTPORTB Bit 2* 62 FIRSTPORTB Bit 3* 63 FIRSTPORTB Bit 4* 64 FIRSTPORTB Bit 5* 65 FIRSTPORTB Bit 6* 66 FIRSTPORTB Bit 7*

E. Byte de información que es capturado del circuito contador de pulsos. Su interpretación será según los bits de control usados.

67 FIRSTPORTC Bit 0* S. resetear el FPGA ALTERA MAX 68 FIRSTPORTC Bit 1* S. captura de cuenta según la cuenta seleccionada 69 FIRSTPORTC Bit 2* S. selección byte bajo de la captura 70 FIRSTPORTC Bit 3* S. selección byte alto de la captura 71 FIRSTPORTC Bit 4* S. selección de cuenta para capturar y leer (eje x o eje

y) 72 FIRSTPORTC Bit 5* No usado 73 FIRSTPORTC Bit 6* No usado 74 FIRSTPORTC Bit 7* No usado 85 DIO0 E. detector de presencia eje x (cable rojo) 86 DIO1 E. detector de presencia eje y (cable negro) 87 DIO2 S. extiende cargador (gris) 88 DIO3 S. sube cargador (blanco) 89 DIO4 S. recoge cargador (verde) 90 DIO5 S. baja cargador (marrón) 91 DIO6 S. bandeja telescópica hacia derecha ( casillas 37-72) 92 DIO7 S. bandeja telescópica hacia izquierda (casillas 1-36)

50, 100 GND Taula 9. Taula de connexions

Per poder treballar amb aquesta targeta, primer hem de definir quins pins són entrades i quins són sortides. Per fer-ho, existeix la següent funció:

int cbDConfingBit(int BoardNum, int PortType, int BitNum, int Direction)

on els arguments són:

BoardNum Número de targeta usada en la configuració del PC.

PortType AUXPORT, FIRSTPORTA, FIRSTPORTB, FIRSTPORTCL, FIRSTPORTCH.

BitNum 0 to 23 ( FISRTPORTA )

Direction DIGITALOUT, DIGITALIN

A més a més, existeixen altres funcions utilitzades per treballar amb el bits de la targeta. int cbDIn(int BoardNum, int PortNum, unsigned short *DataValue);

Llegeix el valor del port indicat (PortNum) i l’emmagatzema en la variable indicada.

44

int cbDBitIn(int BoardNum, int PortType, int BitNum, unsigned short *BitValue);

Llegeix el bit del port indicat i el guarda en la variable indicada. int cbDBitOut (int BoardNum, int PortType, int BitNum, unsigned short BitValue);

Escriu el valor indicat(0 o 1) en el port i en el bit indicat. int cbDConfingport(int BoardNum, int PortType, int Direction);

Configura en la targeta indicada, si el port introduït és d’escriptura o de lectura.

El següent tros del codi, és l’encarregat de configurar totes les entrades i sortides de la targeta

cbDConfigPort(0,FIRSTPORTA,DIGITALIN); cbDConfigPort(0,FIRSTPORTB,DIGITALIN); cbDConfigPort(0,FIRSTPORTCL,DIGITALOUT); cbDConfigPort(0,FIRSTPORTCH,DIGITALOUT); cbDConfigBit (0,AUXPORT,0,DIGITALIN); //senyal d’origen eje x cbDConfigBit (0,AUXPORT,1,DIGITALIN); //senyal d’origen eje y cbDConfigBit (0,AUXPORT,2,DIGITALOUT); //senyal per extendre braç cbDConfigBit (0,AUXPORT,3,DIGITALOUT); //pujar braç cbDConfigBit (0,AUXPORT,4,DIGITALOUT); //recull braç cbDConfigBit (0,AUXPORT,5,DIGITALOUT); //baixa braç cbDConfigBit (0,AUXPORT,6,DIGITALOUT); //mou safata central a la dreta cbDConfigBit (0,AUXPORT,7,DIGITALOUT); // mou safata central a la esquerra cbDBitOut(0,FIRSTPORTA,16,0); //reset cbDBitOut(0, FIRSTPORTA, 17, 1); //capture*='1' cbDBitOut(0, FIRSTPORTA, 18, 1); //Output Enable 1(bit OE1*='1') cbDBitOut(0, FIRSTPORTA, 19, 1); //Output Enable 2(bit OE2*='1') cbC8254Config(0,1,4); //Targeta 0, comptador 1, mode 2 cbCLoad(0,1,0xFFFF); //Carga de compta màxima

Codi 12. Codi per configurar les entrades i sortides

5.2.4.2 Lectura i control dels sensors

Una vegada ja tenim els sensors configurats, es pot començar a utilitzar-los. En el cas d’aquesta planta, es poden agrupar en dos petits grups, els sensors de la safata central i els sensors de la safata d’alimentació.

Safata central Es parlarà primer de la safata central, de la qual cal recordar que esta formada per un

motor de corrent continua per al moviment de la safata, i 3 sensors de presència ajuden al control de posició d’aquesta.

En el funcionament normal del magatzem, la safata central s’encarrega d’agafar o de deixar els palets al seu lloc. Existeixen 4 usos diferents de la safata en el magatzem.

El dos primer usos són per introduir palets en una casella concreta i per treure’ls. La part del codi encarregada d’aquesta tasca, segueix el funcionament del següent diagrama de flux.

45

Diagrama 8. Funcionament de la safata central

Per assegurar el correcte funcionament de la planta. En cada pas del diagrama, s’ha de comprovar que l’estat dels sensors de la safata central sigui el correcte. És a dir, no podem saltar al següent pas, si les condicions anteriors no s’han donat.

El tros de codi encarregat d’aquesta funció es mostra a continuació. /******************************************** //SECUENCIA PARA EL ALMACENAMIENTO DE UN PALÉ //******************************************** case 3:{ //Succés número 3 switch (pd) { //pd --> passes per a desar case 1:{ if (recull_cinta()) pd=2; //Si la recollida de palet ha finalitzat, continuem. }break; case 2:{ cbDBitIn(0, FIRSTPORTA,BAJADO,&bit); //Llegim el sensor de la safata d’alimentació abaix if ((pos_ok())&&(!bit)) pd=3; //Si safata central i d’alimentació estan en posició, continuem }break; case 3:{

Ubicar safata en la davant de la casella

Casella desti ?

Desplaçament cap a la dreta

Desplaçament cap a la esquerra

Acció?

Baixar la safata central

Pujar la safata central

Casella desti ?

Desplaçament cap a la esquerra

Desplaçament cap a la dreta

>36 <=36

Entrada Sortida

Inici

>36 <=36

Fi

46

if (seq_safata(DRETA,TREU)) { //Si seqüència safata d’alimentació finalizada pid1.wishpos=pos[posi].x; //nova destinació eix X pid2.wishpos=pos[posi].y+175; //nova destinació eix Y per descarregar pd=4; //passar al següent pas } } break; case 4:{ if (pos_ok()) pd=5; //Si posición correcta llavors passar següent pas }break; case 5:{ if (seq_safata(costat,DESA)) { //Si seqüència safata alimetnació finalizada KillTimer(3); //Fin seqüència, eliminació timer pd=0; //ajust inicial } } break;

Codi 13. Codi per funcionament de la safata central

De manera paral·lela, els altres dos usos de la safata central, són per treure o deixar un palet el la safata d’alimentació. El funcionament és molt semblant al Diagrama 8, l’únic canvi és, que en aquest cas la safata central sempre es desplaçarà cap al cantó dret per arribar a la safata d’alimentació.

Safata d’alimentació En aquest cas, els sensors que s’han de controlar, són els sensors de posició que

trobem en els dos pistons. El funcionament del programa és senzill i es detalla en el Diagrama 9.

47

Diagrama 9. Funcionament de la safata d’alimentació

Com es pot veure, depenent si són entrades o sortides de palets, l’ordre d’ús dels pistons pneumàtics canvia lleument, però sempre és important verificar l’estat dels sensors per comprovar que el sistema està seguint correctament els passos.

Entrada de palet?

Sortida de palet?

Avançar el pistó de l’eix X

SI

NO

SI

NO

Pujar el pistó de l’eix Y

El pistó ha arribat a

l’extrem?

NO

SI

Retrocedir el pistó de l’eix X


l’extrem?

NO

SI

Baixar el pistó de l’eix Y


l’extrem?

NO

SI

Avançar el pistó de l’eix X


l’extrem?

SI

NO

SI

Pujar el pistó de l’eix Y

NO

SI

Retrocedir el pistó de l’eix X

NO

SI

Baixar el pistó de l’eix Y


l’extrem?

NO

SI

NO

INICI

Fi


l’extrem?


l’extrem?


l’extrem?

48

5.2.4.3 Lectura del chip FPGA

Per al control de moviment dels motors dels dos eixos, cal recordar que existien dos encoders que donaven uns polsos cada vegada que el motor girava 0,36º. Cal recordar també, que aquestes senyals dels encoders no es connecten directament a la targeta de captació de dades, sinó que hi han dos circuits de condicionament abans.

El primer és un circuit de condicionament que alimenta els encoders i genera uns polsos complementaris a les senyals generades pels encoders. El segon circuit és una placa amb un chip programable FPGA(field programable gate array), que s’encarregarà de comptar les senyals de l’encoder i donar un nombre decimal del polsos contats.

Encara que aquesta placa està preparada per contar fins a 20 bits per cada encoder, només s’utilitzen 16, ja que la resolució és més que suficient.

Donada la lògica que d’aquesta placa que conté el FPGA (Figura 28), per poder llegir hem de controlar aquestes senyals:

• CTR – serveix per definir sobre quin compte es vol actuar.

• OEL – activa o desactiva la carrega en buffer dels 8 bits baixos.

• OEH – activa o desactiva la carrega en buffer dels 8 bits alts.

• CAPTURE – Aquesta senyal serveix per activar el mode captura.

• Q[7...0] – Seran els bits de sortida per llegir.

Figura 28. Portes lògiques de control FPGA

49

Llavors per poder llegir, hem de seguir la seqüència que es pot veure en la Figura 29.

Figura 29. Seqüència per llegir els comptes

Com es veu en la figura anterior, començarem amb la captura dels dos comptes dels encoders mitjançant les senyals CAPTURE i CTR. Llavors amb les senyals OEL i OEH, es decideix quin byte es posa en el buffer. Canviem el valor de CTR per llegir l’altre compte i repetim els passos amb les senyals OEL i OEH.

Aquí es presenta el codi que reflexa aquesta seqüència. cbDBitOut(0, FIRSTPORTA, 17, 1); //Bloqueo de cuenta (bit capture*) cbDBitOut(0, FIRSTPORTA, 20, 1 ); // encoder 1 eje x cbDBitOut(0, FIRSTPORTA, 17, 0); //Liberamos bloqueo (bit Capture*.) cbDBitOut(0, FIRSTPORTA, 18, 0); //Output Enable 1(bit OEL*) cbDIn(0, FIRSTPORTB, &Byte1L); /lectura 8 bits bajos encoder eje x cbDBitOut(0, FIRSTPORTA, 18, 1); //Output disable 1(bit OEL*='1') cbDBitOut(0, FIRSTPORTA, 19, 0); //Output enable 1(bit OEH*='0') cbDIn(0, FIRSTPORTB, &Byte1H); //lectura 8 bits altos encoder eje x cbDBitOut(0, FIRSTPORTA, 19, 1); //Output disable 1(bit OEH*='1') cbDBitOut(0, FIRSTPORTA, 20, 0 ); // encoder 2 eje y cbDBitOut(0, FIRSTPORTA, 18, 0); //Output Enable 1(bit OEL*) cbDIn(0, FIRSTPORTB, &Byte2L); //lectura 8 bits bajos encoder 2 cbDBitOut(0, FIRSTPORTA, 18, 1); //Output disable 1(bit OEL*='1') cbDBitOut(0, FIRSTPORTA, 19, 0); //Output enable 1(bit OEH*='0') cbDIn(0, FIRSTPORTB, &Byte2H); //lectura 8 bits altos encoder 1 cbDBitOut(0, FIRSTPORTA, 19, 1); //Output disable 1(bit OEH*='1') pulsos1=(Byte1H<<8)|Byte1L; //acondicionamos lectura encoder 1 a 16 bits pulsos1-=0x8000; //acondicionamiento de signo pulsos2=(Byte2H<<8)|Byte2L; //acondicionamos lectura encoder 2 a 16 bits pulsos2-=0x8000; //acondicionamiento de signo

Codi 14. Codi per llegir comptes del FPGA

Temps d’excucció

50

5.2.4.4 Control de motors

Per al control del motors, s’utilitzarà un regulador PID que farà el sistema molt més eficaç.

El controlador PID està format per tres reguladors, un de proporcional, un d’integratiu i un de derivatiu. Aquests tres reguladors treballen amb una senyal d’error que s’obté de la diferència entre la posició de consigna i la posició real. Al final el PID genera una senyal que s’utilitzarà per al control del motor.

L’equació que defineix el controlador PID en l’espai del temps és la següent:

⎥⎦

⎤⎢⎣

⎡++= ∫ dt

tdeTddtteTi

teKptm )()(1)()(1

0

(1)

on:

Kp: Constant proporcional

Ti: Temps integral

Td: Temps derivatiu

Per poder simular un control PID per fer el control des del programa, l’expressió s’ha de passar a digital, és a dir passar l’expressió anterior a una forma discreta en comptes de continua. Per tant obtenim la següent expressió amb la que treballarà el programa.

⎥⎦

⎤⎢⎣

⎡Δ

−−+Δ+= ∑

= tneneTdte

TineKpnm

n

kk

)1()(1)()(1

(2)

Aquesta expressió s’utilitza per a calcular el valor absolut de la posició de l’actuador. Aixó de vegades presenta problemes, per tant existeix una expressió que ens dona la magnitud de canvi i no el valor absolut.

)3()1()()( 321 −+−+=Δ neKneKneKnm (3)

on:

)1(1 TsTd

TiTsKpK ++= (4)

)21(2 TsTdKpK +−= (5)

TsTdKpK =3 (6)

Ts: Temps de mostreig

Les constants Kp, Td, Ti, s’han obtingut a partir de l’experimentació encara que existeix la Regla de Ziegler – Nichols per obtenir aquests valors, no s’ha utilitzat per què aconseguien un sistema del tot ràpid i estabilitzat.

En el programa, el control PID es fa en diferents apartats que es mostren a continuació:

51

Per un costat hi ha la definició dels paràmetres i càlcul de constants: magatzem::def_parametres(double proporcional, double integrativo, double derivativo, double muestreo){ kp=proporcional; Ti=integrativo; Td=derivativo; t_sample=muestreo; k1=kp*(1+(t_sample/Ti)+(Td/t_sample)); k2=kp*(1+(2*(Td/t_sample))); k3=kp*(Td/t_sample); }

Codi 15. Codi per definir paràmetres del PID

I per un altre costat hi ha el càlcul de l’increment a aplicar en la variable de sortida. magatzem::controlpid (double realpos, double wp_incr){ if (wishpos>wp_temp) { wp_temp+=wp_incr; if ((wishpos<wp_temp)||(wishpos<(wp_temp+wp_incr))) wp_temp=wishpos; } if (wishpos<wp_temp) { wp_temp-=wp_incr; if ((wishpos>wp_temp)||(wishpos>(wp_temp-wp_incr))) wp_temp=wishpos; } error0=wp_temp-realpos; control+=k1*error0-k2*error1+k3*error2; error2=error1; error1=error0; controlaux=control; if ((controlaux)>(RANGO)) controlaux=(RANGO); else if ((controlaux)<(-RANGO)) controlaux=(-RANGO); control=controlaux; }

Codi 16. Codi per controla PID

52

5.3 Manual d’usuari El programa que es descriu a continuació, és un programa pensat i dissenyat per al

cas concret de la CFF situada en les instal·lacions del Campus Sescel·lades. A continuació s’explicarà tot el funcionament d’aquest programa per a que l’usuari sigui capaç de gestionar el magatzem.

Aquest programa dona la possibilitat de controlar les entrades i sortides, totes les posicions dins del magatzem, així com els moviments i accions que es realitzin. A més a més, aquest programa proporcionarà a l’usuari tota la informació necessària per a la gestió, control d’estocs,...

5.3.1 Informació prèvia Tot usuari d’aquest programa i del magatzem, ha de conèixer certs aspectes de la

planta abans de començar amb el programa.

El magatzem que es vol gestionar, és capaç de controlar fins a 72 palets que ubicarà en les 72 caselles disponibles. Aquestes caselles estan distribuïdes en dos mòduls de 6 alçades i 6 caselles per a cada alçada, en total 36 caselles en cada mòdul. Totes les caselles estan codificades amb un numero, de l’1 al 36 per al mòdul 1 i del 37 al 72 per al mòdul 2.

En cada casella es pot guardar un palet que pot tenir fins a 3 pistons que es fabriquen en la cèl·lula de fabricació flexible (CFF). Aquests pistons poden ser, en funció del color i material, de 3 tipus: Vermells, Grisos o Negres. Per tant existeixen fins a 64 tipus de palets resultats de la combinació dels 3 tipus de pistons i de la manca d’ells. En la Taula 7 es descriuen tots els tipus de palets possibles i la codificació amb la que es treballarà en el programa.

Tipus Contingut Tipus Contingut Tipus Contingut Tipus Contingut

de del de del de del de del

Palets palet

Palets palet Palets palet Palets palet

0 16 32 48 1 17 33 49 2 18 34 50 3 19 35 51 4 20 36 52 5 21 37 53 6 22 38 54 7 23 39 55 8 24 40 56 9 25 41 57 10 26 42 58 11 27 43 59 12 28 44 60 13 29 45 61 14 30 46 62 15 31 47 63

Taula 7. Tipus de palets

53

A més a més d’aquestes 64 possibilitats, s’ha reservat el tipus de palet 64 a la casella buida, és a dir, sense contingut de palet. Cal diferenciar-ho del tipus 0, que si que hi ha palet, però aquest està totalment buit.

Ja que aquest programa està dissenyat des del punt de vista del magatzem, direm que un palet entra, quan s’introdueix al magatzem un palet des de l’exterior, i que trèiem un palet, quan buidem una casella i portem el palet al sistema.

5.3.2 Pantalla principal

Figura 30. Pantalla principal

En la Figura 30, es pot veure la pantalla principal d’aquest programa. Aquesta és la primera finestra que se’ns obrirà i a partir de la qual, podrem fer totes les gestions. En aquesta finestra trobem:

1. Botó de sortir

2. Botó de entrada de palets

3. Botó de treure palets o peces

4. Botó de modificar magatzem

5. Botó de control d’estoc

6. Botó d’historial

7. Botó de planificació de treball

8. Menú

9. Representació de l’estat del magatzem

54

5.3.3 Sortir Al fer clic en el botó de sortir, el programa preguntarà si és realment es vol sortir. En

cas afirmatiu, el programa guardarà l’estat del magatzem i sortirà del programa.

5.3.4 Entrada de palets

Al fer clic en el botó d’entrada de palets, s’obrirà la finestra que es mostra en la Figura 31, en la que es troba:

Figura 31. Pantalla entrar palets

• Casella de Tipus de palets: És on s’ha d’introduir el tipus de palet que entrarà en el magatzem. El botó “Ajuda (?)” és una ajuda per no haver de memoritzar tots els tipus de palets possibles. Al fer clic, s’obrirà una finestra amb tots els tipus de palets possibles. Si es fa clic en una casella i es surt, automàticament s’introduirà el valor del tipus de palet en aquesta casella.

• Opció manual d’entrada de palets: Al fer clic en aquesta casella, s’oferirà la possibilitat d’introduir la casella en la que es vulgui situar el palet que entrarà. Si aquesta casella no està acceptada, el programa buscarà la casella més propera per introduir aquest palet.

• Casella de casella destí: En aquesta casella, s’introduirà la posició on es vulgui col·locar el palet que entrarà al magatzem. Aquesta casella només està accessible si està acceptada la opció d’entrada manual del palet.

Quan es faci clic en el botó “OK”, el programa tornarà a mostrar la pantalla principal, però primer farà un reconeixement de les dades que s’hagin introduït, i les verificarà6. En cas que les dades siguin correctes, el programa enviarà les ordres corresponents al magatzem.

6 Per a què una entrada de palets, sigui correcte, el tipus de palets introduït ha de ser un tipus del 0 al

63. El botó Ajuda, ens introdueix el nombre del tipus que nosaltres fem clic per tal de reduir errors. A més, en el cas que nosaltres diguem la casella destí, aquesta ha de ser una casella vàlida, és a dir estar entre 1 i 72, i a més la casella ha d’estar buida.

55

5.3.5 Treure palets o peces Al fer clic en el botó de la pantalla principal “treure palets / peces”, s’obrirà una

nova finestra, on es troben les següents opcions:

Figura 32. Pantalla treure peces

• Opció de treure un palet: Al fer clic en aquesta casella, es podrà introduir en la casella habilitada, la posició del magatzem que es vulgui buidar.

• Opció de treure un tipus de palet: Si es selecciona aquesta casella, significa que pretén buscar un tipus concret de palet, però es igual la casella on es trobi. Per tant, s’haurà d’especificar el tipus de palet que es vulgui i el programa buscarà el palet més proper del tipus desitjat. A més es disposa del botó “Ajuda (?)” on hi han tots els tipus de palets. Només cal seleccionar el que es vulgui i al fer clic en (OK), automàticament apareixerà el valor en la casella del tipus de palet.

• Opció de treure peces: Si el que es necessita és una quantitat de peces d’una classe concreta, s’haurà de fer clic en aquesta casella. Llavors només s’haurà de dir el color de les peces que es vulguin i la quantitat de peces (màxim 15). Una vegada acceptem la opció, el programa calcularà una combinació de palets (màxim 15) per tal de poder donar la quantitat de peces desitjada.

Al igual que passa en el cas d’entrada de palets, al fer clic en el botó “OK”, el programa verificarà7 les dades introduïdes, en cas afirmatiu, el programa començarà amb el moviment del magatzem.

7 Per a què es pugui treure un palet, primer el programa revisarà les dades introduïdes en la finestra de

“Treure palets / peces”. En el cas de seleccionar que es vol treure una casella, aquesta ha d’estar entre 1 i 72 i ha de contenir un palet, és a dir, no pot estar buida. Si hem seleccionat la opció de treure un tipus de palet

56

5.3.6 Modificar el magatzem Imagini que hi han hagut modificacions en el magatzem que no s’han registrat ja

sigui per error d’usuari o falta de subministrament elèctric,... llavors, la manera de poder introduir tots els palets en les caselles corresponents, és fer un clic en el botó “modificar magatzem”. Al fer-ho, s’obrirà la següent finestra.

Figura 33. Pantalla modificar magatzem

Com es pot veure, es disposa de 72 caselles on introduir el valor del tipus de palet que hi ha en cada casella. Si no es recorda de memòria de tots els tipus de palets, el programa disposa del botó “Ajuda (?)”, on trobaràs tots els tipus de palets representats.

Cal recordar que per indicar que una casella està completament buida, sense palet, el nombre a escriure és el 64.

5.3.7 Control d’estoc Una de les coses més importants que tota empresa vol controlar, és tenir tot el

material existent controla, ja sigui com a matèria prima o com a producte final. En el aquest cas, el magatzem controla només el producte final (pistons), per tant, s’haurà de tenir en tot moment una informació detallada de l’estat del magatzem. Una de les funcions d’aquest programa és, precisament aquesta, donar informació a l’usuari de tot l’estat del magatzem.

concret, el programa verificarà que aquest palet estigui entre 0 i 63 i que trobi algun palet d’aquestes característiques en el magatzem. Per últim si hem seleccionat que volem peces, el programa revisarà que les peces demanades, no superin el nombre 15 ni siguin més petites que la unitat.

57

Per poder obtenir aquesta informació, s’haurà de fer clic en el botó corresponent, amb el que se’ns obrirà la finestra que se’ns mostra en la Figura 34.

Figura 34. Pantalla Control d’estoc

En aquesta pantalla es pot veure la següent informació:

• Caselles buides

• Caselles plenes

• Quantitat de peces vermelles

• Quantitat de peces grises

• Quantitat de peces negres

• Quantitat d’espais buits en els palets

• Quantitat de cada tipus de palets

En aquesta finestra, es torna a trobar el botó “Ajuda (?)”, on trobem tots els tipus de palets amb un dibuix, per no haver de memoritzar tots els tipus de palets.

58

5.3.8 Historial de moviments

Figura 35. Pantalla historial de moviments

Al fer clic en aquest botó s’obrirà la finestra que es mostra en la Figura 35, en la que trobarem tota la informació dels moviments que s’han fet en el magatzem. Cada línia de text, correspon a un moviment del qual disposem de la següent informació:

• Acció: S’indica el tipus de moviment que hi ha hagut. “TREURE” per indicar que un palet ha sortit, “ENTRAR” per les entrades de palets i “MOURE” per indicar un moviment entre dues caselles del magatzem.

• Casella 1: S’indica la casella en la que s’ha realitzat la acció, és a dir, si el moviment ha estat de “TREURE” un palet, s’indica la casella que s’ha agafat, en canvi, si el moviment és “ENTRAR”, la casella 1 informa de la casella on s’ha col·locat el palet que ha entrat. Entre parèntesis, trobem el tipus de palet afectat.

• Casella 2: Aquesta casella només tindrà valor en el cas de que l’acció sigui “MOURE” i indica la casella a on s’ha mogut el palet.

• Data: S’informa del dia, mes, any i hora en que s’ha realitzat l’acció.

A més també trobarem línies on apareixen els errors que hi han hagut alhora de realitzar un moviment.

En la part esquerra de la pantalla, podem observar que hi ha la opció de filtrar tots aquests moviments i que només es mostrin aquells que interessin. Es pot filtrar-los per una franja de temps concreta, un any, un mes, un dia concret, i per moviments, per exemple, es pot mostrar totes aquelles entrades que van haver-hi el dia que es vulgui.

59

Per fer-ho només cal seleccionar el moviment que es vulgui i la franja de temps que es vulgui mirar. Després s’ha de fer clic en el botó “filtrar” i si les dades són correctes8 el programa mostrarà allò que es vol.

Des de aquesta finestra, podem accedir a una finestra que ens mostrarà uns gràfics estadístics del magatzem. Per accedir-hi només cal fer un clic en el botó “gràfics”.

5.3.9 Gràfics

Figura 36. Pantalla gràfics

Existeixen tres tipus de gràfics possibles a mostrar. El primer és un gràfic on es mostra la freqüència dels moviments en el temps desitjat. El segon gràfic, mostra la freqüència d’us de cada tipus de palet. I el tercer gràfic mostra la freqüència d’us de cada tipus de pistò.

Per escollir entre el gràfic, només cal fer clic les opcions desitjades de la banda esquerra de la pantalla. Primer seleccionar el tipus de gràfic a calcular i després la franja de temps. Es pot veure que al fer clic en alguna opció de temps, el programa habilita o deshabilita unes caselles o unes altres per a què es pugui introduir tota la informació necessària. És a dir si per exemple, es vol mostrar un gràfic de la freqüència dels pistons el dia 23 de maig del 2008, s’haurà de fer clic en la opció “freqüència de palets”, el “dia” i escriure el dia, més i any en les caselles habilitades, tal i com es mostra en la Figura 37.

8 Al clicar en el botó “filtrar” el programa mirarà que s’hagi seleccionat una opció de moviment a

filtrar i que el rang de temps estigui ben introduït. Fixeu-vos, que quan es selecciona una opció de temps, el programa mostra aquelles dades necesaries i deixa els altres camps deshabilitats.

60

Figura 37. Exemple de gràfics

En el cas de seleccionar el gràfic de freqüències dels tipus de palets, es pot passar el ratolí per damunt de les barres i apareixerà un requadre amb el tipus de palet i la freqüència d’aquest.

5.3.10 Planificació de treball Una de les funcions més interessants d’aquest programa és poder planificar un seguit

d’accions a realitzar a partir d’una hora concreta. Per fer-ho s’ha de fer clic en el botó “planificació de treball” i s’obrirà la següent finestra, on es podrà definir tot un seguit d’accions (màxim 10) per a realitzar a l’hora que es vulgui.

Figura 38. Pantalla de planificació de treball

61

En aquesta finestra trobem els següents objectes:

1. Llistat de les accions pendents

2. Botó per afegir una nova acció

3. Botó per eliminar una acció

4. Hora d’inici del programa d’accions.

5. Opcions per a la planificació de les ordres

A continuació trobarem com poder programar les accions que vulguem.

5.3.10.1 Afegir una nova ordre.

Per afegir una nova ordre, només caldrà fer un clic en el botó (2) “Afegir ordre”. Al fer-ho se’ns apareixerà la següent finestra.

Figura 39. Pantalla per afegir nova ordre

Per a poder crear una nova ordre haurem de seguir els següents passos:

1. Seleccionar en l’acció que vulguem realitzar:

• TREURE per buidar una casella

• DESA per entrar un palet

• MOU per moure un palet a una casella buida

2. Introduir la informació necessària per a la acció, les caselles i el tipus de palet. Depenent de l’acció seleccionada, s’haurà de donar una informació o una altra. En el cas d’introduir el tipus de palet, es torna a activar el botó “ajuda” amb tots els tipus de palets.

62

3. Per acabar, haurem de dir la posició que ocuparà aquesta ordre dins del seguit d’accions a realitzar. Per defecte, el programa omplirà aquesta casella amb la última ordre, però nosaltres es pot indicar la que es vulgui9.

5.3.10.2 Eliminar una ordre

Per a poder eliminar una ordre, només cal seleccionar la ordre desitjada i fer clic en el botó “eliminar ordre”. El programa preguntarà si es vol eliminar la ordre seleccionada. En cas afirmatiu, l’ordre serà eliminada i totes les ordres posteriors pujaran una nova posició.

5.3.10.3 Indicar la hora d’inici i confirmar les accions

Una vegada ja estiguin introduïdes totes les accions en l’ordre desitjat, només ens caldrà indicar la hora en la que ha de començar les accions. Per fer-ho hi han dos caselles on introduir la hora10 i el minut en els que ha de començar el procés d’ordres programat.

Quan ja s’hagi introduït la hora, només cal fer clic en el botó (OK) i el programa ens informarà del temps que falta per a que comenci el seguit d’ordres.

5.3.10.4 Opcions de la planificació de treball.

Una vegada comenci a realitzar les accions programades, el programa verificarà que aquella ordre es pugui complir amb l’estat actual del magatzem. En cas de no poder fer una ordre, el programa té dues opcions continuar amb la resta d’accions o acabar amb totes les ordres restants. Per a poder definir que ha de fer el programa en aquest cas, s’haurà de fer clic en l’opció desitjada.

5.3.11 “Menú” En el menú hi ha dos apartats, el primer anomenat “Arxiu” i l’últim anomenat “El

programa”.

En el sub-menú “Arxiu”, es troben les següents opcions:

• Carrega: Al fer clic en aquesta opció, el programa carregarà l’estat del magatzem de l’últim arxiu guardat.

• Guardar: Aquest botó serveix per guardar els canvis en el magatzem.

• Calibrar: Per tornar a recuperar la posició exacta del robot cartesià, es disposa d’aquest botó. Al fer clic, el programa anirà fins al final del magatzem per tal de tornarà a calibrar el punt 0 del sistema.

• Sortir: Per abandonar el programa, només cal fer un clic en aquest botó. Abans de marxar ens preguntarà si es vol sortir. En cas afirmatiu, guarda l’estat del magatzem i tanca el programa.

I en el sub-menú “El programa” trobem un botó que dona una miqueta d’informació del programa; versió, autor, etc..., i un botó per les opcions del programa. Al fer clic en aquest últim, s’obrirà la següent finestra.

9 La posició de la nova ordre ha de ser, com a molt, el valor indicat. No és podrà col·locar una acció en

una posició si la ordre anterior està en blanc. 10 La hora serà en format 24 hores, de 0 a 23. Els minuts vàlids estàn entre 0 i 59.

63

Figura 41. Pantalla opcions

En aquesta finestra podrem definir entre fer un control de les caselles per mínim consum o per rapidesa.

5.3.12 Funcions extres A més a més de totes les funcions anteriors, el programa incorpora un parell de

funcions més que faciliten el treball de l’usuari.

Al passar el ratolí per les caselles de la pantalla principal, aquestes obtindran un marc de color per indicar a l’usuari en quina casella es troba. En aquest moment i sense deixar el ratolí, l’usuari podrà fer dos tipus d’accions:

• Moure palets amb ratolí: Si volem moure un palet d’una casella a una altra buida, el que hem de fer, és fer un clic amb el botó esquerre del ratolí, sobre la casella que vulguem moure i sense deixar de prémer el botó, moure el ratolí fins la posició desitjada. Si les caselles seleccionades són vàlides11, el programa ens preguntarà si el nostre desig és moure aquella palet de la casella 1 a la 2. En cas afirmatiu el robot començarà el moviment portant el palet de la casella origen a la casella destí.

• Treure palets amb el ratolí: Si volem treure un palet d’una casella concreta, no cal que anem al botó “treure palets / peces”, ho podem fer amb el ratolí. L’únic que hem de fer és clic amb el botó esquerra del ratolí sobre la casella i arrossegar-la fora del magatzem, és a dir, sense deixar de prémer el botó, portar el ratolí des de la casella desitjada fins a qualsevol punt de la pantalla que no sigui cap casella. D’aquesta manera el programa treure el palet.

11 La casella origen, on es prem el botó, té palet i la casella destí, on s’ha deixat el botó, ha d’estar

buida.

64

5.3.13 Missatges d’error Durant la execució del programa, podria ser que apareixen alguns missatges d’error.

Aquests poden ser degut a que algun paràmetre no s’ha introduït correctament o que hi ha alguna funció realitzant-se,... Tots els errors estan codificats amb un número d’error, a continuació, veurem els missatges d’error més freqüents i el seu significat:

Nº d’error Missatge Significat

E001 "Error en la carrega" No s’ha pogut llegir l’arxiu magatzem.txt

E002 "LA CASELLA INTRODUÏDA NO ESTÀ BUIDA"

La casella que s’ha introduït per entrar un palet, no està buida

E003 "LA CASELLA INTRODUÏDA ÉS ERRONIA"

La casella que s’ha introduït per treure, no existeix (1-72)

E004 "NO HI HAN CASELLES BUIDES" No s’han trobat caselles buides

E005 "EL TIPUS DE PALET ÉS ERRONI" El tipus de palet que s’ha introduït, no es correcte(0-63)

E006 "LA CASELLA INTRODUÏDA ESTÀ BUIDA"

No es pot treure d’una casella que no en té.

E007 "NO S'HA TROBAT CAP PALET D'AQUEST TIPUS"

No hi ha cap palet d’aquest tipus al magatzem

E008 "NO S'HA SELECCIONAT CAP TIPUS DE PECES"

No s’ha introduït cap tipus de palet (0-63)

E009 "NO S'HA INTRODUÏT QUANTITAT DE PECES"

No s’ha introduït quantitat de peces (1-15)

E010 "LA PRIMERA CASELLA ESTÀ BUIDA" S’ha intentat moure una casella buida

E011 "LA SEGONA CASELLA NO ESTÀ BUIDA"

La casella seleccionada per moure un palet a aquesta, no està buida

E012 "Error al guardar" No s’ha pogut guardar l’estat del magatzem en l’arxiu magatzem.txt

Taula 8. Taula de missatges d’error

65

5.4 Aplicacions del software Tot i que aquest programa s’ha dissenyat pensant en la CFF de les instal·lacions del

campus Secel·lades, no seria molt difícil transportar el programa fins a un altre tipus de magatzem que funcionés de manera matricial, és a dir, que les posicions on col·locar palets fossin com una matriu amb files i columnes.

Per què aquest programa funcionés en qualsevol altre magatzem, s’hauria de:

• Ajustar els polsos a contar que provenen dels encoders dels motors de desplaçament, per a cada posició possible.

• Canviar la mida de la variable magatzem definint la quantitat de mòduls, i la quantitat de files i de columnes que es troben en cada mòdul.

• Definir els productes que es poden emmagatzemar.

• Ajustar alguns paràmetres

67

6 PRESSUPOST

6.1 Consideracions inicials

En el present pressupost, s’han comptat tots aquells elements necessaris en la realització d’aquest projecte. L’ordinador i el hardware de la planta, són elements que ja existien prèviament i en aquest projecte només es contemplarà l’amortització d’aquest.

6.2 Preus unitaris

Unitat Descripció Preu € h Enginyer tècnic 15,05 u Amortització Equip. Hardware 2,00

6.3 Descomposició de tasques

Les diferents tasques que s’han realitzat per arribar a obtenir cada capítol de projecte són:

• T001 - Estudi del component

• T002 - Programació amb Visual C++

• T003 - Proves i validacions

• T004 - Documentació

S’ha establert que el cost d’execució es el mateix per cada una de les tasques :

Codi Partida Designació Unitat T001, T002, T003, T004 Tasca genèrica per realitzar cada component del projecte u.

Unitat Quantitat Preu unitari Total (€) Material: 101- Amortització Equip. Hardware h 2,00 1,00 2,00

Subtotal Material: 2,00 Mà d’obra: 202- Analista Programador h 1,00 15,00 15,00

Subtotal Material: 15,00 Cost Execució : 17,00

6.4 Descomposició del projecte El projecte s’ha descompost en els següents components:

68

• C001 - Creació de la interfície d’usuari

• C002 - Gestió del magatzem

• C003 - Comunicació amb la prestatgeria

• C004 – Finalització del contracte i Garantia

6.4.1 C001 - Creació de la interfície d’usuari

Codi Partida Designació Unitat C001 Creació de la interfície d’usuari u.

Unitat Quantitat Preu unitari Total (€) Tasques

T001 - Estudi del component h 10,00 17,00 170,00 T002 - Programació en Visual C++ h 70,00 17,00 1190,00 T003 - Proves i validació h 15,00 17,00 255,00 T004 - Documentació h 10,00 17,00 170,00

Cost Execució : 1785,00

6.4.2 C002 - Gestió del magatzem

Codi Partida Designació Unitat C002 Gestió del magatzem u.




69

6.4.3 C003 - Comunicació amb la prestatgeria

Codi Partida Designació Unitat C003 Comunicació amb la prestatgeria u.




6.4.4 C004 – Finalització del contracte i garantia

Codi Partida Designació Unitat C004 Finalització del contracte i garantia u.


Curset de formació (2hores) (màx. 10persones) u 1,00 500,00 500,00

Garantia de funcionament durant el primer any u 0,00 0,00 0,00

Manteniment després de la garantia (màxim 100hores) u 1,00 2000,00 2000,00


70

6.5 Resum de pressupost

Capítols Import (€)

C001 - Creació de la interfície d’usuari 1785,00

C002 - Gestió del magatzem 1360,00

C003 - Comunicació amb la prestatgeria 2805,00

C004 – Finalització del contracte i garantia 2500,00

Total pressupost d’execució materials 8450,00

Despeses Generals 13% 1098,50

Benefici Industrial 6% 422,50

Total Parcial 9971,00

I.V.A. 16% 1595,36

Total Pressupost 11566,36

El preu total d’aquest projecte és de ONCE MIL CINC-CENTS SEIXANTA-SIS EUROS AMB TRENTA-SIS CENTIMS D’EURO.

Tarragona, juny de 2008

VÍCTOR MANUEL VEGA HOYO Enginyer Tècnic Industrial en Electrònica Industrial

72

7 PLEC DE CONDICIONS

En aquest apartat, s’inclou un contracte entre l’empresa que vol automatitzar i gestionar el seu magatzem amb l’empresa que s’encarregarà de fer el software.

7.1 Contracte

CONTRACTE PER AL PROJECTE DE GESTIÓ D’UN MAGATZEM

Tarragona, a…..de………….200….

COMPAREIXEN

Per una part ................. (des d’ara, l’EMPRESA CONTRACTADA) amb CIF .................., i seu en .............................................................................., que va ser constituïda davant el Notari de ................... D. ................................, el ... de ........... de ....., inscrita en el Registre Mercantil de ............ el ... de ........... de ....., i en el seu nom i representació D. .........................., actuant en qualitat de .............., amb DNI ........., i de la qual té concedit poder en escriptura atorgada davant el Notari de .............. D. ..................... el ... de ............ de ....., poder que no l’ha estat derogat.

D’altra part ................. (des d’ara, l’EMPRESA CONTRACTANT) amb CIF ............, i seu en .........................................., que va ser constituïda davant el Notari de ................... D. ................................, el ... de ........... de ....., inscrita en el Registre Mercantil de ............ el ... de ........... de ....., i en el seu nom i representació D. .........................., actuant en qualitat de .............., amb DNI ........., i de la qual té concedit poder en escriptura atorgada davant el Notari de .............. D. ..................... el ... de ............ de ....., poder que no l’ha estat derogat.

Ambdós representants, reconeixent-se mútuament capacitat jurídica suficient, subscriuen en nom de les respectives entitats el present contracte i, a aquest efecte,

EXPOSEN PRIMER.- Que l’EMPRESA CONTRACTANT, està interessada en contractar a

l’EMPRESA CONTRACTADA per a dur a terme un projecte d’automatització, control i gestió del magatzem en les seves instal·lacions.

SEGON.- L’EMPRESA CONTRACTANT, està completament capacitada per poder dur a terme el projecte, motiu d’aquest contracte.

I en conseqüència, ambdues parts col·laboren d’acord les següents

CLÀUSULES

73

PRIMERA.- OBJECTE DEL CONTRACTE

L’objecte del present contracte, és la realització per part de l’EMPRESA CONTRACTADA del projecte “Gestió òptima de l’estoc en la unitat d’emmagatzematge integrada en la cèl·lula de fabricació flexible” (des d’ara, el PROJECTE) per a les instal·lacions (des d’ara, el MAGATZEM) situades .......................................................... , per a l’EMPRESA CONTRACTANT i a sol·licitud de la mateixa.

SEGONA.- CONDICIONS D’ACCEPTACIÓ DEL CONTRACTE

L’EMPRESA CONTRACTADA accepta realitzar aquest PROJECTE d’acord amb el pla de treball i pressupost de despeses que s’especifiquen en la memòria tècnica del PROJECTE que s’adjunta al present contracte com Annex 1.

TERCERA.- TERMINI D’EXECUCIÓ

La duració del present projecte serà de 4 mesos, comptats a partir de la data de la signatura del present contracte. Aquest termini pot ser prorrogat de mutu acord si ambdues parts ho considerin oportú.

QUARTA.-RESPONSABLES DEL PROJECTE

El responsable de la realització del PROJECTE per part de l’EMPRESA CONTRACTADA, serà el Sr. Víctor Manuel Vega Hoyo(des d’ara RESPONSABLE TÈCNIC), responsable tècnic assignat a dur a terme aquest projecte, amb DNI. 39888927-G.

CINQUENA.- IMPORT DEL PROJECTE

El Pressupost total del PROJECTE ascendeix a la quantitat de 9971,00 Euros. A aquesta quantitat se li haurà d’incrementar el corresponent IVA i es farà efectiva en el numero de compte ........................... oberta en ....................... a nom de ........................ Factura a nom de la EMPRESA CONTRACTADA.

SISENA.- TERMINIS DE PAGAMENT

El pagament de la quantitat esmentada en el apartat anterior, s’haurà de fer efectiu en dos terminis. Un quantitat de 4000 Euros s’entregarà en un període màxim de 15 dies a partir de la data de la signatura de contracte. La resta, 7566,36 Euros, s’entregaran al finalitzar el projecte.

74

SETENA.- OBLIGACIONS DE L’EMPRESA CONTRACTADA

L’EMPRESA CONTRACTADA es responsabilitza del correcte funcionament del programa en el MAGATZEM fins que les dues parts contractants donin el PROJECTE per finalitzat.

VUITENA.- PRESTACIÓNS DEL SOFTWARE

L’EMPRESA CONTRACTADA es compromet a realitzar un software específic per al MAGATZEM que permeti a l’EMPRESA CONTRACTANT:

• Gestionar les entrades al MAGATZEM.

• Gestionar les sortides al MAGATZEM.

• Gestionar les caselles de dins del MAGATZEM , permetent canviar la ubicació dels palets.

• Visualitzar l’estat del MAGATZEM en tot moment així com el control d’estoc.

• Visualitzar un historial d’accions realitzades en el MAGATZEM

• Programar un seguit d’ordres que es duran a terme quan l’usuari del software ho estipuli.

NOVENA .- FINALITZACIÓ DEL PROJECTE

El programa es donarà per finalitzat quan el software creat per l’EMPRESA CONTRACTADA sigui capaç de realitzar les tasques esmentades en la clàusula VUITENA i les dues parts contractants hi estiguin d’acord.

DESENA.- RESPONSABILITATS

Quan les dues parts contractants donin el PROJECTE per finalitzat segons la clàusula NOVENA, l’EMPRESA CONTRACTADA es responsabilitza a:

Oferir un curset de 2 hores a un màxim de 10 persones que l’EMPRESA CONTRACTANT determini.

Oferir un servei de manteniment com a garantia del software, a partir de la data de finalització i durant els dos anys següents, l’EMPRESA CONTRACTANT.

ONZENA.- MODIFICACIONS DEL SOFTWARE

Qualsevol modificació en el PROJECTE haurà de ser comprovada i acceptada pel RESPONSABLE TÈCNIC juntament amb l’EMPRESA CONTRACTANT, en el cas de no complir aquesta clàusula, l’EMPRESA CONTRACTADA pot donar per finalitzada el servei de manteniment garantit en la clàusula NOVENA.

Durant la realització del PROJECTE, en el cas que el RESPONSABLE TÈCNIC cregui convenient realitzar alguna modificació del software que no estigui contemplat en les prestacions dels software segons la clàusula SETENA, l’EMPRESA CONTRACTANT haurà de esser prèviament notificada del possible canvi i de la modificació del pressupost que suposarà.

75

DOTZENA.- COMPROMISOS

Les EMPRESES CONTRACTANT i CONTRACTADES, es comprometen a resoldre de manera amistosa qualsevol desacord que pugui sorgir en el desenvolupament del present acord. En cas de conflicte ambdues parts acorden la submissió als Tribunals de Tarragona, amb renúncia del seu propi fur.

I en prova de conformitat de quant antecedeix, signen per duplicat de totes les pàgines el present document en el lloc i data dalt indicats.

Per l’EMPRESA CONTRACTANT per l’EMPRESA CONTRACTADA

77

8 ANNEX 1 – CODI DEL PROGRAMA // MAGATZEM1Dlg.cpp : implementation file // ///////////////////////////////////////////// // AUTOR: Víctor Manuel Vega Hoyo // // a/e: [email protected] // // data: 05/06/2008 // // software de lliure distribució // ///////////////////////////////////////////// ///////////////////////////////////////////// // LLIBRERIES // ///////////////////////////////////////////// #include "stdafx.h" #include "MAGATZEM1.h" #include "InsertarDlg.h" #include "EntrarDlg.h" #include "TreureDlg.h" #include "TipusDlg.h" #include "EstocDlg.h" #include "HistorialDlg.h" #include "OrdresDlg.h" #include "OpcionsDlg.h" #include "MAGATZEM1Dlg.h" #include "magatzem.h" //Clase almacen definida por XRB #include "C:\MCC\CWIN\cbw.h" //Libreria de funciones de la tarjeta #include "math.h" #ifdef _DEBUG #define new DEBUG_NEW #undef THIS_FILE static char THIS_FILE[] = __FILE__; #endif ///////////////////////////////////////////// // VARIABLES GLOBALS i definicions // ///////////////////////////////////////////// #define REST 2047 #define RANGO 2000 #define RECOGIDO 1 #define BAJADO 2 #define EXTENDIDO 3 #define ARRIBA 4 #define TREU 0 #define DESA 1 #define MOU 2 #define CALIBRA 3 #define MIG 5 #define DRETA 6 #define ESQUERRA 7 magatzem pid1, pid2; //Creación de objetos

78

static short auxpulsos,pulsos1, pulsos2, pulsos; static unsigned short bit,posi,costat,costat_d; static double wp_memo1, wp_memo2; static short pasos_x=0,pasos_y=0, cuenta=0, pd=0, pt=0, pm=0; static int acabat=0,contador; static int canvi=0,fila=0,columna=0,modul=2,Casella1,Casella2; static int HoraAcc,MinAcc,ordres[10][4]; //opcions static int QueFer=0; //0 si continuar endevant i 1 si s'acaben les ordres static int Mode; //0 rapid 1 Economic //Vector para la calibración de cada posición struct { int x, y; } pos[73]; ///////////////////////////////////////////////////////////////////////////// // CAboutDlg dialog used for App About class CAboutDlg : public CDialog { public: CAboutDlg(); // Dialog Data //{{AFX_DATA(CAboutDlg) enum { IDD = IDD_ABOUTBOX }; //}}AFX_DATA // ClassWizard generated virtual function overrides //{{AFX_VIRTUAL(CAboutDlg) protected: virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support //}}AFX_VIRTUAL // Implementation protected: //{{AFX_MSG(CAboutDlg) //}}AFX_MSG DECLARE_MESSAGE_MAP() }; CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD) { //{{AFX_DATA_INIT(CAboutDlg) //}}AFX_DATA_INIT } void CAboutDlg::DoDataExchange(CDataExchange* pDX) { CDialog::DoDataExchange(pDX); //{{AFX_DATA_MAP(CAboutDlg) //}}AFX_DATA_MAP } BEGIN_MESSAGE_MAP(CAboutDlg, CDialog) //{{AFX_MSG_MAP(CAboutDlg) // No message handlers //}}AFX_MSG_MAP END_MESSAGE_MAP()

79

///////////////////////////////////////////////////////////////////////////// // CMAGATZEM1Dlg dialog CMAGATZEM1Dlg::CMAGATZEM1Dlg(CWnd* pParent /*=NULL*/) : CDialog(CMAGATZEM1Dlg::IDD, pParent) { //{{AFX_DATA_INIT(CMAGATZEM1Dlg) //}}AFX_DATA_INIT // Note that LoadIcon does not require a subsequent DestroyIcon in Win32 m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME); } void CMAGATZEM1Dlg::DoDataExchange(CDataExchange* pDX) { CDialog::DoDataExchange(pDX); //{{AFX_DATA_MAP(CMAGATZEM1Dlg) //}}AFX_DATA_MAP } BEGIN_MESSAGE_MAP(CMAGATZEM1Dlg, CDialog) //{{AFX_MSG_MAP(CMAGATZEM1Dlg) ON_WM_SYSCOMMAND() ON_WM_PAINT() ON_WM_QUERYDRAGICON() ON_BN_CLICKED(IDEXIT, OnExit) ON_BN_CLICKED(IDINSERTAR, OnInsertar) ON_BN_CLICKED(IDENTRAR, OnEntrar) ON_BN_CLICKED(IDTREURE, OnTreure) ON_WM_TIMER() ON_WM_LBUTTONDOWN() ON_WM_MOUSEMOVE() ON_WM_LBUTTONUP() ON_BN_CLICKED(ID_ESTOC, OnEstoc) ON_BN_CLICKED(ID_HISTORIAL, OnHistorial) ON_BN_CLICKED(ID_ORDRES, OnOrdres) ON_COMMAND(ID_ARCHIU_CARREGAR, OnArchiuCarregar) ON_COMMAND(ID_ARCHIU_GUARDAR, OnArchiuGuardar) ON_COMMAND(ID_ARCHIU_SORTIR, OnArchiuSortir) ON_COMMAND(ID_SOBRE_SOBREPROGRAMA, OnSobreSobreprograma) ON_COMMAND(ID_ARCHIU_CALIBRAR, OnArchiuCalibrar) ON_COMMAND(IDD_PROGRAMA_OPCIONS, OnProgramaOpcions) //}}AFX_MSG_MAP END_MESSAGE_MAP() ///////////////////////////////////////////////////////////////////////////// // CMAGATZEM1Dlg message handlers BOOL CMAGATZEM1Dlg::OnInitDialog() { CDialog::OnInitDialog(); int i,j,k,a=0; // Add "About..." menu item to system menu. // IDM_ABOUTBOX must be in the system command range. ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX); ASSERT(IDM_ABOUTBOX < 0xF000); CMenu* pSysMenu = GetSystemMenu(FALSE); if (pSysMenu != NULL) { CString strAboutMenu; strAboutMenu.LoadString(IDS_ABOUTBOX);

80

if (!strAboutMenu.IsEmpty()) { pSysMenu->AppendMenu(MF_SEPARATOR); pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu); } } // Set the icon for this dialog. The framework does this automatically // when the application's main window is not a dialog SetIcon(m_hIcon, TRUE); // Set big icon SetIcon(m_hIcon, FALSE); // Set small icon // s'omple la variable tipus amb tots els continguts de cada tipus de palet for(i=0;i<4;i++){ for(j=0;j<4;j++){ for(k=0;k<4;k++){ tipus[a][0]=i; tipus[a][1]=j; tipus[a][2]=k; a++; } } } int aux,eix_x,eix_y; for(i=0;i<10;i++){ for(j=0;j<4;j++){ ordres[i][j]=0; } } SetTimer(7,10000,NULL); for (i=1;i<73;i++) { if (i>36) aux=i-37; else aux=i-1; eix_x=(5-(aux%6)); eix_y=aux/6; if (i<37) pos[i].x=(eix_x*1304)+8; else pos[i].x=(eix_x*1304)-22; pos[i].y=(eix_y*1304)+680; } //ajust de posicions de cada casella pos[0].x=8102; pos[0].y=14; pos[1].x+=0; pos[2].x+=0; pos[3].x+=0; pos[4].x+=0; pos[5].x+=0; pos[6].x+=0; pos[1].y+=0; pos[2].y+=0; pos[3].y+=-8; pos[4].y+=-10; pos[5].y+=-15; pos[6].y+=0; pos[7].x+=0; pos[8].x+=0; pos[9].x+=0; pos[10].x+=0; pos[11].x+=0; pos[12].x+=0; pos[7].y+=0; pos[8].y+=-4; pos[9].y+=-6; pos[10].y+=-4; pos[11].y+=0; pos[12].y+=-2; pos[13].x+=0; pos[14].x+=0; pos[15].x+=0; pos[16].x+=0; pos[17].x+=0; pos[18].x+=0; pos[13].y+=2; pos[14].y+=2; pos[15].y+=2; pos[16].y+=4; pos[17].y+=4; pos[18].y+=6;

81

pos[19].x+=0; pos[20].x+=0; pos[21].x+=0; pos[22].x+=0; pos[23].x+=0; pos[24].x+=0; pos[19].y+=-12; pos[20].y+=-8; pos[21].y+=-5; pos[22].y+=-4; pos[23].y+=-3; pos[24].y+=3; pos[25].x+=0; pos[26].x+=0; pos[27].x+=0; pos[28].x+=0; pos[29].x+=0; pos[30].x+=0; pos[25].y+=-5; pos[26].y+=-4; pos[27].y+=-3; pos[28].y+=-2; pos[29].y+=1; pos[30].y+=3; pos[31].x+=-1; pos[32].x+=-1; pos[33].x+=-1; pos[34].x+=-1; pos[35].x+=-1; pos[36].x+=-1; pos[31].y+=11; pos[32].y+=11; pos[33].y+=13; pos[34].y+=13; pos[35].y+=13; pos[36].y+=13; //************************************************************************************************ pos[37].x+=0; pos[38].x+=0; pos[39].x+=0; pos[40].x+=0; pos[41].x+=0; pos[42].x+=0; pos[37].y+=0; pos[38].y+=0; pos[39].y+=0; pos[40].y+=0; pos[41].y+=0; pos[42].y+=0; pos[43].x+=0; pos[44].x+=0; pos[45].x+=0; pos[46].x+=0; pos[47].x+=0; pos[48].x+=0; pos[43].y+=0; pos[44].y+=0; pos[45].y+=0; pos[46].y+=0; pos[47].y+=-2; pos[48].y+=0; pos[49].x+=0; pos[50].x+=0; pos[51].x+=0; pos[52].x+=1; pos[53].x+=0; pos[54].x+=1; pos[49].y+=0; pos[50].y+=0; pos[51].y+=-1; pos[52].y+=0; pos[53].y+=0; pos[54].y+=0; pos[55].x+=1; pos[56].x+=1; pos[57].x+=0; pos[58].x+=0; pos[59].x+=0; pos[60].x+=1; pos[55].y+=0; pos[56].y+=0; pos[57].y+=0; pos[58].y+=0; pos[59].y+=0; pos[60].y+=0; pos[61].x+=0; pos[62].x+=0; pos[63].x+=0; pos[64].x+=0; pos[65].x+=0; pos[66].x+=0; pos[61].y+=0; pos[62].y+=0; pos[63].y+=0; pos[64].y+=0; pos[65].y+=0; pos[66].y+=0; pos[67].x+=1; pos[68].x+=1; pos[69].x+=1; pos[70].x+=1; pos[71].x+=1; pos[72].x+=1; pos[67].y+=0; pos[68].y+=0; pos[69].y+=0; pos[70].y+=0; pos[71].y+=0; pos[72].y+=0; static bool inicio=TRUE; if (inicio){ inicio=false; pid1.def_parametres(20,100,5,50); //proporcional,integrativo,derivativo,muestreo pid2.def_parametres(20,150,10,50); calibra(); wp_memo1=pos[5].x; wp_memo2=pos[5].y; } while(acabat==0); CARREGAR(); return TRUE; // return TRUE unless you set the focus to a control } void CMAGATZEM1Dlg::OnSysCommand(UINT nID, LPARAM lParam) { if ((nID & 0xFFF0) == IDM_ABOUTBOX)

82

{ CAboutDlg dlgAbout; dlgAbout.DoModal(); } else { CDialog::OnSysCommand(nID, lParam); } } // If you add a minimize button to your dialog, you will need the code below // to draw the icon. For MFC applications using the document/view model, // this is automatically done for you by the framework. void CMAGATZEM1Dlg::OnPaint() { if (IsIconic()) { CPaintDC dc(this); // device context for painting SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0); // Center icon in client rectangle int cxIcon = GetSystemMetrics(SM_CXICON); int cyIcon = GetSystemMetrics(SM_CYICON); CRect rect; GetClientRect(&rect); int x = (rect.Width() - cxIcon + 1) / 2; int y = (rect.Height() - cyIcon + 1) / 2; // Draw the icon dc.DrawIcon(x, y, m_hIcon); } else { CDialog::OnPaint(); } //es dibuixa l'estat del magatzem només començar CDC* Mdc; Mdc = GetDC(); pintar_magatzem(Mdc); } // The system calls this to obtain the cursor to display while the user drags // the minimized window. HCURSOR CMAGATZEM1Dlg::OnQueryDragIcon() { return (HCURSOR) m_hIcon; } void CMAGATZEM1Dlg::OnExit() { if(MessageBox("Segur que vol marxar del programa?","SORTIR",MB_YESNO)==IDYES){ OnOK(); } } void CMAGATZEM1Dlg::OnInsertar() { int m,i,j; CDC* Mdc; Mdc = GetDC();

83

//ES PASEN TOTES LES POSICIONS DEL MAGATZEM PER TAL DE MODIFICAR l'ARXIU EXISTEN m_dInsertarDlg.m_iCas36=magatzem[0][0][0]; m_dInsertarDlg.m_iCas35=magatzem[0][0][1]; m_dInsertarDlg.m_iCas34=magatzem[0][0][2]; m_dInsertarDlg.m_iCas33=magatzem[0][0][3]; m_dInsertarDlg.m_iCas32=magatzem[0][0][4]; m_dInsertarDlg.m_iCas31=magatzem[0][0][5]; m_dInsertarDlg.m_iCas30=magatzem[0][1][0]; m_dInsertarDlg.m_iCas29=magatzem[0][1][1]; m_dInsertarDlg.m_iCas28=magatzem[0][1][2]; m_dInsertarDlg.m_iCas27=magatzem[0][1][3]; m_dInsertarDlg.m_iCas26=magatzem[0][1][4]; m_dInsertarDlg.m_iCas25=magatzem[0][1][5]; m_dInsertarDlg.m_iCas24=magatzem[0][2][0]; m_dInsertarDlg.m_iCas23=magatzem[0][2][1]; m_dInsertarDlg.m_iCas22=magatzem[0][2][2]; m_dInsertarDlg.m_iCas21=magatzem[0][2][3]; m_dInsertarDlg.m_iCas20=magatzem[0][2][4]; m_dInsertarDlg.m_iCas19=magatzem[0][2][5]; m_dInsertarDlg.m_iCas18=magatzem[0][3][0]; m_dInsertarDlg.m_iCas17=magatzem[0][3][1]; m_dInsertarDlg.m_iCas16=magatzem[0][3][2]; m_dInsertarDlg.m_iCas15=magatzem[0][3][3]; m_dInsertarDlg.m_iCas14=magatzem[0][3][4]; m_dInsertarDlg.m_iCas13=magatzem[0][3][5]; m_dInsertarDlg.m_iCas12=magatzem[0][4][0]; m_dInsertarDlg.m_iCas11=magatzem[0][4][1]; m_dInsertarDlg.m_iCas10=magatzem[0][4][2]; m_dInsertarDlg.m_iCas9=magatzem[0][4][3]; m_dInsertarDlg.m_iCas8=magatzem[0][4][4]; m_dInsertarDlg.m_iCas7=magatzem[0][4][5]; m_dInsertarDlg.m_iCas6=magatzem[0][5][0]; m_dInsertarDlg.m_iCas5=magatzem[0][5][1]; m_dInsertarDlg.m_iCas4=magatzem[0][5][2]; m_dInsertarDlg.m_iCas3=magatzem[0][5][3]; m_dInsertarDlg.m_iCas2=magatzem[0][5][4]; m_dInsertarDlg.m_iCas1=magatzem[0][5][5]; m_dInsertarDlg.m_iCas67=magatzem[1][0][0]; m_dInsertarDlg.m_iCas68=magatzem[1][0][1]; m_dInsertarDlg.m_iCas69=magatzem[1][0][2]; m_dInsertarDlg.m_iCas70=magatzem[1][0][3]; m_dInsertarDlg.m_iCas71=magatzem[1][0][4]; m_dInsertarDlg.m_iCas72=magatzem[1][0][5]; m_dInsertarDlg.m_iCas61=magatzem[1][1][0]; m_dInsertarDlg.m_iCas62=magatzem[1][1][1]; m_dInsertarDlg.m_iCas63=magatzem[1][1][2]; m_dInsertarDlg.m_iCas64=magatzem[1][1][3]; m_dInsertarDlg.m_iCas65=magatzem[1][1][4]; m_dInsertarDlg.m_iCas66=magatzem[1][1][5]; m_dInsertarDlg.m_iCas55=magatzem[1][2][0]; m_dInsertarDlg.m_iCas56=magatzem[1][2][1]; m_dInsertarDlg.m_iCas57=magatzem[1][2][2]; m_dInsertarDlg.m_iCas58=magatzem[1][2][3]; m_dInsertarDlg.m_iCas59=magatzem[1][2][4]; m_dInsertarDlg.m_iCas60=magatzem[1][2][5]; m_dInsertarDlg.m_iCas49=magatzem[1][3][0]; m_dInsertarDlg.m_iCas50=magatzem[1][3][1]; m_dInsertarDlg.m_iCas51=magatzem[1][3][2]; m_dInsertarDlg.m_iCas52=magatzem[1][3][3]; m_dInsertarDlg.m_iCas53=magatzem[1][3][4]; m_dInsertarDlg.m_iCas54=magatzem[1][3][5];

84

m_dInsertarDlg.m_iCas43=magatzem[1][4][0]; m_dInsertarDlg.m_iCas44=magatzem[1][4][1]; m_dInsertarDlg.m_iCas45=magatzem[1][4][2]; m_dInsertarDlg.m_iCas46=magatzem[1][4][3]; m_dInsertarDlg.m_iCas47=magatzem[1][4][4]; m_dInsertarDlg.m_iCas48=magatzem[1][4][5]; m_dInsertarDlg.m_iCas37=magatzem[1][5][0]; m_dInsertarDlg.m_iCas38=magatzem[1][5][1]; m_dInsertarDlg.m_iCas39=magatzem[1][5][2]; m_dInsertarDlg.m_iCas40=magatzem[1][5][3]; m_dInsertarDlg.m_iCas41=magatzem[1][5][4]; m_dInsertarDlg.m_iCas42=magatzem[1][5][5]; //ES CRIDA AL DIALEG "INSERTAR" if(m_dInsertarDlg.DoModal()==IDOK){ //ES GUARDEN A LA VARIABLE "MAGATZEM" EL NOU ESTAT DEL MAGATZEM for(m=0;m<2;m++){ for(i=0;i<6;i++){ for(j=0;j<6;j++){ magatzem[m][i][j]=m_dInsertarDlg.magatzem[m][i][j]; } } } pintar_magatzem(Mdc); } } void CMAGATZEM1Dlg::CARREGAR() { CFile Archi; int m,i,j; CString text,texto,nr; Archi.Open ("MAGATZEM.txt", CFile::modeRead); //Abro el archivo if (Archi) //si retorna distinto de NULL es porque se pudo abrir { for(m=0;m<2;m++){ for(i=0;i<6;i++){ for(j=0;j<6;j++){ Archi.Read(&magatzem[m][i][j],sizeof(magatzem[m][i][j])); } } } Archi.Read(&Mode,sizeof(Mode)); Archi.Close (); //cierro el archivo text.Format("Carrega de l'arxiu: Correcta\n"); MessageBox(text, "MAGATZEM", MB_ICONINFORMATION); } else{ MessageBox("Error en la carrega","ERROR (E001)",MB_ICONEXCLAMATION); } } void CMAGATZEM1Dlg::pintar_magatzem(CDC *pdc) { int AnchoM=412,AltoM=400,i,j,a,AnchoB,AltoB,AnchoP=17,AltoP=25; int m;

85

//creem els colors que utilitzarem COLORREF Blanco=RGB(255,255,255); COLORREF GrisOsc=RGB(100,100,100); COLORREF Fons=RGB(0,100,85 ); COLORREF m_crColors[4]; m_crColors[0]= RGB(255,255,255); //Blanc m_crColors[1]= RGB(255,0,0); //Vermell m_crColors[2]= RGB(200,200,200); //Gris Clar m_crColors[3]= RGB(0,0,0); //Negre CString nr; CPoint p_Ini_M1,p_Fin_M1; UpdateData(TRUE); p_Ini_M1.x=50; p_Ini_M1.y=60; AnchoB=((AnchoM+10-35)/6); AltoB=((AltoM-35)/6)-10; a=36; for(m=0;m<2;m++){ //DIBUIXEM EL GRIS DEL FONS DELS MODUL (m) pdc->FillSolidRect(p_Ini_M1.x-6,p_Ini_M1.y-10,AnchoM+10,AltoM+30,Fons); pdc->FillSolidRect(p_Ini_M1.x-6,p_Ini_M1.y-50,AnchoM+10,35,Fons); pdc->SetTextColor(RGB(225,225,225)); //S'escriu el nom del mòdul nr.Format("MÒDUL %i",m+1); pdc->TextOut((p_Ini_M1.x-28+(10+AnchoM)/2),p_Ini_M1.y-38,nr); //DIBUIXEM LES CASELLES DEL MODUL for(i=0;i<6;i++){ for(j=0;j<6;j++){ //Selecciona el color de fons dels numeros de les caselles i el color del text pdc->SetTextColor(RGB(200,200,200)); pdc->SetBkColor(Fons); //S'escriu el numero de cada casella sota de cada quadrat nr=""; nr.Format("%2i",a); pdc->TextOut((p_Ini_M1.x+AnchoB/2-7)+j*(5+AnchoB),(p_Ini_M1.y+AltoB+2)+i*(AltoB+20),nr); //es dibuixa l'espai blanc de cada casella pdc->FillSolidRect(p_Ini_M1.x+j*(5+AnchoB),p_Ini_M1.y+i*(AltoB+20),AnchoB,AltoB,Blanco); //si hi ha palet en la casella, es pinta el palet i les peces if(magatzem[m][i][j]>=0&&magatzem[m][i][j]<64){ pdc->FillSolidRect(p_Ini_M1.x+j*(5+AnchoB)+1,p_Ini_M1.y+i*(AltoB+20)+AltoB-7,AnchoB-2,6,GrisOsc); pdc->FillSolidRect(p_Ini_M1.x+j*(5+AnchoB)+5,p_Ini_M1.y+i*(AltoB+20)+AltoB-7-AltoP,AnchoP,AltoP,m_crColors[tipus[magatzem[m][i][j]][0]]); pdc->FillSolidRect(p_Ini_M1.x+j*(5+AnchoB)+5+AnchoP+2,p_Ini_M1.y+i*(AltoB+20)+AltoB-7-AltoP,AnchoP,AltoP,m_crColors[tipus[magatzem[m][i][j]][1]]); pdc->FillSolidRect(p_Ini_M1.x+j*(5+AnchoB)+5+2*AnchoP+4,p_Ini_M1.y+i*(AltoB+20)+AltoB-7-AltoP,AnchoP,AltoP,m_crColors[tipus[magatzem[m][i][j]][2]]); }

86

if(m==0) a--; //modul 1 else a++; } if(m==1) a-=12; } p_Ini_M1.x+=AnchoM+20; a=67; } UpdateData(FALSE); } void CMAGATZEM1Dlg::OnEntrar() { CString Text; int i,j,m; CDC* Mdc; if(m_dEntrarDlg.DoModal()==IDOK){ //si es fa clic en OK per sortir de la finestra if (m_dEntrarDlg.m_iTipusPalet<64&&m_dEntrarDlg.m_iTipusPalet>=0){ //si el tipus de palet és correcte (0-64) if (m_dEntrarDlg.m_boManual==TRUE){ //si esta seleccionat el mode manual if (m_dEntrarDlg.m_iCasellaDesti<=72&&m_dEntrarDlg.m_iCasellaDesti>0){ //si la casella desti és correcte(0-72) //CALCULEM LA POSICIÓ DE LA MATRIU MAGATZEM SEGONS LA CASELLA if(m_dEntrarDlg.m_iCasellaDesti<=36&&m_dEntrarDlg.m_iCasellaDesti>0){ i=(36-m_dEntrarDlg.m_iCasellaDesti)/6; j=(36-m_dEntrarDlg.m_iCasellaDesti)%6; m=0; }else{ i=5-((m_dEntrarDlg.m_iCasellaDesti-37)/6); j=m_dEntrarDlg.m_iCasellaDesti-(37+((5-i)*6)); m=1; } if(magatzem[m][i][j]==64){ Text.Format("s'ha introduït un palet\ndel tipus %02i a la casella %02i",m_dEntrarDlg.m_iTipusPalet,m_dEntrarDlg.m_iCasellaDesti); MessageBox(Text,"ENTRAR PALETS",MB_ICONINFORMATION); if(Magatzem(DESA,m_dEntrarDlg.m_iCasellaDesti,NULL,m_dEntrarDlg.m_iTipusPalet)){ magatzem[m][i][j]=m_dEntrarDlg.m_iTipusPalet; Mdc = GetDC(); pintar_magatzem(Mdc); } }else{ MessageBox("LA CASELLA INTRODUÏDA NO ESTÀ BUIDA","ERROR (E002)",MB_ICONEXCLAMATION); } }else{ MessageBox("LA CASELLA INTRODUÏDA ÉS ERRONIA","ERROR (E003)",MB_ICONEXCLAMATION); } }else{ if(Buscar(64)){ //CALCULEM LA POSICIÓ DE LA MATRIU MAGATZEM SEGONS LA CASELLA if(CasellesTrobades[0]<=36&&CasellesTrobades[0]>0){ i=(36-CasellesTrobades[0])/6; j=(36-CasellesTrobades[0])%6; m=0; }else{

87

i=5-((CasellesTrobades[0]-37)/6); j=CasellesTrobades[0]-(37+((5-i)*6)); m=1; } if(Magatzem(DESA,CasellesTrobades[0],NULL,m_dEntrarDlg.m_iTipusPalet)){ magatzem[m][i][j]=m_dEntrarDlg.m_iTipusPalet; Mdc = GetDC(); pintar_magatzem(Mdc); Text=""; Text.Format("s'ha introduït un palet\ndel tipus %02i a la casella %2d",m_dEntrarDlg.m_iTipusPalet,CasellesTrobades[0]); MessageBox(Text,"ENTRAR PALETS",MB_ICONINFORMATION); } }else{ MessageBox("NO HI HAN CASELLES BUIDES","ERROR (E004)",MB_ICONEXCLAMATION); } } }else{ MessageBox("EL TIPUS DE PALET ÉS ERRONI","ERROR (E005)",MB_ICONEXCLAMATION); } } } int CMAGATZEM1Dlg::Buscar(int palet) { int i,j,m,dist,c=0,a,ni,nj,nm,vi,vm,vj,min,max,trobat=0; int DIMX=6,DIMY=6; int x=13,y=13; CString text,nr; min=-1; max=DIMX*x+DIMY*y; for(c=0;c<(2*DIMX*DIMY);c++){ //nº d'iteracions for(i=0;i<DIMY;i++){ //files for(j=0;j<DIMX;j++){ //columnes for(m=0;m<2;m++){ // modul 1 i 2 if(magatzem[m][i][j]==palet){ dist = Distancia(i,j,m); //Caluclem la distància if(dist==min){ if(i!=vi||j!=vj||m!=vm){ CasellesTrobades[c]=casella(i,j,m); //guardem la casella en el vector if(trobat==0){ trobat=1; } c++; } }else if(dist>min){ if(dist<=max){ max=dist; ni=i; nj=j; nm=m; } } } } } }

88

min=Distancia(ni,nj,nm); max=DIMX*x+DIMY*y; if(vi==ni&&vj==nj&&vm==nm){ for(a=c;a<72;a++){ CasellesTrobades[a]=0; //omplim la resta del vector amb 0 } c=72; }else{ vi=ni; vj=nj; vm=nm; if(magatzem[nm][ni][nj]==palet){ if(trobat==0){ trobat=1; } CasellesTrobades[c]=casella(ni,nj,nm); //guardem la casella en el vector } } if(min==-1) c=72; } return(trobat); } int CMAGATZEM1Dlg::Distancia(int fil, int col, int m) { int dist; int DIMX=6,DIMY=6; int dX=13,dY=13; if(m==0){ //modul 1 dist=((DIMX-col-1)*dX)+((DIMY-fil-1)*dY); } if(m==1){ //mòdul 2 dist=(col*dX)+((DIMY-1-fil)*dY); } return(dist); } /*void CMAGATZEM1Dlg::OnBuscar() { }*/ int CMAGATZEM1Dlg::casella(int fil, int col, int m) { int cas; if(m==0){ //mòdul 1 cas=36-6*fil-col; } if(m==1){ //mòdul 2 cas=67-6*fil+col; } return(cas); } void CMAGATZEM1Dlg::OnTreure() { int i,j,m,MAX,dist,distANT,quantitat,quantitatANT,a,b; CString text,nr; CDC* Mdc; int VectorAux[72];

89

int CasellesTreure[72]; int Anterior[72]; int *VectTreure,*VectAux; for(i=0;i<72;i++){ VectorAux[i]=100; CasellesTreure[i]=100; Anterior[i]=100; } VectTreure=&CasellesTreure[0]; VectAux=&VectorAux[0]; if(m_dTreureDlg.DoModal()==IDOK){ switch(m_dTreureDlg.m_iFuncio){ case 0: if(m_dTreureDlg.m_iCasella>0&&m_dTreureDlg.m_iCasella<=72){ //CALCULEM LA POSICIÓ DE LA MATRIU MAGATZEM SEGONS LA CASELLA if(m_dTreureDlg.m_iCasella<=36&&m_dTreureDlg.m_iCasella>0){ i=(36-m_dTreureDlg.m_iCasella)/6; j=(36-m_dTreureDlg.m_iCasella)%6; m=0; }else{ i=5-((m_dTreureDlg.m_iCasella-37)/6); j=m_dTreureDlg.m_iCasella-(37+((5-i)*6)); m=1; } if(magatzem[m][i][j]!=64){ if(Magatzem(TREU,m_dTreureDlg.m_iCasella,NULL,magatzem[m][i][j])){ text=""; text.Format("S'HA TRET EL PALET DE LA CASELLA %2d DEL TIPUS %2d",m_dTreureDlg.m_iCasella,magatzem[m][i][j]); MessageBox(text,"TREURE PALETS/PECES",MB_ICONINFORMATION); magatzem[m][i][j]=64; Mdc = GetDC(); pintar_magatzem(Mdc); } }else{ MessageBox("LA CASELLA INTRODUÏDA ESTÀ BUIDA","ERROR (E006)",MB_ICONEXCLAMATION); } }else{ MessageBox("LA CASELLA INTRODUÏDA ÉS ERRONIA","ERROR (E003)",MB_ICONEXCLAMATION); } break; case 1: if(m_dTreureDlg.m_iTipusPalet>=0&&m_dTreureDlg.m_iTipusPalet<64){ if(Buscar(m_dTreureDlg.m_iTipusPalet)){ //CALCULEM LA POSICIÓ DE LA MATRIU MAGATZEM SEGONS LA CASELLA if(CasellesTrobades[0]<=36&&CasellesTrobades[0]>0){ i=(36-CasellesTrobades[0])/6; j=(36-CasellesTrobades[0])%6; m=0; }else{ i=5-((CasellesTrobades[0]-37)/6); j=CasellesTrobades[0]-(37+((5-i)*6)); m=1; } if(magatzem[m][i][j]!=64){

90

if(Magatzem(TREU,CasellesTrobades[0],NULL,magatzem[m][i][j])){ text=""; text.Format("S'HA TRET EL PALET DE LA CASELLA %2d DEL TIPUS %2d",CasellesTrobades[0],magatzem[m][i][j]); MessageBox(text,"TREURE PALETS/PECES",MB_ICONINFORMATION); magatzem[m][i][j]=64; Mdc = GetDC(); pintar_magatzem(Mdc); } }else{ MessageBox("LA CASELLA INTRODUÏDA ESTÀ BUIDA","ERROR (E006)",MB_ICONEXCLAMATION); } }else{ MessageBox("NO S'HA TROBAT CAP PALET D'AQUEST TIPUS","ERROR (E007)",MB_ICONEXCLAMATION); } }else{ MessageBox("EL TIPUS DE PALET ÉS ERRONI","ERROR (E005)",MB_ICONEXCLAMATION); } break; case 2: if(m_dTreureDlg.m_iColorPeces==-1){ MessageBox("NO S'HA SELECCIONAT CAP TIPUS DE PECES","ERROR (E008)",MB_ICONEXCLAMATION); }else{ if(m_dTreureDlg.m_iQuantitatPeces<=0&&m_dTreureDlg.m_iQuantitatPeces>15){ MessageBox("NO S'HA SELECCIONAT INTRODUÏT DE PECES","ERROR (E009)",MB_ICONEXCLAMATION); }else{ //Busca tots els palets on es troben peces del color desitjat BuscarPeces(m_dTreureDlg.m_iColorPeces+1); //El màxim de palets a tractar serà de 15. MAX=15; //Buscarem la millor combinació de palets desde 1 palet fins a 15. for(a=1;a<MAX+1;a++){ for(i=0;i<72;i++){CasellesTreure[i]=100;} combinacio(0,0,VectTreure,VectAux,m_dTreureDlg.m_iQuantitatPeces,a,1); dist=-1; quantitat=0; for(b=0;b<72;b++){ if(VectorAux[b]!=100){ if(dist==-1)dist=0; if(CasellesTrobades[VectorAux[b]]<=36&&CasellesTrobades[VectorAux[b]]>0){ i=(36-CasellesTrobades[VectorAux[b]])/6; j=(36-CasellesTrobades[VectorAux[b]])%6; m=0; }else{ i=5-((CasellesTrobades[VectorAux[b]]-37)/6); j=CasellesTrobades[VectorAux[b]]-(37+((5-i)*6)); m=1; } quantitat+=QuantitatCasellesTrobades[VectorAux[b]]; dist+=Distancia(i,j,m); } } if(dist!=-1){ distANT=-1; quantitatANT=0; for(b=0;b<72;b++){ if(Anterior[b]!=100){

91

if(distANT==-1)distANT=0; if(CasellesTrobades[Anterior[b]]<=36&&CasellesTrobades[Anterior[b]]>0){ i=(36-CasellesTrobades[Anterior[b]])/6; j=(36-CasellesTrobades[Anterior[b]])%6; m=0; }else{ i=5-((CasellesTrobades[Anterior[b]]-37)/6); j=CasellesTrobades[Anterior[b]]-(37+((5-i)*6)); m=1; } quantitatANT+=QuantitatCasellesTrobades[Anterior[b]]; distANT+=Distancia(i,j,m); } } if(distANT==-1){ for(b=0;b<72;b++){ Anterior[b]=VectorAux[b]; } }else{ if(dist<distANT){ for(b=0;b<72;b++){ Anterior[b]=VectorAux[b]; } } } } } text=""; nr=""; nr.Format("LA/LES CASELLA/ES QUE ES TREURA/N SERÀ/N\n"); text+=nr; for(b=0;b<MAX+1;b++){ if(Anterior[b]!=100){ a=Anterior[b]; Anterior[b]=CasellesTrobades[a]; nr.Format("%02d => casella:%2d\n",b,Anterior[b]); text+=nr; } } nr.Format("\nHi està d'acord?"); text+=nr; if((MessageBox(text,"CASELLES FINAL",MB_OKCANCEL|MB_ICONINFORMATION))==IDOK){ //començar moviments contador=0; for(b=0;b<MAX+1;b++){ if(Anterior[b]!=100){ ordres[b][0]=0; ordres[b][1]=Anterior[b]; ordres[b][2]=0; ordres[b][3]=0; } } Mdc = GetDC(); pintar_magatzem(Mdc); if (!SetTimer(6,1000,NULL)) { MessageBox("ERROR starting Windows Timer",NULL, MB_OK | MB_ICONEXCLAMATION); } } } } break;

92

} } } int CMAGATZEM1Dlg::coincideix(int palet, int producte) { int i,trobat=0; CString text; for(i=0;i<3;i++){ if(tipus[palet][i]==producte) trobat++; } if(palet==64) trobat=0; return(trobat); } int CMAGATZEM1Dlg::BuscarPeces(int producte) { int i,j,m,dist,c=0,a,ni,nj,nm,vi,vm,vj,min,max,trobat=0,quantitat; int DIMX=6,DIMY=6; int x=13,y=13; CString text,nr; min=-1; max=DIMX*x+DIMY*y; for(c=0;c<(2*DIMX*DIMY);c++){ //nº d'iteracions for(i=0;i<DIMY;i++){ //files for(j=0;j<DIMX;j++){ //columnes for(m=0;m<2;m++){ // modul 1 i 2 quantitat=coincideix(magatzem[m][i][j],producte); // mirem si el palet conté pistons dels desitjats if(quantitat){ dist = Distancia(i,j,m); //calculem distància if(dist==min){ if(i!=vi||j!=vj||m!=vm){ CasellesTrobades[c]=casella(i,j,m); //guardem la casella en el vector QuantitatCasellesTrobades[c]=quantitat; //guardem la quantitat de peces en el vector if(trobat==0){ trobat=1; } c++; } }else if(dist>min){ if(dist<=max){ max=dist; ni=i; nj=j; nm=m; } } } } } } min=Distancia(ni,nj,nm); max=DIMX*x+DIMY*y; if(vi==ni&&vj==nj&&vm==nm){ for(a=c;a<72;a++){ //omplim la resta del vector amb 0

93

CasellesTrobades[a]=0; QuantitatCasellesTrobades[a]=0; } c=72; }else{ vi=ni; vj=nj; vm=nm; quantitat=coincideix(magatzem[nm][ni][nj],producte); if(quantitat){ if(trobat==0){ trobat=1; } //Guardem en el vector la nova casella CasellesTrobades[c]=casella(ni,nj,nm); QuantitatCasellesTrobades[c]=quantitat; } } if(min==-1) c=72; } return(trobat); } int CMAGATZEM1Dlg::minim(int index, int falten) { int i,j,m,a,ind=0,min=10000,dist,MAX; int quantitat; a=index; while(CasellesTrobades[a]!=0&&a<72){ a++; } MAX=a; for(a=(index);a<MAX;a++){ //CALCULEM LA POSICIÓ DE LA MATRIU MAGATZEM SEGONS LA CASELLA if(CasellesTrobades[a]<=36&&CasellesTrobades[a]>0){ i=(36-CasellesTrobades[a])/6; j=(36-CasellesTrobades[a])%6; m=0; }else{ i=5-((CasellesTrobades[a]-37)/6); j=CasellesTrobades[a]-(37+((5-i)*6)); m=1; } quantitat=QuantitatCasellesTrobades[a]; dist = Distancia(i,j,m); if(quantitat>=falten){ if(dist<min){ //si la quantitat es suficient i la distancia mínima, es retorna aquesta casella min=dist; ind=a; } } } return(ind); } int CMAGATZEM1Dlg::combinacio(int index1, int index2,int *VectTreure,int *VectAux, int falten, int necesari, int primari)

94

{ int faltenaux,i,j,m,a,b,quantitat,dist,distaux=10000,num,enc=0,enc2=0; int r; int x=10,y=15; int MAX; CString nr,text; a=index1; while(CasellesTrobades[a]!=0&&a<72){ a++; } MAX=a; //si la quantitat de peces necesaries es més d'una if(necesari>1){ for(a=index1;a<(MAX-necesari+1);a++){ //CALCULEM LA POSICIÓ DE LA MATRIU MAGATZEM SEGONS LA CASELLA if(CasellesTrobades[a]<=36&&CasellesTrobades[a]>0){ i=(36-CasellesTrobades[a])/6; j=(36-CasellesTrobades[a])%6; m=0; }else{ i=5-((CasellesTrobades[a]-37)/6); j=CasellesTrobades[a]-(37+((5-i)*6)); m=1; } //guaredem la 1a casella del vector quantitat=QuantitatCasellesTrobades[a]; *(VectTreure+index2)=a; faltenaux=falten-quantitat; //cridem a la funció combinar amb els nous paràmetres combinacio(a+1,index2+1,VectTreure,VectAux,faltenaux,necesari-1,0); dist=0; distaux=100000; num=0; enc2=0; for(b=0;b<MAX;b++){ //CALCULEM LA POSICIÓ DE LA MATRIU MAGATZEM SEGONS LA CASELLA r=*(VectTreure+b); if(r!=100){ if(CasellesTrobades[r]<=36&&CasellesTrobades[r]>0){ i=(36-CasellesTrobades[r])/6; j=(36-CasellesTrobades[r])%6; m=0; }else{ i=5-((CasellesTrobades[r]-37)/6); j=CasellesTrobades[r]-(37+((5-i)*6)); m=1; } quantitat=QuantitatCasellesTrobades[r]; dist+=Distancia(i,j,m); num+=quantitat; enc2=1; } } //comparem la nova combinació amb l'anterior per guardar la millor if(enc2==0) dist=100000; if(dist!=0){ for(b=0;b<MAX;b++){ if(*(VectAux+b)!=100){ enc=1; } } }

95

if(enc==1){ for(b=0;b<MAX;b++){ if(*(VectAux+b)!=100){ if(distaux==100000)distaux=0; //CALCULEM LA POSICIÓ DE LA MATRIU MAGATZEM SEGONS LA CASELLA if(CasellesTrobades[*(VectAux+b)]<=36&&CasellesTrobades[*(VectAux+b)]>0){ i=(36-CasellesTrobades[*(VectAux+b)])/6; j=(36-CasellesTrobades[*(VectAux+b)])%6; m=0; }else{ i=5-((CasellesTrobades[*(VectAux+b)]-37)/6); j=CasellesTrobades[*(VectAux+b)]-(37+((5-i)*6)); m=1; } quantitat=QuantitatCasellesTrobades[*(VectAux+b)]; distaux+=Distancia(i,j,m); } if(dist<distaux&&primari==1||distaux==100000){ for(b=0;b<MAX;b++){ *(VectAux+b)=*(VectTreure+b); } } } }else{ for(b=0;b<MAX;b++){ *(VectAux+b)=*(VectTreure+b); } } } } //si la quantitat de peces necesaries es d'una if(necesari==1){ //cridem a la funció minim amb les caselles entre les que ha de buscar i=minim(index1,falten); if(QuantitatCasellesTrobades[i]<falten){ for(b=0;b<MAX;b++){ *(VectTreure+b)=100; } }else{ *(VectTreure+index2)=i; } } return(0); } void CMAGATZEM1Dlg::calibra() { if ((pt)||(pm)||(pd)) { MessageBox("ERROR Proceso Activo",NULL, MB_OK | MB_ICONEXCLAMATION); } else { KillTimer(1); acabat=1; wp_memo1=pid1.wishpos; wp_memo2=pid2.wishpos; cbAOut(0,0,BIP10VOLTS,2047); cbAOut(0,1,BIP10VOLTS,2057); if (!SetTimer(2,50,NULL)) MessageBox("ERROR starting Windows Timer",NULL, MB_OK | MB_ICONEXCLAMATION); pasos_x=1; pasos_y=1; cbAOut(0,0,BIP10VOLTS,-RANGO+2047);

96

cbAOut(0,1,BIP10VOLTS,-RANGO+2057); } } bool CMAGATZEM1Dlg::mou_safata(int costat) { unsigned short bit1,bit2, bit3; cbDBitOut(0,AUXPORT,costat,1); //Mueve hacia al lado indicado. cbDBitIn(0, FIRSTPORTA,MIG,&bit1); //Lectura de los sensores de posición cbDBitIn(0, FIRSTPORTA,DRETA,&bit2); //de la bandeja. cbDBitIn(0, FIRSTPORTA,ESQUERRA,&bit3); if ((bit1)&&(bit2)&&(bit3)){ //Cuando esten todos activos el relé cbDBitOut(0,AUXPORT,costat,0); //correspondiente estarà activo. Entonces return 1; //bandeja en movimiento. } return 0; } int CMAGATZEM1Dlg::Magatzem(unsigned short accio, unsigned short casella1, unsigned short casella2, int tipus) { CTime curTime = CTime::GetCurrentTime(); CFile Archi; int dia,mes,any,hora,min,tip,acc,Cas1,Cas2; if (!comprova_parametres(accio,casella1,casella2)&&(!pt)&&(!pm)&&(!pd)) { //Verifica parametros y que no haya //ningún proceso en marcha if ((0<casella1)&&(casella1<37)) costat=ESQUERRA; if ((36<casella1)&&(casella1<73)) costat=DRETA; switch (accio) { case TREU: if (!SetTimer(4,50,NULL)) { MessageBox("ERROR starting Windows Timer",NULL, MB_OK | MB_ICONEXCLAMATION); break; } pid1.wishpos=pos[casella1].x; pid2.wishpos=pos[casella1].y; posi=casella1; pt=1; acc=accio; Cas1=casella1; Cas2=casella2; dia=curTime.GetDay(); mes = curTime.GetMonth(); any = curTime.GetYear(); hora = curTime.GetHour(); min = curTime.GetMinute(); tip = tipus; Archi.Open ("Historial.txt", CFile::modeCreate |CFile::modeNoTruncate| CFile::modeWrite); Archi.SeekToEnd(); Archi.Write (&acc ,sizeof(acc)); Archi.Write (&Cas1 ,sizeof(Cas1)); Archi.Write (&Cas2 ,sizeof(Cas2)); Archi.Write (&dia ,sizeof(dia)); Archi.Write (&mes ,sizeof(mes)); Archi.Write (&any ,sizeof(any)); Archi.Write (&hora ,sizeof(hora));

97

Archi.Write (&min ,sizeof(min)); Archi.Write (&tip ,sizeof(tip)); Archi.Close (); break; case DESA: if (!SetTimer(3,50,NULL)){ MessageBox("ERROR starting Windows Timer",NULL, MB_OK | MB_ICONEXCLAMATION); break; } pid1.wishpos=pos[0].x; pid2.wishpos=pos[0].y; posi=casella1; pd=1; acc=accio; Cas1=casella1; Cas2=casella2; dia=curTime.GetDay(); mes = curTime.GetMonth(); any = curTime.GetYear(); hora = curTime.GetHour(); min = curTime.GetMinute(); tip = tipus; Archi.Open ("Historial.txt", CFile::modeCreate |CFile::modeNoTruncate| CFile::modeWrite); Archi.SeekToEnd(); Archi.Write (&acc ,sizeof(acc)); Archi.Write (&Cas1 ,sizeof(Cas1)); Archi.Write (&Cas2 ,sizeof(Cas2)); Archi.Write (&dia ,sizeof(dia)); Archi.Write (&mes ,sizeof(mes)); Archi.Write (&any ,sizeof(any)); Archi.Write (&hora ,sizeof(hora)); Archi.Write (&min ,sizeof(min)); Archi.Write (&tip ,sizeof(tip)); Archi.Close (); break; case MOU: if ((0<casella2)&&(casella2<37)) costat_d=ESQUERRA; if ((36<casella2)&&(casella2<73)) costat_d=DRETA; if (!SetTimer(5,50,NULL)) { MessageBox("ERROR starting Windows Timer",NULL, MB_OK | MB_ICONEXCLAMATION); break; } pid1.wishpos=pos[casella1].x; pid2.wishpos=pos[casella1].y; posi=casella2; pm=1; acc=accio; Cas1=casella1; Cas2=casella2; dia=curTime.GetDay(); mes = curTime.GetMonth(); any = curTime.GetYear(); hora = curTime.GetHour(); min = curTime.GetMinute();

98

tip = tipus; Archi.Open ("Historial.txt", CFile::modeCreate |CFile::modeNoTruncate| CFile::modeWrite); Archi.SeekToEnd(); Archi.Write (&acc ,sizeof(acc)); Archi.Write (&Cas1 ,sizeof(Cas1)); Archi.Write (&Cas2 ,sizeof(Cas2)); Archi.Write (&dia ,sizeof(dia)); Archi.Write (&mes ,sizeof(mes)); Archi.Write (&any ,sizeof(any)); Archi.Write (&hora ,sizeof(hora)); Archi.Write (&min ,sizeof(min)); Archi.Write (&tip ,sizeof(tip)); Archi.Close (); break; case CALIBRA: calibra(); break; } return(1); }else{ if ((pt)||(pm)||(pd)) MessageBox("ERROR Proceso Activo",NULL, MB_OK | MB_ICONEXCLAMATION); return(0); } } bool CMAGATZEM1Dlg::comprova_parametres(unsigned short cp_a, unsigned short cp_c, unsigned short cp_c_d) { if ((cp_a<0)||(cp_a>3)) { return 1; MessageBox("Parametro incorrecto",NULL, MB_OK | MB_ICONEXCLAMATION); } else { switch (cp_a) { case TREU: { if ((cp_c_d!=NULL)||(cp_c<1)||(cp_c>72)){ MessageBox("Parametro incorrecto",NULL, MB_OK | MB_ICONEXCLAMATION); return 1; } }break; case DESA: { if ((cp_c_d!=NULL)||(cp_c<1)||(cp_c>72)) { MessageBox("Parametro incorrecto",NULL, MB_OK | MB_ICONEXCLAMATION); return 1; } }break; case MOU: { if ((cp_c_d<1)||(cp_c_d>72)||(cp_c<1)||(cp_c>72)||(cp_c==cp_c_d)) { MessageBox("Parametro incorrecto",NULL, MB_OK | MB_ICONEXCLAMATION); return 1; } } break;

99

case CALIBRA: { if ((cp_c!=NULL)||(cp_c_d!=NULL)) { MessageBox("Parametro incorrecto",NULL, MB_OK | MB_ICONEXCLAMATION); return 1; } } break; } } return 0; } bool CMAGATZEM1Dlg::deposita_cinta() { static unsigned short bit,pdc=1; switch (pdc) { //pasos deposita en cinta case 1:{ cbDBitOut(0,AUXPORT,3,1); //sube brazo cbDBitIn(0, FIRSTPORTA,2,&bit); //lectura sensor abajo if (bit) { pdc=2; cbDBitOut(0,AUXPORT,3,0); } }break; case 2:{ cbDBitIn(0, FIRSTPORTA,ARRIBA,&bit); if (!bit) pdc=3; }break; case 3:{ cbDBitOut(0,AUXPORT,2,1); //Extiende brazo cbDBitIn(0, FIRSTPORTA,RECOGIDO,&bit); if (bit) { pdc=4; cbDBitOut(0,AUXPORT,2,0); } }break; case 4:{ cbDBitIn(0, FIRSTPORTA,EXTENDIDO,&bit); if (!bit) pdc=5; }break; case 5:{ cbDBitOut(0,AUXPORT,5,1); //baja brazo cbDBitIn(0, FIRSTPORTA,4,&bit); if (bit) { pdc=6; cbDBitOut(0,AUXPORT,5,0); } }break; case 6:{ cbDBitIn(0, FIRSTPORTA,BAJADO,&bit); if (!bit) pdc=7;

100

}break; case 7:{ cbDBitOut(0,AUXPORT,4,1); //recoge brazo cbDBitIn(0, FIRSTPORTA,3,&bit); if (bit) { pdc=8; cbDBitOut(0,AUXPORT,4,0); } }break; case 8:{ cbDBitIn(0, FIRSTPORTA,RECOGIDO,&bit); if (!bit) { pdc=1; return 1; } }break; } return 0; } bool CMAGATZEM1Dlg::recull_cinta() { static unsigned short bit,prc=1; switch (prc) { //pasos recoge cinta case 1:{ cbDBitOut(0,AUXPORT,2,1); //Extiende brazo cbDBitIn(0, FIRSTPORTA,RECOGIDO,&bit); if (bit) { prc=2; cbDBitOut(0,AUXPORT,2,0); } }break; case 2:{ cbDBitIn(0, FIRSTPORTA,EXTENDIDO,&bit); if (!bit) prc=3; }break; case 3:{ cbDBitOut(0,AUXPORT,3,1); //sube brazo cbDBitIn(0, FIRSTPORTA,2,&bit); //lectura sensor abajo if (bit) { prc=4; cbDBitOut(0,AUXPORT,3,0); } }break; case 4:{ cbDBitIn(0, FIRSTPORTA,ARRIBA,&bit); if (!bit) prc=5; }break; case 5:{ cbDBitOut(0,AUXPORT,4,1); //recoge brazo

101

cbDBitIn(0, FIRSTPORTA,3,&bit); if (bit) { prc=6; cbDBitOut(0,AUXPORT,4,0); } }break; case 6:{ cbDBitIn(0, FIRSTPORTA,RECOGIDO,&bit); if (!bit) prc=7; }break; case 7:{ cbDBitOut(0,AUXPORT,5,1); //baja brazo cbDBitIn(0, FIRSTPORTA,4,&bit); if (bit) { prc=8; cbDBitOut(0,AUXPORT,5,0); } }break; case 8:{ cbDBitIn(0, FIRSTPORTA,BAJADO,&bit); if (!bit){ prc=1; return 1; } }break; } return 0; } bool CMAGATZEM1Dlg::pos_ok() { static short compta; if (compta==1) { compta=0; return 1; } if ((pid1.error0==0)&&(pid2.error0==0)) { compta++; return 0; } return 0; } bool CMAGATZEM1Dlg::seq_safata(unsigned short costat,unsigned short fer) { static short ps=1; unsigned short bit1,bit2, bit3; switch (ps){ case 1: { if (pos_ok()) ps=2; return 0; } break;

102

case 2: { if (mou_safata(costat)) ps=3; return 0; }break; case 3:{ cbDBitIn(0, FIRSTPORTA,costat,&bit); if (!bit) { if (!fer) pid2.wishpos+=175; else pid2.wishpos-=175; ps=4; } return 0; }break; case 4:{ if (pos_ok()) ps=5; return 0; }break; case 5:{ if (costat==DRETA) { if (mou_safata(costat+1)) ps=6; } else { if (mou_safata (costat-1)) ps=6; } return 0; }break; case 6:{ cbDBitIn(0, FIRSTPORTA,5,&bit); //safata al mig cbDBitIn(0, FIRSTPORTA,MIG,&bit1); //Lectura de los sensores de posición cbDBitIn(0, FIRSTPORTA,DRETA,&bit2); //de la bandeja. cbDBitIn(0, FIRSTPORTA,ESQUERRA,&bit3); if(!bit1&&bit2&&bit3){ ps=1; return 1; } }break; } return 0; } void CMAGATZEM1Dlg::OnTimer(UINT nIDEvent) { CTime curTime = CTime::GetCurrentTime(); CFile Archi; int dia,mes,any,hora,min,tip,acc,Cas1,Cas2; static bool origen_x=false, origen_y=false; unsigned short origen1,origen2; static unsigned short Byte1H, Byte1L, Byte2H, Byte2L; static unsigned short ini=1; static unsigned short bit1,bit2,bit3,bit4,bit5,bit6,bit7,bit8,MAX,a; CClientDC mostra(this);

103

//********************************************************************* //cbDBitOut(0, FIRSTPORTA, 16, 1); // * //cbDBitIn(0, FIRSTPORTA, 17, &Bit); * //cbDBitIn(0, AUXPORT, 0, &Bit); * //FIRSTPORTA 16 == bit 0 del FIRSTPORTCL => CLEAR_C* * //FIRSTPORTA 17 == bit 1 del FIRSTPORTCL => CAPTURE* * //FIRSTPORTA 18 == bit 2 del FIRSTPORTCL => OE* * //********************************************************************* cbDBitOut(0, FIRSTPORTA, 17, 1); //Bloqueo de cuenta (bit capture*) cbDBitOut(0, FIRSTPORTA, 20, 1 ); // encoder 1 eje x cbDBitOut(0, FIRSTPORTA, 18, 0); //Output Enable 1(bit OEL*) cbDIn(0, FIRSTPORTB, &Byte1L); //lectura 8 bits bajos encoder eje x cbDBitOut(0, FIRSTPORTA, 18, 1); //Output disable 1(bit OEL*='1') cbDBitOut(0, FIRSTPORTA, 19, 0); //Output enable 1(bit OEH*='0') cbDIn(0, FIRSTPORTB, &Byte1H); //lectura 8 bits altos encoder eje x cbDBitOut(0, FIRSTPORTA, 19, 1); //Output disable 1(bit OEH*='1') cbDBitOut(0, FIRSTPORTA, 17, 0); //Liberamos bloqueo (bit Capture*.) cbDBitOut(0, FIRSTPORTA, 20, 0 ); // encoder 2 eje y cbDBitOut(0, FIRSTPORTA, 18, 0); //Output Enable 1(bit OEL*) cbDIn(0, FIRSTPORTB, &Byte2L); //lectura 8 bits bajos encoder 2 cbDBitOut(0, FIRSTPORTA, 18, 1); //Output disable 1(bit OEL*='1') cbDBitOut(0, FIRSTPORTA, 19, 0); //Output enable 1(bit OEH*='0') cbDIn(0, FIRSTPORTB, &Byte2H); //lectura 8 bits altos encoder 1 cbDBitOut(0, FIRSTPORTA, 19, 1); //Output disable 1(bit OEH*='1') cbDBitOut(0, FIRSTPORTA, 17, 0); //Liberamos bloqueo (bit Capture*.) pulsos1=(Byte1H<<8)|Byte1L; //acondicionamos lectura encoder 1 a 16 bits pulsos1-=0x8000; //acondicionamiento de signo // pulsos=pulsos1-pulsos_ant; //para medir velocidad // pulsos_ant=pulsos1; // PulsosAcumulados+=abs(pulsos); pulsos2=(Byte2H<<8)|Byte2L; //acondicionamos lectura encoder 2 a 12 bits pulsos2-=0x8000; //acondicionamiento de signo // sprintf(str, "PulsosAcumulados: %+08i",PulsosAcumulados); // mostra.TextOut(250, 50, str); switch (nIDEvent){ case 1: { pid1.controlpid(pulsos1,77); //control pid eje x (posicion actual, incremento) cbAOut(0,0,BIP10VOLTS,pid1.control+2047); //Salida eje x pid2.controlpid(pulsos2,78); //control pid eje y (posicion actual, incremento) cbAOut(0,1,BIP10VOLTS,pid2.control+2047); //Salida eje y }break; case 2: { cbDBitIn(0,AUXPORT,0, &origen1); cbDBitIn(0,AUXPORT,1, &origen2); if(pasos_x) {

104

switch (pasos_x){ case 1:{ if (!origen1) { cbAOut(0,0,BIP10VOLTS,2047); //parar motor pid1.consigna_pulsos(pulsos1+2000); pid1.wp_temp=pulsos1; pid1.error0=0; pid1.error1=0; pid1.error2=0; pid1.control=0; pasos_x=2; } } break; case 2:{ if (origen1) { pid1.consigna_pulsos(pulsos1); pid1.controlpid(pulsos1,1); cbAOut(0,0,BIP10VOLTS,pid1.control+2047); origen_x=true; pasos_x=3; break; } pid1.controlpid(pulsos1,1); cbAOut(0,0,BIP10VOLTS,pid1.control+2047); } break; case 3:{ pid1.controlpid(pulsos1,1); cbAOut(0,0,BIP10VOLTS,pid1.control+2047); }break; } } if (pasos_y){ switch (pasos_y){ case 1:{ if (!origen2) { cbAOut(0,1,BIP10VOLTS,2097); //parar motor pid2.consigna_pulsos(pulsos2+200); pid2.wp_temp=pulsos2; pid2.error0=0; pid2.error1=0; pid2.error2=0; pid2.control=0; pasos_y=2; } } break; case 2:{ if (origen2) { pid2.consigna_pulsos(pulsos2); pid2.controlpid(pulsos2,1); cbAOut(0,1,BIP10VOLTS,pid2.control+2047); pasos_y=3; origen_y=true; break; } pid2.controlpid(pulsos2,1); cbAOut(0,1,BIP10VOLTS,pid2.control+2047); } break;

105

case 3:{ pid2.controlpid(pulsos2,77); cbAOut(0,1,BIP10VOLTS,pid2.control+2047); }break; } } if ((origen_y)&&(origen_x)){ if((pid1.error0==0.)&&(pid2.error0==0.)){ cuenta++; } else cuenta=0; } if (cuenta==60) { cuenta=0; origen_y=false; origen_x=false; pid1.wishpos=wp_memo1; pid2.wishpos=wp_memo2; cbDBitOut(0, FIRSTPORTA, 16, 1); pid1.delay(); cbDBitOut(0, FIRSTPORTA, 16, 0); //clear_c* pid1.wishpos=wp_memo1; pid2.wishpos=wp_memo2; pid1.wp_temp=0; pid1.error0=0.; pid1.error1=0.; pid1.error2=0.; pid1.control=0.; pid2.wp_temp=0; pid2.error0=0.; pid2.error1=0.; pid2.error2=0.; pid2.control=0.; KillTimer(2); acabat=0; if (!SetTimer(1,50,NULL)) MessageBox("ERROR starting Windows Timer",NULL, MB_OK | MB_ICONEXCLAMATION); } }break; case 3:{ switch (pd) { //passes per a desar case 1:{ if (recull_cinta()) pd=2; }break;

106

case 2:{ cbDBitIn(0, FIRSTPORTA,BAJADO,&bit); if ((pos_ok())&&(!bit)) pd=3; }break; case 3:{ if (seq_safata(DRETA,TREU)) { pid1.wishpos=pos[posi].x; //destinació pid2.wishpos=pos[posi].y+175; pd=4; //extracció de peça } }break; case 4:{if (pos_ok()) pd=5; }break; case 5:{ if (seq_safata(costat,DESA)) { KillTimer(3); pd=0; acabat=0; } }break; } }break; case 4:{ switch (pt) { //passes per a treure case 1:{ if (pos_ok()) pt=2; }break; case 2:{ if (seq_safata(costat,TREU)) { pid1.wishpos=pos[0].x; pid2.wishpos=pos[0].y+175; pt=3; //extracció de peça } }break; case 3:{ cbDBitIn(0, FIRSTPORTA,BAJADO,&bit); if ((pos_ok())&&(!bit)) pt=4; }break; case 4:{ if (seq_safata(DRETA,DESA)) pt=5; }break; case 5:{ if (deposita_cinta()) { KillTimer(4); pt=0; acabat=0; }

107

}break; } }break; case 5:{ switch (pm) { //passes per a moure case 1:{ if (pos_ok()) pm=2; }break; case 2:{ if (seq_safata(costat,TREU)) { pid1.wishpos=pos[posi].x; pid2.wishpos=pos[posi].y+175; pm=3; } }break; case 3:{ if ((pos_ok())) pm=4; }break; case 4:{ if (seq_safata(costat_d,DESA)) { KillTimer(5); pm=0; acabat=0; } }break; } }break; case 6:{ int i,j,m,i2,j2,m2,a; CDC* Mdc; int Error=0; CString b; if(ordres[0][0]==0&&ordres[0][1]==0){ contador=0; for(i=0;i<10;i++){ for(j=0;j<4;j++){ ordres[i][j]=0; } } if (!SetTimer(7,10000,NULL)) { // MessageBox("ERROR starting Windows Timer",NULL, MB_OK | MB_ICONEXCLAMATION); } KillTimer(6); }else{ if(acabat==0){ MessageBox("Comença el procés ACABAT=1","INFO",MB_OK); acabat=1; //contador++; //ACTUAR SOBRE MAGATZEM switch(ordres[0][0]){ case 0: if(ordres[0][1]<=36&&ordres[0][1]>0){

108

i=(36-ordres[0][1])/6; j=(36-ordres[0][1])%6; m=0; }else{ i=5-((ordres[0][1]-37)/6); j=ordres[0][1]-(37+((5-i)*6)); m=1; } if(magatzem[m][i][j]!=64){ if(Magatzem(ordres[0][0],ordres[0][1],ordres[0][2],magatzem[m][i][j])){ magatzem[m][i][j]=64; } }else{ Error=1; } break; case 1: if(ordres[0][1]<=36&&ordres[0][1]>0){ i=(36-ordres[0][1])/6; j=(36-ordres[0][1])%6; m=0; }else{ i=5-((ordres[0][1]-37)/6); j=ordres[0][1]-(37+((5-i)*6)); m=1; } if(magatzem[m][i][j]==64){ if(Magatzem(ordres[0][0],ordres[0][1],ordres[0][2],ordres[0][3])){ magatzem[m][i][j]=ordres[contador-1][3]; } }else{ Error=1; } break; case 2: b.Format("acc:%i\nCas1:%i\nCas2:%i",ordres[0][0],ordres[0][1],ordres[0][2]); MessageBox(b,"INFO",MB_OK); if(ordres[0][1]<=36&&ordres[0][1]>0){ i=(36-ordres[0][1])/6; j=(36-ordres[0][1])%6; m=0; }else{ i=5-((ordres[0][1]-37)/6); j=ordres[0][1]-(37+((5-i)*6)); m=1; } if(ordres[0][2]<=36&&ordres[0][2]>0){ i2=(36-ordres[0][2])/6; j2=(36-ordres[0][2])%6; m2=0; }else{ i2=5-((ordres[0][2]-37)/6); j2=ordres[0][2]-(37+((5-i2)*6)); m2=1; } if(magatzem[m][i][j]!=64&&magatzem[m2][i2][j2]==64){ MessageBox("TOT ES CORRECTE","INFO",MB_OK); if(Magatzem(ordres[0][0],ordres[0][1],ordres[0][2],magatzem[m][i][j])){ a=magatzem[m][i][j]; magatzem[m][i][j]=magatzem[m2][i2][j2]; magatzem[m2][i2][j2]=a;

109

} }else{ Error=1; } break; } Mdc = GetDC(); pintar_magatzem(Mdc); if(Error==1){ MessageBox("HI HA UN ERROR","ERROR",MB_OK); //GUARDAR ERROR if(QueFer==0){ //Continuar amb la següent ordre MessageBox("HI HA UN ERROR CONTINUEM","ERROR",MB_OK); acabat=0; }else{//Acabar el programa d'ordres //GUARDEM EL ERROR EN L'HISTORIAL MessageBox("HI HA UN ERROR ACABEM TOT","ERROR",MB_OK); acc=ordres[0][0]; Cas1=ordres[0][1]; Cas2=ordres[0][2]; dia=curTime.GetDay(); mes = curTime.GetMonth(); any = curTime.GetYear(); hora = curTime.GetHour(); min = curTime.GetMinute(); tip = 100; //significa ERROR Archi.Open ("Historial.txt", CFile::modeCreate |CFile::modeNoTruncate| CFile::modeWrite); Archi.SeekToEnd(); Archi.Write (&acc ,sizeof(acc)); Archi.Write (&Cas1 ,sizeof(Cas1)); Archi.Write (&Cas2 ,sizeof(Cas2)); Archi.Write (&dia ,sizeof(dia)); Archi.Write (&mes ,sizeof(mes)); Archi.Write (&any ,sizeof(any)); Archi.Write (&hora ,sizeof(hora)); Archi.Write (&min ,sizeof(min)); Archi.Write (&tip ,sizeof(tip)); Archi.Close (); //Borrem totes les ordres i el contador el possem a 0 contador=0; for(i=0;i<10;i++){ for(j=0;j<4;j++){ ordres[i][j]=0; } } if (!SetTimer(7,10000,NULL)) { // MessageBox("ERROR starting Windows Timer",NULL, MB_OK | MB_ICONEXCLAMATION); } KillTimer(6); } } for(i=0;i<9;i++){ for(j=0;j<4;j++){ ordres[i][j]=ordres[i+1][j]; } } for(j=0;j<4;j++){ ordres[9][j]=0; } }

110

} } break; case 7:{ CString text; CTime curTime = CTime::GetCurrentTime(); int Hora,Min; UpdateData(TRUE); Hora=curTime.GetHour(); Min=curTime.GetMinute(); if(HoraAcc==Hora&&MinAcc==Min){ text.Format("ES L'HORA\ncomença proces"); MessageBox(text,"YA TA",MB_OK); contador=0; if (!SetTimer(6,1000,NULL)) { MessageBox("ERROR starting Windows Timer",NULL, MB_OK | MB_ICONEXCLAMATION); } KillTimer(7); } UpdateData(FALSE); }break; } CDialog::OnTimer(nIDEvent); } void CMAGATZEM1Dlg::OnLButtonDown(UINT nFlags, CPoint point) { int cas=0,i,j,m,AltCas,AmpCas; CString text; CPoint p1; p1.x=50; p1.y=60; AmpCas=(412/6); AltCas=(416/6); text=""; if((point.x>p1.x)&&(point.x<p1.x+412)&&(point.y>p1.y)&&(point.y<p1.y+416)){ j=(point.x-p1.x)/AmpCas; i=(point.y-p1.y)/AltCas; m=0; cas=casella(i,j,m); text.Format("Modul:%d Fila:%d, Col:%d\nCASELLA:%2d",m+1,i,j,cas); // MessageBox(text,"INFO",MB_OK); } if((point.x>(p1.x+412+20))&&(point.x<(p1.x+412+20)+412)&&(point.y>p1.y)&&(point.y<p1.y+416)){ j=(point.x-(p1.x+412+20))/AmpCas; i=(point.y-p1.y)/AltCas; m=1; cas=casella(i,j,m); text.Format("Modul:%d Fila:%d, Col:%d\nCASELLA:%2d",m+1,i,j,cas); // MessageBox(text,"INFO",MB_OK); } Casella1=cas;

111

CDialog::OnLButtonDown(nFlags, point); } void CMAGATZEM1Dlg::OnMouseMove(UINT nFlags, CPoint point) { int cas,i,j,m,AltCas,AmpCas,AmpB,AltB; CString text; CPen llapiz2(PS_SOLID,2,RGB(0,255,0)); CPoint p1,p2; CDC* Mdc; p1.x=50; p1.y=60; AmpCas=(412/6); AltCas=(416/6); AmpB=((412+10-35)/6); AltB=((400-35)/6)-10; text=""; if((point.x>p1.x)&&(point.x<p1.x+412)&&(point.y>p1.y)&&(point.y<p1.y+416)){ // MessageBox("ESTAS EN MODUL 1","INFO",MB_OK); j=(point.x-p1.x)/AmpCas; if(j==6)j=5; i=(point.y-p1.y)/AltCas; if(i==6)i=5; m=0; cas=casella(i,j,m); //text.Format("Modul:%d Fila:%d, Col:%d\nCASELLA:%2d",m+1,i,j,cas); //MessageBox(text,"INFO(2)",MB_OK); if(fila!=i||columna!=j||modul!=m){ Mdc = GetDC(); pintar_magatzem(Mdc); p2.x=p1.x+j*(AmpB+5); p2.y=p1.y+i*(AltB+20); Mdc->SelectObject(&llapiz2); Mdc->MoveTo(p2); p2.y+=AltB; Mdc->LineTo(p2); p2.x+=AmpB; Mdc->LineTo(p2); p2.y-=AltB; Mdc->LineTo(p2); p2.x-=AmpB; Mdc->LineTo(p2); fila=i; columna=j; modul=m; } canvi=1; }else if((point.x>p1.x+412+20)&&(point.x<p1.x+412+20+412)&&(point.y>p1.y)&&(point.y<p1.y+416)){ // MessageBox("ESTAS EN MODUL 1","INFO",MB_OK); j=(point.x-(p1.x+412+20))/AmpCas; if(j==6)j=5; i=(point.y-p1.y)/AltCas;

112

if(i==6)i=5; m=1; //text.Format("Modul:%d Fila:%d, Col:%d\nCASELLA:%2d",m+1,i,j,cas); //MessageBox(text,"INFO(2)",MB_OK); if(fila!=i||columna!=j||modul!=m){ Mdc = GetDC(); pintar_magatzem(Mdc); p2.x=p1.x+412+20+j*(AmpB+5); p2.y=p1.y+i*(AltB+20); Mdc->SelectObject(&llapiz2); Mdc->MoveTo(p2); p2.y+=AltB; Mdc->LineTo(p2); p2.x+=AmpB; Mdc->LineTo(p2); p2.y-=AltB; Mdc->LineTo(p2); p2.x-=AmpB; Mdc->LineTo(p2); fila=i; columna=j; modul=m; } canvi=1; }else{ if(canvi==1){ canvi=0; fila=0; columna=0; modul=2; Mdc = GetDC(); pintar_magatzem(Mdc); } } CDialog::OnMouseMove(nFlags, point); } void CMAGATZEM1Dlg::OnLButtonUp(UINT nFlags, CPoint point) { int cas=0,i2,j2,m2,i1,j1,m1,AltCas,AmpCas,a; CString text; CPoint p1; CDC* Mdc; p1.x=50; p1.y=60; AmpCas=(412/6); AltCas=(416/6); text=""; if((point.x>p1.x)&&(point.x<p1.x+412)&&(point.y>p1.y)&&(point.y<p1.y+416)){ j2=(point.x-p1.x)/AmpCas; i2=(point.y-p1.y)/AltCas; m2=0; cas=casella(i2,j2,m2); }

113

if((point.x>(p1.x+412+20))&&(point.x<(p1.x+412+20)+412)&&(point.y>p1.y)&&(point.y<p1.y+416)){ j2=(point.x-(p1.x+412+20))/AmpCas; i2=(point.y-p1.y)/AltCas; m2=1; cas=casella(i2,j2,m2); } Casella2=cas; if(Casella1!=0&&Casella2!=0&&Casella1!=Casella2){ //CALCULEM LA POSICIÓ DE LA MATRIU MAGATZEM SEGONS LA CASELLA if(Casella1<=36&&Casella1>0){ i1=(36-Casella1)/6; j1=(36-Casella1)%6; m1=0; }else{ i1=5-((Casella1-37)/6); j1=Casella1-(37+((5-i1)*6)); m1=1; } if(magatzem[m1][i1][j1 ]==64){ MessageBox("LA PRIMERA CASELLA ESTÀ BUIDA","ERROR (E010)",MB_ICONEXCLAMATION); }else{ if(magatzem[m2][i2][j2 ]!=64){ MessageBox("LA SEGONA CASELLA NO ESTÀ BUIDA","ERROR (E011)",MB_ICONEXCLAMATION); }else{ text.Format("SEGUR QUE VOLS MOURE LA CASELLA %d A LA CASELLA %d?",Casella1,Casella2); if(MessageBox(text,"INFO",MB_OKCANCEL)==IDOK){ if(Magatzem(MOU,Casella1,Casella2,magatzem[m1][i1][j1])){ a=magatzem[m1][i1][j1]; magatzem[m1][i1][j1]=magatzem[m2][i2][j2]; magatzem[m2][i2][j2]=a; Mdc = GetDC(); pintar_magatzem(Mdc); } } } } } if(Casella1!=0&&Casella2==0&&Casella1!=Casella2){ //CALCULEM LA POSICIÓ DE LA MATRIU MAGATZEM SEGONS LA CASELLA if(Casella1<=36&&Casella1>0){ i1=(36-Casella1)/6; j1=(36-Casella1)%6; m1=0; }else{ i1=5-((Casella1-37)/6); j1=Casella1-(37+((5-i1)*6)); m1=1; } if(magatzem[m1][i1][j1]!=64){ text.Format("SEGUR QUE VOLS TREURE LA CASELLA %d?",Casella1); if(MessageBox(text,"INFO",MB_OKCANCEL)==IDOK){ if(Magatzem(TREU,Casella1,NULL,magatzem[m1][i1][j1])){ magatzem[m1][i1][j1]=64; Mdc = GetDC(); pintar_magatzem(Mdc); } }

114

} } CDialog::OnLButtonUp(nFlags, point); } void CMAGATZEM1Dlg::OnEstoc() { EstocDlg m_dEstocDlg; int i,j,m; //pasem el vector de magatzem al dialeg ESTOCDLG for(m=0;m<2;m++){ for(i=0;i<6;i++){ for(j=0;j<6;j++){ m_dEstocDlg.magatzem[m][i][j]=magatzem[m][i][j]; } } } //cridem al dialeg ESTOCDLG m_dEstocDlg.DoModal(); } void CMAGATZEM1Dlg::OnHistorial() { CHistorialDlg m_dHistorialDlg; m_dHistorialDlg.DoModal(); } void CMAGATZEM1Dlg::OnOrdres() { int i,j,m; int HoraAct,MinAct,HoraF,MinF; COrdresDlg m_dOrdresDlg; CString text; CTime curTime; for(m=0;m<2;m++){ for(i=0;i<6;i++){ for(j=0;j<6;j++){ m_dOrdresDlg.Magatzem[m][i][j]=magatzem[m][i][j]; } } } for(i=0;i<10;i++){ for(j=0;j<4;j++){ m_dOrdresDlg.ordres[i][j]=ordres[i][j]; } } m_dOrdresDlg.m_Hores=HoraAcc; m_dOrdresDlg.m_Minuts=MinAcc; m_dOrdresDlg.m_QUEFER=QueFer; if(m_dOrdresDlg.DoModal()==IDOK){ for(i=0;i<10;i++){ for(j=0;j<4;j++){ ordres[i][j]=m_dOrdresDlg.ordres[i][j]; } } QueFer=m_dOrdresDlg.m_QUEFER; HoraAcc=m_dOrdresDlg.m_Hores;

115

MinAcc=m_dOrdresDlg.m_Minuts; curTime = CTime::GetCurrentTime(); HoraAct=curTime.GetHour(); MinAct=curTime.GetMinute(); if(MinAcc>=MinAct){ if(HoraAcc>=HoraAct){ HoraF=HoraAcc-HoraAct; }else{ HoraF=24-HoraAct+HoraAcc; } MinF=MinAcc-MinAct; }else{ if(HoraAcc-1>=HoraAct){ HoraF=HoraAcc-HoraAct-1; }else{ HoraF=24-HoraAct+HoraAcc-1; } MinF=60-MinAct+MinAcc; } acabat=0; text=""; text.Format("FALTEN %02dHores i %02dMinuts\n",HoraF,MinF,QueFer); MessageBox(text,"INFO",MB_OK); } } void CMAGATZEM1Dlg::OnArchiuCarregar() { CARREGAR(); } void CMAGATZEM1Dlg::OnArchiuGuardar() { CFile Archi; int m,i,j; CString text,texto,nr; Archi.Open ("MAGATZEM.txt", CFile::modeWrite); //Abro el archivo if (Archi) //si retorna distinto de NULL es porque se pudo abrir { for(m=0;m<2;m++){ for(i=0;i<6;i++){ for(j=0;j<6;j++){ Archi.Write(&magatzem[m][i][j],sizeof(magatzem[m][i][j])); } } } Archi.Write(&Mode,sizeof(Mode)); Archi.Close (); //cierro el archivo text="L'arxiu s'ha guardat correctament\n"; MessageBox(text, "MAGATZEM", MB_ICONINFORMATION); } else{ MessageBox("Error al guadar","ERROR (E012)",MB_ICONEXCLAMATION); } } void CMAGATZEM1Dlg::OnArchiuSortir() { if(MessageBox("Segur que vol marxar del programa?","SORTIR",MB_YESNO)==IDYES){

116

OnOK(); } } void CMAGATZEM1Dlg::OnSobreSobreprograma() { CAboutDlg m_dAboutDlg; m_dAboutDlg.DoModal(); } void CMAGATZEM1Dlg::OnArchiuCalibrar() { calibra(); } void CMAGATZEM1Dlg::OnProgramaOpcions() { COpcionsDlg m_dOpcionsDlg; m_dOpcionsDlg.m_Mode=Mode; if(m_dOpcionsDlg.DoModal()==IDOK){ Mode=m_dOpcionsDlg.m_Mode; } }

// MAGATZEM1Dlg.h : header file // ///////////////////////////////////////////// // AUTOR: Víctor Manuel Vega Hoyo // // a/e: [email protected] // // data: 05/06/2008 // // software de lliure distribució // ///////////////////////////////////////////// #if !defined(AFX_MAGATZEM1DLG_H__E55D151A_4234_4AD8_B9C8_45D8FF62EA56__INCLUDED_) #define AFX_MAGATZEM1DLG_H__E55D151A_4234_4AD8_B9C8_45D8FF62EA56__INCLUDED_ #include "EntrarDlg.h" // Added by ClassView #include "InsertarDlg.h" // Added by ClassView

117

#include "TreureDlg.h" // Added by ClassView #include "TipusDlg.h"// Added by ClassView #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 ///////////////////////////////////////////////////////////////////////////// // CMAGATZEM1Dlg dialog class CMAGATZEM1Dlg : public CDialog { // Construction public: bool seq_safata(unsigned short ,unsigned short ); bool pos_ok(); bool recull_cinta(); bool deposita_cinta(); bool comprova_parametres (unsigned short cp_a, unsigned short cp_c, unsigned short cp_c_d); int Magatzem(unsigned short accio, unsigned short casella1, unsigned short casella2, int tipus); bool mou_safata(int costat); void calibra(); int combinacio(int index1 , int index2 ,int *VectTreure,int *VectAux, int falten , int necesari, int primari); int minim(int index, int falten); int QuantitatCasellesTrobades[72]; int BuscarPeces(int producte); int coincideix(int palet, int producte); int CasellesTrobades[72]; int casella(int fil, int col, int m); int Distancia(int fil, int col, int m); int Buscar(int palet); int tipus[64][3]; void pintar_magatzem(CDC *pdc); int magatzem[2][6][6]; CMAGATZEM1Dlg(CWnd* pParent = NULL); // standard constructor // Dialog Data //{{AFX_DATA(CMAGATZEM1Dlg) enum { IDD = IDD_MAGATZEM1_DIALOG }; //}}AFX_DATA // ClassWizard generated virtual function overrides //{{AFX_VIRTUAL(CMAGATZEM1Dlg) protected: virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support //}}AFX_VIRTUAL // Implementation protected: HICON m_hIcon; // int VECTOR1[72]; // Generated message map functions //{{AFX_MSG(CMAGATZEM1Dlg) virtual BOOL OnInitDialog(); afx_msg void OnSysCommand(UINT nID, LPARAM lParam); afx_msg void OnPaint(); afx_msg HCURSOR OnQueryDragIcon(); afx_msg void OnExit(); afx_msg void OnInsertar(); afx_msg void OnEntrar(); afx_msg void OnTreure(); afx_msg void OnTimer(UINT nIDEvent);

118

afx_msg void OnLButtonDown(UINT nFlags, CPoint point); afx_msg void OnMouseMove(UINT nFlags, CPoint point); afx_msg void OnLButtonUp(UINT nFlags, CPoint point); afx_msg void OnEstoc(); afx_msg void OnHistorial(); afx_msg void OnOrdres(); afx_msg void OnArchiuCarregar(); afx_msg void OnArchiuGuardar(); afx_msg void OnArchiuSortir(); afx_msg void OnSobreSobreprograma(); afx_msg void OnArchiuCalibrar(); afx_msg void OnProgramaOpcions(); //}}AFX_MSG DECLARE_MESSAGE_MAP() private: CTreureDlg m_dTreureDlg; CEntrarDlg m_dEntrarDlg; void CARREGAR(); CInsertarDlg m_dInsertarDlg; }; //{{AFX_INSERT_LOCATION}} // Microsoft Visual C++ will insert additional declarations immediately before the previous line. #endif // !defined(AFX_MAGATZEM1DLG_H__E55D151A_4234_4AD8_B9C8_45D8FF62EA56__INCLUDED_)

/*

DEFINICIÓ DE FUNCIONS bool seq_safata(unsigned short ,unsigned short ); Funció encarregada de realitzar la seqüència de la safata d’alimentació bool pos_ok(); Funció que verifica tots els sensors per determiner si la planta està en una posición correcte o no bool recull_cinta(); Funció encarregada de realitzar la seqüència per entrar un palet des de la cinta transportadora bool deposita_cinta(); Funció encarregada de realitzar la seqüència per treure un palet des de la cinta transportadora bool comprova_parametres (unsigned short cp_a, unsigned short cp_c, unsigned short cp_c_d); Funció encarregada de verificar els parameters abans de realizar el moviment de la planta int Magatzem(unsigned short accio, unsigned short casella1, unsigned short casella2, int tipus); Funció encarregada de gestionar el movement del magatzem. bool mou_safata(int costat); Funció encarregada del movement de la safata central cap al costat que es digui void calibra(); Funció que calibra el sistema. Busca el punt d’origen i deixa les variables de comptatge a 0. int combinacio(int index1 , int index2 ,int *VectTreure,int *VectAux, int falten , int necesari, int primari); Funció encarregada de buscar una combinació de palets donat el nombre de palets, la quantitat de peces a subministrar i el vector de caselles posibles

119

int minim(int index, int falten); Funció encarregada de buscar el palet que tingui les peces que es necessiten amb la menor distancia int BuscarPeces(int producte); Funció encarregada de buscar palets que continguin el tipus de peces que es vol int coincideix(int palet, int producte); Funció que compta quantes peces del tipus producte es troben en el tipus de palet introduït int casella(int fil, int col, int m); Funció que retorna el numero de la casella en funció de la fila, columna i mòdul int Distancia(int fil, int col, int m); Funció que retorna la distancia d’una casella situada en una fila, columna i modul int Buscar(int palet); Funció encarregada de buscar palets del tipus introduït void pintar_magatzem(CDC *pdc); Funció encarregada de pintar en la pantalla principal l’estat del magatzem

Documents

Gestió òptima de l’estoc en la unitat d'emmagatzematge ...deeea.urv.cat/public/PROPOSTES/pub/pdf/922pub.pdf · Projecte Final de Carrera TITULACIÓ: Enginyeria Tècnica Industrial