Er. Bikash Gurung, Richan Joshi, Prithvi Chaudhary, Pankaj Japrel, Anil Singh

Created June 26, 2020 © MIT

Sister Robot- Food and Medicine Carrying Robot

Sister Robot is a response to a global emergency of protecting frontline health workers from infected population yet continuing medical care

ExpertShowcase (no instructions)Over 12 days41

Sister Robot- Food and Medicine Carrying Robot

Things used in this project

Hardware components

Geared DC Motor, 12 V

DeviceHub.net 2.4 ghz Transmittor /Receiver Set

Cable Clamp, NHX

Digilent BNC Oscilloscope x1/x10 Probes (Pair)

futaba-s3003-servo-motor

MG996R Servo Motor

Software apps and online services

Arduino IDE

AVR studio5.1

Hand tools and fabrication machines

Soldering iron (generic)

Solder Wire, Lead Free

Solder Flux, Soldering

PCB Holder, Soldering Iron

pcb drill bit 0.8 mm

pcb drill bit 1mm

PCB drill machine

Rework Station Kit, SMD

Angle grinder

Drill / Driver, Cordless

Multitool, Screwdriver

Plier, Long Nose

Plier, Needle Nose

Plier, Wire Twisting

Wire Stripper & Cutter, 18-10 AWG / 0.75-4mm² Capacity Wires

Mini Side Cutter, 120mm Length with 25mm Jaw Capacity

Cable Cutter, 143mm

Scissor, Electrician

Tape, Electrical

Tape, Double Sided

Tape Measure, Manual

L N key

jigsaw blade

jigsaw

Digilent Mastech MS8217 Autorange Digital Multimeter

oscilloscope

Story

Necessity is the mother of invention, and the ongoing global fight to stave off COVID-19 pandemic, has spurred all manners of creativity and out-of-the-box thinking to help us make the best of this situation. By this, the project definitely does not mean there was anything less before the pandemic. In the case of the robotics industry, however, the exploration of novel solutions has dramatically increased. In Nepal, the interest and zeal towards machine learning and promoting robotics has shot up significantly, compared to what was before the pandemic.

The pandemic is affecting 95% of the globe (at least 187 countries and territories). Nepal is not immune. Its first case was reported on 23 January, and it took two months for another case to surface. But as of 26th June, Nepal’s Covid-19 tally crosses 11162 with 26 fatalities.. Physical distancing protocols are being followed here in Nepal, as in the rest of the world, more so since the country-wide lockdown that started on 24 March (and currently extended until 30 June 2020). There is good evidence that this measure has helped prevent an exponential spread of the infection. However, physical distancing is a luxury for some essential workers. For example, health workers who are in the frontline are more affected as they have been treating and caring for infected patients 24/7.📷

Robotics Association of Nepal [RAN], Kantibir Tradelink Pvt. Ltd, Robonauts and Oztec explored solutions to minimize physical contact between health workers and patients. And the development team looked into how machines can minimize the exposure of care workers providing a safer work environment under the circumstances. For example, how can machines de-risk some critical care tasks, such as delivering food and medicines to the patients.

While searching for emerging local innovations, the project team planned at utilizing robots in response to COVID-19 and developed Sister Robots - Food and Medicine Carrying Robot.

Within 7 days of collaborative effort, the prototype of the Sister Robot was ready and Robot was taken to the teaching hospital for testing with the permission from the Director of Teaching Hospital. Team had an interaction with the nurses at the hospital, and a demo of Robot on how it works was shown to the nurse. Further, they were requested to operate the Robot which was really successful. Nurses suggested video interaction facilities with the help of the Robot which the team took note. A Biomedical Engineer Ramesh Acharya suggested circular design for the frame system through the use of UV lights. Acharya also suggested how it was important to have curved shapes in order to avoid spaces for germs/bacteria or viruses to live in. Similarly, the Robot was tested at Armed Police Force (APF) hospital. The hospital has the highest number of beds in the isolation ward and 3 storeyed building, control room with CCTV live video feed. The development team operated the Robot from 100m distance smoothly within the isolation room, it took 10 mins to move the robot from one room to another. The APF hospital was quite impressed with the utility of the Robot and shared they would need 6 robots for the hospital. The demonstration was also given to Dr. Khem Raj Karki, Executive Director, Nepal Health Research Council (NHRC) who was impressed with the functionality of Robot and said that NHRC would implement it in Teku Hospital after the product version is developed. The developed product version SISTER V.1 is currently deployed in Hetauda Hospital, provincial level hospital after the Robot was handed over to Hon. Chief Minister, Dormani Poudel, Province no. 3. The response from the nurse is very positive and they are using the robot for serving food and medicine to the COVID19 patient without any hassles. Similarly APF hospital and Teku Hospital has also deployed the second version of the robot.

