Mechatronics I Lab Report 2 Arduino Morse Encoder. Instructor: Joseph Timothy Foley. Axel Bender & Elías Marel

Transcription

1 Mechatronics I Lab Report 2 Arduino Morse Encoder Instructor: Joseph Timothy Foley Axel Bender & Elías Marel September 27, 2012

2 Contents Contents 1 1 Introduction Background Design Requirements Software Limitations Testing 8 4 Usage Installation Instructions Results and Discussion 9 6 Conclusion Future work References 11 8 Appendix Code Tests

3 1 Introduction Communication issues between dierent types of software is a problem every software and mechatronic engineer must face. It is often necessary to translate information between platforms, be it via analog or digital signals, and make it understandable for dierent types of hardware. In this lab exercise we are forced to deal with this well known issue to learn about it rsthand. Another big factor of this experiment is to dive into real world implementation of functional programming. The design and development of the project will be implemented using ideas and concepts of Test Driven Development (TDD). A Morse code encoder will be designed using an Arduino Uno that is connected to a laptop via a serial USB cable. The serial monitor of the Arduino development environment called Arduino will be used to feed a message containing letters and symbols from a keyboard to the Arduino. The Arduino will then translate the message, if possible, and send it out in morse code by blinking a LED. 1.1 Background Morse code was in it's day the preferred method for long distance communication. Before men were able to transmit voice, radio transmissions were in the form of clicks, pulses and silences. Morse code grew to popularity over many other transmission methods due to many qualities, including the fact that one of it's creators, Alfred Vail researched the frequency of use for each letter in the English language and designed the code for optimum transmission speed. Samuel Morse only included numerals in his original morse code which dated back to the 19th century. Morse proved in 1835 that signals could be transmitted through wires after experimenting with using electric current to move an electromagnet attached to a marker to write dots and dashes on a piece of paper [1]. His partner Alfred Vail added the English alphabet to the code and eventually morse code would be used in the rst radio transmissions. Even after vocal radio transmissions were possible morse code remained useful, especially in military purposes. During World War II, for example, communication between ships and over long distances was performed with morse code radio transmissions since voice radio had very limited range. Today morse code is mostly used for emergency communication, mainly in air trac. The main reason for morse code's survival to date is that no special technology is needed to communicate in Morse code with a skilled listener, signals can be sent as blinking lights, knocks or other sounds. Interestingly, morse code has been used by musicians to hide secret messages in their music. One example is The Strangler's 1978 song Enough Time which features traditional morse code beeps that translates to: "SOS this is planet Earth - we are fucked - please advise". The main guitar ri in the Canadian Prog rock band Rush's instrumental song YYZ translates to Y Y Z in morse code. And one of the most famous morse code messages in music is the start of Beethoven's fth symphony which incidentally spells out V in morse code, V being the Roman numeral for 5. This is mostly interesting because Beethoven wrote his fth symphony in , years before morse code even existed. The opening to the fth symphony became the symbol of allied victory in WW2 because of this, V being the radio transmission meaning "Victory" after a battle. [2] 2

4 Figure 1: A circuit diagram of the morse encoder. 2 Design We started out developing a simple circuit design to convert the morse code, that would eventually be encoded by software written in C++ for the arduino, into the physical world. Our design consisted of an Arduino Uno to write our code on, a breadboard to build the circuit on, a potentiometer to control the frequency of the morse signal, a green LED to display our morse code with and some wires to connect the components to the arduino's output. We examined the available outputs on the arduino and decided that pins 12 and 13 were optimal to use for our outputs, for they are completely controllable. The idea for this setup came from both the lab instructions and further research into how the arduino sends signals to a circuit. Upon some experimentation with the build of the circuit we came to the conclusion that in order to get the desired 50 ma current through the circuit we would need to implement some resistors into the design. This is done to protect the Arduino unit. Next we built a separate circuit with a button to manually override the encoding software, using a switch to go from auto to manual. At this point in the development of the project we decided that we wanted to implement sound to our circuit build, which we did by adding an electronic buzzer to the circuit in parallel with the green LED. The last addition to the design came when we had started writing the encoder and had decided to include an error function, so when the user inserts any letters or symbols outside the parameters we had set it would display an error. We connected a red LED to the circuit to display when the encoder ran into an error. The nished circuit can be seen in gure Requirements The requirements for our system is that it accepts a string input through the Arduino software's serial monitor and then systematically break it down into individual char variables that are then translated into pulses of appropriate length. The pulses will be fed into our circuit and displayed via a green LED and sound from an electronic buzzer. The speed of the output 3

