package ssd1306 import ( "errors" "fmt" "image" "image/color" "image/draw" "time" "git.maze.io/go/harmon/config" "git.maze.io/go/harmon/display" "git.maze.io/go/harmon/display/oled" "git.maze.io/go/harmon/internal/pixel" ) func init() { display.Register("ssd1306", newDevice) } var ( errBufferSize = errors.New("invalid size buffer") errOutOfRange = errors.New("out of screen range") ) type ResetValue [2]byte // Device wraps I2C or SPI connection. type Device struct { bus oled.Bus buffer pixel.Image[pixel.Monochrome] width int16 height int16 bufferSize int16 vccState VccMode canReset bool resetCol ResetValue resetPage ResetValue rotation display.Rotation } // Config is the configuration for the display type Config struct { Width int16 Height int16 VccState VccMode //Address uint16 // ResetCol and ResetPage are used to reset the screen to 0x0 // This is useful for some screens that have a different size than 128x64 // For example, the Thumby's screen is 72x40 // The default values are normally set automatically based on the size. // If you're using a different size, you might need to set these values manually. ResetCol ResetValue ResetPage ResetValue Rotation display.Rotation } type VccMode uint8 func newDevice(config *config.Display) (display.Display, error) { width, height, err := display.ParseSize(config.Size, 128, 0) if err != nil || height == 0 { return nil, fmt.Errorf("invalid size %q: %w", config.Size, err) } rotation, err := display.ParseRotation(config.Rotate) if err != nil { return nil, err } bus, err := oled.NewBus(config) if err != nil { return nil, err } d := &Device{ bus: bus, } if err = d.Configure(Config{ Width: int16(width), Height: int16(height), Rotation: rotation, }); err != nil { return nil, err } return d, nil } // Configure initializes the display with default configuration func (d *Device) Configure(cfg Config) error { var zeroReset ResetValue if cfg.Width != 0 { d.width = cfg.Width } else { d.width = 128 } if cfg.Height != 0 { d.height = cfg.Height } else { d.height = 64 } if cfg.VccState != 0 { d.vccState = cfg.VccState } else { d.vccState = SWITCHCAPVCC } if cfg.ResetCol != zeroReset { d.resetCol = cfg.ResetCol } else { d.resetCol = ResetValue{0, uint8(d.width - 1)} } if cfg.ResetPage != zeroReset { d.resetPage = cfg.ResetPage } else { d.resetPage = ResetValue{0, uint8(d.height/8) - 1} } d.bufferSize = d.width * d.height / 8 d.buffer = pixel.NewImage[pixel.Monochrome](int(d.width), int(d.height)) //d.buffer = make([]byte, d.bufferSize) //d.canReset = cfg.Address != 0 || d.width != 128 || d.height != 64 // I2C or not 128x64 time.Sleep(100 * time.Nanosecond) d.Command(DISPLAYOFF) d.Command(SETDISPLAYCLOCKDIV) d.Command(0x80) d.Command(SETMULTIPLEX) d.Command(uint8(d.height - 1)) d.Command(SETDISPLAYOFFSET) d.Command(0x0) d.Command(SETSTARTLINE | 0x0) d.Command(CHARGEPUMP) if d.vccState == EXTERNALVCC { d.Command(0x10) } else { d.Command(0x14) } d.Command(MEMORYMODE) d.Command(0x00) d.SetRotation(cfg.Rotation) if (d.width == 128 && d.height == 64) || (d.width == 64 && d.height == 48) { // 128x64 or 64x48 d.Command(SETCOMPINS) d.Command(0x12) d.Command(SETCONTRAST) if d.vccState == EXTERNALVCC { d.Command(0x9F) } else { d.Command(0xCF) } } else if d.width == 128 && d.height == 32 { // 128x32 d.Command(SETCOMPINS) d.Command(0x02) d.Command(SETCONTRAST) d.Command(0x8F) } else if d.width == 96 && d.height == 16 { // 96x16 d.Command(SETCOMPINS) d.Command(0x2) d.Command(SETCONTRAST) if d.vccState == EXTERNALVCC { d.Command(0x10) } else { d.Command(0xAF) } } else { // fail silently, it might work println("there's no configuration for this display's size") } d.Command(SETPRECHARGE) if d.vccState == EXTERNALVCC { d.Command(0x22) } else { d.Command(0xF1) } d.Command(SETVCOMDETECT) d.Command(0x40) d.Command(DISPLAYALLON_RESUME) d.Command(NORMALDISPLAY) d.Command(DEACTIVATE_SCROLL) return d.Command(DISPLAYON) } // ClearBuffer clears the image buffer func (d *Device) ClearBuffer() { /* for i := int16(0); i < d.bufferSize; i++ { d.buffer[i] = 0 } */ d.buffer.Clear() } // ClearDisplay clears the image buffer and clear the display func (d *Device) ClearDisplay() error { d.ClearBuffer() return d.Refresh() } // Refresh sends the whole buffer to the screen func (d *Device) Refresh() error { // Reset the screen to 0x0 // This works fine with I2C // In the 128x64 (SPI) screen resetting to 0x0 after 128 times corrupt the buffer // Since we're printing the whole buffer, avoid resetting it in this case if d.canReset { d.Command(COLUMNADDR) d.Command(d.resetCol[0]) d.Command(d.resetCol[1]) d.Command(PAGEADDR) d.Command(d.resetPage[0]) d.Command(d.resetPage[1]) } return d.Tx(d.buffer.RawBuffer(), false) } // SetPixel enables or disables a pixel in the buffer // color.RGBA{0, 0, 0, 255} is consider transparent, anything else // with enable a pixel on the screen func (d *Device) SetPixel(x int16, y int16, c pixel.Monochrome) { if d.rotation == display.Rotate90 || d.rotation == display.Rotate270 { x, y = y, x } /* if x < 0 || x >= d.width || y < 0 || y >= d.height { return } byteIndex := x + (y/8)*d.width if c == pixel.Off { d.buffer[byteIndex] &^= 1 << uint8(y%8) } else { d.buffer[byteIndex] |= 1 << uint8(y%8) } */ d.buffer.SetPixel(int(x), int(y), c) } // GetPixel returns if the specified pixel is on (true) or off (false) func (d *Device) GetPixel(x int16, y int16) pixel.Monochrome { if d.rotation == display.Rotate90 || d.rotation == display.Rotate270 { x, y = y, x } /* if x < 0 || x >= d.width || y < 0 || y >= d.height { return false } byteIndex := x + (y/8)*d.width return (d.buffer[byteIndex] >> uint8(y%8) & 0x1) == 1 */ return d.buffer.GetPixel(int(x), int(y)) } /* // SetBuffer changes the whole buffer at once func (d *Device) SetBuffer(buffer []byte) error { if int16(len(buffer)) != d.bufferSize { return errBufferSize } for i := int16(0); i < d.bufferSize; i++ { d.buffer[i] = buffer[i] } return nil } */ // GetBuffer returns the whole buffer func (d *Device) GetBuffer() []byte { return d.buffer.RawBuffer() } // Command sends a command to the display func (d *Device) Command(command uint8) error { return d.bus.Tx([]byte{command}, true) } // Tx sends data to the display func (d *Device) Tx(data []byte, isCommand bool) error { return d.bus.Tx(data, isCommand) } // Size returns the current size of the display. func (d *Device) Size16() (w, h int16) { return d.width, d.height } // DrawBitmap copies the bitmap to the screen at the given coordinates. func (d *Device) DrawBitmap(x, y int16, bitmap pixel.Image[pixel.Monochrome]) error { width, height := bitmap.Size() if x < 0 || x+int16(width) > d.width || y < 0 || y+int16(height) > d.height { return errOutOfRange } for i := 0; i < width; i++ { for j := 0; j < height; j++ { d.SetPixel(x+int16(i), y+int16(j), bitmap.GetPixel(i, j)) } } return nil } // Rotation returns the currently configured rotation. func (d *Device) Rotation() display.Rotation { return d.rotation } // SetRotation changes the rotation of the device (clock-wise). func (d *Device) SetRotation(rotation display.Rotation) error { d.rotation = rotation switch d.rotation { case display.NoRotation: d.Command(SEGREMAP | 0x1) // Reverse horizontal mapping d.Command(COMSCANDEC) // Reverse vertical mapping case display.Rotate180: d.Command(SEGREMAP) // Normal horizontal mapping d.Command(COMSCANINC) // Normal vertical mapping // nothing to do default: d.Command(SEGREMAP | 0x1) // Reverse horizontal mapping d.Command(COMSCANDEC) // Reverse vertical mapping } return nil } // Set the sleep mode for this display. When sleeping, the panel uses a lot // less power. The display won't show an image anymore, but the memory contents // should be kept. func (d *Device) Sleep(sleepEnabled bool) error { if sleepEnabled { d.Command(DISPLAYOFF) } else { d.Command(DISPLAYON) } return nil } // FillRectangle fills a rectangle at a given coordinates with a color func (d *Device) FillRectangle(x, y, width, height int16, c pixel.Monochrome) error { dw, dh := d.Size16() if x < 0 || y < 0 || width <= 0 || height <= 0 || x >= d.width || (x+width) > dw || y >= dh || (y+height) > dh { return errOutOfRange } if x+width == dw && y+height == dh && c == pixel.Off { d.ClearDisplay() return nil } for i := x; i < x+width; i++ { for j := y; j < y+height; j++ { d.SetPixel(i, j, c) } } return nil } // SetScroll sets the vertical scrolling for the display, which is a NOP for this display. func (d *Device) SetScroll(line int16) { return } /* draw.Image interface */ func (d *Device) At(x, y int) color.Color { return d.GetPixel(int16(x), int16(y)) } func (d *Device) Bounds() image.Rectangle { if d.rotation == display.NoRotation || d.rotation == display.Rotate180 { return image.Rect(0, 0, int(d.width), int(d.height)) } return image.Rect(0, 0, int(d.height), int(d.width)) } func (d *Device) ColorModel() color.Model { return pixel.MonochromeModel } func (d *Device) Set(x, y int, c color.Color) { c = pixel.MonochromeModel.Convert(c) d.SetPixel(int16(x), int16(y), c.(pixel.Monochrome)) } /* display.Image interface */ func (d *Device) Halt() error { return d.bus.Halt() } func (d *Device) Size() image.Point { if d.rotation == display.NoRotation || d.rotation == display.Rotate180 { return image.Pt(int(d.width), int(d.height)) } return image.Pt(int(d.height), int(d.width)) } func (d *Device) String() string { return fmt.Sprintf("ssd1306:%dx%d", d.width, d.height) } /* display.imageDrawer interface */ func (d *Device) DrawImage(img image.Image) error { draw.Draw(d.buffer, d.buffer.Bounds(), img, image.Point{}, draw.Src) return d.Refresh() }