element14 Community
element14 Community
    Register Log In
  • Site
  • Search
  • Log In Register
  • Members
    Members
    • Achievement Levels
    • Benefits of Membership
    • Feedback and Support
    • Members Area
    • Personal Blogs
    • What's New on element14
  • Learn
    Learn
    • eBooks
    • Learning Center
    • Learning Groups
    • STEM Academy
    • Webinars, Training and Events
  • Technologies
    Technologies
    • 3D Printing
    • Experts & Guidance
    • FPGA
    • Industrial Automation
    • Internet of Things
    • Power & Energy
    • Sensors
    • Technology Groups
  • Challenges & Projects
    Challenges & Projects
    • Arduino Projects
    • Design Challenges
    • element14 presents
    • Project14
    • Project Groups
    • Raspberry Pi Projects
  • Products
    Products
    • Arduino
    • Avnet Boards Community
    • Dev Tools
    • Manufacturers
    • Product Groups
    • Raspberry Pi
    • RoadTests & Reviews
  • Store
    Store
    • Visit Your Store
    • Or choose another store...
      • Europe
      •  Austria (German)
      •  Belgium (Dutch, French)
      •  Bulgaria (Bulgarian)
      •  Czech Republic (Czech)
      •  Denmark (Danish)
      •  Estonia (Estonian)
      •  Finland (Finnish)
      •  France (French)
      •  Germany (German)
      •  Hungary (Hungarian)
      •  Ireland
      •  Israel
      •  Italy (Italian)
      •  Latvia (Latvian)
      •  
      •  Lithuania (Lithuanian)
      •  Netherlands (Dutch)
      •  Norway (Norwegian)
      •  Poland (Polish)
      •  Portugal (Portuguese)
      •  Romania (Romanian)
      •  Russia (Russian)
      •  Slovakia (Slovak)
      •  Slovenia (Slovenian)
      •  Spain (Spanish)
      •  Sweden (Swedish)
      •  Switzerland(German, French)
      •  Turkey (Turkish)
      •  United Kingdom
      • Asia Pacific
      •  Australia
      •  China
      •  Hong Kong
      •  India
      •  Korea (Korean)
      •  Malaysia
      •  New Zealand
      •  Philippines
      •  Singapore
      •  Taiwan
      •  Thailand (Thai)
      • Americas
      •  Brazil (Portuguese)
      •  Canada
      •  Mexico (Spanish)
      •  United States
      Can't find the country/region you're looking for? Visit our export site or find a local distributor.
  • Translate
  • Profile
FPGA
  • Technologies
  • More
FPGA
Blog Arty S7 50 ArtyBot - Bot Application Framework
  • Blog
  • Forum
  • Documents
  • Events
  • Polls
  • Files
  • Members
  • Mentions
  • Sub-Groups
  • Tags
  • More
  • Cancel
  • New
FPGA requires membership for participation - click to join
Blog Post Actions
  • Subscribe by email
  • More
  • Cancel
  • Share
  • Subscribe by email
  • More
  • Cancel
Group Actions
  • Group RSS
  • More
  • Cancel
Engagement
  • Author Author: javagoza
  • Date Created: 11 Jul 2022 11:45 AM Date Created
  • Views 4414 views
  • Likes 10 likes
  • Comments 1 comment
  • driver
  • arty-s7
  • hbridge
  • dc motors
  • pwm
  • xilinx
  • robot
  • fpga
  • vivado
  • digilent
  • framework
  • vitis
  • Spartan_Migration
  • microblaze
Related
Recommended

Arty S7 50 ArtyBot - Bot Application Framework

javagoza
javagoza
11 Jul 2022
Arty S7 50 ArtyBot - Bot Application Framework

In this post I describe the Bot Application Framework that I have prepared for the Digilent Arty S7 based bot and provides an overview of the Arty S7 Bot Application Framework, its architecture, components, and usage model.

