Morse code: Difference between revisions

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|Action!}}==

DEFINE COUNT="$60"

Process("Atari Action!")

Process("www.rosettacode.org")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Morse_code.png Screenshot from Atari 8-bit computer]

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}}==

code: #[

]

{{out}}

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

It uses the short form of if else that is implemented, to not have such a long script

MorseBeep(teststring) ;Beeps our string after conversion

return ;End Auto-Execute Section

} ;Spaces are extended. Sleep pauses the script

return morse ;Returns the text in morse code

=={{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|Commodore BASIC}}===

{{works with|Commodore BASIC|7.0}}

some of its structured programming features, such as DO...LOOP and BEGIN...BEND.</p>

110 DA$="Q.A": REM DA = DOTTED QUARTER NOTE

120 IS$="IR" : REM SPACE BETWEEN SYMS=1xDOT

620 DATA ".",".-.-.-", ",","--..--"

630 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}}==

#

chars$[] = strchars "abcdefghijklmnopqrstuvwxyz "

for ch$ in strchars txt$

call morse ch$

=={{header|EchoLisp}}==

(require 'json)

(require 'hash)

(else (writeln) (blink)))

(set! EMIT (rest EMIT))))

{{out}}

<pre>

=={{header|Elixir}}==

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

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

end

{{out}}

=={{header|F_Sharp|F#}}==

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

When compiled with FB, this code produces a packaged, stand-alone 64-bit application that will run on either Intel or the newer M-series Macs. It translates a text string into Morse Code and plays back characters along with their respective sounds. The oscillator frequency and volume, along with letter and word spacing, can be adjusted with the definitions at the head of the file. While the code meets the Rosetta Code parameters, it's by no means exhaustive. For instance, it does not include translation of punctuation or prosigns, and the GUI is minimal. It's simply a proof of concept. It's been tested on Catalina (10.15.x) to Monterey (12.4.x) with Ventura still in beta at the time of this post. The free FB compiler is available on the

[http://www.brilorsoftware.com/fb/pages/home.html FutureBasic] home page.

include "Tlbx AVKit.incl"

HandleEvents

{{output}}

<pre>

=={{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:

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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|Nim}}==

Text mode only. The text to translate is provided in the command line.

const Morse = {'A': ".-", 'B': "-...", 'C': "-.-.", 'D': "-..", 'E': ".",

for arg in commandLineParams():

m.add morse(arg)

{{out}}

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:

{{libheader|Phix/online}}

You can run this online [http://phix.x10.mx/p2js/Morse_code.htm here].

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Morse_code.exw

<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

=={{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>

=={{header|Prolog}}==

Runs in SWI Prolog, Edinburgh syntax

% convert text to morse

% query text2morse(Text, Morse)

morse('-', "-....-").

morse('@', ".--.-.").

text2morse("Hello World", Morse).

{{Out}}

<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>

{{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 :

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Sub Main()

End Sub

=={{header|Wren}}==

Any characters which do not appear in the Morse alphabet are simply ignored.

import "/sound" for Wav

}

}

{{out}}

It's also possible to play .wav files which (preferably) have a sample rate of 44.1 kHz using DOME:

{{libheader|DOME}}

class Main {

}

=={{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 "&","._...",":","___...",";","_._._.","=","_..._","+","._._.","-","_...._"