Add sample component for SparkFun LED Stick

external_samples/docs/sparkfun_led_stick.md

@@ -0,0 +1,13 @@
+# SparkFun LED Stick
+
+<img src="SparkFunLEDStick_set_color_1.png">
+
+<img src="SparkFunLEDStick_set_brightness_1.png">
+
+<img src="SparkFunLEDStick_set_brightness_2.png">
+
+<img src="SparkFunLEDStick_set_color_2.png">
+
+<img src="SparkFunLEDStick_set_colors.png">
+
+<img src="SparkFunLEDStick_turn_all_off.png">

external_samples/sparkfun_led_stick.py

@@ -0,0 +1,65 @@
+from component import Component, PortType, InvalidPortException
+from enum import Enum
+import wpilib
+
+class SparkFunLEDStick(Component):    
+    def __init__(self, ports : list[tuple[PortType, int]]):
+        portType, port = ports[0]
+        if portType != PortType.I2C_PORT:
+            raise InvalidPortException
+        self.port = port
+
+    # Component methods
+
+    def get_manufacturer(self) -> str:   
+        return "SparkFun" 
+
+    def get_name(self) -> str:  
+        return "SparkFun Qwiic LED Strip"
+
+    def get_part_number(self) -> str:  
+        return "COM-18354"
+
+    def get_url(self) -> str:  
+        return "https://www.sparkfun.com/sparkfun-qwiic-led-stick-apa102c.html"
+
+    def get_version(self) -> tuple[int, int, str]: 
+        return (1, 0, "")
+
+    def stop(self) -> None:
+        self.turn_all_off()
+
+    def reset(self) -> None:
+        pass
+
+    def get_connection_port_type(self) -> list[PortType]:
+        return [PortType.I2C_PORT]
+
+    def periodic(self) -> None:
+        pass
+
+    # SparkFunLEDStick methods
+
+    def set_color(self, position: int, color: wpilib.Color) -> None:
+        '''Change the color of an individual LED.'''
+        pass # TODO: implement
+
+    def set_color(self, color: wpilib.Color) -> None:
+        '''Change the color of all LEDs to a single color.'''
+        pass # TODO: implement
+
+    def set_colors(self, colors: list[int]) -> None:
+        '''Change the color of all LEDs using a list.'''
+        pass # TODO: implement
+
+    def set_brightness(self, position: int, brightness: int) -> None:
+        '''Set the brightness of an individual LED.'''
+        pass # TODO: implement
+
+    def set_brightness(self, brightness: int) -> None:
+        '''Set the brightness of all LEDs.'''
+        pass # TODO: implement
+
+    def turn_all_off(self) -> None:
+        '''Turn all LEDs off.'''
+        pass # TODO: implement

src/blocks/mrc_call_python_function.ts

@@ -24,11 +24,13 @@ import * as Blockly from 'blockly';
 import { Order } from 'blockly/python';
 
 import * as pythonUtils from './utils/generated/python';
+import { createFieldDropdown } from '../fields/FieldDropdown';
 import { createFieldNonEditableText } from '../fields/FieldNonEditableText';
 import { getAllowedTypesForSetCheck, getOutputCheck } from './utils/python';
 import { ExtendedPythonGenerator } from '../editor/extended_python_generator';
 import { MRC_STYLE_FUNCTIONS } from '../themes/styles'
 import { ClassMethodDefExtraState } from './mrc_class_method_def'
+import { Editor } from '../editor/editor';
 
 // A block to call a python function.
 
@@ -40,10 +42,13 @@ enum FunctionKind {
   CONSTRUCTOR = 'constructor',
   INSTANCE = 'instance',
   INSTANCE_WITHIN = 'instance_within',
+  INSTANCE_COMPONENT = 'instance_component'
 }
 
 const RETURN_TYPE_NONE = 'None';
 
