Control methods and systems for interactive scrolling text display on the pixelated back screen of a mobile phone

Abstract

This invention discloses a control method and system for interactive pixelated display of scrolling text on a mobile phone back screen, relating to the field of mobile terminal display technology. The method includes: receiving user-configured text, speed, and mode; dynamically allocating a virtual canvas larger than the screen size based on the physical screen size and text length; rendering the vector text to the virtual canvas with high precision in one go and caching it; dynamically determining the cropping area on the virtual canvas based on floating-point offsets during scrolling, and using bilinear interpolation for sub-pixel precision image sampling to generate each frame; handling boundary wrapping in loop modes; and finally sending the frame data to the driver layer for display. This invention, through a core architecture of "pre-rendering + dynamic viewport cropping + sub-pixel interpolation," achieves pixel-level smooth scrolling on low-resolution dot matrix screens, completely eliminating jerky scrolling, while significantly reducing CPU and power consumption, and supporting rich extended functions such as sensor linkage and touch interaction.

Description

Technical Field

[0001] This invention relates to the field of mobile terminal display control technology, specifically to a text scrolling display control method, system, and storage medium for devices equipped with low-resolution dot-matrix displays, such as smartphone back screens and smartwatches. Background Technology

[0002] As smartphone form factors have evolved, some devices have begun to integrate secondary screens on the back, such as dot-matrix LED screens or low-power e-ink screens, to display time, notifications, personalized information, etc., providing lightweight information interaction while keeping the main screen off. In these application scenarios, the "text scrolling display" (commonly known as "marquee") function is widely used in scenarios such as concert support slogan display, meeting mute prompts, personalized signatures, and real-time message broadcasts due to its intuitive, eye-catching, and customizable features.

[0003] Meanwhile, user demands are becoming increasingly sophisticated, requiring not only customized text content but also adjustments to font styles, colors, scrolling speeds, and directions. However, back screens (especially dot matrix LED screens) typically have extremely low physical resolutions (such as 16x16 or 32x8 pixels), posing a significant technical challenge to displaying dynamic text clearly and smoothly on a limited number of pixels.

[0004] Existing common text scrolling implementation schemes are mostly based on simple frame buffer shifting and redrawing. Specifically, the system maintains a buffer in memory that is consistent with the physical screen resolution, stores the text bitmap in it, and then periodically moves the pixel data in the buffer one pixel unit to the left or right, and fills the part that has moved off the screen back to the other end to achieve a looping effect.

[0005] However, the shortcomings of existing technical solutions are also very obvious: First, the scrolling is jerky. Since each movement must be an integer number of pixels, the text moves in a "jumping" manner when scrolling at low speeds, resulting in a stiff visual effect and a lack of smoothness. Second, the system resources are consumed in large quantities. Each scroll requires pixel displacement calculation and redrawing of the entire screen or most of the area. When the text is long or requires complex effects, the CPU and memory bandwidth usage is high, leading to increased power consumption and affecting battery life. Furthermore, the functionality is limited and the scalability is poor, making it difficult to support subpixel smooth scrolling, non-linear scrolling trajectories, and complex interactions with sensors.

[0006] Therefore, there is an urgent need for a text scrolling display control solution that can achieve high-definition, smooth, and fluid text scrolling display on low-resolution dot matrix screens with low resource consumption and support for rich interaction. Summary of the Invention

[0007] The technical problem to be solved by the present invention is to overcome the shortcomings of the prior art in realizing text scrolling on low-resolution dot matrix screens, such as strong lag, high resource consumption and limited functionality.

