Vendas Bebidas

Centro de Competência das Ciências Exatas e das Engenharias
Licenciatura em Engenharia Informática
2º Ano, 2º Semestre
Arquitetura de Computadores
Trabalho Prático nº3
Máquina de Bebidas AC_80C51
Programação de sistema de vendas automáticas de
bebidas
Docentes: Dionísio Barros, Élvio Jesus, Fábio Mendonça e Juan Jardim
Discente: Vítor Manuel Gavina Faria (nº 2110312)
Data de entrega: 11 de Junho de 2015

2
Arquitetura de Computadores 2014 / 2015
Vitor Manuel Gavina Faria
Aluno número 2110312
Introdução
Este Trabalho Prático teve como objetivo a programação de um sistema de vendas
automáticas de bebidas. Foi desenvolvido em “C”, linguagem de alto nível e em Assembly,
linguagem de baixo nível.
O controlador programado foi o AT89S51, com as seguintes características:
 O micro CPU de 8 bits;
 Memória Interna de Programa (4Kbytes);
 Memória Interna de Dados (256 bytes);
 2 Contadores/Temporizadores;
 1 Porta Serial Full – Duplex;
 Estrutura de Interrupção com dois níveis de prioridade 5 fontes (2 externas, 3 internas);
 RAM interna endereçável bit-a-bit;
 64Kbytes para Memória Externa de Programas;
 64Kbytes para Memória Externa de Dados;
Este processador possui espaços de endereçamento separados para dados (d:0x00) e
programas (c:0x00). Possui também registos de funções especiais da CPU, os SRF (Special
Function Register), com exceção do PC (Program Counter), estão alocados na parte superior da
Memória Interna de Dados. São eles:
 ACC – Acumulador
 B – Utilizado como fonte e destino para operações de multiplicação e divisão.
 Stack Pointer (SP) – É o ponteiro da pilha da CPU.
 DPTR (Data Pointer) – É um registrador de 16 bits usado para o endereçamento da
memória externa de dados. Eles ocupam dois espaços de 8 bits que podem ser acedidos
com DPL e DPH.
 P0, P1, P2, P3 – Usados para latch nas portas 0 à 3 de E/S.
 SBUF (Serial Data Buffer) – Utilizado para transmissão e receção de dados para a porta
série.
 PSW (Program Status Word) – Contém as flags da CPU. (8-bit)
 Registos de Temporização – Sob os pares (TH0, TL0), (TH1, TL1), (TH2, TL2). Cada par
corresponde a um registrador de 16 bits.
 Registos de Captura (apenas no 8052) – Estes registos (RCAP2H, RCAP2L) são registos
de captura para o Timer 2 “Modo de Captura”.
 Registos de Controle – IP, IE, TMOD, TCON, SCON e PCON são registos de controle e
estado do sistema de interrupção, da seção de temporização e da porta série.

3
Para a realização deste trabalho prático utilizei a aplicação µVision®
, onde desenvolvi o
código tanto da linguagem “C” como da “Assembly” seguindo a explicação e orientação dada
pelo enunciado. Com esta aplicação foi possível ir simulando a minha implementação, tendo
sendo a única simulação (teste) possível para a implementação em Assembly. Apesar de ter sido
disponibilizado pelos docentes da disciplina todo o hardware necessário a reproduzir a
realidade.
Objetivos
O trabalho teve como principal objetivo a compreensão de como implementar um
sistema, no caso o escolhido foi um, de vendas. Desde a conceção da ideia, passando pela
implementação de um algoritmo específico, depois a programação do microcontrolador e por
ultimo a verificação numa máquina de vendas, real, todo o trabalho.
Outros objetivos passam também pelo contacto com as linguagens de programação “C”
(alto nível) e de Assembly (baixo nível), de modo a poder constatar as diferenças, vantagens e
desvantagens dos dois tipos de ambiente.
Em suma a compreensão dos processos envolventes na ligação da parte eletrónica à
programável e a angariação de alguma experiência no que toca ao processo de desenvolvimento
de um projeto, desde a sua estruturação teórica até à sua implementação.