Schematics

Code

Code to control the board

#define BA{B00111100,B01000010,B01000010,B01000010,B01111110,B01000010,B01000010,B01000010}
#define BB{B01111100,B01000010,B01000010,B01111100,B01000010,B01000010,B01000010,B01111100}
#define BC{B00111100,B01000010,B01000000,B01000000,B01000000,B01000000,B01000010,B00111100}
#define BD{B01111000,B01000100,B01000010,B01000010,B01000010,B01000010,B01000100,B01111000}
#define BE{B01111110,B01000000,B01000000,B01111100,B01000000,B01000000,B01000000,B01111110}
#define BF{B01111110,B01000000,B01000000,B01111100,B01000000,B01000000,B01000000,B01000000}
#define BG{B00111100,B01000010,B01000000,B01000000,B01001110,B01000010,B01000010,B00111100}
#define BH{B01000010,B01000010,B01000010,B01111110,B01000010,B01000010,B01000010,B01000010}
#define BI{B01111100,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000,B01111100}
#define BJ{B00111110,B00001000,B00001000,B00001000,B00001000,B00001000,B01001000,B00110000}
#define BK{B01000100,B01001000,B01010000,B01100000,B01100000,B01010000,B01001000,B01000100}
#define BL{B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01111110}
#define BM{B10000010,B11000110,B10101010,B10101010,B10010010,B10010010,B10000010,B10000010}
#define BN{B01000010,B01100010,B01010010,B01010010,B01001010,B01001010,B01000110,B01000010}
#define BO{B00111100,B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B00111100}
#define BP{B01111100,B01000010,B01000010,B01000010,B01111100,B01000000,B01000000,B01000000}
#define BQ{B00111100,B01000010,B01000010,B01000010,B01000010,B01000010,B01000100,B00111010}
#define BR{B01111100,B01000010,B01000010,B01111100,B01010000,B01001000,B01000100,B01000010}
#define BS{B00111100,B01000010,B01000000,B00110000,B00001100,B00000010,B01000010,B00111100}
#define BT{B01111100,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000}
#define BU{B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B00111100}
#define BV{B01000100,B01000100,B01000100,B01000100,B01000100,B01000100,B00101000,B00010000}
#define BW{B10000010,B10000010,B10000010,B10000010,B10010010,B10010010,B10101010,B01101100}
#define BX{B10000010,B10000010,B01000100,B00101000,B00010000,B00101000,B01000100,B10000010}
#define BY{B10000010,B10000010,B01000100,B00101000,B00010000,B00010000,B00010000,B00010000}
#define BZ{B01111110,B00000010,B00000100,B00001000,B00010000,B00100000,B01000000,B01111110}

#define LA{B00000000,B00000000,B00000000,B00111000,B00000100,B00111100,B01000100,B00111000}
#define LB{B01000000,B01000000,B01000000,B01000000,B01111000,B01000100,B01000100,B01111000}
#define LC{B00000000,B00000000,B00000000,B00111100,B01000000,B01000000,B01000000,B00111100}
#define LD{B00000100,B00000100,B00000100,B00000100,B00111100,B01000100,B01000100,B00111100}
#define LE{B00000000,B00000000,B00000000,B00111000,B01000100,B01011000,B01000000,B00111100}
#define LF{B00111000,B01000100,B01000000,B01000000,B01111000,B01000000,B01000000,B01000000}
#define LG{B00111000,B01000100,B01000100,B01000100,B00111000,B00000100,B00000100,B01111000}
#define LH{B01000000,B01000000,B01000000,B01111000,B01000100,B01000100,B01000100,B01000100}
#define LI{B00000000,B00000000,B00010000,B00000000,B00010000,B00010000,B00010000,B00010000}
#define LJ{B00000000,B00001000,B00000000,B00001000,B00001000,B00001000,B01001000,B00110000}
#define LK{B00000000,B01000000,B01000000,B01001000,B01010000,B01100000,B01010000,B01001000}
#define LL{B00100000,B00100000,B00100000,B00100000,B00100000,B00100000,B00100000,B00011000}
#define LM{B00000000,B00000000,B00000000,B01000000,B01101100,B01010100,B01000100,B01000100}
#define LN{B00000000,B00000000,B00000000,B01000000,B01111000,B01000100,B01000100,B01000100}
#define LO{B00000000,B00000000,B00000000,B00111000,B01000100,B01000100,B01000100,B00111000}
#define LP{B00000000,B00000000,B00111000,B01000100,B01000100,B01111000,B01000000,B01000000}
#define LQ{B00000000,B00000000,B00111000,B01000100,B01000100,B00111100,B00000100,B00000100}
#define LR{B00000000,B00000000,B00111000,B01000100,B01000000,B01000000,B01000000,B01000000}
#define LS{B00000000,B00000000,B00111000,B01000100,B01100000,B00011100,B01000100,B00111000}
#define LT{B00100000,B00100000,B00100000,B01111000,B00100000,B00100000,B00100000,B00011000}
#define LU{B00000000,B00000000,B00000000,B01000100,B01000100,B01000100,B01000100,B00111100}
#define LV{B00000000,B00000000,B00000000,B01000100,B01000100,B01000100,B00101000,B00010000}
#define LW{B00000000,B00000000,B00000000,B01000100,B01000100,B01010100,B01010100,B00111000}
#define LX{B00000000,B00000000,B00000000,B01000100,B00101000,B00010000,B00101000,B01000100}
#define LY{B00000000,B00000000,B00000000,B01000100,B01000100,B00111100,B00000100,B01111000}
#define LZ{B00000000,B00000000,B00000000,B01111100,B00000100,B00111000,B01000000,B01111100}

