api

A Pixelcade Listener called pixelweb.exe (Windows) or pixelweb.jar (for Raspberry Pi and Mac) runs in the background and listens for REST URL calls. Note these are local REST calls to localhost so an Internet connection is not required. However if your host (PC or Raspberry Pi) is reachable via the Internet, then you can make these calls remote too. You can interact with the API by making REST URL calls directly or use pixelcade.exe (Windows) or pixelcade.jar (for Raspberry Pi & Mac). If integrating from a third party application, it will be significantly faster to make the REST URL calls direct from your application (option 1) vs. using the command line interface (option 2).

API Support for Pixelcade LED and Pixelcade LCD

All V1 REST APIs will function on Pixelcade LED. For Pixelcade LCD, the following V1 API limitations apply and also note the additional V2 APIs below that only apply to LCD.

  • Substitute pixelcadedx-xxxxxxxx.local for localhost for all API calls where xxxxxxxx is a unique ID for each Pixelcade LCD
  • Loop commands and the Queue feature will not work with LCD so just omit the loop parameter when using the API with LCD.
  • Animations are not supported
  • Scrolling text is supported but will continuously loop until the next API call is received. Font size, speed, number of lines, and offset are not supported.
  • localplayback is not supported
  • quit, reboot, and shutdown are supported
  • Only streaming, no writes
  • Add the URL param &ledonly if you want the command to only display on Pixelcade LED and not be relayed to Pixelcade LCD

Option 1: V1 REST API

The Pixelcade Listener is launched via pixelweb.exe (for Windows) or java -jar pixelweb.jar (Pi & Mac). Use the -s parameter to launch pixelweb without console messages and logging (pixelweb.exe -s) to improve performance. Without the -s parameter, logging is enabled to pixelweb.log.

Note be sure you have the latest version of the Pixelcade software to guarantee all of the below APIs are included.

REST Command

Result

All the examples below refer to localhost but you may also use the ip address or dns name. For example, http://pixelcade.host:8080 or http://192.168.1.206:8080)

 

http://localhost:8080/arcade/[stream or write/[console name]/[rom name]

Displays a console/emulator specific PNG or GIF. If the console specific PNG or GIF does not exist, displays the default marquee or displaying scrolling text if ?t=[alt-scrolling-text] was specified.

Stream or write a PNG (still image) or GIF animation to the LED marquee. In write mode, the PNG or GIF will continue to display after the Pixelcade listener has been shutdown. Write includes a physical write to the microSD card on the PIXEL board and then the PNG or GIF is playing back locally with no dependency on the PC or Pi. With stream mode , the Pixelcade listener must be running. Stream mode playback is instant while there is a delay with write. 

Note if both a PNG and a GIF exist for the same game, the GIF will play first and then the PNG.

Some games have multiple GIFs (the LED art pack adds more multiple GIFs) like for example:

qbert_01.gif

qbert_02.gif

qbert_03.gif

If there is a multiple GIF as defined by the naming convention game_0x.gif, then Pixelcade will pick one of them at random per each API call and then land on the game PNG (ex. qbert.png). The default is three possible variations but this can be overriden in settings.ini with this setting: MaxAnimationVersions=3

Here is the path of the default marquee which can be changed by the user: <pixelcade home folder>/console/default-marquee.png

http://localhost:8080/console/stream/[console-name]?t=[alt-scrolling-text]

Displays a console/emulator specific PNG or GIF. If the console specific PNG or GIF does not exist, displays the default marquee or displaying scrolling text if ?t=[alt-scrolling-text] was specified

The same optional text parameters (font, size, lines, yoffset, etc.) can be used here too.

http://localhost:8080/quit

Shuts down the Pixelcade listener

http://localhost:8080/reboot

Raspberry Pi or Pixelcade LCD: Reboots the OS

http://localhost:8080/shutdown

Raspberry Pi or Pixelcade LCD: Shuts down the OS

http://localhost:8080/localplayback

Puts Pixelcade into local playback mode meaning it will play the last png or gif that was written to it’s microSD card

http://localhost:8080/arcade/stream/black/dummy

Blanks out the LED marquee

http://localhost:8080/text?t=<Your%20Scrolling%20Text%20Here>

Send scrolling text. Make sure to add %20 for all spaces.

