CyberPi is an open-source device.
This section provides the open-source materials that can help you obtain the underlying permissions on CyberPi, allowing you to:

  • Develop functions for CyberPi
  • Design blocks in Extension Builder for CyberPi
  • Enable CyberPi to work with third-party hardware
  • Develop extension boards and electronic modules for CyberPi

    Device schematic diagram

    The schematic diagram of a device can help you understand its hardware design.

    Schematic diagram of Halocode

    To understand the hardware design of Halocode, refer to its schematic diagram, as shown in the following figure.

Open-source Materials - 图1
halocode_V1_0.pdf
[For non-Yuque users, click halocode_V1_0.]

Schematic diagram of CyberPi

image.pngCYBERPI_V1_X (1).pdf [For non-Yuque users, click CYBERPI_V1_X.]
CyberPi_V1_0_PCB.pdf [For non-Yuque users, click CyberPi_V1_0_PCB.]
CyberPi_Gerber.rar [For non-Yuque users, click CyberPi_Gerber.]
Hardware License: License_cern_ohl_p_v2.pdf [For non-Yuque users, click License_cern_ohl_p_v2.]
Software License: GPL v3
Documentation License: CC BY-SA 4.0 International

3D model

If you want to design and print some 3D models to work with CyberPi, refer to the 3D model of CyberPi.

3D model of CyberPi

image.png
CyberPi.rar [For non-Yuque users, click CyberPi.]

3D model of Pocket Shield

image.png
Pocket Shield.rar [For non-Yuque users, click Pocket Shield.]

Third-party compatibility

You can use the 3-pin ports on Pocket Shield to connect and control third-party parts or modules, such as Arduino modules.

Related blocks and Python APIs are provided, as described in the following.

Blocks

image.png

Python APIs

**cyberpi.pocket.write_digital(val, port)**
Sets the digital input for the specified pin(s)
Parameters:

  • val: digital input
  • port: int or str, port where the pins are located

Setting range:
all
s1
s2
S1
S2
1
2

**cyberpi.pocket.read_digital(port)**
Obtains the digital input for the specified pin
Parameter:

  • port: int or str, port where the pins are located

Setting range:
s1
s2
S1
S2
1
2
An int value ranging from 0 to 1 is returned, where 0 indicates a low electrical level and 1 indicates a high electrical level.

**cyberpi.pocket.set_pwm(duty, frequency, port)**
Sets the specified pin(s) to output PWM signals with the specified frequency and duty cycle
Parameters:

  • duty: int, duty cycle of the PWM signals to be output; setting range: 0–100, in percentage
  • frequency: int, frequency of the PWM signals to be output; setting range: 1–2000, in Hz
  • port: int or str, port where the pins are located

Setting range:
all
s1
s2
S1
S2
1
2

**cyberpi.pocket.read_analog(port)**
Obtains the voltage at the specified pin
Parameter:

  • port: int or str, port where the pins are located

Setting range:
s1
s2
S1
S2
1
2
A float value ranging from 0 to 5 is returned, in volts.

For more information, see the Pocket Shield Operation Guide.

Extension Builder (recommended)

With the SDK and Python APIs provided by Makeblock, you can design various block extensions to meet your needs.

Designing an extension is not as difficult as you think. Trust yourself! You can be a developer.

Open Extension Builder.
image.png
For details about how to use Extension Builder, see the Extension Builder Developer Documentation.
For details about the Python APIs, see the Python API Documentation for CyberPi.
Courses for Extension Builder are on the way. Stay tuned!

SDK for developers

To modify the underlying firmware of CyberPi, you can view the corresponding Gitee project. Note that modifications on the firmware may cause the failure of some functions, but you can update the firmware of CyberPi on mBlock 5 to restore the functions, of course.

With the SDK for developers, you can develop CyberPi in another programming environment other than mBlock 5.

Arduino SDK

Arduino is a platform widely used in the open-source hardware field, and therefore we have designed an open Arduino SDK for CyberPi. You can click the following link to modify the firmware of CyberPi and program it based on the functions it provides by using Arduino.

