00001
00002 /***************************************************************************
00003  *  SpeechRecognitionInterface.cpp - Fawkes BlackBoard Interface - SpeechRecognitionInterface
00004  *
00005  *  Templated created:   Thu Oct 12 10:49:19 2006
00006  *  Copyright  2009  Tim Niemueller and Masrur Doostdar
00007  *
00008  ****************************************************************************/
00009
00010 /*  This program is free software; you can redistribute it and/or modify
00011  *  it under the terms of the GNU General Public License as published by
00012  *  the Free Software Foundation; either version 2 of the License, or
00013  *  (at your option) any later version. A runtime exception applies to
00014  *  this software (see LICENSE.GPL_WRE file mentioned below for details).
00015  *
00016  *  This program is distributed in the hope that it will be useful,
00017  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00018  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019  *  GNU Library General Public License for more details.
00020  *
00021  *  Read the full text in the LICENSE.GPL_WRE file in the doc directory.
00022  */
00023
00024 #include <interfaces/SpeechRecognitionInterface.h>
00025
00026 #include <core/exceptions/software.h>
00027
00028 #include <cstring>
00029 #include <cstdlib>
00030
00031 namespace fawkes {
00032 
00033 /** @class SpeechRecognitionInterface <interfaces/SpeechRecognitionInterface.h>
00034  * SpeechRecognitionInterface Fawkes BlackBoard Interface.
00035  * 
00036       The interface provides access to a spech recognition facility.
00037     
00038  * @ingroup FawkesInterfaces
00039  */
00040
00041
00042 
00043 /** Constructor */
00044 SpeechRecognitionInterface::SpeechRecognitionInterface() : Interface()
00045 {
00046   data_size = sizeof(SpeechRecognitionInterface_data_t);
00047   data_ptr  = malloc(data_size);
00048   data      = (SpeechRecognitionInterface_data_t *)data_ptr;
00049   memset(data_ptr, 0, data_size);
00050   add_fieldinfo(IFT_STRING, "text", 1024, data->text);
00051   add_fieldinfo(IFT_UINT, "counter", 1, &data->counter);
00052   add_fieldinfo(IFT_BOOL, "processing", 1, &data->processing);
00053   add_fieldinfo(IFT_BOOL, "enabled", 1, &data->enabled);
00054   add_messageinfo("ResetMessage");
00055   add_messageinfo("SetEnabledMessage");
00056   unsigned char tmp_hash[] = {0xf8, 0x2c, 0xa4, 0x4f, 0xef, 0xc9, 0xa1, 0x57, 0xe2, 0x9a, 0x10, 0xe, 0xa5, 0x5c, 0x62, 0x84};
00057   set_hash(tmp_hash);
00058 }
00059 
00060 /** Destructor */
00061 SpeechRecognitionInterface::~SpeechRecognitionInterface()
00062 {
00063   free(data_ptr);
00064 }
00065 /* Methods */
00066 /** Get text value.
00067  * 
00068       Last spoken string. Must be properly null-terminated.
00069     
00070  * @return text value
00071  */
00072 char *
00073 SpeechRecognitionInterface::text() const
00074 {
00075   return data->text;
00076 }
00077 
00078 /** Get maximum length of text value.
00079  * @return length of text value, can be length of the array or number of 
00080  * maximum number of characters for a string
00081  */
00082 size_t
00083 SpeechRecognitionInterface::maxlenof_text() const
00084 {
00085   return 1024;
00086 }
00087 
00088 /** Set text value.
00089  * 
00090       Last spoken string. Must be properly null-terminated.
00091     
00092  * @param new_text new text value
00093  */
00094 void
00095 SpeechRecognitionInterface::set_text(const char * new_text)
00096 {
00097   strncpy(data->text, new_text, sizeof(data->text));
00098 }
00099 
00100 /** Get counter value.
00101  * 
00102       Counter for messages. Increased after each new recognized string.
00103     
00104  * @return counter value
00105  */
00106 unsigned int
00107 SpeechRecognitionInterface::counter() const
00108 {
00109   return data->counter;
00110 }
00111 
00112 /** Get maximum length of counter value.
00113  * @return length of counter value, can be length of the array or number of 
00114  * maximum number of characters for a string
00115  */
00116 size_t
00117 SpeechRecognitionInterface::maxlenof_counter() const
00118 {
00119   return 1;
00120 }
00121 
00122 /** Set counter value.
00123  * 
00124       Counter for messages. Increased after each new recognized string.
00125     
00126  * @param new_counter new counter value
00127  */
00128 void
00129 SpeechRecognitionInterface::set_counter(const unsigned int new_counter)
00130 {
00131   data->counter = new_counter;
00132 }
00133 
00134 /** Get processing value.
00135  * 
00136       True, if the the speech recognition is currently processing.
00137     
00138  * @return processing value
00139  */
00140 bool
00141 SpeechRecognitionInterface::is_processing() const
00142 {
00143   return data->processing;
00144 }
00145 
00146 /** Get maximum length of processing value.
00147  * @return length of processing value, can be length of the array or number of 
00148  * maximum number of characters for a string
00149  */
00150 size_t
00151 SpeechRecognitionInterface::maxlenof_processing() const
00152 {
00153   return 1;
00154 }
00155 
00156 /** Set processing value.
00157  * 
00158       True, if the the speech recognition is currently processing.
00159     
00160  * @param new_processing new processing value
00161  */
00162 void
00163 SpeechRecognitionInterface::set_processing(const bool new_processing)
00164 {
00165   data->processing = new_processing;
00166 }
00167 
00168 /** Get enabled value.
00169  * 
00170       True, if speech processing is currently enabled, false otherwise.
00171     
00172  * @return enabled value
00173  */
00174 bool
00175 SpeechRecognitionInterface::is_enabled() const
00176 {
00177   return data->enabled;
00178 }
00179 
00180 /** Get maximum length of enabled value.
00181  * @return length of enabled value, can be length of the array or number of 
00182  * maximum number of characters for a string
00183  */
00184 size_t
00185 SpeechRecognitionInterface::maxlenof_enabled() const
00186 {
00187   return 1;
00188 }
00189 
00190 /** Set enabled value.
00191  * 
00192       True, if speech processing is currently enabled, false otherwise.
00193     
00194  * @param new_enabled new enabled value
00195  */
00196 void
00197 SpeechRecognitionInterface::set_enabled(const bool new_enabled)
00198 {
00199   data->enabled = new_enabled;
00200 }
00201
00202 /* =========== message create =========== */
00203 Message *
00204 SpeechRecognitionInterface::create_message(const char *type) const
00205 {
00206   if ( strncmp("ResetMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00207     return new ResetMessage();
00208   } else if ( strncmp("SetEnabledMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00209     return new SetEnabledMessage();
00210   } else {
00211     throw UnknownTypeException("The given type '%s' does not match any known "
00212                                "message type for this interface type.", type);
00213   }
00214 }
00215
00216 
00217 /** Copy values from other interface.
00218  * @param other other interface to copy values from
00219  */
00220 void
00221 SpeechRecognitionInterface::copy_values(const Interface *other)
00222 {
00223   const SpeechRecognitionInterface *oi = dynamic_cast<const SpeechRecognitionInterface *>(other);
00224   if (oi == NULL) {
00225     throw TypeMismatchException("Can only copy values from interface of same type (%s vs. %s)",
00226                                 type(), other->type());
00227   }
00228   memcpy(data, oi->data, sizeof(SpeechRecognitionInterface_data_t));
00229 }
00230
00231 /* =========== messages =========== */
00232 /** @class SpeechRecognitionInterface::ResetMessage <interfaces/SpeechRecognitionInterface.h>
00233  * ResetMessage Fawkes BlackBoard Interface Message.
00234  * 
00235     
00236  */
00237
00238 
00239 /** Constructor */
00240 SpeechRecognitionInterface::ResetMessage::ResetMessage() : Message("ResetMessage")
00241 {
00242   data_size = 0;
00243   data_ptr  = NULL;
00244 }
00245 
00246 /** Destructor */
00247 SpeechRecognitionInterface::ResetMessage::~ResetMessage()
00248 {
00249 }
00250 
00251 /** Copy constructor.
00252  * @param m message to copy from
00253  */
00254 SpeechRecognitionInterface::ResetMessage::ResetMessage(const ResetMessage *m) : Message("ResetMessage")
00255 {
00256   data_size = 0;
00257   data_ptr  = NULL;
00258 }
00259
00260 /* Methods */
00261 /** Clone this message.
00262  * Produces a message of the same type as this message and copies the
00263  * data to the new message.
00264  * @return clone of this message
00265  */
00266 Message *
00267 SpeechRecognitionInterface::ResetMessage::clone() const
00268 {
00269   return new SpeechRecognitionInterface::ResetMessage(this);
00270 }
00271 /** @class SpeechRecognitionInterface::SetEnabledMessage <interfaces/SpeechRecognitionInterface.h>
00272  * SetEnabledMessage Fawkes BlackBoard Interface Message.
00273  * 
00274     
00275  */
00276
00277 
00278 /** Constructor with initial values.
00279  * @param ini_enabled initial value for enabled
00280  */
00281 SpeechRecognitionInterface::SetEnabledMessage::SetEnabledMessage(const bool ini_enabled) : Message("SetEnabledMessage")
00282 {
00283   data_size = sizeof(SetEnabledMessage_data_t);
00284   data_ptr  = malloc(data_size);
00285   memset(data_ptr, 0, data_size);
00286   data      = (SetEnabledMessage_data_t *)data_ptr;
00287   data->enabled = ini_enabled;
00288   add_fieldinfo(IFT_BOOL, "enabled", 1, &data->enabled);
00289 }
00290 /** Constructor */
00291 SpeechRecognitionInterface::SetEnabledMessage::SetEnabledMessage() : Message("SetEnabledMessage")
00292 {
00293   data_size = sizeof(SetEnabledMessage_data_t);
00294   data_ptr  = malloc(data_size);
00295   memset(data_ptr, 0, data_size);
00296   data      = (SetEnabledMessage_data_t *)data_ptr;
00297   add_fieldinfo(IFT_BOOL, "enabled", 1, &data->enabled);
00298 }
00299 
00300 /** Destructor */
00301 SpeechRecognitionInterface::SetEnabledMessage::~SetEnabledMessage()
00302 {
00303   free(data_ptr);
00304 }
00305 
00306 /** Copy constructor.
00307  * @param m message to copy from
00308  */
00309 SpeechRecognitionInterface::SetEnabledMessage::SetEnabledMessage(const SetEnabledMessage *m) : Message("SetEnabledMessage")
00310 {
00311   data_size = m->data_size;
00312   data_ptr  = malloc(data_size);
00313   memcpy(data_ptr, m->data_ptr, data_size);
00314   data      = (SetEnabledMessage_data_t *)data_ptr;
00315 }
00316
00317 /* Methods */
00318 /** Get enabled value.
00319  * 
00320       True, if speech processing is currently enabled, false otherwise.
00321     
00322  * @return enabled value
00323  */
00324 bool
00325 SpeechRecognitionInterface::SetEnabledMessage::is_enabled() const
00326 {
00327   return data->enabled;
00328 }
00329 
00330 /** Get maximum length of enabled value.
00331  * @return length of enabled value, can be length of the array or number of 
00332  * maximum number of characters for a string
00333  */
00334 size_t
00335 SpeechRecognitionInterface::SetEnabledMessage::maxlenof_enabled() const
00336 {
00337   return 1;
00338 }
00339 
00340 /** Set enabled value.
00341  * 
00342       True, if speech processing is currently enabled, false otherwise.
00343     
00344  * @param new_enabled new enabled value
00345  */
00346 void
00347 SpeechRecognitionInterface::SetEnabledMessage::set_enabled(const bool new_enabled)
00348 {
00349   data->enabled = new_enabled;
00350 }
00351 
00352 /** Clone this message.
00353  * Produces a message of the same type as this message and copies the
00354  * data to the new message.
00355  * @return clone of this message
00356  */
00357 Message *
00358 SpeechRecognitionInterface::SetEnabledMessage::clone() const
00359 {
00360   return new SpeechRecognitionInterface::SetEnabledMessage(this);
00361 }
00362 /** Check if message is valid and can be enqueued.
00363  * @param message Message to check
00364  */
00365 bool
00366 SpeechRecognitionInterface::message_valid(const Message *message) const
00367 {
00368   const ResetMessage *m0 = dynamic_cast<const ResetMessage *>(message);
00369   if ( m0 != NULL ) {
00370     return true;
00371   }
00372   const SetEnabledMessage *m1 = dynamic_cast<const SetEnabledMessage *>(message);
00373   if ( m1 != NULL ) {
00374     return true;
00375   }
00376   return false;
00377 }
00378 
00379 /// @cond INTERNALS
00380 EXPORT_INTERFACE(SpeechRecognitionInterface)
00381 /// @endcond
00382 
00383
00384 } // end namespace fawkes