+const FIELD_COMPONENT_NAME = 'COMPONENT_NAME';
+
 export type FunctionArg = {
   name: string,
   type: string,
@@ -58,6 +63,8 @@ interface CallPythonFunctionMixin extends CallPythonFunctionMixinType {
   mrcImportModule: string,
   mrcActualFunctionName: string,
   mrcExportedFunction: boolean,
+  mrcComponentClassName: string,
+  mrcComponentName: string, // Do not access directly. Call getComponentName.
   renameMethod(this: CallPythonFunctionBlock, newName: string): void;
   mutateMethod(this: CallPythonFunctionBlock, defBlockExtraState: ClassMethodDefExtraState): void;
 }
@@ -99,6 +106,14 @@ type CallPythonFunctionExtraState = {
    * user's Project).
    */
   exportedFunction: boolean,
+  /**
+   * The component name. Specified only if the function kind is INSTANCE_COMPONENT.
+   */
+  componentName?: string,
+  /**
+   * The component class name. Specified only if the function kind is INSTANCE_COMPONENT.
+   */
+  componentClassName?: string,
 };
 
 const CALL_PYTHON_FUNCTION = {
@@ -138,6 +153,12 @@ const CALL_PYTHON_FUNCTION = {
           tooltip = 'Calls the method ' + functionName + '.';
           break;
         }
+        case FunctionKind.INSTANCE_COMPONENT: {
+          const className = this.mrcComponentClassName;
+          const functionName = this.getFieldValue(pythonUtils.FIELD_FUNCTION_NAME);
+          tooltip = 'Calls the function ' + className + '.' + functionName + '.';
+          break;
+        }
         default:
           throw new Error('mrcFunctionKind has unexpected value: ' + this.mrcFunctionKind)
       }
@@ -174,6 +195,12 @@ const CALL_PYTHON_FUNCTION = {
     if (this.mrcActualFunctionName) {
       extraState.actualFunctionName = this.mrcActualFunctionName;
     }
+    if (this.mrcComponentClassName) {
+      extraState.componentClassName = this.mrcComponentClassName;
+    }
+    if (this.getField(FIELD_COMPONENT_NAME)) {
+      extraState.componentName = this.getComponentName();
+    }
     return extraState;
   },
   /**
@@ -199,6 +226,10 @@ const CALL_PYTHON_FUNCTION = {
         ? extraState.actualFunctionName : '';
     this.mrcExportedFunction = extraState.exportedFunction
         ? extraState.exportedFunction : false;
+    this.mrcComponentClassName = extraState.componentClassName
+        ? extraState.componentClassName : '';
+    this.mrcComponentName = extraState.componentName
+        ? extraState.componentName : '';
     this.updateBlock_();
   },
   /**
@@ -260,6 +291,19 @@ const CALL_PYTHON_FUNCTION = {
           }
           break;
         }
+        case FunctionKind.INSTANCE_COMPONENT: {
+          const componentNames = Editor.getComponentNames(this.workspace, this.mrcComponentClassName);
+          const componentName = this.getComponentName();
+          if (!componentNames.includes(componentName)) {
+            componentNames.push(componentName);
+          }
+          this.appendDummyInput('TITLE')
+              .appendField('call')
+              .appendField(createFieldDropdown(componentNames), FIELD_COMPONENT_NAME)
+              .appendField('.')
+              .appendField(createFieldNonEditableText(''), pythonUtils.FIELD_FUNCTION_NAME);
+          break;
+        }
         default:
           throw new Error('mrcFunctionKind has unexpected value: ' + this.mrcFunctionKind)
       }
@@ -293,6 +337,15 @@ const CALL_PYTHON_FUNCTION = {
       this.removeInput('ARG' + i);
     }
   },
+  getComponentName(this: CallPythonFunctionBlock): string {
+    // If the COMPONENT_NAME field has been created, get the field value, which the user may have changed.
+    // If the COMPONENT_NAME field has not been created, get the component name from this.mrcComponentName.
+    return (this.getField(FIELD_COMPONENT_NAME))
+      ? this.getFieldValue(FIELD_COMPONENT_NAME) : this.mrcComponentName;
+  },
+  getComponentClassName(this: CallPythonFunctionBlock): string {
+    return this.mrcComponentClassName;
+  },
   renameMethod: function(this: CallPythonFunctionBlock, newName: string): void {
     this.setFieldValue(newName, pythonUtils.FIELD_FUNCTION_NAME);
   },
@@ -365,6 +418,15 @@ export const pythonFromBlock = function(
       code = 'self.' + functionName;
       break;
     }
+    case FunctionKind.INSTANCE_COMPONENT: {
+      const componentName = callPythonFunctionBlock.getComponentName();
+      const varName = generator.componentNameToVarName(componentName);
+      const functionName = callPythonFunctionBlock.mrcActualFunctionName
+          ? callPythonFunctionBlock.mrcActualFunctionName
+          : block.getFieldValue(pythonUtils.FIELD_FUNCTION_NAME);
+      code = 'self.' + varName + '.' + functionName;
+      break;
+    }
     default:
       throw new Error('mrcFunctionKind has unexpected value: ' + callPythonFunctionBlock.mrcFunctionKind)
   }

src/blocks/mrc_class_method_def.ts

@@ -458,7 +458,8 @@ export const pythonFromBlock = function (
         xfix2 = xfix1;
     }
     if(block.mrcPythonMethodName == '__init__'){
-        branch = generator.defineClassVariables() + branch;
+        branch = generator.INDENT + 'super().__init__()\n' +
+            generator.defineClassVariables() + branch;
     }    
     if (returnValue) {
         returnValue = generator.INDENT + 'return ' + returnValue + '\n';

src/editor/editor.ts

@@ -34,6 +34,8 @@ const EMPTY_TOOLBOX: Blockly.utils.toolbox.ToolboxDefinition = {
 };
 
 export class Editor {
+  private static workspaceIdToEditor: {[key: string]: Editor} = {};
+
   private blocklyWorkspace: Blockly.WorkspaceSvg;
   private generatorContext: GeneratorContext;
   private storage: commonStorage.Storage;
@@ -47,6 +49,7 @@ export class Editor {
   private toolbox: Blockly.utils.toolbox.ToolboxDefinition = EMPTY_TOOLBOX;
 
   constructor(blocklyWorkspace: Blockly.WorkspaceSvg, generatorContext: GeneratorContext, storage: commonStorage.Storage) {
+    Editor.workspaceIdToEditor[blocklyWorkspace.id] = this;
     this.blocklyWorkspace = blocklyWorkspace;
     this.generatorContext = generatorContext;
     this.storage = storage;
@@ -219,8 +222,17 @@ export class Editor {
     const exportedBlocks = JSON.stringify(this.generatorContext.getExportedBlocks());
     const blocksContent = JSON.stringify(
         Blockly.serialization.workspaces.save(this.blocklyWorkspace));
+    const componentsContent = JSON.stringify(this.getComponents());
     return commonStorage.makeModuleContent(
-        this.currentModule, pythonCode, exportedBlocks, blocksContent);
+        this.currentModule, pythonCode, blocksContent, exportedBlocks, componentsContent);
+  }
+
+  private getComponents(): commonStorage.Component[] {
+    const components: commonStorage.Component[] = [];
+    if (this.currentModule?.moduleType === commonStorage.MODULE_TYPE_PROJECT) {
+      // TODO(lizlooney): Fill the components array.
+    }
+    return components;
   }
 
   public async saveBlocks() {
@@ -233,4 +245,45 @@ export class Editor {
     }
   }
 
+  private getComponentNamesImpl(componentClassName: string): string[] {
+    if (!this.projectContent) {
+      throw new Error('getComponentNames: this.projectContent is null.');
+    }
+    const components = commonStorage.extractComponents(this.projectContent);
+
+    // TODO(lizlooney): Remove this fake code after getComponents (above) has been implemented.
+    components.push({name: 'frontTouch', className: 'wpilib.RevTouchSensor'});
+    components.push({name: 'backTouch', className: 'wpilib.RevTouchSensor'});
+    components.push({name: 'leftMotor', className: 'wpilib.SmartMotor'});
+    components.push({name: 'rightMotor', className: 'wpilib.SmartMotor'});
+    components.push({name: 'claw', className: 'wpilib.Servo'});
+    components.push({name: 'colorSensor', className: 'wpilib.ColorRangeSensor'});
+    components.push({name: 'ledStick', className: 'wpilib.SparkFunLEDStick'});
+    // End of fake code
+
+    const componentNames: string[] = [];
+    components.forEach((component) => {
+      if (component.className === componentClassName) {
+        componentNames.push(component.name);
+      }
+    });
+    return componentNames;
+  }
+
+  public static getComponentNames(
+      workspace: Blockly.Workspace, componentClassName: string): string[] {
+
+    let editor: Editor | null = null;
+    if (workspace.id in Editor.workspaceIdToEditor) {
+      editor = Editor.workspaceIdToEditor[workspace.id];
+    } else {
+      // If the workspace id was not found, it might be because the workspace is associated with the
+      // toolbox flyout, not a real workspace. In that case, use the first editor.
+      const allEditors = Object.values(Editor.workspaceIdToEditor);
+      if (allEditors.length) {
+        editor =  allEditors[0];
+      }
+    }
+    return editor ? editor.getComponentNamesImpl(componentClassName) : [];
+  }
 }