http://localhost:8080/text?t=[scrolling-text]&c=[color]&s=[speed]&font=[font name]&size=[font size]&lines=[number of lines]&yoffset=[offset number]&loop=[number of times to loop scrolling text]

?t=[your text] is required, the rest of the parameters are optional. ?t=hello world will scroll the text “Hello World”

&c=[color] changes the scrolling text color. Possibles values are: red, blue, cyan, gray, darkgray, green, lightgray, magenta, orange, yellow, pink, and white. &c=green or &color=green will change the text to green.

Hex color values may also be entered in 6 digit format without the # sign. &c=45B39D for example

For scrolling speed, smaller number means faster scrolling. Range 10 – 150. &s=10 for example

The color will default to red if no color is specified or if an invalid color is specified. Of if a color is not specified and random is specified as the default color in settings.ini, then a random color will be used.

New TTF (TrueType) fonts can be added to the /fonts folder. Specify the TTF font name, not the file name. Example font names are “Handwriting”, “Tall Films Fine”, and “Haunting Attraction”. The default font is “Arial Narrow 7”.

Font size ranges are typically 14 – 32. &size=20 would change the font size to 20. Default font size is 28.

lines can be 1, 2, or 4. &lines=4 would change to 4 lines of text. If 2 or 4 is selected, the font and font size will be over-riden.

As some fonts will not center vertically correctly, the yoffset parameter can be used to adjust. &yoffset=-4 for example will move the text up by 4 pixels and &yoffset=4 will move the text down by 4 pixels.

Displays scrolling text for x loops. See the Queue feature described below for more info on the queue works.  Ex. &l=5 will loop the scrolling text 5 times.

Note if the text is shorter than the length of the display (Pixelcade is 132 pixels wide for example), then the text will not scroll.

If LCDLEDCompliment=yes in settings.ini (this is the default), then the additional param &led is sent to the LCD call which then tells Pixelcade LCD not to scroll text since there is already a Pixelcade LED that is scrolling text. Ex. http://pixelcadedx-xxxxxxxx:8080/text?t=Now Playing Pacman&led 

http://localhost:8080/arcade/stream/[console name]/[rom name]?t=[alt-scrolling-text]

If a matching PNG or GIF image is not found, then display scrolling text (Ex. Game Playing Asteroids Deluxe)

The same optional text parameters (font, size, lines, yoffset, etc.) can be used here too.

http://localhost:8080/arcade/stream/[console name]/[rom name]?l=x

Loops a GIF animations x times or displays a still image PNG for x seconds

QUEUE FEATURE

If another loop command (GIF, PNG, or scrolling text) is sent while in the current loop, that next loop command will be sent to a Queue for playback after the current loop command has finished. The Queue can contain an unlimited number of commands in any combination of GIF animations, still PNG images, and scrolling text. 

To abort and clear all items in the Queue, simply send a new command that does not contain the loop parameter (&l=x) or send a write command. This command will immediately take priority, start, and empty the Queue.

Note that the display will be cleared / blanked out after the last loop command in the Queue has finished unless a loop value of 99999 is specified which tells Pixelcade to let the previous Queue item finish and then will stay on the last PNG or GIF until its interrupted. 

If using the Queue feature in a custom script, ensure all your calls have the additional param &event=FEScroll

http://localhost:8080/arcade/stream/[console name]/[rom name]?t=[scrolling text]&l=[number of times to loop the GIF or seconds if a PNG]&color=[text color]&cycle

CYCLE MODE

Cycle indefinitely between a GIF or PNG and scrolling text.  A typical use case would be launching a game and then displaying a marquee for say 5 seconds and then scrolling high scores and then back to the marquee. If the target is a PNG, the PNG will display for x seconds where x is the loop param. If the target is a GIF, the GIF will loop only 1 time. The text will always scroll only one time before cycling back to the PNG or GIF.  To interrupt the cycle, you must send another API command without a loop parameter.

Example:

http://localhost:8080/arcade/stream/mame/pacman?t=High%20Socres%20Al%20200,000%20Erin%203,000&l=1&color=green&cycle

http://localhost:8080/arcade/stream/[console name]/[rom name]?event=[Arcade Front End Event Flag]

Possible Values:

  • FEStart
  • FEScroll
  • GameStart
  • FEScreenSaver
  • FEQuit

