Rudi

De ORT Robotic Arm van Concorde Robotique in Cardiff werd in 1987 geproduceerd in Engeland. Ik kwam er eentje tegen op Marktplaats voor weinig en kon de verleiding niet weerstaan. De robot arm is in prima staat, de grijper ziet er wat ongeordend uit maar dat lijkt me oplosbaar. Alle andere assen draaien soepel. De robot arm kwam met een 12 V voeding en een 10-aderige flatcable. De aansturing kon nog wel eens een klusje worden. Over Concorde Robotique kan ik helemaal geen informatie vinden.

Deze blauwe robot arm heeft aan de binnenkant een printplaat van Colne Robotics en heeft onder de verflaag een oranjerode kleur. Misschien een grondlaag, maar mogelijk betreft het hier een overgespoten robot arm van het type Armdroid van Colne Robotics. Over Colne Robotics is heel veel informatie op het internet beschikbaar en de Armdroid robot armen van dit bedrijf lijken sprekend op deze blauwe, zij het dat ze oranjerood van kleur zijn.

Het elektrische deel van de robot arm bestaat uit zes uit de kluiten gewassen stappenmotoren, die op een printplaat zijn aangesloten, waarop zo op het eerste gezicht alleen enkele logische IC’s en een paar motordrivers zijn gemonteerd. Er is geen CPU en daarom zal de logische aansturing van buitenaf moeten komen, via de 10-aderige kabel. De printplaat bevat 15 verschillende IC’s, waarvan de meest voorkomende productiedatum week 3 in 1987 is. Hiernaast zijn er nog 5 lege IC-voeten.

Ik lees in het ETI magazine uit 1981, waar deze robot arm voor het eerst werd geïntroduceerd, dat er over de 10-aderige kabel zowel schakelaars kunnen worden ingelezen, als de zes stappenmotoren worden aangestuurd. Nu bevat deze ORT robot arm geen schakelaars, maar voor het bufferen van schakelaars zullen de lege IC-voeten voor zijn. Misschien valt er nog iets uit te breiden.

De aansturing van de stappenmotoren is heel low level: de signalen op de 10-aderige kabel bevatten 3 bits voor de selectie van een stappenmotor, 4 bits die gebruikt worden om de stappenmotor te laten draaien, een enable (of richting) bit en 2 voedingslijnen. Op basis van de beschikbare informatie heb ik de volgende schematische weergave opgesteld.

Om deze robot arm met bijvoorbeeld een Arduino of Raspberry Pi te besturen zal er een vertaling moeten plaatsvinden van één of andere vorm van commando (zoals ‘beweeg pols drie stappen omhoog’ of ‘beweeg pols naar positie x’) naar de low level besturing van de stappenmotoren (‘activeer spoel A en spoel B van motor 1’). Ik denk dat ik de commandostructuur leen van de CS-113, die hiervoor prima documentatie heeft. De Arduino moet dan de vertaling doen. Als ik dat eenmaal aan de praat heb, kan ik de Arduino uitbreiden met een toetsenbord of joystick.

• Richard Morris is een Armdroid van Colne Robotics aan het restaureren
• Technische handleiding van de Colne Robotics Armdroid robot arm
• Constructietekeningen van de Armdroid
• Lab-Volt Armdroid 1000 informatieblad
• Alex Zivanovic heeft een resourcepagina
• Armdroid in september 1981 ETI Magazine (PDF)
• Dan Kohn is met een Armdroid 1000 bezig
• Lab-Volt robot armen doen een balletuitvoering met een balletje (video)
• William gebruikt een Arduino Mega om motors te testen

Het is weer herfst geworden. Een heerlijke tijd van het jaar, met een aantal traditionele evenementen zoals kastanjeszoeken en het controleren van de fietsverlichting. De achterlichten van onze beide kinderen zijn van het handmatige type en hoewel het veel goedkoper niet al te duur is om deze door een kant-en-klare automatische, zelfaanschakelende lamp te vervangen, ging me dat deze keer te ver.

