Coverage Report

Coverage Report - tempcontroller.base.ControladorAmostragem

Classes in this File

78%

70%

 /*
  * ControladorAmostragem.java
  *
  * Created on 13 de MarÃ§o de 2007, 12:48
  *
  * To change this template, choose Tools | Template Manager
  * and open the template in the editor.
  */
 
 package tempcontroller.base;
 
 import java.io.File;
 import java.io.IOException;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 
 /**
  * Controla a execução de uma amostragem, monitorando o controlador de
  * temperatura, o Timer e o Leitor de Espectro.
  */
 public class ControladorAmostragem implements
         IControladorAmostragem {
 
     /**
      * programação atual.
      */
     private IProgramacaoAmostragem programacao;
 
     /**
      * controlador de temperatura atual.
      */
     private IControladorTemperatura controladorTemperatura;
 
     /**
      * leitor de espectro atual.
      */
     private ILeitorEspectro leitorEspectro;
 
     /**
      * Conjunto de ouvintes dos eventos deste controlador.
      */
     private Set<IOuvinteEventosControladorAmostragem> ouvintes;
 
     /**
      * Status atual (muito mais que o estado atual).
      */
     private ControladorAmostragemStatus status;
 
     /**
      * Tempo total da programação.
      */
     private long tempoTotalProgramacao;
 
     /**
      * Estado do controlador.
      */
     private IControladorAmostragem.Estado estado;
 
     /**
      * Iterator da programação atual.
      */
     private Iterator<IAmostragem> programacaoIterator;
 
     /**
      * Timer atual.
      */
     private ITimer timer;
 
     /**
      * Amostragem atual.
      */
     private IAmostragem amostragemAtual;
 
     /**
      * Máxima variação de temperatura aceita.
      */
     private static final double MAX_DELTA_TEMPERATURA = 1.0;
 
     /**
      * Cria um novo controlador de amostragem.
      */
     public ControladorAmostragem() {
         limpaProgramacao();
     }
 
     /**
      * Obtém o status corrente.
      * @return O status corrente.
      */
     public final IControladorAmostragem.Status getStatus() {
         if (status == null) {
             status = new ControladorAmostragemStatus();
         } else {
             status.setTemperaturaAtual(0.0);
             status.setTempoDecorridoAmostragem(0);
             status.setTempoDecorridoProgramacao(0);
             status.setTempoTotalAmostragem(0);
             status.setTempoTotalProgramacao(0);
             status.setNomeAmostragemAtual("");
             status.setTempoDaUltimaGravacao(0);
         }
 
         status.setEstado(estado);
 
         if (!estado.equals(Estado.SEM_PROGRAMACAO)) {
             status.setTempoTotalAmostragem(tempoTotalProgramacao);
 
             if (!(estado.equals(Estado.NAO_INICIADO)
             || estado.equals(Estado.PROGRAMACAO_TERMINADA)
             || estado.equals(Estado.CANCELADO))) {
                 status.setNomeAmostragemAtual(amostragemAtual.getNome());
                 status.setTempoTotalAmostragem(amostragemAtual.getDuracao());
             }
 
             if (estado.equals(Estado.EM_AMOSTRAGEM)
             || estado.equals(Estado.ESPERANDO_RETORNO_TEMPERATURA)) {
                 status.setTempoDecorridoAmostragem(timer.getTempoDecorrido());
                 status.setTemperaturaAtual(
                         controladorTemperatura.getTemperatura());
             }
         }
 
         return status;
     }
 
     /**
      * Carrega uma programação de um arquivo.
      * @param file O arquivo que será lido.
      * @return A programação lida.
      * @throws IOException Se ocorrer algum erro de leitura.
      * @throws ClassNotFoundException Se o arquivo não tiver um
      * uma programação gravada.
      */
     public final IProgramacaoAmostragem carregaProgramacao(final File file)
     throws IOException, ClassNotFoundException {
         return (IProgramacaoAmostragem)
         Utilities.getUtilities().leSerializable(file);
     }
 
     /**
      * Grava uma programação para um arquivo.
      * @param programacaoLocal Programação que será gravada
      * @param file Arquivo que será gravado.
      * @throws IOException Se ocorrer algum erro durante a gravação.
      */
     public final void gravaProgramacao(
             final IProgramacaoAmostragem programacaoLocal,
             final File file) throws IOException {
         Utilities.getUtilities().gravaSerializable(file, programacaoLocal);
     }
 
     /**
      * Método que inicia o controlador com os objetos necessários para a
      * execução da amostragem.
      * Ele retorna o status indicando se a amostragem pode ou não prosseguir.
      * @param prog Programação de Amostragem.
      * @param control Controlador de Temperatura que será utilizado.
      * @param leitor O Leitor de espectro que será utilizado.
      * @param timerLocal O timer que será utilizado
      * @return <code>true</code> caso a programação possa ser executada com
      * este controlador, leitor de espectro e timer.
      */
     public final boolean aceita(final IProgramacaoAmostragem prog,
             final IControladorTemperatura control,
             final ILeitorEspectro leitor,
             final ITimer timerLocal) {
         //@TODO não está bom. Deveria retornar mais informações
         // caso a programação não seja aceita.
         boolean toReturn = true;
 
         List<IAmostragem> amostragens = prog.getAmostragens();
         Iterator<IAmostragem> it = amostragens.iterator();
         tempoTotalProgramacao = 0;
         while (it.hasNext()) {
             IAmostragem amostragem = it.next();
             tempoTotalProgramacao = tempoTotalProgramacao
                     + amostragem.getDuracao();
             if (!control.aceitaTemperatura(amostragem.getTemperatura())) {
                 toReturn = false;
                 break;
             }
         }
 
         if (toReturn) {
             programacao = prog;
             controladorTemperatura = control;
             leitorEspectro = leitor;
             timer = timerLocal;
         }
 
         estado = Estado.NAO_INICIADO;
 
         return toReturn;
     }
 
     /**
      * Limpa todos os recursos utilizados por este controlador, inclusive
      * a programação atual.
      */
     public final void limpaProgramacao() {
         programacao = null;
         controladorTemperatura = null;
         leitorEspectro = null;
         ouvintes = null;
         estado = Estado.SEM_PROGRAMACAO;
         tempoTotalProgramacao = 0;
         synchronized (this) {
             programacaoIterator = null;
         }
         timer = null;
         amostragemAtual = null;
     }
 
     /**
      * Adiciona um ouvinte aos eventos gerados por este controlador.
      * @param ouvinte o ouvinte que será notificado sempre que o estado
      * deste controlador mudar.
      */
     public final void addOuvinteEventosControladorAmostragem(
             final IOuvinteEventosControladorAmostragem ouvinte) {
         if (ouvintes == null) {
             ouvintes = new
                     HashSet <IOuvinteEventosControladorAmostragem>();
         }
 
         ouvintes.add(ouvinte);
     }
 
     /**
      * Remove um ouvinte dos eventos deste controlador.
      * @param ouvinte que não quer mais receber notificações
      * de mudança de estado deste controlador.
      */
     public final void removeOuvinteEventosControladorAmostragem(
             final IOuvinteEventosControladorAmostragem ouvinte) {
         if (ouvintes != null) {
             ouvintes.remove(ouvinte);
         }
     }
 
     /**
      * Notifica os ouvintes que o estado deste controlador mudou.
      */
     private void fireNewStatus() {
         if (ouvintes != null) {
             Iterator<IOuvinteEventosControladorAmostragem>
                     it = ouvintes.iterator();
             while (it.hasNext()) {
                 IOuvinteEventosControladorAmostragem ouvinte = it.next();
                 ouvinte.novoStatusControladorAmostragem();
             }
         }
     }
 
     /**
      * Inicia a execução da programação atual.
      */
     public final void start() {
         synchronized (this) {
             programacaoIterator = programacao.getAmostragens().iterator();
             estadoPreparaAmostragem();
             trataProximaAmostragem();
         }
     }
 
     /**
      * Cancela a execução da programação atual.
      */
     public final void cancel() {
         synchronized (this) {
             if (estado.equals(Estado.ESPERANDO_TEMPERATURA_INICIAL)) {
                 timer.stop();
                 
                 controladorTemperatura.cancelaTemperaturaAlvo();
             } else if (estado.equals(Estado.EM_AMOSTRAGEM)) {
                 timer.stop();
                 leitorEspectro.termina();
                 controladorTemperatura.cancelaTemperaturaAlvo();
                 gravaAmostragem();
             } else if (estado.equals(Estado.ESPERANDO_RETORNO_TEMPERATURA)) {
                 timer.stop();
                 leitorEspectro.termina();
                 controladorTemperatura.cancelaTemperaturaAlvo();
                 gravaAmostragem();
             }
 
             estadoCancelado();
         }
     }
 
     /**
      * Verifica se tem mais uma amostragem na programação, e
      * inicia sua execução.
      */
     private void trataProximaAmostragem() {
         synchronized (this) {
             if (estado.equals(Estado.PREPARA_AMOSTRAGEM)) {
                 if (programacaoIterator.hasNext()) {
                     amostragemAtual = programacaoIterator.next();
                     controladorTemperatura.setTemperaturaAlvo(
                             amostragemAtual.getTemperatura());
                     controladorTemperatura.addIOuvinteMundancaTemperatura(this);
                     timer.setTempoTotal(amostragemAtual.getDuracao());
                     timer.addOuvinteTimer(this);
                     estadoEsperandoTemperaturaInicial();
                 } else {
                     estadoProgramacaoTerminada();
                     trataTerminoProgramacao();
                 }
             }
         }
     }
 
     /**
      * Trata o final da programação.
      */
     private void trataTerminoProgramacao() {
         estadoProgramacaoTerminada();
     }
 
     /**
      * Muda o estado para PREPARA_AMOSTRAGEM.
      * Notifica os ouvintes que o estado deste controlador mudou.
      */
     private void estadoPreparaAmostragem() {
         synchronized (this) {
             estado = Estado.PREPARA_AMOSTRAGEM;
             fireNewStatus();
         }
     }
 
     /**
      * Muda o estado para ESPERANDO_TEMPERATURA_INICIAL.
      * Notifica os ouvintes que o estado deste controlador mudou.
      */
     private void estadoEsperandoTemperaturaInicial() {
         synchronized (this) {
             estado = Estado.ESPERANDO_TEMPERATURA_INICIAL;
             fireNewStatus();
         }
     }
 
     /**
      * Muda o estado para EM_AMOSTRAGEM.
      * Notifica os ouvintes que o estado deste controlador mudou.
      */
     private void estadoEmAmostragem() {
         synchronized (this) {
             estado = Estado.EM_AMOSTRAGEM;
             fireNewStatus();
         }
     }
 
     /**
      * Muda o estado para ESPERANDO_RETORNO_TEMPERATURA.
      * Notifica os ouvintes que o estado deste controlador mudou.
      */
     private void estadoEsperandoRetornoTemperatura() {
         synchronized (this) {
             estado = Estado.ESPERANDO_RETORNO_TEMPERATURA;
             fireNewStatus();
         }
     }
 
     /**
      * Muda o estado para PROGRAMACAO_TERMINADA.
      * Notifica os ouvintes que o estado deste controlador mudou.
      */
     private void estadoProgramacaoTerminada() {
         synchronized (this) {
             estado = Estado.PROGRAMACAO_TERMINADA;
             fireNewStatus();
         }
     }
 
     /**
      * Muda o estado para CANCELADO.
      * Notifica os ouvintes que o estado deste controlador mudou.
      */
     private void estadoCancelado() {
         synchronized (this) {
             estado = Estado.CANCELADO;
             fireNewStatus();
         }
     }
 
     /**
      * Notificação do controlador de temperatura indicando que
      * ele está em nova temperatura.
      * O controlador de amosragem deve verificar
      * se a temperatura está dentro dos limites estabelecidos.
      * @param temperatura A temperatura atual do controlador.
      */
     public final void novaTemperatura(final double temperatura) {
         synchronized (this) {
             if (estado.equals(Estado.EM_AMOSTRAGEM)
             && (Math.abs(temperatura - amostragemAtual.getTemperatura())
             > MAX_DELTA_TEMPERATURA)) {
                 leitorEspectro.pausa();
                 timer.pause();
                 estadoEsperandoRetornoTemperatura();
             }
         }
     }
 
     /**
      * Notificação do controlador de temperatura indicando
      * que a temperatura alvo foi alcançada.
      * O controlador de amostragem deve iniciar ou prosseguir
      * na amostragem atual.
      * @param temperatura A temperatura atual do controlador.
      */
     public final void temperaturaAlvoAlcancada(final double temperatura) {
         if (estado.equals(Estado.ESPERANDO_TEMPERATURA_INICIAL)) {
             leitorEspectro.inicia();
             timer.start();
             estadoEmAmostragem();
         } else if (estado.equals(Estado.ESPERANDO_RETORNO_TEMPERATURA)) {
             leitorEspectro.continua();
             timer.continua();
             estadoEmAmostragem();
         }
     }
 
     /**
      * Evento do timer, indicando que um tick do relógio já passou.
      * O controlador de amostragem deve gravar um espectro com resultados
      * parciais.
      */
     public final void tickDoTimer() {
         // grava amostra espectro.
     }
 
     /**
      * Evento do timer, indicando que o tempo total da amostragem atual
      * foi alcançado.
      * O controlador deve gravar a amostragem atual com os resultados
      * finais, e prosseguir com a programação.
      */
     public final void tempoTotalTerminado() {
         if (estado.equals(Estado.EM_AMOSTRAGEM)) {
             leitorEspectro.termina();
             controladorTemperatura.cancelaTemperaturaAlvo();
             gravaAmostragem();
             estadoPreparaAmostragem();
             trataProximaAmostragem();
         }
     }
 
     /**
      * Grava uma amostragem com os resultados atuais.
      */
     private void gravaAmostragem() {
         // gravar a amostragem;
     }
 }