ARCADE FRONT END EVENT FLAGS

For arcade front ends integrating with Pixelcade, it’s highly recommended to add events flag to each API call as this gives Pixelcade context enabling Pixelcade to know if the event is coming from front end scrolling or a game launch for example. 

  • FEStart – when your front end is launched (optional)
  • FEScroll – when scrolling through games (wheels for example) through the front end but not actually launching the game (required)
  • GameStart – launching the game (required)
  • FEScreenSaver (optional)
  • FEQuit – when exiting your front end (nice to have)

Note: case sensitive

Example:

http://localhost:8080/arcade/stream/mame/pacman?event=FEScroll

http://localhost:8080/ticker?start

http://localhost:8080/ticker?stop

TICKER MODE

Starts and stops a scrolling text ticker based on content from RSS feeds. Up the 5 RSS feed sources can be configured and are defined in Pixelcade’s settings.ini. The ticker will stop automatically when any arcade call is sent or when the ticker stop command is called.

http://localhost:8080/achievements/stream/[console name]/[achievement_id]?t=[achievement_scrolling_text&currentgame=[rom name]

ACHIEVEMENTS

This API is specifically for integration with RetroAchievements , here is an example

If a PNG or GIF matching the achievements ID file name exists in <your Pixelcade folder>/achievements , then that file will play , then followed by the achievements scrolling text for 1 loop, and then lastly the game marquee will display that matches the console and rom name. If the achievements ID file does not exist (which will be the more common case), then a random animation (between 10 animations) will display, then the achievements scrolling text, and then the game marquee. 

Example:

http://localhost:8080/achievements/stream/coleco/177575?t=”First Flight : Clear 3 rounds of Skill Level 1″&currentgame=zaxxon

http://localhost:8080/text?t=&l=x

Displays scrolling text for x loops. The Queue feature described above applies also to scrolling text with the loop parameter.

http://localhost:8080/animations/stream/[file name]

Streams or writes an animation that exists in the /animations/gifsource folder. Add the parameter ?r to return a random animation. 

http://localhost:8080/animations/list

Returns a list of animation names from /animations

http://localhost:8080/still/list

Returns a list of single frame image names from /images

http://localhost:8080/arcade/list

Returns a list of mame game names from /mame

http://localhost:8080/currentgame

Returns the name of the last game selected in the format console%game-name Ex. mame%pacman

Examples

REST Call

Result

http://localhost:8080/arcade/stream/Atari%202600/pacman

Streams the pacman PNG or GIF for the Atari 2600 console

http://localhost:8080/arcade/stream/nes/WURM%20-%20Journey%20to%20the%20Center%20of%20the%20World(U).zip

Streams Journey to the center of the World for the NES console

http://localhost:8080/arcade/stream/mame/milliped

Streams Millipede for the MAME console

http://localhost:8080/arcade/write/mame/1942

Writes 1942 for the MAME console

http://pixelcade.local:8080/console/stream/nes

Streams the default console marquee for nes. Also note that pixelcade.local is used here vs. localhost where pixelcade.local is the host name of a Raspberry Pi on your Wifi network that has been configured for Pixelcade.

http://localhost:8080/text?t=Hello%20World

Scrolls Hello World text

http://localhost:8080/text?t=Hello%20World&c=ff6d00

Scrolls Hello World text in light orange (hex color code)

http://localhost:8080/text?t=Game%20Playing%20Pacman&l=1&c=yellow&s=50

http://localhost:8080/arcade/stream/mame/pacman

Streams “Game Playing Pacman” in yellow one time in a slower speed of 50 and then sets the still image pacman PNG indefinitely

http://localhost:8080/text?t=Game%20Playing%20Pacman&l=1&c=blue

http://localhost:8080/arcade/stream/mame/pacman.png?l=3

http://localhost:8080/arcade/stream/mame/pacghosts.gif?l=2

Streams “Game Playing Pacman” in blue one time, then displays pacman PNG for 3 seconds, then loops the pacghosts GIF two times, and then clears the display blank.  

http://localhost:8080/arcade/stream/mame/Missing-Game?t=Game%20Playing%20Missing-Game&c=green

If missing-game.png or missing-game.gif does not exist, scrolls the text “Game Playing Missing Game” in green indefinitely