LED fietsachterlichten
Een standaard fietsachterlicht met LED bestaat uit twee penlite-batterijen, een schakelaar, één of meer LED’s met wat weerstanden. De fietseigenaar schakelt de verlichting in met de schakelaar en schakelt deze na gebruik weer uit. Wat ik graag wil, is dat de fietseigenaar de fietsachterlicht wel inschakelt, maar dat dit achterlicht zelf de LED’s aanzet als dat nodig is. En het is pas nodig als er onvoldoende omgevingslicht is, én de fiets in beweging is. Ik heb enkele goedkope LED-fietsachterlichten gekocht. Hierin zitten 2 penlight-batterijen en 3 LED’s met elk een serieweerstand van 390 ohm. De 3 LED’s gebruiken gezamenlijk 70 mA.

Beetje Arduino, beetje Processing, beetje ISP
Uit de vorige jaren heb ik nog wat Arduino-spullen verzameld. Dit is allemaal te groot (en te duur) voor een fietsachterlicht, maar Atmel, de fabrikant van de microcontrollers die ook voor de Arduino’s worden gebruikt, heeft kleine chips op de markt die de ATtiny heten. Deze is er ondermeer in een 8-pins behuizing, met 5 universele I/O pennen, 8K aan flash-programmageheugen en 512 bytes werkgeheugen (de “ATtiny85”). En met een beetje moeite programmeerbaar met een Arduino, die zich voor die gelegenheid als “In Circuit Programmer” gedraagt. In dezelfde Processing taal als voor de Arduino geschikt is. En, belangrijk, de ATtiny85 is voor minder dan een euro te verkrijgen.

Sensoren
Om vast te stellen dat er onvoldoende omgevingslicht beschikbaar is, is een LDR prima geschikt. De ATtiny85 kan de weerstand hiervan inlezen met een analoge ingangspin. Een tiltschakelaar gedraagt zich als een soort bewegingssensor, prima te detecteren met een digitale ingangspin. En de LED’s kunnen, middels een transistor met open collector, met een digitale uitgangspin worden geschakeld (deze digitale pinnen kunnen maximaal 40 mA aansturen, nipt te weinig voor de benodigde 70 mA, vandaar de transistor). Kortom: het hele circuit gaat bestaan uit de volgende onderdelen:

• ATtiny85 als regelneef
• LDR voor het meting van omgevingslicht
• Tiltschakelaar voor het bepalen van beweging
• BC547 transistor voor het aansturen van de LED’s
• Enkele weerstanden
• De bestaande onderdelen: batterijen, schakelaar, LED’s

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

/*
  Bicycle automatic tail light
  Placed in the public domain
  Written by Rudi Niemeijer (10-2012)
 
  Switches an LED based on light conditions
 
                   _______
  RESET ADC0 PB5 x|1  ^  8|x VCC (+)
    PWM ADC3 PB3 x|2     7|x PB2 ADC1 
    PWM ADC2 PB4 x|3     6|x PB1 PWM
         (-) GND x|4_____5|x PB0 PWM
 
*/
 
// Some constant values
int ledPin = 0;  // Digital Output PB0 (also PWM), AtTiny85 pin 5
int ldrPin = 3;  // Analog Input ADC3, AtTiny85 pin 2 
 
int numberOfResamples = 10;  // Light value is average of this many samples
int treshold = 80;  // Light below this value will make the LED go on
int measuredLightValue;  // Contains the actual light measurement from the LDR
int resetCounter;  // It has to be light this many cycles before light switches off
 
void flashLed(int numTimes) {  // Flash the LED numTimes
  for (int i = 0; i < numTimes; i++) {
    digitalWrite(ledPin, HIGH);   // turn the LED on (HIGH is the voltage level)
    delay(200);               // wait for a second
    digitalWrite(ledPin, LOW);    // turn the LED off by making the voltage LOW
    delay(100);               // wait for a second
  }
}
 
int readLdr() {  
  int analogValue;
  analogValue = analogRead(ldrPin);
  return analogValue;
}
 
void burstLed() {
  for (int i = 0; i < 25; i++) {
    digitalWrite(ledPin, HIGH);
    delay(25);
    digitalWrite(ledPin, LOW);
    delay(25);
  }
}
 
