ELECTRONICS - [Morse Code Typewriter] - [page 3/3]

16F628A Morse Code Typewriter

The Morse software

As you could probably guess, the software part is much more complicated than the hardware part. Basically our PIC's firmware need to do three things:

Constantly read the data from the keyboard by polling the data and clock lines.
It needs to translate the keyboard codes to ASCII character codes: The keyboard doesn't transmit ASCII characters, but the code of the key that was pressed. The software needs to translate this code to the corresponding ASCII character. There is a difficulty here: keyboards exists in different layouts like AZERTY or QWERTY.
It needs to translate the typed ASCII string to its Morse equivalent: a series of dashes and dots.

Polling the PS/2 keyboard

Polling a PS/2 keyboard turned out to be easy: the keyboard generates a clock pulse for each data bit. You can read a data bit when the clock goes from "1" to "0" (falling edge of the clock). 11 databits will form a word, containing: 1 startbit, 8 databits, 1 parity bit and 1 stop bit.

For most ASCII characters a single dataword is transmitted, but for the special characters two data words are transmitted. The keyboard also transmits a "release" code when the key is unpressed. So briefly pressing a key on the keyboard will return 2 words: the keyCode to indicate the key was pressed, and the release code to indicate the key was unpressed again.

The image below shows a typical signal you could measure on an oscilloscope. The blue signal represents the clock, while the red signal represents the data. This signal would decode as the hexadecimal code 0x23. You can verify this yourself: the least significant bit is transmitted first. So our real received data is the binary word 0b00100011, which translates to the hexadecimal 0x23.

The most obvious way to read data from a PS/2 keyboard is to use the external interrupt on the PIC: we can program the PIC microcontroller in a way so it generates an interrupt on the negative edge of the clock pulse (high to low). This way the PIC will never miss a press on the key, even if is currently occupied with something else (like playing the Morse Code).

The PS/2 keyboard clock frequence lies betwien 10 and 16.7 kHz. This is important to know because it's also the frequency of the external triggering on our microcontroller. At 16.7 kHz, an interrupt will be triggered every 59.8 microseconds. This is not a problem for our PIC: it runs on a high 20 MHz clock, 1 instruction cycle will take only 200 nanoseconds. We have plenty of time to execute our interrupt handler.

INFORMATION

The information above is a little bit simplified. A keyboard transmission typical has the following sequence:

The user presses a key: the keyCode of the pressed key is transmitted by the keyboard.
The keyboard will repeat this transmission as long as the key is pressed. The used interval depends on the keyboard's settings.
The user releases the key: the keyboard transmits a code to indicate the key is released. This is called the break code: 0xF0 followed by the keyCode of the key that was pressed.

It is even more complicated for special keys (like the arrow keys): Here the keyCode is preceded by the code 0xE0. So when releasing such key, three different datawords are transmitted: 0xE0, 0xF0, and the keycode of the key.

Translate the keyboard codes to ASCII characters

I already told the keyboard transmits key scan codes. They need to be translated to an ASCII code. I did a little trick by defining two different one-dimensional arrays (table) with data. They are called keyCode and ascii.

The keyCode array contains all keyboard codes that can be recognized by the program. During execution the program will search the location of the received keyCode in the table. Let's say the keyboard scanned the code 0x23: This is the fourth position in the keyCode array. Now the program will remember this position (4) and lookup the same position in the ASCII table. There we find the character D. This means the keyCode 0x23 corresponds with the letter D.

Earlier I explained a keyboard can exist in different layouts. A different keyboard layout will require a different keyCode array. Most of the hexadecimal numbers will remain the same, but some will switch place. An example are the codes that correspond with the letters A and Q. I defined 2 keyCode arrays in my PIC's firmware: 1 for AZERTY and 1 for QWERTY. You will need to uncomment the desired array.

Translate the ASCII characters to Morse code

The PIC also needs to translate between ASCII characters and Morse code. I have used a method that is similar to the method I just described: the program will search the position of the desired character and look for the corresponding Morse code in a third table.

The data inside this table is more complicated. Morse code is a series of 'marks', it can have only 2 possible values: a dot (.) or a dash (-). This is good because we can use the binary format to represent such code. A dot will be represented by the binary "0" while a dash is represented by the binary "1".

