Morse code: Difference between revisions

{{omit from|ML/I}}

 

[[wp:Morse_code|Morse code]] is one of the simplest and most versatile methods of telecommunication in existence.

 

 

from standard input until EOF is reached.

 

bits 16

;;; I/O ports

section .bss

buf: resb 1024 ; 1K buffer

 

=={{header|ABAP}}==

TYPES: BEGIN OF y_morse_code,

letter TYPE string,

ELSE LET prev = index - 1 IN to_upper( word+prev(1) ) ) ]-code OPTIONAL )

IN NEXT word_coded = |{ word_coded } { _morse_code }| ) ) ) )

 

=={{header|Ada}}==

 

Specification of the package :

 

type Symbols is (Nul, '-', '.', ' ');

others => (1, " ")); -- Dummy => Other characters do not need code.

 

use Ada, Ada.Strings, Ada.Strings.Maps, Interfaces;

 

Dit_ms := C.unsigned (Integer (Dit * 1000));

Dah_ms := C.unsigned (Integer (Dah * 1000));

Main program :

procedure Morse_Tx is

begin

Morsebeep (Convert ("Science sans Conscience"));

 

=={{header|AppleScript}}==

This caters for non-diacritical English letters, numerals, and the punctuation found on the Wikipedia page and makes a burping noise for anything else. The morse sounds brisker and smoother if the script's run as an application or from Script Menu rather than in Script Editor or Script Debugger.

 

use framework "Foundation"

use framework "AppKit"

 

-- Test code:

 

=={{header|Arturo}}==

str: "hello world 2019"

 

 

{{out}}

 

 

=={{header|AutoHotkey}}==

This function converts acceptable characters into dot-dash notation then uses SoundBeep to play them.

The frequency and element length are stored near the bottom of the script.

 

 

MorseBeep(passedString)