4
Discussão de resultados
Para implementar a programação de um sistema de vendas automáticas de bebidas, foi
necessário desenvolver métodos que me permitissem recriar o funcionamento de máquina
destas.
A implementação em linguagem de alto nível, foi mais intuitiva e aqui foi apenas
necessário a ter em atenção, o funcionamento deste cpu, e o comportamento da
implementação depois de programada no microprocessador. O algoritmo por mim
implementado (ver anexo IV) foi programado no microprocessador e testado na máquina tendo
ficado a funcionar como era previsto e foi delineado.
Já o algoritmo feito em “Assembly” não consegui testar. Não Programei o
microprocessador e por consequente não testei na máquina.
Mas depois de ter conseguido solucionar alguns detalhes, pela simulação feita no
µVision®
(anexo II) para uma situação de ter colocado (pressionei uma vez no botão P1 ^ 1 e
duas vezes no botão P1 ^ 3) 1,20€ (R7) para comprar a bebida 3 recebi duas moedas de 0,10€ e
uma bebida 3 voltando ao inicio outra vez. Não implementei o atraso nos botões.
Julgando pela implementação em “C” em que várias foram as vezes em que na simulação
com o µVision®
estava tudo impecável e depois de programado o microprocessador, as coisas
não correram bem, não posso garantir que a implementação em Assembly esteja a funcionar
quando transposta para a realidade
Mas fico bastante satisfeito com os resultados, visto todo este trabalho ter sido feito por
mim apenas sem o outro elemento do grupo. Desafio que impus a mim próprio (com algum
apoio do docente, que esteve sempre pronto a, me esclarecer qualquer duvida e a incentivar ao
longo do processo).

5
Conclusão
Para concluir, abordarei muito sucintamente quais foram as principais dificuldades que surgiram
durante o desenvolvimento deste trabalho e como foram solucionadas, assim como algumas
apreciações críticas ao trabalho em geral.
Quanto à implementação em “C” com a bibliografia não foi difícil ir solucionando os problemas
surgidos
Já na parte de Assembly visto este cpu ter particularidades que por mim eram desconhecidas
como;
Ter dois registos próprios para cálculos como o “B” para multiplicações e divisões, o facto de em
algumas operações o “Bit Carry” ser influenciado, tais como as de comparação o que me levou
muitas vezes a ter de rever todo o código por inteiro. E estes foram alguns dos exemplos das
dificuldades que fui tendo ao longo do processo. Outra grande dificuldade foi a gestão de tempo
visto este não ser o único projeto que tive(mos) entre mãos, mas sem duvida foi o mais
interessante de fazer
Para finalizar, acho que este projeto está bastante bem integrado no conceito de Arquitetura de
Computadores e que foi uma grande mais-valia no que toca a angariação de conhecimentos e
experiência neste ramo. Apesar das diversas adversidades, acho que estas tiveram um papel
positivo no sentido de alertar para os eventuais problemas na criação deste tipo de projetos,
principalmente no que toca a aplicar conceitos que teoricamente estão corretos mas que na
prática podem levantar alguns problemas.

6
Bibliografia
[1] “Enunciado.pdf”, http://moodle.dme.uma.pt (disciplina Arquitetura de Computadores),
consultado a 25 de Maio de 2015.
[2] “Aula11_at_c51ism.pdf”, http://moodle.dme.uma.pt (disciplina Arquitetura de
Computadores), consultado por diversas vezes.
[3] “Aula11_ChipMaster_6000XPu_Manual.pdf”, http://moodle.dme.uma.pt (disciplina
Arquitetura de Computadores), consultado por diversas vezes..
[4] “Aula11_at89s51_ds.pdf”, http://moodle.dme.uma.pt (disciplina Arquitetura de
Computadores), consultado por diversas vezes..
[5] “Aula11_Sebenta_L3_2002_2003.pdf”, http://moodle.dme.uma.pt (disciplina
Arquitetura de Computadores), consultado por diversas vezes..
[6] “Aula11_Pratica.pdf”, http://moodle.dme.uma.pt (disciplina Arquitetura de
Computadores), consultado por diversas vezes..
[7] “12ª Aula Prática laboratorial.pdf”, http://moodle.dme.uma.pt (disciplina Arquitetura
de Computadores), consultado por diversas vezes..
[8] “13ª Aula Prática laboratorial.pdf”, http://moodle.dme.uma.pt (disciplina Arquitetura
de Computadores), consultado por diversas vezes.
[9] José Delgado e Carlos Ribeiro, Arquitetura de Computadores, 5ª Edição Atualizada,
2014, ISBN 978-972-722-789-1.