void setup() {                
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);
  resetCounter = 10;
  flashLed(3);    
}
 
// the loop routine runs over and over again forever:
void loop() {
  measuredLightValue = 0;
  for (int i = 0; i < numberOfResamples; i++) {
    measuredLightValue = measuredLightValue + readLdr();
  }
  measuredLightValue = measuredLightValue / numberOfResamples;
 
  if (measuredLightValue < treshold) {
    resetCounter = 10;
    digitalWrite(ledPin, HIGH);
  } else {
    resetCounter--;
    if (resetCounter == 0) {
      burstLed();
      digitalWrite(ledPin, LOW);
    }
  }
  delay(500);  // Do nothing for half a second
  // This means it has to be light AT LEAST 10 * 500 ms before light switches on
}

Slotwoord
Het maken van een zelfschakelend achterlicht is ook voor een minder ervaren hobbyist eenvoudig genoeg te doen. Het is niet moeilijk. Maar het kost wat tijd om de ontwikkelstraat op poten te zetten. Als je eenmaal de smaak te pakken hebt om een ATtiny wat willekeurig eenvoudig regelwerk te laten doen, dan zijn de mogelijkheden onbeperkt.

In het schema heb ik ervoor gekozen om geen basisweerstand bij de transistor te gebruiken. Dat is niet zoals het hoort: de basisweerstand beperkt de collectorstroom door de transistor. Zonder basisweerstand wordt de stroom echter beperkt door de weerstanden R1..R3, waardoor er geen ongewenste situaties kunnen ontstaan.

In het schema is ook een tiltschakelaar te zien, die ik niet in de praktische schakeling en evenmin in de software heb toegepast. Het idee hiervan is, om gebruik te maken van de wetenschap dat een fiets in beweging is. Dat zou helpen om een fietslicht aan te laten bij (tijdelijk) lichte omstandigheden. Geen gebruik van gemaakt.

Het achterlicht doet het ondertussen.

• AtTiny datablad
• Pete maakt een kaars met een AtTiny85
• Arduino print als AtTiny programmer (vergeet de elco niet)
• ATtiny85 vanaf 62 eurocent per stuk
• Goedkope versnellingssensor zelf maken
• 3-assige trilsensor
• Goedkope achterlichten, met of zonder automaat (zucht..)
• Elektronica schema’s en printplaten maken met Fritzing
• ATtiny en ATmega programmer shield op eBay

De afgelopen 50 jaar hebben toegezien op verschillende parallelle ontwikkelingen in computer architectuur, chipfabricatie en massaproductie, met de microprocessor als tekenend resultaat. Deze microprocessor werd voor het eerst in 1971 een commercieel succes door de introductie van de 4-bit 4004 van een toen nog klein en onbekend bedrijfje genaamd Intel. Veel bedrijven volgden Intel’s voorbeeld en tegen het eind van de jaren ’70 kon je uit een half dozijn microprocessoren kiezen. In die jaren explodeerde het aantal computergebruikers van een handvol ondernemende hobbyisten en technisch onderlegde ‘hackers’ naar miljoenen zakelijke, industriële, ambtelijke, educatieve en enthousiaste thuisgebruikers, die allemaal de beschikbaarheid hadden over relatief betaalbare computeroplossingen.

Gelijktijdig aan de microprocessor, gebruikmakend van dezelfde ontwikkelingen, ontstond het concept microcontroller, met hierbij de TMS1000 van Texas Instruments als lichtend voorbeeld. Microcontrollers zijn voor het grote publiek minder als eindproduct bekend dan de veel vaker genoemde microprocessoren, hoewel termen als ‘Arduino‘ en ‘ESP32’ ook bij de gemiddelde consument bekend beginnen te raken. Het grote publiek is zich echter wel bewust van het feit dat ‘iets’ verantwoordelijk is voor de slimmigheid in huishoudelijke apparaten zoals broodroosters, koffiemachines, televisies, ovens, wasmachines, koelkasten, elektrische tandenborstels en ontelbare andere ‘gadgets’.

