HALFZWAAR.NL

De echte Halfzware uit Friesland!

Weerstation

Arduinofoon/Wonderfoon

De Arduinofoon is een oude PTT telefoon die is omgebouwd tot mini-jukebox met behulp van een Arduino Uno microcontroller en een MP3 speler. Als je de hoorn van de haak neemt hoor je de kiestoon en als je daarna een nummer kiest tussen de 0 en de 9 hoor je vervolgens een muziekje.

Hieronder de code…

/*
De Arduinofoon.
Een MP3 speler ingebouwd in een ouderwetse PTT kiesschijftelefoon type T65.
Elk gedraaid nummer laat een MP3 melodie horen.
Bij opnemen van de hoorn klinkt de kiestoon.
Afgeleid van de wonderfoon met Raspberry PI3 maar nu met een Arduino UNO R3.
Zie bijbehorend aansluitschema met technische gegevens Arduinofoon 1.5.
Softwareversie 1.4a.
Alex Pikkert Mei 2019.
MP3 speler aansluitingen:
pin 2 next
pin 4 previous
pin 5 repeat
pin 6 pause
pin 12 5 Volt power MP3 speler ON/OFF via schakeltransistor.
*/
#include <EEPROM.h>
int dialHasFinishedRotatingAfterMs = 100;
int debounceDelay = 10;
int needToSend = 0;
int count; // dit is de variable waar de kiesschijf keuze ( 1 tot 0 wordt 1 tot 10) in vastgelegd wordt.
int lastState = LOW;
int trueState = LOW;
long lastStateChangeTime = 0;
int reading = 0;
int address = 3; // het EEPROM adres waar het songnummer opgeslagen wordt.
int lastSong; // opgeslagen songnummer in EEPROM.
int i; // teller hoeveel keer de MP3 speler vooruit of achteruit gezet moet worden.
int j; // teller welke actuele song gedraaid is met de kiesschijf.
int dialtoneOut = 7; // de uitgang met een 425 Herz kiestoon. Let op: pin 3 en 11 NIET gebruiken. (Zie "tone" uitleg op de Arduino reference site).
int hookContact = 8; // contact gesloten (LOW) als de hoorn van de haak genomen is.
int dialEnabled = 9; // contact gesloten (LOW) als de kiesschijf actief is.
int dialPulses = 10; // contact gesloten LOW) en alleen open als er een puls gegenereerd wordt.
int mp3Power = 12; // als deze poort HIGH is dan is de MP3 speler aan.
//******************************************************************************************
void setup()
{
pinMode(dialPulses, INPUT_PULLUP); // ingang voor het pulscontact van de kiesschijf.
pinMode(dialEnabled, INPUT_PULLUP); // ingang voor het contact van de kieschijf als die geactiveerd is.
pinMode(hookContact, INPUT_PULLUP); // ingang voor het contact van de telefoonhoorn opgenomen/neergelegd.
// PULLUP is nodig om instabiele ingang te voorkomen bij geopend en dus zwevend contact.
// als een contact open is wordt de ingang hooggehouden (HIGH) door de interne pullup weerstand van de Arduino.
pinMode(mp3Power,OUTPUT); // deze poort is 0 of 5 volt om de MP3 speler uit- of in te schakelen.
if (digitalRead(hookContact) == LOW) // als de hoorn opgenomen is doe het volgende:
{
mp3PowerON(); // zet de MP3 speler aan.
delay(2500); //wacht even tot de MP3 speler gestart is.
pause(); // zet de MP3 speler op pauze.
tone(dialtoneOut,425); // zet de kiestoon aan.
}
}
//******************************************************************************************
void loop()
{
// als de kiesschijf actief is, detecteer het nummer en zet de kiestoon uit.
// als de kiesschijf in rust is, selecteer de song door de MP3 speler vooruit of achteruit te zetten.
// als de hoorn op de haak gelegd wordt ga dan in de wachtlus en zet indien nodig de kiestoon uit.
if (digitalRead(dialEnabled) == LOW){numberDialed();noTone(dialtoneOut);}
else{selectSong();}
if (digitalRead(hookContact) == HIGH){mp3Wait();}
}
//subroutines ******************************************************************************************
// zet de MP3 speler vooruit of achteruit afhankelijk van het verschil tussen vorige en de actuele song.
void selectSong()
{
switch (count) {
case 1:j=1;Song();break;
case 2:j=2;Song();break;
case 3:j=3;Song();break;
case 4:j=4;Song();break;
case 5:j=5;Song();break;
case 6:j=6;Song();break;
case 7:j=7;Song();break;
case 8:j=8;Song();break;
case 9:j=9;Song();break;
case 10:j=10;Song();break;
default:
// als de waarde nergens past, voer dan de default instructie uit.
// de default instructie is optioneel.
break;
}
}
// ga naar de actuele song.
void Song()
{
lastSong = EEPROM.read(address); // opgeslagen songnummer van de vorige song.
if(lastSong == j){next();prev();} // als zelfde nummer gekozen is ga dan toch afspelen.
EEPROM.update(address, j); // sla de actuele song op in het geheugen.
if(lastSong <j){for (i=lastSong;i<j;i++){next();}} // ga het verschil tussen de vorige en actuele song verder.
if(lastSong >j){for (i=j;i<lastSong;i++){prev();}} // ga het verschil tussen de vorige en actuele song terug.
delay(400);repeat(); delay(5000); // wacht even en geef dan een repeat commando zodat steeds dezelfde song gespeeld wordt.
}
// besturing van de MP3 speler.
void next()
{pinMode(2,OUTPUT); delay( 200);pinMode(2,INPUT);delay(400);count=0;}
void prev()
{pinMode(4,OUTPUT); delay(200);pinMode(4,INPUT);delay(400);count=0;}
void repeat()
{pinMode(5,OUTPUT); delay(200);pinMode(5,INPUT);delay(400);count=0;}
void pause()
{pinMode(6,OUTPUT); delay(200);pinMode(6,INPUT);delay(400);count=0;}
// zet de MP3 speler uit.
void mp3PowerOFF()
{digitalWrite(mp3Power,LOW);}
// zet de MP3 speler aan.
void mp3PowerON()
{digitalWrite(mp3Power,HIGH);}
// wachtlus als de hoorn op de haak gelegd wordt. kiestoon gaat uit en als hoorn opgenomen wordt dan volgt een soft reset.
void mp3Wait()
{noTone(dialtoneOut);mp3PowerOFF();
while(digitalRead(hookContact)==HIGH){} ;
asm volatile (" jmp 0");
}
// detectie van het gekozen nummer, vastgelegd in de variabele count.
void numberDialed()
{
reading = digitalRead(dialPulses);
if ((millis() - lastStateChangeTime) > dialHasFinishedRotatingAfterMs)
{if (needToSend==1) {needToSend = 0;count = 0;}
}
if (reading != lastState) {lastStateChangeTime = millis();}
if ((millis() - lastStateChangeTime) > debounceDelay)
{if (reading != trueState)
{trueState = reading;if (trueState == HIGH) {count++;needToSend = 1;}
}
}
lastState = reading;
}