This post is part 7 of my contribution to the "7 Ways to Leave Your Spartan-6" program, learning about the Xilinx Spartan-7 FPGA on the Digilent Arty S7 50 board.

"7 Ways to Leave Your Spartan-6" related posts
1 Arty S7 50 First Power Up and Hardware-Only Blinky
2 Arty S7 50 First Baremetal Software Project
3 Arty S7 50 Rapid Prototyping - Environmental Monitor
4 Arty S7 50 ArtyBot Pulse Width Modulation (PWM) for Motor Speed Control
5 Arty S7 50 ArtyBot Custom AXI4 Lite IP Peripheral for Sensing Motor Rotational Speed
6 Arty S7 50 ArtyBot How to Store MicroBlaze Program in the Quad-SPI Flash from Vivado
7 Arty S7 50 ArtyBot - Bot Application Framework
8 Arty S7 50 ArtyBot becomes Emubot, an educational robot for young children
9 Arty S7 50 ArtyBot - Color sensing and line follower
10 Arty S7 50 The Spartan-6 Migration Path Game. Learning the Differences Between Spartan-6 and Spartan-7 FPGAs
11 Arty S7 50 ArtyBot ToF Sensor for Obstacle Avoidance. Vivado Hierarchical Blocks
12 "7 Ways to Leave Your Spartan-6 FPGA" program. My summary
13 Arty S7 50 VGA Thermal Imaging Camera


Short video demonstrating the main driving functions using the Arty S7 Bot Framework

You don't have permission to edit metadata of this video.
Edit media
x
image
Upload Preview
image


Hardware and Development Environment

For this Bot Application Framework you'll need, Windows 10, AMD Xilinx Vivado ML 2021.1 and the following hardware:

Product Name Manufacturer Datasheet
Arty S7 50  Digilent  Buy Now
TI-RSLK element14 Buy Now
PmodOLED Digilent Buy Now


Components and Architecture of the Bot Application Framework

The Bot Application Framework is a Hardware Abstraction Layer (HAL) that provides a function API-based service to higher-level layers that allows them to perform hardware-oriented operations independent of the actual details of the hardware.

The figure shows a representative block diagram of the Bot Application Framework in relation with a possible custom application for the bot

image

The Driving Driver depends on:

  • Motor Position Driver;
  • Speed PID Controller;
  • Distance PID Controller;
  • Motor PWM Speed Controller;
  • and the H-Bridge Drive

Framework configuration

The Bot Application Framework is highly customizable.

You can configure the bot parameters with the bot_parameters.h header file depending on your FPGA configuration.

  • AXI GPIO Address and Channel for the 2 board RGB LEDS
  • AXI GPIO Address and Channel for the 4 board red LEDS
  • AXI GPIO Address and Channel for the 4 board switches
  • AXI GPIO Address and Channel for the 4 board push buttons
  • AXI GPIO Address and Channel for the 4 dual hbridge control signals
  • Right Motor Timer /Counter Device ID
  • Left Motor Timer /Counter Device ID
  • Motor Speed PWM Control signal period in nanoseconds
  • Motor position feedback AXI Base Address
  • Gear box motor ratio
  • Motor Position Module Clock Frequency
  • OLED AXI LITE GPIO Base Address
  • OLED AXI LITE SPI Base Address
  • OLED white background or black background
  • Proportional Constant for the Rotational Motor Speed PID control
  • Integral factor for the Rotational Motor Speed PID control
  • Derivative factor for the Rotational Motor Speed PID control
  • Proportional factor for the Traveled Distance PID control
  • Integral factor for the Traveled Distance PID control
  • Derivative factor for the Traveled Distance PID control
  • Base duty cycle, base speed for the PID controllers
  • Distance correction factor when rotating
  • Distance correction factors when driving straight


Framework Drivers

