DIY: Evita problemas de sobrecalentamiento en tu PS3 con un chip y sensor por 7€

En este tuto veremos cómo regular el ventilador de la PS3 y la PS3 Slim según la temperatura (sirve todas las versiones de PS3 y posiblemente la PS4, además de cualquier ventilador controlado por PWM), evitando que se estropee prematuramente. 

Los ingenieros de la PS3 le dieron prioridad al silencio de la PS3, ya que está destinada a ser un centro de juegos y multimedia, por lo que la temperatura que puede llegar a alcanzar va dañando las soldaduras del mismo, y al cabo de pocos años termina estropeándose por mal contacto de soldaduras (sólo reparable con un reflow o reballing).

La PS3 tiene un ventilador regulado por pulsos PWM, y el attiny85 de Atmel se puede programar fácilmente con el IDE de Arduino. También podemos usar cualquier placa compatible con Arduino (como el Nano, que por su tamaño también podríamos buscarle un sitio).

Hay ejemplos en Youtube e internet de gente que ha regulado el ventilador de forma fija para que vaya siempre más acelerado (con una resistencia en el cable gris conectado a los 12V, regulando a 1V aprox., o bien con un potenciómetro para hacerlo manualmente), pero no es la mejor solución ya que no tiene en cuenta la temperatura del procesador (que puede variar mucho según la temperatura ambiente), y aunque funciona, al tener que cubrir todos los casos, suele quedar más ruidoso. Además con esta solución tenemos la ventaja de que si oímos el ventilador muy fuerte, es que seguramente tenga un problema de falta de ventilación por polvo u otro problema.

Materiales

Sólo necesitamos el attiny85 (muy útil para proyectos pequeños y sencillos como ya vimos en el anterior tuto, con 8 Ks de capacidad) teniendo en cuenta sus diferencias:

1. El Digispark funciona con un Atmel Attiny85 MCU - presenta algunas diferencias respecto del  ATmega328 y algunas librerías no funcionan correctamente, pero irá mejorando con el tiempo.
2. El Digispark sólo tiene 6 KB de memoria disponible para nuestro código (8 KB si eliminamos el bootloader USB virtual y lo programamos directamente con un Arduino UNO).
3. El Pin 3 y el Pin 4 (P3 y P4) se usan para las comunicaciones y programación USB; aunque sólo interfiere si utilizamos la conexión USB y se pueden utilizar mientras que no usemos la conexión USB en el diseño final, pero hay que tener en cuenta que si el programa actúa dramáticamente sobre el voltaje de los mismos, será mejor desconectarlo una vez que hemos subido el programa por el USB.
4. El Pin 3 (P3) tiene conectada una resistencia de pull-up de 1.5 kΩ que se requiere cuando P3 y P4 se usan para comunicación USB (programación incluída). Tu diseño tendrá que tenerlo en cuenta ya que tendrías que sobrealimentar el pin para ponerlo en LOW.
5. El Digispark no tiene un puerto serie hardware ni un convertidor a USB. Se proporciona una librería de ejemplo (DigiUSB) así como algún código de ejemplo y un programa monitor serie, pero la comunicación con el ordenador no será siempre conectar y listo, especialmente cuando hay otras librerías en uso.
6. Al encenderse no hace nada hasta 4 segundos después, ya que es el tiempo de espera que tiene programado para la programación por USB (ésto creo se puede eliminarprogramándolo directamente, pero no lo he probado), por lo que hay que tenerlo en cuenta si necesitamos que arranque rápido el programa.
7. Mientras que las conexiones digitales corresponden a los pines (digitalRead(0) donde 0=Pin0), la correspondencia de los pines analógicos cambian:

analogRead(1); //Read P2
analogRead(2); //Read P4
analogRead(3); //Read P3
analogRead(0); //Read P5

A éso le añadimos un sensor de temperatura para regular la línea PWM (cable gris) del ventilador de la PS3 slim entre 0,8V y 1,3V y por menos de 7€ tenemos regulador.

En la siguiente foto vemos los cables ya soldados. 

• En el pin 4 tenemos la regulación PWM (cable amarillo), 
• en el 2 un lado del sensor (por el otro lado la resistencia que necesita a masa) y el otro lado del sensor a 5V out del chip.
• Y la alimentación conectada directamente a la alimentación del ventilador (el regulador integrado admite entre 6 y 15V).

He soldado directamente la resistencia 6K8 que necesita este sensor NTC (como los utilizados en el anterior tuto para más info) por la parte de atrás de esta pequeña placa:

