Il Blog di Nicolò Carandini

using System;
using System.Threading;

using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;

using GHIElectronics.NETMF.FEZ;

namespace FEZMiniLab.BlinkingLed
{
    public class Program
    {
        // Essendo un programma di prova, il messaggio è impostato direttamente qui,
        // nel codice
        private static string msg = "SOS";
        
        // Nell'ambito delle trasmissioni in codice Morse si usa
        // l'acronimo wpm (word per minute) per dichiarare la velocità
        // media di trasmissione. Poiché le parole sono di diversa lunghezza,
        // per definizione viene usata la parola PARIS, che corrisponde ad una
        // sequenza di 49 segnali (che per comodità nei calcoli si arrotonda a 50).
        // Da cui deriva che, data una determinata velocità W, i corrispondenti
        // baud (simboli trasmessi per secondo) sono pari a: W * 50 / 60 .
        // Poiché le velocità tipiche di trasmissione variano dai 15 wpm ai 50 wpm
        // abbiamo velocità di trasmissione che vanno dai 12,5 baud ai 41,6 baud.
        // Ma per distinguere visivamente il codice morse quando viene mostrato
        // tramite sorgente luminosa, specialmente con chi non è addestrato, è
        // bene mantenersi su velocità ben più basse, pari a 5 wpm, corrispondente
        // a 4,17 baud.
        private static double baud = 4.17;

        // Una volta definita la velocità di trasmissione, è facile ottenere la durata
        // del segnale (in millisecondi):
        private static int signalDuration = (int)System.Math.Round(1000 / baud);
        
        public static void Main()
        {
            // Inizializza il LED presente nella scheda
            bool ledState = false;
            OutputPort led = new OutputPort((Cpu.Pin)FEZ_Pin.Digital.LED, ledState);

            // Istanzia la Tavola di Codifica Morse
            MorseTable morseTable = new MorseTable();
            
            // Codifica il messaggio
            bool[] morseSignalStream = morseTable.Encode(msg);

            while (true)
            {
                // Mostra il segnale Morse tramite il LED
                foreach (bool signalState in morseSignalStream)
                {
                    led.Write(signalState);

                    // Mantieni il segnale per un tempo pari alla durata del
                    // segnale stesso
                    Thread.Sleep(signalDuration);
                }

                // Sleep for 1 second
                Thread.Sleep(2000);
            }
        }

    }
}

using System.Collections;

namespace FEZMiniLab.BlinkingLed
{
    /// <summary>
    /// Enumerazione dei valori Morse.
    /// </summary>
    enum MorseValue
    {
        dot,
        line
    }
    
    /// <summary>
    /// Gestisce la conversione dei messaggi da testo alfanumerico a codice morse
    /// </summary>
    class MorseTable
    {
        private static MorseValue DOT = MorseValue.dot;
        private static MorseValue LINE = MorseValue.line;

        private Hashtable alfaNumericDictionary;