5 Figure 2: International morse code as dened by ITU-R [3]. Figure 3: A ASCII table. signal must be controllable even though the program is running. It must also include a manual override that can be operated by a human and disregard anything the program is doing. The Radiocommunication Sector of The International Telecommunication Union (ITU-R) issued a recommendation booklet about the proper use of morse code in The denition of morse code that is listed in this document is used in this project. This version of the international morse code includes the English alphabet, Arabic numerals and a few punctuation marks. The document also lists morse code for various transmission signs such as "Understood", "Wait" and "End of work" that are not in the scope of this project since we are only dealing with letters and symbols. We made a table where all the letters and symbols encodable with the device are listed along with their morse code as dened by ITU-R [3]. The table can be seen in gure 2. To encode theses letters and symbols we referred to the ASCII table [4] which the computer and therefore the Arduino software use to represent letters and symbols. The table can be seen in gure 3. If the input is lower case letters, they will be automatically converted to upper case letters and then translated. If the input is a symbol that is not in the table in gure 2 it will not be translated and a error will be displayed, both in the serial monitor of the Arduino software and via a red LED in the circuit. 4

6 Figure 4: A Modular Dependency Diagram of the program. To do this we need to create an array with char variables to use as a library to compare our input string with. This array will span symbols in the ASCII table from the value 34 to 90. Then we have to create a function that loops through the input string and analyses each char variable, to be able to convert each letter to a series of short and long pulses. Depending on how each letter corresponds to short and long, we make the loop function go into the desired function to create the pulses and send as output from the arduino into our circuit. In order to be able to control the frequency of the morse code while it is running we have to have the arduino emit a 5 V controlling voltage to the potentiometer and accept a changing analog signal to an input. 2.2 Software This assignment is very software demanding. Therefore we focused our main attention on writing the code for the system. A Modular Dependency Diagram of the program can be seen in gure 4 and below is a pseudocode describing the program step by step. The actual C++ code can be found in section 8.1, Appendix. Decleration of variables Set greenled and redled as output variables 12 and 13. Set minpulse = 50, the minimum pulse length (50 ms) Set scaleofpulse = 6, this controls the scale of the potentiometer. Set pot = A0, assigns an input variable for the potentiometer. Set serialinput = 0, giving variable an initial value. Set rounder = 0, to use with Serial.print to print out the letters we are turning into morse code. Set errortime = 500, to control the time of the error display. Set timer as an unsigned long variable, this will be used to count time for the error function. Create morselib, a reference library which holds the corresponding morse code for the letters we want to translate. 5

7 Setup function Set pin 12 as output Set pin 13 as output Assign the serial port, speed 9600 bit/s Main looping function If the error timer is nished. Turn o the signal to redled to stop the error display. If text is available for encoding. serialinput accepts data from the serial port Print out the letter we are converting and corresponding morse code. Calls for the translator function with serialinput as input variable. Test: prints out the length of short and long morse outputs. Translator function Set index variable which selects the corresponding morse code from the morselib, relative to which letter is being encoded. If the symbol being translated is a space Calls for the space function If the symbol being translated is not within the parameters of morselib Calls for the error function Loops through each element of the character being encoded within the morselib If the element is for a short output Calls for the short function If the element is for a long output Calls for the long function If the symbol being encoded is not accepted by the morselib Calls for the error function 6

