Small craft project for the summer time

solar module
As a mini – craft project for the summertime I call the following tinkering. A small monocrystalline solar module called “SM 6” from a well-known large electronics distributor starting with “C” and ending with “d” plays the main role in the project. The module has a nominal power of 6Wp with a maximum current of 320mA. The rated voltage is 17.3V. The open circuit voltage is 20.8V. The silicon cells are embedded in an EVA (ethylene vinyl acetate) plastic sheet and are UV and moisture resistant. The whole module is about 25cm x 25cm in size. It is thus ideally suited to provide the power to power USB devices. For example, I thought about WIFI IP cams. It should also be possible to charge smartphones or tablets.

In order to be able to do this, the operating voltage of the USB standard (5V) must be generated from the rated voltage of the photovoltaic cell. You could do that easily with a 7805 controller and convert the difference into heat. But this is the least efficient way to get the panel’s energy into a cell phone. Firstly, the internal resistance of the panel depends on the light intensity, which has a major impact on the efficiency of unmatched load resistors. On the other hand, a series regulator is a power shredder, since the difference between input voltage and regulated output voltage is converted into power loss, ie heat, during the flow of current. Here you are better served with a switching converter (buck converter).

 

 
In a simple laboratory setup, the behavior of the panel can be examined. For this purpose, the open circuit voltage of the panel is measured at different illuminance levels. Subsequently, the panel is loaded with different resistance values ​​and the current through the load as well as the voltage at the panel are measured. The measured values ​​are recorded and the Ri (internal resistance of the source) is calculated. The following circuit diagram shows the measurement setup:
measurement setup – schematic
The ammeter is an Agilent and Voltmeter Keithley 2701 table multimeter. These gauges can both be controlled via SCPI commands. The interface is a LAN port. This makes it easy to implement an automated measurement process via a PC and a suitable script. And since Matlab offers a very convenient way to script, it’s also used right now. In order to be able to measure in a laboratory and have approximately the same environmental conditions, a table lamp with halogen bulb is used instead of the sun. The brightness of the lamp is easily adjusted by supplying it with a laboratory power supply of 0-13V. Of course, the laboratory power supply can also be controlled by Matlab.
measurement setup with lamp as “sun”

The lamp is placed at a distance of 25cm in the middle of the panel. In order to get a feeling of which illuminance is achieved with the lamp, a reference measurement is taken with a luxmeter. That is, the lamp goes through the power ramp of 0-13V and the lux meter measures the illuminance at a distance of 25cm under the lamp. The whole thing is resolved in 0.5V steps. This results in a curve that looks like this:

Voltage on the lamp results in illuminance

Now the measurement can begin. Resistors are manually connected to the panel as a load resistor and current and voltage are measured at each brightness level. There are eleven load resistance values ​​ranging from 4.7 ohms to 220 ohms connected in sequence. An idle measurement is then of course made without load resistance. The following graph shows the calculated internal resistance for two loads of the panel over the brightness curve of the lamp in lux and in the other graph over the voltage at the lamp (for better scaling). The internal resistance of a source is calculated from the open circuit voltage of the source minus the voltage under load, divided by the current. With the difference between the no-load and load voltage, the voltage drop at the internal resistance is obtained. Since the load is also known as the current, it is only necessary to use Ohm’s law to obtain the resistance value …

Internal resistance vs. illuminance
Internal resistance vs. Voltage on the lamp

Since some clarifications about the behavior of the PV cell have now been eliminated, I can briefly report on the structure of the voltage converter. As previously announced, a switching converter is the more efficient way to adapt the energy to the consumer. Here comes an LM2596S used. The LM 2596 is a “Simple Switcher Power Converter” that switches at 150kHz and can supply a load with 3A.) Here is an overview of the functions:

  • 3.3-V, 5-V, 12-V, and Adjustable Output Versions
  • Adjustable Version Output Voltage Range: 1.2-V to 37-V ± 4% Maximum
    Over Line and Load Conditions
  • Available in TO-220 and TO-263 Packages
  • 3-A Output Load Current
  • Input Voltage Range Up to 40 V
  • Excellent Line and Load Regulation Specifications
  • 150-kHz Fixed-Frequency Internal Oscillator
  • TTL Shutdown Capability
  • Low Power Standby Mode, IQ, Typically 80μA
  • Uses Readily Available Standard Inductors
  • Thermal Shutdown and Current-Limit Protection