7
Anexo I – Fluxogramas
(segue em anexo no formato PDF – Fluxogramas.pdf)

8

9
Anexo II – Simulação da Implementação em “Assembly”
Botão Moeda 20c
Botão Moeda 50c
Botão Moeda 50c 2ª vez

10
Bebida 3 selecionada
Depois de escolhida Bebida 3
Motor Moeda 10

11
E por fim entrega da bebida 3

12
Anexo III - Implementação em “Assembly”
// Definição das portas I/O de entrada e saída
// declaração dos botões moedas
Moeda5c EQU P1.0;
Moeda10c EQU P1.1;
Moeda20c EQU P1.2;
Moeda50c EQU P1.3;
//botoes dos motores das moedas
MotorMoedad5 EQU P2.6;
//Sensoreses das moedas
SensorMoedad5 EQU P0.2;
//declaração dos botões das bebidas
Bebida1 EQU P1.4;
Bebida2 EQU P1.5;
Bebida3 EQU P1.6;
Bebida4 EQU P1.7;
//botoes dos motores das bebidas

13
MotorB1 EQU P3.4;
MotorB2 EQU P3.5;
MotorB3 EQU P3.6;
MotorB4 EQU P3.7;
//sensor/interruptores dos motores das bebidas
SensorB1 EQU P2.0;
SensorB2 EQU P2.1;
SensorB3 EQU P2.2;
SensorB4 EQU P2.3;
// botão cancelar
Canc EQU P3.2 = 1 ;
//definição de constantes
TempoL EQU 0xef ;byte menos significativo para o temporizador 1110
1111
TempoH EQU 0xd8 ;byte mais significativo para o temporizador
1101 1000
TDelay EQU 0x64 ; 100
Mascara EQU 0x0F ; 0000 1111
MascaraB EQU 0xF0 ; 1111 0000
//preço das bebidas
PrcB1 EQU 100 ;em centimos
ValorTotal EQU 0

14
;stock bebidas ; duvida não sei se não será melhor posições de memoria
;; Stocks Nome Qnt
;StockBebidas*************************************************
STKB1 EQU 0x0A ;Bebida1 10
STKB2 EQU 0x0C ;Bebida2 10
STKB3 EQU 0x0D ;Bebida3 10
STKB4 EQU 0x0E ;Bebida4 10
;StockMoedas *************************************************
STKMD5 EQU 0x10 ;Moeda5centimos
10
STKMD10 EQU 0x12 ;Moeda10centimos 10
;**************************************************************
; R7 reservado para armazenar o TOTAL
; R6 reservado para enviar para o display
; R5 reservado para guardar Bebida Escolhida
; R4 reservado para guardar troco
; R3 reservado para guardar moeda introduzida
;****************************************************************
CSEG AT 0000h
JMP Inicio
; Se ocorrer a excepção externa 0
CSEG AT 0003h

15
;JMP InterrupcaoExt0
CSEG AT 0050H
Inicio:
MOV SP, #7 ; Inicialização da SP
CALL PrioridadeInterrupcoes ;
CALL inicializacoes ;
cicloFor:
CALL ler_moedas ; função para calcular total de moedas
inseridas
CALL ler_bebidas ;função para calcular bebida selecionada
JMP cicloFor ;
;inicializações
inicializacoes:
MOV P1 , #11111111b ;inicialização dos botoes
MOV TL1, #TempoL ;1110 1111
MOV TH1, #TempoH ;1101 1000
MOV TMOD, #0x20 ;0010 0000
;MOV SCON, #0x50 ;0101 0000 Serial port mode bit 1
(SM1=1)./(REN =1) Reception Enable bit enables serial reception when set. When cleared,
serial reception is disabled.
SETB TR1 ;TR1 = 1
SETB TI ;TI = 1