#define SPACE{B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000}
#define NUM0{B00111100,B01000010,B01000110,B01001010,B01010010,B01100010,B01000010,B00111100}
#define NUM1{B00011000,B00111000,B00011000,B00011000,B00011000,B00011000,B00011000,B00111100}
#define NUM2{B00111100,B01000010,B00000010,B00000010,B00001100,B00110000,B01000000,B01111110}
#define NUM3{B00111100,B01000010,B00000010,B00000010,B00011100,B00000010,B01000010,B00111100}
#define NUM4{B01000010,B01000010,B01000010,B01000010,B00111110,B00000010,B00000010,B00000010}
#define NUM5{B01111110,B01000000,B01000000,B01111100,B00000010,B00000010,B01000010,B00111100}
#define NUM6{B01111110,B01000000,B01000000,B01000000,B01111110,B01000010,B01000010,B01111110}
#define NUM7{B01111110,B00000010,B00000100,B00000100,B00001000,B00001000,B00010000,B00010000}
#define NUM8{B00111100,B01000010,B01000010,B01111110,B01000010,B01000010,B01000010,B00111100}
#define NUM9{B01111110,B01000010,B01000010,B01111110,B00000010,B00000010,B01000010,B01111110}
#define DEVIDE{B00000100,B00000100,B00001000,B00001000,B00010000,B00010000,B00100000,B00100000}
#define TWODOTS{B00000000,B00011000,B00011000,B00000000,B00000000,B00011000,B00011000,B00000000}
#define DOT{B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B01100000,B01100000}
#define COMA{B00000000,B00000000,B00000000,B00000000,B00000000,B00110000,B00110000,B01100000}
#define LINE{B00000000,B00000000,B00000000,B01111110,B01111110,B00000000,B00000000,B00000000}
#define QUASTION{B00111000,B01000100,B00000100,B00000100,B00001000,B00010000,B00000000,B00010000}
#define MARK{B00011000,B00011000,B00011000,B00011000,B00011000,B00000000,B00011000,B00011000}
/*
  #define LESSTHAN
  #define GRATTHAN
  #define AT
  #define POUND
  #define DOLLAR
  #define PERCENT
  #define CARAT
  #define AND
  #define ASTERISK
  #define LPARENTH
  #define RPARENTH
  #define HYPHEN
  #define UNSCORE
  #define PLUS
  #define EQUALS
  #define DASH
  #define LBRACKET
  #define RBRACKET
  #define SYM[
  #define SYM]
  #define SYM|
  #define SYM\
  #define SYM`
  #define SYM~
  #define SYM;
  #define SYM:
*/

int latchPin = 10;
int clockPin = 13;
int dataPin = 11;
int clock = 9;
int Reset = 8;
int latchPinPORTB = latchPin - 8;
int clockPinPORTB = clockPin - 8;
int dataPinPORTB = dataPin - 8;
int i = 0;
long scrolling_word[16];
int array_turn = 0;
byte your_text[60][8] = {BP,BU,BS,BP,BA}; //PUT YOUR TEXT HERE