(source: datasheet from vendor TEXAS Instrument)

With this switching converter and a few other components can quickly assemble a circuit and transform with the layout tool “Eagle” into a board. However, this circuit is so simple that it only works as efficiently as possible with the advantages of the LM2596, but does not perform any power tracking. This means that the load representing the circuit for the solar cell is not adapted to the internal resistance of the solar cell.

 

Circuit diagram of the DC-DC converter

From this circuit, a simple layout was created, a board etched and equipped. A USB socket on the output allows the direct connection of USB devices. To make the whole thing look a bit reasonable, I have donated the board still a small plastic casing …

Measurement of illuminance

measurement setup
Switchable load resistors
Layout on the computer
Foil for creating the printed circuit board
Etched PCB
Etched PCB
Finished circuit
   Sende Artikel als PDF   

Calculator from 1975: PICO PA-80N

From 1975 this Japanese calculator comes. He was sold from 1975 to 1976 by the Eduscho – Tchibo coffee chain. The device is called “PICO” PA-80N. Exactly this model was also once in my father’s possession and I was already fascinated by the luminous seven-segment displays as a child. And that was the problem again. As far as I can remember, I was in elementary school age, when I first disassembled the device into its individual parts. That was not the problem, but it was not there. Over time, I disassembled the computer several times. At some point wires broke off and nothing worked. Reassembled, the Pico then disappeared into a box and was disposed of years later by my father. Why I took apart and assembled the small computer again and again, I can not say today anymore. Apparently it was the success of an eight-year-old, after assembly again to have a working device – just to last. 🙂 On an online flea market platform, I found just such a calculator and in addition to that in a TOP condition and almost gave it. So I had to have him …

Pico with the imitation leather case

To the dates:
The display has eight 7-segment digits based on LED technology. To be able to read the MikroLEDs they are embedded in a convex shaped plastic. This achieves a magnifying effect that makes the numbers readable.

Siebensegment – Anzeige mit 8 Digits

LEDs under the convex plastic encapsulant

The housing is made of aluminum and plastic and has the dimensions in about a cigarette box. 8.2 x 5.7 x 2.4 cm. In order to keep the calculator gently, there was a leatherette case to do so.

Mainboard des PICO

The calculator is powered by two Tripple A (AAA) batteries, so with 3V. Optionally, there was also an external power supply that could be purchased according to the then price list by almost 18DM. (unfortunately no price information for Austria)

Power adapter socket at the top

Technically, the small computer consists of a display board, a “motherboard” and a keyboard board. These boards are connected to each other with a multipolar bridge line. This should not be bent too often, because then quickly break off individual wires …

Opened circuit boards

The display board is driven by a Toshiba T1337 Displaydriver IC and the computer itself is a GI C593 (General Instruments) processor that handles the basic operations and percentage calculation. The processor works with a supply voltage of 15-17VDC and is able to drive Floureszentplays directly. In order to produce in the small Pico computer from the 3V of the AAA batteries also the 17VDC a small DC / DC converter on the Mainboard expires.

central processing unit

displaydriver

DC / DC converter circuit for the 17V of the CPU

datasheet from theC593 (source: 1977 Datacatalog GI Microelectronics)

In addition to the faux leather case, there was also a card with a user manual and a flyer. It was printed with warranty information and an advertising slogan:
“The Pico will become an indispensable arithmetic assistant for you. At school, at home, at work – wherever there is something to be expected, the Pico is at your fingertips. Just press keys, and you’ve already calculated the most complicated tasks. This is how arithmetic becomes a pleasure! “(Source: Internet)
   Sende Artikel als PDF   

Data Node with Arduino

Unfortunately, the intervals in which I find some time to write a new post for the blog have not gotten shorter. But post a post per month, I think … 🙂