8 Calls for the letterspace function Short function Set pulse variable, controls the length of the delay. Print out " Short " on the serial window. Turns on the signal to greenled for the duration of pulse. Turns of the signal to greenled and waits for the duration of pulse. Long function Set pulseon variable, controls the length of the delay. Set pulseo variable, controls the length of the delay time after shutting o. Print out " Long " on the serial window. Turns on the signal to greenled for the duration of pulseon. Turns of the signal to greenled and waits for the duration of pulse. Error function Set pulse variable, controls the length of the delay. Print out " Incorrect input " on the serial window. Turns on the signal to redled. Starts the timer counting in milliseconds. Letterspace function Set pulse variable, controls the length of the delay. Delays for the duration of pulse. Space function Set pulse variable, controls the length of the delay. Delays for the duration of pulse. 2.3 Limitations This project has its limitations as one might expect. To start o our system only accepts certain type of input variables, both lower and higher case letters and a handful of symbols. Now in order to avoid a system failure when the user picks a symbol not accepted by the program we used defensive programming to included an error function. Whether the symbol is not within the parameters of the morselib array or it is an illegal symbol within the array the system defaults to an error function. The function sends a signal to a red diode on the circuit board for a duration equal to a normal white-space so not to oset the system. In short no environmental factors limit the usage of the device. Although it is advised to be indoors and 7

9 keep food and beverages away from the arduino at all times. Another thing to consider is that the system needs to be connected to a computer at all times. It would be optimal to have an external power supply mounted to system as well a way to input data or text to be encoded. 3 Testing While developing the software we relied heavily on test driven programming. Before starting our project we had to make sure that the Arduino Uno unit was not defective. To do this we uploaded the example Blink function to the arduino unit which resulted in a light on the unit to blink indicating that it was working correctly. Our rst objective was to program the arduino to send a steady signal through a selected output to the circuit. To test this we placed a diode in the circuit we had built, uploaded the code we had written for this purpose and when the diode lid up we had conrmation that this section was functional. Next section of the project that needed to be tested was whether or not we are able to accept a string input and break it up to be analysed and encoded later. To do this we print out the letter being encoded and the corresponding morse code. Each time the void loop goes through a cycle. We performed the same test on a string including every available variable in the morselib array along with some illegal symbols to see if our encoder was working as intended. Results can be seen in section 8.2 in the appendix. The last test we had to perform was to test if the length of the morse code pulses was accurate. To do this we wrote a separate code that reads the output of our program on a second arduino and measures the time from a high to a low, i.e. times the pulses. Then we compare the short and long signals to see if the ratio is correct. See section 8.1 in the appendix. Upon testing we discovered that it was crucial to connect both arduino units used for this test to mutual ground to get uncorrupted read on the signal from the encoder. 4 Usage The device is useful for people who for some reason need to communicate in morse code but are not trained in transmitting morse code. be able to transmit code so it can be understood takes a lot of training so not everyone who needs to transmit morse code has the ability to do it, at least straight away. In order to use the device some steps must be taken in assembly and software installation. 4.1 Installation To be able to use the device it is necessary to have the Arduino software installed. If it is not installed on the computer the device is to be used with it can be downloaded and installed from Arduino's homepage [5]. 1. Turn on the computer and start an operating system. 8