16
;variaveis globais
MOV R4, #0 ;inicializar o TROCO
MOV R5, #0 ;bebida escolhida
MOV R6, #0 ;inicializar o display
MOV R7, #0 ;ValorTotal (valor introduzido)
;inicialização dos Stocks de Bebiddas
MOV STKB1, #10 ; valor em sock
;inicialização dos Stocks das Moedas
MOV STKMD5, #10 ; valor em sock
MOV STKMD10,#10 ; valor em sock
RET
;Definição de prioridades
PrioridadeInterrupcoes:
MOV IE, #10000001b ;Ativa a interrupção externa 0
MOV IP, #00000001b ;Prioridade da interrupção externa 0
SETB IT0 ;a interrupção externa vai ser detectada na
transição descendente
RET
; Rotina de envio de valores para o visor

17
TXD_data:
cicloData:
JNB TI, cicloData ; se o bit (TI) for zero não transmite fica á espera /
como TI = 1 entra no ciclo
CLR TI ; ccomo o TI foi definido como 1 troca para
zero
MOV SBUF, R6 ; transmite
RET
; Rotina para ler moedas introduzidas na máquina
ler_moedas:
MOV a, #Mascara ;Inicialização do acumulador
com a mascara 0000 1111
ANL A, P1 ;descodifica o valor de
entrada da porta 1
MOV R3, A ;Guarda em R3 a opção
escolhida
case15:
CJNE R3, #15, case14 ;verifica se é a opção 15
CLR A ; reset ao acumulador
JMP finCase
case14:
INC STKMD5 ;atualiza o stock
CLR A ;prepara o acumulador
ADD A, #5 ;soma o valor da
moeda

18
ADD A, R7 ;soma ao total de
moedas inserido
MOV R7, a ;COLOCA NO registo
reservado ao TOTAL
MOV R6, A ;envia para o display
CALL TXD_data ;chama função para transmitir
o valor de R6 para display
MOV P1, #0xFF ;reset aos botões
; CALL my_delay
JMP finCase
case13:
INC STKMD10 ;ATUALIZA STOCK
moeda
ADD A, R7 ;soma ao total de
moedas inserido
MOV R7, A ;atualiza o registo
reservado ao TOTAL
MOV R6, A ; envia para o display
;MOV STKMD10, R1
;CALL my_delay;
JMP finCase
case11:

19
INC STKMD20 ;incrementa uma
unidade ao stock
ADD A, #20; ;soma o valor da
moeda
ADD A, R7
MOV R7, A ;atualiza o registo
reservado ao TOTAL
;MOV STKMD20, R1
;CALL my_delay;
JMP finCase
case7:
CJNE R3, #7, finCase ;verifica se é a opção 7
INC STKMD50 ;incrementa uma
unidade ao stock
moeda
ADD A, R7 ;soma o valor da
moeda ao total
MOV R7, A ;atualiza total
;MOV STKMD50, R1
;CALL my_delay;

20
JMP finCase
finCase:
RET
;Rotina para ler a bebida escolhida
ler_bebidas:
MOV a, #MascaraB ;Inicialização do acumulador
MOV B, #16 ;preparação do registo
b para a divisao
ANL A, P1 ;retira o valor da opção
DIV AB ;deslocamento de 4
bits à direita
MOV R5, A ;Guarda em R5 a
bebida escolhida
case15B: ;no caso de nao ter sido
escolhida nenhuma bebida
CJNE R5, #15, case14B
JMP finCase
case14B:
CJNE R5, #14, case13B ;verifica qual bebida escolhida
MOV R2, STKB1 ;coloca stock no registo
para posterior comparação
CJNE R2, #0 , pagamentoB1 ;VERIFICA SE TEM EM STOCK
;CALL my_delay;
JMP finCase