Een microcontroller bestaat intern uit een microprocessor, werkgeheugen, programmaopslaggeheugen en I/O voorzieningen. Dit maakt een microcontroller in veel opzichten een regelcomputer-in-een-chip, waarbij er slechts een externe voedingsspanning nodig is om een programma uit te voeren. De eerste microcontroller was de voornoemde TMS1000 van Texas Instruments (1974), gevolgd door de 8048 van Intel (1977). Een opvolger van de 8048 was de 8051 (1980), met als speciale uitvoering de hier beschreven 8052AH-BASIC (1986).

Het grootste verschil tussen microprocessoren en microcontrollers is gelegen in hun toepassingsgebieden: waar de microprocessor bedoeld is voor generieke toepassingen met veel aanvullende onderdelen zoals geheugen, invoer en uitvoer, video, audio en opslag is de microcontroller bedoeld voor besturingstoepassingen met minimale externe componenten. Zo heeft een microprocessor over het algemeen geen intern werk- of opslaggeheugen, terwijl een microcontroller dat wel heeft. Een microcontroller heeft meer bitvergelijkingsinstructies en vaak een beperktere instructieset, die ook nog eens vooral op verwerkingssnelheid is ingericht. Ook de mogelijkheden om met andere chips en direct met digitale en analoge elektronica te communiceren is bij een microcontroller vaak meer uitgemeten dan bij een microprocessor.

De MCS-51 is een familie van microcontroller IC’s, ontwikkeld, geproduceerd en op de markt gebracht door Intel, gebaseerd op hun archetype 8051. Andere IC-fabrikanten zoals Siemens, Advanced Micro Devices (AMD), Fujitsu en Philips zijn door Intel gelicenseerde fabrikanten van deze microcontrollers. De microcontrollers uit de MCS-51 familie zijn geoptimaliseerd voor besturingstoepassingen met in de instructieset een verscheidenheid aan adresseringsmodi, handige 8-bits rekenkundige instructies, ínclusief instructies voor vermenigvuldigen en delen en ondersteuning voor één-bit variabelen met bijbehorende bitmanipulatiemogelijkheden.

In de tabel zijn enkele van de MCS-51 microcontrollers weergegeven met hierbij aangegeven de hoeveelheid interne geheugen. Het interne gebeugen ligt in hetzelfde adresbereik als het externe geheugen, wat de uitwisselbaarheid van de microcontrollers vergroot.

Zoals in de tabel weergegeven is de 8052AH een microcontroller met 8K interne ROM en 256 bytes RAM geheugen. De interne ROM wordt bij het maken van de chip al geprogrammeerd. Een speciale variant van de 8052AH, de 8052AH-BASIC, heeft een af-fabriek in het ROM ondergebrachte drijvendekomma-BASIC genaamd MCS-BASIC, een terminalserver en een EPROM programmeercircuit voor de opslag van programma’s. Intel bracht deze speciale 40-pins microcontroller in 1986 op de markt.

De 8052AH-BASIC was bij de introductie in 1986 om verschillende redenen bijzonder: het bevatte een eenvoudige terminalserver met een ingebouwde editor, zodat programma’s met een seriële terminal of terminalemulatieprogramma beheerd konden worden. Ook de ingebouwde MCS-51 BASIC maakte deze microcontroller speciaal. Nog niet eerder was er een besturingschip met een ingebouwde hogere programmeertaal beschikbaar geweest.

Elektuur kwam met het november 1987 nummer met het ontwerp van een microcontrollerboard gebaseerd op de 8052AH-BASIC, ongeveer rondom de tijd waarin ik zelf ook voor mijn studie met deze microcontroller bezig was. Het ontwerp was opgebouwd rondom een 8052AH-BASIC V1.1, twee 6264 RAM’s, een 2764 of 27128 EEPROM, wat bus logica, een programmeerspanning-beveiliging, RS232 niveau-aanpassing en een reset-schakelaar.

