Remember the post we did earlier this year with the Ruby gem written by Jason Goecke called pamfaxr for sending and receiving faxes? Well we are excited to announce that there is a new Python library by Jonathan Sweemer to do the same thing! Here’s the source code on GitHub too!
Remember when the iPhone was only available on AT&T? That was true until October 11, 2009 when a young coder named geohot (and friends) released the first iPhone/iPod jailbreak. Suddenly iPhones weren’t tied to to just AT&T…now you could give AT&T the boot and choose Verizon or T-Mobile as your service provider. Score!
In the spirit of geohot’s jailbreaking efforts, the rapscallions at Disruptive Technologies took on the the task of “jailbreaking” OpenVBX.
OpenVBX is a web-based open source phone system. It’s essentially a virtual PHP/MySQL PBX and it’s available for download from GitHub. Users of OpenVBX can make phone calls, send text messages…all very cool.
The catch is…you’re locked into one service provider: Twilio. There’s no way to choose to use another cloud telephony provider…until now.
Today we’re pleased to announce a new fork of OpenVBX that adds support for Tropo. For the first time, users of OpenVBX will have a choice of multiple platforms on which to run it, making it REALLY OpenVBX.
The coders at Disruptive Technologies added full support for the the Tropo API and Phono SIP-based VoIP web phone to the communications layer of the OpenVBX project. Of course, when selecting the Tropo API, users will now get access to all of the more advanced features of the Tropo network: speech recognition and text-to-speech in 24 languages, phone numbers in over 40 countries, international SMS, in/outbound SIP VoIP support, inbound Skype support, multiple phone numbers per callflow script, improved conferencing.
Disruptive Technologies also extended OpenVBX with the VoiceVault API to support Voice Biometrics in password resets. After adding VoiceVault credentials on the API Accounts Tab, the password reset dialog will provide an option to request a phone call to reset your OpenVBX account password.
The OpenVBX fork with Tropo can be found on GitHub. We have sent the maintainer of the OpenVBX project a pull request to merge these updates into the project. The following features and bugfixes have been added to the OpenVBX package:
Fixed a redirect bug. OpenVBX no longer incorrectly redirects users to 404 pages.
Fixed bug in Twilio client. 60 seconds after the user has been “inactive”, the client is no longer able to be called for that user. This prevents calling the client if the user has closed their browser. (This also works for the Phono Client)
Added support for the Tropo API. You can now add a “Tropo API account” on the system settings page, and from the installer. Either a Tropo or Twilio account is required. Included in the new Tropo API additions are:
Support for Tropo domestic and international phone numbers, on the “numbers” page.
All applets in the “flows” page now support Tropo JSON as well as TwiML. Any number can be assigned any flow – so a tropo number and a twilio number can both be assigned the same flow.
Support for existing Tropo numbers & applications. If the user prefers to set up their numbers initially in Tropo.com, the application will see these numbers and they can be assigned a flow within the application.
Recordings, and Voicemail, as well as outbound dialing with Tropo.
Several theme changes. The OpenVBX logo has been modified to include both the Tropo and Twilio logo. If only one of the accounts is active, only that logo will show in the VBX logo – so if a user only has a Twilio account, only the Twilio logo will show, and vice versa. Other minor theme changes:
Several pages in the System Settings tabs have been reworked. Notibly the API accounts page, which now has each API accounts logos.
Step 3 of the installation has been reworked.
Several Twilio-specific content has been changed to be more ambiguous.
Added support for “Phono” browser phone, in addition to the Twilio Client. Any non-Twilio based numbers will use the new Phono browser phone.
This project has since been renamed to TropoVBX. Please refer to the updated blog post and new source code repository on GitHub.
I remember watching the movie Sneakers (probably 20 times) and would always rewind the part where they could unlock doors with their voice.
The technology, known as voice print identification or voice bio authorization, was demonstrated by the geek Werner Brandes when he utters the words, “My voice is my password. Verify me”, to gain entry to his high-tech office.
This has always sounded uber, geeky, cool to me and it’s been on my list of hacks to try out on Tropo but it looks like someone beat me to it!
The guys over at Disruptive Technologies recently wrote a blog post about Voice Biometrics with VoiceVault and Tropo! To simplify using the VoiceVault API, Disruptive Technologies created a PHP library that can be used with Tropo for both the enrollment and the verification of voices prints. The library is available on Github as part of their sample WordPress Plugin.
Their sample WordPress Plugin was developed to show you how voice biometrics can be used in real life. You can add it to any WordPress site to enhance the user Signup and Password Reset functionality with voice biometrics and Tropo!
If you want to checkout how the plugin works, first browse to this Sign Up Page and sign up for an account. You will receive a phone call asking you, a couple of times, to speak a 4 digit code, this is used to enroll your voice. After enrolling your voice you can call+1(818) 533-9824 to receive a new temporary password to login to WordPress. Make sure to call from the phone number you registered when you signed up for the WordPress account!
Image the communications apps that you could build using this technology! The future is now so what are you waiting for – add voice bio metrics to your apps today using Tropo and VoiceVault thanks to Disruptive Technologies!
One of the cool things about Tropo is that it’s not trapped in the cloud. Sometimes your cloud provider can go down. But fortunately as an open source project of Voxeo Labs, pretty much anyone can spin up their own private Tropo cloud. You can also run a hybrid cloud that leverages the best of both worlds. Yeah, Tropo is good like that.
We set out to prove that it could be done, so we decided to pick the most unlikely place we could think of to set up a private Tropo cloud: on the Playa at Burning Man (of course). Is it possible to set up an open-source telephone network in the middle of the desert? We’re going to find out next week.
We called up our friend David Burgess at Range Networks about the OpenBTS network he’s been setting up at Burning Man every year for the past 4 years. Along with David, we mapped out the technical details of how to connect Tropo to OpenBTS. We put together a team to work on integration and build a couple of Tropo apps to test on the Playa. Over the weekend I got this message:
[8/20/11 5:53:45 PM] Tim Panton: First call from openBTS via vsat out through tropo to the PSTN _WOOP_
So it looks like we *may* have some connectivity, but what can you DO with it?
Well, first and foremost we have an open source voiceboard app written by Chris Matthieu of Teleku and Nodester fame. The Voice Board application is an asynchronous voice messaging platform. It allows callers to join in on live conference calls or leave messages for their friends. Burners can connect to other Burners using the Voice Board app.
The other app was developed by Adam Kalsey (founder of IMIfied). It’s an SMS Gateway which is providing OpenBTS its first SMS gateway to the outside world. We didn’t want Burners to get bombarded with text messages from the outside world, so the gateway is set up to only receive messages AFTER someone has sent one FROM a phone connected through the OpenBTS network first.
Our “man on the ground” this year is Voxeo Labs Chief Architect, Jose De Castro, who volunteered to go to the playa at Burning Man and help set things up. In addition to the OpenBTS team, Jose will be joined onsite by Willow Brugh of Geeks without Bounds (who has assured me she will be at least “half naked most of the time“).
A parallel team working an app on the same OpenBTS network is being coordinated by the Technology and Infrastructure in Emerging Regions group at UC Berkley. More information about their project can be found here: TIER at Burning Man. Additionally, Aaron Huslage is also working in parallel with Ushahidi‘s open source crisis mapping software to ultimately build a very flexible and portable “crisis communications in a box” system.
The camp where we’ll be testing from is called Papa Legba. If you are heading to the Playa this year and would like like to participate in this groundbreaking test, I strongly urge you to check out the Papa Legba 2011 FAQ. Details about the kind of services and what kind of GSM phone equipment you need to connect to the OpenBTS network can be found there.
There are lots of reasons why you might want to collect a caller’s address over the phone.
In open government circles, there has been a lot of interest lately in using automated IVR systems to help gather non-emergency service requests for municipalities. This makes a lot of sense – many municipalities enable non-emergency service reporting through the use of a designated abbreviated dialing number – 3-1-1 – so there is a long history of reporting these issues using the telephone.
Address collection is used quite often in IVR systems, but typically relies on expensive proprietary or “black box” components that might not be suitable for all use cases. This is particularly true for municipalities and local governments who are under financial pressure and who need to do more with less.
In this post, I’ll show how to build a sophisticated address collection system that can be used for almost any city or town, large or small. All of the code for this example is on GitHub (and under active development) and many of the components I will use are free or open source.
Here is a screen cast demonstrating the system running on the Tropo platform.
How it works
The application demonstrated here relies on three primary ingredients:
A data source with all of the street names in a city (in this case, I used the San Francisco Basemap Street Centerlines file from DataSF.org)
A database that can store the data on street names and zip codes, and which can be queried to render a speech grammar. In this instance, I use CouchDB.
A telephony platform that supports speech recognition – in this case, Tropo.
The application is structured to ask the caller for a zip code – obtaining a zip code will help us constrain the number of choices in our speech grammar and help ensure a better recognition.
The application then builds an SRGS grammar in XML format using CouchDB’s view and list functions. This grammar contains a list of all of the streets in a particular zip code and allows a caller to add additional details, like house number and street direction (if applicable).
In the event that a successful match can’t be made (this is inevitable in some small percentage of calls), we ask the caller to say their full address and make a recording.
This recording can be transcribed after the call has ended to gather the caller’s address – this might be a manual step, or it could be automated using functionality provided by Tropo.
Building for the cloud
The example shown here is built to run on the Tropo cloud communication platform, and uses a cloud-based instance of CouchDB.
This same basic approach could be replicated with a more conventional architecture, and could also use a standard relational database (as I did in my previous post on this subject).
But using cloud-based components has a number of advantages that might be attractive to smaller governments that want to employ this approach, or even larger governments that face fiscal constraints or challenges.
Using a cloud-based platform like Tropo makes deployment and scaling easy. It also means that you get access to the latest and greatest technology to support the open specification for speech recognition grammars. The folks that work at Voxeo (the company behind Tropo) help write these standards.
Using CouchDB has a number of advantages too. Populating a CouchDB instance with street data is extremely easy with tools like shp2geocouch by Max Ogden. In addition, it’s actually pretty straightforward to write view and list functions to generate a speech grammar – after all it’s just JavaScript.
If you found this post and screen cast useful, head on over to the GitHub repo for this solution and sign on as a watcher – I’m going to be actively developing this with the goal of deploying it for a municipality in the near future.
Automated Speech Recognition (ASR) as-a-Service can be powered via Tropo and SIP using this simple open source code provided below. This service is perfect for adding speech recognition to your existing Asterisk, FreeSwitch, YATE, or enterprise app from the stone ages.
Here’s how it works!
You can transfer a phone call via SIP from a platform that doesn’t support ASR to Tropo along with the following SIP headers: prompt, choices, and returnaddress (SIP address). Tropo automatically answers the call and prompts the user the the text-to-speech (TTS) prompt passed. It automatically loads the ASR grammar with the choices passed. Upon successfully processing the speech recognition, Tropo transfers the call and the recognized result back to the return SIP adrress along with an x-voxeo-result SIP header containing your keyword spoken by the user.
Here’s the Tropo code using our hosted Scripting API:
This code is written in Ruby using our Tropo Scripting API. You can use $currentCall.getHeader to get the SIP headers passed to your Tropo application and you can send headers to other SIP applications using the Tropo transfer method. The speech recognition magic happens in the Ask method.
We used Phono, our browser-based webphone, to call Tropo and pass the prompt, choices, and returnaddress parameters.
phono.phone.dial("sip:9996106030@sip.tropo.com", {
headers: [
{
name:"returnaddress",
value: "sip:9996106032@sip.tropo.com" // you could use returnaddress var to send the results back to Phono's SIP address
},
{
name:"prompt",
value: "What is your favorite color?"
},
{
name:"choices",
value: "blue,green,red,yellow"
}
],
Just to prove that yet another SIP application could receive the speech recognition results, we created another Tropo application in Ruby using the Scripting API to simple say the results.
say "You said " + $currentCall.getHeader("x-voxeo-result")
This second test application would typically be omitted for a real application since the returnaddress would most likely be the originating SIP address of your switch to return to your original callflow. It’s cool that you could transfer to yet another application for additional processing!
What’s Next?
You can clone or fork this open source project on Github and use it today for as little as $.03 per minute for the Tropo call. Let us know if you would prefer for us to build this service out for commercial use.
We are always excited to see developers using Tropo to extend GoogleVoice functionality and features by adding things like SIP and Call Forwarding and Call-In enhancements. Terry Swanson (@FunnyBoy243) is one of these cool developers who wrote 2 of these extensions and opensourced them for others to share and contribute:
His Call Forwarding Extender Tropo Script includes the following features that extend/add to the current Google Voice feature-set:
Easy forwarding to SIP Numbers (especially compared to IPKall)
Outbound call recoding
Allows forwarding to numbers that cannot be verified through Google Voice (such as numbers with extensions). You can append “postd=DIGITSp” and/or “pause=WAITTIMEms” in the CALL_DEST variable to allow the script to forward to your extension. For example, “+14155551212;postd=ppppp1234pp56″ would dial (415) 555-1212 wait 5 seconds (1 second for each p) dial 1 2 3 4, wait 2 seconds then dial 5 6. Look enter the Parameters section of the Tropo API for more information.
You can have this script call multiple SIP/Telephone numbers at the same time by using an array for the CALL_DEST variable. All numbers will ring and the first to answer the call will take the call.
For step by step instructions, check out Terry’s original post here.
His Google Voice Call In Extender Tropo Script includes the following features that extend/add to the current Google Voice feature-set:
SIP Address for your Google Voice number.
Skype number for your Google Voice number.
Phone Number Aliases for your Google Voice number – You can have multiple phone numbers from different areas forward to the same Google Voice number so they wont have to pay long distance fees to call your Google Voice number.
Here are some additional tips and tricks with this extension:
You can have this script call multiple Google Voice numbers at the same time by using an array for the GV_NUM variable. All numbers will ring and the first to answer the call will take the call. Example: $GV_NUM = array(“5103364032″, “5103364002″);
You can add International Phone numbers to allow people from other countries to call your Google Voice number without paying International rates.
You can use the Skype number to make free telephone calls using Google Voice.
For step by step instructions, check out Terry’s original post here.
Do you have a GoogleVoice phone number? Would you like to route it to your Tropo application?
You can permanently port your GoogleVoice phone number to your Tropo application by submitting a ticket to our Provisioning team via the GetHelp link in the Tropo portal but I would like to show you how to temporarily route your GoogleVoice number to Tropo.
In this screencast, I use a few unnecessary (but fun) geeky apps like Skype (to place PSTN calls) and Blink (for receiving SIP calls). I also route my GoogleVoice number to @Zlu’sOpenVoice application. OpenVoice is an open source GoogleVoice clone that runs on Tropo and also integrates with our Phono webphone! It’s built using Ruby on Rails and its source code is available on Github at http://github.com/openvoice. (OpenVoice also has an Android app available so check it out!)
Add framework for “magic” channel variables. This supports things like CALLERID(all) vs. CALLERID(name) vs. CALLERID(num) that all have overlap in Asterisk. We now try to do the right thing when setting or reading each variation. More special variables can be easily added.
Enhanced Dial compatibility: Allow setting the CallerID on outbound calls, set DIALSTATUS based on Tropo response and clean up parsing of dial string
Set the default AGI port if unspecified in the YAML
Update to RSpec 2
Allow detecting the Tropo dialed number for incoming calls (agi_dnid)
Fix fatal missing error on SIP failover failure
Update unit tests for new functionality; fix broken unit tests
Rspec tests now require JRuby v1.5.x or better
You may grab the latest script from Github here. As a refresher, AGItate is a script that emulates the Asterisk AGI protocol on Tropo. Allowing you to use frameworks like Adhearsion or Asterisk-Java with Tropo.
We are also cooking up some interesting developments for the Adhearsion community with Ben, so stay tuned!
Ham radio or amateur radio communications has been around since the early 1900s. Ham radio technology has kept pace with traditional communications and may even be the only technology that allows people to communicate in natural disasters. Ham radio operators can communicate over very far distances using HF (high frequencies) as well as through satellites via AMSAT and even using VoIP over the Internet using EchoLink, IRLP, or D-STAR!
There are nearly 750,000 FCC licensed ham radio operators in the United States and over 3M licensed operators worldwide. Each operator has federally issued callsign that is used to uniquely identify the station operating on the band.
Using Tropo and Callook (Josh Dick’s W1JDD Callsign API), Chris Matthieu (N7ICE) was able quickly develop a speech recognition and text-to-speech based telephony app that is accessible by any of the following channels:
Upon calling the application, you are asked to spell a callsign using military phonetics:
A – Alfa, B – Bravo, C – Charlie, D – Delta, E – Echo, F – Foxtrot, G – Golf, H – Hotel, I – India, J – Juliet, K – Kilo, L – Lima, M – Mike, N – November, O – Oscar, P – Papa, Q – Quebec, R – Romeo, S – Sierra, T – Tango, U – Uniform, V – Victor, W – Whiskey, X – X-Ray, Y – Yankee, Z – Zulu
In addition to these commands, you can say restart to start over or stop if your callsign is entered correctly. Upon saying stop, the Tropo application does a REST-based call to Callook to get a JSON response of the data related to the callsign inquired. In addition to the communication channels listed above, Chris Matthieu was able to use his handheld hamradio (like the one featured above) to communicate using VHF (very high frequencies) to connect to a repeater nearly 50 miles away on a mountaintop and connect to Tropo via an auto-patch phone line to perform a callsign lookup. Here is a screencast and source code for the application!
Here is the source code running on Tropo’s Scripting API:
require 'rest_client'
require 'json'
answer
sleep 2
say "welcome to the tropo ham radio call sign lookup application"
callsign = ""
callsigntext = ""
loop do
result = ask "spell the callsign phonetically. say stop when done or restart to start over", {
:choices => "alpha, bravo, charlie, delta, echo, foxtrot, golf, hotel, india, juliette, kilo, lima, mike, november, oscar, papa, quebec, romeo, sierra, tango, uniform, victor, whiskey, xray, yankee, zulu, one, two, three, four, five, six, seven, eight, nine, zero, stop, restart"}
if result.value == "stop"
break
elsif result.value == "restart"
callsign = ""
callsigntext = ""
else
callsigntext = callsigntext + " " + result.value
say "so far you entered #{callsigntext}"
letter = case result.value
when "alpha" then "a"
when "bravo" then "b"
when "charlie" then "c"
when "delta" then "d"
when "echo" then "e"
when "foxtrot" then "f"
when "golf" then "g"
when "hotel" then "h"
when "india" then "i"
when "juliette" then "j"
when "kilo" then "k"
when "lima" then "l"
when "mike" then "m"
when "november" then "n"
when "oscar" then "o"
when "papa" then "p"
when "quebec" then "q"
when "romeo" then "r"
when "sierra" then "s"
when "tango" then "t"
when "uniform" then "u"
when "victor" then "v"
when "whiskey" then "w"
when "xray" then "x"
when "yankee" then "y"
when "zulu" then "z"
when "one" then "1"
when "two" then "2"
when "three" then "3"
when "four" then "4"
when "five" then "5"
when "six" then "6"
when "seven" then "7"
when "eight" then "8"
when "nine" then "9"
when "zero" then "0"
end
if letter
callsign = callsign + letter
end
end
end
response = RestClient.get 'http://callook.info/' + callsign + '/json'
data = JSON.parse(response)
say callsigntext + "belongs to "
say data["name"]
say "in " + data["address"]["line2"]
say "and holds a " + data["current"]["operClass"] + " license"