At Vela, Simone Gorrindo contemplates “the terrible thing that the slowness of pain gives you: time” in this meditation on how chronic illness affects the body and mind.
Source: Coexisting With the Void: Simone Gorrindo on Chronic Pain
Author Archives: Techkhabarsite
Fuzzy Logic Control in Autonomous Robotics:
(Pure Extraction)
Fuzzy Logic Control in Autonomous Robotics:
Investigating the Motorola MC68HC12 on a Line Following Robot
David Olsen
Department of Electrical and Computer Engineering
University of Minnesota Duluth
1023 University Drive
Duluth, MN 55812. USA
Faculty Advisor: Dr. Marian S. Stachowicz
Abstract
Autonomous robot systems require complex control systems. Fuzzy Logic, a mathematical system developed by Professor Lotfi Zadeh, helps to reduce the complexity of modeling nonlinear problems. In the 1990s, Motorola developed the MC68HC12 microcontroller with native Fuzzy Logic instructions. This research determined the effectiveness of the MC68HC12’s Fuzzy Logic instructions for robotic control. This research involved designing a robotic platform using the MC68HC12 and testing binary logic control systems against Fuzzy Logic control systems. The research analyzed the two systems using four criteria: (1) the size of memory required to develop the control system, (2) the ease of writing the control software, (3) how well the control system managed the functions of the robot, and (4) the overall processing power of the system. The results showed that Fuzzy Logic uses less memory than binary logic and is much easier to design, although more difficult to program initially. Fuzzy Logic can control more functions of the robot and has greater processing capabilities. The power, ease of use, and small size of Fuzzy Logic instructions make Fuzzy Logic a practical solution to autonomous robotic control systems.
Keywords: Fuzzy Logic, robotics, control systems, HC12
- Introduction
The expansion of robotics and microcontrollers into the facets of everyday life increases the need to develop efficient control systems. A non-traditional approach to control system design is the use of Fuzzy Logic.
Fuzzy Logic extends from the traditional crisp boundaries of Aristotelian logic (true or false) to include the concept of partial truth – having truth-values between ‘completely true’ and ‘completely false.’ Dr. Lotfi Zadeh ofUniversity of California Berkeley first introduced these fuzzy methods in 1965 [1]. These methods allow the engineer to use natural language to describe and implement the control system. Fuzzy Logic uses linguistic values to represent part of the range an ordinary crisp variable may assume [2]. For example, a variable t, that represents temperature, may vary from 0 oC to 100oC. A linguistic value, COLD may be used to represent temperatures from 0oC to 10 oC while other linguistic values represent other ranges. Fuzzy Logic makes it possible to solve complex, ill-defined problems where there is a large degree of expert knowledge or the solution is easy to describe linguistically [3].
Applications of Fuzzy Logic are appearing in many industries. Fuzzy Logic enables designers to model complex systems more quickly and effectively than traditional approaches. Consumer appliances, automobile engines, transmissions, and industrial systems are all using Fuzzy Logic techniques.
Motorola’s HC68HC12 (HC12) microcontroller incorporates several Fuzzy Logic primitives directly in its instruction set. The instruction set contains the Fuzzy Logic operations of trapezoidal membership, rule evaluation, and weighted average defuzzification. The microcontroller also includes other instructions that are helpful in Fuzzy Logic applications such as MIN / MAX instructions and table lookups [4]. Motorola’s HC12 allows the development of low-level applications that can utilize the unique features of Fuzzy Logic.
The goal of this project is to design and build an autonomous line following robot based on Fuzzy Logic techniques. The robot uses the Motorola HC68HC12 microcontroller. This project involves investigating the HC12’s Fuzzy Logic instruction set and analyzing its ability to control an autonomous robot. The robot in this project serves as a test bed for several pieces of software. These software programs include initial test scripts, several control system based on traditional logic, and several control systems based on fuzzy systems. The best classical logic and fuzzy control systems are compared in various tests. These tests involved the robot following a black line on the floor.
- Fuzzy Logic on the HC12
As stated in the introduction, Motorola designed the HC12 with advanced capabilities to handle Fuzzy Logic calculations. The HC12 contains four instructions that are specific to Fuzzy Logic. These instructions are:
- MEM Evaluates the trapezoidal membership functions
- REV/REVW Performs unweighted/weighted MIN-MAX rule evaluation
- WAV Performs weighted average defuzzification
The following section describes the basics of Fuzzy Logic on the Motorola HC12. This section will only serve as an introduction to fuzzy programming on the HC12 and is not a replacement for the manufacture’s documentation. This section assumes that the reader has some knowledge of Fuzzy Logic.
2.1 fuzzy logic basics
The design of a Fuzzy Logic interface for the HC12 consists of two parts. First, the user must design a knowledge base that contains the membership functions and the rule set. The second part is the inference kernel that takes the system inputs and produces the system outputs based on the knowledge base [5]. Figure 1 shows the basic structure of the Fuzzy Logic system.
Figure 1: Block diagram of a fuzzy logic system [5].
2.2 fuzzification strategy (MEM)
Fuzzification is the process by which system inputs are evaluated to determine the degree at which they belong to a particular fuzzy set, on a scale from 00 to FF in hexadecimal [5]. The MEM instruction evaluates trapezoidal membership functions. These functions define the fuzzy set, the foundation of Fuzzy Logic. A fuzzy set is a set without a crisp, clearly defined boundary. It can contain elements with only a partial degree of membership. For example, the membership function for COLD could equal FF for temperatures below 7oC and slope down to 00 toward 10oC. The MEM instruction compares the system input against the membership function to determine the degree of truth of a fuzzy input.
The y-axis in Figure 2 represents the degree of truth from completely false (00) to completely true (FF). The x-axis represents the range of input values for the particular system input. The MEM function works by finding the y-value, given a system input (x-value) and the membership function. MEM returns the percentage of truth (y-axis value) for the particular fuzzy set. The result is a set of fuzzy values that describe characteristics of input variables in the system.
Figure 2: Trapezoidal membership function. The x-axis represents the input range and the y-axis represents the degree of truth [5].
To define a trapezoidal membership function for the HC12, you need four values: (1) the start of the trapezoid, (2) the first slope, (3) second slope, and (4) the end point of the trapezoid. Figure 2 labels these points and shows the memory representation. The user should define the trapezoidal in memory as follows:
LABEL_MF DC.B $40,$D0,$08,$04
The program should use a descriptive label because the programmer will need this label during fuzzification. For example, COLD_MF could represent a membership function of the fuzzy set COLD where the postfix _MF reminds the programmer that this variable represents a membership function. A trapezoidal definition is needed for each membership function.
2.3 rule definition and evaluation (REV/REVW)
Rule evaluation is how Fuzzy Logic performs calculations. The fuzzy values produced by the MEM function are passed through the rule list to find the fuzzy output. The two types of rules that the HC12 allows are weighted (REVW), where each rule can have a different weights; and un-weighted, (REV) were all rules have equal weight. An example of a rule list:
If temperature is COLD and wind is HIGH, then heat is on HIGH.
If temperature is WARM and wind is LOW, then heat is on LOW.
If temperature is HOT and wind is LOW, then heat is OFF.
After the fuzzy inputs are evaluated with REV/REVW, the system’s fuzzy outputs indicate the degree to which an output should have a specific value. These outputs must then undergo defuzzification before their values are useful. Creating the rule list is actually very simple. The antecedents (left side of the rule) are the fuzzy inputs created by the MEM instruction (e.g., a temperature reading evaluated with the COLD, WARM and HOT membership functions). The consequents (right side of the rule) are the fuzzy outputs of the system. During REV, each antecedent is joined using the fuzzy and operator (MIN). This minimum value is compared to the current fuzzy output of each consequent using the fuzzy or operator (MAX), and the maximum of these two values is stored in each consequent (fuzzy output). In other words, the overall “truth” of a rule is stored in the fuzzy outputs and if a subsequent rule is “truer,” then the fuzzy outputs are updated to reflect this new value.
The rule list is stored in memory as a list of pointers to fuzzy inputs (antecedents), a reserved separator value, a list of pointers to fuzzy outputs (consequents), and then another separator. Each rule follows this pattern and the rule list is terminated by an end rule reserved value.
RULE_LIST DC.B P_TisCold, P_WisHigh, SEPARATOR, P_HeatHigh, SEPARATOR
DC.B P_TisWarm, P_WisLow, SEPARATOR, P_HeatLow, SEPARATOR
2.4 defuzzification strategy (WAV)
The final step in the Fuzzy Logic calculation is defuzzification, when the raw fuzzy outputs are evaluated to create a composite system output. Unlike the input, the fuzzy output membership function is not trapezoidal but a singleton. This singleton indicates one system output value for each fuzzy output. The output membership singletons are arraigned in memory in the same order as their corresponding fuzzy outputs. WAV calculates a sum of products of each fuzzy output value times its singleton value and a sum of all of the fuzzy output values. The first sum is divided by the second using EDIV to produce an overall value that is the defuzzified output of the system. Defuzzification creates a weighted average system output based on the truth of the fuzzy outputs.
2.5 fuzzy inference kernel
The inference kernel contains all of the instructions that make up the fuzzy system. The kernel utilizes the knowledge base to create a system output from given system inputs [5]. All of the fuzzy instructions require proper initialization of the accumulators, index registers, and fuzzy values. These details are beyond the scope of this paper and can be found in the manufacture’s documentation. The sample program listing, Appendix A, also includes comments on developing the fuzzy kernel.
Readers wanting more information are encouraged to refer to the “Fuzzy Logic Support” chapter in the Motorola 68HC12 CPU12 Reference Manual for a detailed explanation of the Fuzzy Logic instruction set.
- Control Software
To test if Fuzzy Logic is a superior solution to the problems of autonomous robotic control, this project involved creating two control systems. The first system uses traditional logic to control the system. This system does not use any of the microcontrollers embedded Fuzzy Logic functions. The second robot relies solely on the HC12’s Fuzzy Logic instructions. This second system uses Fuzzy Logic for all of its control processing. Both control systems only used the HC12’s onboard RAM area (512 bytes) for program storage.
3.1 traditional control system
The traditional control system does not use an of the Fuzzy Logic instructions on the HC12. It relies on testing each input as true or false and then uses an if-else programming structure to determine the correct system output. Because of the limited size of RAM available for programming, the binary robot relies on an external chip to convert the analog signals from the sensors to a binary, on or off, form. The control structure is simplified to reduce the necessary amount of memory needed for storage. The traditional control system uses the following rules:
- Center sensor on Go Straight
- Left sensor on Turn Right
- Right sensor on Turn Left
- No sensors on Stop
The motor control of this system is limited to one speed for straight, left, and right. Because the system relies on an external chip to convert the analog sensor values, it is unable to detect when the sensor is partially on the line. While this simplifies programming, it reduces the effective resolution of the sensors.
3.2 fuzzy control system
The small amount of RAM also limits the fuzzy control system. However, the fuzzy instructions are able to handle far more control system computations than the traditional system in a similar amount of memory. First, the fuzzy system uses the analog values from the sensors. This gives the fuzzy robot the benefit of being able to tell exactly when the sensor is leaving the line and to be more robust to changes in the environment. Second, this system has three levels of speed for each direction. This gives the fuzzy control system improved turning ability.
The fuzzy control system takes the analog value from the sensors and assigns a level of “truth” to a fuzzy value. This control system used two fuzzy membership functions for each sensor: ON and OFF, to create a total of six fuzzy input values.
Fuzzy control systems are based on “rules.” The control system uses these rules to evaluate the fuzzy values and create a fuzzy output. Table 1 shows the rules based upon the truth of the fuzzy input values and the corresponding fuzzy outputs used in this control system. In the table, there are ON and OFF fuzzy values for each of the three sensors. The system combines the “truth” of the three fuzzy inputs for each rule using the fuzzy MIN operator. This minimum value is stored in the fuzzy outputs unless the outputs already have a greater value stored from a previous rule. The system finds the output that best fit the fuzzy inputs.
Table 1. Fuzzy Rule List. This table shows the rule list that evaluates the output speed and direction given the fuzzy input variables. This rule list is evaluated using the REV instruction on the MC68HC12.
| Fuzzy Inputs | Fuzzy Outputs | |||
| Left | Center | Right | Speed | Direction |
| Off | Off | Off | Stop | Line Finder |
| On | Off | Off | Slow | Hard Left |
| On | On | Off | Medium | Left |
| On | On | On | Slow | Line Finder |
| Off | On | Off | Fast | Straight |
| Off | On | On | Medium | Right |
| Off | Off | On | Slow | Hard Right |
| On | Off | On | Stop | Line Finder |
- Hardware Implementation
This project uses a custom robot designed to test the various control systems. This robot has a line sensor and two motors. The robot can also handle IR distance sensors, but the distance sensors are not uses in the testing portion of this project.
4.1 base and motors
The test robot consists of a plywood base and uses differential steering. The motors are two servos, modified to allow continuous revolution. Servos are useful for small robots because the servo has an integrated motor controller and it provides adequate torque for a small robot [6]. Ball casters support the front and back of the robot. This allows the robot to turn on its center. A rechargeable battery pack powers the motors, line sensor, and the microcontroller.
4.2 line sensor
The custom line sensor is a collection of three IR phototransistor, transmitter pairs that sense when the robot in centered on the line, to the left, and to the right. These sensors feed analog data into the HC12’s A/D ports for processing. The analog values represent the IR reflectivity of the surface below the line sensor at three points. Because the sensor contains IR transmitters, sensor works without ambient lighting.
- Testing
The two robot control systems were tested on a variety of tracks. These tracks were created by placing black electrical tape on a wooden, carpeted, and cement floor. The tracks included a straight line, a 45-degree angle turn, a 90-degree angle turn, and a 12-inch radius oval shaped ring. The lighting level was kept constant throughout the trials. The testing measurements include a qualitative description of the robots ability to stay on the line without “wiggle” or overcorrection.
- Results
For each of the test tracks, both robots maintained control and followed the line. The traditional control system did have more “wiggle” as it moved down the straight section. This robot was unable to center itself on the line and instead zigzagged down the line. The fuzzy robot system was able to quickly find and hold the true course of the line. The fuzzy robot system also made fewer corrections during the turns in the oval test track. The traditional robot had to correct its course many more times during the oval turns. The fuzzy robot system had a much smoother course throughout the track. Neither robot was unable to make any of the turns in the test.
In addition to comparing at the performance of the two different control systems, this project also looks at the memory requirements, the ease of writing the control software, and the processing power of the system. For the two systems tested, the Fuzzy Logic system used more memory. However, it also processed significantly more information and gave results with finer resolution. Achieving this same level of processing using the traditional system would have made the traditional system’s memory requirements much larger.
The fuzzy system is initially more difficult to program because the syntax of the instructions and the format of the knowledge base in memory is unclear. However, it is much easier to modify the fuzzy control system to changes in the environment or system outputs because only the membership functions need to change. For the traditional system, the entire logic of the control system may need to be modified. It is more intuitive to program in Fuzzy Logic because of the ease of creating a linguistic solution to the control problem. This intuitive nature makes Fuzzy Logic easier to program than traditional logic for complex control problems.
- Conclusion
Fuzzy Logic represents a tremendous advancement in autonomous robotic control systems. The Motorola MC68HC12’s instruction set will make designing fuzzy solutions on microcontrollers much easier than in the past. Fuzzy Logic is well suited for complex control problems like autonomous control, but it may be too difficult for simple control systems. The HC12’s fuzzy instructions simplify the design cycle for control system designers and provide an alternative to traditional control methodologies. The fuzzy system developed by Motorola is a very powerful set of instructions that will have a dramatic impact on control systems in many industries.
- References
[1] Reuss, Robert F, et al. “Fuzzy Logic Control in a Line Following Robot.” http://www.cs.unr.edu/~simon/fuzzy/fuzzylogic.htm [01/22/2002].
[2] Kandel, Abraham, et al. Fuzzy Control Systems. Boca Raton: CRC Press, 1994.
[3] Stachowicz, M.S. and Beall, L., “Fuzzy Logic Package for Mathematica®”, Wolfram Research, Inc., 2000.
[4] M. S. Stachowicz and C. Carroll, “Intelligent Systems on Motorola’s Microcontroller: A Team Design Workshop,” Proceedings of the 2000 International Conference on Engineering Education, Taiwan, August 14 -18, 2000.
[5] Motorola Semiconductor, CPU12 Reference Manual. Motorola Inc., 1999.
[6] McComb, Gordon. The Robot Builder’s Bonanza. New York: MCGraw-Hill, 2001.
Appendix A. Example Fuzzy Assembly Listing
The follow code example lists the overall structure of an assembly program for the HC12 that utilizes Fuzzy Logic. This simplified example takes two system inputs, temperature and wind speed; and produces one system output, heat. Input variables, stored in $0800 and $0801, have been scaled from 0016 to ff16. The range of the heat output is from 0016 to ff16. Refer to section 2 for details on the Fuzzy Logic operators.
ORG $0900 ;Memory location for Fuzzy Knowledge Base
;### Fuzzy Constants ###
MARKER EQU $FE ;Used to separate rule sections
ENDRO EQU $FF ;Used to finish the rule list
;### Relative Pointers ###
P_COLD EQU $00 ;Pointers to the relative locations of the fuzzy
P_WARM EQU $01 ;Input and Output variables
P_HOT EQU $02
P_CALM EQU $03
P_WINDY EQU $04
P_NoHt EQU $05
P_LowHt EQU $06
P_MedHt EQU $07
P_HiHt EQU $08
;### Membership Functions ###
COLD_MF DC $00,$76,$00,$05 ;Temperature Membership functions
WARM_MF DC $56,$AC,$07,$07 ;Point 1, Point 2, Slope 1, Slope 2
HOT_MF DC $8C,$FF,$07,$00
CALM_MF DC $00,$60,$00,$07 ;Wind Membership functions
WINDY_MF DC $50,$FF,$07,$00
;### Output Singletons ###
No_Heat_FS DC $00 ; The Fuzzy system will take the weighted average
Low_Heat_FS DC $56 ; of these values based on the truths of the
Med_Heat_FS DC $AC ; corresponding Fuzzy output variables
High_Heat_FS DC $FF
;### Fuzzy Variables ###
COLD_FI DS $01 ;These instructions reserve bytes for the Fuzzy
WARM_FI DS $01 ; input and output variables.
HOT_FI DS $01 ;(NOTE: This variable ordering is what determines the
CALM_FI DS $01 ; relative locations stored above and can be the
WINDY_FI DS $01 ; same ordering as the membership functions.)
NoHeat_FO DS $01
LowHeat_FO DS $01
MedHeat_FO DS $01
HHeat_FO DS $01
;### RULE Definitions ###
RULE_START
DC P_COLD,P_WINDY,MARKER,P_HiHt,MARKER ;This section defines the rule list
DC P_COLD,P_CALM,MARKER,P_MedHt,MARKER ;The rules are defined as relative
DC P_WARM,P_WINDY,MARKER,P_MedHt,MARKER ;pointers to the locations of
DC P_WARM,P_CALM,MARKER,P_LowHt,MARKER ;Fuzzy input and output variables.
DC P_HOT,P_WINDY,MARKER,P_LowHt,MARKER ;MARKER and ENDRO are constants
DC P_HOT,P_CALM,MARKER,P_NoHt,ENDRO ;$FE, $FF respectively
org $0803 ; Memory starting location for Inference Kernel
;### Fuzzification for temperature data ###
LDX #COLD_MF ; First of three membership function for temperature
LDY #COLD_FI ; Location of first fuzzy input variable for temperature
LDAA $0800 ; Location of temperature data in system
LDAB #$03 ; Number of membership functions for temperature
TEMPFUZZ: MEM ; This loop will process each of the three membership functions
DBNE B,TEMPFUZZ ; and create the three fuzzy input variables
;### Fuzzification for wind data ###
LDX #CALM_MF ; First of two membership function for wind
LDY #CALM_FI ; Location of fuzzy wind (These last two lines are optional because
; Accumulator X and Y already have the correct values)
LDAA $0801 ; Location of wind data in system
LDAB #$02 ; Number of membership functions for wind
WINDFUZZ: MEM ; This loop will process each of the two membership functions
DBNE B,WINDFUZZ ; and create the two fuzzy input variables
;### RULE EVALUATION ###
RULE: LDAB #$04 ; First you must clear out the fuzzy output variables
CLEAROUT: CLR 1,Y+
DBNE B,CLEAROUT
LDY #COLD_FI ; Point at start of Fuzzy Input variables
LDX #RULE_START ; Point at start of rule list
LDAA #$FF ; Must load AA with $FF
REV
;### DEFUZZIFICATION ###
LDX #No_Heat_FS ; Point to singleton positions
LDY #NoHeat_FO ; Point to Fuzzy Output locations
LDAB #$04 ; Number of Fuzzy Outputs
WAV ; Calculate sums for weighted average
EDIV ; Final divide step
TFR Y,D ; Move the results to A:B
STAB $0802 ; Store system outputs
Japan chases title of world’s fastest computer with new system
Taking a cue from China, Japan is developing a new supercomputer that could be among the world’s fastest systems when released in 2020.
The computer — being developed as part of a national project called Flagship2020 — is being developed with the aim to deliver “100 times more application performance” than the current K, which is installed in Japan and is the world’s third-fastest computer, according to the Top500 list of supercomputers, released on Monday.
The supercomputer will be deployed by 2020. It is being developed by Fujitsu and Japanese research institution RIKEN, which also developed K. The current K supercomputer has 705,204 processing cores and offers 10.5 petaflops of performance.
Details about the new supercomputer will be shared at two different sessions on Tuesday at the Supercomputing 15 conference being held in Austin, Texas.
The systems will be based on the Linux OS and the use of a “6D mesh” will be considered, according to details shared on the Supercomputing 15 website. That indicates the use of a six dimensional design, which could facilitate connections for more simultaneous CPUs, memory and storage compared to systems today. The system will also have many storage layers, according to information on the site.
The current K is based on Fujitsu’s SPARC64 VIIIfx processors and Tofu interconnect.
The U.S., Japan and China are in a race to build the world’s fastest supercomputer. An earlier version of the K computer briefly held the title of the world’s fastest supercomputer in 2011. China’s Tianhe-2 is the world’s fastest supercomputer today, delivering peak performance of 54.9 petaflops.
Countries are rushing to develop faster computers to boast about their progress in technology, but also to boost economic, weapons and science programs.
A number of supercomputers that are faster than existing systems are on the horizon. A U.S. Department of Energy supercomputer called Aurora, due in 2019, will deliver 180 petaflops of performance. China is also planning a supercomputer of more than 100 petaflops.
The countries are hoping to create exascale supercomputers between 2018 and 2020, in which systems can conduct million trillion calculations per second.
10 Things Windows Phones Do Better Than Android Phones
Alright, alright, calm yourselves, keyboard warriors, we know this is something most of you would probably not agree with because let’s face it, with over 80 percent of smartphone market share in the world, the Android mobile operating system leads the rest of the competition by a mile.
Perhaps because it is the OS adopted by many leading brands of smartphones,fragmentation becomes an issue that plagues Android-powered phone.Here is a post by Azzief Khaliq that argues for and against the effects of Android OS fragmentation you should check out.
Here, the Windows Phone’s fast and user-friendly OS plus its integration with Microsoft-linked products has given many users, particularly who work a lot with Windows products, a reason to consider the integrated mobile platform. On the surface, it offers the same functionality (and perhaps a bit more) as do other platforms but these are 10 features that you may find better on a Windows Phone than on an Android.
1. Quality Build Phones With Exceptional Design For Everyone
The biggest ammo to join the arsenal of Windows phones has to be Nokia’s partnership. With phones ranging from $180 to $425, sporting screen sizes from 4″ to 6″, Nokia has plenty of choices not just for the budget-conscious but also those are looking for a powerful, sleek phone, for instance like Nokia Lumia 1020 with 41 megapixel camera sensor and Full HD video. You definitely can get good value for your money if you just keep your eyes open for a good alternative phone, rather than stop looking once it isn’t on a “popular” OS.
2. Gorgeous Apps
Although the Windows App Store lags behind the Play Store in terms of quantity, what counts with apps is the quality and so far Windows phoneshave the basic necessities covered. Windows Phone is not an open source platform and Microsoft has a stricter criteria set than Google about which apps and games can populate their respective marketplaces.
As a result, the app store responds with superior and better apps, and cleaner options, than what Android apps can offer. They are consistent, gorgeous, minimalistic and in many cases, look better than they do on Android. I’d suggest you take a look at 6tag (3rd party app for Instagram), Spotify, Skype, and Facebook.
3. Seamless Email And Social Media Integration
Windows Phone with its mission to build an end-to-end product experience for its customers, has a soild built-in social media integrated hub that they use; it’s very smooth and fluid. The People Hub gets updates from social networkslike Facebook, Twitter, and LinkedIn. Rather than opening individual apps one by one, all your friends’ status updates and notifications can be viewed within the People Hub.
Facebook integration on Windows Phone also makes it better than Android when it comes to tagging pictures. It also allows you to use your phone contacts as tags. You can switch between Facebook chat and normal text messaging with your contacts on Windows Phone.
4. Microsoft Integration and Support
Those who are used to Microsoft’s service and software would be glad to know Windows Phone works well with Microsoft products like Outlook.com. OneDrive Skype, Xbox, and OneNote. Unlike Android, Windows Phone comes with free Office in the OS itself. The mobile version is handy for on-the-go professionals. You can view and edit, Excel, PowerPoint and Word documents straight on your Windows Phone. It also integrates with OneDrive and users can save their compatible files on Microsoft’s cloud storage service.
5. Consistency Across All Devices
Android comes in so many shapes and sizes, so performance and quality are always a question. Windows Phone however works well on all levels of devices from the entry-level Lumia 520 to the high-end Lumia 1020 without any noticeable lag whatsoever. The minimalist design approach is applied at all Nokia’s Lumia range of devices and known for best build quality.
6. Customizations on Lockscreen
Windows Phone allows you to check out your notifications from your lockscreen. Not only you can change Background pictures in Lock screen settings, but Windows Phones also allow the integration of live apps on the lockscreen. Some of the better app integrations are Bing and Facebook. Bing displays the Bing Picture of the Day while Facebook displays photos from your albums.
You can also choose from photos of yourself or create a selection of photos to be shown on your lockscreen. Another cool thing that you could do is to configure the lock screen to display artist information when playing music.
7. Play your XBox games on Windows Phone
If you own an XBox, Windows Phone has the perfect XBox integration to help you get the most out of your games, even on low-RAM devices. Microsoft has worked hard to integrate Xbox functionality, meaning you can work with your console avatar to gain points, check your Gamerscore, message your friends and see your avatar.
Despite Android having more games, Windows Phones get Xbox games such as Asphalt 8: Airborne, Jetpack Joyride, Six Guns and FIFA 14 for free. All of the games run smoothly; even on the low end Nokia Lumia Phones, playing games is a breeze.
8. Versatility of Live Tiles
Windows Phones allow users to pin whatever they want and how they want. Instead of widgets, each app on your home screen acts as a Live Tile. They give you a quick glimpse of what’s going on in each individual app. We can see the time and weather via the weather tile and notifications from Twitter, WhatsApp, SMS and email all from the main screen.
Widgets on Android are their own separate entities and their customized looks as designed by their developers. These designs thus can hardly mesh together aesthetically, especially without any form of standardization. Tiles, on the other hand, blend in and complement the overall aesthetic perfectly and they also change dynamically.
9. Offline Maps Integration
Windows Phone have HERE Maps and HERE Drive integrated to its Lumia range, basically Nokia’s alternative to Android’s Google Maps. It comes with full offline capabilities. Some Android smartphones such as Galaxy S4 also has offline navigation in Google Maps, but while Google Maps only allows you to download small areas of offline maps, you can download maps of countries with the Nokia Lumia Phones and navigate across the country without a data connection while driving.
10. Ever Expandable Storage
Most Windows Phone, even the entry level ones have 8GB of internal storage and supports a microSD card of up to 64 GB. The free 7 GB cloud storage from Onedrive makes it even better. This reduces the need to fall back on third-party online storage solutions, which may come with compatibility issues. OneDrivelets you backup content to the cloud, Windows tablets, PCs, and of course the Windows Phone.
Conclusion
While Android offers greater app flexibility, Windows Phone offers great potential, better integration over more platforms and fluidity. With the changing smartphone market, the world needs a solid platform that has quality and the potential to develop into a full range solution, that spans across mobile, desktop and the cloud. The strategies are already in place, and if Nokia and Windows Phone can weather the storm, they may one day be able to unseat Android from its iron grip of the smartphone OS market.
Bachelor of Science in Telecommunications Engineering
Telecommunications engineering lies at the heart of most information exchange, including telephone communications, broadcasting and the Internet. this program provides a blend of knowledge from electrical engineering and computer science, focusing on communications networks and systems.
Careers in Telecommunications Engineering
Telecommunications engineering is a dynamic and rapidly developing field as a result of today’s heavy reliance on the Internet, cellphones, broadband, wireless networks, broadcasting and satellite applications. Telecom engineers design, implement and manage systems for processing and transmitting information, finding career opportunities in such areas as:
- Computer communications and networking
- Mobile communications
- Voice and data networks
- TV and radio broadcasting
- Optical networking
- Remote sensing, measurement and control
- Next-generation networks
Telecommunications engineers also find employment in broader areas such as electronic engineering, instrumentation engineering, computer engineering, systems analysis and control engineering.
High School Preparation
Engineering education requires strong high school preparation. Pre-engineering students should have high school preparation of at least one semester of trigonometry and at least one year each in elementary algebra, intermediate and advanced algebra, plane geometry, chemistry, and physics, thus developing their competencies to the highest possible levels and preparing them to move immediately into demanding college courses in calculus, calculus-based physics, and chemistry for science majors. It’s also essential that pre-engineering students be able to read rapidly and write clearly.
Telecommunications Engineering at Universities
The telecom engineering program is based on a solid foundation of science and mathematics coursework. Students learn to extend their abilities to analyze and solve complex problems and to design new uses of technology to serve society. The program provides an integrated educational experience directed toward the development of the ability to apply pertinent knowledge to the identification and solution of practical problems in electrical and telecommunications engineering. The design experience, which includes both analytical and experimental studies, is integrated throughout the curriculum in a sequential development leading to advanced work.
ARE YOU SMARTER THAN AN A.I. SEARCH ENGINE?
How to Rename Internet Explorer to Firefox/Chrome Downloader
Now that Internet Explorer has officially dropped below 50% market share, it’s high time that we rename it to a more fitting title: Google Chrome Downloader, or if you prefer, Firefox Downloader.
Obviously this is a very stupid geek trick, and the reality is that Internet Explorer 9 is a very capable browser that works well. But don’t spoil our fun!
Renaming Internet Explorer to Firefox/Chrome Downloader
The first thing you’ll want to do is open up regedit.exe through the Start Menu search or Run box, and browse down to the following key:
HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\Main
Once there, create a new String key on the right-hand side, call it Window Title, and set the text to Chrome Downloader, Firefox Downloader, or something else entirely.
You should probably also open up the properties pane on any IE shortcuts and change the General tab to the new text.
Next, you should change the home page of Internet Explorer to the Chrome or Firefox download page:
Awesome Results
Now that you’ve done the rename and closed all the IE windows, you can launch it again and see that the title is really changed everywhere, including Alt-Tab:
And even Task Manager:
If you’re the techie fix-it guy in your family, all you have to do is set this up on everybody’s computer, and they won’t be confused again.
The Beginner’s Guide to Shell Scripting: The Basics
The Beginner’s Guide to Shell Scripting: The Basics
The term “shell scripting” gets mentioned often in Linux forums, but many users aren’t familiar with it. Learning this easy and powerful programming method can help you save time, learn the command-line better, and banish tedious file management tasks.
What Is Shell Scripting?
Being a Linux user means you play around with the command-line. Like it or not, there are just some things that are done much more easily via this interface than by pointing and clicking. The more you use and learn the command-line, the more you see its potential. Well, the command-line itself is a program: the shell. Most Linux distros today use Bash, and this is what you’re really entering commands into.
Now, some of you who used Windows before using Linux may remember batch files. These were little text files that you could fill with commands to execute and Windows would run them in turn. It was a clever and neat way to get some things done, like run games in your high school computer lab when you couldn’t open system folders or create shortcuts. Batch files in Windows, while useful, are a cheap imitation of shell scripts.
Shell scripts allow us to program commands in chains and have the system execute them as a scripted event, just like batch files. They also allow for far more useful functions, such as command substitution. You can invoke a command, like date, and use it’s output as part of a file-naming scheme. You can automate backups and each copied file can have the current date appended to the end of its name. Scripts aren’t just invocations of commands, either. They’re programs in their own right. Scripting allows you to use programming functions – such as ‘for’ loops, if/then/else statements, and so forth – directly within your operating system’s interface. And, you don’t have to learn another language because you’re using what you already know: the command-line.
That’s really the power of scripting, I think. You get to program with commands you already know, while learning staples of most major programming languages. Need to do something repetitive and tedious? Script it! Need a shortcut for a really convoluted command? Script it! Want to build a really easy to use command-line interface for something? Script it!
Before You Begin
Before we begin our scripting series, let’s cover some basic information. We’ll be using the bash shell, which most Linux distributions use natively. Bash is available for Mac OS users and Cygwin on Windows, too. Since it’s so universal, you should be able to script regardless of your platform. In addition, so long as all of the commands that are referenced exist, scripts can work on multiple platforms with little to no tweaking required.
Scripting can easily make use of “administrator” or “superuser” privileges, so it’s best to test out scripts before you put them to work. Also use common sense, like making sure you have backups of the files you’re about to run a script on. It’s also really important to use the right options, like –i for the rm command, so that your interaction is required. This can prevent some nasty mistakes. As such, read through scripts you download and be careful with data you have, just in case things go wrong.
At their core, scripts are just plain text files. You can use any text editor to write them: gedit, emacs, vim, nano… This list goes on. Just be sure to save it as plain text, not as rich text, or a Word document. Since I love the ease of use that nano provides, I’ll be using that.
Script Permissions and Names
Scripts are executed like programs, and in order for this to happen they need to have the proper permissions. You can make scripts executable by running the following command on it:
chmod +x ~/somecrazyfolder/script1
This will allow anyone to run that particular script. If you want to restrict its use to just your user, you can use this instead:
chmod u+x ~/somecrazyfolder/script1
In order to run this script, you would have to cd into the proper directory and then run the script like this:
cd ~/somecrazyfolder
./script1
To make things more convenient, you can place scripts in a “bin” folder in your home directory:
~/bin
In many modern distros, this folder no longer is created by default, but you can create it. This is usually where executable files are stored that belong to your user and not to other users. By placing scripts here, you can just run them by typing their name, just like other commands, instead of having to cd around and use the ‘./’ prefix.
Before you name a script, though, you should the following command to check if you have a program installed that uses that name:
which [command]
A lot of people name their early scripts “test,” and when they try to run it in the command-line, nothing happens. This is because it conflicts with the test command, which does nothing without arguments. Always be sure your script names don’t conflict with commands, otherwise you may find yourself doing things you don’t intend to do!
Scripting Guidelines
As I mentioned before, every script file is essentially plain text. That doesn’t mean you can write what you want all willy-nilly, though. When a text file is attempted to be executed, shells will parse through them for clues as to whether they’re scripts or not, and how to handle everything properly. Because of this, there are a few guidelines you need to know.
- Every script should being with “#!/bin/bash”
- Every new line is a new command
- Comment lines start with a #
- Commands are surrounded by ()
The Hash-Bang Hack
When a shell parses through a text file, the most direct way to identify the file as a script is by making your first line:
#!/bin/bash
If you use another shell, substitute its path here. Comment lines start with hashes (#), but adding the bang (!) and the shell path after it is a sort of hack that will bypass this comment rule and will force the script to execute with the shell that this line points to.
New Line = New Command
Every new line should be considered a new command, or a component of a larger system. If/then/else statements, for example, will take over multiple lines, but each component of that system is in a new line. Don’t let a command bleed over into the next line, as this can truncate the previous command and give you an error on the next line. If your text editor is doing that, you should turn off text-wrapping to be on the safe side. You can turn off text wrapping in nano bit hitting ALT+L.
Comment Often with #s
If you start a line with a #, the line is ignored. This turns it into a comment line, where you can remind yourself of what the output of the previous command was, or what the next command will do. Again, turn off text wrapping, or break you comment into multiple lines that all begin with a hash. Using lots of comments is a good practice to keep, as it lets you and other people tweak your scripts more easily. The only exception is the aforementioned Hash-Bang hack, so don’t follow #s with !s. 😉
Commands Are Surrounded By Parentheses
In older days, command substitutions were done with single tick marks (`, shares the ~ key). We’re not going to be touching on this yet, but as most people go off and explore after learning the basics, it’s probably a good idea to mention that you should use parentheses instead. This is mainly because when you nest – put commands inside other commands – parentheses work better.
Your First Script
Let’s start with a simple script that allows you to copy files and append dates to the end of the filename. Let’s call it “datecp”. First, let’s check to see if that name conflicts with something:
You can see that there’s no output of the which command, so we’re all set to use this name.
Let’s create a blank file in the ~/bin folder:
touch ~/bin/datecp
And, let’s change the permission now, before we forget:
Let’s start building our script then. Open up that file in your text editor of choice. Like I said, I like the simplicity of nano.
nano ~/bin/datecp
And, let’s go ahead and put in the prerequisite first line, and a comment about what this script does.
Next, let’s declare a variable. If you’ve ever taken algebra, you probably know what a that is. A variable allows us to store information and do things with it. Variables can “expand” when referenced elsewhere. That is, instead of displaying their name, they will display their stored contents. You can later tell that same variable to store different information, and any instruction that occurs after that will use the new information. It’s a really fancy placeholder.
What will we put in out variable? Well, let’s store the date and time! To do this, we’ll call upon the date command.
Take a look at the screenshot below for how to build the output of the date command:
You can see that by adding different variables that start with %, you can change the output of the command to what you want. For more information, you can look at the manual page for the date command.
Let’s use that last iteration of the date command, “date +%m_%d_%y-%H.%M.%S”, and use that in our script.
If we were to save this script right now, we could run it and it would give us the output of the date command like we’d expect:
But, let’s do something different. Let’s give a variable name, like date_formatted to this command. The proper syntax for this is as follows:
variable=$(command –options arguments)
And for us, we’d build it like this:
date_formatted=$(date +%m_%d_%y-%H.%M.%S)
This is what we call command substitution. We’re essentially telling bash that whenever the variable “date_formatted” shows up, to run the command inside the parentheses. Then, whatever output the commands gives should be displayed instead of the name of the variable, “date_formatted”.
Here’s an example script and its output:
Note that there are two spaces in the output. The space within the quotes of the echo command and the space in front of the variable are both displayed. Don’t use spaces if you don’t want them to show up. Also note that without this added “echo” line, the script would give absolutely no output.
Let’s get back to our script. Let’s next add in the copying part of the command.
cp –iv $1 $2.$date_formatted
This will invoke the copy command, with the –i and –v options. The former will ask you for verification before overwriting a file, and the latter will display what is being down on the command-line.
Next, you can see I’ve added the “$1” option. When scripting, a dollar sign ($) followed by a number will denote that numbered argument of the script when it was invoked. For example, in the following command:
cp –iv Trogdor2.mp3 ringtone.mp3
The first argument is “Trogdor2.mp3” and the second argument is “ringtone.mp3”.
Looking back at our script, we can see that we’re referencing two arguments:
This means that when we run the script, we’ll need to provide two arguments for the script to run correctly. The first argument, $1, is the file that will be copied, and is substituted as the “cp –iv” command’s first argument.
The second argument, $2, will act as the output file for the same command. But, you can also see that it’s different. We’ve added a period and we’ve referenced the “date_formatted” variable from above. Curious as to what this does?
Here’s what happens when the script is run:
You can see that the output file is listed as whatever I entered for $2, followed by a period, then the output of the date command! Makes sense, right?
Now when I run the datecp command, it will run this script and allow me to copy any file to a new location, and automatically add the date and time to end of the filename. Useful for archiving stuff!
Shell scripting is at the heart of making your OS work for you. You don’t have to learn a new programming language to make it happen, either. Try scripting with some basic commands at home and start thinking of what you can use this for.
Do you script? Have any advice for newbies? Share your thoughts in the comments! There’s more to come in this series!
Batch Programming Dos Scripting VS Shell Scripting
Its a good experience to work on DOS scripts(aka Batch programming). There are manysimilarities/differences/advantages/disadvantages between Batch programmingand Shell scripting. Lets see what they are.
Similarities
| Sl.No | Batch programming | Shell script |
| 1 | Sequential execution of group commands in a batch file | Sequential execution of groupcommand in shell scripts |
| 2 | Can read inputs from users | Can read inputs from users |
| 3 | Has control structures such as for, if, while, switch for better automating/scripting | Has control structures such as for, if, while, switch for better automating/scripting |
| 4 | Supports advanced features such as Functions and Arrays | Supports advanced features such as Functions and Arrays |
| 5 | Supports regular expressions(using findstr) | Supports regular expressions |
| 6 | Can include other programming codes such as perl(ie.. in middle of dos script we can include some other programming language code for effective scripting to get our desired output) | Can include other programming codes such as Perl, AWK, SED etc. |
Differences
| Sl.No | Batch programming | Shell script |
| 1 | Lack of richness of tools/commands | Have good number of tools(as of my knowledge there are more than 75000 commands in Linux/Unix) |
| 2 | Supports only one vendor(i.e. windows) | Supports for number of vendors such as Sun/apple/IBM AIX/HP-UX/GNU Linux etc. |
| 3 | No other variants for DOS | There are number of variants such as bash, ksh, csh, zsh etc.. |
| 4 | Low capabilities of integrating with other programming code in batch scripting | Good capabilities of integrating other programming code in shell script |
| 5 | Cannot handle complex regular expressions | Can handle complex regular expressions. |
| 6 | A batch file should always end with .bat | There is no such concept like file extension, but a shell script file permission should be set to executable. |
| 7 | To execute a batch program just enter the file name at CLI | To execute a shell script, here are the ways to execute it 1)chmod +x shellscript.sh;./shellscript.sh 2)sh shellscript.sh |
Robot Programming languages
A robot will require a programming language for describing the operations that are to be done. Recently, there are plenty of robot programming languages available. Among them, five robot languages are commonly and basically used. They are:
- RAIL
- AML
- VAL
- AL
- RPL
RAIL:
RAIL will be a best language for controlling two major tasks such as the manipulation and visionsystem. It is a high – level robot language based on Pascal, and it will implement a Motorola–68000 central processor, teach pendant, and terminal. This language was designed by Automatix for arc welding and inspection purposes.
RAIL comes with three different kinds of systems, namely:
- Hitachi Process Robot – Arc Welding
- Cartesian Arm – Assembly functions
- Vision system without arm
AML:
AML (A Manufacturing Language) is a high level language based on sub routine, which is mainly implemented to manage RS / 1 Assembly Robot, End Effectors Active Force Feedback, and Cartesian Arm with hydraulic motors. The RS / 1 assembly robot incorporates a mini – computer (IBM Series/1), 192 KB memory, matrix printer, disk drive, display terminals, and keyboard. AML was developed by IBM Corporation for robot programming. An important reason for creating this language is to offer simple subsets and as well as powerful base language.
VAL:
VAL (Variable Assembly Language) Robot Programming Language is adopted mainly forUnimation Robots. As this language is designed with simple syntax, it is capable of illustrating the robot functions very easily. It includes two major tasks such as:
- Program instructions are used to provide VAL programs in order to manage the robot functions.
- Monitor commands are used to execute the user written programs.
AL:
AL robot language was developed in Artificial Intelligence Lab at Stanford University. It is the second generation language based on simultaneous Pascal. The programs are written and executed on PDP – 10. If the program is developed with high level code, then it should be written in Stanford Artificial Intelligence Language (SAIL). The AL system includes a big mainframe computer, and it generally runs on PDP 11/45. The PDP 11/45 implements one terminal, 128 KB RAM memory, and floating point processor. This language has got the capability to control two Stanford Scheinman and two PUMA 600 arms simultaneously.
RPL:
RPL robot language makes the improvement, checking, and correction of control algorithms very easy. It can be done even by an unskilled programmer like line foreman, production engineers, etc. The RPL programs are translated to interpretable code with the help of a compiler in SRI Robot Programming System. The programs are typically written in BLISS – 11 and run in RT – 11. The DECPDP – 10 is cross compiled into the LSI – 11 or PDP – 11. This robot language was designed in SRI International.
techkhabarsite 
You must be logged in to post a comment.