Visit the Arduino SDK at https://github.com/Makeblock-official/CyberPi-Library-for-Arduino.

Currently, the firmware includes the source code of the drivers for the sensors, display, and LEDs, and available interfaces are encapsulated in the drivers.

Welcome to join us to make it more powerful! We will update this project continuously to develop more features for it.

Arduino examples

Some basic example programs are provided in the following. You can download the official Arduino IDE to update and use the firmware of CyberPi.

1. Button

  1. #include "cyberpi.h"
  3. CyberPi cyber;
  4. void setup()
  5. {
  6.     Serial.begin(115200);
  7.     cyber.begin();
  8. }
  10. void loop()
  11. { 
  12.     Serial.print("a:");
  13.     Serial.print(cyber.get_button_a());
  14.     Serial.print(" b:");
  15.     Serial.print(cyber.get_button_b());
  16.     Serial.print(" menu:");
  17.     Serial.println(cyber.get_button_menu());
  18.     delay(500);
  19. }

2. Joystick

  2. #include "cyberpi.h"
  4. CyberPi cyber;
  5. void setup()
  6. {
  7.     Serial.begin(115200);
  8.     cyber.begin();
  9. }
  11. void loop()
  12. { 
  13.     Serial.print("x:");
  14.     Serial.print(cyber.get_joystick_x());
  15.     Serial.print(" y:");
  16.     Serial.print(cyber.get_joystick_y());
  17.     Serial.print(" pressed:");
  18.     Serial.println(cyber.get_joystick_pressed());
  19.     delay(500);
  20. }

3. LED

  1. #include "cyberpi.h"
  3. CyberPi cyber;
  4. void setup()
  5. {
  6.     cyber.begin();
  7. }
  8. float j, f, k;
  10. void loop()
  11. { 
  12.     for(uint8_t t = 0; t < 5; t++)
  13.     {
  14.         uint8_t red    = 32 * (1 + sin(t / 2.0 + j / 4.0) );
  15.         uint8_t green = 32 * (1 + sin(t / 1.0 + f / 9.0 + 2.1) );
  16.         uint8_t blue = 32 * (1 + sin(t / 3.0 + k / 14.0 + 4.2) );
  17.         cyber.set_rgb(t, red, green, blue);
  18.     }
  19.     j += random(1, 6) / 6.0;
  20.     f += random(1, 6) / 6.0;
  21.     k += random(1, 6) / 6.0;
  22.     delay(10);
  23. }

4. Light sensor

  1. #include "cyberpi.h"
  3. CyberPi cyber;
  4. void setup()
  5. {
  6.     Serial.begin(115200);
  7.     cyber.begin();
  8. }
  10. void loop()
  11. { 
  12.     Serial.print("light:");
  13.     Serial.println(cyber.get_light());
  14.     delay(500);
  15. }

5. Gyroscope

  1. #include "cyberpi.h"
  3. CyberPi cyber;
  4. void setup()
  5. {
  6.     Serial.begin(115200);
  7.     cyber.begin();
  8. }
  10. void loop()
  11. {    
  12.     Serial.print("roll:");
  13.     Serial.print(cyber.get_roll());
  14.     Serial.print(" pitch:");
  15.     Serial.println(cyber.get_pitch());
  16.     delay(25);
  17. }

6. Display

  1. #include "cyberpi.h"
  3. CyberPi cyber;
  4. void setup()
  5. {
  6.     Serial.begin(115200);
  7.     cyber.begin();
  8.     for(int y=0;y<128;y++)
  9.     {
  10.         for(int x=0;x<128;x++)
  11.         {
  12.             int R = (128-x)*255/128;
  13.             int G = x*255/128;
  14.             int B = y*255/128;
  15.             cyber.set_lcd_pixel(x,y,cyber.swap_color(cyber.color24_to_16((R<<16)+(G<<8)+B)));
  16.         }
  17.     }
  18.     cyber.render_lcd();
  19. }
  20. void loop()
  21. { 
  22.     cyber.set_lcd_light(false);
  23.     delay(2000);
  24.     cyber.set_lcd_light(true);
  25.     delay(2000);
  26. }