{

{

if (A_LoopField = ".")

If (A_LoopField = "-")

If (A_LoopField = " ")

 

=={{header|AWK}}==

AWK cannot play sounds by itself,

so here we just translate text to dits and dots:

BEGIN { FS="";

m="A.-B-...C-.-.D-..E.F..-.G--.H....I..J.---K-.-L.-..M--N-.";

printf("\n");

}

 

{{Out}} with input "sos sos titanic"

{{works with|GNU bash, version 4 + sox (optional)}}

 

#!/bin/bash

# michaeltd 2019-11-29 https://github.com/michaeltd/dots/blob/master/dot.files/.bashrc.d/.var/morse.sh

fi

 

{{out}} (input: sos titanic sos):

<pre>

Note that this will ''only'' work as-is under [[DOS]] (and [[Windows]] 9x); under NT systems, the <code>player</code> routine must be changed to use the <code>Beep</code> API call. ([http://www.freebasic.net/forum/viewtopic.php?p=20441#20441 This forum post] details how to use the speaker under Linux, DOS, and Windows in FreeBASIC; the Linux & DOS code differs further from the below by require inline assembly.)

 

 

'this determines the length of the notes

PLAY "p" + LTRIM$(STR$(noteLen))

NEXT i%

 

{{out}} (2 runs):

==={{header|BBC BASIC}}===

{{works with|BBC BASIC for Windows}}

DIM morse$(63)

FOR char% = 0 TO 63 : READ morse$(char%) : NEXT char%

DATA 33333,13333,11333,11133,11113,11111,31111,33111,33311,33331,333111,313131,6,31113,6,113311

DATA 133131,13,3111,3131,311,1,1131,331,1111,11,1333,313,1311,33,31,333

 

==={{header|IS-BASIC}}===

110 STRING TONE$(48 TO 90)*5,ST$*254

120 SET CHARACTER 46,0,0,0,0,24,24,0,0,0:SET CHARACTER 47,0,0,0,0,126,126,0,0,0

350 CLEAR FONT

360 DATA .////,..///,...//,..../,.....,/....,//...,///..,////.,/////,"","","","","","",""

 

=={{header|Befunge}}==

Since Befunge doesn't have a way to output sound, this implementation just generates a text representation of the morse. The string to convert is read from stdin.

 

^v('_')v!:-*57g+3/"!"\%"!":+1\-*<

^$$,*84_\#!:#:2#-%#15#\9#/*#2+#,<

'(&*&#$&&*'$&)'%'/'########6)##$%

1'-')&$$.''&2'&%$'%&0'#%%%#&,'''(

 

{{out}}

One could substitute another program for ubuntu beep command.

 

/*

 

return 0;

}

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

 

}

}

 

=={{header|C++}}==

/*

Michal Sikorski

}

 

 

=={{header|Clojure}}==

 

(defn play [sample-rate bs]

(apply concat ,)

byte-array

 

=={{header|CoffeeScript}}==

constructor : (@unit=0.05, @freq=700) ->

 

 

morse = new Morse()

 

=={{header|D}}==

import std.conv;

import std.stdio;

}

}

 

=={{header|Delphi}}==

program Morse;

 

Dictionary.Free;

end;

 

=={{header|EasyLang}}==

#

sleep 0.4

.

 

=={{header|EchoLisp}}==

(require 'json)

(require 'hash)

(else (writeln) (blink)))

(set! EMIT (rest EMIT))))

{{out}}

<pre>

 

=={{header|Elixir}}==

@morse %{"!" => "---.", "\"" => ".-..-.", "$" => "...-..-", "'" => ".----.",

"(" => "-.--.", ")" => "-.--.-", "+" => ".-.-.", "," => "--..--",

end

 

 

{{out}}

</pre>

 

open System

open System.Threading

 

send "Rosetta Code"

{{out}}

<pre>._. ___ ... . _ _ ._ _._. ___ _.. .</pre>

 

=={{header|Factor}}==

 

=={{header|Forth}}==

The Morse code generator could have taken the form of a look-up array with bit patterns cross referencing dits and dahs, but we instead used the Forth dictionary, which is functionally like a big case statement. By making each letter an executable routine in Forth we get a very succinct way to code our Morse. Proper sounding morse code requires precise time delays between the dits, dahs, letters and words. The program uses the Forth word "ms" which delays for n milliseconds and gives us real time control. This morse code sounds right.

There is a lot accomplished in 75 lines of code for a "low level" language.

HEX

\ PC speaker hardware control (requires GIVEIO or DOSBOX for windows operation)

 

PREVIOUS DEFINITIONS \ go back to previous namespace

 

Test at the Forth console

 

=={{header|FreeBASIC}}==

' FB 1.05.0 Win64

 

DyLibFree(library)

End

 

=={{header|Gambas}}==

 

Public Sub Main()

Next

 

Output (plus sound):

<pre>

=={{header|Go}}==

 

// showing the output on the console, and playing it as sound.

// Only works on ubuntu.

 

}

 

=={{header|Haskell}}==

 

The main program.

import System.IO

import MorseCode

text <- getContents

play $ toMorse text

 

The module to convert text to Morse code symbols.

module MorseCode (Morse, MSym(..), toMorse) where

 

fromChar = fromJust . flip M.lookup dict

weed = filter (\c -> c == ' ' || M.member c dict)

 

The module to interpret Morse code symbols as sound.

module MorsePlaySox (play) where

 

play :: Morse -> IO ExitCode

play = simple put none rate . concatMap toSamples

 

=={{header|J}}==

 

morse=:[:; [:(' ',~' .-' {~ 3&#.inv)&.> (_96{.".0 :0-.LF) {~ a.&i.@toupper

79 448 0 1121 0 0 484 214 644 0 151 692 608 455 205 242 161 134 125 122

 

onoffdur=: 0.01*100<.@*(1.2%[)*(4 4#:2 5 13){~' .-'i.]

 

Example use:

 

- .... .. ... .. ... .- -. . -..- .- -- .--. .-.. .

playmorse'this is an example'

1

12 playmorse'as is this'

 

morse converts from text to dot dash notation

=={{header|Java}}==

{{works with|java|7}}

 

public class MorseCode {

System.out.println("\n");

}

 

<pre>sos

This implementation utilises the fairly new Web Audio API in the browser for generating tones, as such it only uses one vendor implementation (WebKit). It is split into three modules; 1. translating the characters into morse code. 2. creating timings for the morse code. 3. creating tones with the timings.

 

var globalAudioContext = new webkitAudioContext();

 

return cont;

}

 

Usage:

 

morsecode('Hello World');

 

{{out}}

=={{header|Julia}}==

Requires a sound card and the PortAudio libraries.

 

const pstream = PortAudioStream(0, 2)

sendmorse("sos sos sos")

sendmorse("The case of letters in Morse coding is ignored."

 

=={{header|Kotlin}}==

Java does not have easy access to the beep method, so we need to create one using the Audio API it provides.

 

import javax.sound.sampled.AudioSystem

 

playMorseCode(toMorseCode(it.toLowerCase()))

}

 

=={{header|Liberty BASIC}}==

Input "Input the text to translate to Morse Code... "; string$

Print PlayMorse$(string$)

Data "@", ".--.-.", "(", "-.--.", ")", "-.--.-", "_", "..--.-", "$", "...-..-", "&", ".-..."

Data "=", "-...-", "!", "..--.", " ", " ", "End", ""

 

=={{header|Lua}}==

The following code is actual eLua code used to beep the speaker in Morse code n the Shenzhou III STM32F103ZET6 evaluation board. eLua is a Lua 5.1.4 implementation paired with libraries for low-level hardware access in embedded systems. The below code could easily be converted to any other Lua 5.n environment (including games), provided some kind of sound library has been installed. Only the functions buzz and pause would have to be modified.

 

 

-- module-local variables

init(50000)

 

 

Using this module is as simple as:

 

 

A Morse "codec" based on replacement rule programming.

Replacement rules also translate the text Morse code into audible Morse code.

The function, sonicMorse[s_String], plays the Morse code audio translation of a string.

 

mark = 0.1; gap = 0.125; (* gap should be equal to mark. But longer gap makes audio code easier to decode *)

shortgap = 3*gap; medgap = 7*gap;

morseCode[s_String] := StringReplace[ToLowerCase@s, codeRules~Join~{x_ /; FreeQ[Flatten@{Dictionary, " "}, x] -> "? "}]

morseDecode[s_String] := StringReplace[s, decodeRules]

 

{{out|Text example}}

This function will remove any characters not defined in the morse code.

 

 

%% Translate AlphaNumeric Text to Morse Text

end

 

{{out}} This will play the audio automatically, because the playSound argument is "true".

 

ans =

 

 

=={{header|Modula-2}}==

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

 

ReadChar;

 

=={{header|OCaml}}==

Using <code>/dev/dsp</code>:

 

'a', ".-"; 'b', "-..."; 'c', "-.-.";

'd', "-.."; 'e', "."; 'f', "..-.";

| _ -> prerr_endline "unknown char")

 

 

=={{header|Ol}}==

 

To simplify the example will be used only lower letter case.

(display "Please, enter the string in lower case bounded by \" sign: ")

(lfor

; <== "hello world"

; ==> ......-...-..--- .-----.-..-..-..

 

=={{header|PARI/GP}}==

while((ms-=gettime()) > 0,);

};

};

 

 

=={{header|Pascal}}==

This program uses OpenAL for cross-platform PCM audio.

 

{$mode delphi}

PROGRAM cw;

AlutExit();

END.

 

=={{header|Perl}}==

SetMorseVals(20,30,400);

SendMorseMsg('Hello World! abcdefg @\;'); # note, caps are ingnored in Morse Code

 

The above code requires:

 

=={{header|Phix}}==

 

=={{header|PicoLisp}}==

The following simply uses the 'beep' pc-speaker beeper utility.

 

(balance '*Morse

(wait (- *Dah *Dit)) ) )

 

 

=={{header|PL/I}}==

/* Sound Morse code via the PC buzzer. June 2011 */

MORSE: procedure options (main);

end send_morse;

 

 

=={{header|PowerShell}}==

This function is case insensitive, ignores all non-Morse characters and optionally displays the Morse code.

function Send-MorseCode

{

}

}

Send-MorseCode -Message "S.O.S" -ShowCode

{{Out}}

<pre>

... --- ...

</pre>

"S.O.S", "Goodbye, cruel world!" | Send-MorseCode -ShowCode

{{Out}}

<pre>

-.-. .-. ..- . .-..

.-- --- .-. .-.. -..

</pre>

 

=={{header|PureBasic}}==

#Frequence=1250

#Short = #BaseTime

Data.s "Done",""

EndOfMorseCode:

 

=={{header|Python}}==

 

char2morse = {

while True:

windowsmorse(input('A string to change into morse: '))

 

=={{header|Racket}}==

Using MIDI on Windows for the beeps.

#lang racket

(require ffi/unsafe ffi/unsafe/define)

 

(morse "Say something here")

 

=={{header|Raku}}==

Just read the output, leaving extra pauses where indicated

by either whitespace or underscore.

|<

! ---.

}

 

Sample run:

<p>Gimme a string: <b>Howdy, World!</b>

or "red.exe -r morse.red " to compile to single .exe file <br>

each character will be printed with its corresponding code before played

file: %morse.red ;; filename, could be ommited

]

morse-text "rosetta code"

morse-text "hello world"

file: %api.reds ;; filename, could be ommited

]

] [ wsleep duration ]