The Bot Application Framework provides several drivers that allows to perform hardware-oriented operations independent of the actual details of the hardware.

  • Bot Driver: Initializes the whole framework or specific parts of the framework.
  • Driving Driver : Functions to drive the bot: forward, backward, turn left. turn right and swinging on both wheels
  • Motor Position: Keep track of motor rotation counters.
  • Speed PID Controller: PID control with goal of maintaining the same target speed for both wheels 
  • Distance PID Controller: PID control with goal of maintaining the same traveled distance for both wheels
  • Motor PWM Speed Controller: Motor Speed controller Controls with Pulse Width Modulated signals
  • H-Bridge Driver: Control motor direction and sleep mode
  • Buttons Driver: Driver to poll to the four board buttons state
  • Switches Driver: Driver to poll to the four board switches state
  • Leds Driver: Driver to control the four board red leds state
  • RGB Leds Driver:  Driver to control the four board RGB leds state
  • OLED Extensions: Functions to extend OLED Driver as displaying integers and floats
  • OLED Driver: Functions to control the OLED display

Bot Driver

Initializes the whole framework or specific parts of the framework.

  • BOT_init()
  • BOT_init_driving_driver()
  • BOT_init_gpio_inputs() 
  • BOT_init_gpio_outputs() 
  • BOT_init_oled_display()

Driving Driver

Functions to drive the bot: forward, backward, turn left. turn right and swinging on both wheels

  • DRIVING_DRIVER_end()
  • DRIVING_DRIVER_init()
  • DRIVING_DRIVER_drive_backward_cm()
  • DRIVING_DRIVER_drive_backward_continuous_cm()
  • DRIVING_DRIVER_drive_forward_cm()
  • DRIVING_DRIVER_drive_forward_continuous_cm()
  • DRIVING_DRIVER_set_speed()
  • DRIVING_DRIVER_swing_turn_left_degrees()
  • DRIVING_DRIVER_swing_turn_right_degrees()
  • DRIVING_DRIVER_turn_left_continuous_degrees()
  • DRIVING_DRIVER_turn_left_degrees()
  • DRIVING_DRIVER_turn_right_continuous_degrees()
  • DRIVING_DRIVER_turn_right_degrees()

Motor Position Driver

Keep track of motor rotation counters.

  • MOTOR_POSITION_clear_pos_counter()
  • MOTOR_POSITION_clear_speed_counters()
  • MOTOR_POSITION_get_distance_traveled()
  • MOTOR_POSITION_get_edge_counts()
  • MOTOR_POSITION_get_position_difference()
  • MOTOR_POSITION_get_positions()
  • MOTOR_POSITION_get_speeds()
  • MOTOR_POSITION_init()

Speed PID Controller

PID control with goal of maintaining the same target speed for both wheels 

  • SPEED_PID_CONTROLLER_init()
  • SPEED_PID_CONTROLLER_reset_errors()
  • SPEED_PID_CONTROLLER_get_new_outputs()
  • SPEED_PID_CONTROLLER_set_duty_cycle()

Distance PID Controller

PID control with goal of maintaining the same traveled distance for both wheels

  • DISTANCE_PID_CONTROLLER_get_new_outputs()
  • DISTANCE_PID_CONTROLLER_init()
  • DISTANCE_PID_CONTROLLER_reset_errors()
  • DISTANCE_PID_CONTROLLER_set_duty_cycle()

Motor PWM Speed Controller

Motor Speed controller Controls with Pulse Width Modulated signals

  • PWM_DRIVER_disable()
  • PWM_DRIVER_enable()
  • PWM_DRIVER_get_duty_pct()
  • PWM_DRIVER_get_period_ns()
  • PWM_DRIVER_init()
  • PWM_DRIVER_set_duty_pct()
  • PWM_DRIVER_set_period_ns()

H-Bridge Driver

Control motor direction and sleep mode

  • HBRIDGE_DRIVER_get_hbridge_state()
  • HBRIDGE_DRIVER_init()
  • HBRIDGE_DRIVER_left_motor_backward()
  • HBRIDGE_DRIVER_left_motor_direction_toggle()
  • HBRIDGE_DRIVER_left_motor_forward()
  • HBRIDGE_DRIVER_right_motor_backward()
  • HBRIDGE_DRIVER_right_motor_direction_toggle()
  • HBRIDGE_DRIVER_right_motor_forward()
  • HBRIDGE_DRIVER_set_direction()
  • HBRIDGE_DRIVER_set_hbridge_state()