This time it’s not a retro craft project from the local Gefielden or a restoration of an old device, but again something about Arduino. The idea – to build a sensor that, as always, transforms a physical quantity into an electrical signal. This is nothing special and what kind of sensor it will be, I will not describe for the time being. But there should not be a sensor board, but many. And these sensor boards short “sensors” are to be networked together in a two-dimensional matrix. You can imagine it as a chessboard, with each of the chessboard panels representing a sensor. This network of sensors – ie sensor nodes – should then be connected via a transfer point to a computer and output the sensor data of the respective field. It should then also be possible to remove individual fields from the network without the remaining network losing its function.

The whole system should be as simple and cheap as possible. And so a system concept was quickly developed in which the nodes communicate via the I²C bus and send their data to a master. The following diagram is intended to illustrate this.

This concept, I thought, is easiest to implement with an ATmega microcontroller. The has enough IO’s, an I²C bus and UART onboard, as well as analog inputs and requires little component peripherals to bring it to life in its own layout. And there is nothing faster to do such a test setup of such a node network than to use the well-known Arduino development boards. I have chosen the cheapest version for a test setup -> the Chinanachbau of the ArduinoUno (Joy-IT UNO) with the Atmga328 in the capped DIL housing.

Joy-It Uno Boards

The picture shows ten of these microcontroller boards. Of these, one should be used as a bus master and nine as slaves. Of course, each of these slaves has a unique bus address, which only occurs once in the system. In the test setup, this bus address is permanently assigned via the program code, since anyway each Arduino must be connected to the computer in order to carry out the program upload. Of course, that should look different later. Because the Arduino is on the Atmega328 chip, its quartz and the few resistors reduced on the sensor board with gelayoutet. The chip should then be programmed via the ISP pins. Of course, as many boards do not always customize the program code and they all have the same Flash file, I want to set the sensor address with a 7-bit DIP switch. A 4021 Cmos Static Shift Register is supposed to read the bits after the controller is powered on and push them serially into the controller. The resulting value is then available as a bus address in a variable.

Each of these slaves with their individual bus address is now queried in sequence by the master node, which state it has and whether it should switch an output or not. That is, the node has only one DO (digital output) with which it can, for example, turn an LED off and on and interrogate one or more DIs (digital input) which polls a state, for example a simple switch. These functions are stored in 2 bits of a byte. Another byte is used to transfer the bus address. So two bytes are sent over the bus. The picture below shows the test setup with the “UNO boards”

All Arduinos are connected to I²C data bus and power supply

The process is as follows:

MASTER:
The master node sends a request after the series to all slave addresses and a switch command (which comes from all nodes of a TEST push button input on the master) for the LED output of the node and sees if a response comes back or not. If no answer comes, the node is not in the network or is defective. If there is an answer, this consists of the address of the node and its status byte. This information is transmitted via an RS232 terminal to the computer connected to the master. Thus, for example, the switching status of each individual node can be displayed on the screen via a visualization using (NI LabView, or Matlab or similar). By adapting the master program, it is also possible to switch the LED outputs of the slaves via the computer.

SLAVE:
When the master node requests data from the slave, the slave sends back two bytes. Where byte0 again is the slave ID (ie bus address) and byte1 is the data. Byte1 actually consists of only two bits encoded as follows (in decimal representation):
 0 = LED off| Sensor not triggered
 1 = LED on | Sensor not triggered
 2 = LED off | Sensor triggered
 3 = LED on | Sensor triggered

The program code as an example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
// I2C Slave Code
// 16.05.2018 
// ver 1.3
#include <Wire.h>
#define ADDRESS 2     // adresse des slave knotens
#define PAYLOAD_SIZE 2 // anzahl der bytes  die vom masterknoten zu erwarten sind
int LED=12;            // indicator led an pin D12
int SENSOR = 8;        // sensor input an pin D8
bool actionState=0;      // sensor zustand
int busstatus;  // statusvariable 
                       // 0 = LED aus | sensor nicht belegt
                       // 1 = LED ein | sensor nicht belegt
                       // 2 = LED aus | sensor belegt
                       // 3 = LED ein | sensor belegt
 
bool sensled=0;          // sensor LED
byte nodePayload[PAYLOAD_SIZE];

