Automaattinen sähkötysavain

Radioamatööri – lehden lokakuun numerossa on artikkelini Arduinolla toteutetusta automaattisesta sähkötysavaimesta. Artikkelissa käsitellään ainoastaan muutamia ohjelmatoteutuksen kohtia, sillä ohjelma olisi ollut turhan pitkä lehtiartikkeliin. Tässä on viimeisin ohjelmaversio. Tämä on vapaasti käytettävissa ja halutessa myös muutettavissa. Rivit 63, 64 ja 65 (sijaisevat asetusosassa) on joka tapauksessa muutettava vastaamaan kunkin radioamatöörin tarpeita. (Noissa on vakiolauseet esim. yleiskutsua, nimeä ja lopetusta varten.)

 

/* Nimi: CW_Test_16v21

Luotu: 11.2.2016

Luoja: Antti Isännäinen

KUVAUS:

Automaattiavain amatöörikäyttöön. Viiva vasemmalle, piste oikealle.

Lisäksi painikkeilla voi valita kolme valmista sanomaa esim: yleiskutsu,

nimi ja QTH sekä yhteyden lopetus kiitoksineen.

Nämä ovat vapaasti valittavissa, mutta ainoastaan ohjelmointivaiheessa

kirjoitettavissa selvätekstinä ja ladatavissa ohjelman käännöksen ja

latauksen yhteydessä. Ääkköset olen jättänyt pois, koska niillä ei ole

yhden merkin ASCII-koodia. Nekin on saatavissa sähkötysmerkeiksi, mutta

tekstissä toisilla merkeillä.

Sähkötysnopeus on säädettävissä potentiometrillä. Samoin suuriohmisille

kuulokkeille tarkoitettu myötäkuuntelun voimakkuus.

Kuunteluäänen korkeus on vakio, mutta määriteltävissä ohjelmointivaiheessa.

Versiossa 10 ensimmäistä kertaa oikea avain käytössä.

Espoossa 5.2.2016

Versio 20 käsittää lopullisen hardiksen, eli itetaidetta

Tyydyttävä toiminta versiolla 20.

Huomioi, ettei lähetyksen nopeuitta voi muuttaa kesken sanoman,

ainoastaan sanomien välillä. Käsin sähkötettäessä nopeutta voi muuttaa

merkkien välillä.

Espoossa 11.2.2016

Versiossa 21 muutetaan tauko hiukan pistettä lyhemmäksi, koska

se netin mukaan on elegantimpaa.

*/

// MÄÄRITTELYT:

int Int_Taajuus = 750; // Myötäkuuntelun taajuus

int Int_Nopeus = 0;

int Int_Piste = 0; // Pisteen kesto viiva/3

int Int_Vali = 0; // Merkkiväli Hiukan lyhempi kuin piste

// int Int_SanaVali = 3*Int_Nopeus;

int Seq_Sanoma = 0;

int p = 3; // piste

int v = 1; // viiva

int i = 0;

int j = 0;

int k = 0;

// Yksittäisten merkkien taulukot; ensin merkin pituus, sitten merkit

int A[] ={2,p,v,0,0,0};int B[] ={4,v,p,p,p,0};int C[] ={4,v,p,v,p,0};

int D[] ={3,v,p,p,0,0};int E[] ={1,p,0,0,0,0};int F[] ={4,p,p,v,p,0};

int G[] ={3,v,v,p,0,0};int H[] ={4,p,p,p,p,0};int I[] ={2,p,p,0,0,0};

int J[] ={4,p,v,v,v,0};int K[] ={3,v,p,v,0,0};int L[] ={4,p,v,p,p,0};

int M[] ={2,v,v,0,0,0};int N[] ={2,v,p,0,0,0};int O[] ={3,v,v,v,0,0};

int P[] ={4,p,v,v,p,0};int Q[] ={4,v,v,p,v,0};int R[] ={3,p,v,p,0,0};

int S[] ={3,p,p,p,0,0};int T[] ={1,v,0,0,0,0};int U[] ={3,p,p,v,0,0};

int V[] ={4,p,p,p,v,0};int W[] ={3,p,v,v,0,0};int X[] ={4,v,p,p,v,0};

int Y[] ={4,v,p,v,v,0};int Z[] ={4,v,v,p,p,0}; // 90 ASCII

int nol[] ={5,v,v,v,v,v}; int yks[] ={5,p,v,v,v,v}; int kak[] ={5,p,p,v,v,v};

int kol[] ={5,p,p,p,v,v}; int nel[] ={5,p,p,p,p,v}; int vii[] ={5,p,p,p,p,p};

int kuu[] ={5,v,p,p,p,p}; int sei[] ={5,v,v,p,p,p}; int kah[] ={5,v,v,v,p,p};

int yhd[] ={5,v,v,v,v,p};

int Arr_Merkki[6]; int Arr_ABC[36][6]; // Merkin ja merkkien välitaulukot

char Arr_Lause1[] = {"CQ CQ DE OH2WJ OH3YD OH6KVE PSE K "};

char Arr_Lause2[] = {"MY NAME ANTTI ANTTI ES QTH ESPOO QTH ESPOO "};

char Arr_Lause3[] = {"TNX FER QSO 73 73 GL ES CUAGN "};

int Int_Pituus1 = 0; int Int_Pituus2 = 0; int Int_Pituus3 = 0;