Una vez programado (programa Arduino al final de este paso a paso), procedemos a instalarlo. No voy a entrar en los detalles de cómo desarmarla; internet está plagada de tutoriales sobre ello.

Instalándolo en la PS3

Una vez que la tengamos sin tapa, podremos ver los tres cables que van al disipador. El rojo es el positivo +12V, el negro es masa o -12V y el gris es el de regulación de voltaje por anchura de pulsos (PWM Wikipedia).

Tened en cuenta que hay varios tipos de ventiladores; los de la PS3 y PS4 se regulan por PWM, pero los de PC, generalmente en el tercer cable emiten 4 pulsos por vuelta (procedentes del sensor Hall), que permiten al PC conocer las rpm, saber si funciona, y regular el voltaje para disminuir temperatura sin emitir excesivo ruido (en la BIOS "Fan control/Quiet fan").

Cortamos el gris, aislando el trozo que viene desde la placa base con un poco de cinta aislante para evitar que toque cualquier parte y se produzca un indeseado corto. La parte que nos interesa es la que sale del ventilador, y es sobre la que vamos a regular el ventilador.

Para conectar los cables rojo y negro sólo los he pelado un poco sin llegar a cortarlos, para aplicarles un poco de estaño con el soldador y alimentar con ellos el aTTiny85.

ES MUY IMPORTANTE colocar bien el sensor de temperatura, para que haga buen contacto con el disipador del RSX, de ello depende que se regule correctamente. Yo lo he sujetado con silicona (puede aguantar temperaturas altas) una vez que he comprobado que todo funcionaba bien:

Y así nos ha quedado ya con la fuente colocada en su sitio.

Tengo varios chips ya preparados con el sensor y programados listos para instalar; si a alguno le interesa que se ponga en contacto conmigo para hacerle el favor y mandárselo por correo.

En el siguiente vídeo podéis ver todos los pasos y la diferencia de RPM del ventilador original y con nuestro regulador automático:

El programa es el siguiente; he añadido código para que haga autolimpieza cada 25 horas (configurables) activando a tope el ventilador durante 3 segundos: Ahora la autolimpieza de casi 3 segundos se realiza cada vez que se enciende la consola:

 /*  ==================================================================

  Sketch control ventilador por PWM con ATTiny85 económico termistor NTC.
  Configurado para ventilador Playstation 3; con autolimpieza al arranque.
  
  Autor: David Losada, basado en trabajos de Rafael Torrales y Antonio Moles.
  Version: 1.32 (Ahora la autolimpieza la hace cada vez que se enciende la consola)
  Fecha: 20 de julio de 2016. Última actualización 7/02/2017
  Compila con Arduino 1.6.9

    ==================================================================   */

#include <EEPROMex.h> //Instalar esta rutina si no la tenéis; está en el repositorio general de Arduino 1.6.9
//Si anduviéramos cortos de memoria, habría que eliminar la librería EEPROM y el código relacionado

//******************* A CAMBIAR SEGÚN TU CONFIGURACIÓN ********************************
//Control temperatura
const float resistor = 6800; //El valor en ohmnios de la resistencia del termistor a 25ºC
const float voltage = 5.0; // El voltaje real en el punto 5Vcc de tu placa Arduino

//Deltas de temperatura
int tempMin = 20; //Temperatura mínima de activación del ventilador
int tempMax = 37; //temperatura a la que funcionará al 100%
//0,85V=velocidad mínima de vent. PS3 y 1,25V vel. máxima
float PWMMin = 0.65; //Voltaje PWM de funcionamiento con temp. mínima (el de la PS3 se pone en marcha con 0,8V)
float PWMMax = 1.3; //Voltaje PWM de funcionamiento al máximo ventilador
//Hay que tener en cuenta que los voltajes se ajustan a las temperaturas pero no se ciñen a ellas,
//es decir, que a tempMin el voltaje será PWMMin, pero a menor temp. el voltaje bajará, y lo mismo
//con el voltaje máximo; si sigue subiendo la temperatura, el voltaje PWM aumentará en consecuencia,
//hay que tener cuidado porque podríamos dar más voltaje del necesario al ventilador

//Definición pines digitales para activar relés
int TempPIN=1; //En el ATTiny85 las entradas son (1)=P2; (2)=P4; (3)=P3; (0)=P5 -> Pin al que conectamos el termistor
int motorPWM=4; //Pin PWM de control motor; P0, P1, P4 el en ATTiny85
const int frecseg = 1; //Tiempo en segundos entre cada ejecución del programa (recomendado entre 1 y 5 segundos)
int ledPIN=1; //Según la placa, en este caso el LED del ATTiny85 B es el 1