Board Buttons Driver

 Driver to poll to the four board buttons state with unbouncing function

  • BUTTONS_DRIVER_button1_pressed()
  • BUTTONS_DRIVER_button2_pressed()
  • BUTTONS_DRIVER_button3_pressed()
  • BUTTONS_DRIVER_button4_pressed()
  • BUTTONS_DRIVER_get_state()
  • BUTTONS_DRIVER_init()
  • BUTTONS_DRIVER_poll()
  • BUTTONS_DRIVER_reset()


Board Switches Driver

 Driver to poll to the four board switches state with unbouncing function

  • SWITCHES_DRIVER_get_state()
  • SWITCHES_DRIVER_init()
  • SWITCHES_DRIVER_poll()
  • SWITCHES_DRIVER_poll_switch1()
  • SWITCHES_DRIVER_poll_switch2()
  • SWITCHES_DRIVER_poll_switch3()
  • SWITCHES_DRIVER_poll_switch4()


Board Red Leds Driver

 Driver to control the four board red leds state 

  • LEDS_DRIVER_get_leds_state()
  • LEDS_DRIVER_init()
  • LEDS_DRIVER_set_led1_off()
  • LEDS_DRIVER_set_led1_on()
  • LEDS_DRIVER_set_led1_toggle()
  • LEDS_DRIVER_set_led2_off()
  • LEDS_DRIVER_set_led2_on()
  • LEDS_DRIVER_set_led2_toggle()
  • LEDS_DRIVER_set_led3_off()
  • LEDS_DRIVER_set_led3_on()
  • LEDS_DRIVER_set_led3_toggle()
  • LEDS_DRIVER_set_led4_off()
  • LEDS_DRIVER_set_led4_on()
  • LEDS_DRIVER_set_led4_toggle()
  • LEDS_DRIVER_set_leds_state()

Board RGB Leds Driver

 Driver to control the four board RGB leds state

  • RGB_LEDS_DRIVER_get_rgb_leds_state()
  • RGB_LEDS_DRIVER_init()
  • RGB_LEDS_DRIVER_set_rgb_led1_blue_off()
  • RGB_LEDS_DRIVER_set_rgb_led1_blue_on()
  • RGB_LEDS_DRIVER_set_rgb_led1_blue_toggle()
  • RGB_LEDS_DRIVER_set_rgb_led1_green_off()
  • RGB_LEDS_DRIVER_set_rgb_led1_green_on()
  • RGB_LEDS_DRIVER_set_rgb_led1_green_on()
  • RGB_LEDS_DRIVER_set_rgb_led1_green_toggle()
  • RGB_LEDS_DRIVER_set_rgb_led1_red_off()
  • RGB_LEDS_DRIVER_set_rgb_led1_red_on()
  • RGB_LEDS_DRIVER_set_rgb_led1_red_toggle()
  • RGB_LEDS_DRIVER_set_rgb_led1_set_color()
  • RGB_LEDS_DRIVER_set_rgb_led2_blue_off()
  • RGB_LEDS_DRIVER_set_rgb_led2_blue_on()
  • RGB_LEDS_DRIVER_set_rgb_led2_blue_toggle()
  • RGB_LEDS_DRIVER_set_rgb_led2_green_off()
  • RGB_LEDS_DRIVER_set_rgb_led2_green_on()
  • RGB_LEDS_DRIVER_set_rgb_led2_green_toggle()
  • RGB_LEDS_DRIVER_set_rgb_led2_red_off()
  • RGB_LEDS_DRIVER_set_rgb_led2_red_on()
  • RGB_LEDS_DRIVER_set_rgb_led2_red_toggle()
  • RGB_LEDS_DRIVER_set_rgb_led2_set_color()
  • RGB_LEDS_DRIVER_set_rgb_leds_state()