void setup()
{
  pinMode(LED, OUTPUT);         //sensorLED
  pinMode(SENSOR, INPUT);       //Sensor 
  Wire.begin(ADDRESS);          // Activate I2C network
  Wire.onReceive(receiveEvent);
  Wire.onRequest(requestEvent); // auf master anforderung warten
                      //  // debug interface
                      //  Serial.begin(9600); 
}

// *********************************mainloop****************************************************
void loop()
{ 
  delay(5);
  
   if(sensled){digitalWrite(LED, HIGH);}
         else{digitalWrite(LED, LOW);}

  actionState = digitalRead(SENSOR);  //Sensoreingang abfragen        
   if((actionState==1)&&(sensled==1)) {busstatus=3;}
   else if ((actionState==0)&&(sensled==1)) {busstatus=1;}
   else if ((actionState==1)&&(sensled==0)) {busstatus=2;}
   else if ((actionState==0)&&(sensled==0)) {busstatus=0;}

                      //  Serial.println("######################");
                      //  Serial.print("busstatus neu setzen ");
                      //  Serial.println(busstatus);
                      //  Serial.print("sensled LED            ");
                      //  Serial.println(sensled);
                      //  Serial.print("actionState           ");
                      //  Serial.println(actionState);
                      //  Serial.println("######################");
  nodePayload[0] = ADDRESS;                  // Adresse in byte0 zurücksenden.  
  nodePayload[1] = busstatus;                //byte 1 ist die statusinfo der LED
}



// *********************************************************************************************
void requestEvent()
{ Wire.write(nodePayload,PAYLOAD_SIZE);  
  Serial.println("bytes status schreiben");
  Serial.println(nodePayload[0]);
  Serial.println(nodePayload[1]);
  delay(5);
}

// *********************************************************************************************
void receiveEvent(int bytes)  //einen wert vom I2C lesen
      
{
  
  busstatus = Wire.read(); //If the value received was true turn the led on, otherwise turn it off  
                              //  Serial.println("status empfangen");
                              //  Serial.println(busstatus);
  if((busstatus==1)||(busstatus==3)){sensled = 1;}
                                else{sensled = 0;}
                                              
}

 

The bus address must still be entered individually in this slave code. In the next version, the previously described “serializer” of the parallel dip-switch variant will be implemented. The following code example is from the master node, which reads out the slaves and sends a LED pattern to the sensor slaves using the test button:

 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
// I2C masterknoten 
// 16.05.2018 
// ver 1.2
// changes abfrage wenn kein knoten am bus dann 255 ausgeben
#include <Wire.h>

#define busbytes 2          // wievele byte vom I2C knoten zu erwarten sind
#define maxKNOTEN  10       // anzahl der zu scannenden slaves
#define startKNOTEN 2       // startadresse der slaves
#define DELAY 5             // einfach ein delay ....

int i; int j=0;
int buttonPin = 12;
int testbut = 0; int anim = 0;
int buttonState = 0;
int DATEN[busbytes];
int adresse; int busstatus;  
byte sensorbelegt; byte ledsensoron;

                       // 0 = LED aus | Sensor nicht belegt
                       // 1 = LED ein | Sensor nicht belegt
                       // 2 = LED aus | Sensor belegt
                       // 3 = LED ein | Sensor belegt

int leddat1[] = {1,1,1,1,0,1,1,1,1}; // -
int leddat2[] = {0,0,0,0,1,0,0,0,0}; // |

void setup()
{
  Serial.begin(9600);  
  Serial.println("MASTER-KNOTEN");
  Serial.print("Maximum Slaveknoten: ");
  Serial.println(maxKNOTEN);
  Serial.print("Datengroesse in byte: ");
  Serial.println(busbytes);
  Serial.println("***********************");
  
  Wire.begin();                 // Activate I2C link
  pinMode(buttonPin, INPUT);    // test-tastereingang festlegen
}


//#####################################################################################################
void loop()
    