[0008] First aspect This invention provides a control method for interactively displaying scrolling text information in a pixelated manner on the back screen of a mobile phone. The method runs on the processor of a smart terminal, which is equipped with a low-resolution dot-matrix display screen. The method includes: S1. Configuration and initialization steps: Receive display information configured by the user, the display information including at least text content, scrolling speed and scrolling mode; dynamically allocate a virtual canvas in memory according to the physical resolution of the dot matrix display and the rendering size of the text content, the width of the virtual canvas being greater than the physical width of the dot matrix display. S2. Pre-rendering step: Using a graphics rendering engine, the text content is drawn onto the virtual canvas in vector form to generate a high-precision static bitmap and cache it. S3. Smooth Scrolling and Frame Generation Steps: Start the timer and execute the following sub-steps within each rendering frame cycle: S31. Based on the scrolling speed and time interval, update a floating-point viewport offset; S32. Based on the updated viewport offset, determine a corresponding cropping area on the virtual canvas, wherein the size of the cropping area is consistent with the physical resolution of the dot matrix display screen. S33. Perform sub-pixel precision image sampling on the captured area to generate display data for the current frame; the image sampling uses an interpolation algorithm to process the fractional part of the viewport offset; S4. Data transmission and display steps: Send the display data of the current frame to the driver layer of the dot matrix display screen to drive the dot matrix display screen to refresh the display.

[0009] Furthermore, the step of "determining a corresponding cropping area on the virtual canvas based on the updated viewport offset" includes: when the scrolling mode is a loop mode and the updated viewport offset is greater than or equal to the effective scrolling width of the virtual canvas, performing a modulo operation on the viewport offset to make it wrap around to the starting end of the virtual canvas, so as to achieve visually seamless loop scrolling.

[0010] Furthermore, the interpolation algorithm is a bilinear interpolation algorithm.

[0011] Second aspect This invention provides a control system for interactive pixelated display of scrolling text information on the back screen of a mobile phone, applicable to smart terminals equipped with a low-resolution dot matrix display. The system includes: The configuration management module is used to receive display information configured by the user. The virtual canvas management module is used to dynamically allocate and manage virtual canvas memory based on physical resolution and text rendering size. The rendering engine module is used to pre-render vector text to the virtual canvas and cache it; The smooth scrolling engine module, including a timer, an offset calculation unit, and an interpolation sampling unit, is used to periodically generate display data for the current frame; The driver interface module is used to transmit display data to the hardware driver layer; The smooth scrolling engine module is configured to: determine the cropping area on the virtual canvas based on the floating-point offset, and perform sub-pixel precision image sampling using an interpolation algorithm.

[0012] Third aspect The present invention provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of the method described above.

[0013] Compared with the prior art, the beneficial effects of the present invention include the following aspects: 1. Achieved truly smooth scrolling: By introducing floating-point viewport offset and sub-pixel interpolation technology, text can move with an accuracy of less than 1 physical pixel, completely eliminating the "grid jumping" stuttering caused by traditional integer displacement, and presenting a smooth visual experience like flowing water at any speed.

[0014] 2. Significantly reduced system overhead and power consumption: Adopting the core architecture of "render once, capture multiple times", the most time-consuming complex graphics calculations such as vector font rasterization and anti-aliasing rendering are only performed once when the text content or style is changed; the subsequent scrolling process only involves low computational complexity memory access and interpolation operations, which greatly reduces the load on the CPU and GPU, reduces energy consumption, and extends the device's battery life.

[0015] 3. Enhanced user experience and flexibility: The unique viewport wrap and data pre-stitching logic achieves seamless visual scrolling of long texts, resulting in a smooth and natural information display. At the same time, the architecture is easily expandable and can conveniently support various scrolling modes (unidirectional, reciprocating, and cyclical), non-linear scrolling paths (such as wave-shaped and curved paths), and interactive linkage with sensors (such as gyroscopes and touch screens), greatly enriching application scenarios and adding fun.

[0016] 4. Ensures stable and efficient display: The driver layer adopts a double or even multi-buffering mechanism, combined with DMA transfer, to ensure that the display is tear-free and flicker-free when updating data, and to maximize the release of CPU resources, so that the entire system runs efficiently and stably. Attached Figure Description

[0017] Figure 1 This is a flowchart of a text scrolling display interactive control method provided in an embodiment of the present invention; Figure 2 This is a schematic diagram of the control system architecture and data processing provided in an embodiment of the present invention. Detailed Implementation