21
case13B:
CJNE R2, #0 , pagamentoB2 ;VERIFICA SE TEM EM STOCK se tem
salta para a função pagamento
;CALL my_delay;
JMP finCase
case11B:
;CALL my_delay;
JMP finCase
case7B:
CJNE R5, #7, finCaseB
MOV R2, STKB4
MOV P1, #0xFF
;CALL my_delay;
JMP finCaseB
finCaseB:

22
RET
;PREPARAÇAO PARA PAGAMENTO
pagamentoB1:
CJNE R7,#PrcB1, fazerTrocoB1 ;comapara valor inserido com preço da
bebida escolhida
JMP compra ;valor inserido é igual
ao preço
pagamentoB2:
CJNE R7,#PrcB1, fazerTrocoB2
JMP compra
pagamentoB3:
CJNE R7,#PrcB3, fazerTrocoB3 ;compara valor inserido com o preço
JMP compra
pagamentoB4:
CJNE R7,#PrcB4, fazerTrocoB4
JMP compra
fazerTrocoB1:
;JC ler_moedas ;se o valor introduzido for
menor que o preço
MOV A, R7
SUBB A, #PrcB1
MOV R4, A
JMP verifTroco
fazerTrocoB2:

23
MOV A, R7
SUBB A, #PrcB2
MOV R4, A
JMP verifTroco
fazerTrocoB3:
MOV A, R7
SUBB A, #PrcB3
MOV R4, A
JMP verifTroco
fazerTrocoB4:
MOV A, R7
SUBB A, #PrcB4
MOV R4, A
JMP verifTroco
;*******************************************************************
; Preparação da verficação se existe capacidade de devolver troco*
;*******************************************************************
verifTroco:
MOV a, R4 ;coloco troco no registo A para calculos
MOV R2, a ; coloco no registo 2 para primeiro avaliar se consigo
dar troco
;***************************************************
; Verificação do stock das moedas ************
;***************************************************
verificaStock50:
MOV R1, STKMD50

24
CJNE R1, #0,vtira050
verificaStock10:
MOV R1, STKMD10
CJNE R1, #0,vtira010
verificaStock05:
MOV R1, STKMD5
CJNE R1, #0,vtira05
JMP cicloFor ;noa tenho stock de moedas
;*************************************************************
; ja foi verificado o stock
; agora verificar se consigo dar
;**************************************************
; Verificar Se a Máquina consegue devolver Troco
;***************************************************
vtira050:
CJNE R2, #50,maisMenos050 ;VERIFICO SE TENHO STOCK
JMP tira050 ;não tenho verifico
proxima moeda
maisMenos050:
JC verificaStock10 ;se for menor que 50 salta para
as moedas de 10
JNC tira050 ;volta a moeda se o
troco a dar for maior que a moeda
tira050:
MOV A, R2 ;variavel aux
JZ verificadoTroco
SUBB A, #50 ;subtrair valor da
moeda
MOV R2, A ;ATUALIZO VARIAVEL
AUX

25
CLR A ; ;preparação do
acumulador para a comparação
CJNE R2, #50,maisMenos050 ;volto a verificar se dou + 50c
JMP tira050 ;tiro mais 50c
vtira010:
CJNE R2, #10,maisMenos010 ;verificação se tiro 10c
JMP tira010
maisMenos010:
JC verificaStock05 ;salta para proxima moeda se o
troco a dar for menor que a moeda
JNC tira010 ;tiro mais 10c se o
troco for maior
tira010:
MOV A, R2
JZ verificadoTroco ;quando o acumulador for zero troco
verificado
;variavel aux
SUBB A, #10 ;subtrair valor da
moeda
MOV R2, A ; atualizo o registo com
o valor da subtração
CLR A; ;preparação do
acumulador para a comparação
CJNE R2, #10,maisMenos010
JMP tira010
vtira05:
JC verificadoTroco
JMP tira05
maisMenos05:
JC verificadoTroco