10 2. Open a web browser and go to Arduino's homepage [5]. 3. Download and install Arduino by following the instructions on Arduino's homepage. 4. Install the serial driver for the Arduino Uno. 5. Connect the arduino to a working USB port. 6. Construct the circuit as described above. The circuit can be seen in gure Open the Arduino software and open the morse encoder software, either by cutting and pasting into a new sketch or by downloading the program here: dropbox.com/u/ /morse_encoder.ino. This is an open download link hosted by dropbox.com. 8. Upload the program to the Arduino Uno. 4.2 Instructions 1. Open the serial monitor. 2. Type in the message to encode and press Enter. 3. If an invalid letter or symbol is entered an error display will let you know. 5 Results and Discussion By implementing test driven development we were successfully able to limit the amount of time and energy lost to bugs and errors in the programming. This was done by cutting the program up into objects or seperate functions that each have a restricted and well dened purpose and testing each step of the way. Naturally some problems occurred, but none of them stopped the programming for long. The circuit was built without any major hitches, experience in electric circuits came to good use there. Testing proved the function of the device as can be seen in sections 5 and 6 6 Conclusion The product of this lab report is a working morse decoder that can handle all the letters and symbols in international morse code as dened by ITU-R [3]. It displays the translated message using a blinking green LED along with an electric buzzer and printing the result out in the serial monitor. The speed of the transmission can be altered while the program is running, a error displays when an invalid character is entered, both via a red LED and in the serial monitor of the development software. A manual override was implemented that can be turned on and used by a human in spite of what the encoder is trying to display. The objectives set in the beginning of the project have all been met and some additional functions have been added over the course of the project. Possible costumers for the device include radio amateurs that are honing their skills at morse code transmissions. The device is very useful as a learning tool for people who are learning morse code and want a safe and sure way to transmit morse code. 9

11 6.1 Future work A way to take this project further would be to develop a decoder capable of translating the whole library for any given frequency. This addition would be make morse code translation capable for people with little or no knowledge of the code. The system might also be used as a learning tool for people interested in morse code to learn how to decipher it. 10

12 7 References [1] M. Bellis, The History of the Telegraph, September [Online]. Available: [2] G. Stanley, The Cambridge Companion to Beethoven. Cambridge University Press, [3] Recommendation ITU-R M (10/2009), International Morse Code, September [Online]. Available: I!!PDF-E.pdf [4] ASCII Table and Description, September [Online]. Available: cc/ [5] Arduino homepage, September [Online]. Available: 11

13 8 Appendix 8.1 Code 1 Encoder : 3 // Variable d e f i n i t i o n s. 5 i n t g r e e n l e d = 12, r e d l e d = 1 3 ; i n t minpulse = 5 0 ; // Sets the minimum p ulse length as 50 ms. I f minpulse = 50 and s c a l e o f p u l s e = 6 the dot length can be changed from 50 ms to 220 ms by a d j u s t i n g the potentiometer while the program i s running. 7 i n t s c a l e o f p u l s e = 6 ; // Sets the d i v i d e r value f o r each pulse, This c o n t r o l s the s c a l e o f the potentiometer. I f minpulse = 50 ms, d i v i s i o n by 2 means the l o n g e s t pulse w i l l be (1023 ms / 2) + 50 ms = 562 ms. i n t pot = A0 ; // A potentiometer i s used to r e g u l a t e the speed o f the encoder. 9 i n t s e r i a l i n p u t = 0 ; // I n t i t a l value f o r the s e r i a l input s e l e c t e d as 0. i n t rounder = 0 ; // Makes S e r i a l. p r i n t p r i n t out l e t t e r s and symbols i n s t e a d o f the ASCII value. 11 unsigned long e r r o r t i m e = 50UL; // Sets the d i s p l a y time f o r the e r r o r f u n c i t o n to 50 ms. UL i s to s p e c i f y that the v a r i a b l e type i s unsigned long. unsigned long timer ; // Declare the timer v a r i a b l e used to stop the e r r o r d i s p l a y i n g. 13 // A r e f e r e n c e array o f p o i n t e r s r e p r e s e n t i n g the ASCII v alues from 34 f o r the symbol " to 90 f o r the l e t t e r Z. The s t r i n g s in the array r e p r e s e n t the Morse code f o r each l e t t e r or symbol. I f the l e t t e r i s not in Morse code a " i " f o r i g n o r e s e t s o f f a e r r o r. 15 char morselib [ ] = " s l s s l s ", " i ", " i ", " i ", " i ", " s l l l l s ", " l s l l s ", " l s l l s l ", " i ", " s l s l s ", " l l s s l l ", " l s s s s l ", " s l s l s l ", " l s s l s ", " l l l l l ", " s l l l l ", " s s l l l ", " s s s l l ", " s s s s l ", " s s s s s ", " l s s s s ", " l l s s s ", " l l l s s ", " l l l l s ", " l l l s s s ", " i ", " i ", " l s s s l ", " i ", " s s l l s s ", " s l l s l s ", " s l ", " l s s s ", " l s l s ", " l s s ", " s ", " s s l s ", " l l s ", " s s s s ", " s s ", " s l l l ", " l s l ", " s l s s ", " l l ", " l s ", " l l l ", " s l l s ", " l l s l ", " s l s ", " s s s ", " l ", " s s l ", " s s s l ", " s l l ", " l s s l ", " l s l l ", " l l s s " ; // Legend : """ "#" "$" "%" "&" " '" "(" ") " " " "+" "," " " ". " "/" "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" " : " " ; " "<" "=" ">" "?" "@" "A" "B" "C" "D" "E" "F" "G" "H" " I " "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S" "T" "U" "V" "W" "X" "Y" "Z" 17 void setup ( ) 19 pinmode ( greenled, OUTPUT) ; // Assigns output 12 f o r green LED f o r morse d i s p l a y. 21 pinmode ( redled, OUTPUT) ; // Assign output 13 f o r red LED f o r e r r o r d i s p l a y. S e r i a l. begin ( 9600 ) ; // Sets up s e r i a l port to communicate with arduino, speed 9600 b i t / s // S e r i a l l i s t e n e r, must be c a l l e d " loop ". 27 void loop ( ) 29 i f ( m i l l i s ( ) timer >= e r r o r t i m e ) // Stops the e r r o r d i s p l a y a f t e r the timer has f i n i s h e d. 31 d i g i t a l W r i t e ( redled, LOW ) ; 12