The Morse code for our letter D is '-..' (1 dash followed by two dots). We need three bits to represent this number. But the following letter, E, contains only a single dot ('.') so we only need a single bit to represent it: this means the Morse code's characters have a variable length!

So I had to find a way to store the length of each Morse character. A possible solution was to add another data array/table with the length of each character. Unfortunately our PIC doesn't have much space for data storage, this was a no-no. I then found another solution where the length of the Morse character is encoded into the Morse character itself. Let me explain this:

Most Morse characters only contain up to 5 marks (dashes or dots). We need 5 bits to represent such character. Inside the PIC microcontroller eight bits are reserved for each character, so we have 3 unused bits. I used these to encode the length of each character. The following image shows the binary Morse data for the letter D (hexadecimal 0x61).

The bits 5-7 are used to indicate the length of the Morse character: the binary 011 (decimal number 3). They indicate that our Morse character contains 3 marks: bits 0,1 and 2.

INFORMATION

Please note I simplified the information above. It turned out some of the special Morse characters had 6 signs so I had only 2 bits left to encode their length. In these cases I only used 2 bits to indicate the length of the character (bits 6 & 7): a more character has 6 marks when bit 6 & 7 are "1". Now the bit 5 is also used to store a mark.

I used an Excel sheet to calculate the hexadecimal numbers I have put in the Morse[] table. Download the Excel sheet. Warning: it is an Excel sheet with macros (I needed my own custom function to reverse the contents of a cell).

I now realize I have 'overcomplicated' the problem to decode my Morse characters. It was not necessary to encode the length of each character into this data. I could have used a 'start bit': This method uses the binary "1" to indicate the start of the code. The image below will illustrate this: bit 3 contains the startbit. This bit is no part of the Morse code. The Morse code begins right after this bit, only bits 0-2 are used for the actual code.

I won't change my program to implement this method. My program works fine and shows there are often multiple solutions to solve a certain programming problem.

The complete firmware

Here you can find the complete firmware for my project. It is written in High-Tech C.

The firmware is currently written for a PS/2 keyboard with an AZERTY layout, but you can easily convert it to a QWERTY layout. Each layout has its own array with keyboard data: const char keyCode[]. You need to comment/delete the version you don't need.