int Int_Merkki = 0; int Int_AsciiEro = 0;

// Liitynnät

const int Con_Key = 3;

const int Con_LED = 4;

const int Con_Aani = 5;

const int Con_Txt1 = 6; boolean Bol_Txt1 = false;

const int Con_LedPois = 7; boolean Bol_LedPois = false;

const int Con_Txt2 = 8; boolean Bol_Txt2 = false;

const int Con_RelePois = 9; boolean Bol_RelePois = false;

const int Con_Txt3 = 10; boolean Bol_Txt3 = false;

const int Con_Viiva = 11; boolean Bol_Viiva = false;

const int Con_Piste = 12; boolean Bol_Piste = false;

const int Con_AnaTulo = 0; int Int_AnaTulo = 0;

// ASETUKSET:

void setup(){ // Alustetaan muuttujat sekä määritellään I/O-tyyppi

Serial.begin(9600); // Alustetaan sarjaliikennne testiä varten

//while (!Serial) { ; } // Odottaa sarjaportin kytkeytymistä

pinMode(Con_Key, OUTPUT);

pinMode(Con_LED, OUTPUT);

pinMode(Con_Txt1, INPUT);

pinMode(Con_Txt2, INPUT);

pinMode(Con_Txt3, INPUT);

pinMode(Con_Viiva, INPUT);

pinMode(Con_Piste, INPUT);

pinMode(Con_LedPois, INPUT);

pinMode(Con_RelePois, INPUT);

// Ladataan kaksiulotteinen merkkitaulukko. Tarvitsee tehdä vain käynnistettäessä

for(i = 0; i < 6; i++){Arr_ABC[0][i] = A[i];} for(i = 0; i < 6; i++){Arr_ABC[1][i] = B[i];}

for(i = 0; i < 6; i++){Arr_ABC[2][i] = C[i];} for(i = 0; i < 6; i++){Arr_ABC[3][i] = D[i];}

for(i = 0; i < 6; i++){Arr_ABC[4][i] = E[i];} for(i = 0; i < 6; i++){Arr_ABC[5][i] = F[i];}

for(i = 0; i < 6; i++){Arr_ABC[6][i] = G[i];} for(i = 0; i < 6; i++){Arr_ABC[7][i] = H[i];}

for(i = 0; i < 6; i++){Arr_ABC[8][i] = I[i];} for(i = 0; i < 6; i++){Arr_ABC[9][i] = J[i];}

for(i = 0; i < 6; i++){Arr_ABC[10][i] = K[i];} for(i = 0; i < 6; i++){Arr_ABC[11][i] = L[i];}

for(i = 0; i < 6; i++){Arr_ABC[12][i] = M[i];} for(i = 0; i < 6; i++){Arr_ABC[13][i] = N[i];}

for(i = 0; i < 6; i++){Arr_ABC[14][i] = O[i];} for(i = 0; i < 6; i++){Arr_ABC[15][i] = P[i];}

for(i = 0; i < 6; i++){Arr_ABC[16][i] = Q[i];} for(i = 0; i < 6; i++){Arr_ABC[17][i] = R[i];}

for(i = 0; i < 6; i++){Arr_ABC[18][i] = S[i];} for(i = 0; i < 6; i++){Arr_ABC[19][i] = T[i];}

for(i = 0; i < 6; i++){Arr_ABC[20][i] = U[i];} for(i = 0; i < 6; i++){Arr_ABC[21][i] = V[i];}

for(i = 0; i < 6; i++){Arr_ABC[22][i] = W[i];} for(i = 0; i < 6; i++){Arr_ABC[23][i] = X[i];}

for(i = 0; i < 6; i++){Arr_ABC[24][i] = Y[i];} for(i = 0; i < 6; i++){Arr_ABC[25][i] = Z[i];}

for(i = 0; i < 6; i++){Arr_ABC[26][i] = nol[i];} for(i = 0; i < 6; i++){Arr_ABC[27][i] = yks[i];}

for(i = 0; i < 6; i++){Arr_ABC[28][i] = kak[i];} for(i = 0; i < 6; i++){Arr_ABC[29][i] = kol[i];}

for(i = 0; i < 6; i++){Arr_ABC[30][i] = nel[i];} for(i = 0; i < 6; i++){Arr_ABC[31][i] = vii[i];}

for(i = 0; i < 6; i++){Arr_ABC[32][i] = kuu[i];} for(i = 0; i < 6; i++){Arr_ABC[33][i] = sei[i];}

for(i = 0; i < 6; i++){Arr_ABC[34][i] = kah[i];} for(i = 0; i < 6; i++){Arr_ABC[35][i] = yhd[i];}

}// Asetuksen loppu

// PÄÄLOOPPI