{
  for (int Knotenadresse = startKNOTEN;         //alle knoten scannen
           Knotenadresse <= maxKNOTEN; 
           Knotenadresse++) 

        
    //################################################################################################       
    { 
     // testbut = 0;  
     anim = 0;   
    Wire.requestFrom(Knotenadresse, busbytes);        // daten vom jeweiligen knoten anfordern
                                                 
           DATEN[0]=255; DATEN[1]=255;   // wenn kein knoten dann auf 255 setzen    
          if(Wire.available() == busbytes) {                                    // wenn knoten und daten dann
            for (i = 0; i < busbytes; i++) DATEN[i] = Wire.read();          // daten holen (zuerst busID, dann daten)
           // for (j = 0; j < busbytes; j++) Serial.println(DATEN[j]);        // daten an rs232 ausgeben   
          }            

//            Serial.println(Knotenadresse);
//            Serial.println(DATEN[0]);
//            Serial.println(DATEN[1]);
//            Serial.println(" ");
           
            adresse=DATEN[0]; 
            busstatus=DATEN[1];
           
            if(busstatus == 0)       {sensorbelegt=false;  ledsensoron=false;}
            else if (busstatus == 1) {sensorbelegt=false;  ledsensoron=true;}
            else if (busstatus == 2) {sensorbelegt=true;  ledsensoron=false;}
            else if (busstatus == 3) {sensorbelegt=true;  ledsensoron=true;}
      
         //################################################################################################
         //Testbutton Status lesen und variable testbut entsprechend setzen
       
          buttonState = digitalRead(buttonPin);               //tastereingang einlesen
          if(buttonState == HIGH){                            //wenn taster aktiv dann variable anim setzen
          anim = 1;
          //delay(5); 
          }
            
//            //debug debuginfo tasterstatus auf rs232 ausgeben
//            Serial.println("#######################");
//            Serial.print("Knoten Adresse    :");
//            Serial.println(adresse);
//            Serial.print("Busstatus         :");
//            Serial.println(busstatus);
//            
//            Serial.println("----------------");
//            Serial.print("Fliese belegt    :");
//            Serial.println(sensorbelegt);
//            Serial.print("LED Fliese       :");
//            Serial.println(ledsensoron);
//            Serial.print("#######################");
//            Serial.println(" ");
      
          //################################################################################################
          //Testbutton Status an jeweiligen knoten senden
      
          Wire.beginTransmission(Knotenadresse);           // transmit to device actual in for loop
          //anim schreiben
                    
           if (anim==0) {testbut=leddat1[j]; j++;}
                   else {testbut=leddat2[j]; j++;}
           if (j>8){j=0;}
          
          Wire.write(testbut);                             // senden des tasterstatus
          Wire.endTransmission();                          // ende gelände mit uerbertragung
       
          delay(DELAY);
          

    }
   
}

 

With this arrangement, it is now possible to read all Arduinos and their input or to control the LED via the bus. In the next step, a “sensor” is built, a board is laid out and the ArduinoUno reduced to its microcontroller. I’ll talk about that in one of the next posts …

 

 

 

   Sende Artikel als PDF   

Solar – Radiometer

The Radiometer – also called lightmill – is an instructive, physical demonstration object that was invented about 100 years ago by the English physicist Crookes. This small physical-technical arrangement clearly shows how light is converted into mechanical energy.

 

 

The working princip of the solar radiometer:

Impeller inside the part evacuated glass ball

If warm light, ie sunlight, light of light bulbs or spotlights, meets with light in the spectrum of which the infrared component is present (but not cold light from fluorescent lamps) on the wing cross resting on a needle, this will turn depending on the intensity of the light source , In a particular method, a partial vacuum is generated in the glass ball, so that the air resistance is not stronger than the rotational force of the impeller generated by the light energy. The blackened surfaces of the wing cross absorb more light energy than the bright surfaces. Due to the warming of the air molecules, a much higher pressure is created on the dark areas than on the bright areas. This causes the constant rotation of the wing cross. (Brownian Molecular Theory). Depending on the light intensity, up to 3000 revolutions per minute should be achieved. (Source: Manufacturer of the Radiometer)

 

   Sende Artikel als PDF   

Philips “Sonate” Philetta Euro280

Philips Philetta Euro 280 “Sonate”