http://localhost:8080/arcade/stream/mame/Missing-Game?t=Game%20Playing%20Missing-Game&l=1

If missing-game.png or missing-game.gif does not exist, scrolls the text “Game Playing Missing Game” one time

http://localhost:8080/text/color/green

Changes scrolling text color to green

http://localhost:8080/text/speed/50

Changes scrolling text speed to 50. Smaller number is faster scrolling and larger number is slower scrolling. Range: 10 – 150

http://localhost:8080/arcade/write/user/

For non arcade use cases, you can use all the above features of the API and place your PNG or GIF files in the pixelcade install directory/user

http://localhost:8080/animations/stream/0rain

Streams the 0rain.gif file in the animations folder

http://localhost:8080/animations/stream/0rain?l=3

Streams the 0rain.gif file in the animations folder 3 times

curl -i -X POST -H "Content-Type: multipart/form-data" -F "upload=@/Users/al/artwork/galaga.png" -F "upload-type=STILL_IMAGE" http://localhost:8080/upload

Using Curl or libcurl, uploads a PNG to $HOME/pixelcade/images

curl -i -X POST -H "Content-Type: multipart/form-data" -F "upload=@/Users/artwork/pacman.gif" -F "upload-type=ANIMATED_GIF" http://localhost:8080/uploadUsing Curl or libcurl, uploads a GIF to $HOME/pixelcade/animations
curl -i -X POST -H "Content-Type: multipart/form-data" -F "upload=@/Users/al/artwork/pacman.PNG" -F "upload-type=STILL_IMAGE" -F "console=alu" -F "displaynow=0" http://localhost:8080/uploadplatformUsing Curl or libcurl, uploads a PNG to $HOME/pixelcade/ALU but doesn’t stream/display the PNG
curl -i -X POST -H "Content-Type: multipart/form-data" -F "upload=@/Users/al/artwork/pacman.gif" -F "upload-type=ANIMATED_GIF" -F "console=MAME" -F "displaynow=1" http://localhost:8080/uploadplatformUsing Curl or libcurl, uploads a GIF to $HOME/pixelcade/mame AND streams/displays the GIF

Note the URL cannot contain spaces and cannot accept a full rom file path, just include the rom name (ex. 1942.zip) or the rom name without extension (Ex. 1942) 

Option 2: pixelcade.exe or pixelcade.jar command line

usage: pixelcade

                    -m,–mode <arg>  Sets stream or write mode, options are stream or write

                    -c,–console <arg>  Sets the console or platform name, ex. mame, atari2600, nes

                    -g,–game <arg>  Sets game / rom name, can be a full path, file name,

                        or just the basename without the extension

                     -s, –silent Disables console message and logging, log file is pixelcade.log

                      -t “your scrolling text” Must enclose in quotes

                     -color <color>   Scrolling text color, possibles values are: red, blue, cyan, gray, darkgray, green, lightgray, magenta, orange, yellow, pink, and white. Default: red

                      -speed <speed> Changes scrolling text speed. Smaller number is faster scrolling and larger number is slower scrolling. Range: 10 – 150

                  -loop <# times to loop> Loops and Queue Feature

                    -q,–quit  Shuts down Pixelcade listener (pixelweb.exe or pixelweb.jar)

                    -h,–help  show help.

 

VERY IMPORTANT: Enclose any parameters with spaces in double quotes. For example Atari 2600 must be enclosed in double quotes.

Command

Result

pixelcade.exe -m stream -p "Atari 2600" -g Rampage.bin

Streams the Rampage game PNG or GIF for the Atari 2600 console for a Windows PC

pixelcade.exe -m write -p mame -g d:\roms\pacman.zip

Writes the pacman game on the MAME console for a Windows PC

pixelcade.exe -q

Sends shutdown command to the Pixelcade Listener (pixelweb)

java -jar pixelcade.jar -m stream -p c64 -g "Video Vermin (World).zip" 

Streams the Video Vermin game on the C64 console for a Raspberry Pi or Mac

java -jar pixelcade.jar -m write -p "Nintendo Entertain System" -g "Zelda II - The Adventure of Link (U).zip"

Writes the Zelda II – Advaneture of Link game for the NES console for a Raspberry Pi or Mac

pixelcade.exe -t "hello world" -l 3 -color green