26
JNC tira05 ;salta para proxima
moeda se o troco a dar for menor que a moeda
tira05:
MOV A, R2
JZ verificadoTroco
;variavel aux
SUBB A, #5
MOV R2, A
CLR A;
JMP tira05
;*****************************************************************************
********
; Fazer Troco - Existe capacidade de fazer troco
;*****************************************************************************
**********
verificadoTroco:
MOV A, R4
JZ compra
vtira50:
CJNE R4, #50,maisMenos50 ;VERIFICO SE TENHO STOCK
JMP tira050 ;não tenho verifico
proxima moeda
maisMenos50:
JC vtira10 ;se for menor que 50
salta para as moedas de 10
JNC tira050 ;volta a moeda se o
troco a dar for maior que a moeda
tira50:

27
JZ devolver50
CLR A
SUBB A, #50
MOV R4, A ;ATUALIZO TROCO
DEC STKMD50
CALL devolver50
CJNE R4, #50,maisMenos50 ;volto a verificar se dou + 50c
JMP tira50
vtira10:
JMP tira10
maisMenos10:
JC vtira5
tira10:
JZ devolver10
CLR A
SUBB A, #10
MOV R4, A
DEC STKMD10
CALL devolver10
JMP tira10
vtira5:

28
JC verificadoTroco
JMP tira5
maisMenos5:
JC devolver5
tira5:
SUBB A, #5
MOV R4, A
DEC STKMD5
CALL devolver5
JMP tira5
;*****************************************************************************
********
; Devolver Troco - devolução de moedas ao comprador
;*****************************************************************************
**********
devolver50:
SETB MotorMoedad50
rodarMotor50:
JB SensorMoedad50,rodarMotor50
roda2Motor50:
JNB SensorMoedad50 ,roda2Motor50
CLR MotorMoedad50
JMP verificadoTroco

29
devolver10:
SETB MotorMoedad10
rodarMotor10:
roda2Motor10:
CLR MotorMoedad10
JMP verificadoTroco
;RET
devolver5:
SETB MotorMoedad5
rodarMotor5:
roda2Motor5:
CLR MotorMoedad10
;RET
JMP verificadoTroco
;*****************************************************************************
********
; Entregar Bebida
;*****************************************************************************
**********
compra:
case14MB:
CJNE R5, #14, case13MB
SETB MotorB1

30
rodarMotorB1:
JB SensorB1,rodarMotorB1
roda2MotorB1:
JNB SensorB1 ,roda2MotorB1
CLR MotorB1
AJMP cicloFor
case13MB:
SETB MotorB2
rodarMotorB2:
roda2MotorB2:
CLR MotorB2
AJMP cicloFor
case11MB:
SETB MotorB3
rodarMotorB3:
roda2MotorB3:
CLR MotorB3
AJMP cicloFor
case7MB:
CJNE R5, #7, termina
SETB MotorB4
rodarMotorB4:

31
roda2MotorB4:
CLR MotorB4
AJMP cicloFor
;;Rotina de atraso ( não implementei)
;my_delay:
;MOV R0, #0
;cicloDelay100:
;MOV A, R0
;ADD A, #1
;MOV R0, A
;CJNE R0, #TDelay, cicloDelay100
;cicloDelay1001:
;CLR a
;MOV R1, #0
;ADD A, #1
;MOV R1, A
;CJNE R1, #TDelay, cicloDelay1001
;RET
END

32
Anexo IV – Implementação em “ C “
#include <reg51.h>
// Definição das portas I/O de entrada e saída
// declaração dos botões moedas
sbit Moeda5c = P1 ^ 0;
sbit MotorMoedad5 = P2^6;
//Sensoreses das moedas
sbit SensorMoedad5 = P0^2;
//declaração dos botões das bebidas
sbit Bebida1 = P1 ^ 4;
sbit MotorB1 = P3 ^ 4;
sbit SensorB1 = P2 ^ 0;