void loop(){

// Tekstipainikkeiden luku

Bol_Txt1 = digitalRead(Con_Txt1);

Bol_Txt2 = digitalRead(Con_Txt2);

Bol_Txt3 = digitalRead(Con_Txt3);

Bol_Viiva = digitalRead(Con_Viiva);

Bol_Piste = digitalRead(Con_Piste);

// Nopeustiedon luku ja nopeuden käsittely

Int_AnaTulo = analogRead(Con_AnaTulo);

Int_Nopeus = map(Int_AnaTulo, 0, 1023, 100, 600);

//Serial.println(Int_Nopeus);

Int_Piste = Int_Nopeus / 3;

Int_Vali = Int_Piste * 8 / 10;

// Viivan lähetys avaimella

if(Bol_Viiva == true){

tone(Con_Aani, Int_Taajuus);

Bol_LedPois = digitalRead(Con_LedPois);

if(Bol_LedPois == false){ digitalWrite(Con_LED, HIGH);}

Bol_RelePois = digitalRead(Con_RelePois);

if(Bol_RelePois == false){digitalWrite(Con_Key, HIGH);}

delay(Int_Nopeus);

noTone(Con_Aani);

digitalWrite(Con_LED, LOW);

digitalWrite(Con_Key, LOW);

delay(Int_Vali); // merkkiväli

}// Viivan loppu

// Pisteen lähetys avaimella

if(Bol_Piste == true){

tone(Con_Aani, Int_Taajuus);

Bol_LedPois = digitalRead(Con_LedPois);

if(Bol_LedPois == false){ digitalWrite(Con_LED, HIGH);}

Bol_RelePois = digitalRead(Con_RelePois);

if(Bol_RelePois == false){digitalWrite(Con_Key, HIGH);}

delay(Int_Piste);

noTone(Con_Aani);

digitalWrite(Con_LED, LOW);

digitalWrite(Con_Key, LOW);

delay(Int_Vali); // merkkiväli

}// Pisteen loppu

// Sanomapainikkeiden runnistus

if(Bol_Txt1 == true){ Seq_Sanoma = 1;}

if(Bol_Txt2 == true){ Seq_Sanoma = 2;}

if(Bol_Txt3 == true){ Seq_Sanoma = 3;}

// Tekstin valinta

switch (Seq_Sanoma) {

case 1: // Ensimmäinen sanoma

for(k = 0; k < sizeof(Arr_Lause1)-1; k++){

Int_Merkki = Arr_Lause1[k];

if(Int_Merkki == 32){delay(Int_Nopeus * 2); // Tunnistetaan sanaväli (SPACE)

}else if(Int_Merkki < 65){Int_AsciiEro = 22;// Tunistetaan numero

Fun_Merkki(Int_Merkki - Int_AsciiEro);

}else {

Int_AsciiEro = 65; // Loput ovat kirjaimia

Fun_Merkki(Int_Merkki - Int_AsciiEro);}}

Seq_Sanoma = 4;

break;

case 2: // Toinen sanoma

for(k = 0; k < sizeof(Arr_Lause2)-1; k++){

Int_Merkki = Arr_Lause2[k];

if(Int_Merkki == 32){delay(Int_Nopeus * 2); // Tunnistetaan sanaväli (SPACE)

}else if(Int_Merkki < 65){Int_AsciiEro = 22;// Tunistetaan numero

Fun_Merkki(Int_Merkki - Int_AsciiEro);

}else {

Int_AsciiEro = 65; // Loput ovat kirjaimia

Fun_Merkki(Int_Merkki - Int_AsciiEro);}}

Seq_Sanoma = 4;

break;

case 3: // Kolmas sanoma

for(k = 0; k < sizeof(Arr_Lause3)-1; k++){

Int_Merkki = Arr_Lause3[k];

if(Int_Merkki == 32){delay(Int_Nopeus * 2); // Tunnistetaan sanaväli (SPACE)

}else if(Int_Merkki < 65){Int_AsciiEro = 22;// Tunistetaan numero

Fun_Merkki(Int_Merkki - Int_AsciiEro);

}else{

Int_AsciiEro = 65; // Loput ovat kirjaimia

Fun_Merkki(Int_Merkki - Int_AsciiEro);}}

Seq_Sanoma = 4;

break;

case 4: // Sanoman lähetyksen lopetus

Seq_Sanoma = 0;

break;

}

delay(1); // IO-stabilointia varten tämä lyhyt tauko

} // Pääohjelma LOPPU

// Merkkien muuntaminen sähkötykseksi

void Fun_Merkki(int x){

int Purku[6];

for(int i = 0; i < 6; i++){Purku[i] = Arr_ABC[x][i];}

for(int i = 0; i < Purku[0]; i++){

tone(Con_Aani, Int_Taajuus);

Bol_LedPois = digitalRead(Con_LedPois);

if(Bol_LedPois == false){ digitalWrite(Con_LED, HIGH);}

Bol_RelePois = digitalRead(Con_RelePois);

if(Bol_RelePois == false){digitalWrite(Con_Key, HIGH);}

delay(Int_Nopeus/Purku[i+1]);

noTone(Con_Aani);

digitalWrite(Con_LED, LOW);

digitalWrite(Con_Key, LOW);

delay(Int_Vali); // merkkiväli

}

delay(Int_Nopeus - Int_Nopeus/10*4); // Kirjainväli

}// Merkki-funktion loppu

”Arpakuutio”

Pyrkimykseni on tällä kerralla valottaa sattumalukukäskyn random(min, max) ja siihen liittyvän randomSeed(parametri) käyttöä sekä sarjana sisään ja rinnan ulos –piirin (74HC595) käyttöä 7-segmenttinäyttöelementin ohjauksessa. Tässä näyttömoduulissa on kahdeksan (8) LEDiä, joista seitsemällä muodostetaan luku 0 .. 9 ja näiden lisäksi piste. Näitä näyttöjä on saatavissa erilaisia ja erikokoisia. Eri tyypit poikkeavat myös kytkennältään. Tässä olen käyttänyt tyyppiä MAN4640A. Ohjaimen ja näyttöpiirin LEDien välissä on vastuspiiri, missä on 8 kpl 330 ohmin vastuksia. Jos tarvitaan useamman numeron näyttöjä, voidaan näitä piirejä kytkeä sarjaan. Arduinosta tarvitaan silti vain kolme lähtöpinniä.