;;----------------------------------------------

 

=={{header|REXX}}==

 

=={{header|Ring}}==

 

strmorse = left(strmorse,len(strmorse)-1)

see strmorse + nl

Output:

<pre>

-|....|..|...| ..|...| .-| -|.|...|-| -|.|-..-|-

</pre>

 

=={{header|Ruby}}==

{{works with|Ruby|1.8.7+}} (uses <code>each_char</code>)

{{libheader|win32-utils}}

 

class MorseCode

 

MorseCode.new('sos').send

 

{{out}}

morse_code/src/main.rs file:

 

//!

//! morse_code/src/main.rs

}

}

 

morse_code/src/lib.rs file:

 

//!

//! morse_code/src/lib.rs

morse_map

}

 

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/9Dsd74J/1 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/68KAarvEQQafYevTkWaCWg Scastie (remote JVM)].

 

private val code = Map(

printMorse("Rosetta Code")

 

 

=={{header|sed}}==

Translation of AWK:

# Convert to uppercase

s/.*/\U&/

ta

# Remove lookup table

Example:

$ echo hello world! | ./morse.sed

 

=={{header|Tcl}}==

{{libheader|Snack}}

package require sound

set frequency 700

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

MODE DATA

mc=EXCHANGE (mc,space2split)

BEEP $mc

{{out}}

<pre>

=={{header|Ursa}}==

{{trans|Python}}

decl string<> chars

decl string<> morse

out "A string to change into morse: " console

encode_morse (in string console)

 

=={{header|VBA}}==

 

 

Private Declare Function Beep Lib "kernel32" (ByVal dwFreq As Long, ByVal dwDuration As Long) As Long

Sleep DELAY

Next i

{{out}}

Play the sound's morse and display :

{{works with|Visual Basic|6}}

The [[#VBA]] example works in VB6 as well, without any change.

 

=={{header|XPL0}}==

when its volume parameter is set to zero.

 

string 0; \use zero-terminated strings

 

CrLf(0);

Morse("Hello, world!");

{{out}}

<pre>

=={{header|Yabasic}}==

Mixin classic/modern style. In Yabasic, line number is not mandatory.

20 DIM c$(54)

30 FOR f = 1 TO 54

1070 DATA "'",".____.","!","_._.__","/","_.._.","(","_.__.",")","_.__._"

1080 DATA "&","._...",":","___...",";","_._._.","=","_..._","+","._._.","-","_...._"