Open Access Journal Volume: 1.

Advances in Computer Sciences

ISSN 2517-5718

Algorithm for Medical Nanobots using C++

Manu Mitra Electrical Engineering Department, University of Bridgeport, Bridgeport, CT, USA

Abstract Article Information

Medical nanobots not only repair cells and tissues but also multiple nanobots can help
cure various types of diseases such as cancers, infection or to remove infected cells/tissues. DOI: 10.31021/acs.20181112
To automate Medical Nanobot we need program to detect it and work on it; and there may
be the need for manual work to move Medical Nanobot and perform operations. Article Type: Research Article
A very basic software attempt is made for Medical Nanobot using C/C++ later same Journal Type: Open Access
methodology can be used for advanced programming of Medical Nanobot. In this paper Volume: 1 Issue: 3
flow diagram of medical nanobot for disease detection, removal of infected cells, tissues,
repairing the cells, tissues and continuous monitoring is made including various pseudo Manuscript ID: ACS-18-012
code is demonstrated such as setting up, driving nanobots for manual and automatic, Publisher: Boffin Access Limited
auto pan/tilt, nano gyro sensors for disease detection, camera configuration, nano servo
mechanism, handling interrupts and synchronization of nanobot using C++.
Received Date: 23 July 2018
Keywords Accepted Date: 18 September 2018
Nanobot; Nano Robot; Medical Nanobot; Nano Machines; Cell Repair; Tissue Repair;
Published Date: 21 September 2018
Algorithm; C++

Introduction *Corresponding author:

Medical uses of nano devices incorporate plaque evacuation and heart repair. They
should relocate to a foreordained site and stay in that area to finish the task. Mitra M
Electrical Engineering Department
Multiple medical nanobots can be used collectively for medical applications to map the
human body, to regulate the cardio-vascular system, for insulin regulation, for targeted drug University of Bridgeport
delivery, for diagnosis of cellular pathologies and for destroying tumor cells [1]. Bridgeport, CT, USA
Another necessity of nano machine is that it works autonomously, free of outside control. E-mail: [email protected]
Physical, electrical, and compound responses can deliver a reaction yet the presentation of
these stimuli victimizes the device of the benefit of autonomous task and they additionally
Citation: Mitra M. Algorithm for Medical Nanobots
can create a reaction in the nanobots encompassing condition.
using C++. Adv Comput Sci. 2018;1(3):112
An innovative theory in the utilization of these nano devices to battle disease that
includes utilizing silicon nanomachines with a thin covering of gold and light in the close
infrared range. Copyright: © 2018 Mitra M. et al. This is
Light in the 700-1000 nanometer range will go through tissue with insignificant an open-access article distributed under the
ingestion. At the point when this close infrared light strikes this specific sort of nanomedibot, terms of the Creative Commons Attribution 4.0
the device gets hot because of the wavering of the metal’s electrons in response to the light. international License, which permits unrestricted
Utilizing MRI to definitely put the nanomedibots in the dangerous district, the light makes
use, distribution and reproduction in any
the devices warmth to 131 degrees Fahrenheit which wrecks the destructive cells yet
doesn’t harm encompassing tissues. medium, provided the original author and source
are credited.
Likewise with respect to disease treatment, ribonucleic corrosive obstruction is
a technique that assaults tumors on a hereditary level. Nanobots weighed down with
meddling RNA that deactivates the protein creation of the growth and murders the danger
would connect themselves to the tumor and convey the deadly hereditary material.In
addition of expelling plaque from blood vessel dividers; they could likewise be utilized to
discover arterial weakness.
Nanobots may likewise be utilized to distinguish particular chemicals or poisons and
could give early cautioning of organ disappointment or tissue dismissal. Additionally they
can be used to take biometric estimations, they might be utilized to screen the general
soundness of a person.
These nano devices may discover application in an assortment of mechanical
applications. Research is continuous into utilizing them in the oil business.
In addition, current research is examining their application in nano photonics to create
light more effectively. PC circuits might be delivered by these small devices. They could
make circuits on a very smaller scale than current drawing systems and would take into
consideration to manufacture of extremely small processors and chips [2-4].
One of the major advantage of nanobots it can be considered as a way of delivering
differentiated stem cells to various positions in the body. Stem cell research has been a

Adv Comput Sci Volume: 1.3 1

Journal Home: https://www.boffinaccess.com/journals/advances-in-computer-sciences/acs