33
// botão cancelar
sbit Canc = P3 ^ 2;
//Definição de constantes
#define TempoL 0xef //byte menos significativo para o temporizador
#define TempoH 0xd8 //byte mais significativo para o temporizador
//preço das bebidas
int PrcB1 = 100;
int PrcB2 = 100;
int PrcB3 = 100;
int PrcB4 = 100;
//stock bebidas
int StockB1 = 0;
int StockB2 = 10;
int StockB3 = 10;
int StockB4 = 10;
//stock das moedas
int Stock5c = 10;
int Stock10c = 10;
int Stock20c = 10;
int Stock50c = 10;
//definição de funções
void mydelay(unsigned int); (atraso para premir botões)
void ler_valor(unsigned int); (função que interpreta moedas introduzidas)
void ler_bebida(); (função que interpreta bebida escolhida)
void pagamento(); (função que simula o pagamento – verifica bebida escolhida e calcula troco
se existir)

34
void fazer_troco(unsigned int); (função que verifica se a maquina tem capacidade de fazer
troco e de seguida devolve-lo)
void gestao_motores(); (função que faz a gestão dos motores)
void TXD_data(unsigned char); (função que envia dados a serem exibidos no visor)
void interrupcoes_init();(); (função que faz a gestão da interrupção)
void external_int0(); (função que define a interrupção- interrupt 0)
void iniciar(); (função que inicia todos os botões, foi criada apenas por segurança não era
necessaria )
//definição de variaveis glogais
unsigned int total; // Variavel total em centimos
unsigned int troco;
unsigned int bebSelec;
unsigned int estado = 1;
// ----------------------- Programa principal ----------------------------------
void interrupcoes_init(){
IE = 129;// Ativa as interrupções externa 0 (#10000011b ou #0x83)
IT0 = 1; // A interrupção externa 0 vai ser detetada na transição descendente (1 para 0)
IP = 1;
}
void main(){
//Ativar a transmissão da porta serial
SCON = 0x50; // uart in mode 1 (8 bit), REN=1
TMOD = 0x20; // use Timer 1, mode 2
TH1 = 0xFD; // 9600 Bps at 11.059MHz
TL1 = 0xFD; // timer de 8 bits
TR1 = 1; // start the timer
TI = 1; // clear the buffer
// Estado inicial
total = 0;
iniciar();
interrupcoes_init();

35
for (;;)
{
ler_valor(total);
ler_bebida();
}
}
void iniciar()
{
MotorB1 = 0;
MotorB2 = 0;
MotorB3 = 0;
MotorB4 = 0;
SensorB1 = 1;
SensorB2 = 1;
SensorB3 = 1;
SensorB4 = 1;
//Sensores das moedas
SensorMoedad5 = 1;
SensorMoedad10 = 1;
SensorMoedad50 = 1;
MotorMoedad5 = 0;
MotorMoedad10 = 0;
MotorMoedad50 = 0;
//botao cancelar
Canc = 1;
}
void mydelay(unsigned int delay ) //atraso

36
{
unsigned int i, j;
for (i = 0; i < 100; i++)
{
for (j = 0; j < delay; j++);
}
}
// Tratamento da interrupção - EX0
void external_int0() interrupt 0{
if (total !=0 && estado!=0 ){
troco = total;
fazer_troco(troco);
total = 0;
}
}
void ler_valor(unsigned int value)
{
int y = 0;
value = total;
y = (P1 & 0x0F); //introdução de uma mascara
switch (y)
{
case 15:
value = value + 0;
//P1 = 0xFF;
TXD_data(total);
break;
case 14:
value = value + 5;
Stock5c++;

37
P1 = 0xFF;
TXD_data(value);
mydelay(200);
break;
case 13:
value = value + 10;
Stock10c++;
P1 = 0xFF;
TXD_data(value);
mydelay(200);
break;
case 11:
value = value + 20;
Stock20c++;
P1 = 0xFF;
TXD_data(value);
mydelay(200);
break;
case 7:
value = value + 50;
Stock50c++;
P1 = 0xFF;
TXD_data(value);
mydelay(200);
break;
}
total = value;
}