In the years 1968 to 1970, the radio receiver was built with the inscription “Philetta Euro 280” by Philips. It is a small multi-band receiver with transistor equipment. The type designation 12RB280 / 30 with the inscription “Sonata” seems to be another version of this model. In any case, I have dug up the version “Sonata” – once again from the depths of the Kellergefilde – and after superficial cleaning connected to the mains. Immediately after switching on, the scale illumination lights up and a loud 50 Hz hum can be heard from the loudspeaker. Increasing the volume level adds some noise. So switched to the FM band and searched for a station – and lo and behold, it works. Only the buzzing disturbs. Otherwise, the device works without any major problems. To find the cause of the humming, you begin with the troubleshooting as usual in the power supply.

entfernte Rückwand

The rear panel is quickly removed and the power supply unit, consisting of a, mounted on a support plate transformer including rectifier and filter capacitors removed. Now, without using the oscilloscope and the multimeter, you can immediately see where the ravages of time have left their mark. The two electrolytic capacitors do not look quite healthy anymore.

A quick measurement of the voltages brings certainty. The DC voltages have a decent ripple, which causes the “hum”. So the function of the electrolytic capacitors to smooth the DC voltage is no longer, or poorly, given. A measurement of the capacities confirmed that. So I renewed the capacitors.

Power supply with renewed capacitors

Immediately after switching on, even before I had the probe at the measuring points, a noise was heard without “humming”. The oscilloscope image now showed a clean DC voltage – almost no ripple. The receiver worked again very clean, without disturbing background noise. That was apparently the only mistake.

Technical information:

The main principle of the receiver is a superhet (according to the superposition principle) with an IF of 460/10700 kHz. The waveband of the receiver:

frequency scale

  • long wave
  • medium wave 1 (520-1400kHz)
  • medium wave 2 (1400-1600kHz)
  • shortwave
  • UKW

The output stage has a power of 3W, which is converted into sound energy in a dynamic loudspeaker with permanent magnetic excitation. The case is made of plastic and has the dimensions 43×17.5×10.5cm with a weight of 2.4kg. The receiver is supplied with 220V / 50Hz mains voltage.

 

 

   Sende Artikel als PDF   

Technology toys from the past – made of plastic

This article has nothing to do with electronics. In my retro-madness I was once again rummaging in the cellar of the parents’ house and discovered there behind dusty jars of musty-smelling cardboard boxes with unknown content. So what was left to me to uncover and view the contents of these cardboard boxes? And what came out here were other boxes of the well-known toy manufacturer “LEGO”. Some very dusty original boxes of Lego-Technik models and old washing powder boxes, which were filled with many, many colorful Lego bricks and other stuff and unfortunately also garbage. Actually, I thought to myself, these many plastic parts I can throw in the trash, because that will not play my son safe. Everything smells like cellar and is dirty and the work, everything to clean and sort will certainly no longer hurt anyone. But on the other hand is the really old toy from the 70s and 80s – so over forty years old. And that is exactly mine again. 🙂 Things from my childhood and memories of it.

So packed everything and transported home. And then, in painstaking work, sorted everything once into colors and freed it from rubbish and lego-foreign parts. And now the real work began. The goal should be to put together from the many parts of the old Lego-Technik models and missing parts as far as still available to order. The “vintage kits” should be restored as well as possible in their originality.

Well mixed and not complete Lego boxes

The photo shows a small part of the “excavated” Lego boxes. At least the boxes were already roughly cleaned. What came out after the painstaking sorting and construction work, however, can also be seen again.

 

Nr. 853 Lego Car-Chassis

The number 853 is the car chassis. The kit was sold in the year 1977. It consists of 601 parts and finished construction about 52cm long and 22cm wide.

The model has a four-cylinder in-line engine with two-speed gearbox and cardan shaft to the rigid rear axle. The gearbox as well as the pistons are functional. Likewise, the steering works. The seats are displaceable in the longitudinal axis.

In this series, the rear axle was still rigid and equipped with a differential. The following picture shows the tidy, restored kit.

 

Nr.: 8860 Car Chassis