//Variables
float Temp= 0; //Valor entrada sensor temp
int fanSpeed= 0; //Velocidad de motor
long timeLED=0; //Para almacenar tiempo
unsigned long millisInicio=0; //Para comprobar paso de horas

//Parte del cálculo temperatura
//Para ahorrar cálculos lo definimos como constante en esta parte del programa
const float K= 273.15; //Para pasar a grados Kelvin
const float e = 2.718281828459045; //Constante matemática 
//const float B = log(RPto2/RPto1)/(1/(TPto2+K)-(1/(TPto1+K))); //Valor Beta de tu termistor calculado de dos puntos
const float B = 3850; //Valor Beta del Datasheet; comentar esta línea si se meten los datos de los dos puntos
const float unodivr = 1/(resistor * pow(e,(-B/298.15))); //Con pow elevamos e al resultado

float T = 0; //Declaramos la variable Temperatura
int grados, decimas; //Para ponerle coma al resultado (en español)

void setup()   { 
//Resetea la EEPROM la primera vez que la usamos
EEPROM.setMemPool(0,512); //Establecemos inicio y tamaño de EEPROM de la tarjeta utilizada
EEPROM.setMaxAllowedWrites(128); //Mínimo para que pueda hacerse el primer borrado completo
//rellenamos de 0 los datos de EEPROM
//Attiny85 tiene 512 Bytes de EEPROM; ajustar según el que uséis
if (EEPROM.readLong(508)!=7091976) { //En ese punto, preferiblemente al final, guardo un valor para saber si ya la he reseteado
  for(int i=0; i<502; i=i+4) { //Ajustar el valor según el tamaño de la (EEPROM)-10
     EEPROM.update(i,0);
      }
  EEPROM.update(508,7091976); //Almacenamos un número indicativo de que ya se ha inicializado en la última posición
  //Serial.println("Borrado de EEPROM terminado");
}
  
//Definir pines
pinMode(TempPIN, INPUT);
pinMode(motorPWM, OUTPUT);
pinMode(ledPIN, OUTPUT);

//Regla de tres; voltMax corresponde a 5V, convertimos a rango de valores PWM
PWMMax=(255*PWMMax)/5;
PWMMin=(255*PWMMin)/5;
millisInicio=millis();
//lcd.begin(16,2); //pantalla de 16 caracteres y 2 filas

delay(5000); //La consola tarda 10 segundos en alimentar el ventilador desde que se enciende
//Para limpieza, ponemos el ventilador a tope 3 segundos
for(int i=0; i<250; i=i+1) {
  analogWrite(motorPWM,i); //Ponemos a tope el ventilador de forma progresiva
  delay(30); //Esperamos 5 segundos en total
}
delay(2500); //dejamos que el motor coja máximas revoluciones
analogWrite(motorPWM,0); //lo volvemos a parar

}
void loop() 
{
  //float B= (RPto2/RPto1);//(1/(TPto2+K)-(1/(TPto1+K)));
// Parte 1:  Leemos el puerto analógico 0 y convertimos el valor en voltios.

//Recoge 5 veces para sacar medias
 for(int x=0; x<5; x++) 
    {    
         Temp=Temp+analogRead(TempPIN);
      delay(25); // espera 25ms entre lecturas
    }
//Sacar media
Temp=Temp/5; 

//Convertimos los valores a la temperatura correcta
    float v2 = (voltage*float(Temp))/1024.0f;  //Convertimos a voltios :)  
  
 // Parte 2: Calcular la resistencia con el valor de los voltios mediante la ecuación del divisor de voltaje
  //voltage = 4.83
  //R2 = 10000
  //R1 = Thermistor resistance
  //V2= v2
  //so V2=(R2*V)/(R1+R2)
  //and r1=((r2*v)/v2)-r2 <--final
  
  float r1a = (voltage*float(resistor))/v2;  
  float r1 =r1a - resistor;


  //Parte 3: Calcular la temperatura basandose en la ecuación Steinhart-Hart y la ecuación del valor Beta.
  // T=B/ln(r1/rinfinit)


  float T = B/log(r1*unodivr);
  Temp=T-273.15; //Convertimos a ºC y ya tenemos la temperatura
 
//Comprobamos temperatura, y actuamos sobre motor en consecuencia
  fanSpeed = doubleMap(Temp, tempMin,tempMax,PWMMin,PWMMax); // Calcula la velocidad a la que corresponde estar
  //(Necesitamos que según aumente la temperatura, lo haga fanSpeed)
  //Valor PWM de 255 en el ATTiny85=5V
  analogWrite(motorPWM, fanSpeed);  // Modifica la velocidad para bajar temp
  
  //DEBUG por serial (no disponible en el aTTiny)
  //Serial.print("Temp: ");
  //Serial.println(Temp);
  //Serial.print("Velocidad: ");
  //Serial.println(fanSpeed); 
  //Serial.print("V: ");
  //Serial.print(fanSpeed*5/255);
  //Serial.print(",");
  //Serial.print(int(fanSpeed*5/2.55));
  //Serial.println("V ");
  //Serial.print("Tiempo encendido: ");   

  //Hacemos parpadear al LED comprobando el tiempo desde la última activación
  if (timeLED>millis()) { //Cuando pasen 50 dias resetear
    timeLED=millis();
  }
  if ((millis()-timeLED)>frecseg*1000*2) {
      analogWrite(ledPIN,100); //enciende LED indicando funcionamiento
      timeLED=millis();
  }
    if ((millis()-timeLED)>frecseg*1000) {
      analogWrite(ledPIN,0); //apaga led
    }

//Si ha pasado una hora desde la puesta en marcha, añadimos una hora
// al contador de la EEPROM, para estadística
if ((millis()-millisInicio)>3600000) { //Ha pasado una hora
  millisInicio=millis(); 
  EEPROM.update(0,EEPROM.readLong(0)+1); //Añadimos una hora
}

  delay(frecseg*1000); //Ponemos en espera al Atmel
}