14 33 i f ( S e r i a l. a v a i l a b l e ( ) > 0 ) // I f t h e r e i s something to t r a n s l a t e, the symbol i s t r a n s l a t e d and d i s p l a y e d on the s e r i a l monitor. 35 s e r i a l i n p u t = toupper ( S e r i a l. read ( ) ) ; S e r i a l. p r i n t ( "\n Translating : " ) ; 37 S e r i a l. p r i n t l n ( s e r i a l i n p u t, 0) ; S e r i a l. p r i n t ( "Morse code : " ) ; 39 t r a n s l a t o r ( s e r i a l i n p u t ) ; S e r i a l. p r i n t ( "\ndot length in ms : " ) ; 41 S e r i a l. p r i n t l n ( ( analogread ( pot ) / s c a l e o f p u l s e ) + minpulse, 1) ; // Displays the length o f each dot, the lowest pulse length // Translator from s e r i a l input to ASCII values. ASCII t a b l e found here : http : / /www. a s c i i t a b l e. com. void t r a n s l a t o r ( char symbol ) 47 i n t index = symbol ' " ' ; // Locates the c o r r e c t array element by s u b t r a c t i n g the ASCII value 34 f o r " from the symbol ' s ASCII value. 49 char encoder = morselib [ index ] ; // Copies a s t r i n g from the morselib r e f e r e n c e array 51 i f ( symbol == ' ' ) // When a space between words i s entered in the s e r i a l monitor the f u n c t i o n space ( ) c r e a t e s a delay f o r 6 dots. The delay a f t e r each s hort or long i s 1 dot long to make the delay between words 7 dots long. 53 space ( ) ; return ; 55 e l s e i f ( index < 0 index > 56 ) // Makes sure only the scope o f the morselib r e f e r e n c e array i s used, from the ASCII values 34 to 9 0. Otherwise a e r r o r i s d i s p l a y e d. 57 e r r ( ) ; 59 return ; 61 f o r ( i n t i = 0 ; i < s t r l e n ( encoder ) ; i++ ) // A f o r loop that walks through each element o f the s t r i n g taken from the morselib r e f e r e n c e array. 63 i f ( encoder [ i ]== ' s ' ) // I f the s t r i n g element i s s the void f u n c t i o n sh ( ) i s s t a r t e d to d i s p l a y a dot ( a s hort s i g n a l ). 65 sh ( ) ; 67 e l s e i f ( encoder [ i ] == ' l ' ) // I f the s t r i n g element i s l the void f u n c t i o n l o ( ) i s s t a r t e d to d i s p l a y a dash ( a 3 dot long s i g n a l ). 69 l o ( ) ; 71 e l s e 73 e r r ( ) ; // I f the l e t t e r i s marked with a i f o r i g n o r e a e r r o r i s d i s p l a y e d l e t t e r s p a c e ( ) ; // Makes the space between each l e t t e r 3 dots long by adding 2 dots o f space a f t e r the one dot in sh ( ) and l o ( ). 13