Scrolls text “hello world” 3 times in green

pixelcade.exe -m stream -c mame -g pacghosts.gif -l 2

Loops the pacghosts GIF animation two times

java -jar pixelcade.jar -m stream -c mame -g pacghosts.gif -l 2

java -jar pixelcade.jar -t "hello world" -l 3 -color green

java -jar pixelcade.jar -t "cats are nice" -l 3 -color ff00ff

Loops the pacghosts GIF animation two times, then scrolls “hello world” 3 times in green, and then scrolls “cats are nice” 3 times in hex color ff00ff

pixelcade.exe -m stream -c mame -g GameX -t "Playing GameX" -color green

If a PNG or GIF does not exist for GameX, scrolls text “Playing GameX” in green indefinitely 

pixelcade.exe -m stream -c mame -g GameX -t "Playing GameX" -l 1

If a PNG or GIF does not exist for GameX, scrolls text “Playing GameX” one time

pixelcade.exe -m stream -c user -g

For non arcade use cases, you can use all the above features of the API and place your PNG or GIF files in the pixelcade install directory/user

Pixelcade LCD V2 API

These additional V2 APIs only apply to Pixelcade LCD and will NOT function on Pixelcade LED. These APIs for example are used by the Pixelcade Companion web application.

Note that each Pixelcade LCD has a unique 8-digit ID so replace all calls with the unique of the target Pixelcade LCD. You can find the unique ID in the Pixelcade settings.ini file after it’s been paired or also in the Pixelcade iOS app. For example a given Pixelcade LCD has the unique ID of: f26967ec , then use for API calls:

pixelcadedx-f26967ec.local:8080
::Pixelcade Device Info::
/v2/info/
GET Returns a PixelcadeLCD object with specifications of the Pixelcade

Sample:
http://pixelcadedx-xxxxxxxx.local:8080/v2/info
{
"name": "Tricks \u0027n Lies",
"hostname": "pixelcadedx-xxxxxxxx",
"firmwareVersion": "2.9.0.9",
"resolution": {
"width": 1920,
"height": 360
},
"isPaired": false,
"hasJoinedNetwork": true
}
::Pixelcade Pairing::
/v2/utility/pairing/
GET Returns the current pairing state

Sample:
http://pixelcadedx-xxxxxxxx.local:8080/v2/utility/pairing/
{
 "succeeded" : true,
 "message" : "paired"
}

/v2/utility/pairing/set/on
GET Sets the system Pairing state to Paired. Returns a Status object
Sample:
http://pixelcadedx-xxxxxxxx.local:8080/v2/utility/pairing/set/on
{
 "succeeded" : true,
 "message" : "Device now set to Paired"
}
/v2/utility/pairing/set/off
GET Sets the system Pairing state to UnPaired. Returns a Status object
Sample:
http://pixelcadedx-xxxxxxxx.local:8080/v2/utility/pairing/set/off
{
 "succeeded" : true,
 "message" : "Device is now UnPaired"
}
::Pixelcade Default Marquee::
/v2/utility/marquee/set/:default marquee number [1,2,3]
GET Sets the system default marquee to one of the 3 options. Returns a Status object
NB - all other paths are rejected
Sample:
http://pixelcadedx-xxxxxxxx.local:8080/v2/utility/marquee/set/2 
{
 "succeeded" : true,
 "message" : "New Default Set@2"
}
::Pixelcade Dot Display Scores::
/score?s=<game score>
Sends a score to the Pixelcade Dot sub-displays only. The Pixelcade Dot sub-display can be of matrix or 7segment type. 
The score will not scroll if under 8 characters although the matrix type can also be 4 characters.
Technically text can also be sent here too in addition to numbers.
Note that not all text characters will render on the 7segment display. Sample: http://pixelcadedx-xxxxxxxx.local:8080/score?s=1000 score request received: 1000
Video Demo
::Marquee Thumbnails::
/v2/thumbnails/:system/:marquee
GET Returns a 640px wide thumbnail JPEG of the requested marquee as `image/jpg` type/data.
Endpoint Note - any non-2xx response should be checked for a Status Object explaining why the call failed.
:system denotes the api-level known system name, console, or system/category.
:marquee denotes the known "rom name" or "game title" and can be learned from the 'consoles' endpoint.
Sample:
http://pixelcadedx-xxxxxxxx.local:8080/v2/thumbnails/mame/deathsml
Result: jpg of marquee
::Marquee Editing::
/v2/marquees/:system/:marquee/display
POST Displays the received JPG as the Marquee for game path, temporarily. Returns as Status Object
NB: The *required* 'Content-Type' for these requests is 'image/jpg'. All others will be rejected.
Additionally, all images will be resized to the display's native resolution
Sample:
curl -X POST -H "Content-Type: image/jpg" "http://pixelcadedx-f26967ec.local:8080/v2/marquees/mame/blazstar/display" --data-binary "@blazstar.jpg"