// *************** RUTINA MAP MEJORADA (admite fracciones)
double doubleMap(double x, double in_min, double in_max, double out_min, double out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
  

En este vídeo podéis ver cómo se programa el económico attiny85:

Instalándolo en la PS3 Slim

Álex, otro intrépido amigo de su PS3, ha querido compartir con nosotros la instalación de este "invento" en su slim. El proceso es el mismo, aunque al ser más compacta, el espacio para los cables es más pequeño.

Como comentaba Álex, el aspecto no es muy bueno con tanta cinta; a los que tengáis tubo termo-retráctil, quedará mucho mejor con él:

Tenemos que asegurarnos de que los cables no peguen luego con el lector BD

El sensor colocado; los cables van mejor junto a la base

Ha colocado el AtTiny85 en el mismo hueco que Sony ha dejado en ambos modelos para mejorar la ventilación de la fuente:

El espacio entre las aletas del disipador es menor, pero así queda bien sujeto

Y el resultado final con los cables ocultos entre la caja del disco duro y los plásticos, queda todo bien ajustado a falta de tapar con el lector. Hay que asegurarse de que no queden tocando con el lector Blu-ray, ya que podrían pegar y dificultar su funcionamiento:

Otra mejora: Aumentar la refrigeración de la fuente de alimentación de la PS3

Para quien le interese, tuve primero la idea de mejorar la disipación de calor de la fuente añadiendo una plancha de aluminio de 1 mm. recortada y atornillada a los dos disipadores que tiene, para eliminar más fácilmente el calor de los reguladores y MOSFET y que nos dure más:

Apliqué silicona o pasta térmica encima de ambos disipadores:

Dejamos que se pegue durante un día al menos y luego perforamos en cada disipador para colocar los tornillos para asegurarlo bien y mejorar el contacto (opcional si hemos usado silicona):

Hay que dejar espacio para los soportes de plástico, por suerte 1 mm. de aluminio es fácil de recortar con unas tijeras fuertes de electricista por ej.:

Gracias a este mod, nuestra play "dará juego" mucho más tiempo, lleva un mes funcionando y sólo se percibe levemente el ventilador si quitas el sonido, y su temperatura ha bajado mínimo 15ºC con respecto a la configuración de fábrica.

Y eso es todo de momento, !Gracias por vuestros comentarios!

Más información:
Regulando la velocidad de ventiladores (inglés)
Conectando y programando tu Digispark
https://digistump.com/wiki/digispark/tutorials/basics
http://digistump.com/wiki/digispark/tutorials/connecting
Empezando con el Attiny85
Thermistor 6K8:
http://www.farnell.com/datasheets/1458615.pdf
http://uk.farnell.com/te-connectivity-neohm/ntc0805j6k8/thermistor-ntc-0805-6k8/dp/2042916
Ventiladores de PC: Midiendo pulsos
Ventiladores de PC con 4 pines