OLED Extensions

Functions to extend OLED Driver as displaying integers and floats

  • OLED_putFloatVariable() 
  • OLED_putIntVariable() 

Usage Model

Initialization using Driving Drivers, Led Driver and Buttons Driver

void test_bot() {
    BotDrivers botDrivers;
    xil_printf("BOT TEST Started\n\r");

    BOT_init(&botDrivers);

    while (1) {
        LEDS_DRIVER_set_led1_toggle(&botDrivers.ledsDriver);
        oled_show_home(&botDrivers.oled, "  PRESS BUTTON");
        if (BUTTONS_DRIVER_button1_pressed(&botDrivers.buttonsDriver)) {
            play_button_1_show(&botDrivers.drivingDriver, &botDrivers.oled);
            BUTTONS_DRIVER_reset(&botDrivers.buttonsDriver);
        }
        if (BUTTONS_DRIVER_button2_pressed(&botDrivers.buttonsDriver)) {
            play_button_2_show(&botDrivers.drivingDriver, &botDrivers.oled);
            BUTTONS_DRIVER_reset(&botDrivers.buttonsDriver);
        }
        if (BUTTONS_DRIVER_button3_pressed(&botDrivers.buttonsDriver)) {
            play_button_3_show(&botDrivers.drivingDriver, &botDrivers.oled);
            BUTTONS_DRIVER_reset(&botDrivers.buttonsDriver);
        }

        usleep(5000);
    }
    DRIVING_DRIVER_end(&botDrivers.drivingDriver);
    OLED_End(&botDrivers.oled);
    xil_printf("BOT TEST Finished\n\r");
    OLED_End(&botDrivers.oled);

}

Driving the bot

void play_button_3_show(DrivingDriver* botDriver, PmodOLED* oled) {
    xil_printf("BTN2 pressed\n\r");
    sleep(1);
    oled_show_action(oled, "  SWING LEFT 90");
    DRIVING_DRIVER_swing_turn_left_degrees(botDriver, 90);
    usleep(50000);
    oled_show_action(oled, "  FORWARD 7 cm");
    DRIVING_DRIVER_drive_forward_cm(botDriver, 7);
    usleep(50000);
    oled_show_action(oled, "  TURN RIGHT 90");
    DRIVING_DRIVER_turn_right_degrees(botDriver, 90);
    usleep(50000);
    oled_show_action(oled, "  FORWARD 7 cm");
    DRIVING_DRIVER_drive_forward_cm(botDriver, 7);
    usleep(50000);
    sleep(1);
    oled_show_action(oled, "  TURN RIGHT 90");
    DRIVING_DRIVER_swing_turn_right_degrees(botDriver, 90);
    usleep(50000);
    oled_show_action(oled, "  FORWARD 7 cm");
    DRIVING_DRIVER_drive_forward_cm(botDriver, 7);
    usleep(50000);
    oled_show_action(oled, "TURN LEFT 90");
    DRIVING_DRIVER_turn_left_degrees(botDriver, 90);
    usleep(50000);
    oled_show_action(oled, "  FORWARD 7 cm");
    DRIVING_DRIVER_drive_forward_cm(botDriver, 7);
    usleep(50000);
    sleep(1);
}

Using only LEDs and push buttons