void setup() {
  Serial.begin(9600);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(latchPin, OUTPUT);
  pinMode(clock, OUTPUT);
  pinMode(Reset, OUTPUT);
  digitalWrite(Reset, HIGH);
  digitalWrite(Reset, LOW);
  setupSPI();
}

void display_word(int loops, byte word_print[][8], int num_patterns, int delay_langth) { // this function displays your symbols
  i = 0;// resets the counter fot the 4017
  for (int g = 0; g < 8; g++) //resets the the long int where your word goes
    scrolling_word[g] = 0;
  for (int x = 0; x < num_patterns; x++) { //main loop, goes over your symbols
    // you will need to find a better way to make the symbols scroll my way is limited for 24 columns

    for (int r = 0; r < 8; r++) //puts the buildes the first symbol (also controls how many columns are displayed)
      scrolling_word[r] |= word_print[x][r];
    for (int z = 0; z < 8; z++) { //the scrolling action (Z is also pretty much a kerning variable- larger vale = more space between letters)
      for (int p = 0; p < 8; p++)
        scrolling_word[p] = scrolling_word[p] << 1;
      // end of the scrolling funcion
      for (int t = 0; t < delay_langth; t++) { // delay function, it just loops over the same display
        for (int y = 0; y < 8; y++) { // scaning the display
          if (i == 8) { // counting up to 8 with the 4017
            digitalWrite(Reset, HIGH);
            digitalWrite(Reset, LOW);
            i = 0;
          }
          latchOff();
          spi_transfer(make_word(0x01000000, y)); // sending the data
          spi_transfer(make_word(0x00010000, y));
          spi_transfer(make_word(0x00000100, y));
          latchOn();
          delayMicroseconds(2000);//waiting a bit
          latchOff();
          spi_transfer(0);// clearing the data
          spi_transfer(0);
          spi_transfer(0);
          latchOn();
          digitalWrite(clock, HIGH); //counting up with the 4017
          digitalWrite(clock, LOW);
          i++;
        }
      }
    }
  }
  finish_scroll(delay_langth);
}

void finish_scroll(int delay_scroll) { // this function is the same as the funcion above, it just finishing scrolling
  for (int n = 0; n < 24; n++) {
    for (int h = 0; h < 8; h++)
      scrolling_word[h] = scrolling_word[h] << 1;
    for (int w = 0; w < delay_scroll; w++) {
      for (int k = 0; k < 8; k++) {
        if (i == 8) {
          digitalWrite(Reset, HIGH);
          digitalWrite(Reset, LOW);
          i = 0;
        }
        latchOff();
        spi_transfer(make_word(0x01000000, k));
        spi_transfer(make_word(0x00010000, k));
        spi_transfer(make_word(0x00000100, k));
        latchOn();
        delayMicroseconds(2000);
        latchOff();
        spi_transfer(0);
        spi_transfer(0);
        spi_transfer(0);
        latchOn();
        digitalWrite(clock, HIGH);
        digitalWrite(clock, LOW);
        i++;
      }
    }
  }
}

byte make_word (long posistion, byte turn) {
  byte dummy_word = 0;
  for (int q = 0; q < 8; q++) {
    if (scrolling_word[turn] & (posistion << q))
      dummy_word |= 0x01 << q;
  }
  return dummy_word;
}

void loop() {
  display_word(1, your_text, 20, 15); // calls for the display_pattern function and says that int loop = 15(if you do more loop the pattern whould scrole slower).
  // the seconds variable in this (20 in this case), controls how many letters your display can hold at one time.
}
void latchOn() {
  bitSet(PORTB, latchPinPORTB);
}

void latchOff() {
  bitClear(PORTB, latchPinPORTB);
}

void setupSPI() {
  byte clr;
  SPCR |= ( (1 << SPE) | (1 << MSTR) ); // enable SPI as master
  //SPCR |= ( (1<<SPR1) | (1<<SPR0) ); // set prescaler bits
  SPCR &= ~( (1 << SPR1) | (1 << SPR0) ); // clear prescaler bits
  clr = SPSR; // clear SPI status reg
  clr = SPDR; // clear SPI data reg
  SPSR |= (1 << SPI2X); // set prescaler bits
  //SPSR &= ~(1<<SPI2X); // clear prescaler bits
  delay(10);
}

byte spi_transfer(byte data) {
  SPDR = data;     // Start the transmission
  while (!(SPSR & (1 << SPIF))){};   // Wait the end of the transmission
  return SPDR;     // return the received byte, we don't need that
}

Sister Robot- Food and Medicine Carrying Robot