7. Points

  1. #include "cyberpi.h"
  3. CyberPi cyber;
  4. #define POINTS_COUNT 200
  5. Bitmap points[POINTS_COUNT];
  6. float speed_x[POINTS_COUNT];
  7. float speed_y[POINTS_COUNT];
  8. void setup() {
  9.     Serial.begin(112500);
  10.     delay(1000);
  11.     cyber.begin();
  12.     for(int i=0;i<POINTS_COUNT;i++)
  13.     {
  14.         points[i].x = 64;
  15.         points[i].y = 64;
  16.         speed_x[i] = random(100)/20.0f-2.5f;
  17.         speed_y[i] = random(100)/20.0f-2.5f;
  18.         points[i].width = 1;
  19.         points[i].height = 1;
  20.         points[i].buffer = (uint16_t*)cyber.malloc(2);
  21.         points[i].buffer[0] = 0xffff;
  22.     }
  23. }
  25. void loop() 
  26. {
  27.     cyber.clean_lcd();
  28.     for(int i=0;i<POINTS_COUNT;i++)
  29.     {
  30.         cyber.set_bitmap(points[i].x,points[i].y,&points[i]);
  31.         points[i].x+=speed_x[i];
  32.         points[i].y+=speed_y[i];
  33.         if(points[i].x<0||points[i].y<0||points[i].x>127||points[i].y>127)
  34.         {
  35.             points[i].x = 64;
  36.             points[i].y = 64;
  37.         }
  38.     }
  39.     cyber.render_lcd();
  40. }

8. Text

  1. #include "cyberpi.h"
  3. CyberPi cyber;
  4. uint8_t samples[128];
  5. int idx = 0;
  7. void setup() 
  8. {
  9.     Serial.begin(112500);
  10.     delay(1000);
  11.     cyber.begin();
  12.     int font_size = 16;
  13.     Bitmap *bitmap1 = cyber.create_text(L"你好",0xffff,font_size);
  14.     cyber.set_bitmap(4,4,bitmap1);
  15.     Bitmap *bitmap2 = cyber.create_text(L"簡體",0xff00,font_size);
  16.     cyber.set_bitmap(4,24,bitmap2);
  17.     Bitmap *bitmap3 = cyber.create_text(L"hello",0x00ff,font_size);
  18.     cyber.set_bitmap(4,44,bitmap3);
  19.     Bitmap *bitmap4 = cyber.create_text(L"こんにちは",0x0ff0,font_size);
  20.     cyber.set_bitmap(4,64,bitmap4);
  21.     Bitmap *bitmap5 = cyber.create_text(L"여보세요",0x0f0f,font_size);
  22.     cyber.set_bitmap(4,84,bitmap5);
  23.     Bitmap *bitmap6 = cyber.create_text(L"Привет",0xf0f0,font_size);
  24.     cyber.set_bitmap(4,104,bitmap6);
  25.     cyber.render_lcd();
  26. }
  28. void loop() 
  29. {
  31. }

9. Loudness detection

  1. #include "cyberpi.h"
  3. CyberPi cyber;
  4. uint8_t samples[128];
  5. int idx = 0;
  7. void setup() {
  8.     Serial.begin(112500);
  9.     delay(1000);
  10.     cyber.begin();
  11. }
  13. void loop() 
  14. {
  15.     if(idx<128)
  16.     {
  17.         samples[idx] = cyber.get_loudness()>>5;
  18.         idx++;
  19.     }
  20.     else
  21.     {
  22.         for(int i=0;i<128;i++)
  23.         {
  24.             samples[i] = samples[i+1];
  25.         }
  26.         samples[idx-1] = cyber.get_loudness()>>5;
  27.     }
  28.     cyber.clean_lcd();
  29.     for(int i=0;i<128;i++)
  30.     {
  31.       if(i==0)
  32.         cyber.set_lcd_pixel(i,127-samples[i],0xffff);
  33.       else
  34.       {
  35.           int min_level = MIN(samples[i-1],samples[i]);
  36.           int max_level = MAX(samples[i-1],samples[i]);
  37.           for(int j=min_level;j<=max_level;j++)
  38.           {
  39.             cyber.set_lcd_pixel(i,127-j,0xffff);
  40.           }
  41.       }
  43.     }
  44.     cyber.render_lcd();
  45.     delay(25);
  46. }

