+* [Programmers](#programmers) +* **[How to install](#how-to-install)** + - [Boards Manager Installation](#boards-manager-installation) + - [Manual Installation](#manual-installation) +* **[Getting started](#getting-started)** + +* **[Digging deeper](#digging-deeper)** + - [Hardware Abstraction Layer](#hardware-abstraction-layer) + +## Programmers + +Since there is no bootloader in a tile, all code must be programmed rather than downloaded. + +Each Blink has a standard 6-pin ISP connector. The arrow marks pin #1. + +You can use any AVR programmer supported by AVRDUDE and the Arduino IDE. + +This one is cheap... +http://amzn.to/2u5ZHw6 + +This one is fast and comes with nice cables... +http://amzn.to/2u5Wo7M + +Just connect your programmer and select it in the "Programmers" menu, and connect the 6-pin ISP to the tile. I like to use this pogo pin fixture to make the connections... + +https://www.sparkfun.com/products/11591 + +...but you can also just hold a 6-pin header onto the tile, or solder on a 6-pin header if you want to leave the programmer attached. + +If you do not have a programmer, you can also use an Arduino and a couple of wires. + +You can then use the "Sketch-Upload to Programmer" menu choice or just press the Play button to compile your code and program it into the connected tile. (Both the menu option and the button do the same thing with a tile.) + +## How to install +Click on the "Download ZIP" button in the upper right corner of this repo on Github... + +https://github.com/bigjosh/Move38-Arduino-Platform + +You can switch to the `dev` branch if you want to live on the bleeding edge and get new features quickly. + +Extract the ZIP file, and move the extracted files to the location "**~/Documents/Arduino/hardware/Move38-manual/avr**". Create the folder if it doesn't exist. This readme file should be located at "**~/Documents/Arduino/hardware/Move38-manual/avr/README.md**" when you are done. + +Open Arduino IDE, and a new category in the boards menu called "Move38-manual" will show up. + +##### Notes + +* We called the "vendor/maintainer" folder `Move38-manual` so that you can also use the boards manager and you will be able to tell the two apart in the boards menu. + +* You must manually create the `avr` folder and you must also manually move the files out from this repo into this folder. We could not automatically have the folds inside the repo match the Arduino required folder layout because in in the boards manager, the architecture is in the JSON file rather than the folder structure. Arg. + +* The "**~/Documents/Arduino/hardware/Move38-manual/avr**" folder is a Git repo and is also set up for easy editing in Atmel Studio with a solution inside the `\AS7` sub-folder. + +* If you want to leave the git repo in a directory that is not inside the Arduino tree (I do), then you can add a directory symlink from the Arduino tree to the repo tree. This repo needs to be at `arduino\hardware\move38\avr` where `arduino` is your Arduino home directory as set in `File->Preferences->Sketchbook Location` in the IDE. You have to manually create `hardware` and then `move38` and then put the `avr` symlink in then. On my windows machine the command for that was `D:\Documents\Arduino\hardware\move38\avr>mklink /D avr "D:\Github\Move38-Arduino-Platform"` + +## Helllo Blink! + +* Open the **Tools > Board** menu item, and select `Blink` from the `Move38` submenu. +* Select what kind of programmer you're using under the **Programmers** menu. +* Select "File->Examples->Examples for Blink->Getting Started" and choose "F-ColorWheel". +* Hit the Play button. + +The IDE should compile the code and program the Blinks tile... and you should see pretty blinking lights! diff --git a/Layers.md b/Layers.md new file mode 100644 index 00000000..7887b605 --- /dev/null +++ b/Layers.md @@ -0,0 +1,50 @@ +## Layers + +### 1. Cold power up + +This typically only happens when a new battery is installed or when the foreground software locks up. + +The chip resets all the ports according to the the datasheet and then jumps to the reset vector, which typically points to the GCC bootstrap code. This code initializes global variables and does a bit of hardware setup. + +Here is an example on how to run code before the bootstrap (very esoteric)... + +https://github.com/bigjosh/Ognite-firmware/blob/master/Atmel%20Studio/Candle0005.c#L440 + +### 2. main() + +After all the C setup is complete, the bootstrap jumps to the `main()` function. This function is in `cores/blinkcore/main.c` + +Here we... + +1. Initialize the binks hardware systems and turn them on. +2. Jump to the `run()` function. +3. Re-run `run()` forever if it returns. + +The blinks `main()` function is weakly defined, so you can make your own if you want to take over before the blinks hardware gets started up. + +### 3. run() + +Once all the hardware is up and running, then `run()` function takes over. This code lives in `libraries\blinklib\src\blinklib.cpp`. + +Here we... + +1. Call the user-supplied `setup()` function. +2. Repeatedly... + a. Clears the cached `millis()` snapshot + b. Calls the user-suppled `loop()` function + c. Atomically updates the values shown on the LEDs to match any changes made in `loop()` + d. Processes new IR data that has been recieved, and potentially sends IR data. + + +Then `run()` function is weakly defined, so you can override it if you want more control over these. + +### 4. `setup()` and `loop()` + +These are the idiomatic entry points provided by Arduino sketches. + +`setup()` is called once, typically right after a tile has had a battery change. + +`loop()` is called at the current frame rate, which is currently about 18 times per second. You `loop()` function should complete before the next frame starts, so should not have any blocking code in it. The tile sleeps for the time between when `loop()` returns and the next frame, so the faster you can complete your work and return from loop, the longer batteries will last. + + + \ No newline at end of file diff --git a/Production.MD b/Production.MD new file mode 100644 index 00000000..24bbbc62 --- /dev/null +++ b/Production.MD @@ -0,0 +1,75 @@ +## Production Programming + +Each virgin blink needs to be programmed with... + +1. The correct FUSE settings +2. The BIOS code that lives in the flash bootloader area +3. The application code that lives in the application flash area. + +### Fuses + +BOOTSZ = 1024W_1C00 +BOOTRST = [X] +RSTDISBL = [ ] +DWEN = [ ] +SPIEN = [X] +WDTON = [ ] +EESAVE = [ ] +BODLEVEL = DISABLED +CKDIV8 = [X] +CKOUT = [ ] +SUT_CKSEL = INTRCOSC_8MHZ_6CK_14CK_65MS + +EXTENDED = 0xF8 (valid) +HIGH = 0xDF (valid) +LOW = 0x62 (valid) + +Note that the `high` and `low` fuses are the same as their default values from the factory, but the `extended` fuse must be reprogrammed from the default value. + +### Bootloader + +The bootloader code comes from a different repo and can be found in the [`bootloaders`](/bootloaders) directory here. + +### Application + +The application code is generated by compiling a sketch in the Arduino IDE. + +## Combining the bootloader and application + +You can minimize the number of production programming steps by combining the application code and bootloader into a single HEX file using the `Sketch->Export Compiled Binary` option from the IDE menus. This will create a file called `SKETCHNAME.ino.with_bootloader.standard.hex` in the current sketch folder that contains both the application and the bootloader. + +### Example + +Here is and example command that will program a blink using the `AVRDUDE` utility and the `USBtiny` programmer... + +``` +avrdude -B 5 -v -patmega168pb -cusbtiny -Uflash:w:SKETCHNAME.ino.with_bootloader.standard.hex:i -Uefuse:w:0xf8:m -u +``` + +`-B` sets the clock programming speed. This must be less than 1/4 of the chip clock speed, which is 1Mhz by default, but here we make it slightly slower to account for chips that might have an extra slow internal clock. +`-v` verifies the programming when complete +`-p` specifies the chip model +`-Uflash` specifies the file to program into flash memory (both bootloader and application in this case) +`-Uefuse` specifies the new value for the extended fuse (note that the high and low fuses are left with their default values) +`-u` disables AVRDUDE's normal behavior that blocks changing fuses. + +Note that this assumes that `avrdude` is in your search path and that it can find its config file. See `avrdude` docs for details. + +### Optimizing + +We can slightly reduce cycle using a command like this... + +``` +avrdude -B 4 -D -v -patmega168pb -cusbtiny -Uflash:w:D-TimerFlashX.ino.with_bootloader.standard.hex:i -Uefuse:w:0xf8:m -u +``` + +`-D` skips erasing the flash before programming it. If you are programming virgin chips then the flash should be blank. +`-B` lowered to 4 slightly increases the programmer clock. Some out of spec chips might fall to program at this speed. + +Note that these new options are both safe because the verify will fail if anything goes wrong. + +### QA + +Some programming errors may pass functional testing, but still contain latent errors, so you must check that the programming cycle verified successfully before passing a programmed unit. + +You can use the error code returned by AVRDUDE to check if the verify succeeded. \ No newline at end of file diff --git a/README.md b/README.md index f979f876..2a8cb374 100644 --- a/README.md +++ b/README.md @@ -2,24 +2,25 @@ An Arduino core for the Blinks gaming tile. More info at... http://move38.com +## Roadmap This core requires at least Arduino IDE v1.6.2, where v1.6.5+ is recommended.
* [Programmers](#programmers) * **[How to install](#how-to-install)** * **[Getting started](#getting-started)** -* **[Digging deeper](#digging-deeper)** - - [Hardware Abstraction Layer](#hardware-abstraction-layer) +Covers installing this repo so that you can write and download code into a Blinks tile using the Arduino IDE. -## Programmers +Ends with loading a `HelloBlink` program it a tile. -Since there is no bootloader in a tile, all code must be programmed rather than downloaded. +### Writing games -You can use any AVR programmer supported by AVRDUDE and the Arduino IDE. +The best way to start writing games is to work your way though the examples in the "File->Examples->Examples for Blink Tile" menu in the Arduino IDE (after you have installed this repo as described in the Getting Started above). + -Just connect your programmer and select it in the "Programmers" menu, and connect the 6-pin ISP to the tile. If you do not have a programmer, you can also use an Arduino and a couple of wires. More detailed instructions to come. +### [Service Port](Service Port.MD) -You can then use the "Sketch-Upload to Programmer" menu choice or just press the Play button to compile your code and program it into the connected tile. (Both the menu option and the button do the same thing with a tile.) +Describes the service port connector on each blink. Lets you add `print` statements to your programs, which can be very helpful during development. ## How to install @@ -37,16 +38,11 @@ In the future, we'll offer a simplified Arduino Boards Manager install path. * The "**~/Documents/Arduino/hardware/Move38-manual/avr**" folder is a Git repo and is also set up for easy editing in Atmel Studio with a solution inside the `\AS7` sub-folder. -## Getting started with Move38 Blinks on Arduino +### API Layers -* Open the **Tools > Board** menu item, and select `Blinks` from the `Move38` submenu. -* Select what kind of programmer you're using under the **Programmers** menu. -* Select "File->Examples->Examples for Blink Tile" and choose "HelloBlink". -* Hit the Play button. +The blinks hardware can do incredible things, and you can have unfettered access to it at any level you want. This documents describes those layers from bare metal up. -The IDE should compile the code and program the Blinks tile... and you should see pretty blinking lights! -### Digging Deeper #### Hardware Abstraction Layer diff --git a/Service Port.MD b/Service Port.MD index 5bd44a1c..234ae3fd 100644 --- a/Service Port.MD +++ b/Service Port.MD @@ -10,6 +10,64 @@ Each Blink tile has a service port to make developing and debugging easier. For * See print statements * Accept type in values and commands -* Output precise timing signals to an oscilloscope +* Output precise timing signals to an oscilloscope + + +### Seeing output + +When writing normal game code, you can use the the service port as a serial connection to the host computer. + +#### Connection + +Get yourself a Blinks Dev Candy board, which converts the service port connector into a 6-pin header that connects to a USB serial converter like this... + +http://amzn.to/2ptPUv5 + +#### Use + +* Connect the USB serial port adapter to the computer +* Open Arduino IDE +* Pick the correct serial port from `Tools->Port` +* Open the monitor with "Tools->Serial Port Monitor" +* Pick `1000000 baud`. (Yes, it is that fast! :) ) + +You will now see anything that the tile prints out. + +You can also use any other serial monitor program with the same port and baud settings. + +#### Instrumentation + +The easiest way to get prints out the serial port is to use the `ServicePortSerial` class like this... + +~~~ +/* + * Prints a welcoming message to the servie port. + * + * To see the message, connect a serial terminal to the Blinks service port. + * More info on how to do that here... + * https://github.com/bigjosh/Move38-Arduino-Platform/blob/master/Service%20Port.MD + */ + +#include "Serial.h" + +ServicePortSerial Serial; + +void setup() { + + Serial.begin(); + +} + + +void loop() { + + Serial.println("Hello Serial port!"); + +}; +~~~ + +#### Input -*MORE INFO ON CONNECTION AND USE COMING* \ No newline at end of file +The Serial class also has several read functions that let you input data from the serial terminal. Check out the Tile World example to see one way to do this. + +Note that that by default Arduino serial monitor does not send what you type until you press enter. \ No newline at end of file diff --git a/boards.txt b/boards.txt index 70f97f67..d01eb81e 100644 --- a/boards.txt +++ b/boards.txt @@ -1,65 +1,46 @@ -########################################## -## -## This file to use the Move38 Blinks platform -## with the Ardiuno IDE -## http://move38.com -## -## Orginally based on ATMEGA168PA settings from MiniCore -## https://github.com/MCUdude/MiniCore -## -########################################## +# See: http://code.google.com/p/arduino/wiki/Platforms -tile.name=Blinks Tile -tile.upload.maximum_size=15872 -tile.upload.maximum_data_size=1024 +menu.cpu=Processor -# This line seems to have no effect? -tile.upload.tool=nothing +############################################################## -tile.program.tool=avrdude +blink.name=Blink -tile.build.core=blinkcore -tile.build.board=AVR_Blink -tile.build.variant=standard +blink.vid.0=0x2341 +blink.pid.0=0x0043 +blink.vid.1=0x2341 +blink.pid.1=0x0001 +blink.vid.2=0x2A03 +blink.pid.2=0x0043 +blink.vid.3=0x2341 +blink.pid.3=0x0243 +blink.upload.tool=avrdude +blink.upload.protocol=arduino -# Note that we actually boot up with DIV8 fuse programmed, so -# only running at 1Mhz. Then we switch the prescaller to /2 in init() -# so we are at 4Mhz by the time user code runs. -# This is done becuase 8Mhz might need a higher voltage than our battery can -# supply. +# This is the maximum size of a program image. It comes from +# `blinkbios.h` and is the result of `FLASH_PAGES_PER_IMAGE` * `FLASH_BYTES_PER_PAGE` +# Used only for printing the "Sketch uses... of program stroage space..." message. +blink.upload.maximum_size=5888 +blink.upload.maximum_data_size=1024 +blink.upload.speed=115200 -tile.build.f_cpu=4000000L +#blink.bootloader.tool=avrdude +#blink.bootloader.low_fuses=0xFF +#blink.bootloader.high_fuses=0xDE +#blink.bootloader.extended_fuses=0xFD +#blink.bootloader.unlock_bits=0x3F +#blink.bootloader.lock_bits=0x0F -tile.build.mcu=atmega168pb +# Note that the folder `bootloaders` seems to be hardcoded into the Ardunio IDE -tile.ltoarcmd=avr-gcc-ar +blink.bootloader.file=BlinkBIOS.hex +blink.build.mcu=atmega168pb +blink.build.f_cpu=8000000L +blink.build.board=AVR_BLINK +blink.build.core=blinklib +blink.build.variant=standard -# -------------------------------------------------------------------- -# This is tmeporary to support the old tiles without logos. Soon there will be none of them. +############################################################## -legacytile.name=Legacy No-Logo Blinks Tile -legacytile.upload.maximum_size=15872 -legacytile.upload.maximum_data_size=1024 - -# This line seems to have no effect? -legacytile.upload.tool=nothing - -legacytile.program.tool=avrdude - -legacytile.build.core=blinkcore -legacytile.build.board=AVR_Blink -legacytile.build.variant=legacy - -# Note that we actually boot up with DIV8 fuse programmed, so -# only running at 1Mhz. Then we switch the prescaller to /2 in init() -# so we are at 4Mhz by the time user code runs. -# This is done becuase 8Mhz might need a higher voltage than our battery can -# supply. - -legacytile.build.f_cpu=4000000L - -legacytile.build.mcu=atmega168pb - -legacytile.ltoarcmd=avr-gcc-ar \ No newline at end of file diff --git a/bootloaders/BlinkBIOS.hex b/bootloaders/BlinkBIOS.hex new file mode 100644 index 00000000..2209e6b1 --- /dev/null +++ b/bootloaders/BlinkBIOS.hex @@ -0,0 +1,280 @@ +:102E00000AB400FCFDCF90938900809388008AB5B6 +:102E100081608ABD08959B01F894409131015091E1 +:102E2000320160913301709134017894420F531F45 +:102E3000611D711DFC01408351836283738308957A +:102E4000CF93C62F7AD5882349F08DE55DD58C2F99 +:102E50005BD585E78C1B58D5CF9146C5CF9108959A +:102E6000CF92DF92FF920F931F93CF93DF93062FA2 +:102E7000F42E152F62D58823F1F08BED45D5CF2D9B +:102E8000D12F6E0180E2C80ED11C1BEDF9908F2D61 +:102E90003BD51F0DCC16DD06C9F7802F35D582ED49 +:102EA000801B811B31D5DF91CF911F910F91FF9036 +:102EB000DF90CF9019C5DF91CF911F910F91FF90B7 +:102EC000DF90CF900895CF93DF93C0E0D1E0DE0193 +:102ED000EC912E2F229526952695237011968C9194 +:102EE0001197982F9770990F990F922B8695869529 +:102EF0008695E695EF71F0E0EC5BF74CE491ED8799 +:102F0000E92FF0E0EC5BF74CE491EE87E82FF0E07E +:102F1000EC5BF74CE491EF871296249681E0AC309D +:102F2000B807B1F6DF91CF910895E0E0F1E011929A +:102F300082E0EE37F807D8F38091310190913201A9 +:102F4000A0913301B0913401805E9D4EA54FBF4FDB +:102F50008093360190933701A0933801B0933901E3 +:102F6000B2CFEDE4F1E0108212AA1092B1011092FA +:102F7000E30110921502109247020895F894EEE3CF +:102F8000F1E01182148216821582128611867894DD +:102F9000089582E00895FF920F931F93CF93DF93DC +:102FA000F62E072F142FC9D4882361F087E3ACD401 +:102FB000CF2DD02F112321F08991A6D41150FACF13 +:102FC00093D481E0DF91CF911F910F91FF900895ED +:102FD000182FC12FDE63DF738D2F90E0B5D52FEF53 +:102FE00080E792E0215080409040E1F700C000006F +:102FF000B8DF80E090E0A8D52FEF80E792E0215085 +:1030000080409040E1F700C00000ABDFC15021F0EC +:1030100080913F0180FFDECFC6E0C15021F080915A +:103020003F0180FF0CC080913F0180FFD2CFF89418 +:1030300080E18093600088E080936000FFCF80E0B3 +:1030400090E082D52FEF80E792E0215080409040C1 +:10305000E1F700C0000085DF80E090E075D52FEF3C +:1030600080E792E0215080409040E1F700C00000EE +:1030700078DFD3CF14BE0FB6F894A8958091600086 +:10308000886180936000109260000FBEC1E6D0E0BE +:1030900010E8188301E008832FEF80E792E02150C9 +:1030A00080409040E1F700C000003FDF85B7982FD7 +:1030B000916095BF826085BF10BF84E880936400F3 +:1030C000E8E6F0E08081846080835F9A729A589A83 +:1030D000599A269A689A279A699A549A529A5E9AA5 +:1030E0005D9A569A559A00936E0082E08093700024 +:1030F000D0D380E0E82E81E0F82EF70100A784B15C +:103100008F6384B987B1806C87B978946BD425D5E7 +:10311000F894188318827894F70110A6D1D46FD44C +:10312000CF93DF93CDB7DEB7CB5BD1090FB6F89461 +:10313000DEBF0FBECDBFC455DF4F8883CC5AD04011 +:1031400012D581E08093790280E090E0FDD4C455EF +:10315000DF4F2881CC5AD0402223F9F0412C512C4A +:10316000E0E0F0E08491480E511C3196E11537E122 +:10317000F307C1F768E873E1CE018F559F4F4BDE2F +:103180004EE2C655DF4F4883CA5AD0401FE300E0E5 +:1031900088EBF82E96E0B92E43C01DE4812E11E095 +:1031A000912EE12CF12C12E3BE2C1E9D60011F9D7F +:1031B000D00C1124F601E35BFE4F8081882309F4D3 +:1031C000AAC083818B3009F0A6C08281843009F0C7 +:1031D000A2C0C40149D3882309F49DC0F601E05B75 +:1031E000FE4F4180528001E00E0D063019F400E0E0 +:1031F000B5E0BB2E81E090E00B2C01C0880F0A9453 +:10320000EAF7182F10951F7360E070E0CE018F551C +:103210009F4F01DEC655DF4F1882CA5AD040F12CAD +:10322000CB55DF4F188219821A821B82C55AD040B3 +:10323000A5DECB54DF4F4882C55BD040CA54DF4F78 +:103240005882C65BD04087EC282E24182518C95414 +:10325000DF4F2882C75BD04053E0C755DF4F58830C +:10326000C95AD040C555DF4F1882CB5AD0407AEBAF +:10327000E72E8B2D90E0E2E3E89F9001E99F300D6F +:103280001124A901435B5E4F1A01FA013396C1551F +:10329000DF4FF983E883CF5AD040A901405B5E4FEE +:1032A000CF54DF4F59834883C15BD040FC01EE0F00 +:1032B000FF1FCD54DF4FF983E883C35BD0404F5FDE +:1032C0005F4FC854DF4F59834883C85BD040E050FC +:1032D000FF4FC355DF4FF983E883CD5AD0403E01FD +:1032E000F1E86F0E711C9301205E3F4FC654DF4F13 +:1032F00039832883CA5BD040C455DF4F3881CC5A0C +:10330000D040332319F0112309F406C280913F0104 +:1033100080FF0DC001C23FEFE31AF30A42E3840EBF +:10332000911C56E0E516F10409F03ECF63CFC45579 +:10333000DF4F8881CC5AD040811198C0F101808143 +:10334000882309F493C0C155DF4FE881F981CF5A32 +:10335000D04080818B3D09F060C0F10182818332D1 +:1033600009F05BC0C10180D2882309F456C0CF5454 +:10337000DF4FE881F981C15BD04081A18F1160C02E +:10338000CD54DF4FE881F981C35BD040E050FF4F5F +:10339000818187709F2D9295990F907E892B8183D3 +:1033A0008F2D8370A1E0B0E0AC0FBD1FF0E28F9FC6 +:1033B000A00DB11D112490E2C854DF4FE881F981BE +:1033C000C85BD04001900D929A95E1F78330A1F44B +:1033D000BE016F5F7F4FC655DF4F8881CA5AD0400C +:1033E00098D3C655DF4F2881CA5AD0402F5FC655A3 +:1033F000DF4F2883CA5AD040F39438EBF3122CC025 +:10340000C355DF4FE881F981CD5AD0408081806C6F +:10341000808383E08183A12C17C0C155DF4FE881F1 +:10342000F981CF5AD0408081883E51F4F1018281E8 +:10343000823031F4C10118D2AA24A394811101C0B1 +:10344000A12CF8EBFF120CC0111108C069EB8B2DF9 +:10345000F7DC68EBF62E07C0A12C02C058EBF52E66 +:103460006F2D8B2DEDDCF101108201C0A12CC02E3F +:10347000D12CF2E3FC9D4001FD9D900C1124F40140 +:10348000E35BFE4F8081882309F45CC083818D3526 +:1034900009F04DC08281833009F049C0CF01E4D1E9 +:1034A000882309F444C021E030E0002E01C0220F3F +:1034B0000A94EAF7C555DF4F4881CB5AD040422BDA +:1034C000C555DF4F4883CB5AD040F401E05BFE4F37 +:1034D000E180C601880F991F57EB5E15D8F4E9EB20 +:1034E000EE120BC020951223FC01E050FF4F20810B +:1034F000206C20832181276009C0FC01E050FF4F30 +:103500002081206C20832181287F236021839924BE +:10351000939401C0912CFC01E050FF4F8181877092 +:103520009E2D9295990F907E892B818301C0912CBD +:1035300022E32C9DF0012D9DF00D1124E35BFE4F45 +:10354000108201C0912CEF1408F03DC08E2D86959D +:103550008695C655DF4F3881CA5AD0408317B8F4D4 +:1035600040E2E49EC0011124D30186199709FC01B1 +:10357000EA0FFB1FE491ED93C654DF4FE881F98118 +:10358000CA5BD040AE17BF0791F7A3010BC08E2DC9 +:10359000837041E050E04C0F5D1FF0E28F9F400DC3 +:1035A000511D11246E2D802F5BDC68E770E0CE0189 +:1035B0008B559F4F30DC23E0C755DF4F2883C95A16 +:1035C000D0403AEBE32EF894409131015091320112 +:1035D00060913301709134017894CB55DF4F88812D +:1035E0009981AA81BB81C55AD04084179507A60747 +:1035F000B70718F09110C1C08BC0C755DF4FE881E5 +:10360000C95AD040E111AEC0F894409131015091B7 +:10361000320160913301709134017894CF55DF4FBE +:1036200088819981AA81BB81C15AD04084179507AE +:10363000A607B70748F481E090E00C2C01C0880F82 +:103640000A94EAF780951823F601EE0FFF1FE05069 +:10365000FF4F818187708183112309F459C0212F85 +:1036600030E00F5F063009F400E0C901002E02C00F +:10367000959587950A94E2F780FFF3CF33E0C7551D +:10368000DF4F3883C95AD040802F57D18823A9F003 +:103690008BE03AD1CB54DF4F8881C55BD04034D129 +:1036A000CA54DF4F8881C65BD0402ED1C954DF4F4A +:1036B0008881C75BD04028D117D1E02FF0E0EE0F12 +:1036C000FF1FE050FF4F8181886F8183C555DF4F19 +:1036D0004881CB5AD040842F90E0002E02C09595AF +:1036E00087950A94E2F780FD40C062E370E0CE0166 +:1036F0008B559F4F90DBC755DF4F5881C95AD0403B +:103700005150C755DF4F5883C95AD0408AEBE82E35 +:10371000DADBAA2009F4F0CD109279022FDC98EBC5 +:10372000F91226C080E090E0E0E0F0E02491820F02 +:10373000911D3196E11527E1F207C1F748165906A8 +:10374000B9F403E010E0812FF8D0882329F088EE47 +:10375000DBD08AEED9D0C8D01F5F1630A1F7015058 +:1037600089F74DD1992031F06FCF68E770E0BFCF76 +:1037700083E02EDC111188CFCBCFC755DF4FF88106 +:10378000C95AD040FF2309F43FCF5ECFF89404E03C +:103790000EBF0FEF0DBF7894C3DC80E0F7DF90D150 +:0637A00081E0F4DF15DCFE +:1038000031C00000FDCF0000FBCF0000F9CF000069 +:10381000C2CB000028C1000027C10000F7C1000092 +:103820008BC10000BCCF00009EC10000F1C00000B1 +:10383000ABC1000028C10000ACCB0000B3CF00003A +:10384000E5C10000FFFEFDFBFAF8F5F2EEEAE6E066 +:10385000DAD3CCC3BAB0A5998C7E6F5F4E3B2813E8 +:103860000D090301112406DCFC012281339690E04E +:10387000215018F08191980FFBCF81E0923D09F023 +:1038800080E008952E9870982F9871985C985A98B7 +:1038900008958FEF87BD88BD16BC95B5906895BD1E +:1038A00095B5906495BD93EA94BD93E29093B00072 +:1038B00090E89093B3008093B4001092B200E1EBD3 +:1038C000F0E080818064808383B5806883BD83B5A8 +:1038D000826083BD83B5816083BD82E085BD8083C6 +:1038E00083B58F7783BD089580EB97E189DAEDE4A6 +:1038F000F1E0118213AA1092B2011092E401109229 +:1039000016021092480208950F931F93CF93DF93EE +:10391000082FC8E0D0E011E0812F802319F08CE05F +:1039200096E002C08EED9EE06BDA110F2197A1F7B1 +:10393000DF91CF911F910F910895F89442E3849FF6 +:10394000F0011124E35BFE4F95A5911103C091E0B6 +:10395000918301C090E078949923C1F121E030E097 +:10396000A90102C0440F551F8A95E2F7CA012091B0 +:1039700081002111FCCF98E190938100109280008A +:10398000109285001092840021E030E0309389008D +:103990002093880093E0909380002CE036E03093F1 +:1039A000890020938800B19A90916F009260909363 +:1039B0006F0080938A008AB581608ABD89E1809317 +:1039C000810080EB97E11CDA81E0089580E00895A2 +:1039D00080917A0086FDFCCF8091790096EC9093DF +:1039E0007A00089586EC80937A008EE680937C00BE +:1039F0008DE58A95F1F70000EBDFEADFE9CFF89477 +:103A000094DA04E00EBF0FEF0DBF78940C94000021 +:103A10001F920F920FB60F9211242F938F939F93A3 +:103A200090918A0086B1892397B993B92AE12A95A2 +:103A3000F1F700C093B986B995E09A95F1F70000C7 +:103A400017B886B90AB400FC03C01092810003C005 +:103A50008AB58E7F8ABD9F918F912F910F900FBE57 +:103A60000F901F90189518951F920F920FB60F92F6 +:103A700011248F9386B5809327018F910F900FBEED +:103A80000F901F90189590E8899FF0011124F894E9 +:103A900083E080935700E895789407B600FCFDCF4B +:103AA000F89485E080935700E895789407B600FC79 +:103AB000FDCFF89481E180935700E89578940895BC +:103AC0000F931F93CF93DF9310E020E037E101E0E5 +:103AD00080E090E0E901C80FD91F8038910569F0B6 +:103AE000FE0145915491F894FC010A01009357009E +:103AF000E895112478940296EDCF812FC4DF1F5FE3 +:103B00001E3211F09E01E4CFDF91CF911F910F91F2 +:103B10000895E0E0F0E091E0F894DB012D913D9113 +:103B2000BD01090190935700E895112478943296CD +:103B3000E038F10589F7A7CF81E080930C018091EF +:103B40000C018111FCCFBFC9E0E0F1E081939193BA +:103B500021E0EC30F207D1F7EFCF3ADF8A3710F0EF +:103B600082E036CA0895F894E1E3F1E08081918122 +:103B7000A281B381805E9D4EA54FBF4F8583968302 +:103B8000A783B08778940895F89480E880936100C3 +:103B900081E080936100789415BC74DE1092B100CE +:103BA00014BC1092B0006B9810927A002FEF80E74F +:103BB00092E0215080409040E1F700C000004F9B10 +:103BC000FECF2FEF80E792E0215080409040E1F758 +:103BD00000C0000080916D00806880936D0085E0DA +:103BE00083BF889580916D008F7780936D00FADE9A +:103BF00050DEB3DFF89480E880936100109261009A +:103C00007894BCD9B0DF1092410108951F920F92B1 +:103C10000FB60F921124EF92FF920F931F932F93E1 +:103C20003F934F935F936F937F938F939F93AF9344 +:103C3000BF93CF93DF93EF93FF9316B1109516B90F +:103C400017B985E18A95F1F7000095E09A95F1F7AB +:103C5000000017B816B978948091B20087FFBDC0F4 +:103C6000C091350180E28C0F8D3708F4B3C080918C +:103C7000310190913201A0913301B091340101964C +:103C8000A11DB11D8093310190933201A0933301A6 +:103C9000B093340140913601509137016091380161 +:103CA00070913901481759076A077B0708F46CDFE0 +:103CB00080913F0169B1562F5095551F5527551FCB +:103CC00090913E0140914201209143013091440185 +:103CD000591349C04111415067FD2FC021153105CD +:103CE00029F02150310911F41092450160914701EA +:103CF000709148016F5F7F4F709348016093470157 +:103D0000613797E1790730F080681092480110928E +:103D1000470149C0693B9BE0790710F0806443C0CC +:103D2000613B744008F43FC09091460191113BC043 +:103D3000826091E09093460136C02115310599F1DA +:103D40002150310981F590914501913011F488603D +:103D500007C0923011F4806103C0806290934001EB +:103D60001092450120C041111DC09091450167FD91 +:103D70000BC081609F3F09F09F5F10924801109235 +:103D800047012AE431E007C084602115310509F4B8 +:103D900090E0109246019093450150933E0144E11A +:103DA00091E002C044E190E080933F0140934201E2 +:103DB00030934401209343019111D5DE8091280175 +:103DC000811106C081E080932801C7DE109228018E +:103DD00083EA8C0F8093350173C080912601909106 +:103DE0002501C92FD0E0823009F441C028F488238E +:103DF00051F08130C9F062C0833009F445C084308D +:103E000009F451C05BC03EDDCC0FDD1FCC0FDD1FC0 +:103E1000C050DF4F8F858F3F29F083E28093B00041 +:103E2000539A6B9A81E04AC06B98923081F030F4DB +:103E3000992359F0913081F4709A0EC0943059F062 +:103E400040F0953049F45A9A07C02E9A05C02F9A2F +:103E500003C0719A01C05C9ACC0FDD1FCC0FDD1F2F +:103E6000C050DF4F8F858093B40082E027C08FEF72 +:103E70008093B400CC0FDD1FCC0FDD1FC050DF4F8F +:103E80008D8587BD83E01AC053988093B0008FEF73 +:103E900087BDCC0FDD1FCC0FDD1FC050DF4F8E85DF +:103EA00088BD84E00BC08FEF88BD9F5F963019F40A +:103EB00010920C0190E09093250180E08093260100 +:103EC000C7E4D2E000E2F12CEE24E3949CA5802F1D +:103ED000812309F43EC08DA59430D0F48823B1F13C +:103EE000923010F490E801C090E0282F2695922B94 +:103EF00080FF2BC08A81883248F48A81FE01E80F56 +:103F0000F11D93838A818F5F8A8338C01A8214C01F +:103F10009730E0F4803891F49A819923B9F0E882DF +:103F20008B818B3049F48A81843031F4CE019CDC62 +:103F3000882311F0FF24F39480E008C09881911148 +:103F400005C099819923C9F001C0892F8DA71CA6AE +:103F500006C0983018F49F5F9CA701C01DA6E29789 +:103F6000069581E0CB31D80709F0B0CFFF2041F0B2 +:103F700080917902811104C010DC1A8280E8E6CFBA +:103F8000FF91EF91DF91CF91BF91AF919F918F9171 +:103F90007F916F915F914F913F912F911F910F9161 +:0E3FA000FF90EF900F900FBE0F901F9018959E +:0400000300003800C1 +:00000001FF diff --git a/bootloaders/readme.MD b/bootloaders/readme.MD new file mode 100644 index 00000000..4b36726a --- /dev/null +++ b/bootloaders/readme.MD @@ -0,0 +1,13 @@ +This folder contains the BlinkBIOS bootloader HEX file. This file is created by the BlinkBIOS repo... + +https://github.com/bigjosh/Move38-BlinkBIOS + +..and then copied here after each compile by an Atmel Studio post-build event. Note that the this bootloader directory is hardcoded into the text of that event. + +This file is used by... + +1. The `upload` and `program` recipes to download a new sketch to a blink. Note that we could make upload only update the actual program and not the BIOS for faster turnaround during development, but I do not want to change this behavior now. The path to the bootloader is hardcoded into the recipes but is relative to the platform folder. +2. The `Export Binary` function which creates a single HEX file with both the current sketch and the BIOS. In this case, the folder name must be `bootloader` as this is hardcoded into the IDE. + + + \ No newline at end of file diff --git a/cores/blinkcore/IR.md b/cores/blinkcore/IR.md deleted file mode 100644 index 8f7b97ec..00000000 --- a/cores/blinkcore/IR.md +++ /dev/null @@ -1,51 +0,0 @@ -### IR Communications Protocol - -Each of the 6 edges of a blink tile has an IR LED to communicate with its adjacent neighbor. - -#### Physical layer - -Each single IR LED is used for both transmit and receive. The LED pins are connected directly to GPIO pins on the MCU. - -For transmitting, the LED is briefly driven with a forward voltage to flash it. These flashes are short to save power. - -For receiving, the LED is negatively biased to charge it up like a capacitor. Light falling on the LED makes it discharge more quickly, and by timing how long it takes to discharge we can measure the integral how much light is hitting it. [This technique](https://www.sparkfun.com/news/2161) was originally described by Forest Mimms III. - -We've chosen our LED to... - -* quickly reliably discharge below the digital trigger voltage of our MCU input pins when exposed to a >10us flash from a corresponding transmitting LED at a distance of about 1mm, - -AND - -* take >1ms to discharge in ambient light. - - -##### DDR and PORTs of IR LEDs during different states - - -| State | Anode DDR | Anode PORT | Cathode DDR | Cathode PORT | Notes | -| --- | --- | --- | --- | --- | --- | -| Charging | High (driving) | Low | High (driving) | High | Led reverse biased | -| Listening | High (driving) | Low | Low (input) | Low (no pull-up) | Cathode sees input go low when charge depleted | -| Sending | High (driving) | High | High (driving) | Low | Normal forward voltage lights LED | - -Note that Anode DDR is always driven so we never touch that after enabling IR system. - -#### Receiving - -Higher level code can use `ir_test_and_charge()` to check the digital state of the LEDs to see if they have been discharged since last charged. Any LEDs that have discharged are recharged. - -It is also possible to generate an interrupt when an LED crosses the digital threshold voltage, but this is not currently used. - -#### Transmitting - -All transmissions are a series of flashes separated by a number of gaps times called spaces. The space time is typically fixed for a given protocol. - -The gaps are precisely timed and will be accurate to within the latency of interrupts on the system, so keep interrupt disabled for as little time as possible. - -Call `ir_tx_start()` to begin transmitting a pulse train. This sends the first flash. - -Then call `ir_tx_sendpulse()` to transmit each of the remaining flashes in the pulse train. Obviously you must call `ir_tx_sendpulse()` quickly enough that you keep up with the specified number of spaces from the previous call. - -Call `ir_tx_end()` at the end of the train. This will block until the final flash is transmitted. - - \ No newline at end of file diff --git a/cores/blinkcore/Interrupts.md b/cores/blinkcore/Interrupts.md deleted file mode 100644 index adfb6ba1..00000000 --- a/cores/blinkcore/Interrupts.md +++ /dev/null @@ -1,65 +0,0 @@ -# Blinks Interrupt Usage - -## `TIMER2_OCR2A_vect` - -Fires every time Timer2 matches with 128 (max is 256). - -We needed a 256us clock to properly do IR comms, but there is no suitable prescaller that get us this rate so we had to synthesize it. - -We do this by combining the overflow interrupt on timer0 with the match interrupt on timer2. Both are running in lockstep at 512us rate, and so by setting the match on timer2 to 128, we get one interrupt every 256us. - -On each match, we call the 256us clock callbacks. - -## `TIMER0_OVF_vect` - -Fires every time the Timer0 overflows. - -This timer directly drives the RED and GREEN LEDs via PWM output. It is also synchronized with Timer2 whose output drives the BLUE LED though a charge pump. - -It is run off the 4Mhz system clock with a `/8` prescaller, giving a tick rate of 500Khz. - -The overflow happens every 256 ticks, giving an interrupt rate of ~2KHz (every 512ms). - -On each overflow, we first call the 256us clock callbacks, then the 512us clock callback. - -### Pixel Refresh - -This code lives in `blinkcore`. - -This code sets up the PWM signals to step though each of the 3 colors individually, and though all 6 RGB LEDs. - -This code takes between 9us and 16.6us - -### 256us Timer Callback - -This code lives in `blinklib` & `irdata`. - -This code... - -Checks the IR LEDs for triggers and decodes incoming data. - - -### 512us Timer Callback - -This code lives in `blinklib`. - -This code... -2. Updates the millisecond clock. -3. Checks if the button state has changed and decodes clicks and pressed. -4. Checks to see if we have timed out and should go to sleep. - -## `BUTTON_ISR` - -Currently points to an `EMPTY_INTERRUPT`. - -We need some ISR here because we use the button to wake from sleep, but it effectively only takes a few us to call and return. - -## `TIMER1_CAPT_vect` - -We use this interrupt to precisely time outgoing IR pulses. It is only used when actually sending a pulse train. - -It takes about 23us. - -## `WDT_vect` - -Currently a placeholder function. We will need this to implement partial sleeping where we want to wake up after a certain period of time. diff --git a/cores/blinkcore/README.md b/cores/blinkcore/README.md deleted file mode 100644 index ad7a08c6..00000000 --- a/cores/blinkcore/README.md +++ /dev/null @@ -1,60 +0,0 @@ -### Hardware Abstraction Layer Core Files - -These functions provide low level access to the hardware. The `Blinks` API is built on top of these functions and provides a higher level view more that is more appropriate for most game developers. - -Reasons to use this HAL: - -1. You want to do something not supported in the higher level API. In this case, you can include the `.h` file for the subsystem you need direct access to directly in your sketch, but you have to be careful not to step on the toes of the other API calls. -2. You want to make your own higher programming model. Wish you could program your Blinks using an SmallTalk actor based model? Or an ELM functional state transformation model? You can build is from scratch starting with these functions! - - -#### Conventions - - -Each subsystem has a `.h` file and a `.cpp` file. - -Most subsystems offer these base functions... - -`subsystem_init()` - On time hardware initialization run at power up. -`subsystem_enable()` - Start operation. Called after either `_init` or `_disable` -`subsystem_disable()` - Stop the subsystem to save power. Called after `_enable` - - -#### Disabling interrupts - -Both the IR communications and the display RGB LED systems are very timing sensitive, so it is important that interrupts never be turned off for too long. - -The maximum allowed interrupt latency is dependent on clock speed and other factors that are still changing, so I can't give you a hard answer now- but in general try to only turn off interrupts for a few instructions. If you need atomicity longer than that, you a higher level semaphore or something like that. - -#### Asynchronous Callbacks - -To support asynchronous callbacks without impacting interrupt latency, the HAL implements a pseudo interrupt system where the hardware interrupts are intercepted by the HAL and then re-dispatched to the callback functions. - -Interrupts are enabled while callback functions are running, but only one instance of a callback can be active at a time. If another asynchronous event occurs while a callback is already running, the new callback is held until the running callback completes. Multiple events that would trigger the same callback are batched into a single call. - -This means that... - -2. Even though interrupts are enabled, you callback will never be interrupted by another copy if itself -2. If another trigger events happens while your callback is running, it will get called again right after the running copy returns -3. If multiple trigger events happen while your callback is running, you may only get called once more when your currently running callback returns. -4. If a triggering event occurs, your callback will always get called, even if the trigger disappears before the callback is invoked. -4. You should always write callbacks so they can deal with being called even if the triggering event is no longer present. -5. Any variables that are accessed only within your callback do not need to be `volatile` since there will only ever be one copy of the callback running. -6. Any variables that are access by the foreground should be declared as `volatile` from the foreground process's point of view since these could be updated asynchronously by the callback. -7. Any variables that are shared between different callbacks should be declared as `volatile` from the reading callback's point of view since that callback could be interrupted by another callback. - -#### The DEBUG subsystem - -It can be hard to debug code on a little board with no screen or keyboard. The `DEBUG` subsystem gives you at least a couple of bits of IO to interact with your program during debugging. - -To use the `DEBUG` subsystem you must `#define DEBUG` a the top of your source file(s). - -The debug system uses pins #6 and #19 for communications. Hopefully these will be broken out on future PCB versions. - - -#### Other files - -`Arduino.h` is automatically included in all Arduino sketches and defines some of the the Arduino API functions that make sense on Blinks. - -`WMath.cpp` is taken from the Arduino core. It provides wrappers for some `random()` functions from `stdlib` and the `map()` function. - \ No newline at end of file diff --git a/cores/blinkcore/SP.md b/cores/blinkcore/SP.md deleted file mode 100644 index 2187c3d3..00000000 --- a/cores/blinkcore/SP.md +++ /dev/null @@ -1,94 +0,0 @@ -# Service Port - - -## Features - -Newer boards have a service port that features... - -* Super high speed, low latency, bi-directional serial port -* Aux pin that can be used for either digital IO or as an analog input - -These can be very helpful for... - -* debugging code on the tile since you get a printf() (via the serial port) -* collecting very accurate timing info on a scope (via the a Aux pin as digital out) -* intuitively to adjusting things like colors (using a potentiometer connected to the the aux pin as analog in) - -## Connections - -To use the port, you probably want to solder on a 4 pin 1.25mm pitch connector like this one... - -https://www.digikey.com/products/en?keywords=wm1733-nd - -The pins are... - -|Pin|Function|Direction| -|---|---|---| -|G|Ground|(na)| -|T|Serial TX|Out from tile| -|R|Serial RX|Into Tile| -|A|Aux pin|digital in or out with or without pull-up, or analog in to Tile| - -At some point I'll make a nice board that breaks out the service port connector into nice serial and aux links with all the level shifting built in. - -## Voltage conversions - -Note that all the pins are referenced to whatever the tile battery voltage happens to be, so level shifting may be required. - -### Serial TX -I use a FDTI USB serial converter that will see a '1' for any voltage above 2 volts, so the RX pin on that can be connected directly to the service port `T` pin. Otherwise you could use a MOSFET or packaged voltage converter like this... - -http://amzn.to/2zjSx8t - -### Serial RX - -Because of the ESD protection diode on the pin of the AVR, you can connect the service port 'R' pin to a 3.3V (or even a 5V) output TX pin of a serial port as long as you put a current limiting resistor in there. I am using a 3.3K resistor which should limit the current to less than 1mA. - -There is a downside to this in that that trickle current will keep the AVR somewhat powered up even with the battery out. Since the current is limited, it will undervoltage if it tries to light an LED so as a practical matter this means I need to unplug the service port when changing the battery. - -Again, a proper level convert like above will solve these problems. - -### Aux - -#### Digital Output - -This will just be whatever the battery voltage is when set to out a `1`. If you are just connecting up to a scope then this works great. - -#### Digital Input - -Like the serial RX pin, you could drive this with a voltage higher than the battery voltage though a large current limiting resistor or use a level converter. - -You could also enable the optional pull-up on this pin and then use an open collector (or dry contact switch) to pull low. - -#### Analog input - -In the mode, you get 8-bits that tell you the voltage on the aux pin relative to the battery voltage, so 0 means 0 volts, and 128 means the voltage on the aux pin is 1/2 the battery voltage. - -#### Touch sensing - -The aux pin is also connected electrically to the Move30 logo on the PCB, so this opens up the possibly to do CapSense touch sensing on this pad by charging the pad using aux digital out to `1`, and then switching to analog input and seeing how much the voltage drops each time you do a reading. This is an indication of the capacitance connected to the pin - which will be much higher when there is a finger connected to a person touching it. - -# On Latency - -## Serial - -The serial port is implemented using the on-chip USART, so works completely in the background. - -The `sp_serial_tx()` function will first check so see if there is already a pending transmit in progress, and if so will wait for it to complete. The test adds a couple cycles before the send even if the coast is clear, and the call could block for a dozen cycles if there is a transmit in progress that just started. - -if you are working on timing sensitive stuff, you can also use the `SP_SERIAL_TX_NOW()` function. This function does not do any checking- it immediately (and blindly) writes the byte to the serial port, and takes only a single instruction to execute. If the buffer is not ready (there is already a byte waiting to be transferred into the shift register) then the new byte will be ignored. This is not a scary as it sounds since you can just be sure to always leave at least a dozen instructions between sequential calls to give a byte time to drain out before sending the next one. This will likely happen easily in practice since you will be doing other stuff between consecutive serial writes. - -## Aux out - -The `SP_AUX_0()` and `SP_AUX_0()` also always complete in a single cycle, so are great for timing. - -To benchmark how long a function takes, you can put a `SP_AUX_1()` at the entry and a `SP_AUX_0()` at the exit and then connect a scope to the aux pin. Measuring the pulse width will give you instant and minimally intrusive metrics on on the min/avg/max run time for the function! - -# Connecting a potentiometer for analog input. - -Some things are each to do analog-ly. So much easier to turn a dial than to keep clicking up and down for stuff like color normalization. The analog in function of the aux pin should be great for this stuff. - -Since the input is referenced to the battery voltage, we need a good place to get at the reference voltage. - -As long as you init() the service port serial and are not actively sending data, then the pin will be an an idle "space", which is driven at the battery voltage. In this case, you should be able to attach a large pot (>1K) between the `T` and `G` and then connect the pot tap to the `A` pin and read the position of of pot with `sp_aux_analogRead()`. Untested, but should work! - diff --git a/cores/blinkcore/adc.cpp b/cores/blinkcore/adc.cpp deleted file mode 100644 index 8c39ce20..00000000 --- a/cores/blinkcore/adc.cpp +++ /dev/null @@ -1,109 +0,0 @@ -/* - * Internal analog to digital converter - * - * We connect the ADC to the battery so we can check its voltage. - * - */ - - -#include "hardware.h" - -#include "adc.h" - -#include "shared.h" - -#include "bitfun.h" - - -// Set up adc to read Vcc -// https://wp.josh.com/2014/11/06/battery-fuel-guage-with-zero-parts-and-zero-pins-on-avr/ - -void adc_init(void) { - - ADMUX = - _BV(REFS0) | // Reference AVcc voltage - _BV( ADLAR ) | // Left adjust result so only one 8 bit read of the high register needed - _BV( MUX3 ) | _BV( MUX2 ) | _BV( MUX1 ) // Measure internal 1.1V bandgap voltage - ; - - - // Set the prescaller based on F_CPU - // Borrowed from https://github.com/arduino/Arduino/blob/2bfe164b9a5835e8cb6e194b928538a9093be333/hardware/arduino/avr/cores/arduino/wiring.c#L353 - - // set a2d prescaler so we are inside the desired 50-200 KHz range. - #if F_CPU >= 16000000 // 16 MHz / 128 = 125 KHz - SBI(ADCSRA, ADPS2); - SBI(ADCSRA, ADPS1); - SBI(ADCSRA, ADPS0); - #elif F_CPU >= 8000000 // 8 MHz / 64 = 125 KHz - SBI(ADCSRA, ADPS2); - SBI(ADCSRA, ADPS1); - CBI(ADCSRA, ADPS0); - #elif F_CPU >= 4000000 // 4 MHz / 32 = 125 KHz - SBI(ADCSRA, ADPS2); - CBI(ADCSRA, ADPS1); - SBI(ADCSRA, ADPS0); - #elif F_CPU >= 2000000 // 2 MHz / 16 = 125 KHz - SBI(ADCSRA, ADPS2); - CBI(ADCSRA, ADPS1); - CBI(ADCSRA, ADPS0); - #elif F_CPU >= 1000000 // 1 MHz / 8 = 125 KHz - CBI(ADCSRA, ADPS2); - SBI(ADCSRA, ADPS1); - SBI(ADCSRA, ADPS0); - #else // 128 kHz / 2 = 64 KHz -> This is the closest you can get, the prescaler is 2 - CBI(ADCSRA, ADPS2); - CBI(ADCSRA, ADPS1); - SBI(ADCSRA, ADPS0); - #endif - -} - - -// Enable ADC and prime the pump (it takes 2 conversions to get accurate results) - -void adc_enable(void) { - - // enable a2d conversions - SBI(ADCSRA, ADEN); - SBI( ADCSRA , ADSC); // Kick off a primer conversion (the initial one is noisy) - while (TBI(ADCSRA,ADSC)) ; // Wait for 1st conversion to complete - - SBI( ADCSRA , ADSC); // Kick off 1st real conversion (the initial one is noisy) - - - -} - -// Disable and power down the ADC to save power - -void adc_disable(void) { - - CBI(ADCSRA, ADEN); // Disable ADC unit - -} - - -// Start a new conversion. Read the result ~1ms later by calling adc_readLastVccX10(). -// 1ms is safe, but if you need faster then conversion will actually be ready in -// 13 CPU cycles * ADC prescaller (25 cycles for 1st conversion) - -void adc_startConversion(void) { - SBI( ADCSRA , ADSC); // Start next conversion, will complete silently in 13 cycles (25 cycles for 1st) -} - -// Returns the previous conversion result (call adc_startConversion() to start a conversion). -// Blocks if you call too soon and conversion not ready yet. - -uint8_t adc_readLastVccX10(void) { // Return Vcc x10 - - while (TBI(ADCSRA,ADSC)) ; // Wait for any pending conversion to complete - - uint8_t lastReading = (11 / ADCH); // Remember the result from the last reading. - - return( lastReading ); - -} - - - diff --git a/cores/blinkcore/adc.h b/cores/blinkcore/adc.h deleted file mode 100644 index 5722bc69..00000000 --- a/cores/blinkcore/adc.h +++ /dev/null @@ -1,38 +0,0 @@ -/* - * Internal analog to digital converter - * - * We connect the ADC to the battery so we can check its voltage. - * - */ - -#ifndef ADC_H_ -#define ADC_H_ - -#include
-
- 
- {% endif %}
-
-
-
-
-
- {{ content }}
-
-
-
-
-
- {% if site.google_analytics %}
-
- {% endif %}
-
-
\ No newline at end of file
diff --git a/docs/android-chrome-192x192.png b/docs/android-chrome-192x192.png
deleted file mode 100644
index c9edf006..00000000
Binary files a/docs/android-chrome-192x192.png and /dev/null differ
diff --git a/docs/android-chrome-256x256.png b/docs/android-chrome-256x256.png
deleted file mode 100644
index fe978f89..00000000
Binary files a/docs/android-chrome-256x256.png and /dev/null differ
diff --git a/docs/api.md b/docs/api.md
deleted file mode 100644
index 4b2f010c..00000000
--- a/docs/api.md
+++ /dev/null
@@ -1,188 +0,0 @@
-# Blinks API Reference
-[Glossary](glossary.md) - glanceable reference
-
-## Display
-```
-void setColor(color);
-// sets all 6 pixels on all faces to the same color
-
-void setFaceColor(face, color);
-// sets a single pixel on a face to this color
-```
-
-## Colors
-```
-Color makeColorRGB(red, green, blue);
-// R, G, and B values [0-255]
-
-Color makeColorHSB(hue, saturation, brightness);
-// H, S, and V values [0-255]
-
-Color dim(color, value);
-// returns the color passed in a dimmer state
-//(0-255 bucketed into 32 levels of brightness)
-
-#define RED makeColorRGB(255, 0, 0)
-#define ORANGE makeColorRGB(255, 127, 0)
-#define YELLOW makeColorRGB(255, 255, 0)
-#define GREEN makeColorRGB( 0, 255, 0)
-#define CYAN makeColorRGB( 0, 255, 255)
-#define BLUE makeColorRGB( 0, , 255)
-#define MAGENTA makeColorRGB(255, 0, 255)
-#define WHITE makeColorRGB(255, 255, 255)
-#define OFF makeColorRGB( 0, 0, 0)
-```
-
-## Button
-```
-/*
- * All button handling is done with flags, so when
- * you call a function, it returns the value of
- * the flag (i.e. whether or not that action
- * has occured) and only when you have
- * called the function will it reset
- * the flag to false
- */
-
-bool buttonPressed();
-// a flag is set to true on the change from button up to button down
-// buttonPressed() returns that flag and sets it back to false
-
-bool buttonReleased();
-// a flag is set to true on the change from button
-// down to button up buttonReleased() returns that
-// flag and sets it back to false
-
-bool buttonSingleClicked();
-// a flag is set to true when the the
-// button goes from down to up
-// only once in under 330ms. The flag is set exactly
-// 330ms after the button is up
-// buttonSingleClicked() returns that flag and sets it back to false
-
-bool buttonDoubleClicked();
-// returns true when a double click has been recorded
-// (down-up-down-up under 330ms*)
-// ^ also a flag with the same properties as above
-
-bool buttonMultiClicked();
-// returns true when multiple click has been recorded
-// (down-up...down-up under 330ms*)
-// ^ also a flag with the same properties as above
-
-byte buttonClickCount();
-// returns the number of clicks recorded during button multi clicking
-
-bool buttonLongPressed();
-// returns true when the button has been down for more than 3000ms (3 seconds)
-// ^ also a flag with the same properties as above
-
-bool buttonDown();
-// returns true when the button is down
-// ^ also a flag with the same properties as above
-```
-
-## Communication
-```
-void setValueSentOnAllFaces(value);
-// sets a value (0-63) to be sent
-// repeatedly (every loop() cycle) on all 6 faces
-
-void setValueSentOnFace(value, face);
-// sets a value (0-63) to be sent repeatedly (every loop() cycle)
-// on the face specified
-
-byte getLastValueReceivedOnFace(face);
-// retreives the last value seen on the
-// specified face even if expired
-// (i.e. last message from neighbor)
-// defaults to 0 on startup
-
-bool isValueReceivedOnFaceExpired(face);
-// returns true if the message from a
-// neighbor has expired
-// (i.e. it's been longer than 200ms since we last
-// received a message from this neighbor)
-
-bool didValueOnFaceChange(face);
-// returns true if the value on this face is different
-// from the last stored seen value on this face
-
-bool isAlone();
-// returns true if all faces have expired values
-// (i.e. it is safe to assume this Blink is now alone)
-```
-
-## Time
-```
-unsigned long millis();
-// monotonically incrementing timer
-// remains constant in a single pass of loop()
-// i.e. millis() will return the same value at the top
-// of loop() and the bottom does not
-// increment while asleep
-// resets after ~50 days
-
-
-void Timer.set(duration);
-// a timer that will expire after duration milliseconds
-// used like this:
-// Timer myTimer;
-// myTimer.set(millisTilExpired);
-
-bool Timer.isExpired();
-// a timer remains expired once it become
-// expired until set again or if
-// a timer is set to NEVER, it will never expire
-```
-
-## Types
-```
-byte
-word
-int
-long
-float
-double
-bool
-Color
-Timer
-```
-
-## Convenience
-```
-FOREACH_FACE(f) {
-// f increments from 0-5 (i.e. each face)
-}
-
-COUNT_OF(array);
-// pass this function an array and it will returns number of elements in the array
-```
-
-## Constants
-```
-#define FACE_COUNT 6
-// 6 for the number of faces the current Blinks have
-// (maybe a new tesselation for heptagons will be found and we'll come out with a new version, but until then, six.)
-
-#define MAX_BRIGHTNESS 255
-// 255 for the highest brightness level displayed
-// Note: brightness actually only has 31 different values,
-// however, we scale them to 0-255 to match a familia 8-bit color scheme
-
-#define NEVER ( (uint32_t)-1 )
-// If you would like the timer to effectively never expire, set it to this constant
-
-#define SERIAL_NUMBER_LEN 9
-// Length of the globally unique serial number (9 bytes long)
-```
-
-## Uniqueness
-```
-uint16_t rand( uint16_t limit );
-// Return a random number between 0 and limit inclusive.
-
-byte getSerialNumberByte( byte n );
-// Read the unique serial number for this blink tile
-// There are 9 bytes in all, so n can be 0-8
-```
diff --git a/docs/apple-touch-icon.png b/docs/apple-touch-icon.png
deleted file mode 100644
index 19e8919c..00000000
Binary files a/docs/apple-touch-icon.png and /dev/null differ
diff --git a/docs/assets/Blinks Functionality Guide _ Blinks Developers.htm b/docs/assets/Blinks Functionality Guide _ Blinks Developers.htm
deleted file mode 100644
index 9033a7e1..00000000
--- a/docs/assets/Blinks Functionality Guide _ Blinks Developers.htm
+++ /dev/null
@@ -1,145 +0,0 @@
-
-
-
-
-
-
-
-
-
-{{ site.title | default: site.github.repository_name }}
- - {% if site.logo %} -{{ site.description | default: site.github.project_tagline }}
- - - - {% if site.github.is_user_page %} - - {% endif %} - - {% if site.show_downloads %} - - - {% endif %} - - - - - - - -
-
- 
-
-
-
-
-
-
-
-
-Inputs
-
-Communication
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/blink_click.png b/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/blink_click.png
deleted file mode 100644
index a2205785..00000000
Binary files a/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/blink_click.png and /dev/null differ
diff --git a/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/blink_comm.png b/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/blink_comm.png
deleted file mode 100644
index 9a494ca7..00000000
Binary files a/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/blink_comm.png and /dev/null differ
diff --git a/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/blink_light.png b/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/blink_light.png
deleted file mode 100644
index 9e7e7bb9..00000000
Binary files a/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/blink_light.png and /dev/null differ
diff --git a/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/blinkslogo.png b/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/blinkslogo.png
deleted file mode 100644
index f7e7866d..00000000
Binary files a/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/blinkslogo.png and /dev/null differ
diff --git a/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/scale.fix.js b/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/scale.fix.js
deleted file mode 100644
index 911d33c3..00000000
--- a/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/scale.fix.js
+++ /dev/null
@@ -1,27 +0,0 @@
-(function(document) {
- var metas = document.getElementsByTagName('meta'),
- changeViewportContent = function(content) {
- for (var i = 0; i < metas.length; i++) {
- if (metas[i].name == "viewport") {
- metas[i].content = content;
- }
- }
- },
- initialize = function() {
- changeViewportContent("width=device-width, minimum-scale=1.0, maximum-scale=1.0");
- },
- gestureStart = function() {
- changeViewportContent("width=device-width, minimum-scale=0.25, maximum-scale=1.6");
- },
- gestureEnd = function() {
- initialize();
- };
-
-
- if (navigator.userAgent.match(/iPhone/i)) {
- initialize();
-
- document.addEventListener("touchstart", gestureStart, false);
- document.addEventListener("touchend", gestureEnd, false);
- }
-})(document);
diff --git a/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/style.css b/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/style.css
deleted file mode 100644
index fda38d76..00000000
--- a/docs/assets/Blinks Functionality Guide _ Blinks Developers_files/style.css
+++ /dev/null
@@ -1 +0,0 @@
-@font-face{font-family:'Noto Sans';font-weight:400;font-style:normal;src:url("../fonts/Noto-Sans-regular/Noto-Sans-regular.eot");src:url("../fonts/Noto-Sans-regular/Noto-Sans-regular.eot?#iefix") format("embedded-opentype"),local("Noto Sans"),local("Noto-Sans-regular"),url("../fonts/Noto-Sans-regular/Noto-Sans-regular.woff2") format("woff2"),url("../fonts/Noto-Sans-regular/Noto-Sans-regular.woff") format("woff"),url("../fonts/Noto-Sans-regular/Noto-Sans-regular.ttf") format("truetype"),url("../fonts/Noto-Sans-regular/Noto-Sans-regular.svg#NotoSans") format("svg")}@font-face{font-family:'Noto Sans';font-weight:700;font-style:normal;src:url("../fonts/Noto-Sans-700/Noto-Sans-700.eot");src:url("../fonts/Noto-Sans-700/Noto-Sans-700.eot?#iefix") format("embedded-opentype"),local("Noto Sans Bold"),local("Noto-Sans-700"),url("../fonts/Noto-Sans-700/Noto-Sans-700.woff2") format("woff2"),url("../fonts/Noto-Sans-700/Noto-Sans-700.woff") format("woff"),url("../fonts/Noto-Sans-700/Noto-Sans-700.ttf") format("truetype"),url("../fonts/Noto-Sans-700/Noto-Sans-700.svg#NotoSans") format("svg")}@font-face{font-family:'Noto Sans';font-weight:400;font-style:italic;src:url("../fonts/Noto-Sans-italic/Noto-Sans-italic.eot");src:url("../fonts/Noto-Sans-italic/Noto-Sans-italic.eot?#iefix") format("embedded-opentype"),local("Noto Sans Italic"),local("Noto-Sans-italic"),url("../fonts/Noto-Sans-italic/Noto-Sans-italic.woff2") format("woff2"),url("../fonts/Noto-Sans-italic/Noto-Sans-italic.woff") format("woff"),url("../fonts/Noto-Sans-italic/Noto-Sans-italic.ttf") format("truetype"),url("../fonts/Noto-Sans-italic/Noto-Sans-italic.svg#NotoSans") format("svg")}@font-face{font-family:'Noto Sans';font-weight:700;font-style:italic;src:url("../fonts/Noto-Sans-700italic/Noto-Sans-700italic.eot");src:url("../fonts/Noto-Sans-700italic/Noto-Sans-700italic.eot?#iefix") format("embedded-opentype"),local("Noto Sans Bold Italic"),local("Noto-Sans-700italic"),url("../fonts/Noto-Sans-700italic/Noto-Sans-700italic.woff2") format("woff2"),url("../fonts/Noto-Sans-700italic/Noto-Sans-700italic.woff") format("woff"),url("../fonts/Noto-Sans-700italic/Noto-Sans-700italic.ttf") format("truetype"),url("../fonts/Noto-Sans-700italic/Noto-Sans-700italic.svg#NotoSans") format("svg")}.highlight table td{padding:5px}.highlight table pre{margin:0}.highlight .cm{color:#999988;font-style:italic}.highlight .cp{color:#999999;font-weight:bold}.highlight .c1{color:#999988;font-style:italic}.highlight .cs{color:#999999;font-weight:bold;font-style:italic}.highlight .c,.highlight .cd{color:#999988;font-style:italic}.highlight .err{color:#a61717;background-color:#e3d2d2}.highlight .gd{color:#000000;background-color:#ffdddd}.highlight .ge{color:#000000;font-style:italic}.highlight .gr{color:#aa0000}.highlight .gh{color:#999999}.highlight .gi{color:#000000;background-color:#ddffdd}.highlight .go{color:#888888}.highlight .gp{color:#555555}.highlight .gs{font-weight:bold}.highlight .gu{color:#aaaaaa}.highlight .gt{color:#aa0000}.highlight .kc{color:#000000;font-weight:bold}.highlight .kd{color:#000000;font-weight:bold}.highlight .kn{color:#000000;font-weight:bold}.highlight .kp{color:#000000;font-weight:bold}.highlight .kr{color:#000000;font-weight:bold}.highlight .kt{color:#445588;font-weight:bold}.highlight .k,.highlight .kv{color:#000000;font-weight:bold}.highlight .mf{color:#009999}.highlight .mh{color:#009999}.highlight .il{color:#009999}.highlight .mi{color:#009999}.highlight .mo{color:#009999}.highlight .m,.highlight .mb,.highlight .mx{color:#009999}.highlight .sb{color:#d14}.highlight .sc{color:#d14}.highlight .sd{color:#d14}.highlight .s2{color:#d14}.highlight .se{color:#d14}.highlight .sh{color:#d14}.highlight .si{color:#d14}.highlight .sx{color:#d14}.highlight .sr{color:#009926}.highlight .s1{color:#d14}.highlight .ss{color:#990073}.highlight .s{color:#d14}.highlight .na{color:#008080}.highlight .bp{color:#999999}.highlight .nb{color:#0086B3}.highlight .nc{color:#445588;font-weight:bold}.highlight .no{color:#008080}.highlight .nd{color:#3c5d5d;font-weight:bold}.highlight .ni{color:#800080}.highlight .ne{color:#990000;font-weight:bold}.highlight .nf{color:#990000;font-weight:bold}.highlight .nl{color:#990000;font-weight:bold}.highlight .nn{color:#555555}.highlight .nt{color:#000080}.highlight .vc{color:#008080}.highlight .vg{color:#008080}.highlight .vi{color:#008080}.highlight .nv{color:#008080}.highlight .ow{color:#000000;font-weight:bold}.highlight .o{color:#000000;font-weight:bold}.highlight .w{color:#bbbbbb}.highlight{background-color:#f8f8f8}body{background-color:#fff;padding:50px;font:14px/1.5 "Noto Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;color:#727272;font-weight:400}h1,h2,h3,h4,h5,h6{color:#222;margin:0 0 20px}p,ul,ol,table,pre,dl{margin:0 0 20px}h1,h2,h3{line-height:1.1}h1{font-size:28px}h2{color:#393939}h3,h4,h5,h6{color:#494949}a{color:#267CB9;text-decoration:none}a:hover,a:focus{color:#069;font-weight:bold}a small{font-size:11px;color:#777;margin-top:-0.3em;display:block}a:hover small{color:#777}.wrapper{width:860px;margin:0 auto}blockquote{border-left:1px solid #e5e5e5;margin:0;padding:0 0 0 20px;font-style:italic}code,pre{font-family:Monaco, Bitstream Vera Sans Mono, Lucida Console, Terminal, Consolas, Liberation Mono, DejaVu Sans Mono, Courier New, monospace;color:#333}pre{padding:8px 15px;background:#f8f8f8;border-radius:5px;border:1px solid #e5e5e5;overflow-x:auto}table{width:100%;border-collapse:collapse}th,td{text-align:left;padding:5px 10px;border-bottom:1px solid #e5e5e5}dt{color:#444;font-weight:700}th{color:#444}img{max-width:100%}header{width:270px;float:left;position:fixed;-webkit-font-smoothing:subpixel-antialiased}header ul{list-style:none;height:40px;padding:0;background:#f4f4f4;border-radius:5px;border:1px solid #e0e0e0;width:270px}header li{width:89px;float:left;border-right:1px solid #e0e0e0;height:40px}header li:first-child a{border-radius:5px 0 0 5px}header li:last-child a{border-radius:0 5px 5px 0}header ul a{line-height:1;font-size:11px;color:#676767;display:block;text-align:center;padding-top:6px;height:34px}header ul a:hover,header ul a:focus{color:#675C5C;font-weight:bold}header ul a:active{background-color:#f0f0f0}strong{color:#222;font-weight:700}header ul li+li+li{border-right:none;width:89px}header ul a strong{font-size:14px;display:block;color:#222}section{width:500px;float:right;padding-bottom:50px}small{font-size:11px}hr{border:0;background:#e5e5e5;height:1px;margin:0 0 20px}footer{width:270px;float:left;position:fixed;bottom:50px;-webkit-font-smoothing:subpixel-antialiased}@media print, screen and (max-width: 960px){div.wrapper{width:auto;margin:0}header,section,footer{float:none;position:static;width:auto}header{padding-right:320px}section{border:1px solid #e5e5e5;border-width:1px 0;padding:20px 0;margin:0 0 20px}header a small{display:inline}header ul{position:absolute;right:50px;top:52px}}@media print, screen and (max-width: 720px){body{word-wrap:break-word}header{padding:0}header ul,header p.view{position:static}pre,code{word-wrap:normal}}@media print, screen and (max-width: 480px){body{padding:15px}header ul{width:99%}header li,header ul li+li+li{width:33%}}@media print{body{padding:0.4in;font-size:12pt;color:#444}}
diff --git a/docs/assets/apple-icon-76x76.png b/docs/assets/apple-icon-76x76.png
deleted file mode 100644
index cdd7b04d..00000000
Binary files a/docs/assets/apple-icon-76x76.png and /dev/null differ
diff --git a/docs/assets/blink_click.png b/docs/assets/blink_click.png
deleted file mode 100644
index a2205785..00000000
Binary files a/docs/assets/blink_click.png and /dev/null differ
diff --git a/docs/assets/blink_comm.png b/docs/assets/blink_comm.png
deleted file mode 100644
index 9a494ca7..00000000
Binary files a/docs/assets/blink_comm.png and /dev/null differ
diff --git a/docs/assets/blink_light.png b/docs/assets/blink_light.png
deleted file mode 100644
index 9e7e7bb9..00000000
Binary files a/docs/assets/blink_light.png and /dev/null differ
diff --git a/docs/assets/blinkslogo.png b/docs/assets/blinkslogo.png
deleted file mode 100644
index f7e7866d..00000000
Binary files a/docs/assets/blinkslogo.png and /dev/null differ
diff --git a/docs/assets/favicon-32x32.png b/docs/assets/favicon-32x32.png
deleted file mode 100644
index afe2223b..00000000
Binary files a/docs/assets/favicon-32x32.png and /dev/null differ
diff --git a/docs/assets/favicon.ico b/docs/assets/favicon.ico
deleted file mode 100644
index 7af09b24..00000000
Binary files a/docs/assets/favicon.ico and /dev/null differ
diff --git a/docs/assets/ms-icon-310x310.png b/docs/assets/ms-icon-310x310.png
deleted file mode 100644
index 83fec34f..00000000
Binary files a/docs/assets/ms-icon-310x310.png and /dev/null differ
diff --git a/docs/assets/transfercode.jpeg b/docs/assets/transfercode.jpeg
deleted file mode 100644
index f5fc5b99..00000000
Binary files a/docs/assets/transfercode.jpeg and /dev/null differ
diff --git a/docs/browserconfig.xml b/docs/browserconfig.xml
deleted file mode 100644
index b3930d0f..00000000
--- a/docs/browserconfig.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-
-Blinks Developers
- - -
-
-
- Resources for Blinks developers
- - - - - - - - - - - - - - - - -Blinks Functionality Guide
- -Overview
- -First of all, what are Blinks? Blinks is a digital/physical (“phygital”) tabletop game system that contains either six Blinks or twelve Blinks (the party pack). Each Blink is a “smart” hexagonal tile, designed to be held in the hand or placed next to other Blinks on a table. Magnets inside of each Blink allow the hexagonal tile to maintain an organized grid-like structure without needing a board. Each Blink has 3 key properties:
- --
-
- Blinks are ticklish (respond to touch) -
- Blinks are social (communicate with their neighbors) -
- Blinks love to play games (each one is responsible for remembering a single game, and can teach the others… more on game transmission later) -
Let’s start with an understanding of the ins and outs of Blinks. If you want to jump right into the API, it is rather self explanatory, head here now.
- -
.
-
-Blinks communicate to the players through RGB(red, green, blue… like a screen) illumination. You have full control over their hue, saturation, brightness, and can animate them in countless ways (i.e. pulsing, blinking, flashing…). A diffuser makes Blinks look like an even glowing surface; however, there are 6 LEDs or pixels, one for each face of the hexagon. This allows for more complex animation and directionality, such as spinning, flowing from side to side, or counting up or down to name a few.
- -While illumination is how a single Blink communicates to the players, the arrangement of the Blinks also communicates something to the players. In one example, the arrangement of 10 Blinks into different forms creates different behaviors of the whole. For example, if the Blinks are representing trees in a forest fire, a tightly packed set of 10 will spread the fire quicker than a long single file line of Blinks(trees). The player can reason this by seeing the arrangement of the board, and conversely, affect it by rearranging the board. Which brings me to inputs.
- -Inputs
.
-
-The simplest of inputs is a press. Each Blink responds to touch by pressing on a tactile button in the middle of the Blink (Blinks are seamless, so the entire top depresses). The button can be used in a variety of ways, and can respond to a quick click, a long press, a double click…
- -The button press can be an input to change the state of a Blink, or inform the Blink of a users action. For example, in the forest fire ruleset, a single press strikes lightning upon a Blink. If the Blink is a tree, it will then change state to be on fire, and if it is not a tree, it will simply go on being not a tree, as well as not on fire.
- -The press can also be used to reveal information contained in a Blink. For example, a Blink representing a place in a game of minesweeper could reveal that it has a mine under it only when held with a long press. The button press in this case didn’t add information to the system but is simply used to reveal information.
- -Communication 
.
-
-The Blinks communicate with each of their six neighbors by receiving information ~20 times per second. The information passed is in the form of a single integer (0-63). If no Blink is present on a single side, the information expires. What does this mean in simple terms? This means that each Blink can tell each neighboring Blink that it is in one of roughly 64 states. In the forest fire example, there are 3 states: tree, fire, soil. But what about lightning? that isn’t a state, since it only affects the local Blink, so it is animated through the illumination, but simply changes the Blink’s state from tree to fire. -Blinks are setup to do this kind of communication often and reliably, but it is not the only way they can communicate. For longer forms of information, such as passing string-like information, there is a shared data buffer that could be utilized. This is experimental and not refined in the API, so I recommend first trying to rely on simple communication with the dozen or so states afforded above.
- -Time
- -Game time for the Blinks can be continuous, evaluating their state 20 times a second, or they can be discrete, evaluating their state only when a step is called. A step is a convenience function that allows all connected Blinks to understand that a step has happened. Think of it as a convenient way to let the entire connected board know that a single move has been made.
- -In the forest fire example, time is discrete, which makes the spread of the fire controlled by the rate of the steps. One could see this as a game mechanic, where each turn is a step forward.
- -In the game Fracture, a continuous game, Blinks are constantly evaluating their state so they can show players the most up to date representation of the current board state. This results in a board that is quickly responsive to arrangement, while discrete time makes a board that feels responsive to specific state changes or steps.
- -Random vs. Deterministic
- -Blinks can respond to their inputs and neighbors deterministically, where they will respond exactly the same way given the same inputs and neighbors every time. This is the case in the example of Fracture or Game of Life. Players can learn how Blinks will behave given a certain arrangement because of this deterministic rule-set.
- -Games often use randomness for a bit of chance involved in each move. A dice roll, or a weighted random value can be very useful in creating suspense or capturing the real world uncertainty.
- -Randomness can also be used with Blinks with a bit of care and caution. In the example of the forest fire, each Blink (plot of land) has an n% chance of growing a tree. That percent increases with the number of neighboring trees, to represent fertile ground, but it is random none-the-less. The caviat with randomness and Blinks is that players must feel like Blinks are giving signal, not simply noise. If a player can’t understand why a Blink is behaving in the way it is, it will be confusing for everyone. That said, it is not a technical limitation, if you want a Blink to be a random different color every time you press it, that is an easy program to write.
- -Memory
- -While Blinks can maintain a bit of a memory or history of what they have done, neighbors they’ve had, or how much time has passed, this is limited and it is important to remember that if this isn’t transparent to the player, it could be very confusing. I look forward to seeing elegant solutions in which a bit of stygmergy might just seep its way into a game and shed light on a beautiful invisible system that lies just beneath the surface. (more on program space below)
- -Trickery
- -As you might have noticed, you have complete control over the way a Blink displays itself to the player and the state a Blink is actually in. It might be useful to have many states an only 2 visibly different appearances to the players. Conversely, it might be useful to have only two states and show many different illuminations.
- -The possibilities are many, feel free to look through the examples, they aim to walk you through the basics, and we welcome contributions for more.
- -Please feel free to ask about features, and if I didn’t cover something that is in the API, I should, so point it out, it belongs here, too!
- -API
- - -Nerdy Details
- -Each Blink has 16KB of RAM. For not having a screen, this is more than sufficient. In fact, we recommend keeping games under 4KB, so that we can transmit them from Blink to Blink in an efficient manner. The full code-base is published on GitHub where master contains our latest robust release and dev contains in progress features (such as an animation library).
- - -