[0018] To make the objectives, technical solutions, and advantages of the present invention clearer, the embodiments of the present invention will be described in further detail below with reference to the accompanying drawings; the specific embodiments described below are intended to explain the present invention and should not be construed as limiting the present invention.

[0019] The core idea of ​​this invention is to "trade space for time and precision for smoothness". By constructing a high-precision "virtual canvas" in memory that is much larger than the actual physical screen, the entire text is pre-rendered. When scrolling, only a "viewport" the same size as the physical screen needs to be moved to slide on the virtual canvas. And by using advanced image interpolation technology to process non-integer displacement, a high-quality smooth scrolling effect is achieved with extremely low computational cost.

[0020] ( Example 1 Please see Figure 1 This embodiment provides a control method for interactively displaying scrolling text on the pixelated back screen of a mobile phone, including the following steps: Step S101, Parameter Reception and Parsing: Users input or select the text content they wish to display (e.g., "Welcome to the 2024 Global Developer Conference") through the application interface and configure related display parameters. These parameters are encapsulated as a configuration object (ConfigObject). Key configuration parameters include, but are not limited to: 1) textString: A string representing the text content to be displayed; 2) fontSize: Integer, font size (unit: virtual pixels); 3) textColor: Color value (e.g., ARGB_8888 format), the foreground color of the text; 4) backgroundColor: Color value, the background color of the canvas; 5) scrollSpeed: A floating-point number representing the scrolling speed in pixels per second (px / s); a positive number indicates scrolling to the right or down, and a negative number indicates scrolling to the left or up. 6) scrollMode: An enumeration value that defines the scrolling behavior mode; for example: SCROLL_MODE_ONCE (scroll once in one direction and then stop), SCROLL_MODE_LOOP (scroll repeatedly in a loop), SCROLL_MODE_BOUNCE (scroll repeatedly after reaching the boundary). 7) direction: An enumeration value that defines the scrolling direction, such as LEFT_TO_RIGHT, RIGHT_TO_LEFT, TOP_TO_BOTTOM, etc.

[0021] Step S102: Dynamic construction and size calculation of the virtual canvas: The system obtains the physical resolution of the dot matrix display, denoted as physicalWidth x physicalHeight (e.g., 32 pixels x 8 pixels); the system creates a temporary Paint object with the same font configuration, calls its measureText(textString) method to calculate the theoretical pixel width textRenderedWidth of the text after rendering under the current settings; next, the dimensions of the virtual canvas are calculated as follows: 1) The height of the virtual canvas (virtualHeight) is directly equal to the height of the physical screen (physicalHeight) to ensure a perfect vertical match; 2) The width of the virtual canvas, virtualWidth, needs to be dynamically calculated. The principle is that it must be able to accommodate the complete text and reserve a buffer for smooth loops; a preferred strategy is as follows: "if (scrollMode == SCROLL_MODE_LOOP) { / / In loop mode, the virtual canvas width = text width + 2 Physical screen width / / Physical screen width buffers at both ends are used to achieve seamless transitions virtualWidth = textRenderedWidth + 2 physicalWidth; } else { / / In non-looping mode, the virtual canvas width = max(text width, physical screen width) + physicalWidth / / Leave at least one screen width of margin at the end so that the text scrolls completely off-screen. virtualWidth = max(textRenderedWidth, physicalWidth) + physicalWidth; }”; 3) After the calculation is complete, allocate a block of size virtualWidth in the memory heap. virtualHeight A 4-byte buffer (assuming ARGB_8888 format) is used as the virtual canvas mVirtualCanvasBitmap.