Out of 671 individual parts, the car is to assemble chassis number 8860. The set dates from the year 1980 and has a size of 46×19 cm. Here was compared to the 853er already much expanded. The rear wheels are hung individually and have a suspension. The engine sits behind and this time is a four-cylinder boxer. Again, there is a transmission with three stages.

The seats are adjustable in the longitudinal direction and the inclination of the seat back can also be adjusted. Again, a rack and pinion steering is installed.

The original packaging is still available and looks like this in the sorted condition:

 

Nr. 854 Lego GoKart

From 1978 comes the Lego GoKart No. 854. It has the dimensions of approximately 21 x 13cm and is composed of 206 parts. On realized functions there is a rack and pinion steering and a single-cylinder engine, with a functional piston. The rear axle is rigid and the shaft is connected via a transmission with the crank of the piston. According to data in the network, this model has now reached cult status, as it should be one of the first Lego-technology models ever. Here is the original packaging and especially the number 9 on the front still available, then the model in collector’s circles should be really valuable. Unfortunately, I can not meet either criterion.

Nr. 856 Lego Bulldozer

 

With the model no. 856, Lego has launched one of the countless construction vehicle models on the market. The bulldozer dates back to 1979 and consists of 370 parts. The base is 24x 11cm at a height of 14cm. Of the functions of the blade is tiltable, raised and lowered. Two chains on gears represent the connection to the bearing surface.

 

Unfortunately, here too, only the box without internal division is available from the original packaging.

 

Nr. 8848 Lego Unimog

The Unimog 8848 from the year 1981 measures just under 30x12cm at a base of 14cm. It consists of 398 parts. As a functioning technology here again the steering, the tilting cargo area, as well as a raised and lowered, and tiltable bucket available.

Unfortunately, the box is missing the interior, otherwise the model is complete. Apart from the here presented, complete kits are still some more available, but where unfortunately too many parts missing. But some flea market or online raid of lego parts will probably arise once again to complete these sets and to be able to fully incorporate them into a retrospective collection.

 

 

   Sende Artikel als PDF   

YouTube, and interesting technology favorites

This time, I’m not going to talk about a project or an “old equipment concept”, but would like to introduce some interesting users or their contributions from the YouTube portal. These are contributions from the field of computer, technology and science, which I personally like to look at.

First and foremost, I would like to mention the legend of modern computer history, which has fascinated me since my youth. The ComputerClub from WDR times with Wolfgang Rudolph and Wolfgang Back. The two moderators moderated the program Computerclub from the beginning of the 80’s to 2003 at Westdeutscher Rundfunk. In the topics, the two men are generally concerned with computers and peripherals, new developments in the field of electronics and present all sorts of things here. Many broadcast recordings are archived on YouTube, including by user janbras.

On 22 February 2003, the last broadcast was broadcast on WDR.

But the two protagonists have not given up the computer club and let him resurrect on July 24, 2007 on a German private broadcaster (NRW-TV).

However, the private broadcaster NRW-TV had to cease its operation in 2016 and so the program was Nr.186 recorded as the last in the studios of NRW.

But Wolfgang Rudolph has managed by fundraising to set up his own studio and now produces the CC2 from his private studio on his own.

In the background, a lot has changed, which confused the viewers and freaks a bit. Parallel to the broadcasts existed the page cczwei.de which was filled by both gentlemen. After 13.12.2016 suddenly a new page appeared. The new domain cc2.tv has been created. The now operates Rudolph alone. The domain cczwei.de continues to be operated by Mr. Back. He is assisted by Heinz Schmitz, who is now producing YouTube broadcasts with Mr. Back. Apparently, there were sufficient reasons for the gentlemen to part with years of community work. There never was an official explanation.

 

From the computer area, the guys from VirtualDimension report. They call their channel VD Hurrican and produce the formats: Virtual Worlds, Back in Time, Retroplay and On Site. The contributions are absolutely professional and mainly deal with home computers. With a lot of background information the old 8 and 16 Bit’er are presented here. Gameplay as well as fair reports and contributions from community events are also part of their repertoire. As an example here a link to the unboxing of an Amiga500 and its history. On the occasion of their 1000th subscriber on YouTube, they have published a 1000-subscriber special with a studio tour.