Deze onderdelen heb je nodig:

  • 1 draaischijftelefoon type T65
  • meeraderig montagedraad in verschillende kleuren
  • krimpkous 4 mm doorsnede
  • 1 Arduino UNO R3 (een originele of een kloon kan ook)
  • 1 MP3 speler type FN-M981
  • 1 voedingsplug 9-12 Volt minimaal 1 Ampère met 2,1mm ronde steker
  • 1 micro SD kaartje voor de muziek (1 Gb is meer dan voldoende)
  • 1 SD kaarthouder om het micro SD kaartje op de PC te kunnen aansluiten
  • 6 weerstanden 1 kOhm 1/8 Watt
  • 1 weerstand 22 kOhm 1/8 watt
  • 1 transistor type BC547
  • 1 condensator 1uf
  • 1 DC contrasteker 2,1 mm met bedrading
  • 1 DC steker 2,1 mm met bedrading
  • 1 zekeringhouder met een glaszekering 1A traag voor inbouw in bedrading
  • 1 rijtje aansluitpinnetjes voor de Arduino UNO
  • 1 stukje experimenteerprint 6×8 gaatjes 0,1 inch afstand met eilandjes koper
  • 1 plaatje hardboard volgens tekening, 3,2 mm dik
  • 2 M3 boutjes 10 mm lang
  • 2 M3 boutjes 20 mm lang
  • 4 M3 moertjes
  • 2 M5 moeren, gebruikt als afstandshouders
  • dubbelzijdig plakband

Het schema


Ploegendienstkalender 2018

De kalender van 2018 staat weer online…

Philips Reverbeo 1961-1963