        public MorseTable()
        {
            alfaNumericDictionary = new Hashtable();

            alfaNumericDictionary.Add("A", new MorseValue[] { DOT, LINE });
            alfaNumericDictionary.Add("B", new MorseValue[] { LINE, DOT, DOT, DOT });
            alfaNumericDictionary.Add("C", new MorseValue[] { LINE, DOT, LINE, DOT });
            alfaNumericDictionary.Add("D", new MorseValue[] { LINE, DOT, DOT });
            alfaNumericDictionary.Add("E", new MorseValue[] { DOT });
            alfaNumericDictionary.Add("F", new MorseValue[] { DOT, DOT, LINE, DOT });
            alfaNumericDictionary.Add("G", new MorseValue[] { LINE, LINE, DOT });
            alfaNumericDictionary.Add("H", new MorseValue[] { DOT, DOT, DOT, DOT });
            alfaNumericDictionary.Add("I", new MorseValue[] { DOT, DOT });
            alfaNumericDictionary.Add("J", new MorseValue[] { DOT, LINE, LINE, LINE });
            alfaNumericDictionary.Add("K", new MorseValue[] { LINE, DOT, LINE });
            alfaNumericDictionary.Add("L", new MorseValue[] { DOT, LINE, DOT, DOT });
            alfaNumericDictionary.Add("M", new MorseValue[] { LINE, LINE });
            alfaNumericDictionary.Add("N", new MorseValue[] { LINE, DOT });
            alfaNumericDictionary.Add("O", new MorseValue[] { LINE, LINE, LINE });
            alfaNumericDictionary.Add("Q", new MorseValue[] { DOT, LINE, LINE, DOT });
            alfaNumericDictionary.Add("R", new MorseValue[] { DOT, LINE, DOT });
            alfaNumericDictionary.Add("S", new MorseValue[] { DOT, DOT, DOT });
            alfaNumericDictionary.Add("T", new MorseValue[] { LINE });
            alfaNumericDictionary.Add("U", new MorseValue[] { DOT, DOT, LINE });
            alfaNumericDictionary.Add("V", new MorseValue[] { DOT, DOT, DOT, LINE });
            alfaNumericDictionary.Add("W", new MorseValue[] { DOT, LINE, LINE });
            alfaNumericDictionary.Add("X", new MorseValue[] { LINE, DOT, DOT, LINE });
            alfaNumericDictionary.Add("Y", new MorseValue[] { LINE, DOT, LINE, LINE });
            alfaNumericDictionary.Add("Z", new MorseValue[] { LINE, LINE, DOT, DOT });
            alfaNumericDictionary.Add("0", new MorseValue[] { LINE, LINE, LINE, LINE, LINE });
            alfaNumericDictionary.Add("1", new MorseValue[] { DOT, LINE, LINE, LINE, LINE });
            alfaNumericDictionary.Add("2", new MorseValue[] { DOT, DOT, LINE, LINE, LINE });
            alfaNumericDictionary.Add("3", new MorseValue[] { DOT, DOT, DOT, LINE, LINE });
            alfaNumericDictionary.Add("4", new MorseValue[] { DOT, DOT, DOT, DOT, LINE });
            alfaNumericDictionary.Add("5", new MorseValue[] { DOT, DOT, DOT, DOT, DOT });
            alfaNumericDictionary.Add("6", new MorseValue[] { LINE, DOT, DOT, DOT, DOT });
            alfaNumericDictionary.Add("7", new MorseValue[] { LINE, LINE, DOT, DOT, DOT });
            alfaNumericDictionary.Add("8", new MorseValue[] { LINE, LINE, LINE, DOT, DOT });
            alfaNumericDictionary.Add("9", new MorseValue[] { LINE, LINE, LINE, LINE, DOT });
            alfaNumericDictionary.Add(".", new MorseValue[] { DOT, LINE, DOT, LINE, DOT, LINE });
            alfaNumericDictionary.Add(",", new MorseValue[] { LINE, LINE, DOT, DOT, LINE, LINE });
            alfaNumericDictionary.Add(":", new MorseValue[] { LINE, LINE, LINE, DOT, DOT, DOT });
            alfaNumericDictionary.Add("?", new MorseValue[] { DOT, DOT, LINE, LINE, DOT, DOT });
            alfaNumericDictionary.Add("=", new MorseValue[] { LINE, DOT, DOT, DOT, LINE });
            alfaNumericDictionary.Add("-", new MorseValue[] { LINE, DOT, DOT, DOT, DOT, LINE });
            alfaNumericDictionary.Add("(", new MorseValue[] { LINE, DOT,LINE, LINE, DOT });
            alfaNumericDictionary.Add(")", new MorseValue[] { LINE, DOT, LINE, LINE, DOT, LINE});
            alfaNumericDictionary.Add("\"", new MorseValue[] { DOT, LINE, DOT, DOT, LINE, DOT });
            alfaNumericDictionary.Add("'", new MorseValue[] { DOT, LINE, LINE, LINE, LINE, DOT });
            alfaNumericDictionary.Add("/", new MorseValue[] { LINE, DOT, DOT, LINE, DOT });
            alfaNumericDictionary.Add("_", new MorseValue[] { DOT, DOT, LINE, LINE, DOT, LINE });
            alfaNumericDictionary.Add("@", new MorseValue[] { DOT, LINE, LINE, DOT, LINE, DOT });
        }