Tällä piirilevyllä on myös sellaisia komponentteja (toinen painike ja kaksivärinen LED), joita en käytä tässä sovelluksessa. Niiden on tarkoitus tulla mukaan seuraavan kerran blogissa. Sähköiset kytkennät näkyvät oheisista kuvista. Tuon Vero-levy-hahmotelman mukaan ei kannata lähteä sellaisenaan kytkemään, sillä se kuuluu enemminkin osastoon: ”etsi viisi virhettä!” On siitä kyllä hyötyäkin, sillä on se enimmäkseen oikein. Paint-ohjelma on vain melko alkeellinen, joten myöhemmät korjaukset sillä on varsin hankalia.

 Asetuksessa olevalla käskyllä randomSeed(analogRead(5)); alustetaan sattumageneraattori. Parametrinä voi olla myös kiinteä luku, jolloin ”sattumasarja” on aina sama numerojono. Tätä voi käyttää testeissä, mutta muuten se ei ole mielekästä. Ohjekirja suosittelee parametriksi jotain vapaana olevaan pinniä. Tässä olen käyttänyt analogiatuloa 5. Vapaassa tulossa ilmenee kohinaa, jolloin lähtöluku on sattumanvarainen ja saatu lukusarja todella perustuu sattumaan. Varsinainen sattumakäsky random(min, max) suorittaa arpomisen. Min on lukualueen minimi ja max on suurin arvottava luku lisättynä yhdellä (1). Siksi tässä on rajana luku seitsemän (7), jolloin saadaan aikaan noppien lukualue. Sattumalukukäskyn arpoma luku voi olla hyvin suuri. Siksi muuttujan tulee olla tyyppiä long.

Käynnistyessään ohjelma alkaa pyörittää myötäpäivään kutakin segmentin (A..F, G poisluettuna) LEDiä peräjälkeen. Pistettä ei polteta lainkaan. Siksi LEDien talukossa oikean puoleisin bitti on nolla (0). Bitit ovat käänteisessä järjestyksessä, koska ensimmäinen taulukon bitti Arr_DataA[0] menee sarjasyötössä ensimmäisenä ja bitti 7 viimeisenä (8 bittiä, taulukon bitit 0 .. 7). Tällöin bitti 7 siirtyy viimeisenä muunnospiiriin ja siirtyy pistettä vastaavaan kohtaan Q0. Vastaava taulukkoluettelo on numeroista.

Kun ohjelma käynnistyy, käynnistyy pyörityssekvenssi, ja kun vasenta painiketta painetaan, pysähtyy pyöritys ja ohjelma hyppää arpomista vastaavaan numerosekvenssin askeleeseen. Kun painike päästetään, pysähtyy numerosekvenssi ja pyörityssekvenssi käynnistyy jälleen. Video antinarduvideo22. youtube.com havainnollistaa tapahtumaa parhaiten. Sekvenssiaskeleissa ladataan kukin taulukon bittijono ensin talukkoon Arr_Data[8], mikä välitetään aliohjelmalle varsinaista näyttöön tulostusta varten.