15 79 81 // D e f i n i t i o n o f f u n c t i o n s void sh ( ) // Displays a short p u lse ( dot ). 83 i n t pulse = ( analogread ( pot ) / s c a l e o f p u l s e ) + minpulse ; // This v a r i a b l e c o n t r o l s the space length. 85 S e r i a l. p r i n t ( " Short " ) ; d i g i t a l W r i t e ( greenled, HIGH ) ; 87 delay ( p u lse ) ; d i g i t a l W r i t e ( greenled, LOW ) ; 89 delay ( p u lse ) ; 91 void l o ( ) // Displays a long pulse ( dash ). 93 i n t pulseon = ( 3 ( ( analogread ( pot ) / s c a l e o f p u l s e ) + minpulse ) ) ; 95 i n t p u l s e o f f = ( analogread ( pot ) / s c a l e o f p u l s e ) + minpulse ; S e r i a l. p r i n t ( "Long " ) ; 97 d i g i t a l W r i t e ( greenled, HIGH ) ; delay ( pulseon ) ; 99 d i g i t a l W r i t e ( greenled, LOW ) ; delay ( p u l s e o f f ) ; void e r r ( ) // Displays a e r r o r message and l i g h t s a red LED. 105 i n t pulse = ( 1 ( ( analogread ( pot ) / s c a l e o f p u l s e ) + minpulse ) ) ; S e r i a l. p r i n t ( " I n c o r r e c t input " ) ; 107 d i g i t a l W r i t e ( redled, HIGH ) ; timer = m i l l i s ( ) ; // S t a r t s a timer that counts u n t i l the e r r o r t i m e p r e s e t i s reached void l e t t e r s p a c e ( ) 113 i n t pulse = ( 2 ( ( analogread ( pot ) / s c a l e o f p u l s e ) + minpulse ) ) ; delay ( p u lse ) ; void space ( ) 119 i n t pulse = ( 6 ( ( analogread ( pot ) / s c a l e o f p u l s e ) + minpulse ) ) ; delay ( p u lse ) ; // End o f program 14

16 1 Decoder : i n t readpin = 1 2 ; 3 unsigned long duration ; 5 void setup ( ) 7 pinmode ( rea dpin, INPUT) ; S e r i a l. begin (9600) ; 9 11 void loop ( ) 13 duration = p u l s e I n ( readpin, HIGH, ) ; i f ( duration > 20000) 15 S e r i a l. p r i n t ( "\n Pulse [ us ] : " ) ; 17 S e r i a l. p r i n t ( duration ) ; Tests 1 Test1 : 3 This i s w r i tten i n t o the s e r i a l monitor : "#$%&'() +,../ :; <= >?@ABCDEFGHJKLMNOPQRSTUVWXYZ 2 4 See results in the gures below: Test2 : We typed SOS i n t o the s e r i a l port o f the encoder and t h i s i s what we read from the s e r i a l port on the decoder : Pulse [ us ] : Pulse [ us ] : Pulse [ us ] : Pulse [ us ] : Pulse [ us ] : Pulse [ us ] : Pulse [ us ] : Pulse [ us ] : Pulse [ us ] :

17 Figure 5: 16

18 Figure 6: 17