1		/*
2		* ControladorAmostragem.java
3		*
4		* Created on 13 de MarÃ§o de 2007, 12:48
5		*
6		* To change this template, choose Tools \| Template Manager
7		* and open the template in the editor.
8		*/
9
10		package tempcontroller.base;
11
12		import java.io.File;
13		import java.io.IOException;
14		import java.util.HashSet;
15		import java.util.Iterator;
16		import java.util.List;
17		import java.util.Set;
18
19		/**
20		* Controla a execução de uma amostragem, monitorando o controlador de
21		* temperatura, o Timer e o Leitor de Espectro.
22		*/
23		public class ControladorAmostragem implements
24		IControladorAmostragem {
25
26		/**
27		* programação atual.
28		*/
29		private IProgramacaoAmostragem programacao;
30
31		/**
32		* controlador de temperatura atual.
33		*/
34		private IControladorTemperatura controladorTemperatura;
35
36		/**
37		* leitor de espectro atual.
38		*/
39		private ILeitorEspectro leitorEspectro;
40
41		/**
42		* Conjunto de ouvintes dos eventos deste controlador.
43		*/
44		private Set<IOuvinteEventosControladorAmostragem> ouvintes;
45
46		/**
47		* Status atual (muito mais que o estado atual).
48		*/
49		private ControladorAmostragemStatus status;
50
51		/**
52		* Tempo total da programação.
53		*/
54		private long tempoTotalProgramacao;
55
56		/**
57		* Estado do controlador.
58		*/
59		private IControladorAmostragem.Estado estado;
60
61		/**
62		* Iterator da programação atual.
63		*/
64		private Iterator<IAmostragem> programacaoIterator;
65
66		/**
67		* Timer atual.
68		*/
69		private ITimer timer;
70
71		/**
72		* Amostragem atual.
73		*/
74		private IAmostragem amostragemAtual;
75
76		/**
77		* Máxima variação de temperatura aceita.
78		*/
79		private static final double MAX_DELTA_TEMPERATURA = 1.0;
80
81		/**
82		* Cria um novo controlador de amostragem.
83		*/
84	4	public ControladorAmostragem() {
85	4	limpaProgramacao();
86	4	}
87
88		/**
89		* Obtém o status corrente.
90		* @return O status corrente.
91		*/
92		public final IControladorAmostragem.Status getStatus() {
93	11	if (status == null) {
94	2	status = new ControladorAmostragemStatus();
95		} else {
96	9	status.setTemperaturaAtual(0.0);
97	9	status.setTempoDecorridoAmostragem(0);
98	9	status.setTempoDecorridoProgramacao(0);
99	9	status.setTempoTotalAmostragem(0);
100	9	status.setTempoTotalProgramacao(0);
101	9	status.setNomeAmostragemAtual("");
102	9	status.setTempoDaUltimaGravacao(0);
103		}
104
105	11	status.setEstado(estado);
106
107	11	if (!estado.equals(Estado.SEM_PROGRAMACAO)) {
108	11	status.setTempoTotalAmostragem(tempoTotalProgramacao);
109
110	11	if (!(estado.equals(Estado.NAO_INICIADO)
111		\|\| estado.equals(Estado.PROGRAMACAO_TERMINADA)
112		\|\| estado.equals(Estado.CANCELADO))) {
113	9	status.setNomeAmostragemAtual(amostragemAtual.getNome());
114	9	status.setTempoTotalAmostragem(amostragemAtual.getDuracao());
115		}
116
117	11	if (estado.equals(Estado.EM_AMOSTRAGEM)
118		\|\| estado.equals(Estado.ESPERANDO_RETORNO_TEMPERATURA)) {
119	9	status.setTempoDecorridoAmostragem(timer.getTempoDecorrido());
120	9	status.setTemperaturaAtual(
121		controladorTemperatura.getTemperatura());
122		}
123		}
124
125	11	return status;
126		}
127
128		/**
129		* Carrega uma programação de um arquivo.
130		* @param file O arquivo que será lido.
131		* @return A programação lida.
132		* @throws IOException Se ocorrer algum erro de leitura.
133		* @throws ClassNotFoundException Se o arquivo não tiver um
134		* uma programação gravada.
135		*/
136		public final IProgramacaoAmostragem carregaProgramacao(final File file)
137		throws IOException, ClassNotFoundException {
138	1	return (IProgramacaoAmostragem)
139		Utilities.getUtilities().leSerializable(file);
140		}
141
142		/**
143		* Grava uma programação para um arquivo.
144		* @param programacaoLocal Programação que será gravada
145		* @param file Arquivo que será gravado.
146		* @throws IOException Se ocorrer algum erro durante a gravação.
147		*/
148		public final void gravaProgramacao(
149		final IProgramacaoAmostragem programacaoLocal,
150		final File file) throws IOException {
151	1	Utilities.getUtilities().gravaSerializable(file, programacaoLocal);
152	1	}
153
154		/**
155		* Método que inicia o controlador com os objetos necessários para a
156		* execução da amostragem.
157		* Ele retorna o status indicando se a amostragem pode ou não prosseguir.
158		* @param prog Programação de Amostragem.
159		* @param control Controlador de Temperatura que será utilizado.
160		* @param leitor O Leitor de espectro que será utilizado.
161		* @param timerLocal O timer que será utilizado
162		* @return <code>true</code> caso a programação possa ser executada com
163		* este controlador, leitor de espectro e timer.
164		*/
165		public final boolean aceita(final IProgramacaoAmostragem prog,
166		final IControladorTemperatura control,
167		final ILeitorEspectro leitor,
168		final ITimer timerLocal) {
169		//@TODO não está bom. Deveria retornar mais informações
170		// caso a programação não seja aceita.
171	4	boolean toReturn = true;
172
173	4	List<IAmostragem> amostragens = prog.getAmostragens();
174	4	Iterator<IAmostragem> it = amostragens.iterator();
175	4	tempoTotalProgramacao = 0;
176	13	while (it.hasNext()) {
177	10	IAmostragem amostragem = it.next();
178	10	tempoTotalProgramacao = tempoTotalProgramacao
179		+ amostragem.getDuracao();
180	10	if (!control.aceitaTemperatura(amostragem.getTemperatura())) {
181	1	toReturn = false;
182	1	break;
183		}
184	9	}
185
186	4	if (toReturn) {
187	3	programacao = prog;
188	3	controladorTemperatura = control;
189	3	leitorEspectro = leitor;
190	3	timer = timerLocal;
191		}
192
193	4	estado = Estado.NAO_INICIADO;
194
195	4	return toReturn;
196		}
197
198		/**
199		* Limpa todos os recursos utilizados por este controlador, inclusive
200		* a programação atual.
201		*/
202		public final void limpaProgramacao() {
203	4	programacao = null;
204	4	controladorTemperatura = null;
205	4	leitorEspectro = null;
206	4	ouvintes = null;
207	4	estado = Estado.SEM_PROGRAMACAO;
208	4	tempoTotalProgramacao = 0;
209	4	synchronized (this) {
210	4	programacaoIterator = null;
211	4	}
212	4	timer = null;
213	4	amostragemAtual = null;
214	4	}
215
216		/**
217		* Adiciona um ouvinte aos eventos gerados por este controlador.
218		* @param ouvinte o ouvinte que será notificado sempre que o estado
219		* deste controlador mudar.
220		*/
221		public final void addOuvinteEventosControladorAmostragem(
222		final IOuvinteEventosControladorAmostragem ouvinte) {
223	0	if (ouvintes == null) {
224	0	ouvintes = new
225		HashSet <IOuvinteEventosControladorAmostragem>();
226		}
227
228	0	ouvintes.add(ouvinte);
229	0	}
230
231		/**
232		* Remove um ouvinte dos eventos deste controlador.
233		* @param ouvinte que não quer mais receber notificações
234		* de mudança de estado deste controlador.
235		*/
236		public final void removeOuvinteEventosControladorAmostragem(
237		final IOuvinteEventosControladorAmostragem ouvinte) {
238	0	if (ouvintes != null) {
239	0	ouvintes.remove(ouvinte);
240		}
241	0	}
242
243		/**
244		* Notifica os ouvintes que o estado deste controlador mudou.
245		*/
246		private void fireNewStatus() {
247	30	if (ouvintes != null) {
248		Iterator<IOuvinteEventosControladorAmostragem>
249	0	it = ouvintes.iterator();
250	0	while (it.hasNext()) {
251	0	IOuvinteEventosControladorAmostragem ouvinte = it.next();
252	0	ouvinte.novoStatusControladorAmostragem();
253	0	}
254		}
255	30	}
256
257		/**
258		* Inicia a execução da programação atual.
259		*/
260		public final void start() {
261	2	synchronized (this) {
262	2	programacaoIterator = programacao.getAmostragens().iterator();
263	2	estadoPreparaAmostragem();
264	2	trataProximaAmostragem();
265	2	}
266	2	}
267
268		/**
269		* Cancela a execução da programação atual.
270		*/
271		public final void cancel() {
272	0	synchronized (this) {
273	0	if (estado.equals(Estado.ESPERANDO_TEMPERATURA_INICIAL)) {
274	0	timer.stop();
275
276	0	controladorTemperatura.cancelaTemperaturaAlvo();
277	0	} else if (estado.equals(Estado.EM_AMOSTRAGEM)) {
278	0	timer.stop();
279	0	leitorEspectro.termina();
280	0	controladorTemperatura.cancelaTemperaturaAlvo();
281	0	gravaAmostragem();
282	0	} else if (estado.equals(Estado.ESPERANDO_RETORNO_TEMPERATURA)) {
283	0	timer.stop();
284	0	leitorEspectro.termina();
285	0	controladorTemperatura.cancelaTemperaturaAlvo();
286	0	gravaAmostragem();
287		}
288
289	0	estadoCancelado();
290	0	}
291	0	}
292
293		/**
294		* Verifica se tem mais uma amostragem na programação, e
295		* inicia sua execução.
296		*/
297		private void trataProximaAmostragem() {
298	8	synchronized (this) {
299	8	if (estado.equals(Estado.PREPARA_AMOSTRAGEM)) {
300	8	if (programacaoIterator.hasNext()) {
301	6	amostragemAtual = programacaoIterator.next();
302	6	controladorTemperatura.setTemperaturaAlvo(
303		amostragemAtual.getTemperatura());
304	6	controladorTemperatura.addIOuvinteMundancaTemperatura(this);
305	6	timer.setTempoTotal(amostragemAtual.getDuracao());
306	6	timer.addOuvinteTimer(this);
307	6	estadoEsperandoTemperaturaInicial();
308		} else {
309	2	estadoProgramacaoTerminada();
310	2	trataTerminoProgramacao();
311		}
312		}
313	8	}
314	8	}
315
316		/**
317		* Trata o final da programação.
318		*/
319		private void trataTerminoProgramacao() {
320	2	estadoProgramacaoTerminada();
321	2	}
322
323		/**
324		* Muda o estado para PREPARA_AMOSTRAGEM.
325		* Notifica os ouvintes que o estado deste controlador mudou.
326		*/
327		private void estadoPreparaAmostragem() {
328	8	synchronized (this) {
329	8	estado = Estado.PREPARA_AMOSTRAGEM;
330	8	fireNewStatus();
331	8	}
332	8	}
333
334		/**
335		* Muda o estado para ESPERANDO_TEMPERATURA_INICIAL.
336		* Notifica os ouvintes que o estado deste controlador mudou.
337		*/
338		private void estadoEsperandoTemperaturaInicial() {
339	6	synchronized (this) {
340	6	estado = Estado.ESPERANDO_TEMPERATURA_INICIAL;
341	6	fireNewStatus();
342	6	}
343	6	}
344
345		/**
346		* Muda o estado para EM_AMOSTRAGEM.
347		* Notifica os ouvintes que o estado deste controlador mudou.
348		*/
349		private void estadoEmAmostragem() {
350	9	synchronized (this) {
351	9	estado = Estado.EM_AMOSTRAGEM;
352	9	fireNewStatus();
353	9	}
354	9	}
355
356		/**
357		* Muda o estado para ESPERANDO_RETORNO_TEMPERATURA.
358		* Notifica os ouvintes que o estado deste controlador mudou.
359		*/
360		private void estadoEsperandoRetornoTemperatura() {
361	3	synchronized (this) {
362	3	estado = Estado.ESPERANDO_RETORNO_TEMPERATURA;
363	3	fireNewStatus();
364	3	}
365	3	}
366
367		/**
368		* Muda o estado para PROGRAMACAO_TERMINADA.
369		* Notifica os ouvintes que o estado deste controlador mudou.
370		*/
371		private void estadoProgramacaoTerminada() {
372	4	synchronized (this) {
373	4	estado = Estado.PROGRAMACAO_TERMINADA;
374	4	fireNewStatus();
375	4	}
376	4	}
377
378		/**
379		* Muda o estado para CANCELADO.
380		* Notifica os ouvintes que o estado deste controlador mudou.
381		*/
382		private void estadoCancelado() {
383	0	synchronized (this) {
384	0	estado = Estado.CANCELADO;
385	0	fireNewStatus();
386	0	}
387	0	}
388
389		/**
390		* Notificação do controlador de temperatura indicando que
391		* ele está em nova temperatura.
392		* O controlador de amosragem deve verificar
393		* se a temperatura está dentro dos limites estabelecidos.
394		* @param temperatura A temperatura atual do controlador.
395		*/
396		public final void novaTemperatura(final double temperatura) {
397	3	synchronized (this) {
398	3	if (estado.equals(Estado.EM_AMOSTRAGEM)
399		&& (Math.abs(temperatura - amostragemAtual.getTemperatura())
400		> MAX_DELTA_TEMPERATURA)) {
401	3	leitorEspectro.pausa();
402	3	timer.pause();
403	3	estadoEsperandoRetornoTemperatura();
404		}
405	3	}
406	3	}
407
408		/**
409		* Notificação do controlador de temperatura indicando
410		* que a temperatura alvo foi alcançada.
411		* O controlador de amostragem deve iniciar ou prosseguir
412		* na amostragem atual.
413		* @param temperatura A temperatura atual do controlador.
414		*/
415		public final void temperaturaAlvoAlcancada(final double temperatura) {
416	9	if (estado.equals(Estado.ESPERANDO_TEMPERATURA_INICIAL)) {
417	6	leitorEspectro.inicia();
418	6	timer.start();
419	6	estadoEmAmostragem();
420	3	} else if (estado.equals(Estado.ESPERANDO_RETORNO_TEMPERATURA)) {
421	3	leitorEspectro.continua();
422	3	timer.continua();
423	3	estadoEmAmostragem();
424		}
425	9	}
426
427		/**
428		* Evento do timer, indicando que um tick do relógio já passou.
429		* O controlador de amostragem deve gravar um espectro com resultados
430		* parciais.
431		*/
432		public final void tickDoTimer() {
433		// grava amostra espectro.
434	0	}
435
436		/**
437		* Evento do timer, indicando que o tempo total da amostragem atual
438		* foi alcançado.
439		* O controlador deve gravar a amostragem atual com os resultados
440		* finais, e prosseguir com a programação.
441		*/
442		public final void tempoTotalTerminado() {
443	6	if (estado.equals(Estado.EM_AMOSTRAGEM)) {
444	6	leitorEspectro.termina();
445	6	controladorTemperatura.cancelaTemperaturaAlvo();
446	6	gravaAmostragem();
447	6	estadoPreparaAmostragem();
448	6	trataProximaAmostragem();
449		}
450	6	}
451
452		/**
453		* Grava uma amostragem com os resultados atuais.
454		*/
455		private void gravaAmostragem() {
456		// gravar a amostragem;
457	6	}
458		}