Pyörityssekvenssin viive käsitellään aliohjelmassa int Fun_Viive(int Viive){, mikä on nyt tyyppiä int (eikä void), koska se palauttaa (return) kokonaisluvun. Sinne välitetään kutsussa viiveen hetkelline arvo, sitä kasvatetaan aliohjelmassa ja palautetaan uusi arvo pääohjelmaan. Pääohjelmassa tutkitaan, onko raja-arvo ylitetty, ja jos on, niin hypätään seuraavaan asekeleeseen.

Ohjelma 22

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

 *  Ohjelma 22

 *  08.06.2016

 *  Noppa

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

// MÄÄRITTELYT:

const int Con_PainVas = 2;

boolean Bol_PainVas = false;

int Seq_PainVas = 1;

const int Con_PainVasVii = 5;

int Int_PainVasVii = 0;

const int Con_DS_Data = 6;        // Sarjadatan syöttö

const int Con_SHCP_Kello = 7;     // Sarjadatan kellotus

const int Con_STCP_Siirto = 8;    // Syöttö rinnanlähtöön

//Sekvenssin pyöritys

int Seq_Pyoritus = 1;

const int Con_PyorViive = 47;

int Int_PyorViive = 0;

// Numerosekvenssi

int Seq_Arpa = 0; // Näyttösekvenssiä ei käynnistetä alustuksessa

long Lng_Arpa = 0;

boolean Arr_Data[8] = {0,0,0,0,0,0,0,0};

// Näytön LEDit pyörityksessä

boolean Arr_DataA[8] = {0,0,0,0,0,0,1,0};

boolean Arr_DataB[8] = {0,0,0,0,0,1,0,0};

boolean Arr_DataC[8] = {0,0,0,0,1,0,0,0};

boolean Arr_DataD[8] = {0,0,0,1,0,0,0,0};

boolean Arr_DataE[8] = {0,0,1,0,0,0,0,0};

boolean Arr_DataF[8] = {1,0,0,0,0,0,0,0};

// Numerot 1 .. 6

boolean Arr_Data1[8] = {0,0,0,0,1,1,0,0};

boolean Arr_Data2[8] = {0,1,1,1,0,1,1,0};

boolean Arr_Data3[8] = {0,1,0,1,1,1,1,0};

boolean Arr_Data4[8] = {1,1,0,0,1,1,0,0};

boolean Arr_Data5[8] = {1,1,0,1,1,0,1,0};

boolean Arr_Data6[8] = {1,1,1,1,1,0,1,0};

// ASETUKSET:

void setup(){                 

 Serial.begin(9600);         

 pinMode(Con_PainVas, INPUT);

 pinMode(Con_DS_Data, OUTPUT);

 pinMode(Con_SHCP_Kello, OUTPUT);

 pinMode(Con_STCP_Siirto, OUTPUT);

 randomSeed(analogRead(5)); // Sattumageneraattorin alustus

}// Asetuksen loppu

// PÄÄLOOPPI 

void loop(){

Lng_Arpa = random(1,7);

Bol_PainVas = digitalRead(Con_PainVas);

// KOSKETTIMEN-tilan käsittely

switch (Seq_PainVas) {

  case 1:

    if (Bol_PainVas == true){

      Int_PainVasVii ++;

        if (Int_PainVasVii > Con_PainVasVii){

          Seq_Pyoritus = 0; // Pysäytetään pyöritys

          Seq_Arpa = Lng_Arpa; // Valitaan näytettävä numero

          Fun_Tyhjenna(); // Tyhjennetään näyttö

          Int_PainVasVii = 0;

          Seq_PainVas = 2;

        }

    }

    break;

  case 2:

    if (Bol_PainVas == false){

          Seq_Arpa = 0; // Pysäytettän numeronäyttö

          Seq_Pyoritus = 1; // Käynnistettän pyöritys

          Seq_PainVas = 1;

    }

    break;

}// Vasen painike loppu

// Pyörityksen sekvenssi

switch (Seq_Pyoritus) {

  case 1:

   for(int i = 0; i < 8; i++){

    Arr_Data[i] = Arr_DataA[i];}

      Fun_Naytto();

      Int_PyorViive = Fun_Viive(Int_PyorViive);

      if (Int_PyorViive > Con_PyorViive){

        Int_PyorViive = 0;

        Seq_Pyoritus = 2;

      }

    break;

  case 2:

   for(int i = 0; i < 8; i++){

    Arr_Data[i] = Arr_DataB[i];}

      Fun_Naytto();

      Int_PyorViive = Fun_Viive(Int_PyorViive);

      if (Int_PyorViive > Con_PyorViive){

        Int_PyorViive = 0;

        Seq_Pyoritus = 3;

      }

    break;

  case 3:

   for(int i = 0; i < 8; i++){

    Arr_Data[i] = Arr_DataC[i];}

      Fun_Naytto();

      Int_PyorViive = Fun_Viive(Int_PyorViive);

      if (Int_PyorViive > Con_PyorViive){

        Int_PyorViive = 0;

        Seq_Pyoritus = 4;

      }

    break;

  case 4:

   for(int i = 0; i < 8; i++){

    Arr_Data[i] = Arr_DataD[i];}

      Fun_Naytto();

      Int_PyorViive = Fun_Viive(Int_PyorViive);

      if (Int_PyorViive > Con_PyorViive){

        Int_PyorViive = 0;

        Seq_Pyoritus = 5;

      }

    break;

  case 5:

   for(int i = 0; i < 8; i++){

    Arr_Data[i] = Arr_DataE[i];}

      Fun_Naytto();

      Int_PyorViive = Fun_Viive(Int_PyorViive);

      if (Int_PyorViive > Con_PyorViive){

        Int_PyorViive = 0;

        Seq_Pyoritus = 6;

      }

    break;

  case 6:

   for(int i = 0; i < 8; i++){

    Arr_Data[i] = Arr_DataF[i];}

      Fun_Naytto();

      Int_PyorViive = Fun_Viive(Int_PyorViive);

      if (Int_PyorViive > Con_PyorViive){

        Int_PyorViive = 0;

        Seq_Pyoritus = 1;

      }

    break;

}// Pyörityksen loppu

// Arvotun numeron sekvenssi

switch (Seq_Arpa) {

  case 1:

   for(int i = 0; i < 8; i++){

    Arr_Data[i] = Arr_Data1[i];}

      Fun_Naytto();

      break;

  case 2:

   for(int i = 0; i < 8; i++){

    Arr_Data[i] = Arr_Data2[i];}

      Fun_Naytto();

    break;

  case 3:

   for(int i = 0; i < 8; i++){

    Arr_Data[i] = Arr_Data3[i];}

      Fun_Naytto();

    break;

  case 4:

   for(int i = 0; i < 8; i++){

    Arr_Data[i] = Arr_Data4[i];}

      Fun_Naytto();

    break;

  case 5:

   for(int i = 0; i < 8; i++){

    Arr_Data[i] = Arr_Data5[i];}

      Fun_Naytto();

    break;

  case 6:

   for(int i = 0; i < 8; i++){

    Arr_Data[i] = Arr_Data6[i];}

      Fun_Naytto();

    break;

}// Numeronäytön loppu

delay(1);

} // Pääohjelma LOPPU

// FUNKTIOT

void Fun_Naytto(){

// Datan siirto sarjamuodossa

for(int i = 0; i < 8; i++){

  digitalWrite(Con_DS_Data, Arr_Data[i]);

  digitalWrite(Con_SHCP_Kello, HIGH);

  digitalWrite(Con_SHCP_Kello, LOW);

}// Sarjakirjoitus loppu

// Sarjadatan siirto rinnakkaisiin lähtöihin

  digitalWrite(Con_STCP_Siirto, HIGH);

  digitalWrite(Con_STCP_Siirto, LOW);

}// Näytön loppu

void Fun_Tyhjenna(){

for(int i = 0; i < 8; i++){

  digitalWrite(Con_DS_Data, 0); // Kirjoitetaan 0:aa

  digitalWrite(Con_SHCP_Kello, HIGH);

  digitalWrite(Con_SHCP_Kello, LOW);}

  digitalWrite(Con_STCP_Siirto, HIGH);

  digitalWrite(Con_STCP_Siirto, LOW);

}// Tyhjennyksen loppu

int Fun_Viive(int Viive){

  Viive++;

  return(Viive);

}// Viiveen loppu

Haptiikka ja ”valkoinen keppi”

Haptiikka on tuntoaistiin perustuvaa aistimista. Lainaus Wikipediasta: Tuntoaistilla eli kosketustunnolla eli paineaistilla tarkoitetaan aistitoimintoa, jolla aistitaan painetta ja hahmotetaan kosketusta, terävyyttä, pehmeyttä, lämpötilaa, kipua ja kehon asentoja.

Tämä sovellus vaikuttaa lähinnä kipuaistiin, mutta niin hellästi, että kieli tuntee sen lähinnä kutituksena. Kielianturiin syötetty 5V:in pulssi on niin matalajännitteinen ja lyhyt, että se ei tunnu kipuna. Tietysti kokemuksessa täytyy olla yksilöllisiä eroja. Huomasin pöydällä laktrisapaloja, joten keksin kääriä elektrodit lakupalan päihin, joten samalla sai ”palkinnon”, sain suun magiaks’. Oleellinen tavoite on tuoda esiin käskyn pulseIn(Pin, HIGH/ LOW) (= pulse In, In isolla iillä) toiminta. Sen avulla voi suurella resoluutiolla mitata, kauanko digitaalipinni on alhaalla / ylhäällä.

Digitaalitekniikkassa on tähän aistiin liittyvien tuotteiden kehitys voimakkaan kehityksen kohteena. Tähän mennessä olemme voineet keskutella puheella etäällä olevan henkilön kanssa ja nykyään mukana on myös kuva. Siis kuulo ja näköaisti ovat nykytekniikalle jo arkipäivää. Ei varmaankaan (näin kuvittelen) mene enää montakaan vuotta, kun voimme aidon tuntuisesti kätellä toisella mantereella olevaa ystävää ja tehdä virtuaalilasit päässä yhteisen patikkaretken vaikkapa vuoristoon.

Mutta nyt laskeudun takaisin alavalle pinnalle. Verenpainemittari hajosi. Siinä paine muutetaan sähköiseksi signaaliksi pietsosähköisellä elementillä. Tässä elementissä mekaaninen puristus tai vääntö saa aikaan sähköjännitteen elementin napoihin. Arkisempi esimerkki ilmiöstä on sytkäri, missä on useita pietsokiteitä sarjassa (kunkin jännite kytkeytyy myös sarjaan) ja vasaran naksahtaessa elementtipinoon, syntyy kipinä, joka sytyttää kaasun, ja savukkeen voi sytyttää (toivottavasti kuitenkin tuuli sammuttaa liekin sitä ennen, jotta keuhkot säilyvät terveempinä).

Toiminto toimii toisinkin päin. Kun elemettiin tuodaan jännite, muuttaa kide muotoaan. Päivittäin törmäämme (tiedostamatta) ilmiöön esim. kännykän yhteydessä. Niissä on tarkkaa taajuutta ja aikaa muodostamassa värähtelevä kide. Arduinossa se näyttää tekevän 16 000 000 (16MHz) heilahdusta sekunnissa. Tavoittelin tuon mittarin elementin irroittamisella juuri tätä. Tarkoitukseni oli side silmillä ”tutkailla” ultraäänianturilla (HC-SR04) ympäristöä ja viedä näin saatu (jalostuksen jälkeen) signaali kehoon teipattuun pietsoelementtiin, jonka värähtelyn voisi tuntea iholla. Anturi toimi, mutta ei tarpeeksi voimakkaasti nyt käytettävissä olevilla jännitteillä (esim. 5V). Ajatus oli hylättävä. Onneksi muistin kuinka lapsena kielenpäällä kokeiltiin, vieläkö litteässä taskulampun paristossa oli ”virtaa” (oikeasti jännitettä 4,5V). Pitääpä siis hyödyntää kielen herkkää tuntoa.

Tähän mennessä tuo oli vasta ensimmäinen erehdys. Lisää oli tulossa! Ultraäänianturi (tämä tyyppi HC-SR04) toimii siten, että lyhyellä posittivisella pulssilla (OUT) trikataan anturia ja seuraavaksi toinen (IN) pinni asettuu HIGH (1) kaikua vastaavaksi ajaksi. Arduinon sisäinen laskuri päivittyy aikaan verrannollista pulsseita. Pulssiluku on suuri ja muuttujan täytyy olla unsigned long. Ääni kulkee ilmassa 340m sekunnissa. Ultraäänipulssi ottaa siis aikaa mennäkseen ja heijastuakseen takaisin. 

Tämän toiminnon aikana Arduino ei suorita mitään muuta ohjelmaa. Ennen kuin hoksasin tämän, oli kokeilussa kulunut paljon aikaa. Lakupala ehti hyvin liueta loppuun. (Tosin pureskelin sen siinä pähkäillessä.) Alkuperäiseen kuvitteluun nähden ohjelmasta tuli paljon yksinkertaisempi. Kaikki kielianturin pulssitukseen liittyvä laskenta jäi pois. Kaiusta muodostui luonnollinen viive. Sitä pidempi, mitä enemmän edessä on vapaata tilaa. Sekvenssillä hallitaan perusjksoa (noin 2s pulssiväli) ja kaiulla (eli lasketuilla pulsseilla) ohjelman kiertoaikaa. Tällöin kieli saa sykäyksen harvakseltaan, kun edessä on paljon tilaa ja ”sähköiskut” kiihtyvät, kun välimatka esteeseen lyhenee. Huoneissa tämä toimii hyvin, mutta ulkona tarvitaan kyllä muutakin (esim. GPS), tai joutuu helposti eksyksiin.

Ohjelma 21

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

 *  Ohjelma 21

 *  02.06.2016

 *  Haptiikka ja "valkoinen keppi"

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

// Määrittelyt

const int Con_Pulssi = 8;

const int Con_Kaiku = 9;

unsigned long Ulo_Kesto1 = 0;

const int Con_LED13 = 13;

const  int Con_Hapti = 2;

int Seq_Pulssitus = 1;

const int Con_PulssiVali = 30;

int Int_PullsiVali = Con_PulssiVali;

// ASETUKSET:

void setup(){                 

 Serial.begin(9600);         

pinMode(Con_Pulssi, OUTPUT);

pinMode(Con_Kaiku, INPUT);

pinMode(Con_LED13, OUTPUT);

pinMode(Con_Hapti, OUTPUT);

}// Asetuksen loppu

// PÄÄLOOPPI        

void loop(){

// Paluupulssin pituuden mittaus

    digitalWrite(Con_Pulssi, HIGH);

    digitalWrite(Con_Pulssi, LOW);

     Ulo_Kesto1 = pulseIn(Con_Kaiku, HIGH); // Mittausjakso

// Muunnos anturille

switch (Seq_Pulssitus) {

  case 1:

    Int_PullsiVali = Con_PulssiVali;

     Seq_Pulssitus = 2;

    break;

  case 2:

    Int_PullsiVali--;

    if(Int_PullsiVali == 0){

      Fun_Pulssi();

      Seq_Pulssitus = 1;}

    break;

 } // Pulssisekvenssin loppu

delay(1);

} // Pääohjelma LOPPU

void Fun_Pulssi(){

  digitalWrite(Con_Hapti, HIGH);

  digitalWrite(Con_LED13, HIGH); 

  delay(30);

  digitalWrite(Con_LED13, LOW);

  digitalWrite(Con_Hapti, LOW); 

} // Aliohjeman loppu

Ja leikki jatkuu

Oikeastaan Arduino mikrokonttrolleri ei ole mikään tietokone, vaan yksi elektroniikan ”komponentti” muiden komponenttien joukossa. Toki ohjelmoinnilla on paljon helpompi saada aikaan erilaisia toimintoja kuin erilliskomponenteista rakentamalla. Tähän mennessä olen käyttänyt (tässä blogissa) samaa kontrolleria (paitsi kelloon jäi jatkuvaan käyttöön) eri sovelluksiin, mutta lopullinen tarkoitus on tuoda eri ideoita ja keinoja erilasten hyötysovellusten toteutukseen. Toki tämä leikkiminen ja luovuus ovat tärkeässä asemassa. Sen huomaa siitäkin, miten paljon erilaista anturia ja lisälaitettä netissä on tarjolla Arduino-maailmaan.

Mökillä on sähköt toteutettu aurinkopaneeleilla ja tuuligeneraattorilla. Sen vuoksi monet tähänastiset sovellukset liittyvät juuri tähän maailmaan. Kaikki laitteet toimivat 12V akkusähköllä. Toimivia laitteita ovat akkujen ylilatauksen valvonta, akkujen liian purkamisen esto, aurinkopaneelien kääntö, akkujen jännitteen näyttö jne. Näistä ei ole kuvia, mutta jäljempänä joitakin näihin liittyvää. Aina ei paista, ei edes päivisin. Jääkaapin syötössä on siksi valvontalaite. Jos akun varaus ei riitä, vaan yöllä jännite laskee, pudottaa valvontalaite jääkaapin pois. Akkua ei saa purkaa liikaa. Jääkaapin sisältö pysyy kyllä kylmänä aamuun saakka, kun ovea ei avata. Aamulla jälleen toivotaan aurinkoista päivää.

Akut eivät ole ikuisia. Nykyään ne ovat kiinnostuksen ja kehityksen kohteita, koska autoliikenteen toivotaan siirtyvän sähkökäyttöiseksi. Edelleen akkujen kapasiteetti pienenee jokaisesta latauskerrasta ja myös vuosien mittaan. Kuvassa oleva laite kytketään täyteen ladattuun akkuun, painetaan nappia, valo syttyy ja laite ryhtyy purkamaan akkua. Purkaus päättyy, kun akun jännite on laskenut 10V:iin. Purkauslaitteena on auton lamppu. Vaihdossa pitkien valojen puoli on jäänyt ehjäksi, joten se on saanut tässä jatkokäytön. Purkusvirta on noin 5A. Näyttönä on analogianäyttö, mikä pysähtyy johonkin lukemaan välille 0 .. 100Ah (ampeerituntia). Käytetty aika muutetaan analogialähdöllä jännitteeksi. Ei tällä ”mittarilla” aivan tarkkaa kapasiteettia saada mitattua, mutta luotettavan vastauksen siihen, pitäisikö vanha akku jo korvata uudella.

Mittausteni mukaan aurinkopaneelin tuotto pienenee puoleen noin 45 asteen kulmassa. Maa pyörii tämän kulman kolmessa tunnissa. Varsinaisista kääntäjistä minulla ei nyt ole kuvaa, mutta parista erityyppisestä pienoismalliprototyypistä on. Näiden tärkein tehtävä oli toiminta ohjelmakehitysksessä. Tuossa kuvassa oleva jäljittelee vanhanaikaista auton tunkkia. Sen toinen haara on kiinteä, ja kun ruuvi vetää haaraa avoimemmaksi, kääntyy pystyakseli. Tällä pääsee noi 90 asteen kääntymään. Jos kääntö käynnityy klo 09:00, seuraa paneeli aurinkoa 6 tuntia eli kello 15:00 saakka. Yli 50% tuotto saadaan siis kello kuudesta aamusta kello kuuteen illalla.

Toisessa käytössä olevassa tyypissä (tässä jälleen pienoismalli ohjelmakehitystä varten) moottori pyörittää pitkää ruuvia putken sisälä. Putkeen on uurrettu pitkittäinen hahlo, joka kiertää puoli kierrosta. Haitan siirtyessä pitkin ruuvia, samalla kiertyy putki, mihin paneeli on kiinnitetty. Tällä menetelmällä päästään 180 asteen eli 12 tunnin seurantaan. Siirto tapahtuu (kuten edellisessäkin mallissa) tunnin välein. Kääntö jään 7,5 astetta jälkeen ja siirtyy sitten 7,5 astetta edelle aurinkoa. Pilville ei sitten mahda mitään. Jos taivas on täysin umpipilvinen, pienenee paneelin tuotto helposti parin prosentin luokkaan. Käytössä on ollut myös hammasratasvaihteistolla toteutettu kääntäjä ja kehitteillä on malli, jossa veneen tuulilasinpyyhkijä naksauttaa aina ratasta eteenpäin. Tuollakin on mahdollista päästä noi kuuden tunnin seurantaan.

LEDilammpu meni taannoin rikki, niin pitihän se tutkia, mitä se oli ”syönyt”. Itse LEDipaneeli oli toimiva, ja toimi 12V:in jännitteellä, joten sain siitä idean tehdä valaisimen mökille. Siinä on kaksi toimintaa: Kytkimen toisessa asennossa syttyy valo ja toisessa asennossa laite toimii hämärkytkimenä. Siinä valovastus mittaa valoisuutta ja kytkee valon päälle, kun tulee tarpeeksi pimeää. Raja on säädettävissä potentiemetrillä. Kumpikin valo on säädettävissä (PWM) siten, että joka toinen painikkeen painaminen lisää valoa ja joka toinen himmentää. Tuo oli käytössä jo viime kesän lopulla, mutta vaati ohjelmistopäivitystä. Tärkein muutos oli kuitenkin valovastuksen liittäminen johdon päähän, joten se ei ole enää lähellä valokiilaa. Viime kesänä se pyrki toimimaan vilkkuvalona.

Tämä laite on oikeastaan jo täyttänyt päätehtävänsä. Toivottavasti sille löytyy vielä käyttöä ohjelmakehityksessä. Rinnan sisään / sarjassa ulos - IC-piiri 74HC165 lukee painikkeitten tilaa rinnakkaismuodossa ja siirtää datan sarjamuodossa Arduinolle. Sarjassa sisään / rinnan ulos – IC-piiri 74HC595 lukee sarjassa Arduinolta ja jakaa datan rinnan ulos. Tässä on indikaattorina 7-segmenttinäyttö. Molemmat piirit ovat kahdeksan(8) bittisiä, mutta näitä voidaan kytkeä peräkkäin. Näin voidaan helposti mikrokontrollerin IO-avaruutta laajentaa merkittävästi.

Arduinon ympärille on kehittynyt oikein maailman laajuinen tohina. Siitä elävin merkki on valtava netissä oleva ohjelmaesimerkkien paljous sekä monipuolinen lisälaitetarjonta. Tuossa kuvassa on vain muutama anturi. Tarjolla on runsas määrä moduleita Arduinoille. On ultraääntä (US), on infrapunaa (IR), on radiotaajuudelle (RF), on laseria, on lämpötilan ja kosteuden mittaukseen, painikkeita, joystick:iä, potikkaa jne. on innostavat mahdollisuudet mielikuvitukselle ja innovaatioille.

JA LEIKKI JATKUU!