{"id":5926,"date":"2019-04-25T15:00:05","date_gmt":"2019-04-25T19:00:05","guid":{"rendered":"https:\/\/dronebotworkshop.com\/?p=5926"},"modified":"2019-05-02T10:58:15","modified_gmt":"2019-05-02T14:58:15","slug":"real-robot-008","status":"publish","type":"post","link":"https:\/\/dronebotworkshop.com\/real-robot-008\/","title":{"rendered":"Build a Real Robot – Part 8 – Motor Controller 1"},"content":{"rendered":"\n

This article is the eighth is a series about building a full-sized, intelligent robot. You can view all of the previous articles here<\/a>. There is also a YouTube playlist of all of the videos<\/a> for your enjoyment.<\/span><\/p>\n

Introduction<\/span><\/h2>\n

Now that we have the mechanical components on the base (or \u201cNavigation Layer\u201d) built it\u2019s time to turn our attention to the motor controller. <\/span><\/p>\n

<\/div>\n

In this installment, I will just go over the design criteria for the controller. In the next part of this series, we will look at some of the code used to program it.<\/span><\/p>\n

Motor Controllers<\/span><\/h2>\n

There are actually two motor controllers, one for each of the DC gear motors used to propel the robot. Each controller is identical and they are completely independent, although they both use the same Emergency Stop input.<\/span><\/p>\n

\"Build<\/p>\n

Each of the devices is controlled using the I2C bus, and they each have their own I2C address.<\/span><\/p>\n

ATmega328<\/span><\/h3>\n

The controller design will be based upon the ATmega328P, which is the microcontroller chip at the heart of the Arduino Uno, The Arduino Nano, and the Arduino Pro Mini. \u00a0The device could be built around any of these controllers, or it could use just an ATMega328P chip with the appropriate support hardware.<\/span><\/p>\n

I was originally planning to build my controller using two Arduino Nano devices, I thought that having an onboard USB port for each controller might turn out to be a useful feature during development.<\/span><\/p>\n

However, my plans were somewhat thwarted due to a computer mishap in my workshop! The SSD drive on my workshop Linux computer failed, so I needed to move a Windows notebook in to take over until I could repair the shop computer.<\/span><\/p>\n

This is not a problem, as the Windows computer has all of the software that I require to develop Arduino software. However, it was lacking the driver for the USB on the Nano clone I was using, and every attempt to install that driver failed.<\/span><\/p>\n

So I have switched development over to an Arduino Uno so I can carry on. As it uses the same microcontroller chip as the Nano it would be possible to transfer the software to a Nano once I have my workshop Linux box functioning.<\/span><\/p>\n

I\u2019ve actually been considering just using the ATMega328P chip on its own for the final design, and will likely do just that. However, you could certainly take the code I produce and use an Arduino Nano or Pro Mini if you find it easier to wire.<\/span><\/p>\n

Design Criteria<\/span><\/h3>\n

Before embarking on any design of considerable size I like to establish some design criteria. These are preliminary design specs and could (and likely will) change as the design progresses.<\/span><\/p>\n

Here is what my controller(s) will need to do:<\/span><\/p>\n

    \n
  • Provide a PWM output for the Cytron motor driver board. This will control the motor speed.<\/span><\/li>\n
  • Provide a DIR (direction)signal for the Cytron motor driver board.<\/span><\/li>\n
  • Have an input for the rotary encoder used on my gear motors. <\/span><\/li>\n
  • Have an I2C interface so it can be controlled by the Arduino Mega 2560. Each controller will have its own I2C address.<\/span><\/li>\n
  • Have Emergency Stop inputs. <\/span><\/li>\n
  • Be capable of accepting commands and reporting status, via the I2C bus.<\/span><\/li>\n<\/ul>\n

    I also want these controllers to be relatively \u201cuniversal, so that if you are building a robot that doesn\u2019t use the same motors or motor drivers yo can use the same design. \u00a0This means that the controllers need to be able to have some adjustable parameters for things like:<\/span><\/p>\n

      \n
    • Wheel Size<\/span><\/li>\n
    • Number of steps per rotation from the rotary encoders<\/span><\/li>\n<\/ul>\n

      This implies that the controller will need some form of non-volatile memory. As the ATmega328P does have a bit of NV memory this might suffice, otherwise, an external EEPROM or similar device will need to be employed.<\/span><\/p>\n

      Controller Hookup<\/span><\/h3>\n

      The following diagram illustrates how the controller will fit into the DB1 robot design:<\/span><\/p>\n

      \"Motor<\/p>\n

      Note that although only one controller, motor and motor driver are shown there will actually be two of each. If you are designing a 4-motor robot then, of course, you will need four of each device.<\/span><\/p>\n

      The controller will connect to the Arduino Mega 2560 using I2C. Only SDA, SCL and Ground are required as the controller has its own 5-volt power supply input.<\/span><\/p>\n

      The Emergency Stop input also connects to one of the digital I\/O pins on the Arduino Mega 2560. There will be other Emergency Stop inputs as well. \u00a0A signal on this line will stop all motor activity and the controller will no longer respond to movement commands until the stop is cleared.<\/span><\/p>\n

      The Driver Output connects to the Cytron MD10C motor driver. It has a PWM, DIR and Ground signal.<\/span><\/p>\n

      The Rotary Encoder input takes the output from the rotary encoder on the DC gear motor. It also supplies 5-volts and ground to the encoder.<\/span><\/p>\n

      Controller Commands<\/span><\/h2>\n

      The controller will accept commands on the I2C bus. I have defined some of these commands already, please note that this is just a preliminary list and could be expanded upon as the design progresses.<\/span><\/p>\n

      \"Motor<\/p>\n

      Many of the commands have additional parameters. The parameters in brackets are optional, those not encased in brackets are mandatory.<\/span><\/p>\n

      Here is a brief description of each command, along with any parameters it may have.<\/span><\/p>\n

      MovePWM<\/span><\/h3>\n

      This moves the motor in a specific direction at a specific PWM speed. \u00a0The motor can move for a specified time, or it can move until another command is received.<\/span><\/p>\n

        \n
      • SpeedPWM<\/b> – The motor speed in PWM, valid values are 1-255<\/span><\/li>\n
      • Direction<\/b> – A binary indicator of the motor direction<\/span><\/li>\n
      • Time<\/b> – An optional parameter that specifies the time the motor should move. If this is omitted then the motor will move indefinitely, until another command is received to stop it or reset its speed.<\/span><\/li>\n
      • Accelerate<\/b> – An optional parameter that specifies if the motor should accelerate to reach the desired speed. If this is omitted the motor will come to the desired speed immediately.<\/span><\/li>\n
      • Decelerate<\/b> – An optional parameter that specifies if the motor should decelerate before stopping. If this is omitted then the motor will come to an abrupt stop. \u00a0This is only applicable if a Time parameter has also been provided.<\/span><\/li>\n<\/ul>\n

        MoveRPM<\/span><\/h3>\n

        This is almost identical to the previous command, the exception being that the speed will be specified in RPM instead of PWM speed. The input from the rotary encoder will measure and regulate the speed.<\/span><\/p>\n

        The controller will also need to be aware of the maximum RPM that the motor can rotate, any value above this will simply cause the motor to operate at full speed.<\/span><\/p>\n

        MoveDistance<\/span><\/h3>\n

        This command will move the robot motor a specified distance. The distance is calculated using the motor RPM readings from the rotary encoder and the stored wheel diameter. <\/span><\/p>\n

          \n
        • DistanceCM<\/b> – The distance, specified in centimeters.<\/span><\/li>\n
        • Direction<\/b> – A binary indicator of the motor direction.<\/span><\/li>\n
        • SpeedPWM<\/b> – The motor speed in PWM, valid values are 1-255<\/span><\/li>\n
        • Accelerate<\/b> – An optional parameter that specifies if the motor should accelerate to reach the desired speed. If this is omitted the motor will come to the desired speed immediately.<\/span><\/li>\n
        • Decelerate<\/b> – An optional parameter that specifies if the motor should decelerate before stopping. If this is omitted then the motor will come to an abrupt stop.<\/span><\/li>\n<\/ul>\n

          Stop<\/span><\/h3>\n

          This command stops the motor. An optional Decelerate parameter can be used, otherwise, the motor will come to an abrupt stop.<\/span><\/p>\n

          ReadRPM<\/span><\/h3>\n

          This command will return the current RPM of the motor.<\/span><\/p>\n

          ClearStop<\/span><\/h3>\n

          This command will clear the stop executed due to an Emergency Stop. \u00a0It is the only command that the controller will respond to after an Emergency Stop has been executed.<\/span><\/p>\n

          GetStatus<\/span><\/h3>\n

          This command will return the current status of the motor and motor controller.<\/span><\/p>\n

          Conclusion<\/span><\/h2>\n

          It\u2019s been a short article (and video) this week, there is a lot of design work to get done. Next week I will report on the progress I have made on the controller design.<\/span><\/p>\n

          I might even have my Linux box working again! Stay tuned.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

          In part 8 of the Build a Real Robot series I will start designing the motor controller. It’s being designed using ATmega328P microcontrollers and will have an I2C interface.<\/p>\n

          Today I’m getting my development environment setup and I’ll go over the criteria for the motor controller.<\/p>\n","protected":false},"author":1,"featured_media":5928,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[88,4],"tags":[52],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"https:\/\/i0.wp.com\/dronebotworkshop.com\/wp-content\/uploads\/2019\/04\/Build-Real-Robot-Episode-8.jpeg?fit=768%2C432&ssl=1","jetpack_shortlink":"https:\/\/wp.me\/p74ClK-1xA","jetpack-related-posts":[],"_links":{"self":[{"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/posts\/5926"}],"collection":[{"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/comments?post=5926"}],"version-history":[{"count":0,"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/posts\/5926\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/media\/5928"}],"wp:attachment":[{"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/media?parent=5926"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/categories?post=5926"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/dronebotworkshop.com\/wp-json\/wp\/v2\/tags?post=5926"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}