10. Microphone data

  1. #include "cyberpi.h"
  3. CyberPi cyber;
  5. int lo[7] = {48,50,52,53,55,57,59};
  6. int mo[7] = {60,62,64,65,67,69,71};
  7. int ho[7] = {72,74,76,77,79,81,83};
  8. void mic_recv(uint8_t* samples,int len) 
  9. {
  10.     cyber.clean_lcd();
  11.     for(int i=0;i<len;i+=8)
  12.     {
  13.       int current = (int8_t)samples[i+1];
  14.       if(current>-64&&current<64)
  15.       {
  16.         cyber.set_lcd_pixel(i/8,current+64,0xffff);
  17.       }
  18.     }
  19.     cyber.render_lcd();
  20. }
  22. void setup() 
  23. {
  24.     Serial.begin(112500);
  25.     delay(1000);
  26.     cyber.begin();
  27.     cyber.on_microphone_data(mic_recv);
  28.     for(int i=0;i<14;i++)
  29.     {
  30.         cyber.set_instrument(i);
  31.         int idx = 0;
  32.         while(idx<7)
  33.         {
  34.             cyber.set_pitch(0,lo[idx],100);
  35.             delay(600);
  36.             idx++;
  37.         }
  38.         idx = 0;
  39.         while(idx<7)
  40.         {
  41.             cyber.set_pitch(0,mo[idx],100);
  42.             delay(600);
  43.             idx++;
  44.         }
  45.         idx = 0;
  46.         while(idx<7)
  47.         {
  48.             cyber.set_pitch(0,ho[idx],100);
  49.             delay(600);
  50.             idx++;
  51.         }
  52.     }
  53. }
  55. void loop() 
  56. {
  58. }

11. Music property

  1. #include "cyberpi.h"
  3. CyberPi cyber;
  5. int lo[7] = {48,50,52,53,55,57,59};
  6. int mo[7] = {60,62,64,65,67,69,71};
  7. int ho[7] = {72,74,76,77,79,81,83};
  8. void data_recv(uint8_t* samples,int len)
  9. {
  10.     cyber.clean_lcd();
  11.     for(int i=0;i<len;i+=16)
  12.     {
  13.       int current = samples[i+1];
  14.       cyber.set_lcd_pixel(i/16,current-64,0xffff);
  15.     }
  16.     cyber.render_lcd();
  17. }
  18. void setup() 
  19. {
  20.     Serial.begin(112500);
  21.     delay(1000);
  22.     cyber.begin();
  23.     cyber.on_sound_data(data_recv);
  24.     for(int i=0;i<14;i++)
  25.     {
  26.         cyber.set_instrument(i);
  27.         int idx = 0;
  28.         while(idx<7)
  29.         {
  30.             cyber.set_pitch(0,lo[idx],100);
  31.             delay(600);
  32.             idx++;
  33.         }
  34.         idx = 0;
  35.         while(idx<7)
  36.         {
  37.             cyber.set_pitch(0,mo[idx],100);
  38.             delay(600);
  39.             idx++;
  40.         }
  41.         idx = 0;
  42.         while(idx<7)
  43.         {
  44.             cyber.set_pitch(0,ho[idx],100);
  45.             delay(600);
  46.             idx++;
  47.         }
  48.     }
  49. }
  51. void loop() 
  52. {
  53. }