void test_leds_and_buttons() {
    LedsDriver ledsDriver;
    RgbLedsDriver rgbLedsDriver;
    ButtonsDriver buttonsDriver;
    SwitchesDriver switchesDriver;

    XGpio GpioLedsAndRgbLeds; /* Dual GPIO Driver for LEDs and RGB LEDS*/
    XGpio GpioSwitchsAndButtons; /* Dual GPIO Driver for Switchs and Push Buttons */

    LEDS_DRIVER_init(&ledsDriver, &GpioLedsAndRgbLeds,
    BOT_LEDS_RGBLEDS_DEVICE_ID,
    BOT_LED_CHANNEL, 0b0000);

    RGB_LEDS_DRIVER_init(&rgbLedsDriver, &GpioLedsAndRgbLeds,
    BOT_LEDS_RGBLEDS_DEVICE_ID,
    BOT_RGB_LED_CHANNEL, 0b000000);

    BUTTONS_DRIVER_init(&buttonsDriver, &GpioSwitchsAndButtons,
    BOT_BUTTONS_SWITCHES_DEVICE_ID, BOT_BUTTONS_CHANNEL);

    SWITCHES_DRIVER_init(&switchesDriver, &GpioSwitchsAndButtons,
    BOT_BUTTONS_SWITCHES_DEVICE_ID, BOT_SWITCHES_CHANNEL);

    unsigned long semiperiod = 250000;
    xil_printf("LED TEST Started\n\r");

    LEDS_DRIVER_set_led1_toggle(&ledsDriver);
    usleep(semiperiod);
    LEDS_DRIVER_set_led1_toggle(&ledsDriver);
    usleep(semiperiod);
    LEDS_DRIVER_set_led2_toggle(&ledsDriver);
    usleep(semiperiod);
    LEDS_DRIVER_set_led2_toggle(&ledsDriver);
    usleep(semiperiod);
    LEDS_DRIVER_set_led3_toggle(&ledsDriver);
    usleep(semiperiod);
    LEDS_DRIVER_set_led3_toggle(&ledsDriver);
    usleep(semiperiod);
    LEDS_DRIVER_set_led4_toggle(&ledsDriver);
    usleep(semiperiod);
    LEDS_DRIVER_set_led4_toggle(&ledsDriver);
    usleep(semiperiod);

    RGB_LEDS_DRIVER_set_rgb_led1_set_color(&rgbLedsDriver, COLOR_RED);
    usleep(semiperiod);
    RGB_LEDS_DRIVER_set_rgb_led1_set_color(&rgbLedsDriver, COLOR_GREEN);
    usleep(semiperiod);
    RGB_LEDS_DRIVER_set_rgb_led1_set_color(&rgbLedsDriver, COLOR_BLUE);
    usleep(semiperiod);
    RGB_LEDS_DRIVER_set_rgb_led1_set_color(&rgbLedsDriver, COLOR_CYAN);
    usleep(semiperiod);
    RGB_LEDS_DRIVER_set_rgb_led1_set_color(&rgbLedsDriver, COLOR_MAGENTA);
    usleep(semiperiod);
    RGB_LEDS_DRIVER_set_rgb_led1_set_color(&rgbLedsDriver, COLOR_MAGENTA);
    usleep(semiperiod);
    RGB_LEDS_DRIVER_set_rgb_led1_set_color(&rgbLedsDriver, COLOR_YELLOW);
    usleep(semiperiod);
    RGB_LEDS_DRIVER_set_rgb_led1_set_color(&rgbLedsDriver, COLOR_WHITE);
    usleep(semiperiod);
    RGB_LEDS_DRIVER_set_rgb_led1_set_color(&rgbLedsDriver, COLOR_BLACK);
    usleep(semiperiod);

    RGB_LEDS_DRIVER_set_rgb_led2_set_color(&rgbLedsDriver, COLOR_RED);
    usleep(semiperiod);
    RGB_LEDS_DRIVER_set_rgb_led2_set_color(&rgbLedsDriver, COLOR_GREEN);
    usleep(semiperiod);
    RGB_LEDS_DRIVER_set_rgb_led2_set_color(&rgbLedsDriver, COLOR_BLUE);
    usleep(semiperiod);
    RGB_LEDS_DRIVER_set_rgb_led2_set_color(&rgbLedsDriver, COLOR_CYAN);
    usleep(semiperiod);
    RGB_LEDS_DRIVER_set_rgb_led2_set_color(&rgbLedsDriver, COLOR_MAGENTA);
    usleep(semiperiod);
    RGB_LEDS_DRIVER_set_rgb_led2_set_color(&rgbLedsDriver, COLOR_MAGENTA);
    usleep(semiperiod);
    RGB_LEDS_DRIVER_set_rgb_led2_set_color(&rgbLedsDriver, COLOR_YELLOW);
    usleep(semiperiod);
    RGB_LEDS_DRIVER_set_rgb_led2_set_color(&rgbLedsDriver, COLOR_WHITE);
    usleep(semiperiod);
    RGB_LEDS_DRIVER_set_rgb_led2_set_color(&rgbLedsDriver, COLOR_BLACK);
    usleep(semiperiod);
    while (!BUTTONS_DRIVER_button3_pressed(&buttonsDriver)) {
        LEDS_DRIVER_set_leds_state(&ledsDriver,
                BUTTONS_DRIVER_poll(&buttonsDriver));
        RGB_LEDS_DRIVER_set_rgb_leds_state(&rgbLedsDriver,
                SWITCHES_DRIVER_poll(&switchesDriver) << 2
                        | SWITCHES_DRIVER_poll(&switchesDriver));
    }

    xil_printf("LED TEST Finished\n\r");
}