        public bool[] Encode(string msg)
        {
            ArrayList signalStream = new ArrayList();
            MorseValue[] morseValues;
            string lastLiteral = "";
            string literal;

            foreach(char c in msg)
            {
                literal = c.ToString().ToUpper();

                if (literal == " ")
                {
                    // Codifica lo spazio come un wordSpace solo se il precedente carattere
                    // non era uno spazio (in pratica elimina gli spazi ripetuti)
                    if (lastLiteral != " ")
                    {
                        // Aggiungi un wordSpaceSignal (una sequenza di 7 "off" signal)
                        signalStream.Add(false);
                        signalStream.Add(false);
                        signalStream.Add(false);
                        signalStream.Add(false);
                        signalStream.Add(false);
                        signalStream.Add(false);
                        signalStream.Add(false);
                    }
                }
                else
                {
                    if ((lastLiteral != " ") && (lastLiteral.Length != 0))
                    {
                        // Aggiungi un charSpaceSignal (una sequenza di 3 "off" signal)
                        signalStream.Add(false);
                        signalStream.Add(false);
                        signalStream.Add(false);
                    }
                    
                    // Da notare che nel Micro Framework (almeno fino alla versione 4.1) non ci sono i Generics
                    // quindi bisogna usare il cast esplicito al tipo MorseValue[]
                    // che è il tipo del valore della coppia <chiave, valore> della hash table.
                    morseValues = (MorseValue[])alfaNumericDictionary[literal];

                    bool firstValue = true;
                    foreach(MorseValue morseValue in morseValues)
                    {
                        if (!firstValue)
                        {
                            // Aggiungi un valueSpaceSignal (1 "off" signal)
                            signalStream.Add(false);
                        }
                        
                        switch (morseValue)
                        {
                            case MorseValue.dot:
                                // Aggiungi un dotSignal (1 "on" signal)
                                signalStream.Add(true);
                                break;
                            case MorseValue.line:
                                // Aggiungi un dotSignal (una sequenza di 3 "on" signal)
                                signalStream.Add(true);
                                signalStream.Add(true);
                                signalStream.Add(true);
                                break;
                            default:
                                break;
                        }

                        firstValue = false;
                    }
                }

                lastLiteral = literal;
            }

            // Spenge il segnale
            signalStream.Add(false);

            // Ritorna un array di bool
            return (bool[]) signalStream.ToArray(typeof(bool));
        }

    }
}

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace FEZMiniLab.BlinkingLed.Test
{
    /// <summary>
    ///This is a test class for MorseTableTest and is intended
    ///to contain all MorseTableTest Unit Tests
    ///</summary>
    [TestClass()]
    public class MorseTableTest
    {
        private TestContext testContextInstance;

        /// <summary>
        ///Gets or sets the test context which provides
        ///information about and functionality for the current test run.
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        [TestMethod()]
        public void EncodeTest_U()
        {
            MorseTable target = new MorseTable();
            string msg = "U";
            bool[] expected = new bool[] {
                                           true, false, true, false, true, true, true, // ..-
                                           false                                       // fine trasmissione
                                         } ;
            bool[] actual = target.Encode(msg);
            CollectionAssert.AreEqual(expected, actual);
        }

        [TestMethod()]
        public void EncodeTest_N()
        {
            MorseTable target = new MorseTable();
            string msg = "N";
            bool[] expected = new bool[] {
                                           true, true, true, false, true,              // -.
                                           false                                       // fine trasmissione
                                         };
            bool[] actual = target.Encode(msg);
            CollectionAssert.AreEqual(expected, actual);
        }

        [TestMethod()]
        public void EncodeTest_UN()
        {
            MorseTable target = new MorseTable();
            string msg = "UN";
            bool[] expected = new bool[] {
                                            true, false, true, false, true, true, true,   // U
                                            false, false, false,                          // spazio tra i caratteri
                                            true, true, true, false, true,                // N
                                            false                                         // fine trasmissione
                                         };
            bool[] actual = target.Encode(msg);
            CollectionAssert.AreEqual(expected, actual);
        }

        [TestMethod()]
        public void EncodeTest_A()
        {
            MorseTable target = new MorseTable();
            string msg = "A";
            bool[] expected = new bool[] {
                                           true, false, true, true, true,                // .-
                                           false                                         // fine trasmissione
                                         };
            bool[] actual = target.Encode(msg);
            CollectionAssert.AreEqual(expected, actual);
        }

        [TestMethod()]
        public void EncodeTest_G()
        {
            MorseTable target = new MorseTable();
            string msg = "G";
            bool[] expected = new bool[] {
                                           true, true, true, false, true, true, true, false, true,  //--.
                                           false                                                    // fine trasmissione
                                         };
            bool[] actual = target.Encode(msg);
            CollectionAssert.AreEqual(expected, actual);
        }

       [TestMethod()]
        public void EncodeTest_O()
        {
            MorseTable target = new MorseTable();
            string msg = "O";
            bool[] expected = new bool[] {
                                           true, true, true, false, true, true, true, false, true, true, true,   // ---
                                           false                                                                 // fine trasmissione
                                         };
            bool[] actual = target.Encode(msg);
            CollectionAssert.AreEqual(expected, actual);
        }

        [TestMethod()]
        public void EncodeTest_AGO()
        {
            MorseTable target = new MorseTable();
            string msg = "AGO";
            bool[] expected = new bool[] {
                                            true, false, true, true, true,                                              // A
                                            false, false, false,                                                        // spazio tra i caratteri
                                            true, true, true, false, true, true, true, false, true,                     // G
                                            false, false, false,                                                        // spazio tra i caratteri
                                            true, true, true, false, true, true, true, false, true, true, true,         // O
                                            false                                                                       // fine trasmissione
                                         };
            bool[] actual = target.Encode(msg);
            CollectionAssert.AreEqual(expected, actual);
        }

        [TestMethod()]
        public void EncodeTest_UN_AGO()
        {
            MorseTable target = new MorseTable();
            string msg = "UN AGO";
            bool[] expected = new bool[] {
                                            true, false, true, false, true, true, true,                             // U
                                            false, false, false,                                                    // spazio tra i caratteri
                                            true, true, true, false, true,                                          // N
                                            false, false, false, false, false, false, false,                        // spazio tra le parole
                                            true, false, true, true, true,                                          // A
                                            false, false, false,                                                    // spazio tra i caratteri
                                            true, true, true, false, true, true, true, false, true,                 // G
                                            false, false, false,                                                    // spazio tra i caratteri
                                            true, true, true, false, true, true, true, false, true, true, true,     // O
                                            false                                                                   // fine trasmissione
                                         };
            bool[] actual = target.Encode(msg);
            CollectionAssert.AreEqual(expected, actual);
        }
    }
}