Result:
{
"success": true,
"message": "Marquee Displayed."
}

/v2/marquees/:system/:marquee/save
POST Displays the received JPG as the Marquee for game path and saves/replaces it. Returns as Status Object

Sample:
curl -X POST -H "Content-Type: image/jpg" "http://pixelcadedx-f26967ec.local:8080/v2/marquees/mame/blazstar/display" --data-binary "@blazstar.jpg"

Result:
{
"success": true,
"message": "Marquee Updated."
}

/v2/marquees/:system/:marquee/undo
POST Reverts the Marquee for game path to previous version. Returns as Status Object
NB: There is one "level" of Undo. Intent is to revert a "just changed" marquee.
POST empty data to the /undo path

Sample:
curl -X POST -H "Content-Type: image/jpg" "http://pixelcadedx-f26967ec.local:8080/v2/marquees/mame/blazstar/undo" Result:
{
"success": true,
"message": "Marquee Reverted."
::Attract Mode::
/v2/utility/attractmode/timeline/
GET Returns the currently set Timeline object

Sample:
http://pixelcadedx-xxxxxxxx.local:8080/v2/utility/attractmode/timeline/
{
"isPlaying": false,
"media": [
{
"marqueeName": "pacman",
"delay": false,
"playVideo": true,
"playGIFs": false
},
{
"marqueeName": "blazstar",
"delay": true,
"playVideo": true,
"playGIFs": false
},
{
"marqueeName": "Legendary Axe I",
"delay": true,
"playVideo": true,
"playGIFs": false
},
{
"marqueeName": "Mario_Kart_8",
"delay": true,
"playVideo": true,
"playGIFs": false
},
{
"marqueeName": "blktiger",
"delay": true,
"playVideo": true,
"playGIFs": false
}
]
}

/v2/utility/attractmode/timeline/
POST Sets the Attract Mode Timeline to the provided Timeline object. Returns a Status object
NB call must set type to application/json for data sent

Sample:
curl -X POST -H 'content-type: application/json' http://pixelcaded-xxxxxxxxx.local:8080/v2/utility/attractmode/timeline/ \
-d @timeline.json
{
 "succeeded" : true,
 "message" : "Timeline set: 5 Items"
} /v2/utility/attractmode/timeline/play/
GET Starts playback of currently set Timeline. Returns Status objectSample:
http://pixelcadedx-xxxxxxxx.local:8080/v2/utility/attractmode/timeline/play/
{
 "succeeded" : true,
 "message" : "Starting timeline playback"
} /v2/utility/attractmode/timeline/stop/
GET Stops playback. Returns Status object

Sample:
http://pixelcadedx-xxxxxxxx.local:8080/v2/utility/attractmode/timeline/stop/
{
"success": "Stopping timeline playback"
}
:: System and Artwork Update::
/update
Pixelcade LCD Update Started
Please wait until your see the Update Complete message on your Pixelcade before doing anything else
Note: This initiates a bash shell update script that will check for new artwork and new firmware from a private GitHub repo

Sample: http://pixelcadedx-xxxxxxxx.local/update
::Settings::

settings?key=marqueeOverlays&value=no
Marquee Overlays Disabled
settings?key=marqueeOverlays&value=yes
Marquee Overlays Enabled

settings?key=SubDisplayScrollingOnly&value=no
Set to scroll text on both Pixelcade LCD and Pixelcade Dot Sub-Display
settings?key=SubDisplayScrollingOnly&value=yes
Disables scrolling text on LCD, text will only scroll on LED (if connected) or Pixelcade Dot Sub-Displays (if connected)

settings?key=ImageMarqueesOnly&value=no
Disables video snaps meaning only still image JPG marquees will be displayed
settings?key=ImageMarqueesOnly&value=yes
Enables video snaps

settings?key=font&value=<user selected font>
font changed to <user selected font>
Note the font must match one of the following or will return an error: 
{"Orbitron-SemiBold","Orbitron-Regular", "Eight-Bit-Madness", "Arial Narrow 7", "Benegraphic", "Candy Stripe (BRK)", "Casio FX-702P","Daddy Longlegs NF", "Decoder", "DIG DUG", "dotty", "DPComic","Early GameBoy","Fiddums Family", "Ghastly Panic", "GilbertC", "Gnuolane", "Grapevine", "Grinched", "Handwriting", "Harry P", "Haunting Attraction", "Minimal4", "Morris Roman", "MostlyMono", "Neon 80s", "Nintendo DS BIOS", "Not So Stout Deco", "Paulistana Deco", "Pixelated", "Pixeled", "RetroBoundmini", "RM Typerighter medium", "Samba Is Dead", "Shlop", "Space Patrol NF", "Star Jedi Hollow", "Star Jedi", "Still Time", "Tall Films Fine", "taller", "techno overload (BRK)", "TR2N", "TRON", "Vectroid", "Videophreak"};

settings?key=UseConsoleMapping&value=no
Set to NOT to use server side console mapping and instead use the console mapping from the local pixelcade running on your arcade front end devuce (this is the default behavior)
settings?key=UseConsoleMapping&value=yes
Set to use server side console mapping. Note only use this option if your arcade front end is making direct calls to Pixelcade LCD without using a local console.csv mapping function (this is uncommon)

settings?key=textColor&value=<user selected text color>
Scrolling text color changed to: <user selected color>
Note valid colors are: 
{ "random", "red", "cyan", "darkgray", "lightgray","orange","yellow","blue","gray","green","magenta","pink","white"}

settings?key=DisplayName&value=<New Pixelcade LCD Name>
Pixelcade LCD named changed to: <<New Pixelcade LCD Name>

settings?key=SetSubDisplayNumModules&value=<4 or 8>
Pixelcade Dot Sub-Display Set to <4 or 8> modules
Note: Value can only be 4 or 8

settings?key=PixelcadeDotType&value=<matrix or 7segment>
Sets Pixelcade Dot Sub-Display type to matrix or 7 segment
Note: Value can only be matrix or 7segment settings?key=getSettings Returns of a JSON of current settings: {"font":"Neon 80s","SubDisplayScrollingOnly":false,"ImageMarqueesOnly":false,"SubDisplayNumModules":"8","FontColor":"751d7d","consoleMapping":false,"marqueeOverlays":true} Samples: http://pixelcadedx-xxxxxxxx.local:8080/settings?key=ImageMarqueesOnly&value=yes http://pixelcadedx-c5d7aa96.local:8080/settings?key=getSettings
http://pixelcadedx-c59b51ea:8080/settings?key=PixelcadeDotType&value=7segment

API Notes:


As a “rule” all endpoints in the v2 api return JSON objects. The Api standard/default object returned is the Status Object, currently defined as:

{
"succeeded":
"message":
}

Sample:
{
 "succeeded" : false,
 "message" : "It broked :("
}

All API requests to any endpoint should check the HTTP-Response for a non 200-range response, as an indicator of if the call succeeded with the expected results returned, or if a Status Object with an error message was returned, per the “standard practices”

Customizing

Customizing the Startup Marquee

To customize the default marquee, edit the settings.ini file that is located in your Pixelcade folder. Ensure startupLEDMarquee=yes and change startupLEDMarqueeName to your desired startup logo (ex. yourlogo.png) and place this file in the <Pixelcade Installation Folder >/system folder.

Note though that once your respective arcade front end takes over (Big Box, HyperSpin, RetroPie, etc), this startup log will be replaced by whatever the front end sends to Pixelcade.

startupLEDMarquee=yes
startupLEDMarquee_OPTION=no
startupLEDMarquee_OPTION=yes
startupLEDMarqueeName=yourlogo

Pixelcade and API Source Code

LED V1 API Source Code https://github.com/alinke/PIXEL/tree/wip (see the pixel-web-enabled folder)