From the Australian continent, Dave Jones, also an inveterate technician, blogs. On his YouTube channel EEVblog, He also introduces electronic devices, explains their structure and operation. A special category in his channel are the so-called Mailbags. Here, Dave receives packages from people in the community who he opens in front of the camera and presents their content. This can be old computers and boards, or even new developments and prototypes of startups that are presented here.

 

A slightly different channel is that of an Englishman. He calls himself Photonicinduction and shows experiments with high performances. All sorts of appliances, such as vacuum cleaners, heating lamps, washing machines, loudspeakers, etc. are operated to the limit of their maximum performance data – and far beyond. The end of the device through destruction is the goal here.

 

 

   Sende Artikel als PDF   

X-Mas 2016

Merry Christmas to the visitors of the blog!

Now it is already two years, in which I feed the “technology and retro blog” with contributions. Who would have thought that … By now some readers have strayed here and asked if I could introduce one or the other device here. Of course I will try to realize it if possible. Unfortunately, the rubric with the computers of the 80s is still empty. Here I still lack the “thread”, as I should process the whole – it floats me to every device before a small video in which the devices are to be shown in the living state. If someone has ideas for that … like.

I would like to say a big thank you to my colleague Mario Wehr, who provides me with the WordPress environment and thus offers excellent service!

In this sense: Merry Christmas and happy holidays!

 

 

 

   Sende Artikel als PDF   

Retro controller brand new

NES – Nintendo Entertainment System is certainly still a household name. It was the 8-bit game console from Nintendo, which was also sold in Europe in the mid-80s and had influenced the youth of the time. It is now a museum piece that already deserves the title “Retro”. Maybe for this reason, she begins to revive in the Retrogamergemeinde. For example, this year a remake of the NES in miniaturized form with modern technology and pre-installed games on the market.

dsc_2760Also via emulators for all kinds of platforms you can bring the old NES game titles back to life. In order to be able to serve these games “in the right way” (of course, it is also possible with the PC keyboard or via the touch screen on the mobile phone), the company 8Bitdo Tech has launched the NES30 GamePad Controller. It is a wireless bluetooth controller which was modeled on the original NES controller. It is equipped with an integrated rechargeable battery that can be charged via a MicroUSB cable connection. The controller is designed to be configured as a PC game controller, as a joystick, as a Bluetooth keyboard, and as a USB joystick. This can be realized via five different modes. These modes can be selected by keyboard shortcuts during power up. The table below shows the different modes:

  Mode1 Mode2 Mode3 Mode4 Mode5
  Joystick BT-Keyboard iCade Emu-Touch USB-Joystick
Power ON START START+B START+A START+X Kabelverbindung
Blue LEDs are flashing 1x 2x 3x 4x
OS WIN Android WIN/Apple Android Android Apple Android Apple WIN
           

dsc_2759The picture shows the USB charging socket, to the right of which are two status LEDs.

dsc_2816The battery is located on the back of the board

dsc_2817die Platine des Controllers; der die Firmware des Mikrocontrollers kann aktualisiert werden

dsc_2818Contact mats represent the buttons. Under the two shoulder buttons are real micro buttons …

dscn0763Here is the emulator “NES Emu” served on an Android phone with the NES30;)

 

   Sende Artikel als PDF   

WordPress to Word.doc

If you wanted to save your Blogposts from WordPress, you will definitely know the XML export function in the Dashboard of WordPress itself. Here you can create and save an XML file in the menu “Tools” under “Export data” , This XML file can be used in a – for example – server error again to create the blog.

But what to do if you want to save your blog content in a Word file, or as a PDF, or even print? There are several possibilities to realize this. I will briefly list these variants here.

The latter tool I find personally very convenient and convenient, since it is very easy here to export his entire blog, including images in a Word document and postprocessing. All you have to do is export the XML file from wordpress.

converter0
chooese XML-file

After specifying the XML file, the blog posts are displayed directly in a list. Now you can choose which blog post should be converted and whether it should be a Word or PDF document.

 

converter1
window with exportable posts

Now you can start exporting …

converter2Depending on the number of posts and their length, the corresponding document is quickly available and can be edited as needed …

   Sende Artikel als PDF