| # Copyright (c) 2013 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import fcntl |
| import glib |
| import logging |
| import os |
| import re |
| import termios |
| import tty |
| |
| import task_loop |
| |
| class ATChannel(object): |
| """ |
| Send a single AT command in either direction asynchronously. |
| |
| This class represents the AT command channel. The program can |
| (1) Request *one* AT command to be sent on the channel. |
| (2) Get notified of a received AT command. |
| |
| """ |
| |
| CHANNEL_READ_CHUNK_SIZE = 128 |
| |
| GLIB_CB_CONDITION_STR = { |
| glib.IO_IN: 'glib.IO_IN', |
| glib.IO_OUT: 'glib.IO_OUT', |
| glib.IO_PRI: 'glib.IO_PRI', |
| glib.IO_ERR: 'glib.IO_ERR', |
| glib.IO_HUP: 'glib.IO_HUP' |
| } |
| |
| # And exception with error code 11 is raised when a write to some file |
| # descriptor fails because the channel is full. |
| IO_ERROR_CHANNEL_FULL = 11 |
| |
| def __init__(self, receiver_callback, channel, channel_name='', |
| at_prefix='', at_suffix='\r\n'): |
| """ |
| @param receiver_callback: The callback function to be called when an AT |
| command is received over the channel. The signature of the |
| callback must be |
| |
| def receiver_callback(self, command) |
| |
| @param channel: The file descriptor for channel, as returned by e.g. |
| os.open(). |
| |
| @param channel_name: [Optional] Name of the channel to be used for |
| logging. |
| |
| @param at_prefix: AT commands sent out on this channel will be prefixed |
| with |at_prefix|. Default ''. |
| |
| @param at_suffix: AT commands sent out on this channel will be |
| terminated with |at_suffix|. Default '\r\n'. |
| |
| @raises IOError if some file operation on |channel| fails. |
| |
| """ |
| super(ATChannel, self).__init__() |
| assert receiver_callback and channel |
| |
| self._receiver_callback = receiver_callback |
| self._channel = channel |
| self._channel_name = channel_name |
| self._at_prefix = at_prefix |
| self._at_suffix = at_suffix |
| |
| self._logger = logging.getLogger(__name__) |
| self._task_loop = task_loop.get_instance() |
| self._received_command = '' # Used to store partially received command. |
| |
| flags = fcntl.fcntl(self._channel, fcntl.F_GETFL) |
| flags = flags | os.O_RDWR | os.O_NONBLOCK |
| fcntl.fcntl(self._channel, fcntl.F_SETFL, flags) |
| try: |
| tty.setraw(self._channel, tty.TCSANOW) |
| except termios.error as ttyerror: |
| raise IOError(ttyerror.args) |
| |
| # glib does not raise errors, merely prints to stderr. |
| # If we've come so far, assume channel is well behaved. |
| self._channel_cb_handler = glib.io_add_watch( |
| self._channel, |
| glib.IO_IN | glib.IO_PRI | glib.IO_ERR | glib.IO_HUP, |
| self._handle_channel_cb, |
| priority=glib.PRIORITY_HIGH) |
| |
| |
| @property |
| def at_prefix(self): |
| """ The string used to prefix AT commands sent on the channel. """ |
| return self._at_prefix |
| |
| |
| @at_prefix.setter |
| def at_prefix(self, value): |
| """ |
| Set the string to use to prefix AT commands. |
| |
| This can vary by the modem being used. |
| |
| @param value: The string prefix. |
| |
| """ |
| self._logger.debug('AT command prefix set to: |%s|', value) |
| self._at_prefix = value |
| |
| |
| @property |
| def at_suffix(self): |
| """ The string used to terminate AT commands sent on the channel. """ |
| return self._at_suffix |
| |
| |
| @at_suffix.setter |
| def at_suffix(self, value): |
| """ |
| Set the string to use to terminate AT commands. |
| |
| This can vary by the modem being used. |
| |
| @param value: The string terminator. |
| |
| """ |
| self._logger.debug('AT command suffix set to: |%s|', value) |
| self._at_suffix = value |
| |
| |
| def __del__(self): |
| glib.source_remove(self._channel_cb_handler) |
| |
| |
| def send(self, at_command): |
| """ |
| Send an AT command on the channel. |
| |
| @param at_command: The AT command to send. |
| |
| @return: True if send was successful, False if send failed because the |
| channel was full. |
| |
| @raises: OSError if send failed for any reason other than that the |
| channel was full. |
| |
| """ |
| at_command = self._prepare_for_send(at_command) |
| try: |
| os.write(self._channel, at_command) |
| except OSError as write_error: |
| if write_error.args[0] == self.IO_ERROR_CHANNEL_FULL: |
| self._logger.warning('%s Send Failed: |%s|', |
| self._channel_name, repr(at_command)) |
| return False |
| raise write_error |
| |
| self._logger.debug('%s Sent: |%s|', |
| self._channel_name, repr(at_command)) |
| return True |
| |
| |
| def _process_received_command(self): |
| """ |
| Process a command from the channel once it has been fully received. |
| |
| """ |
| self._logger.debug('%s Received: |%s|', |
| self._channel_name, repr(self._received_command)) |
| self._task_loop.post_task(self._receiver_callback, |
| self._received_command) |
| |
| |
| def _handle_channel_cb(self, channel, cb_condition): |
| """ |
| Callback used by the channel when there is any data to read. |
| |
| @param channel: The channel which issued the signal. |
| |
| @param cb_condition: one of glib.IO_* conditions that caused the signal. |
| |
| @return: True, so as to continue watching the channel for further |
| signals. |
| |
| """ |
| if channel != self._channel: |
| self._logger.warning('%s Signal received on unknown channel. ' |
| 'Expected: |%d|, obtained |%d|. Ignoring.', |
| self._channel_name, self._channel, channel) |
| return True |
| if cb_condition == glib.IO_IN or cb_condition == glib.IO_PRI: |
| self._read_channel() |
| return True |
| self._logger.warning('%s Unexpected cb condition %s received. Ignored.', |
| self._channel_name, |
| self.GLIB_CB_CONDITION_STR[cb_condition]) |
| return True |
| |
| |
| def _read_channel(self): |
| """ |
| Read data from channel when the channel indicates available data. |
| |
| """ |
| incoming_list = [] |
| try: |
| while True: |
| s = os.read(self._channel, self.CHANNEL_READ_CHUNK_SIZE) |
| if not s: |
| break |
| incoming_list.append(s) |
| except OSError as read_error: |
| if not read_error.args[0] == self.IO_ERROR_CHANNEL_FULL: |
| raise read_error |
| if not incoming_list: |
| return |
| incoming = ''.join(incoming_list) |
| if not incoming: |
| return |
| |
| # TODO(pprabhu) Currently, we split incoming AT commands on '\r' or |
| # '\n'. It may be that some modems that expect the terminator sequence |
| # to be '\r\n' send spurious '\r's on the channel. If so, we must ignore |
| # spurious '\r' or '\n'. |
| |
| # (1) replace ; by \rAT. |
| # ';' can be used to string together AT commands. |
| # So |
| # AT1;2 |
| # is the same as sending two commands: |
| # AT1 |
| # AT2 |
| incoming = re.sub(';', '\rAT', incoming) |
| |
| # (2) Replace any occurence of a terminator with '\r\r'. |
| # This ensures that splitting at the terminator actually gives us an |
| # empty part. viz -- |
| # 'some_string\nother_string' --> 'some_string\r\rother_string' |
| # --> ['some_string', '', 'other_string'] |
| # We use the empty string generated to detect completed commands. |
| incoming = re.sub('\r|\n|;', '\r\r', incoming) |
| |
| # (3) Split into AT commands. |
| parts = re.split('\r', incoming) |
| for part in parts: |
| if (not part) and self._received_command: |
| self._process_received_command() |
| self._received_command = '' |
| elif part: |
| self._received_command = self._received_command + part |
| |
| |
| def _prepare_for_send(self, command): |
| """ |
| Sanitize AT command before sending on channel. |
| |
| @param command: The command to sanitize. |
| |
| @reutrn: The sanitized command. |
| |
| """ |
| command = command.strip() |
| assert command.find('\r') == -1 |
| assert command.find('\n') == -1 |
| command = self.at_prefix + command + self.at_suffix |
| return command |