/************************************************************************** * Morse Code Generator * Copyright (c) 2012 Vanderhaegen Bart * * This PIC firmware can read a PS/2 keyboard. The typed text will appear * on an LCD screen. After the user presses enter, the typed text will be * played in morse code. * * The sound output is 1 kHz. This frequency is achieved by the PWM output * of the PIC MCP (16F628A). * **************************************************************************/ // include for the high-tech C environment #include <htc.h>; // Define the crystal speed #define _XTAL_FREQ 20000000 // Define the hardware I/O ports #define CLOCK RB0 #define DATA RB1 #define RS RB2 // RS word. 0=Instr, 1=Data #define CE RA1 // CE word. 0=disabled, 1=enabled #define LED_TEST RB3 #define LED RA0 // Additional definitions #define BUFFER_SIZE 11 #define true 1 #define false 0 #define MODE_DATA 1 #define MODE_CMD 0 // Define the morse code timings #define DOT 50 // time in milliseconds #define DASH 3*DOT #define PAUSE 5*DOT // Define the LCD properties #define LCD_DISP 0b00001000 #define LCD_DISPLAY_ON 0b00000100 #define LCD_DISPLAY_OFF 0b00000000 #define LCD_CURSOR_ON 0b00000010 #define LCD_CURSOR_OFF 0b00000000 #define LCD_BLINK_ON 0b00000001 #define LCD_BLINK_OFF 0b00000000 #define LCD_CLEAR 0b00000001 #define LCD_FUNCTIONSET 0b00100000 #define LCD_8BIT 0b00010000 #define LCD_4BIT 0b00000000 #define LCD_1LINE 0b00000000 #define LCD_2LINE 0b00001000 #define LCD_FONT_S 0b00000000 #define LCD_FONT_L 0b00000100 #define LCD_SETADDR 0b10000000 #define LCD_SHIFTMODE 0b00010000 #define LCD_SHIFTLEFT 0b00001000 #define LCD_SHIFTRIGHT 0b00000100 // Scancode unsigned int scanCode=0; unsigned char scanCodeCnt=0; unsigned char scanCodeBuf[6]; // morse code LCD buffer char morseBuffer[16]=""; char *morsePntr=morseBuffer; // define bits bit playStopRequested=false; bit isPlaying=false; // function prototypes void interrupt irq(); void writeFourbits(char data); void writeData(char data); void writeString(char *pMsg); void writeCommand(char data); void LCDbusy(); void LCDinitialize(); void main(); void writeFourbits(char data); void writeData(char data); void writeStringConstant(const char *pMsg); void writeCommand(char data); void LCDbusy(); void LCDinitialize(); void runPWM(); void clearPWM(); void showInputScreen(); char keycodeToAscii(char codeToFind); char AsciiToMorse(char charToFind); char bitCounter=0; /************************************************************************** * CODE TABLES * * Some explanation: I have used three different code tables which defines * all possible characters that can be entered. All tables should have the * same size. The data at each index of the table corresponds: keyboard * scancode 0x15 corresponds with 'A' or the morse data 0x42. *************************************************************************/ // ASCII character set const char ascii[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789;=.,?-: "; // KeyCode set /* // Querty keycode set: uncomment to activate this code const char keyCode[]={0x1C,0x32,0x21,0x23,0x24,0x2B,0x34,0x33,0x43,0x3B,0x42, 0x4B,0x3A,0x31,0x44,0x4D,0x15,0x2D,0x1B,0x2C,0x3C,0x2A, 0x1D,0x22,0x35,0x1A,0x45,0x16,0x1E,0x26,0x25,0x2E,0x36, 0x3D,0x3E,0x46,0x4C,0x55,0x49,0x41,0x05,0x7B,0x05,0x29,0x00}; */ // AZERTY keycode set. Comment to deactivate this code. const char keyCode[]={0x15,0x32,0x21,0x23,0x24,0x2B,0x34,0x33,0x43,0x3B,0x42, 0x4B,0x4C,0x31,0x44,0x4D,0x1C,0x2D,0x1B,0x2C,0x3C,0x2A, 0x1A,0x22,0x35,0x1D,0x45,0x16,0x1E,0x26,0x25,0x2E,0x36, 0x3D,0x3E,0x46,0x3A,0x55,0x49,0x41,0x05,0x7B,0x05,0x29,0x00}; // Morse Code Set const char morse[] = { 0x42,0x81,0x85,0x61,0x20,0x84,0x63,0x80,0x40,0x8E,0x65, 0x82,0x43,0x41,0x67,0x86,0x8B,0x62,0x60,0x21,0x64,0x88, 0x66,0x89,0x8D,0x83,0xBF,0xBE,0xBC,0xB8,0xB0,0xA0,0xA1, 0xA3,0xA7,0xDF,0xB5,0xB1,0xEA,0xF3,0xCC,0xE1,0xC7,0x01,0x00 }; /************************************************************************** * LCD Routines * * These routines are used to control the LCD module. You could use any * LCD module that uses the standard chipset. Some tuning of the * initialisation might be required, though. **************************************************************************/ // Create short LCD clock pulse void LCD_pulse() { CE=1; __delay_us(1); CE=0; } // Initialize the LCD module void LCDinitialize() { __delay_ms(20); // initial delay // Activate Command Mode RS=MODE_CMD; // Function set writeFourbits(LCD_FUNCTIONSET | LCD_8BIT); __delay_ms(5); writeFourbits(LCD_FUNCTIONSET | LCD_8BIT); __delay_us(100); writeFourbits(LCD_FUNCTIONSET | LCD_8BIT); __delay_us(100); // Start configuration writeCommand(LCD_FUNCTIONSET); writeCommand(LCD_FUNCTIONSET | LCD_4BIT | LCD_2LINE | LCD_FONT_S); __delay_us(100); writeCommand(LCD_DISP | LCD_DISPLAY_ON | LCD_CURSOR_ON | LCD_BLINK_ON); __delay_us(100); writeCommand(LCD_CLEAR); __delay_us(100); writeCommand(0x06); __delay_us(100); } // wait a few milliseconds so the LCD can process the command void LCDbusy() { __delay_ms(5); } // writeFourBits writes a sequence of 4 bits to the LCD void writeFourbits(char data) { PORTB=(PORTB&0x0F)|data; LCD_pulse(); } // writeData adds a character to the LCD void writeLCD(char data) { RS=MODE_DATA; writeFourbits(data&0xF0); writeFourbits((data&0x0F)<<4); LCDbusy(); } // writeData adds a character to the LCD void writeData(char data) { RS=MODE_DATA; writeFourbits(data&0xF0); writeFourbits((data&0x0F)<<4); LCDbusy(); } // writeCommand writes a command to the LCD void writeCommand(char data) { RS=MODE_CMD; writeFourbits(data&0xF0); writeFourbits((data&0x0F)<<4); LCDbusy(); } // writeFastCommand writes a command to the LCD // No delay is executed afterwards // !!! do not execute these commands too fast void writeFastCommand(char data) { RS=MODE_CMD; writeFourbits(data&0xF0); writeFourbits((data&0x0F)<<4); } // writeStringConstant writes a constant string to the LCD void writeStringConstant(const char *pMsg) { while(*pMsg!='\0') writeData(*pMsg++); } // writeLetter writes a single eltter to the LCD void writeLetter(char *pMsg) { writeData(*pMsg); } /************************************************************************** * Program Handlers * * Here you can find the helper functions that are needed to run the * program. **************************************************************************/ // updateBuffer() will refresh the screen information void updateBuffer() { // clear buffer writeCommand(LCD_CLEAR); char *pMsg=morseBuffer; while(*pMsg!='\0') writeData(*pMsg++); writeCommand(LCD_SETADDR | 0x40); const char lcd[]="Enter or ESC"; writeStringConstant(&lcd); writeCommand(LCD_SETADDR | (morsePntr-morseBuffer)); } // selftest executes the selftest void selfTest() { // initial texts const char line1[]="Starting Bart's"; const char line2[]="Morse Coder!"; // write them to the LCD writeCommand(LCD_SETADDR | 0x00); writeStringConstant(&line1); writeCommand(LCD_SETADDR | 0x40); writeStringConstant(&line2); // perform speaker runPWM(); LED=1; __delay_ms(1000); clearPWM(); LED=0; } // showPlayingMessage() shows a code is currently playing void showPlayingMessage() { writeCommand(LCD_SETADDR | 0x40); const char lcd[]="Playing code..."; writeStringConstant(&lcd); } // showInputScreen() shows the input screen void showInputScreen() { writeCommand(LCD_CLEAR); writeCommand(LCD_SETADDR | 0x40); const char lcd[]="Enter or ESC"; writeStringConstant(&lcd); writeCommand(LCD_SETADDR | 0x00); } // This function will convert a code from one unit to another unsigned char convertCode(char codeToFind,const char *source, const char *destination) { while(*source!=codeToFind && *source++>0x00) destination++; return *destination; } /************************************************************************** * Morse code player routines * * These routines are used to control the LCD module. You could use any * LCD module that uses the standard chipset. Some tuning of the * initialisation might be required, though. **************************************************************************/ // Play a dash void playDash() { runPWM(); LED=1; __delay_ms(DASH); LED=0; clearPWM(); } // Play a DOT void playDot() { runPWM(); LED=1; __delay_ms(DOT); LED=0; clearPWM(); } // Play a complete morse sequence void playMorse(char *buffer) { // set playing bits isPlaying=true; playStopRequested=false; // set LCD to the first position char position=0x00; while (*buffer>0x00 && !playStopRequested) { // set current LCD position writeFastCommand(LCD_SETADDR | position); char morseChar=convertCode(*buffer,ascii,morse); if (*buffer==' ') { __delay_ms(PAUSE); } else { // determine code size char size; if ((morseChar & 0xC0) == 0xC0) size=(morseChar & 0xC0) >> 5; else size=(morseChar & 0xE0) >> 5; // play code for (char i=0;i<size;i++) { if ((morseChar & 0x01) == 0x01) playDash(); else playDot(); morseChar>>=1; // wait the time of one dot until the following sign __delay_ms(DOT); } __delay_ms(DOT); __delay_ms(DOT); } position++; buffer++; } // clear the isPlaying flag isPlaying=false; } /************************************************************************** * Keyboard Processing Handler * * The sub processCode() is called as soon as a new databyte is received * by the keyboard. This routine might be called multiple times to form * a single character. **************************************************************************/ // this code will analyze the received data void processCode() { if ((*scanCodeBuf | 0x10) == 0xF0) { // release code or special character received: do nothing! __delay_ms(20); scanCodeCnt=0; } else { // normal character received char decoded = convertCode(*scanCodeBuf,keyCode,ascii); if (decoded!='\0') { // allowed morse code character received if ((morsePntr-morseBuffer)>(sizeof(morseBuffer)-1)) { // buffer full writeCommand(LCD_SETADDR | 0x40); const char lcd[]="Buffer full!"; writeStringConstant(lcd); } else { *morsePntr=decoded; morsePntr++; *morsePntr='\0'; writeLetter(&decoded); } } else { // other character received switch (*scanCodeBuf) { case 0x66: // backspace if (morsePntr>morseBuffer) { // clear current and previous character *morsePntr='\0'; morsePntr--; *morsePntr='\0'; } updateBuffer(); break; case 0x5A: // enter // ENTER showPlayingMessage(); __delay_ms(100); playMorse(morseBuffer); morsePntr=morseBuffer; *morsePntr='\0'; showInputScreen(); break; case 0x76: // ESCAPE morsePntr=morseBuffer; *morsePntr='\0'; updateBuffer(); break; } // end switch } // end if (decoded>0x00) __delay_ms(20); scanCodeCnt=0; } } /************************************************************************** * PWM Audio Controller * * These functions will start or stop the PIC's PWM output. **************************************************************************/ // setup PWM output : 1 kHz / 50 % duty cycle void runPWM() { CCP1CON=0b00111100; T2CON=0b00000111; CCPR1L=0x7C; PR2=0xFF; CCPR1L=0b01111111; TMR2ON=1; // doesn't need to be stopped afterwards } void clearPWM() { CCP1CON=0x00; CCPR1L=0x00; } /************************************************************************** * Interrupt Handler * * This interrupt handler will process the received data as soon as it * arrives. **************************************************************************/ void interrupt irq() { // check the interrupt source if (INTF==1) { if (isPlaying) { playStopRequested=true; } if (bitCounter<10) { // No 10 bits received yet: add to the scancode scanCode >>= 1; scanCode += (DATA*0b10000000000); bitCounter++; } else if(bitCounter==10){ // 10 bits received: process the code scanCodeBuf[scanCodeCnt] = (char)(scanCode >> 2); if (scanCodeCnt<sizeof(scanCodeBuf)) scanCodeCnt++; scanCode=0; bitCounter=0; } INTF=0; } } /************************************************************************** * Program's Main Sub * * Here the PIC program will begin working. **************************************************************************/ void main(void) { // setup IO configuration TRISB=0x03; TRISA=0x00; // setup IO values PORTB=0x00; PORTA=0x00; // set interrupt options INTEDG=0; // falling edge INTE=1; // enable interrupt INTF=0; // clear interrupt flag ei(); // enable interrupts // setup PWM output clearPWM(); // setup LCD module __delay_ms(100); LCDinitialize(); // selftest selfTest(); // Show the user input screen showInputScreen(); // clear the isPlaying bit isPlaying=0; // Execute the actual scanning process. This process will run // forever. This code actually belongs in an interrupt handler // but I didn't get that right yet. bitCounter=0; scanCode==0; scanCodeCnt=0; while(true) { if (scanCodeCnt>0) processCode(); } }

Possible Improvements

My firmware certainly needs some extra optimisations. Here are some things that still needs to be done:

Add an option to change the speed of the code. The speed could be selected by pressing one of the F1 ... F12 buttons.
The parity of the incoming keyboard data is ignored. This means that incorrect data won't be detected.
The software counts the number of received bits. Every eleventh bit, an incoming keycode is composed. The PIC could 'miss' an incoming bit. This would cause the PIC to mix parts of different keycodes into a single keycode. A possible solution is to use a timer that resets the bitcounter after a certain time-out.