Country: Netherlands
Manufacturer / Brand: Philips; Eindhoven (tubes international!); Miniwatt
Year: 1961–1963 Category: Broadcast Receiver – or past WW2 Tuner
Valves / Tubes 10: ECC85 ECH81 EF89 EBF89 EM80 EAA91 ECC83 EL84 EL84 EZ81
Semiconductors (the count is only for transistors) 1: OC71
Main principle to an articleSuper-Heterodyne (Super in general); ZF/IF 452/10700 kHz
Tuned circuits 6 AM circuit(s) 11 FM circuit(s)
Wave bands Broadcast, Long Wave, Short Wave plus FM or UHF.
Details
Power type and voltage Alternating Current supply (AC) / 110; 127; 145; 165; 220; 245 Volt
Loudspeaker 2 Loudspeakers / Ø 21 cm = 8.3 inch
Power out 3 W (unknown quality)
from Radiomuseum.org Model: Capella-Reverbeo B7X14A /00 /01 – Philips; Eindhoven tubes
Material Wooden case
Shape Tablemodel with Push Buttons.
Dimensions (WHD) 712 x 265 x 292 mm / 28 x 10.4 x 11.5 inch
Notes
Loudspeakers: AD3800AM (800 Ohm). Bi-amplifier, stereo only for pick-up and tape. Dial lamp 2x 8024N (6,3V/0,3A).

Net weight (2.2 lb = 1 kg) 14 kg / 30 lb 13.4 oz (30.837 lb)

Prototype Arduino Weerstation

Proto

Prototype op een breadboard

Als geheugensteuntje voor me zelf…

De uiteindelijke uitvoering zoals het moet worden…

Wat hebben we nodig voor deze klus:

1 X Arduino Uno
1 X ESP8266 Wifi-module
1 X DHT22 temperatuur en luchtvochtigheidssensor
1 X Barometer-sensor
2 x LED Display – 7-segment module
2 X Blauwe LED
2 X Weerstand 100 Ω
1 X 3,3 volt spanningsregelaar (voor de ESP8266)


Het arduino weerstation is online…

Hier de tijdelijke code voor de Arduino:

#include<stdlib.h>                 //voor strings
#include <Arduino.h>
#include <DHT.h>
#include <Adafruit_BMP085.h>
#include <SoftwareSerial.h>

#include "SevenSegmentTM1637.h"
#define DEBUG 0                                     // change value to 1 to enable debuging using serial monitor

String IP = "184.106.153.149"; // ThingSpeak IP Address: 184.106.153.149
String GET = "GET /update?key=XXXXXXXXXXXXX";    // replace with your channel key
int count = 1;

long previousMillis = 0;        // will store last time Thingspeak was updated
// the follow variables is a long because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long interval = 300000;           // interval at which to update (milliseconds) (5 minuten)


float temp;
float p;
float hum;
int h;

#define CLK 2
#define DIO 3

#define CLL 4
#define DIP 5

#define DHTTYPE DHT22   // DHT 11
#define DHTPIN 8     // what digital pin is DHT connected to
#define BLED 12      // Blauwe LED   pinMode(BLED, OUTPUT); //initialiseer pin 12 (BLAUWE LED).
#define WLED 11

Adafruit_BMP085 bmp;
DHT dht(DHTPIN, DHTTYPE);
SevenSegmentTM1637 tm1637(CLK, DIO);
SevenSegmentTM1637 tm1638(CLL, DIP);
//{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
//0~9,A,b,C,d,E,F
SoftwareSerial mySerial(7, 6); // RX, TX

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  mySerial.begin(9600);
  delay(1000);

  tm1637.setBacklight(30);  // set the brightness to 100 %
  tm1638.setBacklight(30);  // set the brightness to 100 %


  delay(300); // Pauze om sensor stabiel te laten worden
  if (DEBUG) {
    Serial.println("Klaar om te beginnen...\r\n");
  }
  delay(700); // Nog een pauze (in totaal is 1sec nodig)

  if (!bmp.begin()) {
    if (DEBUG) {
      Serial.println("Could not find a valid BMP085 sensor, check wiring!");
    }
    while (1) {}
  }
  resetWiFi();
  tm1637.begin();            // initializes the display
  tm1637.print("INIT");      // display INIT on the display
  tm1638.begin();            // initializes the display
  tm1638.print("INIT");      // display INIT on the display

  delay(1000);
}