[0022] Step S103: High-precision pre-rendering and caching of vector text: This step is performed only once during initialization or when the displayed content changes, and it is crucial for performance optimization, including: 1) Create a Canvas object associated with mVirtualCanvasBitmap; 2) Use canvas.drawColor(backgroundColor) to fill the background color of the entire virtual canvas; 3) Configure the Paint object for text drawing: enable anti-aliasing (setAntiAlias(true)) and subpixel text rendering (setSubpixelText(true)), and set the font, size, color, etc.; 4) Determine the starting Y coordinate for text drawing, centering it vertically: startY = (virtualHeight - fontMetrics.descent - fontMetrics.ascent) / 2; 5) Determine the starting X coordinate for text drawing; In loop mode, to ensure smooth scrolling from off-screen, the text is usually drawn at the physicalWidth coordinate in the horizontal direction of the virtual canvas; that is: startX = physicalWidth. 6) Perform drawing: canvas.drawText(textString, startX, startY, paint); 7) Cache locking: After rendering is complete, call mVirtualCanvasBitmap.setImmutable(true) (if the system API supports it) or mark it as read-only to prevent accidental modification; thereafter, as long as the text content and style remain unchanged, the bitmap will be reused.

[0023] Step S104: Smooth scrolling engine operation and frame data generation: This is the core loop of the invention, executed at a fixed frequency (e.g., 60Hz, approximately 16.67ms / frame), specifically including: S1041, Floating-point viewport offset update: Maintain a global floating-point variable `currentOffset`, representing the X-coordinate of the top-left corner of the current "viewframe" on the virtual canvas (taking scrolling from left to right as an example), at the beginning of each frame: "deltaTime = getCurrentTime() - lastFrameTime; / / Calculate the time elapsed since the last frame (in milliseconds)" lastFrameTime = getCurrentTime(); / / Calculate the displacement of this frame pixelDelta = scrollSpeed (deltaTime / 1000.0f); / / Convert to pixel displacement currentOffset += pixelDelta; / / Update offset; S1042, Scrolling Mode Logic Processing and Boundary Control: Based on the set scrolling mode, perform boundary checks and corrections on currentOffset: a. Loop Mode: When currentOffset is greater than or equal to the effective scroll width of the virtual canvas (virtualWidth - physicalWidth), it means that the text header has completely left the visible area of ​​the canvas; at this time, wrap around: currentOffset = currentOffset % (virtualWidth - physicalWidth); since there are reserved buffers at both ends of the virtual canvas (step S102), this operation can ensure that the part that moves out from the right side of the canvas can be seamlessly moved in from the left buffer, forming an infinite loop visually; b. BOUNCE mode: When currentOffset touches any boundary of the effective scroll range, scrollSpeed ​​is inverted to achieve a bounce effect; c. One-time mode (ONCE): The scrolling engine stops when the text has completely scrolled off the screen (currentOffset>= (virtualWidth - physicalWidth)); S1043, Image frame extraction based on sub-pixel precision (bilinear interpolation): This is key to achieving "smoothness" rather than "jumping"; since currentOffset is a floating-point number, its integer part intPart and fractional part fracPart represent the base pixel position and sub-pixel offset, respectively, including: 1) Define the source rectangle srcRect: "srcRect.left = currentOffset; / / Floating-point number!" srcRect.top = 0; srcRect.right = currentOffset + physicalWidth; / / Floating-point number! srcRect.bottom = physicalHeight;"; 2) Define the target rectangle dstRect, whose size is fixed as the target frame buffer mFrameBuffer (size is physicalWidth x physicalHeight): 3) Draw using graphics APIs (such as Android's Canvas.drawBitmap(Bitmap source, Rect src, Rect dst, Paint paint), where the underlying layer automatically performs interpolation when src is a floating-point rectangle); specifically, for each pixel (x_dst, y_dst) in the target frame using bilinear interpolation: a. Map back to floating-point coordinates on the source virtual canvas: x_src = currentOffset + x_dst, y_src = y_dst; b. Find the four nearest neighbor source pixels around (x_src, y_src): P00, P01, P10, P11, with coordinates (floor(x_src), floor(y_src)), (floor(x_src), ceil(y_src)), (ceil(x_src), floor(y_src)), (ceil(x_src), ceil(y_src)). c. Calculate the interpolation weights wx = frac(x_src), 1-wx in the horizontal direction and wy = frac(y_src), 1-wy in the vertical direction respectively; d. Target pixel color = (1 - wy) [(1-wx) P00 + wx P10] + wy [(1-wx) P01 + wx P11]; This calculation ensures that even if the currentOffset changes by only 0.1 pixels, the generated new frame will have a slight difference from the previous frame, thus creating a smooth motion visual effect during continuous playback.

