├── .gitignore ├── LICENSE ├── README.md ├── add_support_for_circuitpython ├── README.md ├── pinmap_T-Display.png └── test.xlsx ├── arduino ├── ESP32_data_collection.xlsx ├── Pong_v3 │ └── Pong_v3.ino ├── Read_User_Setup │ └── Read_User_Setup.ino ├── TFT_Mandlebrot │ └── TFT_Mandlebrot.ino ├── TFT_Matrix │ ├── TFT_Matrix.ino │ └── bmp.h ├── TFT_Starfield │ └── TFT_Starfield.ino ├── TFT_Text │ └── TFT_Text.ino ├── TFT_Voltage │ ├── NotoSansBold15.h │ └── TFT_Voltage.ino ├── TFT_hello_world │ ├── NotoSansBold15.h │ └── TFT_hello_world.ino ├── TFT_power-consumption │ └── TFT_power-consumption.ino ├── WiFiScan │ └── WiFiScan.ino ├── factory │ ├── bmp.h │ └── factory.ino ├── factory2 │ ├── bmp.h │ ├── factory2.ino │ └── source │ │ ├── bmp_ttgo.h │ │ ├── logo.c │ │ ├── logo.png │ │ ├── logo1.c │ │ └── logo1.png ├── power-consumption │ └── power-consumption.ino └── ramspeed │ ├── ramspeed.ino │ └── ramspeed_results.txt ├── circuitpython9 ├── boot.py ├── boot_rp2040.py ├── code.py ├── config.py ├── fonts │ └── LeagueSpartan-Bold-16.pcf ├── lib │ ├── adafruit_bitmap_font │ │ ├── __init__.py │ │ ├── bdf.mpy │ │ ├── bitmap_font.mpy │ │ ├── glyph_cache.mpy │ │ ├── pcf.mpy │ │ └── ttf.mpy │ ├── adafruit_display_text │ │ ├── __init__.mpy │ │ ├── bitmap_label.mpy │ │ ├── label.mpy │ │ └── scrolling_label.mpy │ ├── adafruit_displayio_ssd1306.mpy │ ├── adafruit_st7789.mpy │ └── neopixel.mpy └── menu │ ├── Blinky.py │ ├── Calculate_Primes.py │ ├── Mandelbrot.py │ ├── Moving_Disks.py │ ├── Pinmap_of_this_board.py │ ├── TFT_Hello_World.py │ ├── TFT_Test.py │ ├── i2c_scanner.py │ ├── oled_128x64.py │ └── oled_128x64_button.py ├── circuitpython_T-PicoC3 ├── apps │ ├── blink.py │ ├── led.py │ ├── pin_board.py │ ├── pinmap.py │ ├── prime5.4.py │ ├── prime_to_100M.py │ ├── scan_pins.py │ └── tft_example.py ├── boot.py ├── code.py ├── fonts │ ├── Junction-regular-24.pcf │ ├── LeagueSpartan-Bold-16.bdf │ └── LeagueSpartan-Bold-16.pcf ├── lib │ ├── adafruit_bitmap_font │ │ ├── __init__.py │ │ ├── bdf.mpy │ │ ├── bitmap_font.mpy │ │ ├── glyph_cache.mpy │ │ ├── pcf.mpy │ │ └── ttf.mpy │ ├── adafruit_display_text │ │ ├── __init__.mpy │ │ ├── bitmap_label.mpy │ │ ├── label.mpy │ │ └── scrolling_label.mpy │ └── adafruit_st7789.mpy └── menu │ ├── Blinky.py │ ├── Calculate_Primes.py │ ├── Pinmap_of_this_board.py │ └── tft_example.py ├── circuitpython_esp32 ├── apps │ ├── blink.py │ ├── led.py │ ├── led2.py │ ├── pin_board.py │ ├── pinmap.py │ ├── scan_pins.py │ ├── tft_example.py │ ├── tft_test2.py │ └── tft_works.py └── code.py ├── circuitpython_rpi2040 ├── apps │ ├── blink.py │ ├── led.py │ ├── pin_board.py │ ├── pinmap.py │ ├── prime5.4.py │ ├── prime_to_100M.py │ ├── scan_pins.py │ └── tft_example.py ├── boot.py ├── code.py ├── data │ ├── 100.txt │ ├── 1000.txt │ ├── 10000.txt │ ├── 100000.txt │ ├── 1000000.txt │ └── summary.txt ├── fonts │ ├── Junction-regular-24.pcf │ ├── LeagueSpartan-Bold-16.bdf │ └── LeagueSpartan-Bold-16.pcf ├── lib │ ├── adafruit_bitmap_font │ │ ├── __init__.py │ │ ├── bdf.mpy │ │ ├── bitmap_font.mpy │ │ ├── glyph_cache.mpy │ │ ├── pcf.mpy │ │ └── ttf.mpy │ ├── adafruit_display_text │ │ ├── __init__.mpy │ │ ├── bitmap_label.mpy │ │ ├── label.mpy │ │ └── scrolling_label.mpy │ └── adafruit_st7789.mpy └── menu │ ├── Blinky.py │ ├── Calculate_Primes.py │ ├── Pinmap_of_this_board.py │ └── tft_example.py ├── docs ├── README.md ├── TTGO_T-Display_schematics.pdf ├── _config.yml ├── _layouts │ └── default.html ├── assets │ └── css │ │ ├── style.scss │ │ ├── style_reference.scss │ │ └── style_simple.scss ├── bat_divider.png ├── bat_esp32.png ├── index.md ├── pinmap_t-display.jpg ├── qwiic.png ├── starfield.gif ├── x254-i2c.jpg └── xh254.jpg ├── esp32s3 ├── README.md ├── adafruit_circuitpython_entry │ ├── board.c │ ├── mpconfigboard.h │ ├── mpconfigboard.mk │ ├── pins.c │ └── sdkconfig.txt ├── circuitpython │ ├── apps │ │ ├── blinka.jpg │ │ ├── display.py │ │ ├── example.py │ │ ├── hello_world_tft240_st7789.py │ │ ├── main.py │ │ ├── mandelbrot.py │ │ ├── prime.py │ │ ├── prime_logging_51.py │ │ └── prime_rp2040.py │ ├── boot.py │ ├── boot_out.txt │ ├── code.py │ ├── code_N8R8.py │ ├── lib │ │ ├── adafruit_debouncer.mpy │ │ ├── adafruit_display_text │ │ │ ├── __init__.mpy │ │ │ ├── bitmap_label.mpy │ │ │ ├── label.mpy │ │ │ └── scrolling_label.mpy │ │ └── adafruit_st7789.mpy │ ├── menu │ │ ├── Button_test.py │ │ ├── Mandelbrot.py │ │ └── Prime10000.py │ └── settings.toml ├── info_arduino.txt ├── info_circuitpython.txt └── info_tft.txt ├── micropython ├── README.md ├── apps │ ├── boot_blink_post.py │ ├── helloworld.py │ ├── led1.py │ ├── led2.py │ ├── led3.py │ ├── led4.py │ ├── led5.py │ ├── led6.py │ ├── led7.py │ ├── pinmap.py │ ├── prime.py │ ├── prime1.py │ ├── prime2.py │ ├── prime3.py │ ├── prime4.py │ ├── prime5.py │ └── temperature_tft_mqtt.py ├── prime10000_esp32_fast.py └── tft │ ├── calibrate_adc.py │ ├── calibration.xlsx │ ├── hello_world.py │ ├── temperature_tft_mqtt.py │ └── ttgo_hello.py └── pinmap ├── README.md ├── USB_VID_PID.xlsx ├── pinmap esp32 and rp2040 in circuitpython.xlsx ├── pinmap_T-Display.png ├── pinmap_T-PicoC3.jpg ├── pinmap_T-display-RP2040.jpg ├── pinmap_T8-ST7789.jpg ├── pinmap_esp32.jpg └── pinmaps.xlsx /.gitignore: -------------------------------------------------------------------------------- 1 | # Synology Diskstation 2 | .DS_Store 3 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 Matthias Kreier 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /add_support_for_circuitpython/pinmap_T-Display.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/add_support_for_circuitpython/pinmap_T-Display.png -------------------------------------------------------------------------------- /add_support_for_circuitpython/test.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/add_support_for_circuitpython/test.xlsx -------------------------------------------------------------------------------- /arduino/ESP32_data_collection.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/arduino/ESP32_data_collection.xlsx -------------------------------------------------------------------------------- /arduino/Pong_v3/Pong_v3.ino: -------------------------------------------------------------------------------- 1 | /* 2 | * Pong 3 | * Original Code from https://github.com/rparrett/pongclock 4 | * 5 | */ 6 | 7 | #define BLACK 0x0000 8 | #define WHITE 0xFFFF 9 | #define GREY 0x5AEB 10 | 11 | #include // Graphics and font library for ST7735 driver chip 12 | #include 13 | 14 | TFT_eSPI tft = TFT_eSPI(); // Invoke library, pins defined in User_Setup.h 15 | 16 | int16_t h = 135; 17 | int16_t w = 240; 18 | 19 | int dly = 10; 20 | 21 | int16_t paddle_h = 25; 22 | int16_t paddle_w = 2; 23 | 24 | int16_t lpaddle_x = 0; 25 | int16_t rpaddle_x = w - paddle_w; 26 | 27 | int16_t lpaddle_y = 0; 28 | int16_t rpaddle_y = h - paddle_h; 29 | 30 | int16_t lpaddle_d = 1; 31 | int16_t rpaddle_d = -1; 32 | 33 | int16_t lpaddle_ball_t = w - w / 4; 34 | int16_t rpaddle_ball_t = w / 4; 35 | 36 | int16_t target_y = 0; 37 | 38 | int16_t ball_x = 2; 39 | int16_t ball_y = 2; 40 | int16_t oldball_x = 2; 41 | int16_t oldball_y = 2; 42 | 43 | int16_t ball_dx = 1; 44 | int16_t ball_dy = 1; 45 | 46 | int16_t ball_w = 4; 47 | int16_t ball_h = 4; 48 | 49 | int16_t dashline_h = 4; 50 | int16_t dashline_w = 2; 51 | int16_t dashline_n = h / dashline_h; 52 | int16_t dashline_x = w / 2 - 1; 53 | int16_t dashline_y = dashline_h / 2; 54 | 55 | int16_t lscore = 12; 56 | int16_t rscore = 4; 57 | 58 | void setup(void) { 59 | 60 | randomSeed(analogRead(0)*analogRead(1)); 61 | 62 | tft.init(); 63 | 64 | tft.setRotation(1); 65 | 66 | tft.fillScreen(BLACK); 67 | 68 | initgame(); 69 | 70 | tft.setTextColor(WHITE, BLACK); 71 | 72 | delay(2000); 73 | 74 | } 75 | 76 | void loop() { 77 | delay(dly); 78 | 79 | lpaddle(); 80 | rpaddle(); 81 | 82 | midline(); 83 | 84 | ball(); 85 | } 86 | 87 | void initgame() { 88 | lpaddle_y = random(0, h - paddle_h); 89 | rpaddle_y = random(0, h - paddle_h); 90 | 91 | // ball is placed on the center of the left paddle 92 | ball_y = lpaddle_y + (paddle_h / 2); 93 | 94 | calc_target_y(); 95 | 96 | midline(); 97 | 98 | tft.fillRect(0,h-26,w,h-1,BLACK); 99 | 100 | tft.setTextDatum(TC_DATUM); 101 | tft.setTextColor(WHITE); 102 | tft.drawString("TFT_eSPI example", w/2, h-26 , 2); 103 | } 104 | 105 | void midline() { 106 | 107 | // If the ball is not on the line then don't redraw the line 108 | if ((ball_x dashline_x+dashline_w)) return; 109 | 110 | tft.startWrite(); 111 | 112 | // Quick way to draw a dashed line 113 | tft.setAddrWindow(dashline_x, 0, dashline_w, h); 114 | 115 | for(int16_t i = 0; i < dashline_n; i+=2) { 116 | tft.pushColor(WHITE, dashline_w*dashline_h); // push dash pixels 117 | tft.pushColor(BLACK, dashline_w*dashline_h); // push gap pixels 118 | } 119 | 120 | tft.endWrite(); 121 | } 122 | 123 | void lpaddle() { 124 | 125 | if (lpaddle_d == 1) { 126 | tft.fillRect(lpaddle_x, lpaddle_y, paddle_w, 1, BLACK); 127 | } 128 | else if (lpaddle_d == -1) { 129 | tft.fillRect(lpaddle_x, lpaddle_y + paddle_h - 1, paddle_w, 1, BLACK); 130 | } 131 | 132 | lpaddle_y = lpaddle_y + lpaddle_d; 133 | 134 | if (ball_dx == 1) lpaddle_d = 0; 135 | else { 136 | if (lpaddle_y + paddle_h / 2 == target_y) lpaddle_d = 0; 137 | else if (lpaddle_y + paddle_h / 2 > target_y) lpaddle_d = -1; 138 | else lpaddle_d = 1; 139 | } 140 | 141 | if (lpaddle_y + paddle_h >= h && lpaddle_d == 1) lpaddle_d = 0; 142 | else if (lpaddle_y <= 0 && lpaddle_d == -1) lpaddle_d = 0; 143 | 144 | tft.fillRect(lpaddle_x, lpaddle_y, paddle_w, paddle_h, WHITE); 145 | } 146 | 147 | void rpaddle() { 148 | 149 | if (rpaddle_d == 1) { 150 | tft.fillRect(rpaddle_x, rpaddle_y, paddle_w, 1, BLACK); 151 | } 152 | else if (rpaddle_d == -1) { 153 | tft.fillRect(rpaddle_x, rpaddle_y + paddle_h - 1, paddle_w, 1, BLACK); 154 | } 155 | 156 | rpaddle_y = rpaddle_y + rpaddle_d; 157 | 158 | if (ball_dx == -1) rpaddle_d = 0; 159 | else { 160 | if (rpaddle_y + paddle_h / 2 == target_y) rpaddle_d = 0; 161 | else if (rpaddle_y + paddle_h / 2 > target_y) rpaddle_d = -1; 162 | else rpaddle_d = 1; 163 | } 164 | 165 | if (rpaddle_y + paddle_h >= h && rpaddle_d == 1) rpaddle_d = 0; 166 | else if (rpaddle_y <= 0 && rpaddle_d == -1) rpaddle_d = 0; 167 | 168 | tft.fillRect(rpaddle_x, rpaddle_y, paddle_w, paddle_h, WHITE); 169 | } 170 | 171 | void calc_target_y() { 172 | int16_t target_x; 173 | int16_t reflections; 174 | int16_t y; 175 | 176 | if (ball_dx == 1) { 177 | target_x = w - ball_w; 178 | } 179 | else { 180 | target_x = -1 * (w - ball_w); 181 | } 182 | 183 | y = abs(target_x * (ball_dy / ball_dx) + ball_y); 184 | 185 | reflections = floor(y / h); 186 | 187 | if (reflections % 2 == 0) { 188 | target_y = y % h; 189 | } 190 | else { 191 | target_y = h - (y % h); 192 | } 193 | } 194 | 195 | void ball() { 196 | ball_x = ball_x + ball_dx; 197 | ball_y = ball_y + ball_dy; 198 | 199 | if (ball_dx == -1 && ball_x == paddle_w && ball_y + ball_h >= lpaddle_y && ball_y <= lpaddle_y + paddle_h) { 200 | ball_dx = ball_dx * -1; 201 | dly = random(5); // change speed of ball after paddle contact 202 | calc_target_y(); 203 | } else if (ball_dx == 1 && ball_x + ball_w == w - paddle_w && ball_y + ball_h >= rpaddle_y && ball_y <= rpaddle_y + paddle_h) { 204 | ball_dx = ball_dx * -1; 205 | dly = random(5); // change speed of ball after paddle contact 206 | calc_target_y(); 207 | } else if ((ball_dx == 1 && ball_x >= w) || (ball_dx == -1 && ball_x + ball_w < 0)) { 208 | dly = 5; 209 | } 210 | 211 | if (ball_y > h - ball_w || ball_y < 0) { 212 | ball_dy = ball_dy * -1; 213 | ball_y += ball_dy; // Keep in bounds 214 | } 215 | 216 | //tft.fillRect(oldball_x, oldball_y, ball_w, ball_h, BLACK); 217 | tft.drawRect(oldball_x, oldball_y, ball_w, ball_h, BLACK); // Less TFT refresh aliasing than line above for large balls 218 | tft.fillRect( ball_x, ball_y, ball_w, ball_h, WHITE); 219 | oldball_x = ball_x; 220 | oldball_y = ball_y; 221 | } 222 | -------------------------------------------------------------------------------- /arduino/TFT_Mandlebrot/TFT_Mandlebrot.ino: -------------------------------------------------------------------------------- 1 | // Mandlebrot 2 | 3 | // This will run quite slowly due to the large number of floating point calculations per pixel 4 | 5 | #include // Hardware-specific library 6 | #include 7 | 8 | TFT_eSPI tft = TFT_eSPI(); // Invoke custom library 9 | 10 | #define TFT_GREY 0x7BEF 11 | 12 | unsigned long runTime = 0; 13 | 14 | float sx = 0, sy = 0; 15 | uint16_t x0 = 0, x1 = 0, yy0 = 0, yy1 = 0; 16 | uint16_t max_x = 240, max_y = 135; 17 | 18 | 19 | void setup() 20 | { 21 | Serial.begin(115200); 22 | //randomSeed(analogRead(A0)); 23 | Serial.println(); 24 | // Setup the LCD 25 | tft.init(); 26 | tft.setRotation(3); 27 | } 28 | 29 | void loop() 30 | { 31 | runTime = millis(); 32 | 33 | tft.fillScreen(TFT_BLACK); 34 | tft.startWrite(); 35 | for (int px = 1; px < max_x; px++) 36 | { 37 | for (int py = 0; py < max_y; py++) 38 | { 39 | float x0 = (map(px, 0, max_x, -250000/2, -242500/2)) / 100000.0; //scaled x coordinate of pixel (scaled to lie in the Mandelbrot X scale (-2.5, 1)) 40 | float yy0 = (map(py, 0, max_y, -75000/4, -61000/4)) / 100000.0; //scaled y coordinate of pixel (scaled to lie in the Mandelbrot Y scale (-1, 1)) 41 | float xx = 0.0; 42 | float yy = 0.0; 43 | int iteration = 0; 44 | int max_iteration = 128; 45 | while ( ((xx * xx + yy * yy) < 4) && (iteration < max_iteration) ) 46 | { 47 | float xtemp = xx * xx - yy * yy + x0; 48 | yy = 2 * xx * yy + yy0; 49 | xx = xtemp; 50 | iteration++; 51 | } 52 | int color = rainbow((3*iteration+64)%128); 53 | yield();tft.drawPixel(px, py, color); 54 | } 55 | } 56 | tft.endWrite(); 57 | 58 | Serial.println(millis()-runTime); 59 | while(1) yield(); 60 | } 61 | 62 | unsigned int rainbow(int value) 63 | { 64 | // Value is expected to be in range 0-127 65 | // The value is converted to a spectrum colour from 0 = blue through to red = blue 66 | 67 | byte red = 0; // Red is the top 5 bits of a 16 bit colour value 68 | byte green = 0;// Green is the middle 6 bits 69 | byte blue = 0; // Blue is the bottom 5 bits 70 | 71 | byte quadrant = value / 32; 72 | 73 | if (quadrant == 0) { 74 | blue = 31; 75 | green = 2 * (value % 32); 76 | red = 0; 77 | } 78 | if (quadrant == 1) { 79 | blue = 31 - (value % 32); 80 | green = 63; 81 | red = 0; 82 | } 83 | if (quadrant == 2) { 84 | blue = 0; 85 | green = 63; 86 | red = value % 32; 87 | } 88 | if (quadrant == 3) { 89 | blue = 0; 90 | green = 63 - 2 * (value % 32); 91 | red = 31; 92 | } 93 | return (red << 11) + (green << 5) + blue; 94 | } 95 | -------------------------------------------------------------------------------- /arduino/TFT_Matrix/TFT_Matrix.ino: -------------------------------------------------------------------------------- 1 | // A fun MATRIX-like screen demo of scrolling 2 | // Screen will flicker initially until fully drawn 3 | // then scroll smoothly 4 | 5 | // Needs GLCD font 6 | // adapted for 135x240 screen from TTGO T-Display 7 | 8 | // Here https://github.com/Bodmer/TFT_eSPI/issues/493 the comment ghostoy solved the problem 9 | 10 | /* 11 | Make sure all the display driver and pin comnenctions are correct by 12 | editting the User_Setup.h file in the TFT_eSPI library folder. 13 | 14 | ######################################################################### 15 | ###### DON'T FORGET TO UPDATE THE User_Setup.h FILE IN THE LIBRARY ###### 16 | ######################################################################### 17 | */ 18 | 19 | #include // Hardware-specific library 20 | #include 21 | 22 | TFT_eSPI tft = TFT_eSPI(); // Invoke custom library 23 | 24 | #define TEXT_HEIGHT 8 // Height of text to be printed and scrolled 25 | #define BOT_FIXED_AREA 40 // Number of lines in bottom fixed area (lines counted from bottom of screen) 26 | #define TOP_FIXED_AREA 40 // Number of lines in top fixed area (lines counted from top of screen) 27 | 28 | uint16_t yStart = TOP_FIXED_AREA; 29 | uint16_t yArea = 320 - TOP_FIXED_AREA - BOT_FIXED_AREA; 30 | uint16_t yDraw = 240 - TEXT_HEIGHT; 31 | byte pos[42]; 32 | uint16_t xPos = 0; 33 | 34 | void setup() { 35 | Serial.begin(115200); 36 | randomSeed(analogRead(A0)); 37 | tft.init(); 38 | tft.setRotation(0); 39 | tft.fillScreen(TFT_BLACK); 40 | setupScrollArea(TOP_FIXED_AREA, BOT_FIXED_AREA); 41 | } 42 | 43 | void loop(void) { 44 | // First fill the screen with random streaks of characters 45 | for (int j = 0; j < 600; j += TEXT_HEIGHT) { 46 | for (int i = 0; i < 40; i++) { 47 | if (pos[i] > 20) pos[i] -= 3; // Rapid fade initially brightness values 48 | if (pos[i] > 0) pos[i] -= 1; // Slow fade later 49 | if ((random(20) == 1) && (j<400)) pos[i] = 63; // ~1 in 20 probability of a new character 50 | tft.setTextColor(pos[i] << 5, TFT_BLACK); // Set the green character brightness 51 | if (pos[i] == 63) tft.setTextColor(TFT_WHITE, TFT_BLACK); // Draw white character 52 | xPos += tft.drawChar(random(32, 128), xPos, yDraw, 1); // Draw the character 53 | } 54 | yDraw = scroll_slow(TEXT_HEIGHT, 14); // Scroll, 14ms per pixel line 55 | xPos = 0; 56 | } 57 | 58 | //tft.setRotation(2); 59 | //tft.setTextColor(63 << 5, ILI9341_BLACK); 60 | //tft.drawCentreString("MATRIX",120,60,4); 61 | //tft.setRotation(0); 62 | 63 | // Now scroll smoothly forever 64 | while (1) {yield(); yDraw = scroll_slow(320,5); }// Scroll 320 lines, 5ms per line 65 | 66 | } 67 | 68 | void setupScrollArea(uint16_t TFA, uint16_t BFA) { 69 | tft.writecommand(ST7789_VSCRDEF); // Vertical scroll definition 70 | tft.writedata(TFA >> 8); 71 | tft.writedata(TFA); 72 | tft.writedata((320 - TFA - BFA) >> 8); 73 | tft.writedata(320 - TFA - BFA); 74 | tft.writedata(BFA >> 8); 75 | tft.writedata(BFA); 76 | } 77 | 78 | int scroll_slow(int lines, int wait) { 79 | int yTemp = yStart; 80 | for (int i = 0; i < lines; i++) { 81 | yStart++; 82 | if (yStart == 320 - BOT_FIXED_AREA) yStart = TOP_FIXED_AREA; 83 | scrollAddress(yStart); 84 | delay(wait); 85 | } 86 | return yTemp - 40; 87 | } 88 | 89 | void scrollAddress(uint16_t VSP) { 90 | tft.writecommand(0x37); // Vertical scrolling start address ILI9341_VSCRSADD 91 | tft.writedata(VSP >> 8); 92 | tft.writedata(VSP); 93 | } 94 | -------------------------------------------------------------------------------- /arduino/TFT_Starfield/TFT_Starfield.ino: -------------------------------------------------------------------------------- 1 | // Animates white pixels to simulate flying through a star field 2 | // updated 2020-11-09 for 135x240 TFT display of TTGO T-Display 3 | 4 | #include 5 | #include 6 | 7 | // Use hardware SPI 8 | TFT_eSPI tft = TFT_eSPI(); 9 | 10 | int16_t h = 135; 11 | int16_t w = 240; 12 | 13 | // With 1024 stars the update rate is ~65 frames per second 14 | #define NSTARS 1024 15 | uint8_t sx[NSTARS] = {}; 16 | uint8_t sy[NSTARS] = {}; 17 | uint8_t sz[NSTARS] = {}; 18 | 19 | uint8_t za, zb, zc, zx; 20 | 21 | // Fast 0-255 random number generator from http://eternityforest.com/Projects/rng.php: 22 | uint8_t __attribute__((always_inline)) rng() 23 | { 24 | zx++; 25 | za = (za^zc^zx); 26 | zb = (zb+za); 27 | zc = ((zc+(zb>>1))^za); 28 | return zc; 29 | } 30 | 31 | void setup() { 32 | za = random(256); 33 | zb = random(256); 34 | zc = random(256); 35 | zx = random(256); 36 | 37 | Serial.begin(115200); 38 | tft.init(); 39 | tft.setRotation(1); 40 | tft.fillScreen(TFT_BLACK); 41 | 42 | // fastSetup() must be used immediately before fastPixel() to prepare screen 43 | // It must be called after any other graphics drawing function call if fastPixel() 44 | // is to be called again 45 | //tft.fastSetup(); // Prepare plot window range for fast pixel plotting 46 | } 47 | 48 | void loop() 49 | { 50 | unsigned long t0 = micros(); 51 | uint8_t spawnDepthVariation = 255; 52 | 53 | for(int i = 0; i < NSTARS; ++i) 54 | { 55 | if (sz[i] <= 1) 56 | { 57 | sx[i] = w/2 - h/2 + rng(); 58 | sy[i] = rng(); 59 | sz[i] = spawnDepthVariation--; 60 | } 61 | else 62 | { 63 | int old_screen_x = ((int)sx[i] - w/2) * 256 / sz[i] + w/2; 64 | int old_screen_y = ((int)sy[i] - h/2) * 256 / sz[i] + h/2; 65 | 66 | // This is a faster pixel drawing function for occassions where many single pixels must be drawn 67 | tft.drawPixel(old_screen_x, old_screen_y,TFT_BLACK); 68 | 69 | sz[i] -= 2; 70 | if (sz[i] > 1) 71 | { 72 | int screen_x = ((int)sx[i] - w/2) * 256 / sz[i] + w/2; 73 | int screen_y = ((int)sy[i] - h/2) * 256 / sz[i] + h/2; 74 | 75 | if (screen_x >= 0 && screen_y >= 0 && screen_x < 320 && screen_y < 240) 76 | { 77 | uint8_t r, g, b; 78 | r = g = b = 255 - sz[i]; 79 | tft.drawPixel(screen_x, screen_y, tft.color565(r,g,b)); 80 | } 81 | else 82 | sz[i] = 0; // Out of screen, die. 83 | } 84 | } 85 | } 86 | unsigned long t1 = micros(); 87 | //static char timeMicros[8] = {}; 88 | 89 | // Calcualte frames per second 90 | Serial.println(1.0/((t1 - t0)/1000000.0)); 91 | } 92 | -------------------------------------------------------------------------------- /arduino/TFT_Text/TFT_Text.ino: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | TFT_eSPI tft = TFT_eSPI(); 5 | 6 | void setup() { 7 | tft.init(); 8 | tft.fillScreen(TFT_BLACK); 9 | tft.setCursor(0, 0); 10 | tft.setTextColor(TFT_GREEN); 11 | } 12 | 13 | void loop() { 14 | tft.print("Hello world! "); 15 | delay(1000); 16 | // pinMode(4, OUTPUT); 17 | // digitalWrite(4, LOW); switch off backlight 18 | } 19 | -------------------------------------------------------------------------------- /arduino/TFT_Voltage/TFT_Voltage.ino: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "NotoSansBold15.h" 4 | #include "esp_adc_cal.h" 5 | 6 | const int pin[13] = {36, 37, 38, 39, 32, 33, 27, 25, 26, 2, 15, 13, 12}; 7 | const int batteryPin = 34; 8 | 9 | int battery; 10 | int volt; 11 | int vref = 1100; 12 | 13 | TFT_eSPI tft = TFT_eSPI(); 14 | 15 | void setup() { 16 | Serial.begin(115200); 17 | tft.init(); 18 | tft.loadFont(NotoSansBold15); 19 | tft.setTextColor(TFT_GREEN); 20 | 21 | esp_adc_cal_characteristics_t adc_chars; 22 | esp_adc_cal_value_t val_type = esp_adc_cal_characterize((adc_unit_t)ADC_UNIT_1, (adc_atten_t)ADC1_CHANNEL_6, (adc_bits_width_t)ADC_WIDTH_BIT_12, 1100, &adc_chars); 23 | //Check type of calibration value used to characterize ADC 24 | if (val_type == ESP_ADC_CAL_VAL_EFUSE_VREF) { 25 | Serial.printf("eFuse Vref:%u mV", adc_chars.vref); 26 | vref = adc_chars.vref; 27 | } else if (val_type == ESP_ADC_CAL_VAL_EFUSE_TP) { 28 | Serial.printf("Two Point --> coeff_a:%umV coeff_b:%umV\n", adc_chars.coeff_a, adc_chars.coeff_b); 29 | } else { 30 | Serial.println("Default Vref: 1100mV"); 31 | } 32 | } 33 | 34 | void loop() { 35 | tft.fillScreen(TFT_BLACK); 36 | tft.setCursor(0, 0); 37 | tft.setTextColor(TFT_GREEN); 38 | tft.print("Battery: "); 39 | battery = measureVoltage(batteryPin) * 2; 40 | tft.print(battery); 41 | tft.println(" mV"); 42 | tft.setTextColor(TFT_WHITE); 43 | for(int i = 0; i < 13; i++) { 44 | volt = measureVoltage(pin[i]); 45 | if(pin[i]<10) tft.print(" "); 46 | tft.print(pin[i]); 47 | tft.print(" - "); 48 | tft.print(volt); 49 | tft.println(" mV"); 50 | } 51 | delay(5000); 52 | } 53 | 54 | int measureVoltage(int measurePin) { 55 | int raw = 0; 56 | int voltage = 0; 57 | for(int j = 0; j < 100; j++ ) { 58 | raw += analogRead(measurePin); 59 | } 60 | voltage = int((float)raw / 409500.0 * 3.3 * vref); 61 | return voltage; 62 | } 63 | -------------------------------------------------------------------------------- /arduino/TFT_hello_world/TFT_hello_world.ino: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "NotoSansBold15.h" 4 | #include "esp_adc_cal.h" 5 | 6 | const int pin[13] = {36, 37, 38, 39, 32, 33, 27, 25, 26, 2, 15, 13, 12}; 7 | const int batteryPin = 34; 8 | 9 | int battery; 10 | int volt; 11 | int vref = 1100; 12 | 13 | TFT_eSPI tft = TFT_eSPI(); 14 | 15 | void setup() { 16 | Serial.begin(115200); 17 | tft.init(); 18 | tft.loadFont(NotoSansBold15); 19 | tft.setTextColor(TFT_GREEN); 20 | 21 | esp_adc_cal_characteristics_t adc_chars; 22 | esp_adc_cal_value_t val_type = esp_adc_cal_characterize((adc_unit_t)ADC_UNIT_1, (adc_atten_t)ADC1_CHANNEL_6, (adc_bits_width_t)ADC_WIDTH_BIT_12, 1100, &adc_chars); 23 | //Check type of calibration value used to characterize ADC 24 | if (val_type == ESP_ADC_CAL_VAL_EFUSE_VREF) { 25 | Serial.printf("eFuse Vref:%u mV", adc_chars.vref); 26 | vref = adc_chars.vref; 27 | } else if (val_type == ESP_ADC_CAL_VAL_EFUSE_TP) { 28 | Serial.printf("Two Point --> coeff_a:%umV coeff_b:%umV\n", adc_chars.coeff_a, adc_chars.coeff_b); 29 | } else { 30 | Serial.println("Default Vref: 1100mV"); 31 | } 32 | tft.fillScreen(TFT_BLACK); 33 | tft.setCursor(0, 0); 34 | } 35 | 36 | void loop() { 37 | tft.setTextColor(TFT_GREEN); 38 | tft.print("Hello "); 39 | tft.setTextColor(TFT_RED); 40 | tft.print("World! "); 41 | delay(1000); 42 | } 43 | 44 | int measureVoltage(int measurePin) { 45 | int raw = 0; 46 | int voltage = 0; 47 | for(int j = 0; j < 100; j++ ) { 48 | raw += analogRead(measurePin); 49 | } 50 | voltage = int((float)raw / 409500.0 * 3.3 * vref); 51 | return voltage; 52 | } 53 | -------------------------------------------------------------------------------- /arduino/WiFiScan/WiFiScan.ino: -------------------------------------------------------------------------------- 1 | /* 2 | * This sketch demonstrates how to scan WiFi networks. 3 | * The API is almost the same as with the WiFi Shield library, 4 | * the most obvious difference being the different file you need to include: 5 | */ 6 | #include "WiFi.h" 7 | 8 | void setup() 9 | { 10 | Serial.begin(115200); 11 | 12 | // Set WiFi to station mode and disconnect from an AP if it was previously connected 13 | WiFi.mode(WIFI_STA); 14 | WiFi.disconnect(); 15 | delay(100); 16 | 17 | Serial.println("Setup done"); 18 | } 19 | 20 | void loop() 21 | { 22 | Serial.println("scan start"); 23 | 24 | // WiFi.scanNetworks will return the number of networks found 25 | int n = WiFi.scanNetworks(); 26 | Serial.println("scan done"); 27 | if (n == 0) { 28 | Serial.println("no networks found"); 29 | } else { 30 | Serial.print(n); 31 | Serial.println(" networks found"); 32 | for (int i = 0; i < n; ++i) { 33 | // Print SSID and RSSI for each network found 34 | Serial.print(i + 1); 35 | Serial.print(": "); 36 | Serial.print(WiFi.SSID(i)); 37 | Serial.print(" ("); 38 | Serial.print(WiFi.RSSI(i)); 39 | Serial.print(")"); 40 | Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN)?" ":"*"); 41 | delay(10); 42 | } 43 | } 44 | Serial.println(""); 45 | 46 | // Wait a bit before scanning again 47 | delay(5000); 48 | } 49 | -------------------------------------------------------------------------------- /arduino/factory/factory.ino: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "WiFi.h" 4 | #include 5 | #include 6 | #include "esp_adc_cal.h" 7 | #include "bmp.h" 8 | 9 | #ifndef TFT_DISPOFF 10 | #define TFT_DISPOFF 0x28 11 | #endif 12 | 13 | #ifndef TFT_SLPIN 14 | #define TFT_SLPIN 0x10 15 | #endif 16 | 17 | #define TFT_MOSI 19 18 | #define TFT_SCLK 18 19 | #define TFT_CS 5 20 | #define TFT_DC 16 21 | #define TFT_RST 23 22 | 23 | #define TFT_BL 4 // Display backlight control pin 24 | #define ADC_EN 14 25 | #define ADC_PIN 34 26 | #define BUTTON_1 35 27 | #define BUTTON_2 0 28 | 29 | TFT_eSPI tft = TFT_eSPI(135, 240); // Invoke custom library 30 | Button2 btn1(BUTTON_1); 31 | Button2 btn2(BUTTON_2); 32 | 33 | char buff[512]; 34 | int vref = 1100; 35 | int btnCick = false; 36 | 37 | //! Long time delay, it is recommended to use shallow sleep, which can effectively reduce the current consumption 38 | void espDelay(int ms) 39 | { 40 | esp_sleep_enable_timer_wakeup(ms * 1000); 41 | esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH,ESP_PD_OPTION_ON); 42 | esp_light_sleep_start(); 43 | } 44 | 45 | void showVoltage() 46 | { 47 | static uint64_t timeStamp = 0; 48 | if (millis() - timeStamp > 1000) { 49 | timeStamp = millis(); 50 | uint16_t v = analogRead(ADC_PIN); 51 | float battery_voltage = ((float)v / 4095.0) * 2.0 * 3.3 * (vref / 1000.0); 52 | String voltage = "Voltage :" + String(battery_voltage) + "V"; 53 | Serial.println(voltage); 54 | tft.fillScreen(TFT_BLACK); 55 | tft.setTextDatum(MC_DATUM); 56 | tft.drawString(voltage, tft.width() / 2, tft.height() / 2 ); 57 | } 58 | } 59 | 60 | void button_init() 61 | { 62 | btn1.setLongClickHandler([](Button2 & b) { 63 | btnCick = false; 64 | int r = digitalRead(TFT_BL); 65 | tft.fillScreen(TFT_BLACK); 66 | tft.setTextColor(TFT_GREEN, TFT_BLACK); 67 | tft.setTextDatum(MC_DATUM); 68 | tft.drawString("Press again to wake up", tft.width() / 2, tft.height() / 2 ); 69 | espDelay(6000); 70 | digitalWrite(TFT_BL, !r); 71 | 72 | tft.writecommand(TFT_DISPOFF); 73 | tft.writecommand(TFT_SLPIN); 74 | esp_sleep_enable_ext1_wakeup(GPIO_SEL_35, ESP_EXT1_WAKEUP_ALL_LOW); 75 | esp_deep_sleep_start(); 76 | }); 77 | btn1.setPressedHandler([](Button2 & b) { 78 | Serial.println("Detect Voltage.."); 79 | btnCick = true; 80 | }); 81 | 82 | btn2.setPressedHandler([](Button2 & b) { 83 | btnCick = false; 84 | Serial.println("btn press wifi scan"); 85 | wifi_scan(); 86 | }); 87 | } 88 | 89 | void button_loop() 90 | { 91 | btn1.loop(); 92 | btn2.loop(); 93 | } 94 | 95 | void wifi_scan() 96 | { 97 | tft.setTextColor(TFT_GREEN, TFT_BLACK); 98 | tft.fillScreen(TFT_BLACK); 99 | tft.setTextDatum(MC_DATUM); 100 | tft.setTextSize(1); 101 | 102 | tft.drawString("Scan Network", tft.width() / 2, tft.height() / 2); 103 | 104 | WiFi.mode(WIFI_STA); 105 | WiFi.disconnect(); 106 | delay(100); 107 | 108 | int16_t n = WiFi.scanNetworks(); 109 | tft.fillScreen(TFT_BLACK); 110 | if (n == 0) { 111 | tft.drawString("no networks found", tft.width() / 2, tft.height() / 2); 112 | } else { 113 | tft.setTextDatum(TL_DATUM); 114 | tft.setCursor(0, 0); 115 | Serial.printf("Found %d net\n", n); 116 | for (int i = 0; i < n; ++i) { 117 | sprintf(buff, 118 | "[%d]:%s(%d)", 119 | i + 1, 120 | WiFi.SSID(i).c_str(), 121 | WiFi.RSSI(i)); 122 | tft.println(buff); 123 | } 124 | } 125 | WiFi.mode(WIFI_OFF); 126 | } 127 | 128 | void setup() 129 | { 130 | Serial.begin(115200); 131 | Serial.println("Start"); 132 | tft.init(); 133 | tft.setRotation(1); 134 | tft.fillScreen(TFT_BLACK); 135 | tft.setTextSize(2); 136 | tft.setTextColor(TFT_WHITE); 137 | tft.setCursor(0, 0); 138 | tft.setTextDatum(MC_DATUM); 139 | tft.setTextSize(1); 140 | 141 | if (TFT_BL > 0) { // TFT_BL has been set in the TFT_eSPI library in the User Setup file TTGO_T_Display.h 142 | pinMode(TFT_BL, OUTPUT); // Set backlight pin to output mode 143 | digitalWrite(TFT_BL, TFT_BACKLIGHT_ON); // Turn backlight on. TFT_BACKLIGHT_ON has been set in the TFT_eSPI library in the User Setup file TTGO_T_Display.h 144 | } 145 | 146 | tft.setSwapBytes(true); 147 | tft.pushImage(0, 0, 240, 135, ttgo); 148 | espDelay(5000); 149 | 150 | tft.setRotation(0); 151 | int i = 5; 152 | while (i--) { 153 | tft.fillScreen(TFT_RED); 154 | espDelay(1000); 155 | tft.fillScreen(TFT_BLUE); 156 | espDelay(1000); 157 | tft.fillScreen(TFT_GREEN); 158 | espDelay(1000); 159 | } 160 | 161 | button_init(); 162 | 163 | esp_adc_cal_characteristics_t adc_chars; 164 | esp_adc_cal_value_t val_type = esp_adc_cal_characterize((adc_unit_t)ADC_UNIT_1, (adc_atten_t)ADC1_CHANNEL_6, (adc_bits_width_t)ADC_WIDTH_BIT_12, 1100, &adc_chars); 165 | //Check type of calibration value used to characterize ADC 166 | if (val_type == ESP_ADC_CAL_VAL_EFUSE_VREF) { 167 | Serial.printf("eFuse Vref:%u mV", adc_chars.vref); 168 | vref = adc_chars.vref; 169 | } else if (val_type == ESP_ADC_CAL_VAL_EFUSE_TP) { 170 | Serial.printf("Two Point --> coeff_a:%umV coeff_b:%umV\n", adc_chars.coeff_a, adc_chars.coeff_b); 171 | } else { 172 | Serial.println("Default Vref: 1100mV"); 173 | } 174 | } 175 | 176 | 177 | 178 | void loop() 179 | { 180 | if (btnCick) { 181 | showVoltage(); 182 | } 183 | button_loop(); 184 | } 185 | -------------------------------------------------------------------------------- /arduino/factory2/source/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/arduino/factory2/source/logo.png -------------------------------------------------------------------------------- /arduino/factory2/source/logo1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/arduino/factory2/source/logo1.png -------------------------------------------------------------------------------- /arduino/ramspeed/ramspeed.ino: -------------------------------------------------------------------------------- 1 | // more information on memory for Arduino and variables in general can be found at 2 | // https://docs.arduino.cc/learn/programming/memory-guide/ 3 | // https://esphome.io/components/psram.html 4 | // The following code is taken from https://www.esp32.com/viewtopic.php?t=13356 5 | 6 | // Profile fun! microseconds to seconds 7 | double GetTime() { return (double)esp_timer_get_time() / 1000000; } 8 | 9 | int RamTest() 10 | { 11 | int rs[] = { 1,2,4,8,16,32,64,128,256,512,1024,2048,4000 }; 12 | printf("Ram Speed Test!\n\n"); 13 | char xx = 0; 14 | for (int a = 0; a < 13; a++) 15 | { 16 | printf("Read Speed 8bit ArraySize %4dkb ", rs[a]); 17 | int ramsize = rs[a] * 1024; 18 | char * rm = (char*)malloc(ramsize); 19 | 20 | int iters = 10; // Just enuff to boot the dog 21 | if (rs[a] < 512) iters = 50; 22 | double st = GetTime(); 23 | for (int b = 0; b < iters; b++) 24 | for (int c = 0; c < ramsize; c++) 25 | xx |= rm[c]; 26 | st = GetTime() - st; 27 | vTaskDelay(1); // Dog it! 28 | double speed = ((double)(iters*ramsize ) / (1024 * 1024)) / (st); 29 | printf(" time: %2.1f %2.1f mb/sec \n", st, speed); 30 | free(rm); 31 | } 32 | printf("\n"); 33 | for (int a = 0; a < 13; a++) 34 | { 35 | printf("Read Speed 16bit ArraySize %4dkb ", rs[a]); 36 | int ramsize = rs[a] * 1024; 37 | short * rm = (short*)malloc(ramsize); 38 | 39 | int iters = 10; // Just enuff to boot the dog 40 | if (rs[a] < 512) iters = 50; 41 | double st = GetTime(); 42 | for (int b = 0; b < iters; b++) 43 | for (int c = 0; c < ramsize/2; c++) 44 | xx |= rm[c]; 45 | st = GetTime() - st; 46 | vTaskDelay(1); // Dog it! 47 | double speed = ((double)(iters*ramsize) / (1024 * 1024)) / (st); 48 | printf(" time: %2.1f %2.1f mb/sec \n", st, speed); 49 | free(rm); 50 | } 51 | printf("\n"); 52 | for (int a = 0; a < 13; a++) 53 | { 54 | printf("Read Speed 32bit ArraySize %4dkb ", rs[a]); 55 | int ramsize = rs[a] * 1024; 56 | int * rm = (int*)malloc(ramsize); 57 | 58 | int iters = 10; // Just enuff to boot the dog 59 | if (rs[a] < 512) iters = 50; 60 | double st = GetTime(); 61 | for (int b = 0; b < iters; b++) 62 | for (int c = 0; c < ramsize/4; c++) 63 | xx |= rm[c]; 64 | st = GetTime() - st; 65 | vTaskDelay(1); // Dog it! 66 | double speed = ((double)(iters*ramsize) / (1024 * 1024)) / (st); 67 | printf(" time: %2.1f %2.1f mb/sec \n", st, speed); 68 | free(rm); 69 | } 70 | printf("Test done!\n"); 71 | return xx; 72 | } -------------------------------------------------------------------------------- /arduino/ramspeed/ramspeed_results.txt: -------------------------------------------------------------------------------- 1 | From https://www.esp32.com/viewtopic.php?t=13356 2 | ESP32 240mhz, spiram @ 80mhz 3 | 4 | in MBit/s 8bit 16bit 32bit 5 | RAM 22 45 89 6 | PSRAM 12 17 21 7 | 8 | 9 | But with 32bit CPU at 240 MHz this should be 240x32 == 7680 MBit. 10 | 11 | Octal PSRAM https://www.issi.com/ww/pdf/Octal-Memory.pdf 12 | 13 | 400 MBit/s 14 | 15 | 16 | SPI PSRAM 17 | 18 | For the reset of the above configurations: 19 | 20 | Flash and PSRAM share the same internal clock. 21 | 22 | Quad Flash only supports STR mode. Octal Flash may support either/both STR/DTR modes under OPI mode, depending on the flash model and the vendor. 23 | 24 | Quad PSRAM only supports STR mode, while Octal PSRAM only supports DTR mode. 25 | 26 | 27 | Modes 28 | STR mode - Single Transfer rate 29 | DTR mode - Double Transfer rate 30 | QPI mode - quad SPI having 4 data lines instead of one 31 | QSPI, known as queued-SPI 32 | 33 | SPI - Serial Peripheral Interface 34 | PSRAM - pseudostatic (random-access) memory -------------------------------------------------------------------------------- /circuitpython9/boot.py: -------------------------------------------------------------------------------- 1 | # Start rp2040 and initiate the display 2 | # https://github.com/kreier/rp2040/blob/main/tft_st7789_240x240/boot.py 3 | # 2023/02/23 v0.2 4 | # 2023/12/29 v0.3 adjusted for CircuitPython 9.0 with fourwire 5 | 6 | from urllib.request import HTTPDigestAuthHandler 7 | import board, busio, fourwire 8 | from adafruit_st7789 import ST7789 9 | 10 | display.release_displays() 11 | 12 | if board.board_id == 'vcc_gnd_yd_rp2040' or board.board_id == 'raspberry_pi_pico_w': 13 | spi = busio.SPI(clock=board.GP10, MOSI=board.GP11) 14 | tft_cs = board.GP9 15 | tft_dc = board.GP8 16 | display_bus = fourwire.FourWire( 17 | spi, command=tft_dc, chip_select=tft_cs, reset=board.GP12 18 | ) 19 | display = ST7789(display_bus, width=240, height=240, rowstart=80, rotation=0) 20 | 21 | import digitalio, storage, time 22 | 23 | button = digitalio.DigitalInOut(board.GP3) 24 | button.direction = digitalio.Direction.INPUT 25 | button.pull = digitalio.Pull.UP 26 | led = digitalio.DigitalInOut(board.LED) 27 | led.direction = digitalio.Direction.OUTPUT 28 | led.value = True 29 | 30 | timer = 6 31 | print(f"Press the button in the next {timer} seconds to activate saving") 32 | end = time.monotonic() + timer 33 | while end - time.monotonic() > 0: 34 | if not button.value: 35 | print("write access activated") 36 | storage.remount("/", False) 37 | led.value = False 38 | if end - timer + 1 < time.monotonic(): 39 | timer -= 1 40 | print(f"{timer} seconds left | " + "*" * timer) 41 | print("Not activated") 42 | 43 | if board.board_id == 'lilygo_ttgo_tdisplay_esp32_4m': 44 | tft_dc = board.LCD_DC 45 | tft_cs = board.LCD_CS 46 | spi_clk = board.LCD_CLK 47 | spi_mosi = board.LCD_MOSI 48 | tft_rst = board.LCD_RESET 49 | backlight = board.LCD_BACKLIGHT 50 | spi = busio.SPI(spi_clk, spi_mosi) 51 | display = ST7789( 52 | display_bus, 53 | rotation=270, 54 | width=240, 55 | height=135, 56 | rowstart=40, 57 | colstart=53, 58 | backlight_pin=backlight, 59 | ) 60 | -------------------------------------------------------------------------------- /circuitpython9/boot_rp2040.py: -------------------------------------------------------------------------------- 1 | # toggle the write switch to the local file system 2023/12/22 2 | 3 | import board 4 | import busio 5 | import displayio 6 | from adafruit_st7789 import ST7789 7 | 8 | # Release any resources currently in use for the displays 9 | displayio.release_displays() 10 | 11 | tft_dc = board.LCD_DC 12 | tft_cs = board.LCD_CS 13 | spi_clk = board.LCD_CLK 14 | spi_mosi = board.LCD_MOSI 15 | tft_rst = board.LCD_RESET 16 | backlight = board.LCD_BACKLIGHT 17 | spi = busio.SPI(spi_clk, spi_mosi) 18 | 19 | display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=tft_rst) 20 | 21 | display = ST7789( 22 | display_bus, 23 | rotation=270, 24 | width=240, 25 | height=135, 26 | rowstart=40, 27 | colstart=53, 28 | backlight_pin=backlight, 29 | ) 30 | 31 | 32 | import time 33 | import board 34 | import digitalio 35 | import storage 36 | 37 | button_pin = board.BUTTON_L 38 | # T-Display rp2040 board.BUTTON_L False if pressed 39 | # rp2040 with NeoPixel board.BUTTON 40 | # T-Display ESP32-S2 board.IO0 41 | 42 | button = digitalio.DigitalInOut(button_pin) 43 | button.direction = digitalio.Direction.INPUT 44 | # button.pull = digitalio.Pull.UP 45 | 46 | led = digitalio.DigitalInOut(board.LED) 47 | led.direction = digitalio.Direction.OUTPUT 48 | led.value = True 49 | 50 | #time.sleep(1) 51 | timer = 0 52 | can_write = False 53 | print(f"Press the button in the next {timer} seconds to activate saving") 54 | end = time.monotonic() + timer 55 | print(timer) 56 | while end - time.monotonic() > 0: 57 | if not button.value: 58 | print("write access activated") 59 | storage.remount("/", False) 60 | can_write = True 61 | if end - timer + 1 < time.monotonic(): 62 | timer -= 1 63 | led.value = False 64 | time.sleep(0.1) 65 | led.value = True 66 | print(timer) 67 | if can_write: 68 | led.value = False 69 | else: 70 | led.value = True 71 | if not can_write: 72 | print("Not activated") 73 | #time.sleep(1) 74 | -------------------------------------------------------------------------------- /circuitpython9/code.py: -------------------------------------------------------------------------------- 1 | # Menu selector v0.5 for boards with display and button(s) - 2024/02/04 2 | # https://github.com/kreier/t-display/tree/main/circuitpython9 3 | 4 | import time, board, digitalio, os, terminalio, config 5 | from adafruit_display_text import label 6 | from adafruit_bitmap_font import bitmap_font 7 | 8 | LED = digitalio.DigitalInOut(config.pin_led) 9 | LED.direction = digitalio.Direction.OUTPUT 10 | LED.value = True 11 | BUTTON_NEXT = digitalio.DigitalInOut(config.pin_button_next) 12 | BUTTON_NEXT.direction = digitalio.Direction.INPUT 13 | BUTTON_OK = digitalio.DigitalInOut(config.pin_button_ok) 14 | BUTTON_OK.direction = digitalio.Direction.INPUT 15 | if config.pullup: 16 | BUTTON_NEXT.pull = digitalio.Pull.UP 17 | BUTTON_OK.pull = digitalio.Pull.UP 18 | 19 | font_file = "fonts/LeagueSpartan-Bold-16.pcf" 20 | display = config.disp 21 | 22 | programs = [] # link to all programs installed in /menu (avoid clutter from all apps in /apps) 23 | menu = [] # all menu options - can be more than fit on the display 24 | menu_item = [] # the five items that currently fit on the display 25 | selected_item = 0 26 | selected_program = 0 27 | nr_menuitems = int((display.height-12)/22) 28 | 29 | directory = os.listdir("menu") # folder for menu programs - less cluttered 30 | directory.sort() # collection of all programs are in /apps 31 | 32 | def fill_menu(first_program): 33 | for i in range(nr_menuitems): 34 | if i + first_program < len(menu): 35 | menu_item[i].text = menu[i + first_program] 36 | else: 37 | menu_item[i].text = " " 38 | 39 | # create program list in /menu but skipping deleted programs 40 | for i, x in enumerate(directory): 41 | if x[:2] != "._": 42 | programs.append(directory[i]) 43 | number_programs = len(programs) # number of installed programs 44 | 45 | # first menu item: 46 | menu.append(" Settings ") 47 | for i, x in enumerate(programs): 48 | menu.append(" " + x[:-3].replace("_", " ") + " ") # remove the .py from program files 49 | 50 | statusbar = label.Label(terminalio.FONT, text=f" CP 9.0 | {number_programs} ", color=0xCCDDFF) 51 | statusbar.x = 0 52 | statusbar.y = 6 53 | battery = label.Label(terminalio.FONT, text="100%", color=0x00FF00) 54 | battery.x = 210 55 | battery.y = 0 56 | statusbar.append(battery) 57 | font = bitmap_font.load_font(font_file) 58 | color = 0xFFFFFF 59 | menu_item = [] 60 | for i in range(nr_menuitems): 61 | menu_item.append(label.Label(font, text=" Item " + str(i) + " "*30, color=color, background_color=0x000000)) 62 | menu_item[i].x = 1 63 | menu_item[i].y = 20 + 23*i 64 | statusbar.append(menu_item[i]) 65 | fill_menu(0) 66 | display.root_group = statusbar 67 | LED.value = False 68 | 69 | menu_item[selected_item].color=0x000000 70 | menu_item[selected_item].background_color=0xFFFFFF 71 | timer = time.monotonic() 72 | while True: 73 | if not BUTTON_NEXT.value: 74 | LED.value = True 75 | menu_item[selected_item].color=0xFFFFFF 76 | menu_item[selected_item].background_color=0x000000 77 | selected_program += 1 78 | if selected_program > len(programs): 79 | selected_program = 0 80 | selected_item = nr_menuitems 81 | selected_item += 1 82 | if selected_item >= nr_menuitems: 83 | selected_item = 0 84 | fill_menu(selected_program) 85 | menu_item[selected_item].color=0x000000 86 | menu_item[selected_item].background_color=0xFFFFFF 87 | while not BUTTON_NEXT.value: 88 | pass 89 | LED.value = False 90 | if not BUTTON_OK.value: 91 | program = "menu/" + programs[selected_program - 1] 92 | print("Selected: ", program) 93 | display.root_group = None 94 | while not BUTTON_OK.value: 95 | pass 96 | BUTTON_NEXT.deinit() 97 | BUTTON_OK.deinit() 98 | LED.deinit() 99 | exec(open(program).read()) 100 | break 101 | if timer + 1 < time.monotonic(): 102 | LED.value = not LED.value 103 | timer = time.monotonic() 104 | -------------------------------------------------------------------------------- /circuitpython9/config.py: -------------------------------------------------------------------------------- 1 | # configuration for different boards and setups 2 | # 2024/02/04 3 | # output: define LED 4 | # input: define one/two/three buttons BUTTON_NEXT, BUTTON_OK, BUTTON_BACK and BUTTON_EXIT 5 | 6 | import digitalio, board 7 | 8 | pullup = False 9 | has_button_ok = True 10 | 11 | if board.board_id == 'lilygo_t_display_rp2040' or board.board_id == 'lilygo_t_picoc3': 12 | pin_led = board.LED 13 | pin_button_next = board.BUTTON_L 14 | pin_button_ok = board.BUTTON_R 15 | pin_button_exit = board.BUTTON_L 16 | disp = board.DISPLAY 17 | 18 | if board.board_id == 'lilygo_tdisplay_s3': 19 | pin_led = board.IO1 # it actually has no LED 20 | pin_button_next = board.BUTTON0 21 | pin_button_ok = board.BUTTON1 22 | pin_button_exit = board.BUTTON1 23 | disp = board.DISPLAY 24 | 25 | if board.board_id == 'lilygo_ttgo_tdisplay_esp32_4m' or board.board_id == 'lilygo_ttgo_tdisplay_esp32_16m': 26 | pin_led = board.IO12 # it actually has no LED 27 | pin_button_next = board.BUTTON0 28 | pin_button_ok = board.BUTTON1 29 | pin_button_exit = board.BUTTON0 30 | disp = board.DISPLAY 31 | pullup = True 32 | 33 | if board.board_id == 'lilygo_ttgo_t8_s2_st7789': 34 | has_button_ok = False 35 | pin_led = board.IO1 # it actually has no LED 36 | pin_button_next = board.IO0 37 | pin_button_exit = board.IO0 38 | disp = board.DISPLAY 39 | pullup = True 40 | 41 | if board.board_id == 'vcc_gnd_yd_rp2040' or board.board_id == 'raspberry_pi_pico_w': 42 | pin_led = board.LED 43 | pin_button_next = board.GP16 44 | pin_button_ok = board.GP3 45 | pin_button_next = board.GP3 46 | pullup = True 47 | import busio, displayio, fourwire 48 | from adafruit_st7789 import ST7789 49 | displayio.release_displays() 50 | spi = busio.SPI(clock=board.GP10, MOSI=board.GP11) 51 | tft_cs = board.GP9 52 | tft_dc = board.GP8 53 | display_bus = fourwire.FourWire( 54 | spi, command=tft_dc, chip_select=tft_cs, reset=board.GP12 55 | ) 56 | disp = ST7789(display_bus, width=240, height=240, rowstart=80) 57 | -------------------------------------------------------------------------------- /circuitpython9/fonts/LeagueSpartan-Bold-16.pcf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython9/fonts/LeagueSpartan-Bold-16.pcf -------------------------------------------------------------------------------- /circuitpython9/lib/adafruit_bitmap_font/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython9/lib/adafruit_bitmap_font/__init__.py -------------------------------------------------------------------------------- /circuitpython9/lib/adafruit_bitmap_font/bdf.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython9/lib/adafruit_bitmap_font/bdf.mpy -------------------------------------------------------------------------------- /circuitpython9/lib/adafruit_bitmap_font/bitmap_font.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython9/lib/adafruit_bitmap_font/bitmap_font.mpy -------------------------------------------------------------------------------- /circuitpython9/lib/adafruit_bitmap_font/glyph_cache.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython9/lib/adafruit_bitmap_font/glyph_cache.mpy -------------------------------------------------------------------------------- /circuitpython9/lib/adafruit_bitmap_font/pcf.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython9/lib/adafruit_bitmap_font/pcf.mpy -------------------------------------------------------------------------------- /circuitpython9/lib/adafruit_bitmap_font/ttf.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython9/lib/adafruit_bitmap_font/ttf.mpy -------------------------------------------------------------------------------- /circuitpython9/lib/adafruit_display_text/__init__.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython9/lib/adafruit_display_text/__init__.mpy -------------------------------------------------------------------------------- /circuitpython9/lib/adafruit_display_text/bitmap_label.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython9/lib/adafruit_display_text/bitmap_label.mpy -------------------------------------------------------------------------------- /circuitpython9/lib/adafruit_display_text/label.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython9/lib/adafruit_display_text/label.mpy -------------------------------------------------------------------------------- /circuitpython9/lib/adafruit_display_text/scrolling_label.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython9/lib/adafruit_display_text/scrolling_label.mpy -------------------------------------------------------------------------------- /circuitpython9/lib/adafruit_displayio_ssd1306.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython9/lib/adafruit_displayio_ssd1306.mpy -------------------------------------------------------------------------------- /circuitpython9/lib/adafruit_st7789.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython9/lib/adafruit_st7789.mpy -------------------------------------------------------------------------------- /circuitpython9/lib/neopixel.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython9/lib/neopixel.mpy -------------------------------------------------------------------------------- /circuitpython9/menu/Blinky.py: -------------------------------------------------------------------------------- 1 | # LED Blink T-Display rpi2040 2 | # https://github.com/kreier/t-display/tree/main/circuitpython_rpi2040/menu 3 | 4 | import time, board, digitalio, config, displayio 5 | 6 | display = config.disp 7 | display.root_group = displayio.CIRCUITPYTHON_TERMINAL 8 | BUTTON_EXIT = digitalio.DigitalInOut(config.pin_button_exit) 9 | BUTTON_EXIT.direction = digitalio.Direction.INPUT 10 | if config.pullup: 11 | BUTTON_EXIT.pull = digitalio.Pull.UP 12 | LED = digitalio.DigitalInOut(config.pin_led) 13 | LED.direction = digitalio.Direction.OUTPUT 14 | 15 | timer = time.monotonic() 16 | LED.value = True 17 | while True: 18 | if not BUTTON_EXIT.value: 19 | LED.deinit() 20 | BUTTON_EXIT.deinit() 21 | exec(open("code.py").read()) 22 | if timer + 1 < time.monotonic(): 23 | LED.value = not LED.value 24 | timer = time.monotonic() 25 | print("LED", end=" ") 26 | -------------------------------------------------------------------------------- /circuitpython9/menu/Mandelbrot.py: -------------------------------------------------------------------------------- 1 | # mandelbrot on rp2040 with lcd 240x240 2 | # https://github.com/kreier/rp2040/blob/main/tft_st7789_240x240/menu/Mandelbrot.py 3 | # 2023/12/26 v0.3 4 | 5 | import board, displayio, random, digitalio 6 | 7 | # Create a bitmap with 256 colors 8 | bitmap = displayio.Bitmap(display.width, display.height, 256) 9 | 10 | def hsv_to_rgb(h, s, v): 11 | if s == 0.0: v*=255; return (v, v, v) 12 | i = int(h*6.) 13 | f = (h*6.)-i; p,q,t = int(255*(v*(1.-s))), int(255*(v*(1.-s*f))), int(255*(v*(1.-s*(1.-f)))); v*=255; i%=6 14 | if i == 0: ret = (65536*v + 256*t + p) 15 | if i == 1: ret = (65536*q + 256*v + p) 16 | if i == 2: ret = (65536*p + 256*v + t) 17 | if i == 3: ret = (65536*p + 256*q + v) 18 | if i == 4: ret = (65536*t + 256*p + v) 19 | if i == 5: ret = (65536*v + 256*p + q) 20 | #return f"{ret:06X}" 21 | return ret 22 | 23 | # Create a 256 color palette 24 | palette = displayio.Palette(256) 25 | for i in range(256): 26 | #palette[i] = random.randrange(16777216) 27 | palette[i] = hsv_to_rgb(i/256, 1, 1) 28 | palette[0] = 0 29 | 30 | # Create a TileGrid using the Bitmap and Palette 31 | tile_grid = displayio.TileGrid(bitmap, pixel_shader=palette) 32 | 33 | # Create a Group 34 | group = displayio.Group() 35 | 36 | # Add the TileGrid to the Group 37 | group.append(tile_grid) 38 | 39 | # Add the Group to the Display 40 | display.root_group = group 41 | 42 | # Draw even more pixels 43 | #for c in range(len(palette)): 44 | # for x in range(display.width): 45 | # for y in range(display.height): 46 | # bitmap[x, y] = (x + y) % 256 47 | 48 | minX = -1.9 49 | maxX = 0.6 50 | width = display.width 51 | height = display.height 52 | aspectRatio = 1 53 | ITERATION = 20 54 | yScale = (maxX-minX)*(float(height)/width)*aspectRatio 55 | 56 | for y in range(height): 57 | for x in range(width): 58 | c = complex(minX+x*(maxX-minX)/width, y*yScale/height-yScale/2) 59 | z = c 60 | for iter in range(ITERATION): 61 | if abs(z) > 2: 62 | break 63 | z = z*z+c 64 | if iter == ITERATION - 1: 65 | pixelcolor = 0 66 | else: 67 | pixelcolor = iter *5 68 | bitmap[x, y] = pixelcolor 69 | 70 | # standardized final loop part for T-Display programs to return to the menu 71 | import time, board, digitalio, config 72 | BUTTON_EXIT = digitalio.DigitalInOut(config.pin_button_ok) 73 | BUTTON_EXIT.direction = digitalio.Direction.INPUT 74 | if config.pullup: 75 | BUTTON_EXIT.pull = digitalio.Pull.UP 76 | LED = digitalio.DigitalInOut(config.pin_led) 77 | LED.direction = digitalio.Direction.OUTPUT 78 | timer = time.monotonic() 79 | LED.value = True 80 | while True: 81 | if not BUTTON_EXIT.value: 82 | LED.deinit() 83 | BUTTON_EXIT.deinit() 84 | exec(open("code.py").read()) 85 | if timer + 2 < time.monotonic(): 86 | LED.value = not LED.value 87 | timer = time.monotonic() 88 | -------------------------------------------------------------------------------- /circuitpython9/menu/Moving_Disks.py: -------------------------------------------------------------------------------- 1 | # lilygo_t_display_rp2040_demo.py - show how to use LILYGO T display RP2040 board 2 | # 23 Jun 2022 - @todbot / Tod Kurt 3 | 4 | import time, random, board, busio, digitalio, displayio 5 | import vectorio, rainbowio 6 | 7 | BUTTON_EXIT = digitalio.DigitalInOut(config.pin_button_exit) 8 | BUTTON_EXIT.direction = digitalio.Direction.INPUT 9 | if config.pullup: 10 | BUTTON_EXIT.pull = digitalio.Pull.UP 11 | LED = digitalio.DigitalInOut(config.pin_led) 12 | LED.direction = digitalio.Direction.OUTPUT 13 | 14 | maingroup = displayio.Group() 15 | display.root_group = maingroup 16 | 17 | # demo with a bunch of vectorio circles 18 | for i in range(20): 19 | palette = displayio.Palette(1) 20 | palette[0] = rainbowio.colorwheel(random.randint(0,255)) 21 | x,y = random.randint(0,display.width), random.randint(0,display.height) 22 | ball = vectorio.Circle(pixel_shader=palette, radius=20, x=x, y=y) 23 | maingroup.append(ball) 24 | 25 | timer = time.monotonic() 26 | LED.value = True 27 | while True: 28 | if not BUTTON_EXIT.value: 29 | LED.deinit() 30 | BUTTON_EXIT.deinit() 31 | exec(open("code.py").read()) 32 | for ball in maingroup: 33 | ball.x = (ball.x + 1) % display.width 34 | time.sleep(0.1) 35 | if timer + 0.2 < time.monotonic(): 36 | LED.value = not LED.value 37 | timer = time.monotonic() 38 | -------------------------------------------------------------------------------- /circuitpython9/menu/Pinmap_of_this_board.py: -------------------------------------------------------------------------------- 1 | """CircuitPython Essentials Pin Map Script""" 2 | # adapted for T-Display with line 5-8 led and button_next and the finishing loop 3 | # https://github.com/kreier/t-display/tree/main/circuitpython_rpi2040/menu 4 | 5 | import microcontroller, board, displayio 6 | 7 | display.root_group = displayio.CIRCUITPYTHON_TERMINAL 8 | 9 | board_pins = [] 10 | for pin in dir(microcontroller.pin): 11 | if isinstance(getattr(microcontroller.pin, pin), microcontroller.Pin): 12 | pins = [] 13 | for alias in dir(board): 14 | if getattr(board, alias) is getattr(microcontroller.pin, pin): 15 | pins.append("board.{}".format(alias)) 16 | if len(pins) > 0: 17 | board_pins.append(" ".join(pins)) 18 | for pins in sorted(board_pins): 19 | print(pins) 20 | 21 | # standardized final loop part for T-Display programs to return to the menu 22 | import time, board, digitalio, config 23 | BUTTON_EXIT = digitalio.DigitalInOut(config.pin_button_ok) 24 | BUTTON_EXIT.direction = digitalio.Direction.INPUT 25 | if config.pullup: 26 | BUTTON_EXIT.pull = digitalio.Pull.UP 27 | LED = digitalio.DigitalInOut(config.pin_led) 28 | LED.direction = digitalio.Direction.OUTPUT 29 | timer = time.monotonic() 30 | LED.value = True 31 | while True: 32 | if not BUTTON_EXIT.value: 33 | LED.deinit() 34 | BUTTON_EXIT.deinit() 35 | exec(open("code.py").read()) 36 | if timer + 2 < time.monotonic(): 37 | LED.value = not LED.value 38 | timer = time.monotonic() 39 | -------------------------------------------------------------------------------- /circuitpython9/menu/TFT_Hello_World.py: -------------------------------------------------------------------------------- 1 | # ST7789 on T-Display RP2040 @kreier 2023-03-04 2 | # update 2023-12-28 to universal menu version 3 | 4 | import displayio, digitalio, terminalio 5 | from adafruit_display_text import label 6 | 7 | # First set some parameters used for shapes and text 8 | BORDER = 20 9 | FONTSCALE = 2 10 | BACKGROUND_COLOR = 0x00FF00 # Bright Green 11 | FOREGROUND_COLOR = 0xAA0088 # Purple 12 | TEXT_COLOR = 0xFFFF00 13 | 14 | # Make the display context 15 | splash = displayio.Group() 16 | display.root_group = splash 17 | 18 | color_bitmap = displayio.Bitmap(display.width, display.height, 1) 19 | color_palette = displayio.Palette(1) 20 | color_palette[0] = BACKGROUND_COLOR 21 | 22 | bg_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, x=0, y=0) 23 | splash.append(bg_sprite) 24 | 25 | # Draw a smaller inner rectangle 26 | inner_bitmap = displayio.Bitmap( 27 | display.width - BORDER * 2, display.height - BORDER * 2, 1 28 | ) 29 | inner_palette = displayio.Palette(1) 30 | inner_palette[0] = FOREGROUND_COLOR 31 | inner_sprite = displayio.TileGrid( 32 | inner_bitmap, pixel_shader=inner_palette, x=BORDER, y=BORDER 33 | ) 34 | splash.append(inner_sprite) 35 | 36 | # Draw a label 37 | text = "Hello World!" 38 | text_area = label.Label(terminalio.FONT, text=text, color=TEXT_COLOR) 39 | text_width = text_area.bounding_box[2] * FONTSCALE 40 | text_group = displayio.Group( 41 | scale=FONTSCALE, 42 | x=display.width // 2 - text_width // 2, 43 | y=display.height // 2, 44 | ) 45 | text_group.append(text_area) # Subgroup for text scaling 46 | splash.append(text_group) 47 | 48 | 49 | 50 | # standardized final loop part for T-Display programs to return to the menu 51 | import time, board, digitalio, config 52 | BUTTON_EXIT = digitalio.DigitalInOut(config.pin_button_exit) 53 | BUTTON_EXIT.direction = digitalio.Direction.INPUT 54 | if config.pullup: 55 | BUTTON_EXIT.pull = digitalio.Pull.UP 56 | LED = digitalio.DigitalInOut(config.pin_led) 57 | LED.direction = digitalio.Direction.OUTPUT 58 | timer = time.monotonic() 59 | LED.value = True 60 | while True: 61 | if not BUTTON_EXIT.value: 62 | LED.deinit() 63 | BUTTON_EXIT.deinit() 64 | exec(open("code.py").read()) 65 | if timer + 2 < time.monotonic(): 66 | LED.value = not LED.value 67 | timer = time.monotonic() 68 | -------------------------------------------------------------------------------- /circuitpython9/menu/TFT_Test.py: -------------------------------------------------------------------------------- 1 | # ST7789 on T-Display RP2040 @kreier 2022-05-23 2 | 3 | import board, displayio 4 | 5 | # Make the display context 6 | splash = displayio.Group() 7 | display.root_group = splash 8 | 9 | color_bitmap = displayio.Bitmap(display.width, display.height, 1) 10 | color_palette = displayio.Palette(1) 11 | color_palette[0] = 0x2345FF 12 | 13 | bg_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, x=0, y=0) 14 | splash.append(bg_sprite) 15 | 16 | 17 | # standardized final loop part for T-Display programs to return to the menu 18 | import time, board, digitalio, config 19 | BUTTON_EXIT = digitalio.DigitalInOut(config.pin_button_exit) 20 | BUTTON_EXIT.direction = digitalio.Direction.INPUT 21 | if config.pullup: 22 | BUTTON_EXIT.pull = digitalio.Pull.UP 23 | LED = digitalio.DigitalInOut(config.pin_led) 24 | LED.direction = digitalio.Direction.OUTPUT 25 | timer = time.monotonic() 26 | LED.value = True 27 | while True: 28 | if not BUTTON_EXIT.value: 29 | LED.deinit() 30 | BUTTON_EXIT.deinit() 31 | exec(open("code.py").read()) 32 | if timer + 2 < time.monotonic(): 33 | LED.value = not LED.value 34 | timer = time.monotonic() 35 | -------------------------------------------------------------------------------- /circuitpython9/menu/i2c_scanner.py: -------------------------------------------------------------------------------- 1 | # SPDX-FileCopyrightText: 2017 Limor Fried for Adafruit Industries 2 | # SPDX-License-Identifier: MIT 3 | # https://github.com/kreier/clue 2022-10-28 4 | 5 | """CircuitPython I2C Device Address Scan""" 6 | # If you run this and it seems to hang, try manually unlocking 7 | # your I2C bus from the REPL with 8 | # >>> import board 9 | # >>> board.I2C().unlock() 10 | 11 | import time 12 | import board 13 | import busio 14 | 15 | # To use default I2C bus (most boards) 16 | #i2c = board.I2C() 17 | 18 | # To create I2C bus on specific pins 19 | # import busio 20 | # i2c = busio.I2C(board.SCL1, board.SDA1) # QT Py RP2040 STEMMA connector 21 | # i2c = busio.I2C(board.GP1, board.GP0) # Pi Pico RP2040 22 | # i2c = busio.I2C(board.GP17, board.GP16) # Pi Pico RP2040 23 | # i2c = busio.I2C(board.GP1, board.GP0) # Pi Pico RP2040 24 | i2c = busio.I2C(board.STEMMA_SCL, board.STEMMA_SDA) # T-Display S3 25 | 26 | 27 | print("i2c detection range 0x00-0x7F") 28 | print(" 0 1 2 3 4 5 6 7 8 9 A B C D E F") 29 | 30 | while not i2c.try_lock(): 31 | pass 32 | 33 | try: 34 | devices = i2c.scan() 35 | 36 | finally: # unlock the i2c bus when ctrl-c'ing out of the loop 37 | i2c.unlock() 38 | 39 | devices.append(0) 40 | device = 0 41 | for row in range(0, 127, 16): 42 | print(f"0x{row:02x}", end=":") 43 | for col in range(16): 44 | if devices[device] == (row + col): 45 | print(hex(row+col)[2:], end="") 46 | device += 1 47 | else: 48 | print(" -", end="") 49 | print(" ") 50 | 51 | import digitalio, displayio 52 | 53 | board.DISPLAY.root_group = displayio.CIRCUITPYTHON_TERMINAL 54 | 55 | BUTTON_EXIT = digitalio.DigitalInOut(board.BUTTON0) 56 | BUTTON_EXIT.direction = digitalio.Direction.INPUT 57 | while BUTTON_EXIT.value: 58 | pass 59 | -------------------------------------------------------------------------------- /circuitpython9/menu/oled_128x64.py: -------------------------------------------------------------------------------- 1 | import board, time, busio, displayio, busdisplay 2 | import adafruit_displayio_ssd1306 3 | 4 | #busdisplay.release_displays() 5 | displayio.release_displays() 6 | i2c = busio.I2C(board.GP1, board.GP0) 7 | display_bus = displayio.I2CDisplay(i2c, device_address=0x3c) 8 | display = adafruit_displayio_ssd1306.SSD1306(display_bus, width=128, height=64) 9 | -------------------------------------------------------------------------------- /circuitpython9/menu/oled_128x64_button.py: -------------------------------------------------------------------------------- 1 | import board, time, busio, displayio, busdisplay, terminalio, digitalio 2 | from adafruit_display_text import label 3 | import adafruit_displayio_ssd1306 4 | 5 | WIDTH = 128 6 | HEIGHT = 64 7 | BORDER = 5 8 | 9 | #busdisplay.release_displays() 10 | displayio.release_displays() 11 | i2c = busio.I2C(board.GP1, board.GP0) 12 | display_bus = displayio.I2CDisplay(i2c, device_address=0x3c) 13 | display = adafruit_displayio_ssd1306.SSD1306(display_bus, width=128, height=64) 14 | 15 | splash = displayio.Group() 16 | display.root_group = splash 17 | 18 | color_bitmap = displayio.Bitmap(WIDTH, HEIGHT, 1) 19 | color_palette = displayio.Palette(1) 20 | color_palette[0] = 0xFFFFFF # White 21 | 22 | bg_sprite = displayio.TileGrid(color_bitmap, 23 | pixel_shader=color_palette, 24 | x=0, y=0) 25 | splash.append(bg_sprite) 26 | 27 | # Draw a smaller inner rectangle 28 | inner_bitmap = displayio.Bitmap(WIDTH-BORDER*2, HEIGHT-BORDER*2, 1) 29 | inner_palette = displayio.Palette(1) 30 | inner_palette[0] = 0x000000 # Black 31 | inner_sprite = displayio.TileGrid(inner_bitmap, 32 | pixel_shader=inner_palette, 33 | x=BORDER, y=BORDER) 34 | splash.append(inner_sprite) 35 | 36 | # Draw a label 37 | text = "Hello World!" 38 | text_area = label.Label(terminalio.FONT, text=text, color=0xFFFFFF, x=28, y=HEIGHT//2-1) 39 | splash.append(text_area) 40 | 41 | BUTTON_OK = digitalio.DigitalInOut(board.BUTTON) 42 | BUTTON_OK.direction = digitalio.Direction.INPUT 43 | BUTTON_OK.pull = digitalio.Pull.UP 44 | while BUTTON_OK.value: 45 | pass 46 | -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/apps/blink.py: -------------------------------------------------------------------------------- 1 | # LED Blink T-Display rpi2040 2 | 3 | import board 4 | import digitalio 5 | 6 | led = digitalio.DigitalInOut(board.LED) 7 | led.direction = digitalio.Direction.OUTPUT 8 | 9 | while True: 10 | led.value = True 11 | -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/apps/led.py: -------------------------------------------------------------------------------- 1 | import time 2 | import board 3 | import digitalio 4 | 5 | led = digitalio.DigitalInOut(board.LED) 6 | led.direction = digitalio.Direction.OUTPUT 7 | led.value = True 8 | time.sleep(1) 9 | led.value = False 10 | time.sleep(1) 11 | 12 | print("Done!") 13 | led.deinit() 14 | -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/apps/pin_board.py: -------------------------------------------------------------------------------- 1 | """CircuitPython Essentials Pin Map Script""" 2 | import microcontroller 3 | import board 4 | 5 | board_pins = [] 6 | for pin in dir(microcontroller.pin): 7 | if isinstance(getattr(microcontroller.pin, pin), microcontroller.Pin): 8 | pins = [] 9 | for alias in dir(board): 10 | if getattr(board, alias) is getattr(microcontroller.pin, pin): 11 | pins.append("board.{}".format(alias)) 12 | if len(pins) > 0: 13 | board_pins.append(" ".join(pins)) 14 | for pins in sorted(board_pins): 15 | print(pins) 16 | -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/apps/pinmap.py: -------------------------------------------------------------------------------- 1 | """CircuitPython Essentials Pin Map Script""" 2 | import microcontroller 3 | import board 4 | 5 | board_pins = [] 6 | for pin in dir(microcontroller.pin): 7 | if isinstance(getattr(microcontroller.pin, pin), microcontroller.Pin): 8 | pins = [] 9 | for alias in dir(board): 10 | if getattr(board, alias) is getattr(microcontroller.pin, pin): 11 | pins.append("board.{}".format(alias)) 12 | if len(pins) > 0: 13 | board_pins.append(" ".join(pins)) 14 | for pins in sorted(board_pins): 15 | print(pins) 16 | -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/apps/prime5.4.py: -------------------------------------------------------------------------------- 1 | # prime v5.4 2023-12-23 2 | # cycles through limits and writes to the filesystem 3 | 4 | import math, time, digitalio, board, os, terminalio 5 | from adafruit_display_text import label 6 | from adafruit_bitmap_font import bitmap_font 7 | 8 | # try uncommenting different font files if you like 9 | font_file = "fonts/LeagueSpartan-Bold-16.pcf" 10 | # font_file = "fonts/LeagueSpartan-Bold-16.bdf" 11 | # font_file = "fonts/Junction-regular-24.pcf" 12 | 13 | scope = [100, 1000, 10000, 100000, 1000000, 10000000, 25000000, 100000000, 1000000000, 2147483647, 4294967295] 14 | reference = [25, 168, 1229, 9592, 78498, 664579, 1565927, 5761455, 50847534, 105097564, 203280221] 15 | time_calc = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] 16 | led = digitalio.DigitalInOut(board.LED) 17 | led.direction = digitalio.Direction.OUTPUT 18 | led.value = True 19 | display = board.DISPLAY 20 | 21 | def is_prime(number): 22 | global found 23 | flag_prime = 1 24 | for divider in range(3, int(math.sqrt(number)) + 1, 2): 25 | if number % divider == 0: 26 | flag_prime = 0 27 | break 28 | return flag_prime 29 | 30 | def find_primes(largest): 31 | global primes 32 | global found 33 | for number in range(11, largest + 1, 2): 34 | if is_prime(number) > 0: 35 | found += 1 36 | primes.append(number) 37 | 38 | def is_prime_fast(number): 39 | global found 40 | flag_prime = 1 41 | largest_divider = int(math.sqrt(number)) + 1 42 | for divider in primes: 43 | if number % divider == 0: 44 | flag_prime = 0 45 | break 46 | if divider > largest_divider: 47 | break 48 | return flag_prime 49 | 50 | def elapsed_time(seconds): 51 | hours = int(seconds/3600) 52 | minutes = int(seconds/60 - hours*60) 53 | sec = int(seconds - minutes*60 - hours*3600) 54 | return(f"{hours}h {minutes}min {sec}s") 55 | 56 | if __name__ == "__main__": 57 | # title, current_scope and progress 58 | # font = terminalio.FONT 59 | font = bitmap_font.load_font(font_file) 60 | color = 0xFFFFFF 61 | 62 | text_area = label.Label(font, text="Prime 5.4 CircuitPython", color=color) 63 | text_area.x = 0 64 | text_area.y = 20 65 | title = label.Label(font, text="Calculating primes to", color=color) 66 | title.x = 10 67 | title.y = 24 68 | text_area.append(title) 69 | current_scope = label.Label(font, text="100", color=color, background_color=0x000000) 70 | current_scope.x = 130 71 | current_scope.y = 50 72 | text_area.append(current_scope) 73 | percent = label.Label(font, text=" 0.00 Percent ", color=color, background_color=0x000000) 74 | percent.x = 60 75 | percent.y = 75 76 | text_area.append(percent) 77 | runtime = label.Label(font, text=" 0h 0min 0s ", color=color, background_color=0x000000) 78 | runtime.x = 70 79 | runtime.y = 100 80 | text_area.append(runtime) 81 | display.root_group = text_area 82 | 83 | for i in range(8): # 8 needs less than a day - len(scope) 84 | last = scope[i] 85 | found = 4 # we start from 11, know 2, 3, 5, 7 86 | primes = [3, 5, 7] # exclude 2 since we only test odd numbers 87 | 88 | current_scope.text = str(last) 89 | current_scope.x = 140 - int(math.log(last, 10))*10 90 | 91 | print(f"\nPrime numbers to {last} in v5.4") 92 | start = time.monotonic() 93 | dot = start 94 | column = 1 95 | largest_divider = int(math.sqrt(last)) 96 | if largest_divider % 2 == 0: 97 | largest_divider += 1 98 | print(f'First find prime dividers up to {largest_divider}.') 99 | find_primes(largest_divider) 100 | print(f'Found {found} primes, now use them als dividers.') 101 | for number in range(largest_divider + 2, last, 2): 102 | found += is_prime_fast(number) 103 | if (time.monotonic() - dot) > 2: 104 | print(f".", end="") 105 | dot = time.monotonic() 106 | led.value = not led.value 107 | column += 1 108 | percent.text = str(int(number*10000/last)/100.0) + " Percent " 109 | runtime.text = elapsed_time(time.monotonic() - start) 110 | if column > 40: 111 | t = elapsed_time(time.monotonic() - start) 112 | print(f" {t} - {number} {int(number*100/last)}% ") 113 | column = 1 114 | duration = time.monotonic() - start 115 | print(f'This took: {duration} seconds.') 116 | print(f'Found {found} primes.') 117 | filename = "/data/" + str(last) + ".txt" 118 | try: 119 | with open(filename, "w") as fp: 120 | fp.write(board.board_id) 121 | fp.write(f'\nPrimes to {last} took {duration} seconds.') 122 | fp.write(f'\nFound {found} primes. Should be {reference[i]}.') 123 | print('Exported to filesystem ') 124 | except: 125 | print("Can't write to the filesystem. Press reset and after that the boot button in the first 5 seconds") 126 | #print(f'Primes to {last} took {(end - start)} seconds.') 127 | #print(f'Found {found} primes. Should be {reference[i]}.') 128 | time_calc[i] = duration 129 | print('\nWrite summary') 130 | try: 131 | with open("summary.txt", "w") as fp: 132 | fp.write(f'Primes calculation in Circuitpython v5.4 2023/12/25\n') 133 | fp.write(board.board_id) 134 | fp.write('\n last time in seconds\n') 135 | for i in range(len(time_calc)): 136 | fp.write(f' {scope[i]} {time_calc[i]}\n') 137 | print('Exported to filesystem ') 138 | except: 139 | print("Can't write to the filesystem. Press reset and after that the boot button in the first 5 seconds") 140 | 141 | while True: 142 | led.value = True 143 | print(f'LED on - to {last} needs {duration} s') 144 | time.sleep(10) 145 | led.value = False 146 | print('LED off') 147 | time.sleep(1) 148 | pass 149 | -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/apps/prime_to_100M.py: -------------------------------------------------------------------------------- 1 | # prime v5.4 2023-12-23 2 | # cycles through limits and writes to the filesystem 3 | 4 | import math, time, digitalio, board, os, terminalio 5 | from adafruit_display_text import label 6 | from adafruit_bitmap_font import bitmap_font 7 | 8 | # try uncommenting different font files if you like 9 | font_file = "fonts/LeagueSpartan-Bold-16.pcf" 10 | # font_file = "fonts/LeagueSpartan-Bold-16.bdf" 11 | # font_file = "fonts/Junction-regular-24.pcf" 12 | 13 | scope = [100, 1000, 10000, 100000, 1000000, 10000000, 25000000, 100000000, 1000000000, 2147483647, 4294967295] 14 | reference = [25, 168, 1229, 9592, 78498, 664579, 1565927, 5761455, 50847534, 105097564, 203280221] 15 | time_calc = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] 16 | led = digitalio.DigitalInOut(board.LED) 17 | led.direction = digitalio.Direction.OUTPUT 18 | led.value = True 19 | display = board.DISPLAY 20 | 21 | def is_prime(number): 22 | global found 23 | flag_prime = 1 24 | for divider in range(3, int(math.sqrt(number)) + 1, 2): 25 | if number % divider == 0: 26 | flag_prime = 0 27 | break 28 | return flag_prime 29 | 30 | def find_primes(largest): 31 | global primes 32 | global found 33 | for number in range(11, largest + 1, 2): 34 | if is_prime(number) > 0: 35 | found += 1 36 | primes.append(number) 37 | 38 | def is_prime_fast(number): 39 | global found 40 | flag_prime = 1 41 | largest_divider = int(math.sqrt(number)) + 1 42 | for divider in primes: 43 | if number % divider == 0: 44 | flag_prime = 0 45 | break 46 | if divider > largest_divider: 47 | break 48 | return flag_prime 49 | 50 | def elapsed_time(seconds): 51 | hours = int(seconds/3600) 52 | minutes = int(seconds/60 - hours*60) 53 | sec = int(seconds - minutes*60 - hours*3600) 54 | return(f"{hours}h {minutes}min {sec}s") 55 | 56 | if __name__ == "__main__": 57 | # title, current_scope and progress 58 | # font = terminalio.FONT 59 | font = bitmap_font.load_font(font_file) 60 | color = 0xFFFFFF 61 | 62 | text_area = label.Label(font, text="Prime 5.4 CircuitPython", color=color) 63 | text_area.x = 0 64 | text_area.y = 20 65 | title = label.Label(font, text="Calculating primes to", color=color) 66 | title.x = 10 67 | title.y = 24 68 | text_area.append(title) 69 | current_scope = label.Label(font, text="100", color=color, background_color=0x000000) 70 | current_scope.x = 130 71 | current_scope.y = 50 72 | text_area.append(current_scope) 73 | percent = label.Label(font, text=" 0.00 Percent ", color=color, background_color=0x000000) 74 | percent.x = 60 75 | percent.y = 75 76 | text_area.append(percent) 77 | runtime = label.Label(font, text=" 0h 0min 0s ", color=color, background_color=0x000000) 78 | runtime.x = 70 79 | runtime.y = 100 80 | text_area.append(runtime) 81 | display.root_group = text_area 82 | 83 | for i in range(8): # 8 needs less than a day - len(scope) 84 | last = scope[i] 85 | found = 4 # we start from 11, know 2, 3, 5, 7 86 | primes = [3, 5, 7] # exclude 2 since we only test odd numbers 87 | 88 | current_scope.text = str(last) 89 | current_scope.x = 140 - int(math.log(last, 10))*10 90 | 91 | print(f"\nPrime numbers to {last} in v5.4") 92 | start = time.monotonic() 93 | dot = start 94 | column = 1 95 | largest_divider = int(math.sqrt(last)) 96 | if largest_divider % 2 == 0: 97 | largest_divider += 1 98 | print(f'First find prime dividers up to {largest_divider}.') 99 | find_primes(largest_divider) 100 | print(f'Found {found} primes, now use them als dividers.') 101 | for number in range(largest_divider + 2, last, 2): 102 | found += is_prime_fast(number) 103 | if (time.monotonic() - dot) > 2: 104 | print(f".", end="") 105 | dot = time.monotonic() 106 | led.value = not led.value 107 | column += 1 108 | percent.text = str(int(number*10000/last)/100.0) + " Percent " 109 | runtime.text = elapsed_time(time.monotonic() - start) 110 | if column > 40: 111 | t = elapsed_time(time.monotonic() - start) 112 | print(f" {t} - {number} {int(number*100/last)}% ") 113 | column = 1 114 | duration = time.monotonic() - start 115 | print(f'This took: {duration} seconds.') 116 | print(f'Found {found} primes.') 117 | filename = "/" + str(last) + ".txt" 118 | try: 119 | with open(filename, "w") as fp: 120 | fp.write(board.board_id) 121 | fp.write(f'\nPrimes to {last} took {duration} seconds.') 122 | fp.write(f'\nFound {found} primes. Should be {reference[i]}.') 123 | print('Exported to filesystem ') 124 | except: 125 | print("Can't write to the filesystem. Press reset and after that the boot button in the first 5 seconds") 126 | #print(f'Primes to {last} took {(end - start)} seconds.') 127 | #print(f'Found {found} primes. Should be {reference[i]}.') 128 | time_calc[i] = duration 129 | print('\nWrite summary') 130 | try: 131 | with open("summary.txt", "w") as fp: 132 | fp.write(f'Primes calculation in Circuitpython v5.4 2023/12/22\n') 133 | fp.write(board.board_id) 134 | fp.write('\n last time in seconds\n') 135 | for i in range(len(time_calc)): 136 | fp.write(f' {scope[i]} {time_calc[i]}\n') 137 | print('Exported to filesystem ') 138 | except: 139 | print("Can't write to the filesystem. Press reset and after that the boot button in the first 5 seconds") 140 | 141 | while True: 142 | led.value = True 143 | print(f'LED on - to {last} needs {duration} s') 144 | time.sleep(10) 145 | led.value = False 146 | print('LED off') 147 | time.sleep(1) 148 | pass 149 | -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/apps/scan_pins.py: -------------------------------------------------------------------------------- 1 | import time 2 | import board 3 | import digitalio 4 | import re 5 | 6 | # What pins can be switched on and off? 7 | pins = [] 8 | 9 | for item in dir(board): 10 | if item[0] == "G": 11 | pins.append(item) 12 | 13 | for pin in pins: 14 | print("We investigate Pin {}".format(pin)) 15 | led_pin = "board." + pin 16 | print(led_pin) 17 | led = digitalio.DigitalInOut(led_pin) 18 | 19 | 20 | 21 | ''' 22 | led = digitalio.DigitalInOut(board.LED) 23 | led.direction = digitalio.Direction.OUTPUT 24 | led.value = True 25 | time.sleep(1) 26 | led.value = False 27 | time.sleep(1) 28 | 29 | print("Done!") 30 | led.deinit() 31 | 32 | """CircuitPython Essentials Pin Map Script""" 33 | import microcontroller 34 | import board 35 | 36 | board_pins = [] 37 | for pin in dir(microcontroller.pin): 38 | if isinstance(getattr(microcontroller.pin, pin), microcontroller.Pin): 39 | pins = [] 40 | for alias in dir(board): 41 | if getattr(board, alias) is getattr(microcontroller.pin, pin): 42 | pins.append("board.{}".format(alias)) 43 | if len(pins) > 0: 44 | board_pins.append(" ".join(pins)) 45 | for pins in sorted(board_pins): 46 | print(pins) 47 | ''' 48 | print("Hello world!") 49 | -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/apps/tft_example.py: -------------------------------------------------------------------------------- 1 | # ST7789 on T-Display rpi2040 @kreier 2022-05-23 2 | 3 | import board 4 | import displayio 5 | from adafruit_st7789 import ST7789 6 | 7 | spi = board.SPI() 8 | while not spi.try_lock(): 9 | pass 10 | spi.configure(baudrate=24000000) # Configure SPI for 24MHz 11 | spi.unlock() 12 | tft_cs = board.D5 13 | tft_dc = board.D6 14 | 15 | displayio.release_displays() 16 | display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=board.D9) 17 | 18 | display = ST7789(display_bus, width=240, height=240, rowstart=80) 19 | 20 | # Make the display context 21 | splash = displayio.Group(max_size=10) 22 | display.show(splash) 23 | 24 | color_bitmap = displayio.Bitmap(240, 240, 1) 25 | color_palette = displayio.Palette(1) 26 | color_palette[0] = 0xFF0000 27 | 28 | bg_sprite = displayio.TileGrid(color_bitmap, 29 | pixel_shader=color_palette, 30 | x=0, y=0) 31 | splash.append(bg_sprite) 32 | 33 | while True: 34 | pass 35 | -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/boot.py: -------------------------------------------------------------------------------- 1 | # toggle the write switch to the local file system 2023/12/25 2 | 3 | import time 4 | import board 5 | import digitalio 6 | import storage 7 | 8 | button_pin = board.BUTTON_L 9 | # T-Display rp2040 board.BUTTON_L False if pressed 10 | # rp2040 with NeoPixel board.BUTTON 11 | # T-Display ESP32-S2 board.IO0 12 | 13 | button = digitalio.DigitalInOut(button_pin) 14 | button.direction = digitalio.Direction.INPUT 15 | # button.pull = digitalio.Pull.UP 16 | 17 | led = digitalio.DigitalInOut(board.LED) 18 | led.direction = digitalio.Direction.OUTPUT 19 | led.value = True 20 | 21 | time.sleep(1) 22 | timer = 5 23 | can_write = False 24 | print(f"Press the button in the next {timer} seconds to activate saving") 25 | end = time.monotonic() + timer 26 | print(timer) 27 | while end - time.monotonic() > 0: 28 | if not button.value: 29 | print("write access activated") 30 | storage.remount("/", False) 31 | can_write = True 32 | if end - timer + 1 < time.monotonic(): 33 | timer -= 1 34 | led.value = False 35 | time.sleep(0.1) 36 | led.value = True 37 | print(timer) 38 | if can_write: 39 | led.value = False 40 | else: 41 | led.value = True 42 | if not can_write: 43 | print("Not activated") 44 | time.sleep(1) 45 | -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/code.py: -------------------------------------------------------------------------------- 1 | # Menu selector v0.2 for LILYGO T-Display rp2040 - 2023/12/25 2 | # https://github.com/kreier/t-display/tree/main/circuitpython_rpi2040 3 | 4 | import time, board, digitalio, os, terminalio 5 | from adafruit_display_text import label 6 | from adafruit_bitmap_font import bitmap_font 7 | 8 | font_file = "fonts/LeagueSpartan-Bold-16.pcf" 9 | # font_file = "fonts/LeagueSpartan-Bold-16.bdf" 10 | # font_file = "fonts/Junction-regular-24.pcf" 11 | 12 | led = digitalio.DigitalInOut(board.LED) # GP25 13 | led.direction = digitalio.Direction.OUTPUT 14 | led.value = True 15 | button_next = digitalio.DigitalInOut(board.BUTTON_L) # GP6 16 | button_next.direction = digitalio.Direction.INPUT 17 | button_ok = digitalio.DigitalInOut(board.GP7) # GP7 18 | button_ok.direction = digitalio.Direction.INPUT 19 | display = board.DISPLAY 20 | 21 | programs = [] # link to all programs installed in /menu (avoid clutter from all apps in /apps) 22 | menu = [] # all menu options - can be more than fit on the display 23 | menu_item = [] # the five items that currently fit on the display 24 | selected_item = 0 25 | selected_program = 0 26 | 27 | directory = os.listdir("menu") # folder for menu programs - less cluttered 28 | directory.sort() # collection of all programs are in /apps 29 | 30 | def fill_menu(first_program): 31 | for i in range(5): 32 | if i + first_program < len(menu): 33 | menu_item[i].text = menu[i + first_program] 34 | else: 35 | menu_item[i].text = " " 36 | 37 | # create program list in /menu but skipping deleted programs 38 | for i, x in enumerate(directory): 39 | if x[:2] != "._": 40 | programs.append(directory[i]) 41 | number_programs = len(programs) # number of installed programs 42 | 43 | # first menu item: 44 | menu.append(" Settings [{}] ".format(number_programs)) 45 | for i, x in enumerate(programs): 46 | menu.append(" " + x[:-3].replace("_", " ") + " ") # remove the .py from program files 47 | 48 | statusbar = label.Label(terminalio.FONT, text=f" CircuitPython 8.2.9 | {number_programs} ", color=0x99AAFF) 49 | statusbar.x = 0 50 | statusbar.y = 6 51 | battery = label.Label(terminalio.FONT, text="100%", color=0x00FF00) 52 | battery.x = 210 53 | battery.y = 0 54 | statusbar.append(battery) 55 | font = bitmap_font.load_font(font_file) 56 | color = 0xFFFFFF 57 | menu_item = [] 58 | for i in range(5): 59 | menu_item.append(label.Label(font, text=" Item " + str(i) + " "*30, color=color, background_color=0x000000)) 60 | menu_item[i].x = 1 61 | menu_item[i].y = 20 + 23*i 62 | statusbar.append(menu_item[i]) 63 | fill_menu(0) 64 | display.root_group = statusbar 65 | led.value = False 66 | 67 | menu_item[selected_item].color=0x000000 68 | menu_item[selected_item].background_color=0xFFFFFF 69 | timer = time.monotonic() 70 | while True: 71 | if not button_next.value: 72 | led.value = True 73 | menu_item[selected_item].color=0xFFFFFF 74 | menu_item[selected_item].background_color=0x000000 75 | selected_program += 1 76 | if selected_program > len(programs): 77 | selected_program = 0 78 | selected_item = 4 79 | selected_item += 1 80 | if selected_item > 4: 81 | selected_item = 0 82 | fill_menu(selected_program) 83 | menu_item[selected_item].color=0x000000 84 | menu_item[selected_item].background_color=0xFFFFFF 85 | while not button_next.value: 86 | pass 87 | led.value = False 88 | if not button_ok.value: 89 | program = "menu/" + programs[selected_program - 1] 90 | print("Selected: ", program) 91 | display.show(None) 92 | button_next.deinit() 93 | button_ok.deinit() 94 | led.deinit() 95 | exec(open(program).read()) 96 | break 97 | if timer + 1 < time.monotonic(): 98 | led.value = not led.value 99 | timer = time.monotonic() 100 | -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/fonts/Junction-regular-24.pcf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_T-PicoC3/fonts/Junction-regular-24.pcf -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/fonts/LeagueSpartan-Bold-16.pcf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_T-PicoC3/fonts/LeagueSpartan-Bold-16.pcf -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/lib/adafruit_bitmap_font/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_T-PicoC3/lib/adafruit_bitmap_font/__init__.py -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/lib/adafruit_bitmap_font/bdf.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_T-PicoC3/lib/adafruit_bitmap_font/bdf.mpy -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/lib/adafruit_bitmap_font/bitmap_font.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_T-PicoC3/lib/adafruit_bitmap_font/bitmap_font.mpy -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/lib/adafruit_bitmap_font/glyph_cache.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_T-PicoC3/lib/adafruit_bitmap_font/glyph_cache.mpy -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/lib/adafruit_bitmap_font/pcf.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_T-PicoC3/lib/adafruit_bitmap_font/pcf.mpy -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/lib/adafruit_bitmap_font/ttf.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_T-PicoC3/lib/adafruit_bitmap_font/ttf.mpy -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/lib/adafruit_display_text/__init__.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_T-PicoC3/lib/adafruit_display_text/__init__.mpy -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/lib/adafruit_display_text/bitmap_label.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_T-PicoC3/lib/adafruit_display_text/bitmap_label.mpy -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/lib/adafruit_display_text/label.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_T-PicoC3/lib/adafruit_display_text/label.mpy -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/lib/adafruit_display_text/scrolling_label.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_T-PicoC3/lib/adafruit_display_text/scrolling_label.mpy -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/lib/adafruit_st7789.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_T-PicoC3/lib/adafruit_st7789.mpy -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/menu/Blinky.py: -------------------------------------------------------------------------------- 1 | # LED Blink T-Display rpi2040 2 | # https://github.com/kreier/t-display/tree/main/circuitpython_rpi2040/menu 3 | 4 | import time, board, digitalio 5 | 6 | button_next = digitalio.DigitalInOut(board.BUTTON_L) 7 | button_next.direction = digitalio.Direction.INPUT 8 | led = digitalio.DigitalInOut(board.LED) # GP25 9 | led.direction = digitalio.Direction.OUTPUT 10 | 11 | timer = time.monotonic() 12 | led.value = True 13 | while True: 14 | if not button_next.value: 15 | led.deinit() 16 | button_next.deinit() 17 | exec(open("code.py").read()) 18 | if timer + 1 < time.monotonic(): 19 | led.value = not led.value 20 | timer = time.monotonic() 21 | print("LED", end=" ") 22 | -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/menu/Pinmap_of_this_board.py: -------------------------------------------------------------------------------- 1 | """CircuitPython Essentials Pin Map Script""" 2 | # adapted for T-Display with line 5-8 led and button_next and the finishing loop 3 | # https://github.com/kreier/t-display/tree/main/circuitpython_rpi2040/menu 4 | 5 | import microcontroller, board, digitalio 6 | 7 | button_next = digitalio.DigitalInOut(board.BUTTON_L) 8 | button_next.direction = digitalio.Direction.INPUT 9 | led = digitalio.DigitalInOut(board.LED) # GP25 10 | led.direction = digitalio.Direction.OUTPUT 11 | 12 | board_pins = [] 13 | for pin in dir(microcontroller.pin): 14 | if isinstance(getattr(microcontroller.pin, pin), microcontroller.Pin): 15 | pins = [] 16 | for alias in dir(board): 17 | if getattr(board, alias) is getattr(microcontroller.pin, pin): 18 | pins.append("board.{}".format(alias)) 19 | if len(pins) > 0: 20 | board_pins.append(" ".join(pins)) 21 | for pins in sorted(board_pins): 22 | print(pins) 23 | 24 | timer = time.monotonic() 25 | led.value = True 26 | while True: 27 | if not button_next.value: 28 | led.deinit() 29 | button_next.deinit() 30 | exec(open("code.py").read()) 31 | if timer + 0.4 < time.monotonic(): 32 | led.value = not led.value 33 | timer = time.monotonic() 34 | -------------------------------------------------------------------------------- /circuitpython_T-PicoC3/menu/tft_example.py: -------------------------------------------------------------------------------- 1 | # ST7789 on T-Display rpi2040 @kreier 2022-05-23 2 | 3 | import board 4 | import displayio 5 | from adafruit_st7789 import ST7789 6 | 7 | spi = board.SPI() 8 | while not spi.try_lock(): 9 | pass 10 | spi.configure(baudrate=24000000) # Configure SPI for 24MHz 11 | spi.unlock() 12 | tft_cs = board.D5 13 | tft_dc = board.D6 14 | 15 | displayio.release_displays() 16 | display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=board.D9) 17 | 18 | display = ST7789(display_bus, width=240, height=240, rowstart=80) 19 | 20 | # Make the display context 21 | splash = displayio.Group(max_size=10) 22 | display.show(splash) 23 | 24 | color_bitmap = displayio.Bitmap(240, 240, 1) 25 | color_palette = displayio.Palette(1) 26 | color_palette[0] = 0xFF0000 27 | 28 | bg_sprite = displayio.TileGrid(color_bitmap, 29 | pixel_shader=color_palette, 30 | x=0, y=0) 31 | splash.append(bg_sprite) 32 | 33 | while True: 34 | pass 35 | -------------------------------------------------------------------------------- /circuitpython_esp32/apps/blink.py: -------------------------------------------------------------------------------- 1 | # LED Blink T-Display rpi2040 2 | 3 | import board 4 | import digitalio 5 | 6 | led = digitalio.DigitalInOut(board.LED) 7 | led.direction = digitalio.Direction.OUTPUT 8 | 9 | while True: 10 | led.value = True 11 | -------------------------------------------------------------------------------- /circuitpython_esp32/apps/led.py: -------------------------------------------------------------------------------- 1 | import time 2 | import board 3 | import digitalio 4 | 5 | led = digitalio.DigitalInOut(board.LED) 6 | led.direction = digitalio.Direction.OUTPUT 7 | led.value = True 8 | time.sleep(1) 9 | led.value = False 10 | time.sleep(1) 11 | 12 | print("Done!") 13 | led.deinit() 14 | -------------------------------------------------------------------------------- /circuitpython_esp32/apps/led2.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_esp32/apps/led2.py -------------------------------------------------------------------------------- /circuitpython_esp32/apps/pin_board.py: -------------------------------------------------------------------------------- 1 | """CircuitPython Essentials Pin Map Script""" 2 | import microcontroller 3 | import board 4 | 5 | board_pins = [] 6 | for pin in dir(microcontroller.pin): 7 | if isinstance(getattr(microcontroller.pin, pin), microcontroller.Pin): 8 | pins = [] 9 | for alias in dir(board): 10 | if getattr(board, alias) is getattr(microcontroller.pin, pin): 11 | pins.append("board.{}".format(alias)) 12 | if len(pins) > 0: 13 | board_pins.append(" ".join(pins)) 14 | for pins in sorted(board_pins): 15 | print(pins) 16 | -------------------------------------------------------------------------------- /circuitpython_esp32/apps/pinmap.py: -------------------------------------------------------------------------------- 1 | """CircuitPython Essentials Pin Map Script""" 2 | import microcontroller 3 | import board 4 | 5 | board_pins = [] 6 | for pin in dir(microcontroller.pin): 7 | if isinstance(getattr(microcontroller.pin, pin), microcontroller.Pin): 8 | pins = [] 9 | for alias in dir(board): 10 | if getattr(board, alias) is getattr(microcontroller.pin, pin): 11 | pins.append("board.{}".format(alias)) 12 | if len(pins) > 0: 13 | board_pins.append(" ".join(pins)) 14 | for pins in sorted(board_pins): 15 | print(pins) 16 | -------------------------------------------------------------------------------- /circuitpython_esp32/apps/scan_pins.py: -------------------------------------------------------------------------------- 1 | import time 2 | import board 3 | import digitalio 4 | import re 5 | 6 | # What pins can be switched on and off? 7 | pins = [] 8 | 9 | for item in dir(board): 10 | if item[0] == "G": 11 | pins.append(item) 12 | 13 | for pin in pins: 14 | print("We investigate Pin {}".format(pin)) 15 | led_pin = "board." + pin 16 | print(led_pin) 17 | led = digitalio.DigitalInOut(led_pin) 18 | 19 | 20 | 21 | ''' 22 | led = digitalio.DigitalInOut(board.LED) 23 | led.direction = digitalio.Direction.OUTPUT 24 | led.value = True 25 | time.sleep(1) 26 | led.value = False 27 | time.sleep(1) 28 | 29 | print("Done!") 30 | led.deinit() 31 | 32 | """CircuitPython Essentials Pin Map Script""" 33 | import microcontroller 34 | import board 35 | 36 | board_pins = [] 37 | for pin in dir(microcontroller.pin): 38 | if isinstance(getattr(microcontroller.pin, pin), microcontroller.Pin): 39 | pins = [] 40 | for alias in dir(board): 41 | if getattr(board, alias) is getattr(microcontroller.pin, pin): 42 | pins.append("board.{}".format(alias)) 43 | if len(pins) > 0: 44 | board_pins.append(" ".join(pins)) 45 | for pins in sorted(board_pins): 46 | print(pins) 47 | ''' 48 | print("Hello world!") 49 | -------------------------------------------------------------------------------- /circuitpython_esp32/apps/tft_example.py: -------------------------------------------------------------------------------- 1 | # ST7789 on T-Display rpi2040 @kreier 2022-05-23 2 | 3 | import board 4 | import displayio 5 | from adafruit_st7789 import ST7789 6 | 7 | spi = board.SPI() 8 | while not spi.try_lock(): 9 | pass 10 | spi.configure(baudrate=24000000) # Configure SPI for 24MHz 11 | spi.unlock() 12 | tft_cs = board.D5 13 | tft_dc = board.D6 14 | 15 | displayio.release_displays() 16 | display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=board.D9) 17 | 18 | display = ST7789(display_bus, width=240, height=240, rowstart=80) 19 | 20 | # Make the display context 21 | splash = displayio.Group(max_size=10) 22 | display.show(splash) 23 | 24 | color_bitmap = displayio.Bitmap(240, 240, 1) 25 | color_palette = displayio.Palette(1) 26 | color_palette[0] = 0xFF0000 27 | 28 | bg_sprite = displayio.TileGrid(color_bitmap, 29 | pixel_shader=color_palette, 30 | x=0, y=0) 31 | splash.append(bg_sprite) 32 | 33 | while True: 34 | pass 35 | -------------------------------------------------------------------------------- /circuitpython_esp32/apps/tft_test2.py: -------------------------------------------------------------------------------- 1 | # ST7789 on T-Display RP2040 @kreier 2023-03-04 2 | # TFT_SCLK 2 3 | # TFT_CS 5 4 | # TFT_DC 1 5 | # TFT_RST 0 6 | # TFT_BL 4 7 | # TFT_MOSI 3 8 | # TFT_MISO N/A 9 | 10 | import board, time 11 | import displayio 12 | import digitalio 13 | import busio 14 | import terminalio 15 | import adafruit_st7789 16 | from adafruit_display_text import label 17 | 18 | # First set some parameters used for shapes and text 19 | BORDER = 20 20 | FONTSCALE = 2 21 | BACKGROUND_COLOR = 0x00FF00 # Bright Green 22 | FOREGROUND_COLOR = 0xAA0088 # Purple 23 | TEXT_COLOR = 0xFFFF00 24 | 25 | print("Start SPI bus") 26 | time.sleep(5) 27 | print("Let's go") 28 | displayio.release_displays() 29 | spi = busio.SPI(board.D18, MOSI=board.D19, MISO=None) 30 | while not spi.try_lock(): 31 | pass 32 | spi.configure(baudrate=24000000) # Configure SPI for 24MHz 33 | spi.unlock() 34 | tft_cs = board.D5 35 | tft_dc = board.RX 36 | 37 | display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=board.D23) 38 | display = adafruit_st7789.ST7789(display_bus, width=240, height=135, rowstart=40, colstart=53, rotation=270) 39 | 40 | # Make the display context 41 | splash = displayio.Group() 42 | display.show(splash) 43 | 44 | color_bitmap = displayio.Bitmap(display.width, display.height, 1) 45 | color_palette = displayio.Palette(1) 46 | color_palette[0] = BACKGROUND_COLOR 47 | 48 | bg_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, x=0, y=0) 49 | splash.append(bg_sprite) 50 | 51 | # Draw a smaller inner rectangle 52 | inner_bitmap = displayio.Bitmap( 53 | display.width - BORDER * 2, display.height - BORDER * 2, 1 54 | ) 55 | inner_palette = displayio.Palette(1) 56 | inner_palette[0] = FOREGROUND_COLOR 57 | inner_sprite = displayio.TileGrid( 58 | inner_bitmap, pixel_shader=inner_palette, x=BORDER, y=BORDER 59 | ) 60 | splash.append(inner_sprite) 61 | 62 | # Draw a label 63 | text = "Hello World!" 64 | text_area = label.Label(terminalio.FONT, text=text, color=TEXT_COLOR) 65 | text_width = text_area.bounding_box[2] * FONTSCALE 66 | text_group = displayio.Group( 67 | scale=FONTSCALE, 68 | x=display.width // 2 - text_width // 2, 69 | y=display.height // 2, 70 | ) 71 | text_group.append(text_area) # Subgroup for text scaling 72 | splash.append(text_group) 73 | 74 | bl = digitalio.DigitalInOut(board.D2) 75 | bl.direction = digitalio.Direction.OUTPUT 76 | while True: 77 | print("Backlight on.") 78 | bl.value = True 79 | time.sleep(1) 80 | print("Backlight off.") 81 | bl.value = False 82 | time.sleep(1) 83 | pass -------------------------------------------------------------------------------- /circuitpython_esp32/apps/tft_works.py: -------------------------------------------------------------------------------- 1 | import time 2 | import board 3 | import busio 4 | import terminalio 5 | import displayio 6 | from adafruit_display_text import label 7 | from adafruit_st7789 import ST7789 8 | 9 | # Release any resources currently in use for the displays 10 | displayio.release_displays() 11 | 12 | tft_dc = board.RX 13 | tft_cs = board.D5 14 | spi_clk = board.D18 15 | spi_mosi = board.D19 16 | tft_rst = board.D23 17 | backlight = board.D2 # should be D4 18 | spi = busio.SPI(spi_clk, spi_mosi) 19 | 20 | display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=tft_rst) 21 | 22 | display = ST7789( 23 | display_bus, 24 | rotation=270, 25 | width=240, 26 | height=135, 27 | colstart=52, 28 | rowstart=40, 29 | ) 30 | 31 | # Make the display context 32 | splash = displayio.Group() 33 | display.show(splash) 34 | 35 | color_bitmap = displayio.Bitmap(240, 135, 1) 36 | color_palette = displayio.Palette(1) 37 | color_palette[0] = 0x00FF00 # Bright Green 38 | 39 | bg_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, x=0, y=0) 40 | splash.append(bg_sprite) 41 | 42 | # Draw a smaller inner rectangle 43 | inner_bitmap = displayio.Bitmap(200, 95, 1) 44 | inner_palette = displayio.Palette(1) 45 | inner_palette[0] = 0xAA0088 # Purple 46 | inner_sprite = displayio.TileGrid(inner_bitmap, pixel_shader=inner_palette, x=20, y=20) 47 | splash.append(inner_sprite) 48 | 49 | # Draw a label 50 | text_group = displayio.Group(scale=2, x=50, y=70) 51 | text = "Hello World!" 52 | text_area = label.Label(terminalio.FONT, text=text, color=0xFFFF00) 53 | text_group.append(text_area) # Subgroup for text scaling 54 | splash.append(text_group) 55 | 56 | print("Setup done.") 57 | 58 | time.sleep(4) 59 | # while True: 60 | # pass -------------------------------------------------------------------------------- /circuitpython_esp32/code.py: -------------------------------------------------------------------------------- 1 | import math, time 2 | last = 10000 3 | found = 4 # we start from 11, know already 2, 3, 5, 7 4 | print(f"Prime numbers to {last}") 5 | start = time.monotonic() 6 | for number in range(11, last, 2): 7 | prime = True 8 | for divider in range(3, int(math.sqrt(number))+1, 2): 9 | if number % divider == 0: 10 | prime = False 11 | break 12 | if prime: 13 | found += 1 14 | end = time.monotonic() 15 | print(f"This took: {(end - start)} seconds.") 16 | print(f"I found {found} prime numbers.") 17 | 18 | import board, analogio, digitalio 19 | 20 | bat = analogio.AnalogIn(board.BAT_ADC) 21 | button_l = digitalio.DigitalInOut(board.BUTTON_L) 22 | button_l.direction = digitalio.Direction.INPUT 23 | button_r = digitalio.DigitalInOut(board.BUTTON_R) 24 | button_r.direction = digitalio.Direction.INPUT 25 | 26 | def batteryvoltage(): # max analog is 65536 but input is 2:1 voltage divider 27 | battery = 0 28 | for i in range(100): 29 | battery += bat.value 30 | return (battery/100 * 3.3) / 32768 # only half of max because of voltage divider 31 | 32 | while True: 33 | print('(',batteryvoltage(), ')') 34 | time.sleep(1) 35 | -------------------------------------------------------------------------------- /circuitpython_rpi2040/apps/blink.py: -------------------------------------------------------------------------------- 1 | # LED Blink T-Display rpi2040 2 | 3 | import board 4 | import digitalio 5 | 6 | led = digitalio.DigitalInOut(board.LED) 7 | led.direction = digitalio.Direction.OUTPUT 8 | 9 | while True: 10 | led.value = True 11 | -------------------------------------------------------------------------------- /circuitpython_rpi2040/apps/led.py: -------------------------------------------------------------------------------- 1 | import time 2 | import board 3 | import digitalio 4 | 5 | led = digitalio.DigitalInOut(board.LED) 6 | led.direction = digitalio.Direction.OUTPUT 7 | led.value = True 8 | time.sleep(1) 9 | led.value = False 10 | time.sleep(1) 11 | 12 | print("Done!") 13 | led.deinit() 14 | -------------------------------------------------------------------------------- /circuitpython_rpi2040/apps/pin_board.py: -------------------------------------------------------------------------------- 1 | """CircuitPython Essentials Pin Map Script""" 2 | import microcontroller 3 | import board 4 | 5 | board_pins = [] 6 | for pin in dir(microcontroller.pin): 7 | if isinstance(getattr(microcontroller.pin, pin), microcontroller.Pin): 8 | pins = [] 9 | for alias in dir(board): 10 | if getattr(board, alias) is getattr(microcontroller.pin, pin): 11 | pins.append("board.{}".format(alias)) 12 | if len(pins) > 0: 13 | board_pins.append(" ".join(pins)) 14 | for pins in sorted(board_pins): 15 | print(pins) 16 | -------------------------------------------------------------------------------- /circuitpython_rpi2040/apps/pinmap.py: -------------------------------------------------------------------------------- 1 | """CircuitPython Essentials Pin Map Script""" 2 | import microcontroller 3 | import board 4 | 5 | board_pins = [] 6 | for pin in dir(microcontroller.pin): 7 | if isinstance(getattr(microcontroller.pin, pin), microcontroller.Pin): 8 | pins = [] 9 | for alias in dir(board): 10 | if getattr(board, alias) is getattr(microcontroller.pin, pin): 11 | pins.append("board.{}".format(alias)) 12 | if len(pins) > 0: 13 | board_pins.append(" ".join(pins)) 14 | for pins in sorted(board_pins): 15 | print(pins) 16 | -------------------------------------------------------------------------------- /circuitpython_rpi2040/apps/prime5.4.py: -------------------------------------------------------------------------------- 1 | # prime v5.4 2023-12-23 2 | # cycles through limits and writes to the filesystem 3 | 4 | import math, time, digitalio, board, os, terminalio 5 | from adafruit_display_text import label 6 | from adafruit_bitmap_font import bitmap_font 7 | 8 | # try uncommenting different font files if you like 9 | font_file = "fonts/LeagueSpartan-Bold-16.pcf" 10 | # font_file = "fonts/LeagueSpartan-Bold-16.bdf" 11 | # font_file = "fonts/Junction-regular-24.pcf" 12 | 13 | scope = [100, 1000, 10000, 100000, 1000000, 10000000, 25000000, 100000000, 1000000000, 2147483647, 4294967295] 14 | reference = [25, 168, 1229, 9592, 78498, 664579, 1565927, 5761455, 50847534, 105097564, 203280221] 15 | time_calc = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] 16 | led = digitalio.DigitalInOut(board.LED) 17 | led.direction = digitalio.Direction.OUTPUT 18 | led.value = True 19 | display = board.DISPLAY 20 | 21 | def is_prime(number): 22 | global found 23 | flag_prime = 1 24 | for divider in range(3, int(math.sqrt(number)) + 1, 2): 25 | if number % divider == 0: 26 | flag_prime = 0 27 | break 28 | return flag_prime 29 | 30 | def find_primes(largest): 31 | global primes 32 | global found 33 | for number in range(11, largest + 1, 2): 34 | if is_prime(number) > 0: 35 | found += 1 36 | primes.append(number) 37 | 38 | def is_prime_fast(number): 39 | global found 40 | flag_prime = 1 41 | largest_divider = int(math.sqrt(number)) + 1 42 | for divider in primes: 43 | if number % divider == 0: 44 | flag_prime = 0 45 | break 46 | if divider > largest_divider: 47 | break 48 | return flag_prime 49 | 50 | def elapsed_time(seconds): 51 | hours = int(seconds/3600) 52 | minutes = int(seconds/60 - hours*60) 53 | sec = int(seconds - minutes*60 - hours*3600) 54 | return(f"{hours}h {minutes}min {sec}s") 55 | 56 | if __name__ == "__main__": 57 | # title, current_scope and progress 58 | # font = terminalio.FONT 59 | font = bitmap_font.load_font(font_file) 60 | color = 0xFFFFFF 61 | 62 | text_area = label.Label(font, text="Prime 5.4 CircuitPython", color=color) 63 | text_area.x = 0 64 | text_area.y = 20 65 | title = label.Label(font, text="Calculating primes to", color=color) 66 | title.x = 10 67 | title.y = 24 68 | text_area.append(title) 69 | current_scope = label.Label(font, text="100", color=color, background_color=0x000000) 70 | current_scope.x = 130 71 | current_scope.y = 50 72 | text_area.append(current_scope) 73 | percent = label.Label(font, text=" 0.00 Percent ", color=color, background_color=0x000000) 74 | percent.x = 60 75 | percent.y = 75 76 | text_area.append(percent) 77 | runtime = label.Label(font, text=" 0h 0min 0s ", color=color, background_color=0x000000) 78 | runtime.x = 70 79 | runtime.y = 100 80 | text_area.append(runtime) 81 | display.root_group = text_area 82 | 83 | for i in range(8): # 8 needs less than a day - len(scope) 84 | last = scope[i] 85 | found = 4 # we start from 11, know 2, 3, 5, 7 86 | primes = [3, 5, 7] # exclude 2 since we only test odd numbers 87 | 88 | current_scope.text = str(last) 89 | current_scope.x = 140 - int(math.log(last, 10))*10 90 | 91 | print(f"\nPrime numbers to {last} in v5.4") 92 | start = time.monotonic() 93 | dot = start 94 | column = 1 95 | largest_divider = int(math.sqrt(last)) 96 | if largest_divider % 2 == 0: 97 | largest_divider += 1 98 | print(f'First find prime dividers up to {largest_divider}.') 99 | find_primes(largest_divider) 100 | print(f'Found {found} primes, now use them als dividers.') 101 | for number in range(largest_divider + 2, last, 2): 102 | found += is_prime_fast(number) 103 | if (time.monotonic() - dot) > 2: 104 | print(f".", end="") 105 | dot = time.monotonic() 106 | led.value = not led.value 107 | column += 1 108 | percent.text = str(int(number*10000/last)/100.0) + " Percent " 109 | runtime.text = elapsed_time(time.monotonic() - start) 110 | if column > 40: 111 | t = elapsed_time(time.monotonic() - start) 112 | print(f" {t} - {number} {int(number*100/last)}% ") 113 | column = 1 114 | duration = time.monotonic() - start 115 | print(f'This took: {duration} seconds.') 116 | print(f'Found {found} primes.') 117 | filename = "/data/" + str(last) + ".txt" 118 | try: 119 | with open(filename, "w") as fp: 120 | fp.write(board.board_id) 121 | fp.write(f'\nPrimes to {last} took {duration} seconds.') 122 | fp.write(f'\nFound {found} primes. Should be {reference[i]}.') 123 | print('Exported to filesystem ') 124 | except: 125 | print("Can't write to the filesystem. Press reset and after that the boot button in the first 5 seconds") 126 | #print(f'Primes to {last} took {(end - start)} seconds.') 127 | #print(f'Found {found} primes. Should be {reference[i]}.') 128 | time_calc[i] = duration 129 | print('\nWrite summary') 130 | try: 131 | with open("summary.txt", "w") as fp: 132 | fp.write(f'Primes calculation in Circuitpython v5.4 2023/12/25\n') 133 | fp.write(board.board_id) 134 | fp.write('\n last time in seconds\n') 135 | for i in range(len(time_calc)): 136 | fp.write(f' {scope[i]} {time_calc[i]}\n') 137 | print('Exported to filesystem ') 138 | except: 139 | print("Can't write to the filesystem. Press reset and after that the boot button in the first 5 seconds") 140 | 141 | while True: 142 | led.value = True 143 | print(f'LED on - to {last} needs {duration} s') 144 | time.sleep(10) 145 | led.value = False 146 | print('LED off') 147 | time.sleep(1) 148 | pass 149 | -------------------------------------------------------------------------------- /circuitpython_rpi2040/apps/prime_to_100M.py: -------------------------------------------------------------------------------- 1 | # prime v5.4 2023-12-23 2 | # cycles through limits and writes to the filesystem 3 | 4 | import math, time, digitalio, board, os, terminalio 5 | from adafruit_display_text import label 6 | from adafruit_bitmap_font import bitmap_font 7 | 8 | # try uncommenting different font files if you like 9 | font_file = "fonts/LeagueSpartan-Bold-16.pcf" 10 | # font_file = "fonts/LeagueSpartan-Bold-16.bdf" 11 | # font_file = "fonts/Junction-regular-24.pcf" 12 | 13 | scope = [100, 1000, 10000, 100000, 1000000, 10000000, 25000000, 100000000, 1000000000, 2147483647, 4294967295] 14 | reference = [25, 168, 1229, 9592, 78498, 664579, 1565927, 5761455, 50847534, 105097564, 203280221] 15 | time_calc = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] 16 | led = digitalio.DigitalInOut(board.LED) 17 | led.direction = digitalio.Direction.OUTPUT 18 | led.value = True 19 | display = board.DISPLAY 20 | 21 | def is_prime(number): 22 | global found 23 | flag_prime = 1 24 | for divider in range(3, int(math.sqrt(number)) + 1, 2): 25 | if number % divider == 0: 26 | flag_prime = 0 27 | break 28 | return flag_prime 29 | 30 | def find_primes(largest): 31 | global primes 32 | global found 33 | for number in range(11, largest + 1, 2): 34 | if is_prime(number) > 0: 35 | found += 1 36 | primes.append(number) 37 | 38 | def is_prime_fast(number): 39 | global found 40 | flag_prime = 1 41 | largest_divider = int(math.sqrt(number)) + 1 42 | for divider in primes: 43 | if number % divider == 0: 44 | flag_prime = 0 45 | break 46 | if divider > largest_divider: 47 | break 48 | return flag_prime 49 | 50 | def elapsed_time(seconds): 51 | hours = int(seconds/3600) 52 | minutes = int(seconds/60 - hours*60) 53 | sec = int(seconds - minutes*60 - hours*3600) 54 | return(f"{hours}h {minutes}min {sec}s") 55 | 56 | if __name__ == "__main__": 57 | # title, current_scope and progress 58 | # font = terminalio.FONT 59 | font = bitmap_font.load_font(font_file) 60 | color = 0xFFFFFF 61 | 62 | text_area = label.Label(font, text="Prime 5.4 CircuitPython", color=color) 63 | text_area.x = 0 64 | text_area.y = 20 65 | title = label.Label(font, text="Calculating primes to", color=color) 66 | title.x = 10 67 | title.y = 24 68 | text_area.append(title) 69 | current_scope = label.Label(font, text="100", color=color, background_color=0x000000) 70 | current_scope.x = 130 71 | current_scope.y = 50 72 | text_area.append(current_scope) 73 | percent = label.Label(font, text=" 0.00 Percent ", color=color, background_color=0x000000) 74 | percent.x = 60 75 | percent.y = 75 76 | text_area.append(percent) 77 | runtime = label.Label(font, text=" 0h 0min 0s ", color=color, background_color=0x000000) 78 | runtime.x = 70 79 | runtime.y = 100 80 | text_area.append(runtime) 81 | display.root_group = text_area 82 | 83 | for i in range(8): # 8 needs less than a day - len(scope) 84 | last = scope[i] 85 | found = 4 # we start from 11, know 2, 3, 5, 7 86 | primes = [3, 5, 7] # exclude 2 since we only test odd numbers 87 | 88 | current_scope.text = str(last) 89 | current_scope.x = 140 - int(math.log(last, 10))*10 90 | 91 | print(f"\nPrime numbers to {last} in v5.4") 92 | start = time.monotonic() 93 | dot = start 94 | column = 1 95 | largest_divider = int(math.sqrt(last)) 96 | if largest_divider % 2 == 0: 97 | largest_divider += 1 98 | print(f'First find prime dividers up to {largest_divider}.') 99 | find_primes(largest_divider) 100 | print(f'Found {found} primes, now use them als dividers.') 101 | for number in range(largest_divider + 2, last, 2): 102 | found += is_prime_fast(number) 103 | if (time.monotonic() - dot) > 2: 104 | print(f".", end="") 105 | dot = time.monotonic() 106 | led.value = not led.value 107 | column += 1 108 | percent.text = str(int(number*10000/last)/100.0) + " Percent " 109 | runtime.text = elapsed_time(time.monotonic() - start) 110 | if column > 40: 111 | t = elapsed_time(time.monotonic() - start) 112 | print(f" {t} - {number} {int(number*100/last)}% ") 113 | column = 1 114 | duration = time.monotonic() - start 115 | print(f'This took: {duration} seconds.') 116 | print(f'Found {found} primes.') 117 | filename = "/" + str(last) + ".txt" 118 | try: 119 | with open(filename, "w") as fp: 120 | fp.write(board.board_id) 121 | fp.write(f'\nPrimes to {last} took {duration} seconds.') 122 | fp.write(f'\nFound {found} primes. Should be {reference[i]}.') 123 | print('Exported to filesystem ') 124 | except: 125 | print("Can't write to the filesystem. Press reset and after that the boot button in the first 5 seconds") 126 | #print(f'Primes to {last} took {(end - start)} seconds.') 127 | #print(f'Found {found} primes. Should be {reference[i]}.') 128 | time_calc[i] = duration 129 | print('\nWrite summary') 130 | try: 131 | with open("summary.txt", "w") as fp: 132 | fp.write(f'Primes calculation in Circuitpython v5.4 2023/12/22\n') 133 | fp.write(board.board_id) 134 | fp.write('\n last time in seconds\n') 135 | for i in range(len(time_calc)): 136 | fp.write(f' {scope[i]} {time_calc[i]}\n') 137 | print('Exported to filesystem ') 138 | except: 139 | print("Can't write to the filesystem. Press reset and after that the boot button in the first 5 seconds") 140 | 141 | while True: 142 | led.value = True 143 | print(f'LED on - to {last} needs {duration} s') 144 | time.sleep(10) 145 | led.value = False 146 | print('LED off') 147 | time.sleep(1) 148 | pass 149 | -------------------------------------------------------------------------------- /circuitpython_rpi2040/apps/scan_pins.py: -------------------------------------------------------------------------------- 1 | import time 2 | import board 3 | import digitalio 4 | import re 5 | 6 | # What pins can be switched on and off? 7 | pins = [] 8 | 9 | for item in dir(board): 10 | if item[0] == "G": 11 | pins.append(item) 12 | 13 | for pin in pins: 14 | print("We investigate Pin {}".format(pin)) 15 | led_pin = "board." + pin 16 | print(led_pin) 17 | led = digitalio.DigitalInOut(led_pin) 18 | 19 | 20 | 21 | ''' 22 | led = digitalio.DigitalInOut(board.LED) 23 | led.direction = digitalio.Direction.OUTPUT 24 | led.value = True 25 | time.sleep(1) 26 | led.value = False 27 | time.sleep(1) 28 | 29 | print("Done!") 30 | led.deinit() 31 | 32 | """CircuitPython Essentials Pin Map Script""" 33 | import microcontroller 34 | import board 35 | 36 | board_pins = [] 37 | for pin in dir(microcontroller.pin): 38 | if isinstance(getattr(microcontroller.pin, pin), microcontroller.Pin): 39 | pins = [] 40 | for alias in dir(board): 41 | if getattr(board, alias) is getattr(microcontroller.pin, pin): 42 | pins.append("board.{}".format(alias)) 43 | if len(pins) > 0: 44 | board_pins.append(" ".join(pins)) 45 | for pins in sorted(board_pins): 46 | print(pins) 47 | ''' 48 | print("Hello world!") 49 | -------------------------------------------------------------------------------- /circuitpython_rpi2040/apps/tft_example.py: -------------------------------------------------------------------------------- 1 | # ST7789 on T-Display rpi2040 @kreier 2022-05-23 2 | 3 | import board 4 | import displayio 5 | from adafruit_st7789 import ST7789 6 | 7 | spi = board.SPI() 8 | while not spi.try_lock(): 9 | pass 10 | spi.configure(baudrate=24000000) # Configure SPI for 24MHz 11 | spi.unlock() 12 | tft_cs = board.D5 13 | tft_dc = board.D6 14 | 15 | displayio.release_displays() 16 | display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=board.D9) 17 | 18 | display = ST7789(display_bus, width=240, height=240, rowstart=80) 19 | 20 | # Make the display context 21 | splash = displayio.Group(max_size=10) 22 | display.show(splash) 23 | 24 | color_bitmap = displayio.Bitmap(240, 240, 1) 25 | color_palette = displayio.Palette(1) 26 | color_palette[0] = 0xFF0000 27 | 28 | bg_sprite = displayio.TileGrid(color_bitmap, 29 | pixel_shader=color_palette, 30 | x=0, y=0) 31 | splash.append(bg_sprite) 32 | 33 | while True: 34 | pass 35 | -------------------------------------------------------------------------------- /circuitpython_rpi2040/boot.py: -------------------------------------------------------------------------------- 1 | # toggle the write switch to the local file system 2023/12/23 2 | 3 | import board 4 | import busio 5 | import displayio 6 | from adafruit_st7789 import ST7789 7 | 8 | # Release any resources currently in use for the displays 9 | displayio.release_displays() 10 | 11 | tft_dc = board.LCD_DC 12 | tft_cs = board.LCD_CS 13 | spi_clk = board.LCD_CLK 14 | spi_mosi = board.LCD_MOSI 15 | tft_rst = board.LCD_RESET 16 | backlight = board.LCD_BACKLIGHT 17 | spi = busio.SPI(spi_clk, spi_mosi) 18 | 19 | display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=tft_rst) 20 | 21 | display = ST7789( 22 | display_bus, 23 | rotation=270, 24 | width=240, 25 | height=135, 26 | rowstart=40, 27 | colstart=53, 28 | backlight_pin=backlight, 29 | ) 30 | 31 | 32 | import time 33 | import board 34 | import digitalio 35 | import storage 36 | 37 | button_pin = board.BUTTON_L 38 | # T-Display rp2040 board.BUTTON_L False if pressed 39 | # rp2040 with NeoPixel board.BUTTON 40 | # T-Display ESP32-S2 board.IO0 41 | 42 | button = digitalio.DigitalInOut(button_pin) 43 | button.direction = digitalio.Direction.INPUT 44 | # button.pull = digitalio.Pull.UP 45 | 46 | led = digitalio.DigitalInOut(board.LED) 47 | led.direction = digitalio.Direction.OUTPUT 48 | led.value = True 49 | 50 | time.sleep(1) 51 | timer = 5 52 | can_write = False 53 | print(f"Press the button in the next {timer} seconds to activate saving") 54 | end = time.monotonic() + timer 55 | print(timer) 56 | while end - time.monotonic() > 0: 57 | if not button.value: 58 | print("write access activated") 59 | storage.remount("/", False) 60 | can_write = True 61 | if end - timer + 1 < time.monotonic(): 62 | timer -= 1 63 | led.value = False 64 | time.sleep(0.1) 65 | led.value = True 66 | print(timer) 67 | if can_write: 68 | led.value = False 69 | else: 70 | led.value = True 71 | if not can_write: 72 | print("Not activated") 73 | time.sleep(1) 74 | -------------------------------------------------------------------------------- /circuitpython_rpi2040/code.py: -------------------------------------------------------------------------------- 1 | # Menu selector v0.2 for LILYGO T-Display rp2040 - 2023/12/25 2 | # https://github.com/kreier/t-display/tree/main/circuitpython_rpi2040 3 | 4 | import time, board, digitalio, os, terminalio 5 | from adafruit_display_text import label 6 | from adafruit_bitmap_font import bitmap_font 7 | 8 | font_file = "fonts/LeagueSpartan-Bold-16.pcf" 9 | # font_file = "fonts/LeagueSpartan-Bold-16.bdf" 10 | # font_file = "fonts/Junction-regular-24.pcf" 11 | 12 | led = digitalio.DigitalInOut(board.LED) # GP25 13 | led.direction = digitalio.Direction.OUTPUT 14 | led.value = True 15 | button_next = digitalio.DigitalInOut(board.BUTTON_L) 16 | button_next.direction = digitalio.Direction.INPUT 17 | button_ok = digitalio.DigitalInOut(board.BUTTON_R) 18 | button_ok.direction = digitalio.Direction.INPUT 19 | display = board.DISPLAY 20 | 21 | programs = [] # link to all programs installed in /menu (avoid clutter from all apps in /apps) 22 | menu = [] # all menu options - can be more than fit on the display 23 | menu_item = [] # the five items that currently fit on the display 24 | selected_item = 0 25 | selected_program = 0 26 | 27 | directory = os.listdir("menu") # folder for menu programs - less cluttered 28 | directory.sort() # collection of all programs are in /apps 29 | 30 | def fill_menu(first_program): 31 | for i in range(5): 32 | if i + first_program < len(menu): 33 | menu_item[i].text = menu[i + first_program] 34 | else: 35 | menu_item[i].text = " " 36 | 37 | # create program list in /menu but skipping deleted programs 38 | for i, x in enumerate(directory): 39 | if x[:2] != "._": 40 | programs.append(directory[i]) 41 | number_programs = len(programs) # number of installed programs 42 | 43 | # first menu item: 44 | menu.append(" Settings [{}] ".format(number_programs)) 45 | for i, x in enumerate(programs): 46 | menu.append(" " + x[:-3].replace("_", " ") + " ") # remove the .py from program files 47 | 48 | statusbar = label.Label(terminalio.FONT, text=f" CircuitPython 8.2.9 | {number_programs} ", color=0x99AAFF) 49 | statusbar.x = 0 50 | statusbar.y = 6 51 | battery = label.Label(terminalio.FONT, text="100%", color=0x00FF00) 52 | battery.x = 210 53 | battery.y = 0 54 | statusbar.append(battery) 55 | font = bitmap_font.load_font(font_file) 56 | color = 0xFFFFFF 57 | menu_item = [] 58 | for i in range(5): 59 | menu_item.append(label.Label(font, text=" Item " + str(i) + " "*30, color=color, background_color=0x000000)) 60 | menu_item[i].x = 1 61 | menu_item[i].y = 20 + 23*i 62 | statusbar.append(menu_item[i]) 63 | fill_menu(0) 64 | display.root_group = statusbar 65 | led.value = False 66 | 67 | menu_item[selected_item].color=0x000000 68 | menu_item[selected_item].background_color=0xFFFFFF 69 | timer = time.monotonic() 70 | while True: 71 | if not button_next.value: 72 | led.value = True 73 | menu_item[selected_item].color=0xFFFFFF 74 | menu_item[selected_item].background_color=0x000000 75 | selected_program += 1 76 | if selected_program > len(programs): 77 | selected_program = 0 78 | selected_item = 4 79 | selected_item += 1 80 | if selected_item > 4: 81 | selected_item = 0 82 | fill_menu(selected_program) 83 | menu_item[selected_item].color=0x000000 84 | menu_item[selected_item].background_color=0xFFFFFF 85 | while not button_next.value: 86 | pass 87 | led.value = False 88 | if not button_ok.value: 89 | program = "menu/" + programs[selected_program - 1] 90 | print("Selected: ", program) 91 | display.show(None) 92 | button_next.deinit() 93 | button_ok.deinit() 94 | led.deinit() 95 | exec(open(program).read()) 96 | break 97 | if timer + 1 < time.monotonic(): 98 | led.value = not led.value 99 | timer = time.monotonic() 100 | -------------------------------------------------------------------------------- /circuitpython_rpi2040/data/100.txt: -------------------------------------------------------------------------------- 1 | lilygo_t_display_rp2040 2 | Primes to 100 took 0.00800323 seconds. 3 | Found 25 primes. Should be 25. -------------------------------------------------------------------------------- /circuitpython_rpi2040/data/1000.txt: -------------------------------------------------------------------------------- 1 | lilygo_t_display_rp2040 2 | Primes to 1000 took 0.0600052 seconds. 3 | Found 168 primes. Should be 168. -------------------------------------------------------------------------------- /circuitpython_rpi2040/data/10000.txt: -------------------------------------------------------------------------------- 1 | lilygo_t_display_rp2040 2 | Primes to 10,000 took 0.653999 seconds. 3 | Found 1229 primes. Should be 1229. -------------------------------------------------------------------------------- /circuitpython_rpi2040/data/100000.txt: -------------------------------------------------------------------------------- 1 | lilygo_t_display_rp2040 2 | Primes to 100,000 took 9.282 seconds. 3 | Found 9592 primes. Should be 9592. -------------------------------------------------------------------------------- /circuitpython_rpi2040/data/1000000.txt: -------------------------------------------------------------------------------- 1 | lilygo_t_display_rp2040 2 | Primes to 1,000,000 took 155.442 seconds. 3 | Found 78498 primes. Should be 78498. -------------------------------------------------------------------------------- /circuitpython_rpi2040/data/summary.txt: -------------------------------------------------------------------------------- 1 | Primes calculation in Circuitpython v5.4 2023/12/22 2 | lilygo_t_display_rp2040 3 | last time in seconds 4 | 100 0.00699997 5 | 1000 0.072998 6 | 10000 0.666 7 | 100000 9.701 8 | 1000000 158.391 9 | 10000000 2976.13 10 | 25000000 9911.98 11 | 100000000 62744.1 12 | 1000000000 0 13 | 2147483647 0 14 | 4294967295 0 15 | -------------------------------------------------------------------------------- /circuitpython_rpi2040/fonts/Junction-regular-24.pcf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_rpi2040/fonts/Junction-regular-24.pcf -------------------------------------------------------------------------------- /circuitpython_rpi2040/fonts/LeagueSpartan-Bold-16.pcf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_rpi2040/fonts/LeagueSpartan-Bold-16.pcf -------------------------------------------------------------------------------- /circuitpython_rpi2040/lib/adafruit_bitmap_font/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_rpi2040/lib/adafruit_bitmap_font/__init__.py -------------------------------------------------------------------------------- /circuitpython_rpi2040/lib/adafruit_bitmap_font/bdf.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_rpi2040/lib/adafruit_bitmap_font/bdf.mpy -------------------------------------------------------------------------------- /circuitpython_rpi2040/lib/adafruit_bitmap_font/bitmap_font.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_rpi2040/lib/adafruit_bitmap_font/bitmap_font.mpy -------------------------------------------------------------------------------- /circuitpython_rpi2040/lib/adafruit_bitmap_font/glyph_cache.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_rpi2040/lib/adafruit_bitmap_font/glyph_cache.mpy -------------------------------------------------------------------------------- /circuitpython_rpi2040/lib/adafruit_bitmap_font/pcf.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_rpi2040/lib/adafruit_bitmap_font/pcf.mpy -------------------------------------------------------------------------------- /circuitpython_rpi2040/lib/adafruit_bitmap_font/ttf.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_rpi2040/lib/adafruit_bitmap_font/ttf.mpy -------------------------------------------------------------------------------- /circuitpython_rpi2040/lib/adafruit_display_text/__init__.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_rpi2040/lib/adafruit_display_text/__init__.mpy -------------------------------------------------------------------------------- /circuitpython_rpi2040/lib/adafruit_display_text/bitmap_label.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_rpi2040/lib/adafruit_display_text/bitmap_label.mpy -------------------------------------------------------------------------------- /circuitpython_rpi2040/lib/adafruit_display_text/label.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_rpi2040/lib/adafruit_display_text/label.mpy -------------------------------------------------------------------------------- /circuitpython_rpi2040/lib/adafruit_display_text/scrolling_label.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_rpi2040/lib/adafruit_display_text/scrolling_label.mpy -------------------------------------------------------------------------------- /circuitpython_rpi2040/lib/adafruit_st7789.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/circuitpython_rpi2040/lib/adafruit_st7789.mpy -------------------------------------------------------------------------------- /circuitpython_rpi2040/menu/Blinky.py: -------------------------------------------------------------------------------- 1 | # LED Blink T-Display rpi2040 2 | # https://github.com/kreier/t-display/tree/main/circuitpython_rpi2040/menu 3 | 4 | import time, board, digitalio 5 | 6 | button_next = digitalio.DigitalInOut(board.BUTTON_L) 7 | button_next.direction = digitalio.Direction.INPUT 8 | led = digitalio.DigitalInOut(board.LED) # GP25 9 | led.direction = digitalio.Direction.OUTPUT 10 | 11 | timer = time.monotonic() 12 | led.value = True 13 | while True: 14 | if not button_next.value: 15 | led.deinit() 16 | button_next.deinit() 17 | exec(open("code.py").read()) 18 | if timer + 1 < time.monotonic(): 19 | led.value = not led.value 20 | timer = time.monotonic() 21 | print("LED", end=" ") 22 | -------------------------------------------------------------------------------- /circuitpython_rpi2040/menu/Pinmap_of_this_board.py: -------------------------------------------------------------------------------- 1 | """CircuitPython Essentials Pin Map Script""" 2 | # adapted for T-Display with line 5-8 led and button_next and the finishing loop 3 | # https://github.com/kreier/t-display/tree/main/circuitpython_rpi2040/menu 4 | 5 | import microcontroller, board, digitalio 6 | 7 | button_next = digitalio.DigitalInOut(board.BUTTON_L) 8 | button_next.direction = digitalio.Direction.INPUT 9 | led = digitalio.DigitalInOut(board.LED) # GP25 10 | led.direction = digitalio.Direction.OUTPUT 11 | 12 | board_pins = [] 13 | for pin in dir(microcontroller.pin): 14 | if isinstance(getattr(microcontroller.pin, pin), microcontroller.Pin): 15 | pins = [] 16 | for alias in dir(board): 17 | if getattr(board, alias) is getattr(microcontroller.pin, pin): 18 | pins.append("board.{}".format(alias)) 19 | if len(pins) > 0: 20 | board_pins.append(" ".join(pins)) 21 | for pins in sorted(board_pins): 22 | print(pins) 23 | 24 | timer = time.monotonic() 25 | led.value = True 26 | while True: 27 | if not button_next.value: 28 | led.deinit() 29 | button_next.deinit() 30 | exec(open("code.py").read()) 31 | if timer + 0.4 < time.monotonic(): 32 | led.value = not led.value 33 | timer = time.monotonic() 34 | -------------------------------------------------------------------------------- /circuitpython_rpi2040/menu/tft_example.py: -------------------------------------------------------------------------------- 1 | # ST7789 on T-Display rpi2040 @kreier 2022-05-23 2 | 3 | import board 4 | import displayio 5 | from adafruit_st7789 import ST7789 6 | 7 | spi = board.SPI() 8 | while not spi.try_lock(): 9 | pass 10 | spi.configure(baudrate=24000000) # Configure SPI for 24MHz 11 | spi.unlock() 12 | tft_cs = board.D5 13 | tft_dc = board.D6 14 | 15 | displayio.release_displays() 16 | display_bus = displayio.FourWire(spi, command=tft_dc, chip_select=tft_cs, reset=board.D9) 17 | 18 | display = ST7789(display_bus, width=240, height=240, rowstart=80) 19 | 20 | # Make the display context 21 | splash = displayio.Group(max_size=10) 22 | display.show(splash) 23 | 24 | color_bitmap = displayio.Bitmap(240, 240, 1) 25 | color_palette = displayio.Palette(1) 26 | color_palette[0] = 0xFF0000 27 | 28 | bg_sprite = displayio.TileGrid(color_bitmap, 29 | pixel_shader=color_palette, 30 | x=0, y=0) 31 | splash.append(bg_sprite) 32 | 33 | while True: 34 | pass 35 | -------------------------------------------------------------------------------- /docs/TTGO_T-Display_schematics.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/docs/TTGO_T-Display_schematics.pdf -------------------------------------------------------------------------------- /docs/_config.yml: -------------------------------------------------------------------------------- 1 | theme: jekyll-theme-cayman 2 | google_analytics: [UA-126581035-2] 3 | -------------------------------------------------------------------------------- /docs/_layouts/default.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {% if site.google_analytics %} 6 | 7 | 13 | {% endif %} 14 | 15 | 16 | {% seo %} 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 35 | 36 |
37 | {{ content }} 38 | 39 | 45 |
46 | 47 | 48 | -------------------------------------------------------------------------------- /docs/assets/css/style.scss: -------------------------------------------------------------------------------- 1 | --- 2 | --- 3 | 4 | // css for kreier.github.io/T110 #original with headline #147878 5 | 6 | $header-bg-color: #CC2222; // #159959 bottom right corner 7 | $header-bg-color-secondary: #2222CC; // #155999 top left corner 8 | 9 | $body-link-color: #0000CC; // #7EA7D3 10 | $blockquote-text-color: #819198; 11 | 12 | $section-headings-color: #CC22CC; // #159957 13 | 14 | $code-text-color: #191A1A; // #494D4E; 15 | 16 | @import "{{ site.theme }}"; 17 | -------------------------------------------------------------------------------- /docs/assets/css/style_reference.scss: -------------------------------------------------------------------------------- 1 | --- 2 | --- 3 | 4 | // css for kreier.github.io/impact #original with headline #147878 5 | 6 | $header-bg-color: #166989; // #159959 bottom right corner 7 | $header-bg-color-secondary: #168969; // #155999 top left corner 8 | 9 | $body-link-color: #0000CC; // #7EA7D3 10 | $blockquote-text-color: #819198; 11 | 12 | $section-headings-color: #147878; // #159957 13 | 14 | $code-text-color: #191A1A; // #494D4E; 15 | 16 | @import "{{ site.theme }}"; 17 | -------------------------------------------------------------------------------- /docs/assets/css/style_simple.scss: -------------------------------------------------------------------------------- 1 | --- 2 | --- 3 | 4 | // css for kreier.github.io/impact #original with headline #147878 5 | 6 | $header-bg-color: #0F5757; // #159957 bottom right corner 7 | $header-bg-color-secondary: #1A9999; // #7EA7D3 top left corner 8 | 9 | $body-link-color: #0000CC; // #7EA7D3 10 | $blockquote-text-color: #819198; 11 | 12 | $section-headings-color: #147878; // #159957 13 | 14 | $code-text-color: #191A1A; // #494D4E; 15 | 16 | @import "{{ site.theme }}"; 17 | -------------------------------------------------------------------------------- /docs/bat_divider.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/docs/bat_divider.png -------------------------------------------------------------------------------- /docs/bat_esp32.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/docs/bat_esp32.png -------------------------------------------------------------------------------- /docs/pinmap_t-display.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/docs/pinmap_t-display.jpg -------------------------------------------------------------------------------- /docs/qwiic.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/docs/qwiic.png -------------------------------------------------------------------------------- /docs/starfield.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/docs/starfield.gif -------------------------------------------------------------------------------- /docs/x254-i2c.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/docs/x254-i2c.jpg -------------------------------------------------------------------------------- /docs/xh254.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/docs/xh254.jpg -------------------------------------------------------------------------------- /esp32s3/README.md: -------------------------------------------------------------------------------- 1 | # Lilygo TTGO T-Display esp32s3 ST7789 1.9 inch 320x170 8Bit TFT 2 | 3 | You can flash the regular [esp32s3 n8r8](https://circuitpython.org/board/espressif_esp32s3_devkitc_1_n8r8/) circuitpython firmware, but the display is obviously not running. And you don't have support for the 16 MB flash. 4 | 5 | Challenge: the display is not connected via SPI but parallelbus. 6 | 7 | ## Documentation 8 | 9 | - Pull request circuitpython: [Pull by Tyeth](https://github.com/adafruit/circuitpython/tree/9db79efac734a5e5003144f36389e2e33edf8b30/ports/espressif/boards/lilygo_ttgo_t-display-s3) on February 27th, 2023 10 | - Description LilyGO: [on github](https://github.com/Xinyuan-LilyGO/T-Display-S3) 11 | - [Tyeth on github](https://github.com/tyeth) 12 | - [Paralleldisplay on MicroPython](https://docs.circuitpython.org/en/latest/shared-bindings/paralleldisplay/index.html) 13 | - [More parallel displays](https://blog.adafruit.com/2021/09/22/parallel-lcd-displays-on-esp32-s2-with-circuitpython-esp32-circuitpython-espressifsystem-adafruit/) from September 2021 14 | - [The esp32s3 is FAST on a color display](https://github.com/adafruit/circuitpython/issues/6049) 15 | - [More work from Tyeth](https://github.com/tyeth/circuitpython/tree/add-lilygo-T-Display-S3) 16 | - [Circuitpython issue of S3 on board github page](https://github.com/Xinyuan-LilyGO/T-Display-S3/issues/23) 17 | - Flash chip is a Winbond [25Q128JVSQ](https://www.winbond.com/hq/product/code-storage-flash-memory/serial-nor-flash/?__locale=en&partNo=W25Q128JV) 128 MBit (16MByte) according to [rolupusoru](https://github.com/Xinyuan-LilyGO/T-Display-S3/issues/102) 18 | 19 | 20 | ## T-Display rp2040 21 | 22 | - [Pull request](https://github.com/adafruit/circuitpython/pull/6037) 23 | -------------------------------------------------------------------------------- /esp32s3/adafruit_circuitpython_entry/board.c: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of the MicroPython project, http://micropython.org/ 3 | * 4 | * The MIT License (MIT) 5 | * 6 | * Copyright (c) 2020 Scott Shawcroft for Adafruit Industries 7 | * 8 | * Permission is hereby granted, free of charge, to any person obtaining a copy 9 | * of this software and associated documentation files (the "Software"), to deal 10 | * in the Software without restriction, including without limitation the rights 11 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 12 | * copies of the Software, and to permit persons to whom the Software is 13 | * furnished to do so, subject to the following conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be included in 16 | * all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 19 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 21 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 22 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 23 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 24 | * THE SOFTWARE. 25 | */ 26 | 27 | #include "supervisor/board.h" 28 | #include "mpconfigboard.h" 29 | #include "shared-bindings/microcontroller/Pin.h" 30 | #include "shared-module/displayio/__init__.h" 31 | #include "shared-module/displayio/mipi_constants.h" 32 | 33 | #define DELAY 0x80 34 | 35 | //TODO:Tyeth: double check with t-displayS3, this is from lilygo_ttgo_t8_s2_st7789 36 | // display init sequence according to LilyGO example app 37 | uint8_t display_init_sequence[] = { 38 | // sw reset 39 | 0x01, 0 | DELAY, 150, 40 | // sleep out 41 | 0x11, 0 | DELAY, 255, 42 | // normal display mode on 43 | 0x13, 0, 44 | // display and color format settings 45 | 0x36, 1, 0x08, 46 | 0xB6, 2, 0x0A, 0x82, 47 | 0x3A, 1 | DELAY, 0x55, 10, 48 | // ST7789V frame rate setting 49 | 0xB2, 5, 0x0C, 0x0C, 0x00, 0x33, 0x33, 50 | // voltages: VGH / VGL 51 | 0xB7, 1, 0x35, 52 | // ST7789V power setting 53 | 0xBB, 1, 0x28, 54 | 0xC0, 1, 0x0C, 55 | 0xC2, 2, 0x01, 0xFF, 56 | 0xC3, 1, 0x10, 57 | 0xC4, 1, 0x20, 58 | 0xC6, 1, 0x0F, 59 | 0xD0, 2, 0xA4, 0xA1, 60 | // ST7789V gamma setting 61 | 0xE0, 14, 0xD0, 0x00, 0x02, 0x07, 0x0A, 0x28, 0x32, 0x44, 0x42, 0x06, 0x0E, 0x12, 0x14, 0x17, 62 | 0xE1, 14, 0xD0, 0x00, 0x02, 0x07, 0x0A, 0x28, 0x31, 0x54, 0x47, 0x0E, 0x1C, 0x17, 0x1B, 0x1E, 63 | 0x21, 0, 64 | // display on 65 | 0x29, 0 | DELAY, 255, 66 | }; 67 | 68 | static void display_init(void) { 69 | busio_spi_obj_t *spi = &displays[0].fourwire_bus.inline_bus; 70 | 71 | //TODO:TYETH:double check wiring for SPI 72 | common_hal_busio_spi_construct( 73 | spi, 74 | &pin_GPIO36, // CLK 75 | &pin_GPIO35, // MOSI 76 | NULL, // MISO not connected 77 | false); // Not half-duplex 78 | 79 | common_hal_busio_spi_never_reset(spi); 80 | 81 | displayio_fourwire_obj_t *bus = &displays[0].fourwire_bus; 82 | bus->base.type = &displayio_fourwire_type; 83 | 84 | //TODO:TYETH:double check wiring for displayio/fourwire 85 | common_hal_displayio_fourwire_construct( 86 | bus, 87 | spi, 88 | &pin_GPIO37, // DC 89 | &pin_GPIO34, // CS 90 | &pin_GPIO38, // RST 91 | 40000000, // baudrate 92 | 0, // polarity 93 | 0 // phase 94 | ); 95 | 96 | displayio_display_obj_t *display = &displays[0].display; 97 | display->base.type = &displayio_display_type; 98 | 99 | //TODO:TYETH:Double check this, only updated W+H so far... 100 | common_hal_displayio_display_construct( 101 | display, 102 | bus, 103 | 320, // width (after rotation) 104 | 170, // height (after rotation) 105 | 52, // column start 106 | 40, // row start 107 | 90, // rotation 108 | 16, // color depth 109 | false, // grayscale 110 | false, // pixels in a byte share a row. Only valid for depths < 8 111 | 1, // bytes per cell. Only valid for depths < 8 112 | false, // reverse_pixels_in_byte. Only valid for depths < 8 113 | true, // reverse_pixels_in_word 114 | MIPI_COMMAND_SET_COLUMN_ADDRESS, // set column command 115 | MIPI_COMMAND_SET_PAGE_ADDRESS, // set row command 116 | MIPI_COMMAND_WRITE_MEMORY_START, // write memory command 117 | display_init_sequence, 118 | sizeof(display_init_sequence), 119 | &pin_GPIO33, // backlight pin 120 | NO_BRIGHTNESS_COMMAND, 121 | 1.0f, // brightness 122 | false, // single_byte_bounds 123 | false, // data_as_commands 124 | true, // auto_refresh 125 | 60, // native_frames_per_second 126 | true, // backlight_on_high 127 | false, // SH1107_addressing 128 | 50000 // backlight pwm frequency 129 | ); 130 | } 131 | 132 | void board_init(void) { 133 | // Debug UART 134 | #ifdef DEBUG 135 | common_hal_never_reset_pin(&pin_GPIO43); 136 | common_hal_never_reset_pin(&pin_GPIO44); 137 | #endif /* DEBUG */ 138 | 139 | // Display 140 | display_init(); 141 | } 142 | 143 | // Use the MP_WEAK supervisor/shared/board.c versions of routines not defined here. 144 | -------------------------------------------------------------------------------- /esp32s3/adafruit_circuitpython_entry/mpconfigboard.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of the MicroPython project, http://micropython.org/ 3 | * 4 | * The MIT License (MIT) 5 | * 6 | * Copyright (c) 2019 Scott Shawcroft for Adafruit Industries 7 | * 8 | * Permission is hereby granted, free of charge, to any person obtaining a copy 9 | * of this software and associated documentation files (the "Software"), to deal 10 | * in the Software without restriction, including without limitation the rights 11 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 12 | * copies of the Software, and to permit persons to whom the Software is 13 | * furnished to do so, subject to the following conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be included in 16 | * all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 19 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 21 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 22 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 23 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 24 | * THE SOFTWARE. 25 | */ 26 | 27 | // Micropython setup 28 | 29 | #define MICROPY_HW_BOARD_NAME "LILYGO TTGO T-Display-S3" 30 | #define MICROPY_HW_MCU_NAME "ESP32S3" 31 | 32 | 33 | 34 | // #define MICROPY_HW_LED_STATUS (&pin_GPIO3) 35 | 36 | // #define DEFAULT_UART_BUS_RX (&pin_GPIO20) 37 | // #define DEFAULT_UART_BUS_TX (&pin_GPIO21) 38 | 39 | // #define CIRCUITPY_CONSOLE_UART_RX DEFAULT_UART_BUS_RX 40 | // #define CIRCUITPY_CONSOLE_UART_TX DEFAULT_UART_BUS_TX 41 | // #define MICROPY_HW_NEOPIXEL (&pin_GPIO48) 42 | 43 | // #define CIRCUITPY_BOOT_BUTTON (&pin_GPIO0) 44 | 45 | // #define DEFAULT_UART_BUS_RX (&pin_GPIO44) 46 | // #define DEFAULT_UART_BUS_TX (&pin_GPIO43) 47 | 48 | // #define AUTORESET_DELAY_MS 500 49 | -------------------------------------------------------------------------------- /esp32s3/adafruit_circuitpython_entry/mpconfigboard.mk: -------------------------------------------------------------------------------- 1 | USB_VID = 0x303a 2 | USB_PID = 0x813F 3 | USB_PRODUCT = "T-Display-S3" 4 | USB_MANUFACTURER = "LILYGO" 5 | 6 | IDF_TARGET = esp32s3 7 | 8 | CIRCUITPY_ESP_FLASH_MODE = dio 9 | CIRCUITPY_ESP_FLASH_FREQ = 80m 10 | CIRCUITPY_ESP_FLASH_SIZE = 16MB 11 | -------------------------------------------------------------------------------- /esp32s3/adafruit_circuitpython_entry/pins.c: -------------------------------------------------------------------------------- 1 | #include "shared-bindings/board/__init__.h" 2 | #include "shared-module/displayio/__init__.h" 3 | 4 | STATIC const mp_rom_map_elem_t board_module_globals_table[] = { 5 | CIRCUITPYTHON_BOARD_DICT_STANDARD_ITEMS 6 | 7 | { MP_ROM_QSTR(MP_QSTR_IO0), MP_ROM_PTR(&pin_GPIO0) }, 8 | { MP_ROM_QSTR(MP_QSTR_IO1), MP_ROM_PTR(&pin_GPIO1) }, 9 | { MP_ROM_QSTR(MP_QSTR_IO2), MP_ROM_PTR(&pin_GPIO2) }, 10 | { MP_ROM_QSTR(MP_QSTR_IO3), MP_ROM_PTR(&pin_GPIO3) }, 11 | { MP_ROM_QSTR(MP_QSTR_IO4), MP_ROM_PTR(&pin_GPIO4) }, 12 | { MP_ROM_QSTR(MP_QSTR_IO5), MP_ROM_PTR(&pin_GPIO5) }, 13 | { MP_ROM_QSTR(MP_QSTR_IO6), MP_ROM_PTR(&pin_GPIO6) }, 14 | { MP_ROM_QSTR(MP_QSTR_IO7), MP_ROM_PTR(&pin_GPIO7) }, 15 | { MP_ROM_QSTR(MP_QSTR_IO8), MP_ROM_PTR(&pin_GPIO8) }, 16 | { MP_ROM_QSTR(MP_QSTR_IO9), MP_ROM_PTR(&pin_GPIO9) }, 17 | 18 | { MP_ROM_QSTR(MP_QSTR_IO11), MP_ROM_PTR(&pin_GPIO11) }, 19 | { MP_ROM_QSTR(MP_QSTR_IO12), MP_ROM_PTR(&pin_GPIO12) }, 20 | { MP_ROM_QSTR(MP_QSTR_IO13), MP_ROM_PTR(&pin_GPIO13) }, 21 | { MP_ROM_QSTR(MP_QSTR_IO15), MP_ROM_PTR(&pin_GPIO15) }, 22 | { MP_ROM_QSTR(MP_QSTR_IO16), MP_ROM_PTR(&pin_GPIO16) }, 23 | { MP_ROM_QSTR(MP_QSTR_IO17), MP_ROM_PTR(&pin_GPIO17) }, 24 | { MP_ROM_QSTR(MP_QSTR_IO18), MP_ROM_PTR(&pin_GPIO18) }, 25 | { MP_ROM_QSTR(MP_QSTR_IO19), MP_ROM_PTR(&pin_GPIO19) }, 26 | { MP_ROM_QSTR(MP_QSTR_IO20), MP_ROM_PTR(&pin_GPIO20) }, 27 | { MP_ROM_QSTR(MP_QSTR_IO21), MP_ROM_PTR(&pin_GPIO21) }, 28 | 29 | { MP_ROM_QSTR(MP_QSTR_IO39), MP_ROM_PTR(&pin_GPIO39) }, 30 | { MP_ROM_QSTR(MP_QSTR_IO40), MP_ROM_PTR(&pin_GPIO40) }, 31 | { MP_ROM_QSTR(MP_QSTR_IO41), MP_ROM_PTR(&pin_GPIO41) }, 32 | { MP_ROM_QSTR(MP_QSTR_IO42), MP_ROM_PTR(&pin_GPIO42) }, 33 | { MP_ROM_QSTR(MP_QSTR_IO45), MP_ROM_PTR(&pin_GPIO45) }, 34 | { MP_ROM_QSTR(MP_QSTR_IO46), MP_ROM_PTR(&pin_GPIO46) }, 35 | 36 | { MP_ROM_QSTR(MP_QSTR_TX), MP_ROM_PTR(&pin_GPIO43) }, 37 | { MP_ROM_QSTR(MP_QSTR_RX), MP_ROM_PTR(&pin_GPIO44) }, 38 | { MP_ROM_QSTR(MP_QSTR_TX1), MP_ROM_PTR(&pin_GPIO17) }, 39 | { MP_ROM_QSTR(MP_QSTR_RX1), MP_ROM_PTR(&pin_GPIO18) }, 40 | 41 | // SD Card 42 | { MP_ROM_QSTR(MP_QSTR_SD_MISO), MP_ROM_PTR(&pin_GPIO13) }, 43 | { MP_ROM_QSTR(MP_QSTR_SD_MOSI), MP_ROM_PTR(&pin_GPIO11) }, 44 | { MP_ROM_QSTR(MP_QSTR_SD_CLK), MP_ROM_PTR(&pin_GPIO12) }, 45 | { MP_ROM_QSTR(MP_QSTR_SD_CS), MP_ROM_PTR(&pin_GPIO10) }, 46 | 47 | // 1.14 inch LCD ST7789 48 | { MP_ROM_QSTR(MP_QSTR_LCD_MOSI), MP_ROM_PTR(&pin_GPIO35) }, 49 | { MP_ROM_QSTR(MP_QSTR_LCD_CLK), MP_ROM_PTR(&pin_GPIO36) }, 50 | { MP_ROM_QSTR(MP_QSTR_LCD_CS), MP_ROM_PTR(&pin_GPIO34) }, 51 | { MP_ROM_QSTR(MP_QSTR_LCD_RST), MP_ROM_PTR(&pin_GPIO38) }, 52 | { MP_ROM_QSTR(MP_QSTR_LCD_BCKL), MP_ROM_PTR(&pin_GPIO33) }, 53 | { MP_ROM_QSTR(MP_QSTR_LCD_D_C), MP_ROM_PTR(&pin_GPIO37) }, 54 | { MP_ROM_QSTR(MP_QSTR_DISPLAY), MP_ROM_PTR(&displays[0].display) }, 55 | 56 | // Peripheral Power control 57 | { MP_ROM_QSTR(MP_QSTR_PE_POWER), MP_ROM_PTR(&pin_GPIO14) }, 58 | 59 | // Battery Sense 60 | { MP_ROM_QSTR(MP_QSTR_BATTERY), MP_ROM_PTR(&pin_GPIO9) }, 61 | }; 62 | MP_DEFINE_CONST_DICT(board_module_globals, board_module_globals_table); 63 | -------------------------------------------------------------------------------- /esp32s3/adafruit_circuitpython_entry/sdkconfig.txt: -------------------------------------------------------------------------------- 1 | CONFIG_ESP32S3_SPIRAM_SUPPORT=y 2 | # 3 | # SPI RAM config 4 | # 5 | # CONFIG_SPIRAM_MODE_QUAD is not set 6 | CONFIG_SPIRAM_MODE_OCT=y 7 | # CONFIG_SPIRAM_TYPE_AUTO is not set 8 | CONFIG_SPIRAM_TYPE_ESPPSRAM64=y 9 | CONFIG_SPIRAM_SIZE=8388608 10 | # end of SPI RAM config 11 | 12 | CONFIG_DEFAULT_PSRAM_CLK_IO=30 13 | # 14 | # PSRAM Clock and CS IO for ESP32S3 15 | # 16 | CONFIG_DEFAULT_PSRAM_CS_IO=26 17 | # end of PSRAM Clock and CS IO for ESP32S3 18 | 19 | # CONFIG_SPIRAM_FETCH_INSTRUCTIONS is not set 20 | # CONFIG_SPIRAM_RODATA is not set 21 | CONFIG_SPIRAM_SPEED_80M=y 22 | # CONFIG_SPIRAM_SPEED_40M is not set 23 | CONFIG_SPIRAM=y 24 | CONFIG_SPIRAM_BOOT_INIT=y 25 | # CONFIG_SPIRAM_IGNORE_NOTFOUND is not set 26 | CONFIG_SPIRAM_USE_MEMMAP=y 27 | # CONFIG_SPIRAM_USE_CAPS_ALLOC is not set 28 | # CONFIG_SPIRAM_USE_MALLOC is not set 29 | CONFIG_SPIRAM_MEMTEST=y 30 | # 31 | # LWIP 32 | # 33 | CONFIG_LWIP_LOCAL_HOSTNAME="T-Display-S3" 34 | # end of LWIP 35 | -------------------------------------------------------------------------------- /esp32s3/circuitpython/apps/blinka.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/esp32s3/circuitpython/apps/blinka.jpg -------------------------------------------------------------------------------- /esp32s3/circuitpython/apps/display.py: -------------------------------------------------------------------------------- 1 | # Start for T-Display S3 320x170 2 | # 2023/03/07 3 | 4 | import time, os, sys 5 | import board, displayio, terminalio, digitalio, busio 6 | from adafruit_st7789 import ST7789 7 | from adafruit_debouncer import Debouncer 8 | from adafruit_display_text import label 9 | 10 | DISPLAY_ROWS = 5 11 | color_menu = 0xFFFFFF 12 | color_select = 0x000000 # 0x00FF55 13 | long_press = 0.5 # time in seconds for long press to start program 14 | 15 | pin_select = digitalio.DigitalInOut(board.GP15) 16 | pin_select.direction = digitalio.Direction.INPUT 17 | pin_select.pull = digitalio.Pull.UP 18 | switchA = Debouncer(pin_select, interval=0.05) 19 | pin_confirm = digitalio.DigitalInOut(board.GP17) 20 | pin_confirm.direction = digitalio.Direction.INPUT 21 | pin_confirm.pull = digitalio.Pull.UP 22 | switchB = Debouncer(pin_confirm, interval=0.05) 23 | 24 | directory = os.listdir("menu") # folder for programs 25 | directory.sort() 26 | programs = [] 27 | # create program list but skipping deleted programs 28 | for i, x in enumerate(directory): 29 | if x[:2] != "._": 30 | programs.append(directory[i]) 31 | number_programs = len(programs) # number of installed programs 32 | 33 | displayio.release_displays() 34 | spi = busio.SPI(clock=board.GP10, MOSI=board.GP11) 35 | tft_cs = board.GP9 36 | tft_dc = board.GP8 37 | display_bus = displayio.FourWire( 38 | spi, command=tft_dc, chip_select=tft_cs, reset=board.GP12 39 | ) 40 | display = ST7789(display_bus, width=240, height=240, rowstart=80, rotation=90) 41 | 42 | 43 | menu = [] # all menu options - can be more than fit on the display 44 | # first menu item: 45 | menu.append(" Menu/Settings [{}] ".format(number_programs)) 46 | 47 | for i, x in enumerate(programs): 48 | menu.append(" " + x[:-3] + " ") # remove the .py from program files 49 | 50 | displaymenu = displayio.Group() # menu options actually shown on display 51 | select = 0 # item select on the list shown 52 | 53 | 54 | def menu_create(): 55 | for item in range(DISPLAY_ROWS): 56 | listitem = label.Label(terminalio.FONT, text="") 57 | listitem.x = 0 58 | listitem.y = 5 + 13 * item 59 | displaymenu.append(listitem) 60 | 61 | 62 | def menu_fill(s): 63 | if len(menu) < DISPLAY_ROWS: 64 | for item in range(len(menu)): 65 | displaymenu[item].text = menu[item] 66 | else: 67 | for item in range(DISPLAY_ROWS): 68 | displaymenu[item].text = menu[item + s] 69 | # this code fills from the bottom - its slightly faster 70 | #for item in range(DISPLAY_ROWS - 1, -1, -1): 71 | # displaymenu[item].text = menu[item + s] 72 | 73 | 74 | def menu_select(x): 75 | # highlight selected item 76 | displaymenu[x].color = color_select 77 | displaymenu[x].background_color = color_menu 78 | # de-select old item 79 | if x == 0: 80 | if len(menu) > DISPLAY_ROWS: 81 | x = DISPLAY_ROWS 82 | else: 83 | x = len(menu) 84 | x -= 1 85 | displaymenu[x].color = color_menu 86 | displaymenu[x].background_color = color_select 87 | 88 | 89 | # setup 90 | menu_create() 91 | menu_fill(0) 92 | menu_select(0) 93 | display.show(displaymenu) 94 | pressed = time.monotonic() 95 | 96 | # input loop 97 | while True: 98 | switchA.update() 99 | switchB.update() 100 | if switchA.fell: # button pressed 101 | pressed = time.monotonic() 102 | if switchA.rose: # button released 103 | time_pressed = time.monotonic() - pressed 104 | if time_pressed > long_press: # alternative to press button B 105 | if select < 1: 106 | sys.exit() 107 | program = "menu/" + programs[select - 1] 108 | display.show(None) 109 | pin_select.deinit() 110 | pin_confirm.deinit() 111 | exec(open(program).read()) 112 | break 113 | select += 1 114 | if select > len(menu) - 1: 115 | select = 0 116 | menu_fill(0) 117 | if select > DISPLAY_ROWS - 1: 118 | menu_fill(select - DISPLAY_ROWS + 1) 119 | else: 120 | menu_select(select) 121 | if switchB.rose: 122 | if select < 1: 123 | sys.exit() 124 | program = "menu/" + programs[select - 1] 125 | print("Selected: ", program) 126 | display.show(None) 127 | pin_select.deinit() 128 | pin_confirm.deinit() 129 | exec(open(program).read()) 130 | break 131 | -------------------------------------------------------------------------------- /esp32s3/circuitpython/apps/example.py: -------------------------------------------------------------------------------- 1 | # sonar example 2022-02-21 2 | import board, busio, time, math, digitalio, adafruit_hcsr04 3 | from ssis_rvr import pin 4 | from sphero_rvr import RVRDrive 5 | 6 | rvr = RVRDrive(uart = busio.UART(pin.TX, pin.RX, baudrate=115200)) 7 | sonar = adafruit_hcsr04.HCSR04(trigger_pin=pin.TRIGGER, echo_pin=pin.ECHO) 8 | 9 | while True: 10 | try: 11 | sensor_distance = sonar.distance 12 | print(sensor_distance) 13 | if sensor_distance < 10 : 14 | rvr.set_all_leds(255,0,0) 15 | else: 16 | rvr.set_all_leds(0,255,0) 17 | time.sleep(0.1) 18 | rvr.set_all_leds(0,0,0) 19 | time.sleep(sensor_distance / 200) 20 | 21 | except RuntimeError: 22 | print("Retrying!") 23 | rvr.set_all_leds(0,0,255) #set leds to blue 24 | pass 25 | time.sleep(0.2) 26 | -------------------------------------------------------------------------------- /esp32s3/circuitpython/apps/hello_world_tft240_st7789.py: -------------------------------------------------------------------------------- 1 | # SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries 2 | # SPDX-License-Identifier: MIT 3 | 4 | """ 5 | This test will initialize the display using displayio and draw a solid green 6 | background, a smaller purple rectangle, and some yellow text. 7 | """ 8 | import board 9 | import busio 10 | import terminalio 11 | import displayio 12 | from adafruit_display_text import label 13 | from adafruit_st7789 import ST7789 14 | 15 | # Release any resources currently in use for the displays 16 | displayio.release_displays() 17 | 18 | # spi = board.SPI() # does not work on Raspberry Pico 19 | # spi = busio.SPI(clock=board.GP10, MOSI=board.GP11, MISO=board.GP13) 20 | #spi = busio.SPI(clock=board.GP6, MOSI=board.GP7, MISO=board.GP8) 21 | spi = busio.SPI(clock=board.GP10, MOSI=board.GP11) 22 | tft_cs = board.GP9 23 | tft_dc = board.GP8 24 | 25 | display_bus = displayio.FourWire( 26 | spi, command=tft_dc, chip_select=tft_cs, reset=board.GP12 27 | ) 28 | 29 | display = ST7789(display_bus, width=240, height=240, rowstart=80) 30 | 31 | # Make the display context 32 | splash = displayio.Group() 33 | display.show(splash) 34 | 35 | color_bitmap = displayio.Bitmap(240, 240, 1) 36 | color_palette = displayio.Palette(1) 37 | color_palette[0] = 0x00FF00 # Bright Green 38 | 39 | bg_sprite = displayio.TileGrid(color_bitmap, pixel_shader=color_palette, x=0, y=0) 40 | splash.append(bg_sprite) 41 | 42 | # Draw a smaller inner rectangle 43 | inner_bitmap = displayio.Bitmap(200, 200, 1) 44 | inner_palette = displayio.Palette(1) 45 | inner_palette[0] = 0xAA0088 # Purple 46 | inner_sprite = displayio.TileGrid(inner_bitmap, pixel_shader=inner_palette, x=20, y=20) 47 | splash.append(inner_sprite) 48 | 49 | # Draw a label 50 | text_group = displayio.Group(scale=2, x=50, y=120) 51 | text = "Hello World!" 52 | text_area = label.Label(terminalio.FONT, text=text, color=0xFFFF00) 53 | text_group.append(text_area) # Subgroup for text scaling 54 | splash.append(text_group) 55 | 56 | while True: 57 | pass 58 | -------------------------------------------------------------------------------- /esp32s3/circuitpython/apps/main.py: -------------------------------------------------------------------------------- 1 | # mandelbrot on rp2040 with st7789 240x240 2 | # https://github.com/kreier/mandelbrot/circuitpython 3 | # 2022/11/28 v0.1 4 | 5 | import board, displayio, random, busio 6 | from adafruit_st7789 import ST7789 7 | displayio.release_displays() 8 | spi = busio.SPI(clock=board.GP10, MOSI=board.GP11) 9 | tft_cs = board.GP9 10 | tft_dc = board.GP8 11 | display_bus = displayio.FourWire( 12 | spi, command=tft_dc, chip_select=tft_cs, reset=board.GP12 13 | ) 14 | display = ST7789(display_bus, width=240, height=240, rowstart=80) 15 | # display = board.DISPLAY # this works on the clue 16 | 17 | # Create a bitmap with 256 colors 18 | bitmap = displayio.Bitmap(display.width, display.height, 256) 19 | 20 | def hsv_to_rgb(h, s, v): 21 | if s == 0.0: v*=255; return (v, v, v) 22 | i = int(h*6.) 23 | f = (h*6.)-i; p,q,t = int(255*(v*(1.-s))), int(255*(v*(1.-s*f))), int(255*(v*(1.-s*(1.-f)))); v*=255; i%=6 24 | if i == 0: ret = (65536*v + 256*t + p) 25 | if i == 1: ret = (65536*q + 256*v + p) 26 | if i == 2: ret = (65536*p + 256*v + t) 27 | if i == 3: ret = (65536*p + 256*q + v) 28 | if i == 4: ret = (65536*t + 256*p + v) 29 | if i == 5: ret = (65536*v + 256*p + q) 30 | #return f"{ret:06X}" 31 | return ret 32 | 33 | # Create a 256 color palette 34 | palette = displayio.Palette(256) 35 | for i in range(256): 36 | #palette[i] = random.randrange(16777216) 37 | palette[i] = hsv_to_rgb(i/256, 1, 1) 38 | palette[0] = 0 39 | 40 | # Create a TileGrid using the Bitmap and Palette 41 | tile_grid = displayio.TileGrid(bitmap, pixel_shader=palette) 42 | 43 | # Create a Group 44 | group = displayio.Group() 45 | 46 | # Add the TileGrid to the Group 47 | group.append(tile_grid) 48 | 49 | # Add the Group to the Display 50 | display.show(group) 51 | 52 | # Draw even more pixels 53 | #for c in range(len(palette)): 54 | # for x in range(display.width): 55 | # for y in range(display.height): 56 | # bitmap[x, y] = (x + y) % 256 57 | 58 | minX = -1.9 59 | maxX = 0.6 60 | width = display.width 61 | height = display.height 62 | aspectRatio = 1 63 | ITERATION = 50 64 | yScale = (maxX-minX)*(float(height)/width)*aspectRatio 65 | 66 | for y in range(height): 67 | for x in range(width): 68 | c = complex(minX+x*(maxX-minX)/width, y*yScale/height-yScale/2) 69 | z = c 70 | for iter in range(ITERATION): 71 | if abs(z) > 2: 72 | break 73 | z = z*z+c 74 | if iter == ITERATION - 1: 75 | pixelcolor = 0 76 | else: 77 | pixelcolor = iter *5 78 | bitmap[x, y] = pixelcolor 79 | 80 | 81 | # Loop forever so you can enjoy your image 82 | while True: 83 | pass 84 | -------------------------------------------------------------------------------- /esp32s3/circuitpython/apps/mandelbrot.py: -------------------------------------------------------------------------------- 1 | # mandelbrot on clue 2 | # https://github.com/kreier/mandelbrot/circuitpython 3 | # 2022/10/28 v0.1 4 | 5 | import board, displayio, random, busio 6 | from adafruit_st7789 import ST7789 7 | displayio.release_displays() 8 | spi = busio.SPI(clock=board.GP10, MOSI=board.GP11) 9 | tft_cs = board.GP9 10 | tft_dc = board.GP8 11 | display_bus = displayio.FourWire( 12 | spi, command=tft_dc, chip_select=tft_cs, reset=board.GP12 13 | ) 14 | display = ST7789(display_bus, width=240, height=240, rowstart=80) 15 | # display = board.DISPLAY # this works on the clue 16 | 17 | # Create a bitmap with 256 colors 18 | bitmap = displayio.Bitmap(display.width, display.height, 256) 19 | 20 | def hsv_to_rgb(h, s, v): 21 | if s == 0.0: v*=255; return (v, v, v) 22 | i = int(h*6.) 23 | f = (h*6.)-i; p,q,t = int(255*(v*(1.-s))), int(255*(v*(1.-s*f))), int(255*(v*(1.-s*(1.-f)))); v*=255; i%=6 24 | if i == 0: ret = (65536*v + 256*t + p) 25 | if i == 1: ret = (65536*q + 256*v + p) 26 | if i == 2: ret = (65536*p + 256*v + t) 27 | if i == 3: ret = (65536*p + 256*q + v) 28 | if i == 4: ret = (65536*t + 256*p + v) 29 | if i == 5: ret = (65536*v + 256*p + q) 30 | #return f"{ret:06X}" 31 | return ret 32 | 33 | # Create a 256 color palette 34 | palette = displayio.Palette(256) 35 | for i in range(256): 36 | #palette[i] = random.randrange(16777216) 37 | palette[i] = hsv_to_rgb(i/256, 1, 1) 38 | palette[0] = 0 39 | 40 | # Create a TileGrid using the Bitmap and Palette 41 | tile_grid = displayio.TileGrid(bitmap, pixel_shader=palette) 42 | 43 | # Create a Group 44 | group = displayio.Group() 45 | 46 | # Add the TileGrid to the Group 47 | group.append(tile_grid) 48 | 49 | # Add the Group to the Display 50 | display.show(group) 51 | 52 | # Draw even more pixels 53 | #for c in range(len(palette)): 54 | # for x in range(display.width): 55 | # for y in range(display.height): 56 | # bitmap[x, y] = (x + y) % 256 57 | 58 | minX = -2.0 59 | maxX = 1.0 60 | width = display.width 61 | height = display.height 62 | aspectRatio = 1 63 | ITERATION = 50 64 | yScale = (maxX-minX)*(float(height)/width)*aspectRatio 65 | 66 | for y in range(height): 67 | for x in range(width): 68 | c = complex(minX+x*(maxX-minX)/width, y*yScale/height-yScale/2) 69 | z = c 70 | for iter in range(ITERATION): 71 | if abs(z) > 2: 72 | break 73 | z = z*z+c 74 | if iter == ITERATION - 1: 75 | pixelcolor = 0 76 | else: 77 | pixelcolor = iter *5 78 | bitmap[x, y] = pixelcolor 79 | 80 | 81 | # Loop forever so you can enjoy your image 82 | while True: 83 | pass 84 | -------------------------------------------------------------------------------- /esp32s3/circuitpython/apps/prime.py: -------------------------------------------------------------------------------- 1 | import math, time 2 | last = 10000 3 | found = 4 # we start from 11, know 2, 3, 5, 7 4 | print(f"Prime numbers to {last}") 5 | #print("2, 3, 5, 7") 6 | start = time.monotonic() 7 | for number in range(11, last, 2): 8 | prime = True 9 | for divider in range(3, int(math.sqrt(number))+1, 2): 10 | if number % divider == 0: 11 | prime = False 12 | break 13 | if prime: 14 | found += 1 15 | # print(number, sep=', ', end=' ') 16 | end = time.monotonic() 17 | print(f"This took: {(end - start)} seconds.") 18 | print(f"I found {found} prime numbers.") 19 | -------------------------------------------------------------------------------- /esp32s3/circuitpython/apps/prime_logging_51.py: -------------------------------------------------------------------------------- 1 | # prime v5.1 2023-12-06 2 | # cycles through limits and writes to the filesystem 3 | 4 | import math, time, digitalio, board, os 5 | 6 | scope = [100, 1000, 10000, 100000, 1000000, 10000000, 25000000, 100000000, 1000000000] 7 | reference = [25, 168, 1229, 9592, 78498, 664579, 1565927, 5761455, 123456789] 8 | 9 | def is_prime(number): 10 | global found 11 | flag_prime = 1 12 | for divider in range(3, int(math.sqrt(number)) + 1, 2): 13 | if number % divider == 0: 14 | flag_prime = 0 15 | break 16 | return flag_prime 17 | 18 | def find_primes(largest): 19 | global primes 20 | global found 21 | for number in range(11, largest + 1, 2): 22 | if is_prime(number) > 0: 23 | found += 1 24 | primes.append(number) 25 | 26 | def is_prime_fast(number): 27 | global found 28 | flag_prime = 1 29 | largest_divider = int(math.sqrt(number)) + 1 30 | for divider in primes: 31 | if number % divider == 0: 32 | flag_prime = 0 33 | break 34 | if divider > largest_divider: 35 | break 36 | return flag_prime 37 | 38 | def elapsed_time(seconds): 39 | hours = int(seconds/3600) 40 | minutes = int(seconds/60 - hours*60) 41 | sec = int(seconds - minutes*60 - hours*3600) 42 | return(f"{hours}h {minutes}min {sec}s") 43 | 44 | if __name__ == "__main__": 45 | for i in range(len(scope)): 46 | last = scope[i] 47 | found = 4 # we start from 11, know 2, 3, 5, 7 48 | primes = [3, 5, 7] # exclude 2 since we only test odd numbers 49 | print(f"\nPrime numbers to {last} in v5.1") 50 | start = time.monotonic() 51 | dot = start 52 | column = 1 53 | largest_divider = int(math.sqrt(last)) 54 | if largest_divider % 2 == 0: 55 | largest_divider += 1 56 | print(f'First find prime dividers up to {largest_divider}.') 57 | find_primes(largest_divider) 58 | print(f'Found {found} primes, now use them als dividers.') 59 | for number in range(largest_divider + 2, last, 2): 60 | found += is_prime_fast(number) 61 | if (time.monotonic() - dot) > 2: 62 | print(".", end="") 63 | dot = time.monotonic() 64 | column += 1 65 | if column > 30: 66 | t = elapsed_time(time.monotonic() - start) 67 | print(f" {t} - {number} {int(number*100/last)}% ") 68 | column = 1 69 | end = time.monotonic() 70 | print(f'This took: {(end - start)} seconds.') 71 | print(f'Found {found} primes.') 72 | filename = "/" + str(last) + ".txt" 73 | # with open(filename, "w") as fp: 74 | # fp.write(board.board_id) 75 | # fp.write(f'\nPrimes to {last} took {(end - start)} seconds.') 76 | # fp.write(f'\nFound {found} primes. Should be {reference[i]}.') 77 | print('Exported to filesystem ') 78 | #print(board.board_id) 79 | #print(f'Primes to {last} took {(end - start)} seconds.') 80 | #print(f'Found {found} primes. Should be {reference[i]}.') 81 | 82 | led = digitalio.DigitalInOut(board.LED) 83 | led.direction = digitalio.Direction.OUTPUT 84 | 85 | while True: 86 | led.value = True 87 | print(f'LED on - to {last} needs {end - start} s') 88 | time.sleep(10) 89 | led.value = False 90 | print('LED off') 91 | time.sleep(1) 92 | pass 93 | -------------------------------------------------------------------------------- /esp32s3/circuitpython/apps/prime_rp2040.py: -------------------------------------------------------------------------------- 1 | import math, time, board, busio, terminalio, displayio 2 | from adafruit_st7789 import ST7789 3 | displayio.release_displays() 4 | spi = busio.SPI(clock=board.GP10, MOSI=board.GP11) 5 | tft_cs = board.GP9 6 | tft_dc = board.GP8 7 | display_bus = displayio.FourWire( 8 | spi, command=tft_dc, chip_select=tft_cs, reset=board.GP12 9 | ) 10 | display = ST7789(display_bus, width=240, height=240, rowstart=80) 11 | 12 | last = 500 13 | disp = True 14 | found = 4 # we start from 11, know 2, 3, 5, 7 15 | print(f"Prime numbers to {last}") 16 | print("2, 3, 5, 7", end="") 17 | 18 | start = time.monotonic() 19 | for number in range(11, last, 2): 20 | prime = True 21 | for divider in range(3, int(math.sqrt(number))+1, 2): 22 | if number % divider == 0: 23 | prime = False 24 | break 25 | if prime: 26 | found += 1 27 | if disp: 28 | print(number, sep=', ', end=' ') 29 | end = time.monotonic() 30 | print(f"\nThis took: {(end - start)} seconds.") 31 | print(f"I found {found} prime numbers.") 32 | -------------------------------------------------------------------------------- /esp32s3/circuitpython/boot.py: -------------------------------------------------------------------------------- 1 | # Start rp2040 and initiate the display 2 | # https://github.com/kreier/rp2040/blob/main/tft_st7789_240x240/boot.py 3 | # 2023/02/23 v0.2 4 | 5 | import board, busio, displayio 6 | from adafruit_st7789 import ST7789 7 | displayio.release_displays() 8 | spi = busio.SPI(clock=board.GP10, MOSI=board.GP11) 9 | tft_cs = board.GP9 10 | tft_dc = board.GP8 11 | display_bus = displayio.FourWire( 12 | spi, command=tft_dc, chip_select=tft_cs, reset=board.GP12 13 | ) 14 | display = ST7789(display_bus, width=240, height=240, rowstart=80, rotation=90) 15 | 16 | print("Display activated.") 17 | # exec(open("apps/menu.py").read()) 18 | # does not work 19 | -------------------------------------------------------------------------------- /esp32s3/circuitpython/boot_out.txt: -------------------------------------------------------------------------------- 1 | Adafruit CircuitPython 8.0.3 on 2023-02-23; ESP32-S3-DevKitC-1-N8R8 with ESP32S3 2 | Board ID:espressif_esp32s3_devkitc_1_n8r8 3 | UID:4F21AFDC2FCB 4 | -------------------------------------------------------------------------------- /esp32s3/circuitpython/code.py: -------------------------------------------------------------------------------- 1 | # Start for T-Display S3 320x170 2 | # 2023/12/06 3 | 4 | import time, os, sys 5 | import board, displayio, terminalio, digitalio, busio 6 | from adafruit_st7789 import ST7789 7 | from adafruit_debouncer import Debouncer 8 | from adafruit_display_text import label 9 | 10 | DISPLAY_ROWS = 5 11 | color_menu = 0xFFFFFF 12 | color_select = 0x000000 # 0x00FF55 13 | long_press = 0.5 # time in seconds for long press to start program 14 | 15 | pin_select = digitalio.DigitalInOut(board.GPIO14) 16 | pin_select.direction = digitalio.Direction.INPUT 17 | pin_select.pull = digitalio.Pull.UP 18 | switchA = Debouncer(pin_select, interval=0.05) 19 | pin_confirm = digitalio.DigitalInOut(board.GPIO0) 20 | pin_confirm.direction = digitalio.Direction.INPUT 21 | pin_confirm.pull = digitalio.Pull.UP 22 | switchB = Debouncer(pin_confirm, interval=0.05) 23 | 24 | directory = os.listdir("menu") # folder for programs 25 | directory.sort() 26 | programs = [] 27 | # create program list but skipping deleted programs 28 | for i, x in enumerate(directory): 29 | if x[:2] != "._": 30 | programs.append(directory[i]) 31 | number_programs = len(programs) # number of installed programs 32 | 33 | displayio.release_displays() 34 | # spi = busio.SPI(clock=board.GP10, MOSI=board.GP11) 35 | tft_cs = board.GPIO06 36 | tft_dc = board.GPIO07 37 | display_bus = displayio.ParallelBus(data0 = board.GPIO39, 38 | command = board.GPIO07, 39 | chip_select = board.GPIO06, 40 | write = board.GPIO08, 41 | read = board.GPIO09 42 | ) 43 | display = ST7789(display_bus, width=320, height=160, rowstart=0, rotation=90) 44 | 45 | 46 | menu = [] # all menu options - can be more than fit on the display 47 | # first menu item: 48 | menu.append(" Menu/Settings [{}] ".format(number_programs)) 49 | 50 | for i, x in enumerate(programs): 51 | menu.append(" " + x[:-3] + " ") # remove the .py from program files 52 | 53 | displaymenu = displayio.Group() # menu options actually shown on display 54 | select = 0 # item select on the list shown 55 | 56 | 57 | def menu_create(): 58 | for item in range(DISPLAY_ROWS): 59 | listitem = label.Label(terminalio.FONT, text="") 60 | listitem.x = 0 61 | listitem.y = 5 + 13 * item 62 | displaymenu.append(listitem) 63 | 64 | 65 | def menu_fill(s): 66 | if len(menu) < DISPLAY_ROWS: 67 | for item in range(len(menu)): 68 | displaymenu[item].text = menu[item] 69 | else: 70 | for item in range(DISPLAY_ROWS): 71 | displaymenu[item].text = menu[item + s] 72 | # this code fills from the bottom - its slightly faster 73 | #for item in range(DISPLAY_ROWS - 1, -1, -1): 74 | # displaymenu[item].text = menu[item + s] 75 | 76 | 77 | def menu_select(x): 78 | # highlight selected item 79 | displaymenu[x].color = color_select 80 | displaymenu[x].background_color = color_menu 81 | # de-select old item 82 | if x == 0: 83 | if len(menu) > DISPLAY_ROWS: 84 | x = DISPLAY_ROWS 85 | else: 86 | x = len(menu) 87 | x -= 1 88 | displaymenu[x].color = color_menu 89 | displaymenu[x].background_color = color_select 90 | 91 | 92 | # setup 93 | menu_create() 94 | menu_fill(0) 95 | menu_select(0) 96 | display.show(displaymenu) 97 | pressed = time.monotonic() 98 | 99 | # input loop 100 | while True: 101 | switchA.update() 102 | switchB.update() 103 | if switchA.fell: # button pressed 104 | pressed = time.monotonic() 105 | if switchA.rose: # button released 106 | time_pressed = time.monotonic() - pressed 107 | if time_pressed > long_press: # alternative to press button B 108 | if select < 1: 109 | sys.exit() 110 | program = "menu/" + programs[select - 1] 111 | display.show(None) 112 | pin_select.deinit() 113 | pin_confirm.deinit() 114 | exec(open(program).read()) 115 | break 116 | select += 1 117 | if select > len(menu) - 1: 118 | select = 0 119 | menu_fill(0) 120 | if select > DISPLAY_ROWS - 1: 121 | menu_fill(select - DISPLAY_ROWS + 1) 122 | else: 123 | menu_select(select) 124 | if switchB.rose: 125 | if select < 1: 126 | sys.exit() 127 | program = "menu/" + programs[select - 1] 128 | print("Selected: ", program) 129 | display.show(None) 130 | pin_select.deinit() 131 | pin_confirm.deinit() 132 | exec(open(program).read()) 133 | break 134 | -------------------------------------------------------------------------------- /esp32s3/circuitpython/code_N8R8.py: -------------------------------------------------------------------------------- 1 | # Start for T-Display S3 320x170 2 | # 2023/12/06 3 | 4 | import time, os, sys 5 | import board, displayio, terminalio, digitalio, busio, paralleldisplaybus 6 | from adafruit_st7789 import ST7789 7 | from adafruit_debouncer import Debouncer 8 | from adafruit_display_text import label 9 | 10 | DISPLAY_ROWS = 5 11 | color_menu = 0xFFFFFF 12 | color_select = 0x000000 # 0x00FF55 13 | long_press = 0.5 # time in seconds for long press to start program 14 | 15 | pin_select = digitalio.DigitalInOut(board.IO14) 16 | pin_select.direction = digitalio.Direction.INPUT 17 | pin_select.pull = digitalio.Pull.UP 18 | switchA = Debouncer(pin_select, interval=0.05) 19 | pin_confirm = digitalio.DigitalInOut(board.IO0) 20 | pin_confirm.direction = digitalio.Direction.INPUT 21 | pin_confirm.pull = digitalio.Pull.UP 22 | switchB = Debouncer(pin_confirm, interval=0.05) 23 | 24 | directory = os.listdir("menu") # folder for programs 25 | directory.sort() 26 | programs = [] 27 | # create program list but skipping deleted programs 28 | for i, x in enumerate(directory): 29 | if x[:2] != "._": 30 | programs.append(directory[i]) 31 | number_programs = len(programs) # number of installed programs 32 | 33 | displayio.release_displays() 34 | # spi = busio.SPI(clock=board.GP10, MOSI=board.GP11) 35 | #tft_cs = board.IO06 36 | #tft_dc = board.IO07 37 | display_bus = paralleldisplaybus.ParallelBus(data0 = board.IO39, 38 | command = board.IO07, 39 | chip_select = board.IO06, 40 | write = board.IO08, 41 | read = board.IO09 42 | ) 43 | display = ST7789(display_bus, width=320, height=160, rowstart=0, rotation=90) 44 | 45 | 46 | menu = [] # all menu options - can be more than fit on the display 47 | # first menu item: 48 | menu.append(" Menu/Settings [{}] ".format(number_programs)) 49 | 50 | for i, x in enumerate(programs): 51 | menu.append(" " + x[:-3] + " ") # remove the .py from program files 52 | 53 | displaymenu = displayio.Group() # menu options actually shown on display 54 | select = 0 # item select on the list shown 55 | 56 | 57 | def menu_create(): 58 | for item in range(DISPLAY_ROWS): 59 | listitem = label.Label(terminalio.FONT, text="") 60 | listitem.x = 0 61 | listitem.y = 5 + 13 * item 62 | displaymenu.append(listitem) 63 | 64 | 65 | def menu_fill(s): 66 | if len(menu) < DISPLAY_ROWS: 67 | for item in range(len(menu)): 68 | displaymenu[item].text = menu[item] 69 | else: 70 | for item in range(DISPLAY_ROWS): 71 | displaymenu[item].text = menu[item + s] 72 | # this code fills from the bottom - its slightly faster 73 | #for item in range(DISPLAY_ROWS - 1, -1, -1): 74 | # displaymenu[item].text = menu[item + s] 75 | 76 | 77 | def menu_select(x): 78 | # highlight selected item 79 | displaymenu[x].color = color_select 80 | displaymenu[x].background_color = color_menu 81 | # de-select old item 82 | if x == 0: 83 | if len(menu) > DISPLAY_ROWS: 84 | x = DISPLAY_ROWS 85 | else: 86 | x = len(menu) 87 | x -= 1 88 | displaymenu[x].color = color_menu 89 | displaymenu[x].background_color = color_select 90 | 91 | 92 | # setup 93 | menu_create() 94 | menu_fill(0) 95 | menu_select(0) 96 | display.show(displaymenu) 97 | pressed = time.monotonic() 98 | 99 | # input loop 100 | while True: 101 | switchA.update() 102 | switchB.update() 103 | if switchA.fell: # button pressed 104 | pressed = time.monotonic() 105 | if switchA.rose: # button released 106 | time_pressed = time.monotonic() - pressed 107 | if time_pressed > long_press: # alternative to press button B 108 | if select < 1: 109 | sys.exit() 110 | program = "menu/" + programs[select - 1] 111 | display.show(None) 112 | pin_select.deinit() 113 | pin_confirm.deinit() 114 | exec(open(program).read()) 115 | break 116 | select += 1 117 | if select > len(menu) - 1: 118 | select = 0 119 | menu_fill(0) 120 | if select > DISPLAY_ROWS - 1: 121 | menu_fill(select - DISPLAY_ROWS + 1) 122 | else: 123 | menu_select(select) 124 | if switchB.rose: 125 | if select < 1: 126 | sys.exit() 127 | program = "menu/" + programs[select - 1] 128 | print("Selected: ", program) 129 | display.show(None) 130 | pin_select.deinit() 131 | pin_confirm.deinit() 132 | exec(open(program).read()) 133 | break 134 | -------------------------------------------------------------------------------- /esp32s3/circuitpython/lib/adafruit_debouncer.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/esp32s3/circuitpython/lib/adafruit_debouncer.mpy -------------------------------------------------------------------------------- /esp32s3/circuitpython/lib/adafruit_display_text/__init__.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/esp32s3/circuitpython/lib/adafruit_display_text/__init__.mpy -------------------------------------------------------------------------------- /esp32s3/circuitpython/lib/adafruit_display_text/bitmap_label.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/esp32s3/circuitpython/lib/adafruit_display_text/bitmap_label.mpy -------------------------------------------------------------------------------- /esp32s3/circuitpython/lib/adafruit_display_text/label.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/esp32s3/circuitpython/lib/adafruit_display_text/label.mpy -------------------------------------------------------------------------------- /esp32s3/circuitpython/lib/adafruit_display_text/scrolling_label.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/esp32s3/circuitpython/lib/adafruit_display_text/scrolling_label.mpy -------------------------------------------------------------------------------- /esp32s3/circuitpython/lib/adafruit_st7789.mpy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/esp32s3/circuitpython/lib/adafruit_st7789.mpy -------------------------------------------------------------------------------- /esp32s3/circuitpython/menu/Button_test.py: -------------------------------------------------------------------------------- 1 | # Input button A and B test code - with debouncer 2 | # Button A: GP15 3 | # Button B: GP17 4 | 5 | # https://github.com/ssis-aa/rvr2023/blob/main/circuitpython/menu/Button_test.py 6 | 7 | import time 8 | import board 9 | import digitalio 10 | from adafruit_debouncer import Debouncer 11 | 12 | pin_a = digitalio.DigitalInOut(board.GP15) 13 | pin_a.direction = digitalio.Direction.INPUT 14 | pin_a.pull = digitalio.Pull.UP 15 | button_a = Debouncer(pin_a, interval=0.05) 16 | pin_b = digitalio.DigitalInOut(board.GP17) 17 | pin_b.direction = digitalio.Direction.INPUT 18 | pin_b.pull = digitalio.Pull.UP 19 | button_b = Debouncer(pin_b, interval=0.05) 20 | 21 | print("Press button A or B") 22 | 23 | while True: 24 | button_a.update() 25 | button_b.update() 26 | if button_a.fell: 27 | print("A <--- button ") 28 | time.sleep(0.1) 29 | if button_b.rose: 30 | print(" button ---> B") 31 | time.sleep(0.1) 32 | -------------------------------------------------------------------------------- /esp32s3/circuitpython/menu/Mandelbrot.py: -------------------------------------------------------------------------------- 1 | # mandelbrot on rp2040 with st7789 240x240 2 | # https://github.com/kreier/mandelbrot/circuitpython 3 | # 2022/11/28 v0.1 4 | 5 | import board, displayio, random, busio 6 | from adafruit_st7789 import ST7789 7 | #displayio.release_displays() 8 | #spi = busio.SPI(clock=board.GP10, MOSI=board.GP11) 9 | #tft_cs = board.GP9 10 | #tft_dc = board.GP8 11 | #display_bus = displayio.FourWire( 12 | # spi, command=tft_dc, chip_select=tft_cs, reset=board.GP12 13 | #) 14 | #display = ST7789(display_bus, width=240, height=240, rowstart=80) 15 | # display = board.DISPLAY # this works on the clue 16 | 17 | # Create a bitmap with 256 colors 18 | bitmap = displayio.Bitmap(display.width, display.height, 256) 19 | 20 | def hsv_to_rgb(h, s, v): 21 | if s == 0.0: v*=255; return (v, v, v) 22 | i = int(h*6.) 23 | f = (h*6.)-i; p,q,t = int(255*(v*(1.-s))), int(255*(v*(1.-s*f))), int(255*(v*(1.-s*(1.-f)))); v*=255; i%=6 24 | if i == 0: ret = (65536*v + 256*t + p) 25 | if i == 1: ret = (65536*q + 256*v + p) 26 | if i == 2: ret = (65536*p + 256*v + t) 27 | if i == 3: ret = (65536*p + 256*q + v) 28 | if i == 4: ret = (65536*t + 256*p + v) 29 | if i == 5: ret = (65536*v + 256*p + q) 30 | #return f"{ret:06X}" 31 | return ret 32 | 33 | # Create a 256 color palette 34 | palette = displayio.Palette(256) 35 | for i in range(256): 36 | #palette[i] = random.randrange(16777216) 37 | palette[i] = hsv_to_rgb(i/256, 1, 1) 38 | palette[0] = 0 39 | 40 | # Create a TileGrid using the Bitmap and Palette 41 | tile_grid = displayio.TileGrid(bitmap, pixel_shader=palette) 42 | 43 | # Create a Group 44 | group = displayio.Group() 45 | 46 | # Add the TileGrid to the Group 47 | group.append(tile_grid) 48 | 49 | # Add the Group to the Display 50 | display.show(group) 51 | 52 | # Draw even more pixels 53 | #for c in range(len(palette)): 54 | # for x in range(display.width): 55 | # for y in range(display.height): 56 | # bitmap[x, y] = (x + y) % 256 57 | 58 | minX = -1.9 59 | maxX = 0.6 60 | width = display.width 61 | height = display.height 62 | aspectRatio = 1 63 | ITERATION = 50 64 | yScale = (maxX-minX)*(float(height)/width)*aspectRatio 65 | 66 | for y in range(height): 67 | for x in range(width): 68 | c = complex(minX+x*(maxX-minX)/width, y*yScale/height-yScale/2) 69 | z = c 70 | for iter in range(ITERATION): 71 | if abs(z) > 2: 72 | break 73 | z = z*z+c 74 | if iter == ITERATION - 1: 75 | pixelcolor = 0 76 | else: 77 | pixelcolor = iter *5 78 | bitmap[x, y] = pixelcolor 79 | 80 | 81 | # Loop forever so you can enjoy your image 82 | while True: 83 | pass 84 | -------------------------------------------------------------------------------- /esp32s3/circuitpython/menu/Prime10000.py: -------------------------------------------------------------------------------- 1 | import math, time 2 | last = 10000 3 | found = 4 # we start from 11, know 2, 3, 5, 7 4 | print(f"Prime nrs to {last}") 5 | #print('2, 3, 5, 7',end='') 6 | start = time.monotonic() 7 | for number in range(11, last, 2): 8 | prime = True 9 | for divider in range(3, int(math.sqrt(number))+1, 2): 10 | if number % divider == 0: 11 | prime = False 12 | break 13 | if prime: 14 | #print(",", number, end='') 15 | found += 1 16 | prime = 1 17 | end = time.monotonic() 18 | print(f"It took: {(end - start)} s.") 19 | print(f"Found {found} numbers.") 20 | 21 | time.sleep(5) 22 | -------------------------------------------------------------------------------- /esp32s3/circuitpython/settings.toml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/esp32s3/circuitpython/settings.toml -------------------------------------------------------------------------------- /esp32s3/info_arduino.txt: -------------------------------------------------------------------------------- 1 | according to https://github.com/Xinyuan-LilyGO/T-Display-S3/tree/main we need special settings in Arduino 2 | 3 | Setting Value 4 | USB CDC On Boot Enabled 5 | CPU Frequency 240MHz (WiFi) 6 | Core Debug Level None 7 | USB DFU On Boot Enabled 8 | Events Run On Core 1 9 | Flash Mode QIO 80MHz 10 | Flash Size 16MB (128Mb) 11 | JTAG Adapter Integrated USB JTAG 12 | Arduino Runs On Core 1 13 | USB Firmware MSC On Boot Disabled 14 | Partition Scheme Huge APP (3MB No OTA/1MB SPIFFS) 15 | PSRAM OPI PSRAM 16 | USB Mode Hardware CDC and JTAG 17 | -------------------------------------------------------------------------------- /esp32s3/info_circuitpython.txt: -------------------------------------------------------------------------------- 1 | The esp32s3 has 8MB PSRAM and 16MB Flash size 2 | 3 | I used this board successfully: 4 | YD-ESP32-S3 N16R8 5 | by VCC-GND Studio 6 | https://circuitpython.org/board/yd_esp32_s3_n16r8/ 7 | 8 | The garbage collector shows 8GB free space. 9 | The explorer shows 13.8 MB free for programs and data. 10 | 11 | GPIO06 is not available ... 12 | 13 | Try this one 14 | ESP32-S3-DevKitC-1-N8R8 15 | by Espressif 16 | https://circuitpython.org/board/espressif_esp32s3_devkitc_1_n8r8/ 17 | -------------------------------------------------------------------------------- /esp32s3/info_tft.txt: -------------------------------------------------------------------------------- 1 | This display with a st7789 chip is not connected via SPI but parallel! 2 | 3 | This is unique. 4 | 5 | Who made it work? 6 | 7 | PINs? 8 | 9 | LCD_BL 38 10 | LCD_D0 39 11 | LCD_D1 40 12 | LCD_D2 41 13 | LCD_D3 42 14 | LCD_D4 45 15 | LCD_D5 46 16 | LCD_D6 47 17 | LCD_D7 48 18 | LCD_WR 08 19 | LCD_RD 09 20 | LCD_DC 07 21 | LCD_CS 06 22 | LCD_RES 05 23 | LCD_Power_On 15 24 | -------------------------------------------------------------------------------- /micropython/README.md: -------------------------------------------------------------------------------- 1 | # Micropython on esp8266 and esp32 2 | 3 | Instructions are well found at [micropython.org](https://micropython.org/download). First I want to know how big my flash size is. The code is 4 | 5 | ``` 6 | esptool.exe --port COM5 --chip auto flash_id 7 | ``` 8 | 9 | For ESP32 you have to push the 'BOOT' button or connect IO0 to GND, otherwise the esptool is not connecting. 10 | 11 | ## Using uPyCraft 12 | 13 | Download (no need to install) the [latest version](https://raw.githubusercontent.com/DFRobot/uPyCraft/master/uPyCraft.exe) of [uPyCraft](http://docs.dfrobot.com/upycraft/) (developed by [DFRobot](https://www.dfrobot.com/) from Shanghai). Place a file of [SourceCodePro.ttf](SourceCodePro.ttf) into the same folder. Install this font for all users of your machine (right click > 'Install for all users'). The message at the start regarding the missing font should then dissapear. You can start uPyCraft.exe directly. 14 | 15 | Select the correct port on 'Tools > Serial >' and hit the connect button in the right column. In the lower part the REPL should appear and you can start to communicate with your micropython device. Ask for `help()` ! 16 | 17 | ## Prime numbers to 10000 18 | 19 | This took 11375 ms on an esp32 with 160 MHz: 20 | 21 | ``` py 22 | import math 23 | import time 24 | 25 | last = 10000 26 | 27 | start = time.ticks_ms() 28 | print("Prime numbers to 10000") 29 | 30 | print('2, 3, 5, 7',end='') 31 | for number in range(11, last, 2): 32 | prime = 1 33 | for divider in range(2, int(math.sqrt(number))+1, 1): 34 | if number/divider == int(number/divider): 35 | prime = 0 36 | 37 | if prime == 1: 38 | print(',', number,end='') 39 | 40 | end = time.ticks_ms() 41 | print('\nThis took:', (end - start), 'ms.') 42 | ``` 43 | 44 | In uPyCraft V1.0 the output is lagging behind the streaming of numbers from the esp32. After changing the frequency of the esp by 45 | 46 | ``` py 47 | import machine 48 | machine.freq(240000000) 49 | ``` 50 | it took only 7782 ms to finish the calculation. 51 | 52 | ### Timings 53 | 54 | | Frequency | ESP8266 | ESP32 | Raspberry Pi 1 | Raspberry Pi 4 | 55 | |:---------:|:--------:|:--------:|:--------------:|:--------------:| 56 | | 40 MHz | - | 44427 ms | | | 57 | | 80 MHz | 32807 ms | 23323 ms | | | 58 | | 160 MHz | 16113 ms | 11375 ms | | | 59 | | 240 MHz | - | 7783 ms | | | 60 | -------------------------------------------------------------------------------- /micropython/apps/boot_blink_post.py: -------------------------------------------------------------------------------- 1 | # welcome blink and post 2 | 3 | import time 4 | import board 5 | import digitalio 6 | import microcontroller 7 | 8 | led = digitalio.DigitalInOut(board.LED) 9 | led.direction = digitalio.Direction.OUTPUT 10 | 11 | for x in range(3): 12 | led.value = False 13 | time.sleep(0.2) 14 | led.value = True 15 | time.sleep(0.2) 16 | 17 | print("This is a {}, running at {:.1f} MHz".format(board.board_id, float(microcontroller.cpu.frequency)/1000000)) 18 | print("The CPU has a temperature of {:.1f} °C.".format(microcontroller.cpu.temperature)) 19 | -------------------------------------------------------------------------------- /micropython/apps/helloworld.py: -------------------------------------------------------------------------------- 1 | print("Hello World!") 2 | -------------------------------------------------------------------------------- /micropython/apps/led1.py: -------------------------------------------------------------------------------- 1 | import time, machine 2 | 3 | led = machine.Pin(4, machine.Pin.OUT) 4 | N = 200_000 5 | 6 | t0 = time.ticks_us() 7 | 8 | # Simple loop 9 | for i in range(N): 10 | led.on() 11 | led.off() 12 | 13 | t1 = time.ticks_us() 14 | dt = time.ticks_diff(t1, t0) 15 | fmt = '{:5.3f} sec, {:6.3f} µsec/blink : {:8.2f} kblinks/sec' 16 | print(fmt.format(dt * 1e-6, dt/N, N/dt*1e3)) 17 | -------------------------------------------------------------------------------- /micropython/apps/led2.py: -------------------------------------------------------------------------------- 1 | import time, machine 2 | 3 | led = machine.Pin(4, machine.Pin.OUT) 4 | N = 200_000 5 | 6 | # Within a function 7 | def blink_simple(n): 8 | for i in range(n): 9 | led.on() 10 | led.off() 11 | 12 | def time_it(f, n): 13 | t0 = time.ticks_us() 14 | f(n) 15 | t1 = time.ticks_us() 16 | dt = time.ticks_diff(t1, t0) 17 | fmt = '{:5.3f} sec, {:6.3f} µsec/blink : {:8.2f} kblinks/sec' 18 | print(fmt.format(dt * 1e-6, dt/N, N/dt*1e3)) 19 | 20 | time_it(blink_simple, N) 21 | -------------------------------------------------------------------------------- /micropython/apps/led3.py: -------------------------------------------------------------------------------- 1 | import time, machine 2 | 3 | led = machine.Pin(4, machine.Pin.OUT) 4 | N = 200_000 5 | 6 | # Within a function, preload methods 7 | def blink_preload(n): 8 | on = led.on 9 | off = led.off 10 | r = range(n) 11 | for i in r: 12 | on() 13 | off() 14 | 15 | def time_it(f, n): 16 | t0 = time.ticks_us() 17 | f(n) 18 | t1 = time.ticks_us() 19 | dt = time.ticks_diff(t1, t0) 20 | fmt = '{:5.3f} sec, {:6.3f} µsec/blink : {:8.2f} kblinks/sec' 21 | print(fmt.format(dt * 1e-6, dt/N, N/dt*1e3)) 22 | 23 | time_it(blink_preload, N) 24 | -------------------------------------------------------------------------------- /micropython/apps/led4.py: -------------------------------------------------------------------------------- 1 | import time, machine 2 | 3 | led = machine.Pin(4, machine.Pin.OUT) 4 | N = 200_000 5 | 6 | # Unroll the loop 8 times 7 | def blink_preload_unrolled8(n): 8 | n //= 8 9 | on = led.on 10 | off = led.off 11 | r = range(n) 12 | for i in r: 13 | on() 14 | off() 15 | on() 16 | off() 17 | on() 18 | off() 19 | on() 20 | off() 21 | on() 22 | off() 23 | on() 24 | off() 25 | on() 26 | off() 27 | on() 28 | off() 29 | 30 | def time_it(f, n): 31 | t0 = time.ticks_us() 32 | f(n) 33 | t1 = time.ticks_us() 34 | dt = time.ticks_diff(t1, t0) 35 | fmt = '{:5.3f} sec, {:6.3f} µsec/blink : {:8.2f} kblinks/sec' 36 | print(fmt.format(dt * 1e-6, dt/N, N/dt*1e3)) 37 | 38 | time_it(blink_preload_unrolled8, N) 39 | -------------------------------------------------------------------------------- /micropython/apps/led5.py: -------------------------------------------------------------------------------- 1 | import time, machine 2 | 3 | led = machine.Pin(4, machine.Pin.OUT) 4 | N = 200_000 5 | 6 | # Unrolled with native machine emitter 7 | @micropython.native 8 | def blink_preload_unrolled8_native(n): 9 | n //= 8 10 | on = led.on 11 | off = led.off 12 | r = range(n) 13 | for i in r: 14 | on() 15 | off() 16 | on() 17 | off() 18 | on() 19 | off() 20 | on() 21 | off() 22 | on() 23 | off() 24 | on() 25 | off() 26 | on() 27 | off() 28 | on() 29 | off() 30 | 31 | def time_it(f, n): 32 | t0 = time.ticks_us() 33 | f(n) 34 | t1 = time.ticks_us() 35 | dt = time.ticks_diff(t1, t0) 36 | fmt = '{:5.3f} sec, {:6.3f} µsec/blink : {:8.2f} kblinks/sec' 37 | print(fmt.format(dt * 1e-6, dt/N, N/dt*1e3)) 38 | 39 | time_it(blink_preload_unrolled8_native, N) 40 | -------------------------------------------------------------------------------- /micropython/apps/led6.py: -------------------------------------------------------------------------------- 1 | import time, machine, esp32 2 | 3 | led = machine.Pin(4, machine.Pin.OUT) 4 | N = 200_000 5 | 6 | # Viper mode, directly writing GPIO registers 7 | @micropython.viper 8 | def blink_unrolled8_viper(n:int): 9 | n //= 8 10 | p = ptr16(esp32.GPIO4 + esp32.GPIO_BSRR) 11 | r = range(n) 12 | for i in r: 13 | machine.mem32[0x3FF44008] = 0x10 14 | machine.mem32[0x3FF4400C] = 0x10 15 | 16 | def time_it(f, n): 17 | t0 = time.ticks_us() 18 | f(n) 19 | t1 = time.ticks_us() 20 | dt = time.ticks_diff(t1, t0) 21 | fmt = '{:5.3f} sec, {:6.3f} µsec/blink : {:8.2f} kblinks/sec' 22 | print(fmt.format(dt * 1e-6, dt/N, N/dt*1e3)) 23 | 24 | time_it(blink_unrolled8_viper, N) 25 | -------------------------------------------------------------------------------- /micropython/apps/led7.py: -------------------------------------------------------------------------------- 1 | import time, machine, esp32 2 | 3 | led = machine.Pin(4, machine.Pin.OUT) 4 | N = 200_000 5 | 6 | # Viper mode, directly writing GPIO registers 7 | #@micropython.viper 8 | @micropython.native 9 | def blink_unrolled8_viper(n): 10 | n //= 8 11 | #on = led.on 12 | #off = led.off 13 | #on = machine.mem32[0x3FF44008] = 0x10 14 | #off = machine.mem32[0x3FF4400C] = 0x10 15 | r = range(n) 16 | for i in r: 17 | machine.mem32[0x3FF44008] = 0x10 18 | machine.mem32[0x3FF4400C] = 0x10 19 | machine.mem32[0x3FF44008] = 0x10 20 | machine.mem32[0x3FF4400C] = 0x10 21 | machine.mem32[0x3FF44008] = 0x10 22 | machine.mem32[0x3FF4400C] = 0x10 23 | machine.mem32[0x3FF44008] = 0x10 24 | machine.mem32[0x3FF4400C] = 0x10 25 | machine.mem32[0x3FF44008] = 0x10 26 | machine.mem32[0x3FF4400C] = 0x10 27 | machine.mem32[0x3FF44008] = 0x10 28 | machine.mem32[0x3FF4400C] = 0x10 29 | machine.mem32[0x3FF44008] = 0x10 30 | machine.mem32[0x3FF4400C] = 0x10 31 | machine.mem32[0x3FF44008] = 0x10 32 | machine.mem32[0x3FF4400C] = 0x10 33 | #on() 34 | #off() 35 | 36 | def time_it(f, n): 37 | t0 = time.ticks_us() 38 | f(n) 39 | t1 = time.ticks_us() 40 | dt = time.ticks_diff(t1, t0) 41 | fmt = '{:5.3f} sec, {:6.3f} µsec/blink : {:8.2f} kblinks/sec' 42 | print(fmt.format(dt * 1e-6, dt/N, N/dt*1e3)) 43 | 44 | time_it(blink_unrolled8_viper, N) 45 | -------------------------------------------------------------------------------- /micropython/apps/pinmap.py: -------------------------------------------------------------------------------- 1 | """CircuitPython Essentials Pin Map Script""" 2 | import microcontroller 3 | import board 4 | 5 | board_pins = [] 6 | for pin in dir(microcontroller.pin): 7 | if isinstance(getattr(microcontroller.pin, pin), microcontroller.Pin): 8 | pins = [] 9 | for alias in dir(board): 10 | if getattr(board, alias) is getattr(microcontroller.pin, pin): 11 | pins.append("board.{}".format(alias)) 12 | if len(pins) > 0: 13 | board_pins.append(" ".join(pins)) 14 | for pins in sorted(board_pins): 15 | print(pins) 16 | -------------------------------------------------------------------------------- /micropython/apps/prime.py: -------------------------------------------------------------------------------- 1 | import math, time 2 | 3 | last = 1000 4 | 5 | start = time.ticks_us() 6 | print('Prime numbers to {}'.format(last)) 7 | 8 | #print('2, 3, 5, 7',end='') 9 | for number in range(11, last, 2): 10 | prime = 1 11 | for divider in range(2, int(math.sqrt(number))+1, 1): 12 | if number/divider == int(number/divider): 13 | prime = 0 14 | 15 | if prime == 1: 16 | #print(',', number, end='') 17 | prime = 1 18 | 19 | end = time.ticks_us() 20 | print('\nThis took:', (end - start)/1000000, 'seconds.') 21 | -------------------------------------------------------------------------------- /micropython/apps/prime1.py: -------------------------------------------------------------------------------- 1 | import math 2 | import time 3 | 4 | last = 10000 5 | found = 1 # because we skip 2, the only even prime number 6 | 7 | start = time.monotonic() 8 | print('Prime numbers to {}'.format(last)) 9 | 10 | # print('2',end='') 11 | for number in range(3, last, 2): 12 | prime = 1 13 | for divider in range(2, int(math.sqrt(number))+1, 1): 14 | if number/divider == int(number/divider): 15 | prime = 0 16 | 17 | if prime == 1: 18 | # print(',', number,end='') 19 | found += 1 20 | 21 | end = time.monotonic() 22 | print('Found {:} prime numbers'.format(found)) 23 | print('This took:', (end - start), 'seconds.') 24 | -------------------------------------------------------------------------------- /micropython/apps/prime2.py: -------------------------------------------------------------------------------- 1 | import math 2 | import time 3 | 4 | last = 10000 5 | found = 1 # because we skip 2, the only even prime number 6 | 7 | start = time.monotonic() 8 | print('Prime numbers to {}'.format(last)) 9 | 10 | # print('2',end='') 11 | def check(number): 12 | prime = 1 13 | f = 1.5 14 | g = int(math.sqrt(number))+1 15 | for divider in range(2, g): 16 | f = number/divider 17 | if f == int(f): 18 | prime = 0 19 | return(prime) 20 | 21 | for number in range(3, last, 2): 22 | if check(number) == 1: 23 | # print(',', number,end='') 24 | found += 1 25 | 26 | end = time.monotonic() 27 | print('Found {:} prime numbers'.format(found)) 28 | print('This took:', (end - start), 'seconds.') 29 | -------------------------------------------------------------------------------- /micropython/apps/prime3.py: -------------------------------------------------------------------------------- 1 | import math 2 | import time 3 | 4 | first = 3 5 | last = 10000 6 | 7 | @micropython.native 8 | def check(number): 9 | prime = 1 10 | for divider in range(2, int(math.sqrt(number))+1, 1): 11 | f = number/divider 12 | if f == int(f): 13 | prime = 0 14 | return(prime) 15 | 16 | @micropython.native 17 | def prime_range(a, b): 18 | found = 1 # because we skip 2, the only even prime number 19 | for number in range(a, b, 2): # only check odd numbers 20 | if check(number) == 1: 21 | #print(',', number,end='') 22 | found += 1 23 | return(found) 24 | 25 | start = time.monotonic() 26 | print('Prime numbers to {}'.format(last)) 27 | #print('2',end='') 28 | print('Found {:} prime numbers'.format(prime_range(first,last))) 29 | end = time.monotonic() 30 | 31 | print('This took:', (end - start), 'seconds.') 32 | -------------------------------------------------------------------------------- /micropython/apps/prime4.py: -------------------------------------------------------------------------------- 1 | import math 2 | import time 3 | 4 | first = 3 5 | last = 10000 6 | 7 | @micropython.native 8 | def check(number): 9 | prime = 1 10 | if number/2 == int(number/2): 11 | prime = 0 12 | return(prime) 13 | for divider in range(3, int(math.sqrt(number))+1, 2): 14 | f = number/divider 15 | if f == int(f): 16 | prime = 0 17 | return(prime) 18 | 19 | @micropython.native 20 | def prime_range(a, b): 21 | found = 1 # because we skip 2, the only even prime number 22 | for number in range(a, b, 2): # only check odd numbers 23 | if check(number) == 1: 24 | #print(',', number,end='') 25 | found += 1 26 | return(found) 27 | 28 | start = time.monotonic() 29 | print('Prime numbers to {}'.format(last)) 30 | #print('2',end='') 31 | print('Found {:} prime numbers'.format(prime_range(first,last))) 32 | end = time.monotonic() 33 | 34 | print('This took:', (end - start), 'seconds.') 35 | -------------------------------------------------------------------------------- /micropython/apps/prime5.py: -------------------------------------------------------------------------------- 1 | import math 2 | import time 3 | 4 | first = 3 5 | last = 10000 6 | 7 | @micropython.native 8 | def check(number): 9 | prime = 1 10 | if number/2 == int(number/2): 11 | prime = 0 12 | return(prime) 13 | for divider in range(3, int(math.sqrt(number))+1, 2): 14 | f = number/divider 15 | if f == int(f): 16 | prime = 0 17 | break 18 | return(prime) 19 | 20 | @micropython.native 21 | def prime_range(a, b): 22 | found = 1 # because we skip 2, the only even prime number 23 | for number in range(a, b, 2): # only check odd numbers 24 | if check(number) == 1: 25 | #print(',', number,end='') 26 | found += 1 27 | return(found) 28 | 29 | start = time.monotonic() 30 | print('Prime numbers to {}'.format(last)) 31 | #print('2',end='') 32 | print('Found {:} prime numbers'.format(prime_range(first,last))) 33 | end = time.monotonic() 34 | 35 | print('This took:', (end - start), 'seconds.') 36 | -------------------------------------------------------------------------------- /micropython/prime10000_esp32_fast.py: -------------------------------------------------------------------------------- 1 | import math 2 | import time 3 | import machine 4 | 5 | machine.freq(240000000) # standard frequency is 160000000 for ESP32 6 | 7 | last = 10000 8 | 9 | start = time.ticks_ms() 10 | print("Prime numbers to 10000") 11 | 12 | print('2, 3, 5, 7',end='') 13 | for number in range(11, last, 2): 14 | prime = 1 15 | for divider in range(2, int(math.sqrt(number))+1, 1): 16 | if number/divider == int(number/divider): 17 | prime = 0 18 | 19 | if prime == 1: 20 | print(',', number,end='') 21 | 22 | end = time.ticks_ms() 23 | print('\nThis took:', (end - start), 'ms.') 24 | -------------------------------------------------------------------------------- /micropython/tft/calibrate_adc.py: -------------------------------------------------------------------------------- 1 | # /micropython/apps/calibrate_adc.py 2022-03-31 2 | 3 | from machine import Pin, SPI, ADC 4 | import st7789, time 5 | 6 | import vga1_16x32 as font 7 | 8 | pin_adc = ADC(Pin(12)) 9 | pin_adc.atten(ADC.ATTN_11DB) # full range: 3.3V 10 | 11 | white = st7789.color565(255,255,255) 12 | blue = st7789.color565(0,0,255) 13 | green = st7789.color565(0,255,0) 14 | red = st7789.color565(255,0,0) 15 | black = st7789.color565(0,0,0) 16 | 17 | tft = st7789.ST7789( 18 | SPI(2, baudrate=30000000, polarity=1, phase=1, sck=Pin(18), mosi=Pin(19), miso=Pin(14)), 19 | 135, 240, 20 | reset = Pin(23, Pin.OUT), 21 | cs = Pin(5, Pin.OUT), 22 | dc = Pin(16, Pin.OUT), 23 | backlight = Pin(4, Pin.OUT), 24 | rotation=1) 25 | tft.init() 26 | tft.fill(0) 27 | 28 | def main(): 29 | pin_raw = supersample(100) 30 | text1 = "{:} ".format(int(pin_raw)) 31 | text2 = "{:.3f} V ".format(pin_raw * 0.000793 + 0.108) 32 | tft.text(font, "12 bit raw:", 0, 0, green, black) 33 | tft.text(font, text1, 140, 32, white, black) 34 | tft.text(font, "Voltage pin:", 0, 74, blue, black) 35 | tft.text(font, text2, 140, 102, red, black) 36 | 37 | def supersample(iterations): 38 | raw = 0 39 | for k in range(iterations): 40 | raw += pin_adc.read() 41 | raw = raw / iterations 42 | return raw 43 | 44 | while True: 45 | main() 46 | time.sleep(0.5) 47 | 48 | print("Done.") 49 | 50 | -------------------------------------------------------------------------------- /micropython/tft/calibration.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/micropython/tft/calibration.xlsx -------------------------------------------------------------------------------- /micropython/tft/hello_world.py: -------------------------------------------------------------------------------- 1 | # hello_world.py 2 | 3 | from machine import Pin, SPI 4 | import st7789 5 | 6 | # Choose a font 7 | 8 | # import vga1_8x8 as font 9 | # import vga2_8x8 as font 10 | 11 | # import vga1_8x16 as font 12 | # import vga2_8x16 as font 13 | 14 | # import vga1_16x16 as font 15 | # import vga1_bold_16x16 as font 16 | # import vga2_16x16 as font 17 | # import vga2_bold_16x16 as font 18 | 19 | # import vga1_16x32 as font 20 | # import vga1_bold_16x32 as font 21 | # import vga2_16x32 as font 22 | import vga2_bold_16x32 as font 23 | 24 | def main(): 25 | tft = st7789.ST7789( 26 | SPI(2, baudrate=30000000, polarity=1, phase=1, sck=Pin(18), mosi=Pin(19)), 27 | 135, 240, reset=Pin(23, Pin.OUT), cs=Pin(5, Pin.OUT), dc=Pin(16, Pin.OUT), 28 | backlight=Pin(4, Pin.OUT), rotation=3) 29 | 30 | tft.init() 31 | tft.fill(0) 32 | tft.text(font,"Hello world!", 33 | 0, 34 | 0, 35 | st7789.color565(8,8,8), 36 | st7789.color565(0,0,0) 37 | ) 38 | 39 | main() -------------------------------------------------------------------------------- /micropython/tft/ttgo_hello.py: -------------------------------------------------------------------------------- 1 | """ 2 | ttgo_hello.py 3 | Writes "Hello!" in random colors at random locations on a 4 | LILYGO® TTGO T-Display. 5 | https://youtu.be/z41Du4GDMSY 6 | """ 7 | import random 8 | from machine import Pin, SPI 9 | import st7789 10 | 11 | # Choose a font 12 | 13 | # import vga1_8x8 as font 14 | # import vga2_8x8 as font 15 | 16 | # import vga1_8x16 as font 17 | # import vga2_8x16 as font 18 | 19 | # import vga1_16x16 as font 20 | # import vga1_bold_16x16 as font 21 | # import vga2_16x16 as font 22 | # import vga2_bold_16x16 as font 23 | 24 | # import vga1_16x32 as font 25 | # import vga1_bold_16x32 as font 26 | # import vga2_16x32 as font 27 | import vga2_bold_16x32 as font 28 | 29 | def main(): 30 | tft = st7789.ST7789( 31 | SPI(2, baudrate=30000000, polarity=1, phase=1, sck=Pin(18), mosi=Pin(19)), 32 | 135, 33 | 240, 34 | reset=Pin(23, Pin.OUT), 35 | cs=Pin(5, Pin.OUT), 36 | dc=Pin(16, Pin.OUT), 37 | backlight=Pin(4, Pin.OUT), 38 | rotation=3) 39 | 40 | tft.init() 41 | 42 | while True: 43 | for rotation in range(4): 44 | tft.rotation(rotation) 45 | tft.fill(0) 46 | col_max = tft.width() - font.WIDTH*6 47 | row_max = tft.height() - font.HEIGHT 48 | 49 | for _ in range(250): 50 | tft.text( 51 | font, 52 | "Hello!", 53 | random.randint(0, col_max), 54 | random.randint(0, row_max), 55 | st7789.color565( 56 | random.getrandbits(8), 57 | random.getrandbits(8), 58 | random.getrandbits(8)), 59 | st7789.color565( 60 | random.getrandbits(8), 61 | random.getrandbits(8), 62 | random.getrandbits(8)) 63 | ) 64 | 65 | main() -------------------------------------------------------------------------------- /pinmap/README.md: -------------------------------------------------------------------------------- 1 | # Comparison for the 3 editions: ESP32, rp2040 and T-PicoC3 2 | 3 | ![pinmap comparison](pinmap_T-Display.png) 4 | 5 | Here are the individual boards: 6 | 7 | ## T-Display ESP32 8 | 9 | ![T-Display ESP32](pinmap_esp32.jpg) 10 | 11 | ## T-Display rp2040 12 | 13 | ![T-Display rp2040](pinmap_T-display-RP2040.jpg) 14 | 15 | ## T-PicoC3 16 | 17 | ![T-PicoC3](pinmap_T-PicoC3.jpg) 18 | 19 | ## T8 ESP32-S2 ST7789 20 | 21 | ![T8 ST7789](pinmap_T8-ST7789.jpg) 22 | 23 | 24 | 25 | __March 2023__ 26 | 27 | # Circuitpython on T-Display rp2040 and T-PicoC3 28 | 29 | Both boards are similar to the T-Display from 2019, but have a rp2040 MCU and in case of the C3 and additional esp32c3 for wifi connectivity. 30 | 31 | To support them we need a VID and PID combination, see https://github.com/adafruit/circuitpython/pull/6037 32 | 33 | Since the MCU is a rp2040 the VID could be `USB_VID = 0x2E8A` (that's the Raspberry Pi foundation) and we need to request a PID according to 34 | 35 | https://github.com/raspberrypi/usb-pid 36 | 37 | It was requested already according to [https://github.com/adafruit/circuitpython/pull/6037](https://github.com/Xinyuan-LilyGO/LILYGO-T-display-RP2040/issues/5) from May 25, 2022: 38 | 39 | Some history: 40 | 41 | - https://github.com/adafruit/circuitpython/issues/6024 Feb 2022 - closed 42 | - https://github.com/adafruit/circuitpython/pull/6037 Feb 2022 - still open, April 1st @fabaff that raspberry want OEM to make request 43 | - https://github.com/Xinyuan-LilyGO/LILYGO-T-display-RP2040/issues/5 March 2022 44 | - https://github.com/Xinyuan-LilyGO/LILYGO-T-display-RP2040/issues/13 Dec 2022 45 | 46 | Timeline: 47 | - Feb 15th, 2022 @erongd got it working, see issue #6024 on circuitpython 48 | - Mar 19th, 2022 both @erongd and @fabaff submitted a PID request to raspberrypi (VID 2E8A) 49 | - April 1st, 2022 pull 6037: @fabaff got response that raspberry pi wants OEM to make PID request 50 | - November 16th, 2022 pull 6037 @tannewt suggests the use of pid.codes to solve the problem 51 | - March 9th, 2022 PID pull request created for pid.codes https://github.com/pidcodes/pidcodes.github.com/pull/827 52 | 53 | ## Post on the forum 54 | 55 | - https://community.lilygo.cc/topic/50/help-with-usb-vid-pid-for-circuitpython February 2022 56 | - https://community.lilygo.cc/topic/145/t-display-rp2040-needs-usb-vid-pid?_=1678274382618 December 2022 57 | 58 | ## Write to info@raspberrypi.com 59 | 60 | What is the current state? Fill out the form from https://github.com/raspberrypi/usb-pid 61 | 62 | -------------------------------------------------------------------------------- /pinmap/USB_VID_PID.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/pinmap/USB_VID_PID.xlsx -------------------------------------------------------------------------------- /pinmap/pinmap esp32 and rp2040 in circuitpython.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/pinmap/pinmap esp32 and rp2040 in circuitpython.xlsx -------------------------------------------------------------------------------- /pinmap/pinmap_T-Display.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/pinmap/pinmap_T-Display.png -------------------------------------------------------------------------------- /pinmap/pinmap_T-PicoC3.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/pinmap/pinmap_T-PicoC3.jpg -------------------------------------------------------------------------------- /pinmap/pinmap_T-display-RP2040.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/pinmap/pinmap_T-display-RP2040.jpg -------------------------------------------------------------------------------- /pinmap/pinmap_T8-ST7789.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/pinmap/pinmap_T8-ST7789.jpg -------------------------------------------------------------------------------- /pinmap/pinmap_esp32.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/pinmap/pinmap_esp32.jpg -------------------------------------------------------------------------------- /pinmap/pinmaps.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kreier/t-display/065711964534e813c75ffec666c15a2387141484/pinmap/pinmaps.xlsx --------------------------------------------------------------------------------