Transforme sua velha maquina de arroz em um robô que faz deliciosos pratos utilizando o Arduino.

Navegando pela internet encontrei mais um projeto bastante interessante, pois através dele é possível hackear um velha panela de Arroz e transformá-la em um robô que produz uma serie de pratos deliciosos além do arroz através da técnica sous vide.

O que é Sous Vide?

Sous vide é o que existe de mais moderno em cozimento de alimentos, através desta técnica é possível cozinhar alimentos de forma mais consistente e delicada como nunca antes feito.

Quer fazer comida deliciosa, perfeitamente cozida utilizando um robô ? Quem não quer? Este projeto irá mostrar-lhe como construir o seu próprio "Sous viduino", uma panela automatizada que faz ovos perfeitos, bifes suculentos e peixes tenros, sem toda a "escravização sobre um fogão." Tudo isso é possível devido a um recente avanço na tecnologia de cozimento, em vez de usar uma frigideira ou panela utiliza-se um "sous vide" (pronuncia-suu veed), máquina que aquece a comida em uma espécie de cruzamento entre uma jacuuzi e uma panela de barro.

Sous vide está rapidamente se tornando uma técnica de cozimento importante em muitos dos melhores restaurantes do mundo, pois combina princípios da gastronomia molecular com controles de temperatura industriais para gerenciar com precisão as reações químicas de cozimento.

Nós amamos boa comida tanto quanto amamos a ciência e a tecnologia, então é claro que teríamos que construir o nosso próprio controlador sous vide. Esse projeto transforma uma panela de arroz barata em um instrumento de cozinha de precisão capaz de manter a temperatura de cozimento dentro de + / - 0,1 C. Controlando precisamente a temperatura você pode garantir que os alimentos são cozidos exatamente para o nível desejado de cozimento e não-mais. Isso faz com que o método de cozimento sous vide  seja perfeito para tudo, desde um ovo cozido até um bife cozido perfeitamente de borda a borda o que é meio raro.

 

Materiais para o projeto

O Controlador

Você não precisa de um microcomputador poderoso para conduzir esta configuração, nós selecionamos o Arduino para este projeto por causa da excelente PID (bem documentadas) e bibliotecas autotune disponíveis para ele. A Adafruit RGB / LCD shield  com botões integrados também possui perfeita interface com o usuário facilitando seu manuseio.

Para construir este controlador, você vai precisará de:

• Maquina de arroz
• Arduino UNO
• Proto Shield ou Wing Shield
• RGB LCD Shield ( display positivo ou negativo)
• Interruptor de força
• Sensor de Temperatura DS18B20 para altas temperaturas , você também pode usar o tipo DS18B20 Waterproof padrão se não estiver pensando em aquecê-lo acima de 90C, que é muito raro para um Sous Vide.
• Tubos de calor Food Grade
• Cabo de Extensão Servo
• Conector de fio de energia JST In-Line: Masculino e Feminino

Você também vai precisar de algumas ferramentas básicas e materiais de solda:

• Cortadores de fio
• Descascadores de fios
• Ferro de solda
• Solda
• Tubos Enrole
• Pequena chave de fenda Phillips

Seleção da Panela

Tipo

Panelas de arroz e aparelhos Slow Cooker tem os elementos básicos que estamos procurando:

• A vasilha para colocar água
• Um elemento de aquecimento elétrico

Capacidade

Você precisa de um recipiente substancialmente maior do que a comida que você pretende cozinhar nele. Ele precisa ter um grande volume suficiente de água com bastante espaço para circulação mantendo uma temperatura uniforme. Procure uma panela de arroz com capacidade de pelo menos 10 copos (20 xícaras) ou uma panela com pelo menos 4 litros de capacidade.

Controles

Uma vez que estamos preparando nosso próprio controle, escolha a panela com controle manual mais simples que encontrar. Uma com um interruptor simples ou botão de controle seria melhor. Queremos apenas ligá-lo no nível mais alto e conectá-lo a nosso controlador.