38
void TXD_data(unsigned char value) //escrever no ecrã
{
while (TI != 1){};
TI = 0; // clear emission flag for next emission
SBUF = value; // place value in buffer
}
void ler_bebida()
{
bebSelec = 0 ;
bebSelec = (P1 & 0xF0)>>4; //introdução de uma mascara
switch (bebSelec)
{
case 14:
if (StockB1 >0 && total >= PrcB1 )
{
pagamento();
P1 = 0xFF;
mydelay(200);
}
else
ler_valor(total); //
ler_bebida();
break;
case 13:
{
pagamento();
P1 = 0xFF;
mydelay(200);

39
}
else
ler_valor(total);
break;
case 11:
{
pagamento();
P1 = 0xFF;
mydelay(200);
}
else
ler_valor(total);
break;
case 7:
{
pagamento();
P1 = 0xFF;
mydelay(200);
}
else
ler_valor(total);
break;
mydelay(200);
break;
}
ler_valor(total);
}
void pagamento()
{

40
if (Bebida1 == 0 && total == PrcB1) {
troco = 0; //preparação da variavel para o ciclo seguinte -> que o troco fica a zero
total = 0; // reset do total
gestao_motores();
}
if (Bebida1 == 0 && total > PrcB1)
{
troco = total - PrcB1;
fazer_troco(troco);
}
troco = 0;
total = 0;
gestao_motores();
}
{
// TXD_data(troco);
fazer_troco(troco);
}
troco = 0;
total = 0;
gestao_motores();
}
{
fazer_troco(troco);
}

41
troco = 0;
total = 0;
gestao_motores();}
{
estado = 0; //
mudança de estado
fazer_troco(troco);
}
}
void fazer_troco(unsigned int vtroc)
{
int verfTroco;
vtroc = verfTroco;
//verifica se existe troco
while(verfTroco !=0) {
if( Stock50c > 0 && verfTroco >= 50)
verfTroco = verfTroco - 50;
}
// Se existe Devolve/Faço Troco
if (verfTroco == 0)
while(troco !=0){
//devolução de moedas de 50 centimos

42
if( Stock50c > 0 && troco >= 50) {
troco = troco - 50;
TXD_data(troco);
while(SensorMoedad50 !=0){
MotorMoedad50 = 1 ;
}
while(SensorMoedad50 == 0){
MotorMoedad50 = 1 ;
}
MotorMoedad50 = 0 ;
Stock50c--;
continue;
}
if( Stock10c > 0 && troco >= 10) {
troco = troco - 10;
TXD_data(troco);
while(SensorMoedad10 !=0) {
MotorMoedad10 = 1 ;
}
MotorMoedad10 = 1;
}
MotorMoedad10 = 0 ;
Stock10c--;
continue;
}
if( Stock5c > 0 && troco >= 5) {
troco = troco - 5;
TXD_data(troco);

43
while(SensorMoedad5 !=0){
MotorMoedad5 = 1;
}
MotorMoedad5 = 1;
MotorMoedad5 = 0;
}
Stock5c--;
continue;
}
}
total = 0;
estado = 1;
gestao_motores();
}
void gestao_motores(){
switch (bebSelec)
{
case 14:
while(SensorB1 !=0) {
}
while(SensorB1 == 0)
{
MotorB1 = 1 ;
}
MotorB1 = 0 ;
MotorB1 = 1 ;
StockB1--;
break;
case 13:

44
while(SensorB2 !=0) {
MotorB2 = 1 ;
}
while(SensorB2 == 0) {
MotorB2 = 1 ;
}
MotorB2 = 0 ;
StockB2--;
total = 0;
break;
case 11:
while(SensorB3 !=0)
{
MotorB3 = 1 ;
}
{
MotorB3 = 1 ;
}
MotorB3 = 0 ;
StockB3--;
total = 0;
break;
case 7:
while(SensorB4 !=0)
{
MotorB4 = 1 ;
}
{
MotorB4 = 1;

45
}
MotorB4 = 0 ;
StockB4--;
total = 0;
TXD_data(total);
break;
}
}

46

Vendas Bebidas

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Vendas Bebidas

Similaire à Vendas Bebidas (20)

Vendas Bebidas