image

Github repository

Bot Application Framework Github Repository


Bot Framework documentation

See the complete framework library documentation:


Credits

Parts of the driving library are inspired on Arvin Tang's ArtyBot Library


References

  • GitHub - javagoza/E14SpartanMigrationProgram: Project repository for my entry in the Element14 community's "7 Ways to Leave Your Spartan-6" program.

Summary

It has been a long development. The libraries are quite extensive and cover all the hardware configured so far in the FPGA for our Bot.
This framework will allow us to carry out new experiments with our robot with less effort.


"7 Ways to Leave Your Spartan-6" related posts
1 Arty S7 50 First Power Up and Hardware-Only Blinky
2 Arty S7 50 First Baremetal Software Project
3 Arty S7 50 Rapid Prototyping - Environmental Monitor
4 Arty S7 50 ArtyBot Pulse Width Modulation (PWM) for Motor Speed Control
5 Arty S7 50 ArtyBot Custom AXI4 Lite IP Peripheral for Sensing Motor Rotational Speed
6 Arty S7 50 ArtyBot How to Store MicroBlaze Program in the Quad-SPI Flash from Vivado
7 Arty S7 50 ArtyBot - Bot Application Framework
8 Arty S7 50 ArtyBot becomes Emubot, an educational robot for young children
9 Arty S7 50 ArtyBot - Color sensing and line follower
10 Arty S7 50 The Spartan-6 Migration Path Game. Learning the Differences Between Spartan-6 and Spartan-7 FPGAs
11 Arty S7 50 ArtyBot ToF Sensor for Obstacle Avoidance. Vivado Hierarchical Blocks
12 "7 Ways to Leave Your Spartan-6 FPGA" program. My summary
13 Arty S7 50 VGA Thermal Imaging Camera
  • Sign in to reply
  • javagoza
    javagoza over 1 year ago

    I have submitted a new blog with an educational application using this Bot Application Framework: Emubot, an educational robot for young children

    • Cancel
    • Vote Up 0 Vote Down
    • Sign in to reply
    • More
    • Cancel
element14 Community

element14 is the first online community specifically for engineers. Connect with your peers and get expert answers to your questions.

  • Members
  • Learn
  • Technologies
  • Challenges & Projects
  • Products
  • Store
  • About Us
  • Feedback & Support
  • FAQs
  • Terms of Use
  • Privacy Policy
  • Legal and Copyright Notices
  • Sitemap
  • Cookies

An Avnet Company © 2023 Premier Farnell Limited. All Rights Reserved.

Premier Farnell Ltd, registered in England and Wales (no 00876412), registered office: Farnell House, Forge Lane, Leeds LS12 2NE.

ICP 备案号 10220084.

Follow element14

  • X
  • Facebook
  • linkedin
  • YouTube