De opgebouwde microcontroller was een dubbelzijdige, doorgemetaliseerde printplaat met afmetingen van 10×15 centimeter. Twee connectoren maakten I/O en busuitbreidingen mogelijk. Op de printplaat zaten, buiten de 8052AH-BASIC micocontroller, twee RAM-chips, een EPROM-voet en enkele logicachips. De seriële ansluiting voor een terminal of computer met terminalsoftware bestond uit een 5-polige DIN-aansluiting, in die tijd bekend als audioconnector waarmee audioapparaten onderling konden worden verbonden. De toepassing hiervan was niet standaard (een 9-polige D-connector was hier toepasselijker geweest), zodat er een kabel op maat gemaakt moest worden. Twee leds en een schakelaar maakten het geheel af. De printplaat was voorzien van montagegaten zodat het eenvoudig in een behuizing kon worden ingebouwd, een en ander overgelaten aan de creatieve vaardigheden van de constructeur.

Na het aansluiten van een geschikte terminal aan de 5-pins DIN-aansluiting en het inschakelen van de voeding start de ingebouwde BASIC programmeertaal en editor op, wordt een prompt via de seriële poort naar een aangesloten terminal verzonden en kan een programma worden ingetoetst:

*MCS-51(tm) BASIC V1.1*
READY
>10 FOR I=1 TO 3
>20 PRINT I
>30 NEXT I
>RUN
1
2
3
READY
>

Op de prompt kunnen enkele commando’s worden gegeven: RUN, LIST, NEW, NULL, RAM, ROM, XFER, PROG, BAUD, CALL en variaties hierop. Met LIST (of LIST met een regelbereik) wordt het programma (of een deel hiervan) naar de terminal teruggegeven. Een regel wordt gecorrigeerd door deze opnieuw in te voeren.

De geplaatste EPROM kan vanuit de controller worden geprogrammeerd met het commando PROG en programma’s kunnen eenvoudig vanuit de EPROM worden opgestart met het commando ROM:

>LIST
10 FOR I=1 TO 3
20 PRINT I
30 NEXT I
READY 
>PROG
12
READY
>NEW
READY
>LIST
READY
>ROM 12
READY
>LIST
10 FOR I=1 TO 3
20 PRINT I
30 NEXT I
READY
>

De EPROM technologie wordt tegenwoordig niet meer toegepast, omdat hiervoor EEPROM (of ‘flash’) voor in de plaats is gekomen: elektrisch wisbare EPROM’s. Maar de EPROM’s uit de tijd van de 8052AH-BASIC konden alleen met ultraviolet licht (vandaar het doorzichtig venster) worden gewist. Een programmeur in die tijd had altijd de beschikking over een wisapparaatje: een doosje met een UV lamp, waar de EPROM in werd geplaatst en een paar minuten belicht.

De Parallax BASIC Stamp is een goede opvolger van het Elektuur board, hoewel deze ondertussen aardig in de vergetelijkheid is geraakt. Ook een moderne(re) Espressif ESP32 microcontroller heeft een interne BASIC interpreter, een leuke buiging naar de Intel 8052AH-BASIC microcontroller.

Handleidingen, artikelen en projecten met MCS-51 microcontrollers

• Intel’s MCS BASIC-52 Operating and Reference Manual (Archive.org)
• Intel’s MCS BASIC-52 User’s Manual (Archive.org)
• The Microcontroller Idea Book: Circuits, Programs, & Applications featuring the 8052-BASIC Microcontroller (Jan Axelson, Archive.org), ook beschikbaar als gratis toegankelijke PDF
• 8052-BASIC-compuboard (Elektuur november 1987, Archive.org)
• BASIC-compuboard in CMOS (Elektuur januari 1990, Archive.org)
• 8032-mini-board (Elektuur april 1991, Archive.org)
• A Tiny 80(C)32 BASIC Board van Ronald Dekker
• 8052AH-BASIC
• Wouter’s 8052 BASIC Single Board Computer
• 8052 Single Board Computer
• Hein Pragt’s Intel 8052AH Basic computer
• Madis Kaal’s My very first first 8052 BASIC Project
• 8052AH-BASIC single-board computer (Hackaday)
• Intel 8052AH revisited part 1 – a little system archaeology (Alysson Rowan, met mijn 8052AH-BASIC board!)
• Paul’s 8051 Tools, Projects and Free Code
• 8051-projects (GitHub)
• 8051 Projects and Tools
• Turbo Pascal for 8051 microcontrollers