In this code Watchdog time class has been used to make sure
that the nanobot will stop operating if program does something
unexpected or crashes. something unexpected or crashes
1. #include “Libraryfile.h”  // Library File for
Nanobot
2. #include “Nanobot.h”  // Includes all functions,
recursion loops for Nanobot
3. static  const UINT32 LEFT_Nanobot_
PORT = 1;  // Left Navigation for Nanobot
4. static  const UINT32 RIGHT_Nanobot_
PORT = 2; // Right Navigation for Nanobot 
5. static  const UINT32 JOYSTICK_
PORT = 1;  // Manual movement if automation is
failed
6. void Initialize(void) {  
7.     CreateRobotDrive(LEFT_Nanobot_PORT, RIGHT_
Nanobot_PORT);  
Figure 1: Depicts nanobot repairing a damaged DNA
8.     SetWatchdogExpiration(0.1);  // Watchdog
(Deoxyribonucleic Acid) timer
9. }  
huge increase in regenerative medicine. Nanobots help to enhance its 10. void Autonomous(void) {  
impact on medicine in the near future by providing an effective way 11.     SetWatchdogEnabled(false);  
of delivering them [5](Figure 1) [6].
12.     Drive(0.5, 0.0);  
Flow Diagram of Medical Nanobot 13.     Wait(2.0);  
14.     Drive(0.0, 0.0);  
A. Creating nanobot base class
15. }  
Pseudocode for simple nanobot base class Example I
16. void OperatorControl(void) {  
Below is the example code to create a nanobot’s base class [7].
17.     SetWatchdogEnabled(true);  
1. class SimpleNanobot: public NanobotBase {
18.     while (IsOperatorControl()) {  
2. public: SimpleRobot(void);virtual void Autonomo
us(); void OperatorControl();virtual void na 19.         WatchdogFeed();  
nobotMain();virtual void StartCompetition() 20.         ArcadeDrive(JOYSTICK_PORT);  
;private: bool m_nanobotMainOverridden;   21.     }  
3. };  22. }  
Pseudocode for Start Competition method Example II 23. START_ROBOT_CLASS(Nanobot);  
1. void 
Simple pseudocode for nanobot Pan/Tilt in C++
SimpleNanobot::StartCompetition
(void) {  Below is the example code for Pan/Tilt in C++ [8].
1. #include < Libraryfile.h > // This loads the 
     while (IsDisabled()) Wait(0.01); // waiti Nanobot script, allowing you to use specific 
ng for match to start   functions below  
2.     if (IsAutonomous()) // making nanobot auto 2. #include < Nanobot.h > // Includes all func
nomous   tions, recursion loops for Nanobot  
3.     {   3. Nanobot myNanobot; // create Nanobot object to 
4.         Autonomous(); // to run user provided  control a Nanobot  
Autonomous code   4. int pos = 0; // variable to store the Nanobot 
5.     }   position  
6.     while (IsAutonomous()) Wait(0.01); // nano 5. void setup() // required in all Nanobot Software
bot wait until end of autonomous    code  
7.     while (IsDisabled()) Wait(0.01); // make  6.     {  
sure that nanobot is enabled   7. myNanobot.attach(9); // attaches the Nanobot on
8.     OperatorControl(); // start user provided   pin 9 to the Nanobot object  
OperatorControl   8.     }  
9. }  9. void loop() // required in all Nanobot Software 
B. Manual and Autonomous Pseudocodes for code  
Nanobots 10.     {  
An attempt is made for basic manual execution of program 11.         for (pos = 0; pos < 180; pos += 1) 
for a Medical Nanobot using C/C++ language. // 
variable ‘pos’ goes from 0 degrees to 180 degr
Basic program of nanobot using C
ees in steps of 1 degree  
Below is the pseudocode in C program that demonstrates driving
12.         {  
the Nanobot for 2 seconds forward in Autonomous and in arcade
mode for the Operator Control. 13. myNanobot.write(pos); // tell Nanobot to go to 

Adv Comput Sci Volume: 1.3 2/8

Journal Home: https://www.boffinaccess.com/journals/advances-in-computer-sciences/acs

position in variable ‘pos’   Pseudocode for simple camera initialization

14.             delay(15); // waits 15ms for the  1. if (StartCameraTask() == -1) {  
Nanobot to reach the position   2.     dprintf(LOG_ERROR, “Failed to
15.         }    spawn camera task; Error code %s”, 
16.         for (pos = 180; pos >= 1; pos -= 1) //  GetErrorText(GetLastError()));  
variable ‘pos’ goes from 180 degrees to 0 degr 3. }  // Nano camera initialization for
ees   nanobot  
17.         {  
Pseudocode for camera configuration
18. myNanobot.write(pos); // tell Nanobot to go to  1. int frameRate = 15; // valid values 0 - 30  
position in variable ‘pos’  
2. int compression = 0; // valid values 0 – 100  
19. delay(20); // waits 20ms at each degree  
3. ImageSize resolution = k160x120; // k160x120,
20.         }  
 k320x240, k640480  
21.     }  
4. ImageRotation rot = ROT_180; // ROT_0, ROT_90,
C. Nano Gyro Sensors for Nanobots  ROT_180, ROT_270  
Gyro sensors are the angular velocity applied to a vibrating
5. StartCameraTask(frameRate, compression, 
element, the accuracy with which angular velocity is measured resolution, rot);  // Nano camera configurati
differs significantly depending on element material and structural on for nanobot
differences. Various characteristics of gyro sensor include but not Image acquisition through camera
limited to scale factor, temperature-frequency coefficient, compact 1. double timestamp; // timestamp of image retur
size, shock resistance, stability, and noise characteristics etc., [9]. ned
In this program robot drives in a straight line using gyro sensor 2. Image * cameraImage = frcCreateImage(IMAQ_
combination with nanobotDrive class. The NanobotDrive.Drive IMAGE_HSL);  
method takes the speed and turn rate as arguments; where both vary
3. if (!cameraImage) {  
from -1.0 to 1.0. In this instance uses the gyro returns values that
varies either positive or negative degrees as the nanobot’s deviates 4.     printf(“error: % s”, GetErrorText(Get
LastError())  
from its initial heading [10].
5.     };  
Simple pseudocode for nanobot gyro sensor
6.     if (!GetImage(cameraImage, & timest
1. class Gyrosensor: public Nanobot {   amp)) {  
2.     NanobotDrive myNanobot; // Nanobot
7.         printf(“error: % s”, GetErrorText
 drive system  
(GetLastError())  
3.     Gyro gyro;  
8.         };  // Image acquisition through
4.     static   nano camera for nanobot
5.     const float Kp = 0.03;  
E. Vision and Image Processing for Nanobots
6.     public: Gyrosensor(void): myNanobot(1,
Nanobot’s vision system has to make distinction between objects
 2), // initialize the sensors in initial
and in most of all cases it has to track. It is used to automate the
ization list  
process and object detection [11].
7.         gyro(1) 
{   Pseudocode for Color Tracking for Nanobot Example I
1. TrackingThreshold tdata = GetTrackingData(BL
8.             GetWatchdog().SetExpiration
UE, FLUORESCENT);  
(0.1);  
2. ParticleAnalysisReport par;  
9.         }  
3. if (FindColor(IMAQ_HSL, & tdata.hue, & tda
10.     void Autonomous(void) {
ta.saturation, & tdata.luminance, & par) {  
  
4.         printf(“color found at x = % i, y 
11.         gyro.Reset();  
= % i “,  // finding color for nanobot
12.         while (IsAutonomous()) {  
5.             par.center_mass_x_normalized,
13.             GetWatchdog().Feed();    par.center_mass_y_normalized);  
14.             float angle = gyro.GetAngle();  6.         printf(“color as percent of image:
// get heading    % d “,  
15.             myNanobot.Drive(-1.0, -angle  7.             par.particleToImagePercent);  
* Kp)
8.     }  // Color tracking for nanobot
 // turn to correct heading for nanobot  
Pseudocode for Using Specified ranges Example II
16.             Wait(0.004);  
1. Range hue, sat, lum;  
17.         }  
2. hue.minValue = 140; // Hue  
18.         myNanobot.Drive(0.0, 0.0); // stop 
3. hue.maxValue = 155;  
Nanobot  
4. sat.minValue = 100; // Saturation  
19.     }  
5. sat.maxValue = 255;  
20. };  
6. lum.minValue = 40; // Luminance  
D. Nano Camera for Nanobots
7. lum.maxValue = 255;  
A nano camera is very important to nanobots. C++ provides
initialization, control and image acquisition functionality. 8. FindColor(IMAQ_HSL, & hue, & sat, & lum, & 
StartCameraTask () initializes the camera. par)// Specifying range for nanobot 

Adv Comput Sci Volume: 1.3 3/8

Journal Home: https://www.boffinaccess.com/journals/advances-in-computer-sciences/acs

Pseudocode for Declaration Class Example III Pseudocode for nano solenoid
1. RobotDrive * Nanobot Range greenHue,  1. Nano_Solenoid * s[8];  
greenSat, greenLum;  // Declaration 2. for (int i = 0; i < 8; i++) s[i] = new Solenoid
Class for nanobot  (i + 1);
Pseudocode for Initialization of nano camera Example  // allocate the Nano Solenoid objects  
IV 3. for (int i = 0; i < 8; i++) {  
1. if (StartCameraTask() == -1) {  
4.     s[i] - > Set(true); // turn them all on  
2.     printf(“Failed to spawn camera 
5. }  
task; Error code %s”, GetErrorText(GetLast
Error()));   6. for (int i = 0; i < 8; i++) {  
3. } 7.     s[i] - > Set(false); // turn them each off
 in turn  
4. nanobot = new RobotDrive(1, 2); // values 
for tracking a target -may need tweaking  8.     Wait(1.0);  
in the environment greenHue.minValue = 65; 9. }  
 greenHue.maxValue = 80; greenSat.minValue 10. for (int i = 0; i < 8; i++) {  
 = 100; greenSat.maxValue = 255; greenLum
11.     s[i] - > Set(true); // turn them back on 
.minValue  = 100; greenLum.maxValue = 255;  
in turn  
Pseudocode for Automating for nanobot Example IV 12.     Wait(1.0);  
1. while (IsAutonomous()) {  
13.     delete s[i]; // delete the objects  
2.     if (FindColor(IMAQ_HSL, & greenHue, 
14. }  
& greenSat, & greenLum, & par) && par.particl
eToImagePercent < MAX_PARTICLE_TO_IMAGE_PERCE G. Synchronization of Nanobots
NT && par.particleToImagePercent > MIN_PARTI When there are multiple nanobots then synchronization is
CLE_TO_IMAGE_PERCENT) {   required. So that multiple nanobots can perform accordingly to
complete the task accordingly.
3.         nanobot - > Drive(1.0, (float) par.cen
ter_mass_x_normalized);   Pseudocode for synchronization example I
4.     } else nanobot - > Drive(0.0, 0.0);   1. {  
5.     Wait(0.05);   2.     Synchronized s(semaphore); // access shared
 code here  
6. }  
3.     if (condition) return; // more code 
7. nanobot - > Drive(0.0, 0.0); // Automating here  
nanobot  
4. }  // Synchronization for nanobot
F. Nano Servo Mechanismfor Nanobots
Pseudocode for critical condition example II
Nano Servomechanism is also required for nanobots for 1. {  
rotation. 2.     Synchronized s(semaphore); // access shared
 code here  
Pseudocode for Nano servo mechanism Example-I
1. Servo servo(3); // create a servo on PWM port 3.     if (condition) return; // more code 
3 on the first module   here  

2. float servoRange = servo.GetMaxAngle() -  4. }  // Synchronization for nanobot

servo.GetMinAngle();   H. Handling of Interrupts in Nanobots
3. for (float angle = servo.GetMinAngle(); // ste Pseudocode for handling of interrupts example
p through range of angles   1. static int interruptCounter = 0; // The
4. angle < servo.GetMaxAngle(); angle += servoR  interrupt handler that counts number 
ange / 10.0) {   of square wave cycles  
5. servo.SetAngle(angle); // set servo to angle   2. static void tiHandler(tNIRIO_u32 interr
uptAssertedMask, void * param) {  
6. Wait(1.0); // wait 1 second  
3.     interruptCounter++;  
7. }  // Nano servo mechanism for nanobot - I
4. }  
Pseudocode for Nano servo mechanism Example-II
1. #include “Nano_BaeUtilities.h” // Library files 5. void InterruptTestHandler(void) { // c
for reate the two digital ports (Output and Input)  
functions for nano servo mechanism  6.     DigitalOutput digOut(CROSS_CONNECT
2. panInit(); // optional parameters can adjust pan  _A_PORT1);  
speed for nanobot   7.     DigitalInput digIn(CROSS_CONNECT_A
3. bool targetFound = false;   _PORT2); // create the counter that wil
4. while (!targetFound) {   l also count square waves  
5.     panForTarget(servo, 0.0); // Start from 1  8.     Counter counter( & digIn); // init
to +1 // code to identify target for nanobot   ialize the digital output to 0  
6. }  // Nano servo mechanism for nanobot - II 9.     digOut.Set(0); // start the counter
 counting at 0  
F. Nano Solenoid for Nanobots
10.     counter.Reset();  
Solenoids are used as an actuator. Here solenoid can be used 11.     counter.Start(); // register and e
to remotely control if automation fails or any other malfunction. nable the interrupt handler      digIn.
It can be used as steering of nanobot [12]. RequestInterrupts(tiHandler);  

Adv Comput Sci Volume: 1.3 4/8

Journal Home: https://www.boffinaccess.com/journals/advances-in-computer-sciences/acs

Figure 2: UML Diagram of Architecture Description

12.     digIn.EnableInterrupts(); // count tateMachine stateMachine;  

 5 times   13.     1..*srcTransition--1..*AssociationStateSta
13.     while (counter.Get() < 5) {   te associationStateStatesrc;  
14.         Wait(1.0);   14. }  
15.         digOut.Set(1);   15. class StateMachine {  
16.         Wait(1.0);   16.     isA MgaObject; * stateMachine--1..*RootFo
17.         digOut.Set(0);   lder rootFolder;  
18.     } // verify correct operation   17. }  
19.     if (interruptCounter == 5 && counter. 18. class RootFolder {  
Get() == 5) printf(“Test passed!\n”); //  19.     String name;  
free resources   20.     0..1 - > * RootFolder rootFolders;  
20.     digIn.DisableInterrupts();   21. }  
21.     digIn.CancelInterrupts();   22. class AssociationStateState {}  
22. }   23. namespace PrimitiveTypes;  
23. END_TEST(TestInterruptHandler)  //  24. class String {}  
Interrupt Handler for Nanobot
25. class Integer {}  
Appendix Example UML logic Architectural description design
Example UML logic for finite state machine for for Nanobot
nanobot Figure 2 is the Example of UML logic Architectural description
1. namespace FSM;  
design for Nanobot.
2. class MgaObject {  
Example UML logic code architectural description for
3.     String name;  
nanobot
4.     String position;   1. namespace ArchitecturalDescription;  
5. }   2. class Architecture {  
6. class Transition {   3.     0..1 - > 1..*ArchitectureDescription
7.     isA MgaObject; * transition--1..*StateMach  describedBy;  
ine stateMachine;   4. }  
8.     1..*transition--1..*AssociationStateState  5. class ArchitectureDescription {  
associationStateState;   6.     0..1 selectedBy--1..*ArchitectureView
9. }    selects;  
10. class State {   7.     0..1 - > 1..*ArchitectureView o
11.     isA MgaObject;   rganizedBy;  

12.     0..1 dstTransition--1..*AssociationStateS 8. }  

tate associationStateStatedst; * state--1..*S 9. class ArchitectureView {  

Adv Comput Sci Volume: 1.3 5/8

Journal Home: https://www.boffinaccess.com/journals/advances-in-computer-sciences/acs

Figure 3: UML Logic diagram access control for medical nanobot.

10.     0..1 - > 1..*ModelElement constituents;   10.     }  

11.     1..*views--1..*ArchitectureViewPoint  11. } //Functional_Area  
conformsTo;   12. class FunctionalArea {  
12. }   13.     String code;  
13. class ArchitectureViewPoint {   14.     0..1 parent-- * FunctionalArea child;  
14.     0..1 - > 1..*MainView defines;   15.     description {  
15. }   16.         Operations, Control 
16. class MainView {   17.     }  
17.     0..1 - > 1..*ArchitectureView isProjected 18.     key {  
nto;  
19.         code  
18.     0..1 - > 1..*ModelElement consistsOf;  
20.     }  
19. }  
21. } //Facility_Functional_Area  
20. class ModelElement {}  
22. association { * FunctionalArea-- * Facility;  
21. namespace PrimitiveTypes;  
23. }  
22. class Boolean {}  
24. class Facility {  
23. class Integer {}  
25.     Integer id; * - > 0..1 FacilityType;  
24. class String {}  
26.     Integer access_count;  
Example UML diagram for access control design for
27.     name;  
nanobot
28.     description;  
Figure 3 is the Example of UML diagram for access control design
for nanobot. 29.     other_details;  
30.     key {  
Example UML logic for finite state machine for
nanobot 31.         id  
1. // UML class diagram in Umple representing a 32.     }  
 system for managing // access to facilities   33. }  
2. namespace access_control; //Ref_Facility_Type    34. class Role {  
3. class FacilityType {   35.     code;  
4.     code;   36.     role_description {  
5.     description {   37.         Dba, ProjectMgr  
6.         Menu, Record, Screen   38.     }  
7.     }   39.     key {  
8.     key {   40.         code  
9.         code   41.     }  

Adv Comput Sci Volume: 1.3 6/8

Journal Home: https://www.boffinaccess.com/journals/advances-in-computer-sciences/acs

Figure 4: .Flow Chart of a Medical Nanobot for performing various operations inside the body

42. }   Simplified pseudocode for nanobot is demonstrated such as

43. class User {   setting up, driving nanobots for manual and automatic, auto pan/
tilt, nano gyro sensors for disease detection, camera configuration,
44.     Integer id; * - > 0..1 Role;  
nano servo mechanism, handling interrupts and synchronization of
45.     first_name;   nanobot using C++.
46.     last_name;  
47.     password;  
Conclusion
Based on the above results, basic algorithm for Medical Nanobot
48.     other_details;  
can constructed using C++ as shown in the Figure 2.
49.     key {  
Examples of UML for Finite State Machine, Access Control
50.         id   design, Access control logic, Architectural description can be used
51.     }   for designing software for Medical Nanobot using C++ or any other
52. }   programming language.
53. associationClass RoleFacilityAccessRight  Discussion
{ * Facility; * Role;  
For construction of Nanobots biodegradable poly(lactide-co-
54.     CRUD_Value {   glycolide) (PLGA), an FDA approved polymer, can be used to formulate
55.         R, RW   the nanoparticles to form a nanobot [13].
56.     }   Advances in delivering therapy, reduction of analytical tools,
57. } enhanced computational and memory capabilities and developments
in inaccessible communications will be integrated allowing for the
Author notes development of such nanobots [14].
Examples of Pseudocodes in C++ is presented,UML logic for In order to evaluate the effectiveness of technique, known in
Medical nanobot is for demonstration and illustrations only and is literature and simulation results showed the effectiveness technique
not tested. Original code may vary and differ based on operations, in terms of achievement, that is the destruction of the cancerous cells,
model and requirements of multiple functionalities and operations. and velocity of destruction [15].
Results Acknowledgment
Basic Algorithm for Medical Nanobot with the flow chart Author would like to thank Prof. Navarun Gupta, Prof. Hassan
specified in Figure 4, UML logic for Finite State Machine, UML logic Bajwa, Prof. Linfeng Zhang and Prof. Hmurcik for their academic
Architecture Description for Nanobot, UML logic for Access control support. Author also thanks anonymous reviewers for their
design and example of C++ is presented. comments.

Adv Comput Sci Volume: 1.3 7/8

Journal Home: https://www.boffinaccess.com/journals/advances-in-computer-sciences/acs

References 9. Seiko E. Gyro sensors - How they work and what’s ahead. 2018
1. Solomon N. System and methods for collective nanorobotics for 10. Umple Online: Generate Java, C++, PHP, Alloy, NuSMV or Ruby
medical applications. 2008 code from Umple. University of Ottawa; 2018.
2. Mitra M. Medical Nanobot for Cell and Tissue Repair. Int Rob Auto 11. Overview of Robotic Vision - Object Tracking and Image
J. 2017; 2(6): 38. Processing Software. Into robotics; 2013.
3. Microscopemaster. Nanobots - Uses in Medicine and Industry - 12. Solenoid - Let’s Make Robots! - RobotShop. Robot Shop.2008.
Engineering and Drawbacks; 2018.
13. Jacob T, Hemavathy K, Jacob J, Hingorani A, Marks N, et al. A
4. Jonathan S. How Nanorobots Will Work. Stuff Works; 2007. nanotechnology-based delivery system: Nanobots. Novel vehicles
5. Bhat AS. Nanobots: The future of medicine. JEMS.2014;5(1):44- for molecular medicine. J Cardiovasc Surg. 2011;52(2): 159-167.
49. 14. Haberzettl CA. Nanomedicine: destination or
6. Moorthy K. Nanobots can check and repair dna. 2016. journey?. Nanotechnology. 2002; 13(4): R9-R13.
7. Miller B, Streeter K, Finn B, Morrison J. C/C++ Programming 15. Loscrí V, Natalizio E, Mannara V, Aloi G. A Novel Communication
Guide for the FIRST Robotics Competition. 2008 Technique for Nanobots Based on Acoustic Signals. Lecture Notes
8. Benson C. How to Make a Robot - Lesson 10: Programming Your of the Institute for Computer Sciences, Social Informatics and
Robot. Robot Shop Blog. 2012. Telecommunications Engineering. 2014; 91-104.

Adv Comput Sci Volume: 1.3 8/8