`(12) Patent Application Publication (10) Pub. No.: US 2007/0169107 A1
`(43) Pub. Date:
`Jul. 19, 2007
`Huttunen
`
`US 20070169107A1
`
`(54) METHOD OF CONFIGURING PARAMETERS
`OF MACHINE-TO-MACHINE MODULE AND
`MACHINE-TO-MACHINE MODULE
`
`(30)
`
`Foreign Application Priority Data
`
`Jun. 25, 2003
`
`(F1) ........................................... .. 20030943
`
`(76) Inventor: Sampo Huttunen, Oulu (Fl)
`
`Correspondence Address:
`HollingsWorth & Funk
`Suite 125
`8009 34th Avenue South
`Minneapolis, MN 55425 (US)
`
`(21) Appl. No.:
`
`10/561,643
`
`(22) PCT Filed:
`
`Jun_ 1, 2004
`
`(86) PCT NO;
`
`pCT/FI04/00337
`
`§ 371(c)(1),
`(2), (4) Date:
`
`Sep. 14, 2006
`
`Publication Classi?cation
`
`(51) Int. Cl.
`(2006.01)
`G06F 9/445
`(52) US. Cl. ............................................................ ..717/174
`(57)
`ABSTRACT
`The invention relates to an M2M (machine-to-machine)
`module and to a method of con?guring parameters of an
`M2M module, the method comprising establishing a con
`nection between the M2M module and a server. The method
`comprises: downloading, to the M2M module, an applica
`_
`_
`_
`_
`_
`_
`tion havmg an applicatlon programming mterface (API) for
`con?guring the M2M module, the application being con?g
`ured to run on a Java virtual machine (JV M); communicat
`ing With the server by the application for receiving con?gu
`ration parameters; and setting the parameters of the M2M
`module by the application based on the received con?gura
`tion parameters.
`
`SERVER
`H8
`
`M2M
`modu|e
`1' n
`
`3005 GEN (SMS)
`
`302
`
`SENDING_SMS
`
`306
`SENDING__lM|et
`
`‘i
`
`310
`CALLING (CORBA_AP|)
`312
`SENDING_PARAM.
`
`_____ __
`
`304E CONFIGURING (PRELIM. PARAM.)
`
`‘ n u u p a n l
`
`308 DOWNLOADING IMIeT (JVM)
`‘_.___.
`
`314 SETI'ING_PARAMETERS
`
`q__
`
`Samsung, Exh. 1014, p. 1
`
`
`
`Patent Application Publication Jul. 19, 2007 Sheet 1 0f 2
`
`US 2007/0169107 Al
`
`F 116
`
`11s
`
`TCP/IP.
`
`'
`
`SERVER
`
`r 115
`NAME
`SERVER
`
`,- 114
`
`MZM
`GATEWAY.
`
`(-100
`
`Fig. 1
`
`Fig. 2
`
`WM MODULE r. 122
`126
`NM
`CONFIG
`
`GATEWAY
`
`Samsung, Exh. 1014, p. 2
`
`
`
`Patent Application Publication Jul. 19, 2007 Sheet 2 0f 2
`
`US 2007/0169107 A1
`
`WM
`module
`l' 0
`
`SERVER
`ll 8
`
`3005 GEN (SMS)
`
`‘ - - - - Q - I
`
`. . - . . . . . . . . . . . . . . . . 0.;
`
`SEN DING_SMS
`
`. . . . . . . - . . - . . . . . . . - ...|
`
`SENDlNG_lM|et
`
`3045
`CONFIGURING (PREUM. PARAM.)
`
`310
`‘ CALLING (CORBA_AP|)
`312
`SENDING_PARAM.
`
`308 DOWNLOADING IMIet (JVM)
`.___
`
`314 SETTING_PARAMETERS
`
`Fig. 3
`
`Samsung, Exh. 1014, p. 3
`
`
`
`US 2007/0169107 A1
`
`Jul. 19, 2007
`
`METHOD OF CONFIGURING PARAMETERS OF
`MACHINE-TO-MACHINE MODULE AND
`MACHINE-TO-MACHINE MODULE
`
`FIELD
`[0001] The invention relates to a method of con?guring
`parameters of a machine-to-machine (M2M) module and to
`a machine-to-machine module.
`
`BACKGROUND
`[0002] In Wireless data communications, machine-to-ma
`chine (M2M) solutions are currently being developed. M2M
`stands for machine-to-machine, mobile-to-machine, and
`machine-to-mobile. In mobile communications, M2M is
`about combining telecommunication and information tech
`nology; Wireless data is used to establish a link betWeen
`remote devices or locations and systems. By means of M2M
`solutions, processes can be automated, Which in turn
`increases ef?ciency, saves costs and provides better service
`levels. Typically, M2M solutions are created for collecting
`information, setting parameters, sending indications of
`unusual situations or taking care of an on-line transaction by
`means of a Wireless data connection. NeW M2M applica
`tions are continuously emerging and they may serve almost
`any environment (telemetry, telematics, home applications,
`public traf?c service, security and surveillance, telemedi
`cine, sales and payment, service and maintenance, industrial
`applications and ?eet management).
`[0003] M2M modules/terminals are con?gured With spe
`ci?c con?guration parameters. These parameters may be
`needed as usage parameters, for example. The parameters
`may be related to connectivity, such as an address to be
`connected (for example, IP address or phone number),
`authentication information, time-out values or bearer infor
`mation. NoWadays the M2M module con?guration is often
`done by hand and thus, the user enters the parameters into
`the M2M module, for example. Another possibility of con
`?guring the M2M module is to use smart messages that are
`communicated betWeen the M2M module and a server that
`delivers the con?guration parameters. The M2M module
`may, for example, ask for the con?guration parameters by
`sending an SMS (Short Message Service) message through
`a GSM (Global System for Mobile Communications) sys
`tem. The server then sends back a smart message including
`the con?guration parameters. It is also possible to con?gure
`the M2M module by dedicated con?guration softWare
`attached physically to the module or by connecting the M2M
`module to a computer With a cable connection, for example,
`and executing the con?guration by softWare on the com
`puter.
`[0004] HoWever, it is typical that the con?guration param
`eters vary from module to module so that different con?gu
`ration parameters are required for each module. In case there
`are large module populations, con?guration creates prob
`lems because in order to con?gure all the modules, a vast
`number of smart messages and con?guration application
`parameter settings need to be generated and delivered to the
`modules, for example. Further, a great amount of Work in
`form of needless visits to the modules, for example, is
`required to con?gure the modules correctly.
`
`BRIEF DESCRIPTION OF THE INVENTION
`[0005] An object of the invention is to provide an
`improved method of con?guring parameters of an M2M
`
`module and an improved M2M module. An aspect of the
`invention provides a method of con?guring parameters of an
`M2M (machine-to-machine) module, the method compris
`ing establishing a connection betWeen the M2M module and
`a server. The method of the invention comprises: doWnload
`ing, to the M2M module, an application having an interface
`for con?guring the M2M module, the application being
`con?gured to run on a Java virtual machine (JVM); com
`municating With the server by the application for receiving
`con?guration parameters; and setting the parameters of the
`M2M module by the application based on the received
`con?guration parameters.
`[0006] According to another aspect of the invention, there
`is provided an M2M (machine-to-machine) module, com
`prising: means for operating a Java virtual machine and
`means for establishing a connection betWeen the M2M
`module and a server. The M2M module of the invention is
`con?gured to: doWnload an application having an applica
`tion programming interface (API) for con?guring the M2M
`module, the application being con?gured to run on a Java
`virtual machine (JV M); communicate With the server by the
`application for receiving con?guration parameters; and set
`the parameters of the M2M module by the application based
`on the received con?guration parameters.
`
`[0007] Preferred embodiments of the invention are
`described in the dependent claims.
`[0008] The method and system of the invention provide
`several advantages. There is no need for manual con?gura
`tion of the M2M modules. Also, automated con?guration of
`a large module population becomes possible. In a preferred
`embodiment of the invention, there is no need to generate
`different smart messages or applications or different appli
`cation parameter settings for each individual module. The
`invention provides a centraliZed module con?guration, in
`Which a large module population is con?gured consistently
`or individually depending on the con?guration needs,
`becomes possible.
`
`LIST OF DRAWINGS
`
`[0009] In the folloWing, the invention Will be described in
`greater detail With reference to the preferred embodiments
`and the accompanying draWings, in Which
`
`[0010] FIG. 1 shoWs an example of a structure of a radio
`system;
`
`[0011] FIG. 2 illustrates a more detailed example of an
`M2M module in a radio system; and
`
`[0012] FIG. 3 is a signal sequence diagram illustrating the
`method of con?guring parameters of an M2M module in a
`radio system.
`
`DESCRIPTION OF EMBODIMENTS
`
`[0013] With reference to FIG. 1, examine an example of a
`radio system in Which the preferred embodiments of the
`invention can be applied. The radio system can be based on,
`for example, GSM (Global System for Mobile Communi
`cations) or WCDMA (Wide-band Code Division Multiple
`Access).
`[0014] The core netWork may correspond to the combined
`structure of the GSM (Global System for Mobile Commu
`nications) and GPRS (General Packet Radio Service) sys
`
`Samsung, Exh. 1014, p. 4
`
`
`
`US 2007/0169107 A1
`
`Jul. 19, 2007
`
`tems, for example. The GSM network elements are respon
`sible
`for
`the implementation of circuit-switched
`connections, and the GPRS network elements are respon
`sible for the implementation of packet-switched connec
`tions, some of the network elements, however, being shared
`by both systems.
`
`[0015] A centre 100 represents a mobile services switch
`ing centre (MSC) and a serving GPRS support node (SGSN)
`that enable circuit-switched and packet switched signalling,
`respectively, in the radio system. Because the centre 100 can
`control all the tra?ic in the radio system, the centre 100 can
`gather accounting information of each user, which account
`ing information may be used in billing.
`
`[0016] A core network may comprise a gateway unit 102,
`which is represented by a gateway mobile service switching
`centre (GMSC) and a gateway GPRS support node (GGSN).
`The GMSC attends to the circuit-switched connections
`between the core network and external networks, such as a
`public land mobile network (PLMN) or a public switched
`telephone network (PSTN), and the GGSN attends to the
`packet-switched connections between the core network and
`external networks, such as the Internet.
`
`[0017] The centre 100 controls a radio access network
`(RAN) 104, which may comprise at least one base station
`controller 106 controlling at least one base station 108. The
`base station controller 106 can also be called a radio network
`controller, and the base station 108 can be called node B.
`
`[0018] An M2M module 110 communicates with at least
`one base station 108 over a radio interface. The M2M
`module 110 comprises an interface for connecting to a
`remote device 112, for example. The M2M module 110 may
`also comprise a built-in SIM (Subscriber Identity Module)
`and an internal antenna. The remote device 112 may be a
`vending machine or an elevator, for example. Further, the
`remote device 112 may be any device that is related to
`security, automatic meter reading, industrial applications,
`cargo tracking, road traf?c information, traf?c control sys
`tems or telemedicine, for example.
`
`[0019] An M2M gateway 114 is a middleware for estab
`lishing wireless machine-to-machine applications. The
`M2M gateway 114 is used for bridging the GSM network
`and the Internet, for example, by providing a connection for
`two-way communication between applications located on a
`server 118 and within one or more remote devices 112. The
`M2M gateway 114 is based on open, widely accepted
`middleware and communication architecture CORBA
`(Common Object Request Broker Architecture).
`[0020] A server 118 may communicate with the radio
`system over a TCP/IP (transmission control protocol/Inter
`net protocol) 116, for example. The server 118 may be
`located on the Internet or in a company Intranet, for
`example. The server 118 is used for controlling the remote
`devices 112 in the radio system. If the remote device 112 is
`a vending machine, for example, then the company that
`maintains the vending machines may control the server 118.
`The M2M module 110 is used to communicate information
`between the server 118 and the remote device 112 and also
`to execute instructions given by the server 118, for example.
`For example, data about the number of product items present
`in the remote device 112 may be transferred to the server
`118. The server 118 in turn may send control commands to
`
`the remote device 112 in order to get the data it needs or to
`modify the settings of the device, for example.
`
`[0021] The M2M gateway 114 may communicate with a
`name server 115. The name server 115 is, for example, a
`CORBA name server that provides parameters on how to
`make method calls to the server 118 over the TCP/IP
`connection or to the M2M module 110.
`
`[0022] The present solution is generally described in FIG.
`2. The M2M module 110 in FIG. 2 comprises a Java virtual
`machine (JV M) 122, which is an abstract computer that
`provides an interface between a compiled Java binary code
`and the platform which actually performs the program
`instructions. In Java programming environments, there are
`application programs 120, such as applets, MIDlets and
`IMlets. The application program 120 is a small program
`designed to perform speci?c functions. Applications 120 use
`the services of the module’s operating system and other
`supporting applications. The means of communicating with
`other programs that the application 120 program uses is
`called the application program interface (API) 124.
`
`[0023] Wireless Java applications rely on Java 2 Platform,
`Micro Edition (J2ME), for example. The J2ME architecture
`de?nes con?gurations, pro?les and optional packages as
`elements for building Java environments that meet the
`requirements for a broad range of different devices. The
`con?gurations are composed of a virtual machine and a
`minimal set of class libraries. With the J2ME, applications
`are written once for a wide range of devices and can be
`downloaded dynamically. The J2ME applications are small
`programs that can be downloaded to the M2M module 110
`and then be executed in it.
`
`[0024] A J2ME application 120 implemented using an IM
`Pro?le, for example, is referred to as the IMlet, and it
`provides the user interface on the module. The J2ME
`application 120 communicates with a Java servlet, for
`example, usually via HTTP, and over a secure channel when
`necessary. The servlet interprets requests from the J2ME
`application 120, and in turn, dispatches client requests to
`EJB (Enterprise Java Beans architecture) components, for
`example. The IM Pro?le speci?cation provides a mechanism
`for J2ME applications 120 to persist and retrieve data. This
`storage mechanism, called Record Management System
`(RMS), is a simple, record-oriented database. Each record is
`stored and retrieved as an array of bytes. J 2ME applications
`120 may add, retrieve, and remove records from an RMS
`record store.
`
`[0025] In an embodiment of the invention, an application
`120, such as an IMlet, having an application-programming
`interface (API) for con?guring the M2M module, is down
`loaded to the M2M module 110, the application running on
`a Java virtual machine (JV M) 122. The downloaded appli
`cation 120 communicates with the radio system using a
`method call through CORBA API 124, for example, in order
`to receive con?guration parameters from the server 118. The
`application 120 may also communicate over a TCP/IP
`socket, for example. The parameters of the M2M module
`110 are set by the application 120 based on the received
`con?guration parameters.
`
`[0026] The application 120 is downloaded to the M2M
`module 110, to the Java virtual machine 122 over a cable,
`over an infrared connection or over-the-air (OTA), for
`
`Samsung, Exh. 1014, p. 5
`
`
`
`US 2007/0169107 A1
`
`Jul. 19, 2007
`
`example. Over-the-air downloading may also be initiated
`from outside of the M2M module 110, that is, from the M2M
`gateway 114 side. The application 120 may be triggered to
`run immediately after it has been doWnloaded to the M2M
`module 110, for example. Thus, the M2M module’s 110
`connection parameters may be fully con?gured by using the
`application 120 even if the M2M module 110 has not been
`con?gured at all after factory settings.
`
`[0027] In an embodiment of the invention, the application
`120 is a Java 2 Micro Edition (J2METM) application, such as
`a Java MIDlet or a Java IMlet. The application-program
`ming interface 124 may be provided by, for example, an
`ORB API (object request broker API), that is, a basic
`mechanism for making requests to and receiving responses
`from objects located locally or remotely. The ORB estab
`lishes the client-server relationship betWeen objects. For
`example, the CORBA is a standardised ORB architecture.
`
`[0028] The application 120 may comprise different com
`munication channels, such as I/O API, to communicate via
`the M2M module 110 pins, SMS API to provide SMS
`message communication With the GSM network, ORB API
`to communicate With the M2M gateWay, a module ORB or
`an AM ORB and a CLDC (Connected Limited Device
`Con?guration) API to be used With byte stream to socket
`connections, serial protocol to serial port connections and
`HTTP (hypertext transfer protocol) connections.
`
`[0029] The M2M module 110 comprises a con?guration
`block 126, in Which the application 120 sets the parameters
`to be con?gured, for example. The parameters to be con
`?gured may include usage parameters, such as passWords,
`user names, default connection settings, gateWay param
`eters, IP-addresses, used bit rates, connection time-outs or
`idle times, for example.
`
`[0030] The M2M module 110 may comprise an interface
`to connect to a remote device 112, such as a vending
`machine or an electricity meter reader, for example. The
`remote device 112 may then comprise an ORB (object
`request broker) module, such as an AM (Application Mod
`ule) ORB for communicating With the M2M module 110.
`
`[0031] In a case Where the remote device 112 is, for
`example, an electricity meter reader, it is feasible that the
`electricity meter reader should be checked several times a
`year, for example. It is possible that the readings of the
`electricity meter reader are sent periodically to the server
`118 of the electric company, for example. HoWever, if the
`electric company Wishes to change the meter reading peri
`ods, it is possible to con?gure the parameters that control
`these periods by using the described example of the method
`of the invention. Thus, also an automated con?guration of a
`large module population becomes possible Without the need
`to generate different J2ME applications 120 for each indi
`vidual M2M module 110.
`
`[0032] Let us next study the example of FIG. 3 of a
`method of con?guring parameters of an M2M module. In
`FIG. 3, the ?rst vertical line SERVER 118 denotes commu
`nication originating from and terminating in a server, the
`server being in a company Intranet or Internet, for example.
`The second vertical line M2M module 110 denotes commu
`nication of the M2M module and measures taken by the
`M2M module. The lines illustrated With dashed lines shoW
`optional steps of the method.
`
`[0033] This example illustrates a situation Where a neW
`M2M module 110 With no J2ME application for con?guring
`the M2M module is taken to use. In 300, in the server 118,
`a SMS message is generated, the SMS message comprising
`preliminary parameters for con?guring the M2M module.
`Such parameters may be parameters needed for establishing
`GPRS connections to the direction of the M2M gateWay, for
`example. Next in 302, the generated SMS message com
`prising the preliminary parameters is sent from the server
`118 to the M2M module 110. In 304, the M2M module 110
`con?gures the preliminary parameters that have been
`received With the SMS message. After the preliminary
`parameters have been con?gured in the M2M module, then,
`in 306, the server 118 is able to establish a CORBA
`connection betWeen the server 118 and the M2M module
`110 and to send a J2ME application to the M2M module 110
`by the CORBA connection. The J2ME application is called
`in this example an IMlet.
`
`[0034] In 108, the IMlet is doWnloaded to the M2M
`module 110 over the CORBA connection. The IMlet can be
`doWnloaded in other Ways to the M2M module as Well, such
`as over a cable from a computer or over an infrared
`connection, for example. Once the IMlet has been doWn
`loaded to the Java virtual machine operating in the M2M
`module, it can be used to con?gure parameters of the M2M
`module. It is also feasible that the IMlet has already been
`doWnloaded at the manufacturing stage. Thus, the method of
`this example may start in 310.
`
`[0035] In 310, the IMlet makes a CORBA method call
`through a CORBA API to the server 118 in order to receive
`con?guration parameters. Thus, the IMlet communicates
`With an application on the server behind the M2M gateWay
`by using CORBA messages. The IMlet may, for example,
`include a reference to a remote object on the server appli
`cation. The object reference has a stub method, Which is a
`stand-in for the method being called remotely. The stub is
`Wired into the ORB in a Way that the calling of it invokes the
`ORB’s connection capabilities and forWards the invocation
`to the server. On the server, the ORB uses a skeleton code
`to translate the remote invocation into a method call on the
`local object. The skeleton translates the call and any param
`eters and calls the method being invoked. When the method
`returns, the skeleton code transforms the results and sends
`them back to the IMlet via the ORBs. BetWeen the ORBs,
`communication proceeds by means of a shared protocol,
`Which is based on the standard TCP/IP Internet protocol. The
`IMlet may also communicate With the server 118 over
`TCP/IP connections, for example. Thus, the IMlet estab
`lishes a TCP/IP socket to a given IP address or a port and
`uses, for example, a HTTP protocol for doWnloading the
`required con?guration parameters.
`[0036] In 312, the con?guration parameters are sent from
`the server 118 to the IMlet. Then, in 314, the IMlet sets the
`parameters of the M2M module based on the received
`con?guration parameters.
`[0037] It is possible that, When in 306 the server 118 is
`sending the IMlet to the M2M terminal 110, the required
`con?guration parameters at that time are sent at the same
`time to the M2M terminal 110 With the IMlet.
`
`[0038] If the IMlet, in 308, is doWnloaded to the M2M
`module 110 at the manufacturing stage, then some or all of
`the M2M modules used in remote devices, for example, may
`
`Samsung, Exh. 1014, p. 6
`
`
`
`US 2007/0169107 A1
`
`Jul. 19, 2007
`
`have similar lMlets downloaded to each of them. Thus, as
`the M2M module is set to Work, the lMlet may automatically
`establish a connection to the server 118. Then, the lMlet may
`use the CORBA method call or a TCP/IP connection for
`establishing the connection to the server 118.
`
`[0039] In an embodiment, it is also possible that the server
`118 initiates the con?guration of the parameters by sending
`a control command comprising the con?guration parameters
`to the lMlet through the M2M gateWay. There may be a need
`to change some settings of the remote device in connection
`With the M2M module, for example, and the lMlet may be
`used to con?gure these settings of the remote device based
`on the con?guration parameters sent from theserver to the
`lMlet.
`
`[0040] Even though the invention is described above With
`reference to an example according to the accompanying
`draWings, it is clear that the invention is not restricted
`thereto but it can be modi?ed in several Ways Within the
`scope of the appended claims.
`
`1. A method of con?guring parameters of an M2M
`(machine-to-machine) module, the method comprising
`establishing a connection betWeen the M2M module and a
`server, characterized by the method comprising:
`(304) doWnloading, to the M2M module, an application
`having an interface for con?guring the M2M module,
`the application being con?gured to run on a Java virtual
`machine (JV M);
`(306, 308) communicating With the server by the appli
`cation for receiving con?guration parameters; and
`(310) setting the parameters of the M2M module by the
`application based on the received con?guration param
`eters.
`2. The method of claim 1, characterized in that the
`connection betWeen the M2M module and the server is
`established through a M2M gateWay or over a TCP/IP
`connection.
`3. The method of claim 1, characterized in that the
`communicating With the server comprises: requesting (306)
`con?guration parameters from the server and receiving
`(308), in the application, the con?guration parameters from
`the server.
`4. The method of claim 1, characterized by the application
`being a Java 2 Micro Edition (J2METM) application.
`5. The method of claim 3, characterized by the application
`being a Java MlDlet or a Java lMlet.
`6. The method of claim 1, characterized by the application
`being doWnloaded to the M2M module over a cable, over an
`infrared connection or over-the-air (OTA).
`7. The method of claim 1, characterized by the application
`programming interface being a Common Object Request
`Broker Architecture (CORBA) API.
`
`8. The method of claim 6, characterized by communicat
`ing With the server by making a method call through the
`CORBA API.
`9. The method of claim 1, characterized by using the
`M2M module (110) for con?guring parameters of a remote
`device based on the con?guration parameters received from
`the server.
`10. An M2M (machine-to-machine) module (110), com
`prising:
`
`means for operating a Java virtual machine (122) and
`means (124) for establishing a connection betWeen the
`M2M module (110) and a server (118), characterized
`by the M2M module (110) being con?gured to:
`
`doWnload an application (120) having an application
`programming interface (API) (124) for con?guring the
`M2M module, the application (120) being con?gured
`to run on a Java virtual machine (JVM) (122);
`
`communicate With the server (118) by the application
`(120) for receiving con?guration parameters; and
`
`set the parameters of the M2M module (110) by the
`application (120) based on the received con?guration
`parameters.
`11. The M2M module of claim 10, characterized in that
`the M2M module (110) is further con?gured to request, by
`the application, con?guration parameters from the server
`(118) and receiving, in the application, the con?guration
`parameters from the server (118).
`12. The M2M module of claim 10, characterized in that
`the application (120) is a Java 2 Micro Edition (J2METM)
`application.
`13. The M2M module of claim 10, characterized in that
`the application (120) is a Java MlDlet or a Java lMlet.
`14. The M2M module of claim 10, characterized in that
`the M2M module (110) is con?gured to doWnload the
`application (120) over a cable, over an infrared connection
`or over-the-air (OTA).
`15. The M2M module of claim 10, characterized in that
`the application-programming interface (124) is a Common
`Object Request Broker Architecture (CORBA) API.
`16. The M2M module of claim 15, characterized in that
`the M2M module (110) is con?gured to communicate With
`the server (118) by making a method call through the
`CORBA API (124).
`17. The M2M module of claim 10, characterized in that
`the M2M module (110) is used for con?guring parameters of
`a remote device (112) based on the con?guration parameters
`received from the server (118).
`
`Samsung, Exh. 1014, p. 7
`
`