[0024] S1044. Data Format Conversion and Optimization (Optional): The pixel data obtained from mFrameBuffer may be in 32-bit ARGB format, while the dot matrix LED driver chip may receive specific formats such as RGB565 or GRB888. This step is used for format conversion. As an important optimization option, differential update can be performed: the pixel data of the current frame mFrameBuffer is compared pixel by pixel or block by block with the pixel data of the previous frame mlestFrameBuffer. Only the pixel coordinates and color values ​​that have changed are packaged and sent, instead of the entire frame data. This can greatly reduce the amount of data transmission on the system bus (such as I2C / SPI) and further reduce power consumption.

[0025] Step S105, Driver layer data transmission and hardware display: S1051, Double Buffering Mechanism The driver layer maintains two display buffers, FrontBuffer and BackBuffer. When the display screen is reading data from FrontBuffer and scanning the display, the application layer writes the new frame data generated in step S104 into BackBuffer through JNI or system calls. S1052, Vertical Synchronization Switching The driver layer atomically swaps the pointers of FrontBuffer and BackBuffer the instant the display completes a frame scan and enters the vertical blanking period (VBlank); in this way, the next frame displays the new data, avoiding screen tearing caused by half-written data. S1053, Low-level driver The driver moves the data in the FrontBuffer to the transmit register of the communication interface (such as SPI) connected to the LED dot matrix screen via DMA (direct memory access) without the need for continuous CPU involvement. The LED driver chip controls the brightness and color of each LED according to the received data and the set row scan timing, ultimately displaying smooth scrolling text on the physical screen.

[0026] ( Example 2The following is a specific example. Suppose the phone's back screen is a 16x8 monochrome LED dot matrix screen (physical resolution: physicalWidth=16, physicalHeight=8), the user sets the scrolling text to "HELLO", the scrolling speed to 20 pixels / second, and the loop mode.

[0027] Steps S101 / S102: The system measures the rendering width of "HELLO" as textRenderedWidth = 40 pixels, and constructs a virtual canvas: virtualHeight = 8; virtualWidth = 40 + 2 16 = 72 pixels, meaning a 72x8 bitmap is created in memory; Step S103: Start drawing "HELLO" at the horizontal position of 16 pixels on the virtual canvas (startX=16), with the drawing range from X=16 to X=56; the areas from X=0 to 15 and from X=56 to 71 are background color blank buffers; Step S104: Start scrolling; assuming initial currentOffset = 0.0: 1) Frame 0: Capture the virtual canvas area from (0,0) to (16,8) for display, and the screen will show the blank area on the left. 2) After 0.1 seconds (speed 20px / s, displacement 2 pixels): currentOffset=2.0; crop the region from (2.0,0) to (18.0,8); since the offset 2.0 is an integer, directly crop the corresponding pixel column; 3) After 0.105 seconds: currentOffset=2.1; the region (2.1,0) to (18.1,8) is cropped; at this time, for the pixel in column 0 of the screen, its color is determined by the color at X=2.1 on the virtual canvas. Through bilinear interpolation, it is mixed by the grayscale (or brightness) of the pixels in columns X=2 and X=3 in a ratio of 9:1, thus achieving subpixel smoothing; Loop processing: As the text moves right, when currentOffset increases to 56 (virtualWidth(72) - physicalWidth(16)), the text header “H” is about to move out of the right edge of the canvas; at this time, currentOffset %= 56, making it wrap around to 0; however, since the area of ​​virtual canvas X=56 to 71 is a copy of the blank area of ​​X=0 to 15, from the perspective of the screen, at the same time as the text disappears from the right side, the exact same blank / text appears from the left side, with no gaps in the connection; Step S105: Generate a 16x8 monochrome bitmap for each frame, and control the on / off state of 16x8 LEDs through the driver chip to form a smoothly scrolling “HELLO” message.