(Aqui na Adafruit utilizamos uma "Black and Decker RC880" que possui capacidade de 24 copos que é um tamanho bem grande.

Panelas com controles digitais não são adequadas a menos que você queira arrancar a parte eletrônica,  pois o controlador funciona pulsando a alimentação elétrica da panela. Se você fizer isso com uma panela controlada digitalmente, ela só irá desligar!

Construir o controlador 

Prepare o Sensor

A maioria dos sous vide são feitos com sacos plásticos fechados, uma exceção a isso são os ovos que são cozidos em suas conchas. Outras receitas (como caudas de lagosta cozido na manteiga ) cozinham o alimento imerso diretamente no líquido de cozimento. Para fazer com que o sensor de temperatura esteja em contato com o alimento de forma segura, corte um pedaço de fita plastica de alta temperatura e coloque envolvendo o sensor, conforme abaixo.

Construir o RGB LCD shield

 

Siga as instruções deste tutorial para construir e testar o escudo.   

 

Construir o Wing Shield

 

Siga as instruções em este tutorial para construir o escudo asa.

Note-se que o interruptor, LEDs e resistências não são utilizados para o controlador sous vide, você pode salvar essas peças para o seu próximo projeto.

 

Prepare o sensor

Nossos sensores DS18B20 à prova d'água são ótimos para imersão no liquido e medição temperatura , mas eles não são seguros para alimentos. Se você só vai cozinhar alimentos em um saco plástico, isso não importa tanto, mas se você cozinhar alimentos diretamente na água como ovos isso realmente importa. Nós sugerimos fortemente que utilize uma fita para vedar o sensor, use uma pistola de ar quente para encolher a manga plastica à prova d'água sobre o sensor.

Instale o Sensor

Perfure ou amplie a abertura de ventilação do vapor para que o cabo do sensor poça ser colocado através da tampa. Posicione o sensor de modo que se estenda aproximadamente até o meio, dentro do recipiente de cosedura, quando a tampa é fechada.

Se existir uma folga, Coloque uma braçadeira de cabo em torno do fio do sensor e a saída da tampa para evitar que deslizem mais profundamente na panela.

Adicionar abraçadeiras adicionais a cada 4-6 polegas para prender o fio do sensor ao cabo de alimentação.

 

Terminando os fios do sensor

Vamos usar um cabo de extensão como uma maneira de fazer um sensor destacável. Não é obrigatório mas facilita na hora da retirada para limpeza.

• Descasque e prepare alguns comprimentos de heat-shrink.
• Corte um cabo de extensão servo pela metade.
• Solde a extremidade macho nos fios do sensor.
• Encolha o Heat-shrink para isolar.

A cor do fio do sensor de codificação (à direita) são um pouco estranhas, por isso vamos conectá-las para usar uma cor padrão de codificação para o conector de servo (direita).

• Preto <- Branco (terra)
• Red <- Laranja Stripe (+5 v)
• Branco <- listra azul (Sinal)

Adicione o Resistor

Com a metade fêmea da extensão servo:

• Strip e estanho nas extremidades
• Soldar o resistor de 47K ohm que o acompanha entre os fios 5v (vermelho) e sinal (branco).
• Encolha o heat-shrink para isolar.

 

 

Empilhá-los!

Ligue o wing shield no arduino e o RGB shield LCD. Fixe a pilha em cima da caixa Elétrica e acrescente algumas presilhas de segurança.

 

 

 

 

 

 

 

Conecte os cabos

Conecte o cabo de alimentação macho JST no pino 7 e terra no wing shield.

Conecte o cabo JST feminino para os parafusos dos terminais Elétrico caixa. Assegure-se que a polaridade é a mesma que está na outra extremidade.

Ligue a metade macho do cabo na extensão servo:

• Branco -> Pino 2 (Sinal)
• Vermelho -> Pino 3 (5v)
• Black -> Pino 4 (Terra)

 

 

 

 

 

 

 

 

 

Coloque tudo junto:

• Ligue as extremidades macho e fêmea do cabo de extensão servo.
• Conecte os cabos de JST macho e fêmea juntos.
• Ligue a panela ao conector de eletricidade
• Ligue a caixa Elétrica em uma tomada de parede.

 Agora você está pronto para carregar algum software!

Software de Controle

As páginas a seguir irão orientá-lo através de vários aspectos do código do controlador, explicando como cada um funciona. A página final desta seção contém o esboço completo do controlador, pronto para fazer o upload para o seu controlador Sous Vide.

PID 

Antes de começar a cozinhar temos para resolver um problema simples: como para manter a temperatura da água na panela a uma temperatura determinada durante um longo período de tempo. É realmente fácil de obter água fervervente (basta aquecê-lo até que comece a ferver) ou congelamento (resfriá-lo até que ele se solidifique), mas mantendo uma temperatura de água estável é um pouco mais difícil. A água esfria enquanto se aproxima da comida e a esquenta, mas o quão rápido ele esfria depende da quantidade de água, a temperatura da panela, a temperatura dos alimentos, etc. É difícil de fazer este controle manualmente então vamos automatizar usando controle de feedback PID

O que é um PID?

Precisamos que nosso microcontrolador controle o aquecedor para manter a temperatura estável. Pode-se aquecer a água ligando a panela de arroz (controle), e depois medir a temperatura com o nosso sensor à prova d'água (feedback). Estes componentes estão no meio de um algoritmo que liga-os juntos. O algoritmo PID é um tipo de controle de feedback, nesta aplicação a medição de temperatura é comparada com o valor nominal e a diferença entre eles é chamado erro. O erro é usado para calcular um ajuste para a saída, que controla o elemento de aquecimento.

O nome vem do PID dos três termos na equação utilizada para calcular a saída:

• P - O termo proporcional olha para o atual estado do processo. O seu valor é proporcional ao erro de corrente.
• I - O termo integral olha para a história do processo. Seu valor é a integral dos erros do passado.
• D - O Derivative tenta prever o futuro do processo. O seu valor é o derivado ou a taxa de variação no erro ..

Estes três termos são pesos conhecidos como parâmetros de ajuste atribuído:. Kp, Ki e Kd Os três termos são somados para produzir a saída de controle.

A equação básica PID não é tão difícil de implementar e existem muitas implementações PID lá fora. Mas há um monte de 'pegadinhas' para se resolver em um PID com bom desempenho em uma aplicação do mundo real.

Essas dicas foram habilmente dirigidas por Brett Beauregard em sua Biblioteca PID Arduino . E claramente documentado em seu blog: Melhorar a PID para Iniciantes .

 Graças a Brett Beauregard que deu permissão para usar essas imagens.

Ajuste Automático

Você já deve ter ouvido falar de "Auto Tuning" como uma maneira de filtrar a voz. Auto-sintonia de um controlador PID não é bem a mesma coisa - em vez de melhorar a sua voz cantando, ele pode ajudá-lo a definir os parâmetros de ajuste inicial para o seu controlador. Cada "sistema" tem diferentes parâmetros inerentes ao mundo físico. Por exemplo, o controlador de sous vide tem que explicar quantos Watts de potência a panela de arroz usa, o quão rápido ele leva para iniciar, o calor específico da água, etc

A função de autotune tenta caracterizar o desempenho do seu sistema de sous vide, interrompendo a saída do controlador para ver como ele responde.

Com base na resposta do rompimento, o algoritmo calcula os parâmetros de ajuste Kp, Ki e Kd. Autotune não é perfeito e não pode encontrar a afinação ideal para o seu sistema, mas deverá colocá-lo no caminho.

Para mais detalhes sobre como o algoritmo funciona autotune, leia post de Brett sobre o tema aqui: Arduino PID Autotune Biblioteca.

Interface com usuário

A interface de usuário sous vide permite que você defina a temperatura de cozimento e faça os ajustes dos parâmetros de sintonia do PID. Ela é implementada como uma máquina de estado simples, cada estado implementa a 'tela' de interface de usuário. As máquinas de estado são muitas vezes utilizadas em projetos de microcontroladores semi-complexos onde se quer fazer um monte de configurações e atividades na ordem correta.

Os botões do shield são utilizados para navegar entre as diferentes telas. Após um período de inatividade, este retorna o sistema para a tela de "Run", para exibir o set-point de corrente (a temperatura que desejamos) e temperatura atual do banho, como mostrados abaixo:

Cada estado é implementado como uma função que é chamado, o circuito principal com base na variável opState. Para alterar estados, uma função de estado define opState para o novo estado e retorna ao circuito principal.

Se você estiver trabalhando em um projeto que tem um monte de coisas acontecendo, desenhando uma máquina de estado pode ser realmente útil para manter sua cabeça no caminho correto!

1. / / ************************************************
2. / / Loop de controle principal
3. / /
4. / / Todas as mudanças de estado passam por aqui
5. / / ************************************************
6. void loop ()
7. {
8. / / Espera por liberação de botão antes de mudar de estado
9. while (ReadButtons (!) = 0) {}
10. lcd.clear ();
11. Serial.println (opState);
12. switch (opState)
13. {
14. caso OFF:
15. Off ();
16. quebrar;
17. caso SETP:
18. Tune_Sp ();
19. quebrar;
20. caso RUN:
21. Run ();
22. quebrar;
23. caso TUNE_P:
24. TUNEP ();
25. quebrar;
26. caso TUNE_I:
27. TuneI ();
28. quebrar;
29. caso TUNE_D:
30. Tuned ();
31. quebrar;
32. }
33. }

Cada função do Estado é responsável por atualizar a exibição e monitoramento, pressionando o botão além navegar entre as telas,  também são utilizados para modificar os parâmetros de controle. Por exemplo, usa as teclas de cima e baixo para alterar o ponto de ajuste do estado valor de sintonia nominal, como indicado na figura e no código abaixo.

O botão 5 do shield é utilizado como uma chave de "mudança". Quando pressionadas simultaneamente com as teclas cima ou para baixo, ele aumenta ou diminui de 10 em vez de apenas 1. As outras telas de sintonia funcionam da mesma maneira.

1. / / ************************************************
2. / / Valor nominal de entrada do Estado
3. / / UP / DOWN para mudar setpoint
4. / / RIGHT para parâmetros de ajuste
5. / / Esquerda para OFF
6. / / Mudança para o ajuste 10x
7. / / ************************************************
8. vazio Tune_Sp ()
9. {
10. lcd.setBacklight (TEAL);
11. lcd.print (F ("Set Temperatura:"));
12. botões uint8_t = 0;
13. while (true)
14. {
15. botões ReadButtons = ();
16.  
17. flutuar incrementar = 0,1;
18. if (botões e BUTTON_SHIFT)
19. {
20. incremento * = 10;
21. }
22. if (botões e BUTTON_LEFT)
23. {
24. opState = RUN;
25. voltar;
26. }
27. if (botões e BUTTON_RIGHT)
28. {
29. opState = TUNE_P;
30. voltar;
31. }
32. if (botões e BUTTON_UP)
33. {
34. Setpoint + = incremento;
35. retardo (200);
36. }
37. if (botões e BUTTON_DOWN)
38. {
39. Setpoint - = incremento;
40. retardo (200);
41. }
42. if ((millis () - lastInput)> 3000) / / retorna para RUN após 3 segundos ociosas
43. {
44. opState = RUN;
45. voltar;
46. }
47. lcd.setCursor (0,1);
48. lcd.print (valor nominal);
49. DoControl ();
50. }
51. }

Dados persistentes

Você não terá que embutir os parâmetros de ajuste ou digitá-los toda vez que você usar o controlador, serão salvos na EEPROM do Arduino. Isso torna o código um pouco mais elegante, programando o controlador apenas uma vez, sempre que você ligar o seu controlador, ele irá lembrar as configurações a partir da última vez que você o usou e caso altere as configurações as mesmas passarão a ficar gravadas.

EEPROM só pode ser escrito um número finito de vezes (tipicamente 100.000), comparamos os conteúdos antes de escrever e gravaremos apenas se algo mudou. Essa funcionalidade é implementada nas seguintes funções auxiliares:

// ************************************************
// Save any parameter changes to EEPROM
// ************************************************
void SaveParameters()
{
   if (Setpoint != EEPROM_readDouble(SpAddress))
   {
      EEPROM_writeDouble(SpAddress, Setpoint);
   }
   if (Kp != EEPROM_readDouble(KpAddress))
   {
      EEPROM_writeDouble(KpAddress, Kp);
   }
   if (Ki != EEPROM_readDouble(KiAddress))
   {
      EEPROM_writeDouble(KiAddress, Ki);
   }
   if (Kd != EEPROM_readDouble(KdAddress))
   {
      EEPROM_writeDouble(KdAddress, Kd);
   }
}
 
// ************************************************
// Load parameters from EEPROM
// ************************************************
void LoadParameters()
{
  // Load from EEPROM
   Setpoint = EEPROM_readDouble(SpAddress);
   Kp = EEPROM_readDouble(KpAddress);
   Ki = EEPROM_readDouble(KiAddress);
   Kd = EEPROM_readDouble(KdAddress);
   
   // Use defaults if EEPROM values are invalid
   if (isnan(Setpoint))
   {
     Setpoint = 60;
   }
   if (isnan(Kp))
   {
     Kp = 500;
   }
   if (isnan(Ki))
   {
     Ki = 0.5;
   }
   if (isnan(Kd))
   {
     Kd = 0.1;
   }  
}
 
 
// ************************************************
// Write floating point values to EEPROM
// ************************************************
void EEPROM_writeDouble(int address, double value)
{
   byte* p = (byte*)(void*)&value;
   for (int i = 0; i < sizeof(value); i++)
   {
      EEPROM.write(address++, *p++);
   }
}
 
// ************************************************
// Read floating point values from EEPROM
// ************************************************
double EEPROM_readDouble(int address)
{
   double value = 0.0;
   byte* p = (byte*)(void*)&value;
   for (int i = 0; i < sizeof(value); i++)
   {
      *p++ = EEPROM.read(address++);
   }
   return value;
}

Tempo de saída proporcional

Enquanto aquecimento da panela é controlado por um relé, não podemos usar uma saída PWM padrão para controlá-lo. PWM é uma maneira muito fácil e precisa de controlar o aquecimento, mas requer uma SSR mais cara. Existem alguns sistemas de feedback do PID que se beneficiam do controle PWM. Felizmente, o nosso sistema é uma grande banheira de água e a água esquenta e esfria muito lentamente, devido a esta "massa térmica" do sistema, o tempo de resposta é relativamente lento, de modo que pode-se usar uma forma muito lenta de PWM conhecido como "tempo de saída proporcional". Neste caso, a frequência dos impulsos é de 0,1 Hz ou uma vez muito, 10 segundos, é realmente um escala PWM muito, muito lenta.

Precisamos controlar o tempo de pulso com precisão, de modo que não sejam afetados por eventuais atrasos que podem haver no circuito principal, então usaremos um timer para gerar uma interrupção periódica. O temporizador é inicializado no setup ():

1. / / Executar timer2 interromper a cada 15 ms
2. TCCR2A = 0;
3. TCCR2B = 1 << CS22 | 1 << CS21 | 1 << CS20;
4.  
5. / / Timer2 Overflow Interrupt Ativar
6. TIMSK2 | TOIE2 << = 1;

A rotina de serviço de interrupção é chamada uma vez a cada 15 milissegundos para atualizar a saída de relé.

1. / / ************************************************
2. / / Temporizador de interrupção Handler
3. / / ************************************************
4. SINAL (TIMER2_OVF_vect)
5. {
6. if (opState == OFF)
7. {
8. digitalWrite (RelayPin, LOW) / / fazer revezamento certeza é fora
9. }
10. outro
11. {
12. DriveOutput ();
13. }
14. }

O DriveOutput () função que implementa o tempo de saída proporcional.

1. / / ************************************************
2. / / Chamado pelo ISR cada 15ms para acionar a saída
3. / / ************************************************
4. vazio DriveOutput ()
5. {
6. tempo agora = millis ();
7. / / Definir a saída
8. / / "A tempo" é proporcional à saída do PID
9. if (agora - windowStartTime> WindowSize)
10. {/ / Hora de mudar a janela de Revezamento
11. windowStartTime + = WindowSize;
12. }
13. if ((ONTIME> 100) && (ONTIME> (agora - windowStartTime)))
14. {
15. digitalWrite (RelayPin, HIGH);
16. }
17. outro
18. {
19. digitalWrite (RelayPin, LOW);
20. }
21. }

Juntando tudo!

Aqui está o esboço completo para o Controlador Adafruit Sous Vide

Você também pode obter o código mais recente (que pode ter atualizações ou melhorias) de Github em https://github.com/adafruit/Sous_Viduino

1. //-------------------------------------------------------------------
2. //
3. // Sous Vide Controller
4. // Bill Earl - for Adafruit Industries
5. //
6. // Based on the Arduino PID and PID AutoTune Libraries
7. // by Brett Beauregard
8. //------------------------------------------------------------------
9.  
10. // PID Library
11. #include <PID_v1.h>
12. #include <PID_AutoTune_v0.h>
13.  
14. // Libraries for the Adafruit RGB/LCD Shield
15. #include <Wire.h>
16. #include <Adafruit_MCP23017.h>
17. #include <Adafruit_RGBLCDShield.h>
18.  
19. // Libraries for the DS18B20 Temperature Sensor
20. #include <OneWire.h>
21. #include <DallasTemperature.h>
22.  
23. // So we can save and retrieve settings
24. #include <EEPROM.h>
25.  
26. // ************************************************
27. // Pin definitions
28. // ************************************************
29.  
30. // Output Relay
31. #define RelayPin 7
32.  
33. // One-Wire Temperature Sensor
34. // (Use GPIO pins for power/ground to simplify the wiring)
35. #define ONE_WIRE_BUS 2
36. #define ONE_WIRE_PWR 3
37. #define ONE_WIRE_GND 4
38.  
39. // ************************************************
40. // PID Variables and constants
41. // ************************************************
42.  
43. //Define Variables we'll be connecting to
44. double Setpoint;
45. double Input;
46. double Output;
47.  
48. volatile long onTime = 0;
49.  
50. // pid tuning parameters
51. double Kp;
52. double Ki;
53. double Kd;
54.  
55. // EEPROM addresses for persisted data
56. const int SpAddress = 0;
57. const int KpAddress = 8;
58. const int KiAddress = 16;
59. const int KdAddress = 24;
60.  
61. //Specify the links and initial tuning parameters
62. PID myPID(&Input, &Output, &Setpoint, Kp, Ki, Kd, DIRECT);
63.  
64. // 10 second Time Proportional Output window
65. int WindowSize = 10000;
66. unsigned long windowStartTime;
67.  
68. // ************************************************
69. // Auto Tune Variables and constants
70. // ************************************************
71. byte ATuneModeRemember=2;
72.  
73. double aTuneStep=500;
74. double aTuneNoise=1;
75. unsigned int aTuneLookBack=20;
76.  
77. boolean tuning = false;
78.  
79. PID_ATune aTune(&Input, &Output);
80.  
81. // ************************************************
82. // DiSplay Variables and constants
83. // ************************************************
84.  
85. Adafruit_RGBLCDShield lcd = Adafruit_RGBLCDShield();
86. // These #defines make it easy to set the backlight color
87. #define RED 0x1
88. #define YELLOW 0x3
89. #define GREEN 0x2
90. #define TEAL 0x6
91. #define BLUE 0x4
92. #define VIOLET 0x5
93. #define WHITE 0x7
94.  
95. #define BUTTON_SHIFT BUTTON_SELECT
96.  
97. unsigned long lastInput = 0; // last button press
98.  
99. byte degree[8] = // define the degree symbol
100. {
101. B00110,
102. B01001,
103. B01001,
104. B00110,
105. B00000,
106. B00000,
107. B00000,
108. B00000
109. };
110.  
111. const int logInterval = 10000; // log every 10 seconds
112. long lastLogTime = 0;
113.  
114. // ************************************************
115. // States for state machine
116. // ************************************************
117. enum operatingState { OFF = 0, SETP, RUN, TUNE_P, TUNE_I, TUNE_D, AUTO};
118. operatingState opState = OFF;
119.  
120. // ************************************************
121. // Sensor Variables and constants
122. // Data wire is plugged into port 2 on the Arduino
123.  
124. // Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
125. OneWire oneWire(ONE_WIRE_BUS);
126.  
127. // Pass our oneWire reference to Dallas Temperature.
128. DallasTemperature sensors(&oneWire);
129.  
130. // arrays to hold device address
131. DeviceAddress tempSensor;
132.  
133. // ************************************************
134. // Setup and diSplay initial screen
135. // ************************************************
136. void setup()
137. {
138. Serial.begin(9600);
139.  
140. // Initialize Relay Control:
141.  
142. pinMode(RelayPin, OUTPUT); // Output mode to drive relay
143. digitalWrite(RelayPin, LOW); // make sure it is off to start
144.  
145. // Set up Ground & Power for the sensor from GPIO pins
146.  
147. pinMode(ONE_WIRE_GND, OUTPUT);
148. digitalWrite(ONE_WIRE_GND, LOW);
149.  
150. pinMode(ONE_WIRE_PWR, OUTPUT);
151. digitalWrite(ONE_WIRE_PWR, HIGH);
152.  
153. // Initialize LCD DiSplay
154.  
155. lcd.begin(16, 2);
156. lcd.createChar(1, degree); // create degree symbol from the binary
158. lcd.setBacklight(VIOLET);
159. lcd.print(F(" Adafruit"));
160. lcd.setCursor(0, 1);
161. lcd.print(F(" Sous Vide!"));
162.  
163. // Start up the DS18B20 One Wire Temperature Sensor
164.  
165. sensors.begin();
166. if (!sensors.getAddress(tempSensor, 0))
167. {
168. lcd.setCursor(0, 1);
169. lcd.print(F("Sensor Error"));
170. }
171. sensors.setResolution(tempSensor, 12);
172. sensors.setWaitForConversion(false);
173.  
174. delay(3000); // Splash screen
175.  
176. // Initialize the PID and related variables
177. LoadParameters();
178. myPID.SetTunings(Kp,Ki,Kd);
179.  
180. myPID.SetSampleTime(1000);
181. myPID.SetOutputLimits(0, WindowSize);
182.  
183. // Run timer2 interrupt every 15 ms
184. TCCR2A = 0;
185. TCCR2B = 1<<CS22 | 1<<CS21 | 1<<CS20;
186.  
187. //Timer2 Overflow Interrupt Enable
188. TIMSK2 |= 1<<TOIE2;
189. }
190.  
191. // ************************************************
192. // Timer Interrupt Handler
193. // ************************************************
194. SIGNAL(TIMER2_OVF_vect)
195. {
196. if (opState == OFF)
197. {
198. digitalWrite(RelayPin, LOW); // make sure relay is off
199. }
200. else
201. {
202. DriveOutput();
203. }
204. }
205.  
206. // ************************************************
207. // Main Control Loop
208. //
209. // All state changes pass through here
210. // ************************************************
211. void loop()
212. {
213. // wait for button release before changing state
214. while(ReadButtons() != 0) {}
215.  
216. lcd.clear();
217.  
218. switch (opState)
219. {
220. case OFF:
221. Off();
222. break;
223. case SETP:
224. Tune_Sp();
225. break;
226. case RUN:
227. Run();
228. break;
229. case TUNE_P:
230. TuneP();
231. break;
232. case TUNE_I:
233. TuneI();
234. break;
235. case TUNE_D:
236. TuneD();
237. break;
238. }
239. }
240.  
241. // ************************************************
242. // Initial State - press RIGHT to enter setpoint
243. // ************************************************
244. void Off()
245. {
246. myPID.SetMode(MANUAL);
247. lcd.setBacklight(0);
248. digitalWrite(RelayPin, LOW); // make sure it is off
249. lcd.print(F(" Adafruit"));
250. lcd.setCursor(0, 1);
251. lcd.print(F(" Sous Vide!"));
252. uint8_t buttons = 0;
254. while(!(buttons & (BUTTON_RIGHT)))
255. {
256. buttons = ReadButtons();
257. }
258. // Prepare to transition to the RUN state
259. sensors.requestTemperatures(); // Start an asynchronous temperature reading
260.  
261. //turn the PID on
262. myPID.SetMode(AUTOMATIC);
263. windowStartTime = millis();
264. opState = RUN; // start control
265. }
266.  
267. // ************************************************
268. // Setpoint Entry State
269. // UP/DOWN to change setpoint
270. // RIGHT for tuning parameters
271. // LEFT for OFF
272. // SHIFT for 10x tuning
273. // ************************************************
274. void Tune_Sp()
275. {
276. lcd.setBacklight(TEAL);
277. lcd.print(F("Set Temperature:"));
278. uint8_t buttons = 0;
279. while(true)
280. {
281. buttons = ReadButtons();
282.  
283. float increment = 0.1;
284. if (buttons & BUTTON_SHIFT)
285. {
286. increment *= 10;
287. }
288. if (buttons & BUTTON_LEFT)
289. {
290. opState = RUN;
291. return;
292. }
293. if (buttons & BUTTON_RIGHT)
294. {
295. opState = TUNE_P;
296. return;
297. }
298. if (buttons & BUTTON_UP)
299. {
300. Setpoint += increment;
301. delay(200);
302. }
303. if (buttons & BUTTON_DOWN)
304. {
305. Setpoint -= increment;
306. delay(200);
307. }
309. if ((millis() - lastInput) > 3000) // return to RUN after 3 seconds idle
310. {
311. opState = RUN;
312. return;
313. }
314. lcd.setCursor(0,1);
315. lcd.print(Setpoint);
316. lcd.print(" ");
317. DoControl();
318. }
319. }
320.  
321. // ************************************************
322. // Proportional Tuning State
323. // UP/DOWN to change Kp
324. // RIGHT for Ki
325. // LEFT for setpoint
326. // SHIFT for 10x tuning
327. // ************************************************
328. void TuneP()
329. {
330. lcd.setBacklight(TEAL);
331. lcd.print(F("Set Kp"));
332.  
333. uint8_t buttons = 0;
334. while(true)
335. {
336. buttons = ReadButtons();
337.  
338. float increment = 1.0;
339. if (buttons & BUTTON_SHIFT)
340. {
341. increment *= 10;
342. }
343. if (buttons & BUTTON_LEFT)
344. {
345. opState = SETP;
346. return;
347. }
348. if (buttons & BUTTON_RIGHT)
349. {
350. opState = TUNE_I;
351. return;
352. }
353. if (buttons & BUTTON_UP)
354. {
355. Kp += increment;
356. delay(200);
357. }
358. if (buttons & BUTTON_DOWN)
359. {
360. Kp -= increment;
361. delay(200);
362. }
363. if ((millis() - lastInput) > 3000) // return to RUN after 3 seconds idle
364. {
365. opState = RUN;
366. return;
367. }
368. lcd.setCursor(0,1);
369. lcd.print(Kp);
370. lcd.print(" ");
371. DoControl();
372. }
373. }
374.  
375. // ************************************************
376. // Integral Tuning State
377. // UP/DOWN to change Ki
378. // RIGHT for Kd
379. // LEFT for Kp
380. // SHIFT for 10x tuning
381. // ************************************************
382. void TuneI()
383. {
384. lcd.setBacklight(TEAL);
385. lcd.print(F("Set Ki"));
386.  
387. uint8_t buttons = 0;
388. while(true)
389. {
390. buttons = ReadButtons();
391.  
392. float increment = 0.01;
393. if (buttons & BUTTON_SHIFT)
394. {
395. increment *= 10;
396. }
397. if (buttons & BUTTON_LEFT)
398. {
399. opState = TUNE_P;
400. return;
401. }
402. if (buttons & BUTTON_RIGHT)
403. {
404. opState = TUNE_D;
405. return;
406. }
407. if (buttons & BUTTON_UP)
408. {
409. Ki += increment;
410. delay(200);
411. }
412. if (buttons & BUTTON_DOWN)
413. {
414. Ki -= increment;
415. delay(200);
416. }
417. if ((millis() - lastInput) > 3000) // return to RUN after 3 seconds idle
418. {
419. opState = RUN;
420. return;
421. }
422. lcd.setCursor(0,1);
423. lcd.print(Ki);
424. lcd.print(" ");
425. DoControl();
426. }
427. }
428.  
429. // ************************************************
430. // Derivative Tuning State
431. // UP/DOWN to change Kd
432. // RIGHT for setpoint
433. // LEFT for Ki
434. // SHIFT for 10x tuning
435. // ************************************************
436. void TuneD()
437. {
438. lcd.setBacklight(TEAL);
439. lcd.print(F("Set Kd"));
440.  
441. uint8_t buttons = 0;
442. while(true)
443. {
444. buttons = ReadButtons();
445. float increment = 0.01;
446. if (buttons & BUTTON_SHIFT)
447. {
448. increment *= 10;
449. }
450. if (buttons & BUTTON_LEFT)
451. {
452. opState = TUNE_I;
453. return;
454. }
455. if (buttons & BUTTON_RIGHT)
456. {
457. opState = RUN;
458. return;
459. }
460. if (buttons & BUTTON_UP)
461. {
462. Kd += increment;
463. delay(200);
464. }
465. if (buttons & BUTTON_DOWN)
466. {
467. Kd -= increment;
468. delay(200);
469. }
470. if ((millis() - lastInput) > 3000) // return to RUN after 3 seconds idle
471. {
472. opState = RUN;
473. return;
474. }
475. lcd.setCursor(0,1);
476. lcd.print(Kd);
477. lcd.print(" ");
478. DoControl();
479. }
480. }
481.  
482. // ************************************************
483. // PID COntrol State
484. // SHIFT and RIGHT for autotune
485. // RIGHT - Setpoint
486. // LEFT - OFF
487. // ************************************************
488. void Run()
489. {
490. // set up the LCD's number of rows and columns:
491. lcd.print(F("Sp: "));
492. lcd.print(Setpoint);
493. lcd.write(1);
494. lcd.print(F("C : "));
495.  
496. SaveParameters();
497. myPID.SetTunings(Kp,Ki,Kd);
498.  
499. uint8_t buttons = 0;
500. while(true)
501. {
502. setBacklight(); // set backlight based on state
503.  
504. buttons = ReadButtons();
505. if ((buttons & BUTTON_SHIFT)
506. && (buttons & BUTTON_RIGHT)
507. && (abs(Input - Setpoint) < 0.5)) // Should be at steady-state
508. {
509. StartAutoTune();
510. }
511. else if (buttons & BUTTON_RIGHT)
512. {
513. opState = SETP;
514. return;
515. }
516. else if (buttons & BUTTON_LEFT)
517. {
518. opState = OFF;
519. return;
520. }
522. DoControl();
524. lcd.setCursor(0,1);
525. lcd.print(Input);
526. lcd.write(1);
527. lcd.print(F("C : "));
529. float pct = map(Output, 0, WindowSize, 0, 1000);
530. lcd.setCursor(10,1);
531. lcd.print(F(" "));
532. lcd.setCursor(10,1);
533. lcd.print(pct/10);
534. //lcd.print(Output);
535. lcd.print("%");
536.  
537. lcd.setCursor(15,0);
538. if (tuning)
539. {
540. lcd.print("T");
541. }
542. else
543. {
544. lcd.print(" ");
545. }
547. // periodically log to serial port in csv format
548. if (millis() - lastLogTime > logInterval)
549. {
550. Serial.print(Input);
551. Serial.print(",");
552. Serial.println(Output);
553. }
554.  
555. delay(100);
556. }
557. }
558.  
559. // ************************************************
560. // Execute the control loop
561. // ************************************************
562. void DoControl()
563. {
564. // Read the input:
565. if (sensors.isConversionAvailable(0))
566. {
567. Input = sensors.getTempC(tempSensor);
568. sensors.requestTemperatures(); // prime the pump for the next one - but don't wait
569. }
571. if (tuning) // run the auto-tuner
572. {
573. if (aTune.Runtime()) // returns 'true' when done
574. {
575. FinishAutoTune();
576. }
577. }
578. else // Execute control algorithm
579. {
580. myPID.Compute();
581. }
583. // Time Proportional relay state is updated regularly via timer interrupt.
584. onTime = Output;
585. }
586.  
587. // ************************************************
588. // Called by ISR every 15ms to drive the output
589. // ************************************************
590. void DriveOutput()
591. {
592. long now = millis();
593. // Set the output
594. // "on time" is proportional to the PID output
595. if(now - windowStartTime>WindowSize)
596. { //time to shift the Relay Window
597. windowStartTime += WindowSize;
598. }
599. if((onTime > 100) && (onTime > (now - windowStartTime)))
600. {
601. digitalWrite(RelayPin,HIGH);
602. }
603. else
604. {
605. digitalWrite(RelayPin,LOW);
606. }
607. }
608.  
609. // ************************************************
610. // Set Backlight based on the state of control
611. // ************************************************
612. void setBacklight()
613. {
614. if (tuning)
615. {
616. lcd.setBacklight(VIOLET); // Tuning Mode
617. }
618. else if (abs(Input - Setpoint) > 1.0)
619. {
620. lcd.setBacklight(RED); // High Alarm - off by more than 1 degree
621. }
622. else if (abs(Input - Setpoint) > 0.2)
623. {
624. lcd.setBacklight(YELLOW); // Low Alarm - off by more than 0.2 degrees
625. }
626. else
627. {
628. lcd.setBacklight(WHITE); // We're on target!
629. }
630. }
631.  
632. // ************************************************
633. // Start the Auto-Tuning cycle
634. // ************************************************
635.  
636. void StartAutoTune()
637. {
638. // REmember the mode we were in
639. ATuneModeRemember = myPID.GetMode();
640.  
641. // set up the auto-tune parameters
642. aTune.SetNoiseBand(aTuneNoise);
643. aTune.SetOutputStep(aTuneStep);
644. aTune.SetLookbackSec((int)aTuneLookBack);
645. tuning = true;
646. }
647.  
648. // ************************************************
649. // Return to normal control
650. // ************************************************
651. void FinishAutoTune()
652. {
653. tuning = false;
654.  
655. // Extract the auto-tune calculated parameters
656. Kp = aTune.GetKp();
657. Ki = aTune.GetKi();
658. Kd = aTune.GetKd();
659.  
660. // Re-tune the PID and revert to normal control mode
661. myPID.SetTunings(Kp,Ki,Kd);
662. myPID.SetMode(ATuneModeRemember);
664. // Persist any changed parameters to EEPROM
665. SaveParameters();
666. }
667.  
668. // ************************************************
669. // Check buttons and time-stamp the last press
670. // ************************************************
671. uint8_t ReadButtons()
672. {
673. uint8_t buttons = lcd.readButtons();
674. if (buttons != 0)
675. {
676. lastInput = millis();
677. }
678. return buttons;
679. }
680.  
681. // ************************************************
682. // Save any parameter changes to EEPROM
683. // ************************************************
684. void SaveParameters()
685. {
686. if (Setpoint != EEPROM_readDouble(SpAddress))
687. {
688. EEPROM_writeDouble(SpAddress, Setpoint);
689. }
690. if (Kp != EEPROM_readDouble(KpAddress))
691. {
692. EEPROM_writeDouble(KpAddress, Kp);
693. }
694. if (Ki != EEPROM_readDouble(KiAddress))
695. {
696. EEPROM_writeDouble(KiAddress, Ki);
697. }
698. if (Kd != EEPROM_readDouble(KdAddress))
699. {
700. EEPROM_writeDouble(KdAddress, Kd);
701. }
702. }
703.  
704. // ************************************************
705. // Load parameters from EEPROM
706. // ************************************************
707. void LoadParameters()
708. {
709. // Load from EEPROM
710. Setpoint = EEPROM_readDouble(SpAddress);
711. Kp = EEPROM_readDouble(KpAddress);
712. Ki = EEPROM_readDouble(KiAddress);
713. Kd = EEPROM_readDouble(KdAddress);
715. // Use defaults if EEPROM values are invalid
716. if (isnan(Setpoint))
717. {
718. Setpoint = 60;
719. }
720. if (isnan(Kp))
721. {
722. Kp = 850;
723. }
724. if (isnan(Ki))
725. {
726. Ki = 0.5;
727. }
728. if (isnan(Kd))
729. {
730. Kd = 0.1;
731. }
732. }
733.  
734.  
735. // ************************************************
736. // Write floating point values to EEPROM
737. // ************************************************
738. void EEPROM_writeDouble(int address, double value)
739. {
740. byte* p = (byte*)(void*)&value;
741. for (int i = 0; i < sizeof(value); i++)
742. {
743. EEPROM.write(address++, *p++);
744. }
745. }
746.  
747. // ************************************************
748. // Read floating point values from EEPROM
749. // ************************************************
750. double EEPROM_readDouble(int address)
751. {
752. double value = 0.0;
753. byte* p = (byte*)(void*)&value;
754. for (int i = 0; i < sizeof(value); i++)
755. {
756. *p++ = EEPROM.read(address++);
757. }
758. return value;
759. }

Ajustando

Diagrama de entrada Wikipedia: Controlador PID

  

Ajuste padrão

Os parâmetros de ajuste padrão no esboço são valores médios de alguns modelos diferentes de panela de arroz. Mas haverá variações mesmo entre duas panelas do mesmo modelo e do mesmo fabricante. 

Auto Sintonia 

A função de ajuste automático do esboço pode determinar parâmetros "aproximados" para sua panela. Você pode refinar o ajuste de lá. Para usar a função Autotune, primeiro deixe a panela de pré-aquecimento e atingir a temperatura nominal. Auto-ajuste funciona melhor se o sistema já está em um estado de equilíbrio. O estado de "Run" não permitirá que você invoque a auto-tuner, a menos que você esteja a 0,5 graus da temperatura nominal. Uma vez que a panela tenha se estabilizado ou perto do ponto de ajuste, pressione os botões DIREITA e SELEÇÃO simultaneamente. A luz de fundo ficará violeta para indicar que você está no modo de ajuste automático.

Seja paciente quando o sistema sintoniza si mesmo. Ele normalmente vai demorar uma hora ou mais para o algoritmo de auto-tune ser concluído. Quando o auto-ajuste estiver concluído, a luz de fundo irá retornar para o regime normal de funcionamento cromático. Os parâmetros de auto-tuned serão salvos na memória EEPROM, então eles estarão prontos para a próxima vez que for usá-lo. 

Sintonia manual

Como mencionado anteriormente, o auto-ajuste não é perfeito. Com um pouco de prática, você provavelmente pode chegar mais perto da afinação ideal para o seu fogão. Há muitos bons recursos na web que explicam sintonia PID. Aqui estão apenas alguns: PID Controlador de sintonia: um tutorial curto simples regras de sintonia do PID para ajustar o Kp, Ki e Kd parâmetros, use o botão direito para navegar entre as telas de ajuste. Os botões PARA CIMA e PARA BAIXO irão alterar o valor. Pressionando Select enquanto também pressionando UP ou DOWN irá alterar o valor 10x mais rápido.

Dica Sintonia Manual 

Uma coisa a ter em conta é que o controle de temperatura em uma panela de arroz é não-linear e assimétrica . Você pode aplicar o calor, mas não há refrigeração ativa. Como resultado, a maioria das panelas de arroz levar um longo tempo para se recuperar de uma temperatura de superação . Por essa razão, geralmente é melhor procurar uma resposta superamortecido para evitar transbordo. 

Cozinhar com ele! 

A melhor parte de fazer a sua própria configuração de sous vide é a porção de testes, yum! Sous vide utiliza a menor da temperaturas normais de cozimento. Se não for feito com cuidado, isso pode criar condições que promovem o crescimento de bactérias nocivas. Para um excelente guia para sous vide temperaturas seguras de cozinha e práticas de manipulação de alimentos, bem como gráficos de tempo e temperatura, veja o livro de Douglas Baldwin e web-site " Um Guia Prático para Sous Vide Cooking " 

Cozinhar um ovo "perfeito"!

Um primeiro teste bom para o seu fogão novo é um "ovo perfeito". Ovos não necessitam de preparação especial para sous vide. E, uma vez que eles são muito sensíveis a pequenas variações na temperatura de cozimento, são um bom teste para a precisão do seu controlador de temperatura. diferentes chefs têm idéias diferentes sobre o que exatamente constitui um ovo perfeito. Mas o controle preciso da temperatura do seu fogão sous vide vai deixar você atingir o seu ovo perfeito o tempo todo. http://www.edinformatics.com/math_science/science_of_cooking/eggs_sous_vide.htm 

Cozinhar um bife!

Tal como acontece com um ovo, o controle preciso da temperatura do seu fogão irá permitir que você cozinhe bifes para o nível certo de cozimento com 100% de repetibilidade. Sem bordas mais exageradas e cruas no meio. O seu bife será cozido do mesmo jeito de ponta a ponta. Toste-os na grelha por apenas alguns segundos de cada lado antes de servir.

Lombo Tip-Strip com grelhado Zuccini Cozido 90 minutos @ 57C.

Cozinhe um peixe! 

Peixe pode ser complicado para cozinhar. Apenas alguns segundos a mais na frigideira e irá de úmido a seco e quebradiço. Com sous vide, você pode ter certeza que ele ficará cozido perfeitamente, e não exagerado.

Haddock Filetes com vagens e laranja molho de açafrão. (Um dos nossos favoritos!)

Cozido 20 minutes@54.5C

 Transferências e links  

Código Sous Viduino Arduino

Você pode obter o código mais recente do repositório github em https://github.com/adafruit/Sous_Viduino 

Biblioteca de Downloads: 

Arduino PID Biblioteca 

PID Autotune Biblioteca 

Você também vai precisar das bibliotecas para o sensor de temperatura DS18B20 e RGB LCD shield, verifique as páginas de produto e kit para obter detalhes sobre os itens 

Biblioteca de Documentação: 

Documentação Algoritmo PID 

Autotune Documentação PID 

Informações adicionais sobre o sous vide 

Douglas Baldwin " Um Guia Prático para Sous Vide Cooking "

 Para Leonardo:

Leonardo diferenças no Temporizador 

Cliente e membro do fórum ytoff57 portou com sucesso este código para o Leonardo. Uma diferença entre o Leonardo e o Arduino é o timer, então o código de interrupção do timer não funciona nessa plataforma. Leonardo testou as seguintes modificações baseadas na biblioteca TimerOne:

1. # Include <TimerOne.h>
2. / / ...
3. void setup ()
4. {
5. / / ...
6. Timer1 . initialize ( 15.000 );
7. Timer1 . attachInterrupt ( TimerInterrupt );
8. }
9. / / ..
10. anular TimerInterrupt ()
11. {
12. se ( opState == OFF )
13. {
14. digitalWrite ( RelayPin , LOW ); / / fazer revezamento certeza é fora
15. }
16. outro
17. {
18. DriveOutput ();
19. }
20. }

 Fonte: http://learn.adafruit.com/sous-vide-powered-by-arduino-the-sous-viduino?view=all