void loop() {
  byte  rawData;
  int disptemp;
  int har;
  int vocht;

  // put your main code here, to run repeatedly:

  //************************************************************************
  //*********** Temperatuur op display1 ************************************

  unsigned long currentMillis = millis();

  temp = dht.readTemperature();
  hum = dht.readHumidity();
  vocht = hum * 100;
  har = temp * 100;
  if (DEBUG) {
    Serial.print("Temp gelezen: ");
    Serial.println(temp);
    Serial.print("Vocht bewerkt:");
    Serial.println(vocht);
  }

  tm1637.clear();

  tm1637.setColonOn(1);
  rawData = B11100011;

  if (temp < 10)
  {
    tm1637.setCursor(0, 1);
  }
  else
  {
    tm1637.setCursor(0, 0);
  }
  if (temp < 0)
  {
    tm1637.setCursor(0, 0);
  }
  tm1637.print(har);
  tm1637.printRaw(rawData, 3);

  //*************************************************************************
  //*********  LUCHTDRUK op Display 2 ***************************************

  h = bmp.readPressure() / 100;
  for (int i = 0; i <= 4; i++) {
    tm1638.clear();
    tm1638.setColonOn(0);
    tm1638.print(h);

    delay(2000);
    // ******* En VOCHT ********************************************************
    tm1638.clear();
    tm1638.setColonOn(1);
    tm1638.print(vocht);
    //**************************************************************************
    //digitalWrite(BLED, HIGH);
    if (DEBUG) {
      Serial.println(i);
    }
    delay(2000);

  } //Einde FOR LOOP
  //**************************************************************************
  //**************************************************************************

  if (currentMillis - previousMillis > interval) {
    // save the last time you blinked the LED
    previousMillis = currentMillis;
    digitalWrite(BLED, HIGH);         //Even laten zien dat we data uploaden...
    
    String cmd = "AT+CIPSTART=\"TCP\",\"";// Setup TCP connection
    cmd += IP;
    cmd += "\",80";
    mySerial.println(cmd);
    delay(5000);
    if (mySerial.find("Error")) {
      if (DEBUG) {
        Serial.println("ERROR while SENDING");
      }
      digitalWrite(WLED, LOW);
      resetWiFi();
      return;
    }
    cmd = GET + "&field1=" + String(temp) + "&field2=" + String(hum) + +"&field3=" + String(h) + "\r\n";
    mySerial.print("AT+CIPSEND=");
    mySerial.println(cmd.length());
    delay(15000);
    if (mySerial.find(">"))
    {
      mySerial.print(cmd);
      if (DEBUG) {
        Serial.println("Data sent");
      }
    } else
    {
      mySerial.println("AT+CIPCLOSE");
      if (DEBUG) {
        Serial.println("Connection closed");
      }
    }
    digitalWrite(BLED, LOW);
  }

  //**************************************************************************


}

void clearRXbuffer() {
  while (mySerial.available()) {
    char c = mySerial.read();
    //Serial.write(c);
    delay(3);
  }
}

void sendWiFi(String s, bool clearBuffer) {
  mySerial.println(s);
  mySerial.println("");
  delay(100);

  if (clearBuffer) clearRXbuffer();
}

void resetWiFi() {
  unsigned long timout = 0 ;
  digitalWrite(WLED, LOW);
  Serial.println ("WiFi Reset ");
  // Wait for an IP address (WIFI GOT IP)
  char c, buffer[25];
  int i = 0, w = 0;

  do {
    if (millis() > timout) {
      clearRXbuffer();
      timout = millis() + 20000;
      delay(1000);
      sendWiFi("AT+RST", true);
    }

    if (mySerial.available()) {
      c = mySerial.read();
      if (c == 'W' || i >= 20) i = 0;
      if (c > 9 && c < 91) {
        buffer[i++] = c;
      }
    } //else displayLoop(w++);

    if (w > 11) w = 0;

  } while (strstr(buffer, "WIFI GOT IP") == NULL);

  digitalWrite(WLED, HIGH);
}

 

De Philips RR70

Philips RR70

Country: Germany
Manufacturer / Brand: Philips Radios – Deutschland
Brand

Deutsche Philips-Ges.

Year: 1970–1972 Category: Broadcast Receiver – or past WW2 Tuner
Semiconductors (the count is only for transistors) 20:
Main principle Super-Heterodyne (Super in general); ZF/IF 460/10700 kHz
Tuned circuits 5 AM circuit(s)     9 FM circuit(s)
Wave bands Broadcast, Long Wave, Short Wave plus FM or UHF.
Details  
Power type and voltage Line / Batteries (any type) / 110-127; 220-240 / 6×1,5 Volt
Loudspeaker Permanent Magnet Dynamic (PDyn) Loudspeaker (moving coil) / Ø 10 cm = 3.9 inch
Power out 1.5 W (unknown quality)
from Radiomuseum.org Model: Radio Recorder Automatic de Luxe RR70 22RR700 – Philips Radios – Deutschland
Material Modern plastics (no Bakelite or Catalin)
Shape Portable set > 8 inch (usable also without mains)
Dimensions (WHD) 310 x 180 x 90 mm / 12.2 x 7.1 x 3.5 inch
Notes 15 Dioden, ZF-Varianten: /00 = 452kHz, /19 = 460kHz.
Net weight (2.2 lb = 1 kg) 3.5 kg / 7 lb 11.3 oz (7.709 lb)
Collectors’ prices  
External source of data Erb
Source of data Handbuch VDRG 1970/1971
Literature/Schematics (1) — Original-techn. papers.