[0028] ( Example 3 Please see Figure 2 Based on the above control method, this embodiment provides the overall architecture and data flow of its control system, which includes: Application layer: Includes user interface (UI) module and configuration management module, responsible for interacting with users, receiving and encapsulating display parameters; Rendering and Processing Layer: This is the core logic layer, which includes a virtual canvas management module responsible for memory allocation; a vector rendering engine module that performs pre-rendering in step S103; a smooth scrolling engine module that includes a timer, offset calculation unit, and interpolation sampling unit, and executes step S104 in a loop; and a frame buffer management module that manages mFrameBuffer. Driver and hardware layer: This includes the system driver interface module, which is responsible for receiving data from the upper layer; the dual buffer management module, which manages the FrontBuffer and BackBuffer; and the LED dot matrix screen hardware.

[0029] Data stream such as Figure 2 As indicated by the arrows: User Configuration -> Virtual Canvas -> Pre-rendering -> Loop Capture and Interpolation -> Frame Data -> Driver Interface -> Double Buffering -> Hardware Display; This architecture clearly embodies the idea of ​​"separation of rendering and display".

[0030] ( Example 4 This embodiment provides further optimized and modified implementation methods. 1. Sensor Linkage: In step S1041, scrollSpeed ​​can be variable; the system can read accelerometer or gyroscope data in real time and map the phone's tilt angle on the X-axis to the scrolling speed; for example, the tilt angle θ (degrees) and the speed v (pixels / second) satisfy: v = k θ (where k is the scaling factor); this enables the fun interaction of "shaking to accelerate scrolling".

[0031] 2. Touch interaction: If the back screen supports touch, touch events can be listened to during scrolling; when a finger is pressed and slid, the automatic scrolling timer is paused, and the sliding distance dx of the finger in the X direction is directly added to currentOffset to achieve the effect of "finger dragging text"; when the finger is lifted, the system can give the text an initial deceleration scrolling inertia based on the speed at the moment of lifting, in order to simulate the physical sliding effect.

[0032] 3. Non-linear path: The update of currentOffset does not necessarily increase linearly; for example, it can be modified to: currentOffset = A sin(ω t + φ), where A is the amplitude, ω is the angular velocity, t is the time, and φ is the initial phase; in this way, the captured area will move on the virtual canvas according to a sine trajectory, and finally the text will be displayed on the screen in a wave-like scrolling pattern.

[0033] 4. Tile rendering and caching: For extremely long texts (such as a long article), rendering the entire virtual canvas at once may consume too much memory. In this case, an "on-demand tile-based" strategy can be adopted: logically divide the virtual canvas into multiple tiles that are the same width as or slightly wider than the screen; only load the current viewport and 1-2 adjacent tiles into memory for rendering; as scrolling, dynamically unload tiles that have been moved out of view and load new tiles that are about to enter view; thus, manage infinitely long scrolling content with a fixed amount of memory.

[0034] The above description is only a preferred embodiment of the present invention and does not limit the patent scope of the present invention. Any equivalent structural transformations made under the inventive concept of the present invention using the contents of the present invention specification and drawings, or direct / indirect applications in other related technical fields, should be included within the patent protection scope of the present invention.

Claims

1. A control method for interactively displaying scrolling text information on the pixelated back screen of a mobile phone, operating on a smart terminal equipped with a low-resolution dot-matrix display, characterized in that, The method includes: S1. Configuration and initialization steps: Receive display information configured by the user, the display information including at least text content, scrolling speed and scrolling mode; dynamically allocate a virtual canvas in memory according to the physical resolution of the dot matrix display and the rendering size of the text content, the width of the virtual canvas being greater than the physical width of the dot matrix display. S2. Pre-rendering step: Using a graphics rendering engine, the text content is drawn onto the virtual canvas in vector form to generate a high-precision static bitmap and cache it. S3. Smooth Scrolling and Frame Generation Steps: Start the timer and execute the following sub-steps within each rendering frame cycle: Update a floating-point viewport offset based on the scrolling speed and time interval; Based on the updated viewport offset, a corresponding cropping region is determined on the virtual canvas, the size of which is consistent with the physical resolution of the dot matrix display screen. Subpixel-precision image sampling is performed on the captured region to generate display data for the current frame; the image sampling uses an interpolation algorithm to process the fractional part of the viewport offset; S4. Data transmission and display steps: Send the display data of the current frame to the driver layer of the dot matrix display screen to drive the dot matrix display screen to refresh the display.

2. The control method for interactive pixelated display of scrolling text information on the back screen of a mobile phone according to claim 1, characterized in that, The phrase "determining a corresponding cropping region on the virtual canvas based on the updated viewport offset" includes: When the scrolling mode is a loop mode, and the updated viewport offset is greater than or equal to the effective scrolling width of the virtual canvas, the viewport offset is moduloed to wrap around to the beginning of the virtual canvas, so as to achieve visually seamless loop scrolling.

3. The control method for interactive pixelated display of scrolling text information on the back screen of a mobile phone according to claim 1 or 2, characterized in that: The interpolation algorithm is a bilinear interpolation algorithm.

4. The control method for interactive pixelated display of scrolling text information on the back screen of a mobile phone according to any one of claims 1-3, characterized in that, The method also includes a sensor linkage step: Real-time acquisition of motion sensor data from the smart terminal; The rolling speed or rolling direction is dynamically adjusted based on the motion sensor data. The motion sensor includes at least one of a gyroscope and an accelerometer.

5. The control method for interactive pixelated display of scrolling text information on the back screen of a mobile phone according to any one of claims 1-3, characterized in that, The dot matrix display screen is a touch screen; the method further includes a touch interaction step: Listen for touch events on the dot matrix display screen; When a swipe touch operation is detected, the viewport offset is directly adjusted according to the swipe displacement to respond to the user's drag operation; When the touch ends, based on the sliding speed at the moment the touch ends, an inertial velocity is assigned to the viewport offset, causing it to continue scrolling and decelerate to a stop.

6. The control method for interactive pixelated display of scrolling text information on the back screen of a mobile phone according to any one of claims 1-3, characterized in that, The phrase "update a floating-point viewport offset based on the scrolling speed and time interval" specifically means: The viewport offset is updated according to a nonlinear function, so that the cropped area moves on the virtual canvas along a nonlinear path, thereby presenting a nonlinear scrolling text effect on the dot matrix display screen. The nonlinear function includes at least one of a sine function and a Bézier curve function.

7. The control method for interactive pixelated display of scrolling text information on the back screen of a mobile phone according to any one of claims 1-3, characterized in that, In the data transmission and display steps, a differential update method is adopted: the display data of the current frame is compared with the display data of the previous frame, and only the pixel data that has changed is sent to the driver layer.

8. The control method for interactive pixelated display of scrolling text information on the back screen of a mobile phone according to any one of claims 1-3, characterized in that, In the pre-rendering step, a block rendering strategy is adopted: the virtual canvas is logically divided into multiple blocks; only blocks containing the current cropping area and its neighboring areas are rendered and cached, and the corresponding blocks are dynamically loaded and unloaded as the viewport offset changes.

9. A control system for interactive pixelated display of scrolling text information on the back screen of a mobile phone, applied to a smart terminal equipped with a low-resolution dot matrix display, to realize the control method for interactive pixelated display of scrolling text information on the back screen of a mobile phone as described in any one of claims 1-8, characterized in that, The system includes: The configuration management module is used to receive display information configured by the user. The virtual canvas management module is used to dynamically allocate and manage virtual canvas memory based on physical resolution and text rendering size. The rendering engine module is used to pre-render vector text to the virtual canvas and cache it; The smooth scrolling engine module includes a timer, an offset calculation unit, and an interpolation sampling unit. It is used to periodically determine the cropping area on the virtual canvas based on the floating-point offset and to perform sub-pixel precision image sampling using an interpolation algorithm to generate display data for the current frame. The driver interface module is used to transmit the display data of the current frame to the hardware driver layer.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the program is executed by the processor, it implements the steps of the control method for interactively displaying scrolling text information on the pixelated back screen of a mobile phone as described in any one of claims 1-8.

Images