diff options
| author | Clyne Sullivan <tullivan99@gmail.com> | 2015-11-30 16:02:10 -0500 |
|---|---|---|
| committer | Clyne Sullivan <tullivan99@gmail.com> | 2015-11-30 16:02:10 -0500 |
| commit | 670e4d1797ea5e5bdd0e4aa43a1faf5d63b65172 (patch) | |
| tree | 1d5744ba081429dfb914dbe00b8e22965edd5f7b | |
| parent | 31912e28d5311a0e8585dc36e2c01cdd0e3315ca (diff) | |
| parent | a177ec446598382b91cabbce032aa580badffe70 (diff) | |
Merge branch 'master' of https://github.com/drumsetmonkey/vex5106z
22 files changed, 2490 insertions, 0 deletions
diff --git a/Nate's Position Testing/Shooter Testing/.cproject b/Nate's Position Testing/Shooter Testing/.cproject new file mode 100644 index 0000000..e2e54f6 --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/.cproject @@ -0,0 +1,84 @@ +<?xml version="1.0" encoding="UTF-8" standalone="no"?> +<?fileVersion 4.0.0?> + +<cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage"> + <storageModule moduleId="org.eclipse.cdt.core.settings"> + <cconfiguration id="cdt.managedbuild.toolchain.gnu.cross.base.1066004663"> + <storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="cdt.managedbuild.toolchain.gnu.cross.base.1066004663" moduleId="org.eclipse.cdt.core.settings" name="Default"> + <externalSettings/> + <extensions> + <extension id="org.eclipse.cdt.core.ELF" point="org.eclipse.cdt.core.BinaryParser"/> + <extension id="org.eclipse.cdt.core.GmakeErrorParser" point="org.eclipse.cdt.core.ErrorParser"/> + <extension id="org.eclipse.cdt.core.CWDLocator" point="org.eclipse.cdt.core.ErrorParser"/> + <extension id="org.eclipse.cdt.core.GCCErrorParser" point="org.eclipse.cdt.core.ErrorParser"/> + <extension id="org.eclipse.cdt.core.GLDErrorParser" point="org.eclipse.cdt.core.ErrorParser"/> + </extensions> + </storageModule> + <storageModule moduleId="cdtBuildSystem" version="4.0.0"> + <configuration buildProperties="" description="" id="cdt.managedbuild.toolchain.gnu.cross.base.1066004663" name="Default" parent="org.eclipse.cdt.build.core.emptycfg"> + <folderInfo id="cdt.managedbuild.toolchain.gnu.cross.base.1066004663.216315519" name="/" resourcePath=""> + <toolChain id="cdt.managedbuild.toolchain.gnu.cross.base.375388531" name="cdt.managedbuild.toolchain.gnu.cross.base" resourceTypeBasedDiscovery="true" superClass="cdt.managedbuild.toolchain.gnu.cross.base"> + <option id="cdt.managedbuild.option.gnu.cross.prefix.599893882" name="Prefix" superClass="cdt.managedbuild.option.gnu.cross.prefix"/> + <option id="cdt.managedbuild.option.gnu.cross.path.1759346474" name="Path" superClass="cdt.managedbuild.option.gnu.cross.path"/> + <targetPlatform archList="all" binaryParser="org.eclipse.cdt.core.ELF" id="cdt.managedbuild.targetPlatform.gnu.cross.2134707772" isAbstract="false" osList="all" superClass="cdt.managedbuild.targetPlatform.gnu.cross"/> + <builder id="cdt.managedbuild.builder.gnu.cross.779610124" keepEnvironmentInBuildfile="false" managedBuildOn="false" name="Gnu Make Builder" superClass="cdt.managedbuild.builder.gnu.cross"/> + <tool id="cdt.managedbuild.tool.gnu.cross.c.compiler.1492636040" name="Cross GCC Compiler" superClass="cdt.managedbuild.tool.gnu.cross.c.compiler"> + <inputType id="cdt.managedbuild.tool.gnu.c.compiler.input.1080172599" superClass="cdt.managedbuild.tool.gnu.c.compiler.input"/> + </tool> + <tool id="cdt.managedbuild.tool.gnu.cross.cpp.compiler.1535676614" name="Cross G++ Compiler" superClass="cdt.managedbuild.tool.gnu.cross.cpp.compiler"/> + <tool id="cdt.managedbuild.tool.gnu.cross.c.linker.666130241" name="Cross GCC Linker" superClass="cdt.managedbuild.tool.gnu.cross.c.linker"> + <inputType id="cdt.managedbuild.tool.gnu.c.linker.input.1115410559" superClass="cdt.managedbuild.tool.gnu.c.linker.input"> + <additionalInput kind="additionalinputdependency" paths="$(USER_OBJS)"/> + <additionalInput kind="additionalinput" paths="$(LIBS)"/> + </inputType> + </tool> + <tool id="cdt.managedbuild.tool.gnu.cross.cpp.linker.274329887" name="Cross G++ Linker" superClass="cdt.managedbuild.tool.gnu.cross.cpp.linker"/> + </toolChain> + </folderInfo> + </configuration> + </storageModule> + <storageModule moduleId="org.eclipse.cdt.core.externalSettings"/> + </cconfiguration> + </storageModule> + <storageModule moduleId="scannerConfiguration"> + <autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/> + <scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.cross.base.1066004663;cdt.managedbuild.toolchain.gnu.cross.base.1066004663.216315519;cdt.managedbuild.tool.gnu.cross.c.compiler.1492636040;cdt.managedbuild.tool.gnu.c.compiler.input.1080172599"> + <autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfileC"/> + <profile id="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfileC"> + <buildOutputProvider> + <openAction enabled="true" filePath=""/> + <parser enabled="false"/> + </buildOutputProvider> + <scannerInfoProvider id="specsFile"> + <runAction arguments="-E -P -v -dD ${plugin_state_location}/specs.c -mthumb -mcpu=cortex-m3 -mlittle-endian" command="arm-none-eabi-gcc" useDefault="true"/> + <parser enabled="true"/> + </scannerInfoProvider> + </profile> + </scannerConfigBuildInfo> + <scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.cross.base.1066004663"> + <autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfileC"/> + <profile id="org.eclipse.cdt.managedbuilder.core.GCCManagedMakePerProjectProfileC"> + <buildOutputProvider> + <openAction enabled="true" filePath=""/> + <parser enabled="false"/> + </buildOutputProvider> + <scannerInfoProvider id="specsFile"> + <runAction arguments="-E -P -v -dD ${plugin_state_location}/specs.c -mthumb -mcpu=cortex-m3 -mlittle-endian" command="arm-none-eabi-gcc" useDefault="true"/> + <parser enabled="true"/> + </scannerInfoProvider> + </profile> + </scannerConfigBuildInfo> + </storageModule> + <storageModule moduleId="org.eclipse.cdt.make.core.buildtargets"> + <buildTargets> + <target name="upload" path="" targetID="org.eclipse.cdt.build.MakeTargetBuilder"> + <buildCommand>make</buildCommand> + <buildArguments/> + <buildTarget>upload</buildTarget> + <stopOnError>false</stopOnError> + <useDefaultCommand>true</useDefaultCommand> + <runAllBuilders>false</runAllBuilders> + </target> + </buildTargets> + </storageModule> +</cproject> diff --git a/Nate's Position Testing/Shooter Testing/.project b/Nate's Position Testing/Shooter Testing/.project new file mode 100644 index 0000000..36cbd3b --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/.project @@ -0,0 +1,78 @@ +<?xml version="1.0" encoding="UTF-8"?> +<projectDescription> + <name>Shooter Testing</name> + <comment></comment> + <projects> + </projects> + <buildSpec> + <buildCommand> + <name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name> + <triggers>clean,full,incremental,</triggers> + <arguments> + <dictionary> + <key>?name?</key> + <value></value> + </dictionary> + <dictionary> + <key>org.eclipse.cdt.make.core.append_environment</key> + <value>true</value> + </dictionary> + <dictionary> + <key>org.eclipse.cdt.make.core.autoBuildTarget</key> + <value>all</value> + </dictionary> + <dictionary> + <key>org.eclipse.cdt.make.core.buildArguments</key> + <value></value> + </dictionary> + <dictionary> + <key>org.eclipse.cdt.make.core.buildCommand</key> + <value>make</value> + </dictionary> + <dictionary> + <key>org.eclipse.cdt.make.core.cleanBuildTarget</key> + <value>clean</value> + </dictionary> + <dictionary> + <key>org.eclipse.cdt.make.core.contents</key> + <value>org.eclipse.cdt.make.core.activeConfigSettings</value> + </dictionary> + <dictionary> + <key>org.eclipse.cdt.make.core.enableAutoBuild</key> + <value>false</value> + </dictionary> + <dictionary> + <key>org.eclipse.cdt.make.core.enableCleanBuild</key> + <value>true</value> + </dictionary> + <dictionary> + <key>org.eclipse.cdt.make.core.enableFullBuild</key> + <value>true</value> + </dictionary> + <dictionary> + <key>org.eclipse.cdt.make.core.fullBuildTarget</key> + <value>all</value> + </dictionary> + <dictionary> + <key>org.eclipse.cdt.make.core.stopOnError</key> + <value>true</value> + </dictionary> + <dictionary> + <key>org.eclipse.cdt.make.core.useDefaultBuildCmd</key> + <value>true</value> + </dictionary> + </arguments> + </buildCommand> + <buildCommand> + <name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name> + <triggers>full,incremental,</triggers> + <arguments> + </arguments> + </buildCommand> + </buildSpec> + <natures> + <nature>org.eclipse.cdt.core.cnature</nature> + <nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature> + <nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature> + </natures> +</projectDescription> diff --git a/Nate's Position Testing/Shooter Testing/Makefile b/Nate's Position Testing/Shooter Testing/Makefile new file mode 100644 index 0000000..5d6b7fc --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/Makefile @@ -0,0 +1,69 @@ +# Universal C Makefile for MCU targets
+
+# Path to project root (for top-level, so the project is in ./; first-level, ../; etc.)
+ROOT=.
+# Binary output directory
+BINDIR=$(ROOT)/bin
+# Subdirectories to include in the build
+SUBDIRS=src
+
+# Nothing below here needs to be modified by typical users
+
+# Include common aspects of this project
+-include $(ROOT)/common.mk
+
+ASMSRC:=$(wildcard *.$(ASMEXT))
+ASMOBJ:=$(patsubst %.o,$(BINDIR)/%.o,$(ASMSRC:.$(ASMEXT)=.o))
+HEADERS:=$(wildcard *.$(HEXT))
+CSRC=$(wildcard *.$(CEXT))
+COBJ:=$(patsubst %.o,$(BINDIR)/%.o,$(CSRC:.$(CEXT)=.o))
+CPPSRC:=$(wildcard *.$(CPPEXT))
+CPPOBJ:=$(patsubst %.o,$(BINDIR)/%.o,$(CPPSRC:.$(CPPEXT)=.o))
+OUT:=$(BINDIR)/$(OUTNAME)
+
+.PHONY: all clean upload _force_look
+
+# By default, compile program
+all: $(BINDIR) $(OUT)
+
+# Remove all intermediate object files (remove the binary directory)
+clean:
+ -rm -f $(OUT)
+ -rm -rf $(BINDIR)
+
+# Uploads program to device
+upload: all
+ $(UPLOAD)
+
+# Phony force-look target
+_force_look:
+ @true
+
+# Looks in subdirectories for things to make
+$(SUBDIRS): %: _force_look
+ @$(MAKE) --no-print-directory -C $@
+
+# Ensure binary directory exists
+$(BINDIR):
+ -@mkdir -p $(BINDIR)
+
+# Compile program
+$(OUT): $(SUBDIRS) $(ASMOBJ) $(COBJ) $(CPPOBJ)
+ @echo LN $(BINDIR)/*.o $(LIBRARIES) to $@
+ @$(CC) $(LDFLAGS) $(BINDIR)/*.o $(LIBRARIES) -o $@
+ @$(MCUPREFIX)size $(SIZEFLAGS) $(OUT)
+ $(MCUPREPARE)
+
+# Assembly source file management
+$(ASMOBJ): $(BINDIR)/%.o: %.$(ASMEXT) $(HEADERS)
+ @echo AS $<
+ @$(AS) $(AFLAGS) -o $@ $<
+
+# Object management
+$(COBJ): $(BINDIR)/%.o: %.$(CEXT) $(HEADERS)
+ @echo CC $(INCLUDE) $<
+ @$(CC) $(INCLUDE) $(CFLAGS) -o $@ $<
+
+$(CPPOBJ): $(BINDIR)/%.o: %.$(CPPEXT) $(HEADERS)
+ @echo CPC $(INCLUDE) $<
+ @$(CPPCC) $(INCLUDE) $(CPPFLAGS) -o $@ $<
diff --git a/Nate's Position Testing/Shooter Testing/bin/auto.o b/Nate's Position Testing/Shooter Testing/bin/auto.o Binary files differnew file mode 100644 index 0000000..689d59c --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/bin/auto.o diff --git a/Nate's Position Testing/Shooter Testing/bin/init.o b/Nate's Position Testing/Shooter Testing/bin/init.o Binary files differnew file mode 100644 index 0000000..96666b7 --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/bin/init.o diff --git a/Nate's Position Testing/Shooter Testing/bin/opcontrol.o b/Nate's Position Testing/Shooter Testing/bin/opcontrol.o Binary files differnew file mode 100644 index 0000000..9a2d40f --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/bin/opcontrol.o diff --git a/Nate's Position Testing/Shooter Testing/bin/output.bin b/Nate's Position Testing/Shooter Testing/bin/output.bin Binary files differnew file mode 100644 index 0000000..363b7a9 --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/bin/output.bin diff --git a/Nate's Position Testing/Shooter Testing/bin/output.elf b/Nate's Position Testing/Shooter Testing/bin/output.elf Binary files differnew file mode 100644 index 0000000..73c390b --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/bin/output.elf diff --git a/Nate's Position Testing/Shooter Testing/common.mk b/Nate's Position Testing/Shooter Testing/common.mk new file mode 100644 index 0000000..58098f5 --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/common.mk @@ -0,0 +1,45 @@ +# Universal C Makefile for MCU targets
+# Top-level template file to configure build
+
+# Makefile for IFI VeX Cortex Microcontroller (STM32F103VD series)
+DEVICE=VexCortex
+# Libraries to include in the link (use -L and -l) e.g. -lm, -lmyLib
+LIBRARIES=$(ROOT)/firmware/libccos.a -lgcc -lm
+# Prefix for ARM tools (must be on the path)
+MCUPREFIX=arm-none-eabi-
+# Flags for the assembler
+MCUAFLAGS=-mthumb -mcpu=cortex-m3 -mlittle-endian
+# Flags for the compiler
+MCUCFLAGS=-mthumb -mcpu=cortex-m3 -mlittle-endian
+# Flags for the linker
+MCULFLAGS=-nostartfiles -Wl,-static -Bfirmware -Wl,-u,VectorTable -Wl,-T -Xlinker firmware/cortex.ld
+# Prepares the elf file by converting it to a binary that java can write
+MCUPREPARE=$(OBJCOPY) $(OUT) -O binary $(BINDIR)/$(OUTBIN)
+# Advanced sizing flags
+SIZEFLAGS=
+# Uploads program using java
+UPLOAD=@java -jar firmware/uniflash.jar vex $(BINDIR)/$(OUTBIN)
+
+# Advanced options
+ASMEXT=s
+CEXT=c
+CPPEXT=cpp
+HEXT=h
+INCLUDE=-I$(ROOT)/include -I$(ROOT)/src
+OUTBIN=output.bin
+OUTNAME=output.elf
+
+# Flags for programs
+AFLAGS:=$(MCUAFLAGS)
+ARFLAGS:=$(MCUCFLAGS)
+CCFLAGS:=-c -Wall $(MCUCFLAGS) -Os -ffunction-sections -fsigned-char -fomit-frame-pointer -fsingle-precision-constant
+CFLAGS:=$(CCFLAGS) -std=gnu99 -Werror=implicit-function-declaration
+CPPFLAGS:=$(CCFLAGS) -fno-exceptions -fno-rtti -felide-constructors
+LDFLAGS:=-Wall $(MCUCFLAGS) $(MCULFLAGS) -Wl,--gc-sections
+
+# Tools used in program
+AR:=$(MCUPREFIX)ar
+AS:=$(MCUPREFIX)as
+CC:=$(MCUPREFIX)gcc
+CPPCC:=$(MCUPREFIX)g++
+OBJCOPY:=$(MCUPREFIX)objcopy
diff --git a/Nate's Position Testing/Shooter Testing/firmware/STM32F10x.ld b/Nate's Position Testing/Shooter Testing/firmware/STM32F10x.ld new file mode 100644 index 0000000..e6caa0d --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/firmware/STM32F10x.ld @@ -0,0 +1,100 @@ +/* Memory space definitions */
+MEMORY {
+ RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 64K
+ FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 384K
+}
+
+/* Higher address of the user mode stack */
+EXTERN ( _estack );
+PROVIDE ( _estack = ORIGIN(RAM) + LENGTH(RAM) );
+
+/* This sends all unreferenced IRQHandlers to reset. */
+PROVIDE ( ISR_SWI = 0 );
+PROVIDE ( ISR_IRQ = 0 );
+PROVIDE ( ISR_Prefetch = 0 );
+PROVIDE ( ISR_Abort = 0 );
+PROVIDE ( ISR_FIQ = 0 );
+
+PROVIDE ( ISR_NMI = 0 );
+PROVIDE ( ISR_HardFault = 0 );
+PROVIDE ( ISR_MemManage = 0 );
+PROVIDE ( ISR_BusFault = 0 );
+PROVIDE ( ISR_UsageFault = 0 );
+
+PROVIDE ( ISR_SVC = 0 );
+PROVIDE ( ISR_DebugMon = 0 );
+PROVIDE ( ISR_PendSV = 0 );
+PROVIDE ( ISR_SysTick = 0 );
+
+PROVIDE ( ISR_WWDG = 0 );
+PROVIDE ( ISR_PVD = 0 );
+PROVIDE ( ISR_TAMPER = 0 );
+PROVIDE ( ISR_RTC = 0 );
+PROVIDE ( ISR_FLASH = 0 );
+PROVIDE ( ISR_RCC = 0 );
+PROVIDE ( ISR_EXTI0 = 0 );
+PROVIDE ( ISR_EXTI1 = 0 );
+PROVIDE ( ISR_EXTI2 = 0 );
+PROVIDE ( ISR_EXTI3 = 0 );
+PROVIDE ( ISR_EXTI4 = 0 );
+PROVIDE ( ISR_DMAChannel1 = 0 );
+PROVIDE ( ISR_DMAChannel2 = 0 );
+PROVIDE ( ISR_DMAChannel3 = 0 );
+PROVIDE ( ISR_DMAChannel4 = 0 );
+PROVIDE ( ISR_DMAChannel5 = 0 );
+PROVIDE ( ISR_DMAChannel6 = 0 );
+PROVIDE ( ISR_DMAChannel7 = 0 );
+PROVIDE ( ISR_DMA1_Channel1 = 0 );
+PROVIDE ( ISR_DMA1_Channel2 = 0 );
+PROVIDE ( ISR_DMA1_Channel3 = 0 );
+PROVIDE ( ISR_DMA1_Channel4 = 0 );
+PROVIDE ( ISR_DMA1_Channel5 = 0 );
+PROVIDE ( ISR_DMA1_Channel6 = 0 );
+PROVIDE ( ISR_DMA1_Channel7 = 0 );
+PROVIDE ( ISR_ADC = 0 );
+PROVIDE ( ISR_ADC1_2 = 0 );
+PROVIDE ( ISR_USB_HP_CAN_TX = 0 );
+PROVIDE ( ISR_USB_HP_CAN1_TX = 0 );
+PROVIDE ( ISR_USB_LP_CAN_RX0 = 0 );
+PROVIDE ( ISR_USB_LP_CAN1_RX0 = 0 );
+PROVIDE ( ISR_CAN_RX1 = 0 );
+PROVIDE ( ISR_CAN1_RX1 = 0 );
+PROVIDE ( ISR_CAN_SCE = 0 );
+PROVIDE ( ISR_CAN1_SCE = 0 );
+PROVIDE ( ISR_EXTI9_5 = 0 );
+PROVIDE ( ISR_TIM1_BRK = 0 );
+PROVIDE ( ISR_TIM1_UP = 0 );
+PROVIDE ( ISR_TIM1_TRG_COM = 0 );
+PROVIDE ( ISR_TIM1_CC = 0 );
+PROVIDE ( ISR_TIM2 = 0 );
+PROVIDE ( ISR_TIM3 = 0 );
+PROVIDE ( ISR_TIM4 = 0 );
+PROVIDE ( ISR_I2C1_EV = 0 );
+PROVIDE ( ISR_I2C1_ER = 0 );
+PROVIDE ( ISR_I2C2_EV = 0 );
+PROVIDE ( ISR_I2C2_ER = 0 );
+PROVIDE ( ISR_SPI1 = 0 );
+PROVIDE ( ISR_SPI2 = 0 );
+PROVIDE ( ISR_USART1 = 0 );
+PROVIDE ( ISR_USART2 = 0 );
+PROVIDE ( ISR_USART3 = 0 );
+PROVIDE ( ISR_EXTI15_10 = 0 );
+PROVIDE ( ISR_RTCAlarm = 0 );
+PROVIDE ( ISR_USBWakeUp = 0 );
+PROVIDE ( ISR_TIM8_BRK = 0 );
+PROVIDE ( ISR_TIM8_UP = 0 );
+PROVIDE ( ISR_TIM8_TRG_COM = 0 );
+PROVIDE ( ISR_TIM8_CC = 0 );
+PROVIDE ( ISR_ADC3 = 0 );
+PROVIDE ( ISR_FSMC = 0 );
+PROVIDE ( ISR_SDIO = 0 );
+PROVIDE ( ISR_TIM5 = 0 );
+PROVIDE ( ISR_SPI3 = 0 );
+PROVIDE ( ISR_UART4 = 0 );
+PROVIDE ( ISR_UART5 = 0 );
+PROVIDE ( ISR_TIM6 = 0 );
+PROVIDE ( ISR_TIM7 = 0 );
+PROVIDE ( ISR_DMA2_Channel1 = 0 );
+PROVIDE ( ISR_DMA2_Channel2 = 0 );
+PROVIDE ( ISR_DMA2_Channel3 = 0 );
+PROVIDE ( ISR_DMA2_Channel4_5 = 0 );
diff --git a/Nate's Position Testing/Shooter Testing/firmware/cortex.ld b/Nate's Position Testing/Shooter Testing/firmware/cortex.ld new file mode 100644 index 0000000..36d5aa5 --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/firmware/cortex.ld @@ -0,0 +1,123 @@ +/* Include STM32F10X linker scripts */
+INCLUDE "STM32F10x.ld"
+
+EXTERN ( _heapbegin );
+
+/* Section definitions for Cortex firmware flashing */
+SECTIONS {
+ .isr_vector : {
+ /* startup code, prevents garbage collection from eating everything */
+ KEEP(*(.isr_vector))
+ . = ALIGN(4);
+ } >FLASH
+ .text : {
+ . = ALIGN(4);
+ *(.text)
+ *(.text.*)
+ /* Preinit array of functions */
+ __preinit_array_start = .;
+ KEEP (*(.preinit_array))
+ __preinit_array_end = .;
+ . = ALIGN(4);
+ /* Init array of functions */
+ KEEP(*(.init))
+ . = ALIGN(4);
+ __init_array_start = .;
+ KEEP (*(SORT(.init_array.*)))
+ KEEP (*(.init_array))
+ __init_array_end = .;
+ . = ALIGN(4);
+ /* C++ constructors */
+ KEEP (*crtbegin.o(.ctors))
+ KEEP (*(EXCLUDE_FILE (*crtend.o) .ctors))
+ KEEP (*(SORT(.ctors.*)))
+ KEEP (*crtend.o(.ctors))
+ . = ALIGN(4);
+ /* Finalizer array of functions */
+ KEEP(*(.fini))
+ . = ALIGN(4);
+ __fini_array_start = .;
+ KEEP (*(.fini_array))
+ KEEP (*(SORT(.fini_array.*)))
+ __fini_array_end = .;
+ . = ALIGN(4);
+ /* C++ destructors */
+ KEEP (*crtbegin.o(.dtors))
+ KEEP (*(EXCLUDE_FILE (*crtend.o) .dtors))
+ KEEP (*(SORT(.dtors.*)))
+ KEEP (*crtend.o(.dtors))
+ _etext = .;
+ _srdata = .;
+ . = ALIGN(4);
+ *(.rodata)
+ *(.rodata*)
+ *(.glue_7)
+ *(.glue_7t)
+ . = ALIGN(4);
+ _erdata = .;
+ _sidata = .;
+ } >FLASH
+ /* The program executes knowing that the data is in the RAM, but the loader puts the
+ * initial values in the FLASH (inidata). The startup copies the initial values over */
+ .data : AT ( _sidata ) {
+ . = ALIGN(4);
+ _sdata = .;
+ *(.data)
+ *(.data.*)
+ *(.RAMtext)
+ . = ALIGN(4);
+ _edata = .;
+ } >RAM
+ /* Uninitialized data (zero-fill) section */
+ .bss : {
+ . = ALIGN(4);
+ _sbss = .;
+ *(.bss)
+ *(COMMON)
+ . = ALIGN(4);
+ _ebss = .;
+ . = ALIGN(8);
+ _heapbegin = .;
+ } >RAM
+
+ /DISCARD/ : {
+ libc.a ( * )
+ libg.a ( * )
+ libm.a ( * )
+ libgcc.a ( * )
+ libstdc++.a ( * )
+ libsupc++.a ( * )
+ }
+ /* ARM exception unwinding, mandated by ARM EABI C++ standard (with -fno-exceptions?) */
+ .ARM.exidx 0 : { *(.ARM.exidx*) }
+ /* Stabs debugging sections */
+ .stab 0 : { *(.stab) }
+ .stabstr 0 : { *(.stabstr) }
+ .stab.excl 0 : { *(.stab.excl) }
+ .stab.exclstr 0 : { *(.stab.exclstr) }
+ .stab.index 0 : { *(.stab.index) }
+ .stab.indexstr 0 : { *(.stab.indexstr) }
+ .comment 0 : { *(.comment) }
+ /* DWARF 1 */
+ .debug 0 : { *(.debug) }
+ .line 0 : { *(.line) }
+ /* GNU DWARF 1 extensions */
+ .debug_srcinfo 0 : { *(.debug_srcinfo) }
+ .debug_sfnames 0 : { *(.debug_sfnames) }
+ /* DWARF 1.1 and DWARF 2 */
+ .debug_aranges 0 : { *(.debug_aranges) }
+ .debug_pubnames 0 : { *(.debug_pubnames) }
+ /* DWARF 2 */
+ .debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
+ .debug_abbrev 0 : { *(.debug_abbrev) }
+ .debug_line 0 : { *(.debug_line) }
+ .debug_frame 0 : { *(.debug_frame) }
+ .debug_str 0 : { *(.debug_str) }
+ .debug_loc 0 : { *(.debug_loc) }
+ .debug_macinfo 0 : { *(.debug_macinfo) }
+ /* SGI/MIPS DWARF 2 extensions */
+ .debug_weaknames 0 : { *(.debug_weaknames) }
+ .debug_funcnames 0 : { *(.debug_funcnames) }
+ .debug_typenames 0 : { *(.debug_typenames) }
+ .debug_varnames 0 : { *(.debug_varnames) }
+}
diff --git a/Nate's Position Testing/Shooter Testing/firmware/libccos.a b/Nate's Position Testing/Shooter Testing/firmware/libccos.a Binary files differnew file mode 100644 index 0000000..469b330 --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/firmware/libccos.a diff --git a/Nate's Position Testing/Shooter Testing/firmware/uniflash.jar b/Nate's Position Testing/Shooter Testing/firmware/uniflash.jar Binary files differnew file mode 100644 index 0000000..a922ae9 --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/firmware/uniflash.jar diff --git a/Nate's Position Testing/Shooter Testing/include/API.h b/Nate's Position Testing/Shooter Testing/include/API.h new file mode 100644 index 0000000..7de7889 --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/include/API.h @@ -0,0 +1,1553 @@ +/** @file API.h
+ * @brief Provides the high-level user functionality intended for use by typical VEX Cortex
+ * programmers.
+ *
+ * This file should be included for you in the predefined stubs in each new VEX Cortex PROS
+ * project through the inclusion of "main.h". In any new C source file, it is advisable to
+ * include main.h instead of referencing API.h by name, to better handle any nomenclature
+ * changes to this file or its contents.
+ *
+ * Copyright (c) 2011-2014, Purdue University ACM SIG BOTS.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * * Neither the name of Purdue University ACM SIG BOTS nor the
+ * names of its contributors may be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL PURDUE UNIVERSITY ACM SIG BOTS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Purdue Robotics OS contains FreeRTOS (http://www.freertos.org) whose source code may be
+ * obtained from http://sourceforge.net/projects/freertos/files/ or on request.
+ */
+
+#ifndef API_H_
+#define API_H_
+
+// System includes
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdarg.h>
+
+// Begin C++ extern to C
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// -------------------- VEX competition functions --------------------
+
+/**
+ * DOWN button (valid on channels 5, 6, 7, 8)
+ */
+#define JOY_DOWN 1
+/**
+ * LEFT button (valid on channels 7, 8)
+ */
+#define JOY_LEFT 2
+/**
+ * UP button (valid on channels 5, 6, 7, 8)
+ */
+#define JOY_UP 4
+/**
+ * RIGHT button (valid on channels 7, 8)
+ */
+#define JOY_RIGHT 8
+/**
+ * Analog axis for the X acceleration from the VEX Joystick.
+ */
+#define ACCEL_X 5
+/**
+ * Analog axis for the Y acceleration from the VEX Joystick.
+ */
+#define ACCEL_Y 6
+
+/**
+ * Returns true if the robot is in autonomous mode, or false otherwise.
+ *
+ * While in autonomous mode, joystick inputs will return a neutral value, but serial port
+ * communications (even over VexNET) will still work properly.
+ */
+bool isAutonomous();
+/**
+ * Returns true if the robot is enabled, or false otherwise.
+ *
+ * While disabled via the VEX Competition Switch or VEX Field Controller, motors will not
+ * function. However, the digital I/O ports can still be changed, which may indirectly affect
+ * the robot state (e.g. solenoids). Avoid performing externally visible actions while
+ * disabled (the kernel should take care of this most of the time).
+ */
+bool isEnabled();
+/**
+ * Returns true if a joystick is connected to the specified slot number (1 or 2), or false
+ * otherwise.
+ *
+ * Useful for automatically merging joysticks for one operator, or splitting for two. This
+ * function does not work properly during initialize() or initializeIO() and can return false
+ * positives. It should be checked once and stored at the beginning of operatorControl().
+ *
+ * @param joystick the joystick slot to check
+ */
+bool isJoystickConnected(unsigned char joystick);
+/**
+ * Returns true if a VEX field controller or competition switch is connected, or false
+ * otherwise.
+ *
+ * When in online mode, the switching between autonomous() and operatorControl() tasks is
+ * managed by the PROS kernel.
+ */
+bool isOnline();
+/**
+ * Gets the value of a control axis on the VEX joystick. Returns the value from -127 to 127,
+ * or 0 if no joystick is connected to the requested slot.
+ *
+ * @param joystick the joystick slot to check
+ * @param axis one of 1, 2, 3, 4, ACCEL_X, or ACCEL_Y
+ */
+int joystickGetAnalog(unsigned char joystick, unsigned char axis);
+/**
+ * Gets the value of a button on the VEX joystick. Returns true if that button is pressed, or
+ * false otherwise. If no joystick is connected to the requested slot, returns false.
+ *
+ * @param joystick the joystick slot to check
+ * @param buttonGroup one of 5, 6, 7, or 8 to request that button as labelled on the joystick
+ * @param button one of JOY_UP, JOY_DOWN, JOY_LEFT, or JOY_RIGHT; requesting JOY_LEFT or
+ * JOY_RIGHT for groups 5 or 6 will cause an undefined value to be returned
+ */
+bool joystickGetDigital(unsigned char joystick, unsigned char buttonGroup,
+ unsigned char button);
+/**
+ * Returns the backup battery voltage in millivolts.
+ *
+ * If no backup battery is connected, returns 0.
+ */
+unsigned int powerLevelBackup();
+/**
+ * Returns the main battery voltage in millivolts.
+ *
+ * In rare circumstances, this method might return 0. Check the output value for reasonability
+ * before blindly blasting the user.
+ */
+unsigned int powerLevelMain();
+/**
+ * Sets the team name displayed to the VEX field control and VEX Firmware Upgrade.
+ *
+ * @param name a string containing the team name; only the first eight characters will be shown
+ */
+void setTeamName(const char *name);
+
+// -------------------- Pin control functions --------------------
+
+/**
+ * There are 8 available analog I/O on the Cortex.
+ */
+#define BOARD_NR_ADC_PINS 8
+/**
+ * There are 27 available I/O on the Cortex that can be used for digital communication.
+ *
+ * This excludes the crystal ports but includes the Communications, Speaker, and Analog ports.
+ *
+ * The motor ports are not on the Cortex and are thus excluded from this count. Pin 0 is the
+ * Speaker port, pins 1-12 are the standard Digital I/O, 13-20 are the Analog I/O, 21+22 are
+ * UART1, 23+24 are UART2, and 25+26 are the I2C port.
+ */
+#define BOARD_NR_GPIO_PINS 27
+/**
+ * Used for digitalWrite() to specify a logic HIGH state to output.
+ *
+ * In reality, using any non-zero expression or "true" will work to set a pin to HIGH.
+ */
+#define HIGH 1
+/**
+ * Used for digitalWrite() to specify a logic LOW state to output.
+ *
+ * In reality, using a zero expression or "false" will work to set a pin to LOW.
+ */
+#define LOW 0
+
+/**
+ * pinMode() state for digital input, with pullup.
+ *
+ * This is the default state for the 12 Digital pins. The pullup causes the input to read as
+ * "HIGH" when unplugged, but is fairly weak and can safely be driven by most sources. Many VEX
+ * digital sensors rely on this behavior and cannot be used with INPUT_FLOATING.
+ */
+#define INPUT 0x0A
+/**
+ * pinMode() state for analog inputs.
+ *
+ * This is the default state for the 8 Analog pins and the Speaker port. This only works on
+ * pins with analog input capabilities; use anywhere else results in undefined behavior.
+ */
+#define INPUT_ANALOG 0x00
+/**
+ * pinMode() state for digital input, without pullup.
+ *
+ * Beware of power consumption, as digital inputs left "floating" may switch back and forth
+ * and cause spurious interrupts.
+ */
+#define INPUT_FLOATING 0x04
+/**
+ * pinMode() state for digital output, push-pull.
+ *
+ * This is the mode which should be used to output a digital HIGH or LOW value from the Cortex.
+ * This mode is useful for pneumatic solenoid valves and VEX LEDs.
+ */
+#define OUTPUT 0x01
+/**
+ * pinMode() state for open-drain outputs.
+ *
+ * This is useful in a few cases for external electronics and should not be used for the VEX
+ * solenoid or LEDs.
+ */
+#define OUTPUT_OD 0x05
+
+/**
+ * Calibrates the analog sensor on the specified channel.
+ *
+ * This method assumes that the true sensor value is not actively changing at this time and
+ * computes an average from approximately 500 samples, 1 ms apart, for a 0.5 s period of
+ * calibration. The average value thus calculated is returned and stored for later calls to the
+ * analogReadCalibrated() and analogReadCalibratedHR() functions. These functions will return
+ * the difference between this value and the current sensor value when called.
+ *
+ * Do not use this function in initializeIO(), or when the sensor value might be unstable
+ * (gyro rotation, accelerometer movement).
+ *
+ * This function may not work properly if the VEX Cortex is tethered to a PC using the orange
+ * USB A to A cable and has no VEX 7.2V Battery connected and powered on, as the VEX Battery
+ * provides power to sensors.
+ *
+ * @param channel the channel to calibrate from 1-8
+ * @return the average sensor value computed by this function
+ */
+int analogCalibrate(unsigned char channel);
+/**
+ * Reads an analog input channel and returns the 12-bit value.
+ *
+ * The value returned is undefined if the analog pin has been switched to a different mode.
+ * This function is Wiring-compatible with the exception of the larger output range. The
+ * meaning of the returned value varies depending on the sensor attached.
+ *
+ * This function may not work properly if the VEX Cortex is tethered to a PC using the orange
+ * USB A to A cable and has no VEX 7.2V Battery connected and powered on, as the VEX Battery
+ * provides power to sensors.
+ *
+ * @param channel the channel to read from 1-8
+ * @return the analog sensor value, where a value of 0 reflects an input voltage of nearly 0 V
+ * and a value of 4095 reflects an input voltage of nearly 5 V
+ */
+int analogRead(unsigned char channel);
+/**
+ * Reads the calibrated value of an analog input channel.
+ *
+ * The analogCalibrate() function must be run first on that channel. This function is
+ * inappropriate for sensor values intended for integration, as round-off error can accumulate
+ * causing drift over time. Use analogReadCalibratedHR() instead.
+ *
+ * This function may not work properly if the VEX Cortex is tethered to a PC using the orange
+ * USB A to A cable and has no VEX 7.2V Battery connected and powered on, as the VEX Battery
+ * provides power to sensors.
+ *
+ * @param channel the channel to read from 1-8
+ * @return the difference of the sensor value from its calibrated default from -4095 to 4095
+ */
+int analogReadCalibrated(unsigned char channel);
+/**
+ * Reads the calibrated value of an analog input channel 1-8 with enhanced precision.
+ *
+ * The analogCalibrate() function must be run first. This is intended for integrated sensor
+ * values such as gyros and accelerometers to reduce drift due to round-off, and should not be
+ * used on a sensor such as a line tracker or potentiometer.
+ *
+ * The value returned actually has 16 bits of "precision", even though the ADC only reads
+ * 12 bits, so that errors induced by the average value being between two values come out
+ * in the wash when integrated over time. Think of the value as the true value times 16.
+ *
+ * This function may not work properly if the VEX Cortex is tethered to a PC using the orange
+ * USB A to A cable and has no VEX 7.2V Battery connected and powered on, as the VEX Battery
+ * provides power to sensors.
+ *
+ * @param channel the channel to read from 1-8
+ * @return the difference of the sensor value from its calibrated default from -16384 to 16384
+ */
+int analogReadCalibratedHR(unsigned char channel);
+/**
+ * Gets the digital value (1 or 0) of a pin configured as a digital input.
+ *
+ * If the pin is configured as some other mode, the digital value which reflects the current
+ * state of the pin is returned, which may or may not differ from the currently set value. The
+ * return value is undefined for pins configured as Analog inputs, or for ports in use by a
+ * Communications interface. This function is Wiring-compatible.
+ *
+ * This function may not work properly if the VEX Cortex is tethered to a PC using the orange
+ * USB A to A cable and has no VEX 7.2V Battery connected and powered on, as the VEX Battery
+ * provides power to sensors.
+ *
+ * @param pin the pin to read from 1-26
+ * @return true if the pin is HIGH, or false if it is LOW
+ */
+bool digitalRead(unsigned char pin);
+/**
+ * Sets the digital value (1 or 0) of a pin configured as a digital output.
+ *
+ * If the pin is configured as some other mode, behavior is undefined. This function is
+ * Wiring-compatible.
+ *
+ * @param pin the pin to write from 1-26
+ * @param value an expression evaluating to "true" or "false" to set the output to HIGH or LOW
+ * respectively, or the constants HIGH or LOW themselves
+ */
+void digitalWrite(unsigned char pin, bool value);
+/**
+ * Configures the pin as an input or output with a variety of settings.
+ *
+ * Do note that INPUT by default turns on the pull-up resistor, as most VEX sensors are
+ * open-drain active low. It should not be a big deal for most push-pull sources. This function
+ * is Wiring-compatible.
+ *
+ * @param pin the pin to modify from 1-26
+ * @param mode one of INPUT, INPUT_ANALOG, INPUT_FLOATING, OUTPUT, or OUTPUT_OD
+ */
+void pinMode(unsigned char pin, unsigned char mode);
+
+/*
+ * Digital port 10 cannot be used as an interrupt port, or for an encoder. Plan accordingly.
+ */
+
+/**
+ * When used in ioSetInterrupt(), triggers an interrupt on rising edges (LOW to HIGH).
+ */
+#define INTERRUPT_EDGE_RISING 1
+/**
+ * When used in ioSetInterrupt(), triggers an interrupt on falling edges (HIGH to LOW).
+ */
+#define INTERRUPT_EDGE_FALLING 2
+/**
+ * When used in ioSetInterrupt(), triggers an interrupt on both rising and falling edges
+ * (LOW to HIGH or HIGH to LOW).
+ */
+#define INTERRUPT_EDGE_BOTH 3
+/**
+ * Type definition for interrupt handlers. Such functions must accept one argument indicating
+ * the pin which changed.
+ */
+typedef void (*InterruptHandler)(unsigned char pin);
+
+/**
+ * Disables interrupts on the specified pin.
+ *
+ * Disabling interrupts on interrupt pins which are not in use conserves processing time.
+ *
+ * @param pin the pin on which to reset interrupts from 1-9,11-12
+ */
+void ioClearInterrupt(unsigned char pin);
+/**
+ * Sets up an interrupt to occur on the specified pin, and resets any counters or timers
+ * associated with the pin.
+ *
+ * Each time the specified change occurs, the function pointer passed in will be called with
+ * the pin that changed as an argument. Enabling pin-change interrupts consumes processing
+ * time, so it is best to only enable necessary interrupts and to keep the InterruptHandler
+ * function short. Pin change interrupts can only be enabled on pins 1-9 and 11-12.
+ *
+ * Do not use API functions such as delay() inside the handler function, as the function will
+ * run in an ISR where the scheduler is paused and no other interrupts can execute. It is best
+ * to quickly update some state and allow a task to perform the work.
+ *
+ * Do not use this function on pins that are also being used by the built-in ultrasonic or
+ * shaft encoder drivers, or on pins which have been switched to output mode.
+ *
+ * @param pin the pin on which to enable interrupts from 1-9,11-12
+ * @param edges one of INTERRUPT_EDGE_RISING, INTERRUPT_EDGE_FALLING, or INTERRUPT_EDGE_BOTH
+ * @param handler the function to call when the condition is satisfied
+ */
+void ioSetInterrupt(unsigned char pin, unsigned char edges, InterruptHandler handler);
+
+// -------------------- Physical output control functions --------------------
+
+/**
+ * Gets the last set speed of the specified motor channel.
+ *
+ * This speed may have been set by any task or the PROS kernel itself. This is not guaranteed
+ * to be the speed that the motor is actually running at, or even the speed currently being
+ * sent to the motor, due to latency in the Motor Controller 29 protocol and physical loading.
+ * To measure actual motor shaft revolution speed, attach a VEX Integrated Motor Encoder or
+ * VEX Quadrature Encoder and use the velocity functions associated with each.
+ *
+ * @param channel the motor channel to fetch from 1-10
+ * @return the speed last sent to this channel; -127 is full reverse and 127 is full forward,
+ * with 0 being off
+ */
+int motorGet(unsigned char channel);
+/**
+ * Sets the speed of the specified motor channel.
+ *
+ * Do not use motorSet() with the same channel argument from two different tasks. It is safe to
+ * use motorSet() with different channel arguments from different tasks.
+ *
+ * @param channel the motor channel to modify from 1-10
+ * @param speed the new signed speed; -127 is full reverse and 127 is full forward, with 0
+ * being off
+ */
+void motorSet(unsigned char channel, int speed);
+/**
+ * Stops the motor on the specified channel, equivalent to calling motorSet() with an argument
+ * of zero.
+ *
+ * This performs a coasting stop, not an active brake. Since motorStop is similar to
+ * motorSet(0), see the note for motorSet() about use from multiple tasks.
+ *
+ * @param channel the motor channel to stop from 1-10
+ */
+void motorStop(unsigned char channel);
+/**
+ * Stops all motors; significantly faster than looping through all motor ports and calling
+ * motorSet(channel, 0) on each one.
+ */
+void motorStopAll();
+
+/**
+ * Initializes VEX speaker support.
+ *
+ * The VEX speaker is not thread safe; it can only be used from one task at a time. Using the
+ * VEX speaker may impact robot performance. Teams may benefit from an if statement that only
+ * enables sound if isOnline() returns false.
+ */
+void speakerInit();
+/**
+ * Plays up to three RTTTL (Ring Tone Text Transfer Language) songs simultaneously over the
+ * VEX speaker. The audio is mixed to allow polyphonic sound to be played. Many simple songs
+ * are available in RTTTL format online, or compose your own.
+ *
+ * The song must not be NULL, but unused tracks within the song can be set to NULL. If any of
+ * the three song tracks is invalid, the result of this function is undefined.
+ *
+ * The VEX speaker is not thread safe; it can only be used from one task at a time. Using the
+ * VEX speaker may impact robot performance. Teams may benefit from an if statement that only
+ * enables sound if isOnline() returns false.
+ *
+ * @param songs an array of up to three (3) RTTTL songs as string values to play
+ */
+void speakerPlayArray(const char * * songs);
+/**
+ * Plays an RTTTL (Ring Tone Text Transfer Language) song over the VEX speaker. Many simple
+ * songs are available in RTTTL format online, or compose your own.
+ *
+ * The song must not be NULL. If an invalid song is specified, the result of this function is
+ * undefined.
+ *
+ * The VEX speaker is not thread safe; it can only be used from one task at a time. Using the
+ * VEX speaker may impact robot performance. Teams may benefit from an if statement that only
+ * enables sound if isOnline() returns false.
+ *
+ * @param song the RTTTL song as a string value to play
+ */
+void speakerPlayRtttl(const char *song);
+/**
+ * Powers down and disables the VEX speaker.
+ *
+ * If a song is currently being played in another task, the behavior of this function is
+ * undefined, since the VEX speaker is not thread safe.
+ */
+void speakerShutdown();
+
+// -------------------- VEX sensor control functions --------------------
+
+/**
+ * IME addresses end at 0x1F. Actually using more than 10 (address 0x1A) encoders will cause
+ * unreliable communications.
+ */
+#define IME_ADDR_MAX 0x1F
+
+/**
+ * Initializes all IMEs.
+ *
+ * IMEs are assigned sequential incrementing addresses, beginning with the first IME on the
+ * chain (closest to the VEX Cortex I2C port). Therefore, a given configuration of IMEs will
+ * always have the same ID assigned to each encoder. The addresses range from 0 to
+ * IME_ADDR_MAX, so the first encoder gets 0, the second gets 1, ...
+ *
+ * This function should most likely be used in initialize(). Do not use it in initializeIO() or
+ * at any other time when the scheduler is paused (like an interrupt). Checking the return
+ * value of this function is important to ensure that all IMEs are plugged in and responding as
+ * expected.
+ *
+ * This function, unlike the other IME functions, is not thread safe. If using imeInitializeAll
+ * to re-initialize encoders, calls to other IME functions might behave unpredictably during
+ * this function's execution.
+ *
+ * @return the number of IMEs successfully initialized.
+ */
+unsigned int imeInitializeAll();
+/**
+ * Gets the current 32-bit count of the specified IME.
+ *
+ * Much like the count for a quadrature encoder, the tick count is signed and cumulative.
+ * The value reflects total counts since the last reset. Different VEX Motor Encoders have a
+ * different number of counts per revolution:
+ *
+ * * \c 240.448 for the 269 IME
+ * * \c 627.2 for the 393 IME in high torque mode (factory default)
+ * * \c 392 for the 393 IME in high speed mode
+ *
+ * If the IME address is invalid, or the IME has not been reset or initialized, the value
+ * stored in *value is undefined.
+ *
+ * @param address the IME address to fetch from 0 to IME_ADDR_MAX
+ * @param value a pointer to the location where the value will be stored (obtained using the
+ * "&" operator on the target variable name e.g. <code>imeGet(2, &counts)</code>)
+ * @return true if the count was successfully read and the value stored in *value is valid;
+ * false otherwise
+ */
+bool imeGet(unsigned char address, int *value);
+/**
+ * Gets the current rotational velocity of the specified IME.
+ *
+ * In this version of PROS, the velocity is positive if the IME count is increasing and
+ * negative if the IME count is decreasing. The velocity is in RPM of the internal encoder
+ * wheel. Since checking the IME for its type cannot reveal whether the motor gearing is
+ * high speed or high torque (in the 2-Wire Motor 393 case), the user must divide the return
+ * value by the number of output revolutions per encoder revolution:
+ *
+ * * \c 30.056 for the 269 IME
+ * * \c 39.2 for the 393 IME in high torque mode (factory default)
+ * * \c 24.5 for the 393 IME in high speed mode
+ *
+ * If the IME address is invalid, or the IME has not been reset or initialized, the value
+ * stored in *value is undefined.
+ *
+ * @param address the IME address to fetch from 0 to IME_ADDR_MAX
+ * @param value a pointer to the location where the value will be stored (obtained using the
+ * "&" operator on the target variable name e.g. <code>imeGetVelocity(2, &counts)</code>)
+ * @return true if the velocity was successfully read and the value stored in *value is valid;
+ * false otherwise
+ */
+bool imeGetVelocity(unsigned char address, int *value);
+/**
+ * Resets the specified IME's counters to zero.
+ *
+ * This method can be used while the IME is rotating.
+ *
+ * @param address the IME address to reset from 0 to IME_ADDR_MAX
+ * @return true if the reset succeeded; false otherwise
+ */
+bool imeReset(unsigned char address);
+/**
+ * Shuts down all IMEs on the chain; their addresses return to the default and the stored
+ * counts and velocities are lost. This function, unlike the other IME functions, is not
+ * thread safe.
+ *
+ * To use the IME chain again, wait at least 0.25 seconds before using imeInitializeAll again.
+ */
+void imeShutdown();
+
+/**
+ * Reference type for an initialized gyro.
+ *
+ * Gyro information is stored as an opaque pointer to a structure in memory; as this is a
+ * pointer type, it can be safely passed or stored by value.
+ */
+typedef void * Gyro;
+
+/**
+ * Gets the current gyro angle in degrees, rounded to the nearest degree.
+ *
+ * There are 360 degrees in a circle.
+ *
+ * @param gyro the Gyro object from gyroInit() to read
+ * @return the signed and cumulative number of degrees rotated around the gyro's vertical axis
+ * since the last start or reset
+ */
+int gyroGet(Gyro gyro);
+/**
+ * Initializes and enables a gyro on an analog port.
+ *
+ * NULL will be returned if the port is invalid or the gyro is already in use. Initializing a
+ * gyro implicitly calibrates it and resets its count. Do not move the robot while the gyro is
+ * being calibrated. It is suggested to call this function in initialize() and to place the
+ * robot in its final position before powering it on.
+ *
+ * The multiplier parameter can tune the gyro to adapt to specific sensors. The default value
+ * at this time is 196; higher values will increase the number of degrees reported for a fixed
+ * actual rotation, while lower values will decrease the number of degrees reported. If your
+ * robot is consistently turning too far, increase the multiplier, and if it is not turning
+ * far enough, decrease the multiplier.
+ *
+ * @param port the analog port to use from 1-8
+ * @param multiplier an optional constant to tune the gyro readings; use 0 for the default
+ * value
+ * @return a Gyro object to be stored and used for later calls to gyro functions
+ */
+Gyro gyroInit(unsigned char port, unsigned short multiplier);
+/**
+ * Resets the gyro to zero.
+ *
+ * It is safe to use this method while a gyro is enabled. It is not necessary to call this
+ * method before stopping or starting a gyro.
+ *
+ * @param gyro the Gyro object from gyroInit() to reset
+ */
+void gyroReset(Gyro gyro);
+/**
+ * Stops and disables the gyro.
+ *
+ * Gyros use processing power, so disabling unused gyros increases code performance.
+ * The gyro's position will be retained.
+ *
+ * @param gyro the Gyro object from gyroInit() to stop
+ */
+void gyroShutdown(Gyro gyro);
+
+/**
+ * Reference type for an initialized encoder.
+ *
+ * Encoder information is stored as an opaque pointer to a structure in memory; as this is a
+ * pointer type, it can be safely passed or stored by value.
+ */
+typedef void * Encoder;
+/**
+ * Gets the number of ticks recorded by the encoder.
+ *
+ * There are 360 ticks in one revolution.
+ *
+ * @param enc the Encoder object from encoderInit() to read
+ * @return the signed and cumulative number of counts since the last start or reset
+ */
+int encoderGet(Encoder enc);
+/**
+ * Initializes and enables a quadrature encoder on two digital ports.
+ *
+ * Neither the top port nor the bottom port can be digital port 10. NULL will be returned if
+ * either port is invalid or the encoder is already in use. Initializing an encoder implicitly
+ * resets its count.
+ *
+ * @param portTop the "top" wire from the encoder sensor with the removable cover side UP
+ * @param portBottom the "bottom" wire from the encoder sensor
+ * @param reverse if "true", the sensor will count in the opposite direction
+ * @return an Encoder object to be stored and used for later calls to encoder functions
+ */
+Encoder encoderInit(unsigned char portTop, unsigned char portBottom, bool reverse);
+/**
+ * Resets the encoder to zero.
+ *
+ * It is safe to use this method while an encoder is enabled. It is not necessary to call this
+ * method before stopping or starting an encoder.
+ *
+ * @param enc the Encoder object from encoderInit() to reset
+ */
+void encoderReset(Encoder enc);
+/**
+ * Stops and disables the encoder.
+ *
+ * Encoders use processing power, so disabling unused encoders increases code performance.
+ * The encoder's count will be retained.
+ *
+ * @param enc the Encoder object from encoderInit() to stop
+ */
+void encoderShutdown(Encoder enc);
+
+/**
+ * Reference type for an initialized ultrasonic sensor.
+ *
+ * Ultrasonic information is stored as an opaque pointer to a structure in memory; as this is a
+ * pointer type, it can be safely passed or stored by value.
+ */
+typedef void * Ultrasonic;
+/**
+ * Gets the current ultrasonic sensor value in centimeters.
+ *
+ * If no object was found, zero is returned. If the ultrasonic sensor was never started, the
+ * return value is undefined. Round and fluffy objects can cause inaccurate values to be
+ * returned.
+ *
+ * @param ult the Ultrasonic object from ultrasonicInit() to read
+ * @return the distance to the nearest object in centimeters
+ */
+int ultrasonicGet(Ultrasonic ult);
+/**
+ * Initializes an ultrasonic sensor on the specified digital ports.
+ *
+ * The ultrasonic sensor will be polled in the background in concert with the other sensors
+ * registered using this method. NULL will be returned if either port is invalid or the
+ * ultrasonic sensor port is already in use.
+ *
+ * @param portEcho the port connected to the orange cable from 1-9,11-12
+ * @param portPing the port connected to the yellow cable from 1-12
+ * @return an Ultrasonic object to be stored and used for later calls to ultrasonic functions
+ */
+Ultrasonic ultrasonicInit(unsigned char portEcho, unsigned char portPing);
+/**
+ * Stops and disables the ultrasonic sensor.
+ *
+ * The last distance it had before stopping will be retained. One more ping operation may occur
+ * before the sensor is fully disabled.
+ *
+ * @param ult the Ultrasonic object from ultrasonicInit() to stop
+ */
+void ultrasonicShutdown(Ultrasonic ult);
+
+/**
+ * FILE is an integer referring to a stream for the standard I/O functions.
+ *
+ * FILE * is the standard library method of referring to a file pointer, even though there is
+ * actually nothing there.
+ */
+typedef int FILE;
+/**
+ * Bit mask for usartInit() for 8 data bits (typical)
+ */
+#define SERIAL_DATABITS_8 0x0000
+/**
+ * Bit mask for usartInit() for 9 data bits
+ */
+#define SERIAL_DATABITS_9 0x1000
+/**
+ * Bit mask for usartInit() for 1 stop bit (typical)
+ */
+#define SERIAL_STOPBITS_1 0x0000
+/**
+ * Bit mask for usartInit() for 2 stop bits
+ */
+#define SERIAL_STOPBITS_2 0x2000
+/**
+ * Bit mask for usartInit() for No parity (typical)
+ */
+#define SERIAL_PARITY_NONE 0x0000
+/**
+ * Bit mask for usartInit() for Even parity
+ */
+#define SERIAL_PARITY_EVEN 0x0400
+/**
+ * Bit mask for usartInit() for Odd parity
+ */
+#define SERIAL_PARITY_ODD 0x0600
+/**
+ * Specifies the default serial settings when used in usartInit()
+ */
+#define SERIAL_8N1 0x0000
+
+/**
+ * Initialize the specified serial interface with the given connection parameters.
+ *
+ * I/O to the port is accomplished using the "standard" I/O functions such as fputs(),
+ * fprintf(), and fputc().
+ *
+ * Re-initializing an open port may cause loss of data in the buffers. This routine may be
+ * safely called from initializeIO() or when the scheduler is paused. If I/O is attempted on a
+ * serial port which has never been opened, the behavior will be the same as if the port had
+ * been disabled.
+ *
+ * @param usart the port to open, either "uart1" or "uart2"
+ * @param baud the baud rate to use from 2400 to 1000000 baud
+ * @param flags a bit mask combination of the SERIAL_* flags specifying parity, stop, and data
+ * bits
+ */
+void usartInit(FILE *usart, unsigned int baud, unsigned int flags);
+/**
+ * Disables the specified USART interface.
+ *
+ * Any data in the transmit and receive buffers will be lost. Attempts to read from the port
+ * when it is disabled will deadlock, and attempts to write to it may deadlock depending on
+ * the state of the buffer.
+ *
+ * @param usart the port to close, either "uart1" or "uart2"
+ */
+void usartShutdown(FILE *usart);
+
+// -------------------- Character input and output --------------------
+
+/**
+ * The standard output stream uses the PC debug terminal.
+ */
+#define stdout ((FILE *)3)
+/**
+ * The standard input stream uses the PC debug terminal.
+ */
+#define stdin ((FILE *)3)
+/**
+ * UART 1 on the Cortex; must be opened first using usartInit().
+ */
+#define uart1 ((FILE *)1)
+/**
+ * UART 2 on the Cortex; must be opened first using usartInit().
+ */
+#define uart2 ((FILE *)2)
+
+#ifndef EOF
+/**
+ * EOF is a value evaluating to -1.
+ */
+#define EOF ((int)-1)
+#endif
+
+#ifndef SEEK_SET
+/**
+ * SEEK_SET is used in fseek() to denote an absolute position in bytes from the start of the
+ * file.
+ */
+#define SEEK_SET 0
+#endif
+#ifndef SEEK_CUR
+/**
+ * SEEK_CUR is used in fseek() to denote an relative position in bytes from the current file
+ * location.
+ */
+#define SEEK_CUR 1
+#endif
+#ifndef SEEK_END
+/**
+ * SEEK_END is used in fseek() to denote an absolute position in bytes from the end of the
+ * file. The offset will most likely be negative in this case.
+ */
+#define SEEK_END 2
+#endif
+
+/**
+ * Closes the specified file descriptor. This function does not work on communication ports;
+ * use usartShutdown() instead.
+ *
+ * @param stream the file descriptor to close from fopen()
+ */
+void fclose(FILE *stream);
+/**
+ * Returns the number of characters that can be read without blocking (the number of
+ * characters available) from the specified stream. This only works for communication ports and
+ * files in Read mode; for files in Write mode, 0 is always returned.
+ *
+ * This function may underestimate, but will not overestimate, the number of characters which
+ * meet this criterion.
+ *
+ * @param stream the stream to read (stdin, uart1, uart2, or an open file in Read mode)
+ * @return the number of characters which meet this criterion; if this number cannot be
+ * determined, returns 0
+ */
+int fcount(FILE *stream);
+/**
+ * Delete the specified file if it exists and is not currently open.
+ *
+ * The file will actually be erased from memory on the next re-boot. A physical power cycle is
+ * required to purge deleted files and free their allocated space for new files to be written.
+ * Deleted files are still considered inaccessible to fopen() in Read mode.
+ *
+ * @param file the file name to erase
+ * @return 0 if the file was deleted, or 1 if the file could not be found
+ */
+int fdelete(const char *file);
+/**
+ * Checks to see if the specified stream is at its end. This only works for communication ports
+ * and files in Read mode; for files in Write mode, 1 is always returned.
+ *
+ * @param stream the channel to check (stdin, uart1, uart2, or an open file in Read mode)
+ * @return 0 if the stream is not at EOF, or 1 otherwise.
+ */
+int feof(FILE *stream);
+/**
+ * Flushes the data on the specified file channel open in Write mode. This function has no
+ * effect on a communication port or a file in Read mode, as these streams are always flushed as
+ * quickly as possible by the kernel.
+ *
+ * Successful completion of an fflush function on a file in Write mode cannot guarantee that
+ * the file is vaild until fclose() is used on that file descriptor.
+ *
+ * @param stream the channel to flush (an open file in Write mode)
+ * @return 0 if the data was successfully flushed, EOF otherwise
+ */
+int fflush(FILE *stream);
+/**
+ * Reads and returns one character from the specified stream, blocking until complete.
+ *
+ * Do not use fgetc() on a VEX LCD port; deadlock may occur.
+ *
+ * @param stream the stream to read (stdin, uart1, uart2, or an open file in Read mode)
+ * @return the next character from 0 to 255, or -1 if no character can be read
+ */
+int fgetc(FILE *stream);
+/**
+ * Reads a string from the specified stream, storing the characters into the memory at str.
+ * Characters will be read until the specified limit is reached, a new line is found, or the
+ * end of file is reached.
+ *
+ * If the stream is already at end of file (for files in Read mode), NULL will be returned;
+ * otherwise, at least one character will be read and stored into str.
+ *
+ * @param str the location where the characters read will be stored
+ * @param num the maximum number of characters to store; at most (num - 1) characters will be
+ * read, with a null terminator ('\0') automatically appended
+ * @param stream the channel to read (stdin, uart1, uart2, or an open file in Read mode)
+ * @return str, or NULL if zero characters could be read
+ */
+char* fgets(char *str, int num, FILE *stream);
+/**
+ * Opens the given file in the specified mode. The file name is truncated to eight characters.
+ * Only four files can be in use simultaneously in any given time, with at most one of those
+ * files in Write mode. This function does not work on communication ports; use usartInit()
+ * instead.
+ *
+ * mode can be "r" or "w". Due to the nature of the VEX Cortex memory, the "r+", "w+", and "a"
+ * modes are not supported by the file system.
+ *
+ * Opening a file that does not exist in Read mode will fail and return NULL, but opening a new
+ * file in Write mode will create it if there is space. Opening a file that already exists in
+ * Write mode will destroy the contents and create a new blank file if space is available.
+ *
+ * There are important considerations when using of the file system on the VEX Cortex. Reading
+ * from files is safe, but writing to files should only be performed when robot actuators have
+ * been stopped. PROS will attempt to continue to handle events during file writes, but most
+ * user tasks cannot execute during file writing. Powering down the VEX Cortex mid-write may
+ * cause file system corruption.
+ *
+ * @param file the file name
+ * @param mode the file mode
+ * @return a file descriptor pointing to the new file, or NULL if the file could not be opened
+ */
+FILE * fopen(const char *file, const char *mode);
+/**
+ * Prints the simple string to the specified stream.
+ *
+ * This method is much, much faster than fprintf() and does not add a new line like fputs().
+ * Do not use fprint() on a VEX LCD port. Use lcdSetText() instead.
+ *
+ * @param string the string to write
+ * @param stream the stream to write (stdout, uart1, uart2, or an open file in Write mode)
+ */
+void fprint(const char *string, FILE *stream);
+/**
+ * Writes one character to the specified stream.
+ *
+ * Do not use fputc() on a VEX LCD port. Use lcdSetText() instead.
+ *
+ * @param value the character to write (a value of type "char" can be used)
+ * @param stream the stream to write (stdout, uart1, uart2, or an open file in Write mode)
+ * @return the character written
+ */
+int fputc(int value, FILE *stream);
+/**
+ * Behaves the same as the "fprint" function, and appends a trailing newline ("\n").
+ *
+ * Do not use fputs() on a VEX LCD port. Use lcdSetText() instead.
+ *
+ * @param string the string to write
+ * @param stream the stream to write (stdout, uart1, uart2, or an open file in Write mode)
+ * @return the number of characters written, excluding the new line
+ */
+int fputs(const char *string, FILE *stream);
+/**
+ * Reads data from a stream into memory. Returns the number of bytes thus read.
+ *
+ * If the memory at ptr cannot store (size * count) bytes, undefined behavior occurs.
+ *
+ * @param ptr a pointer to where the data will be stored
+ * @param size the size of each data element to read in bytes
+ * @param count the number of data elements to read
+ * @param stream the stream to read (stdout, uart1, uart2, or an open file in Read mode)
+ * @return the number of bytes successfully read
+ */
+size_t fread(void *ptr, size_t size, size_t count, FILE *stream);
+/**
+ * Seeks within a file open in Read mode. This function will fail when used on a file in Write
+ * mode or on any communications port.
+ *
+ * @param stream the stream to seek within
+ * @param offset the location within the stream to seek
+ * @param origin the reference location for offset: SEEK_CUR, SEEK_SET, or SEEK_END
+ * @return 0 if the seek was successful, or 1 otherwise
+ */
+int fseek(FILE *stream, long int offset, int origin);
+/**
+ * Returns the current position of the stream. This function works on files in either Read or
+ * Write mode, but will fail on communications ports.
+ *
+ * @param stream the stream to check
+ * @return the offset of the stream, or -1 if the offset could not be determined
+ */
+long int ftell(FILE *stream);
+/**
+ * Writes data from memory to a stream. Returns the number of bytes thus written.
+ *
+ * If the memory at ptr is not as long as (size * count) bytes, undefined behavior occurs.
+ *
+ * @param ptr a pointer to the data to write
+ * @param size the size of each data element to write in bytes
+ * @param count the number of data elements to write
+ * @param stream the stream to write (stdout, uart1, uart2, or an open file in Write mode)
+ * @return the number of bytes successfully written
+ */
+size_t fwrite(const void *ptr, size_t size, size_t count, FILE *stream);
+/**
+ * Reads and returns one character from "stdin", which is the PC debug terminal.
+ *
+ * @return the next character from 0 to 255, or -1 if no character can be read
+ */
+int getchar();
+/**
+ * Prints the simple string to the debug terminal without formatting.
+ *
+ * This method is much, much faster than printf().
+ *
+ * @param string the string to write
+ */
+void print(const char *string);
+/**
+ * Writes one character to "stdout", which is the PC debug terminal, and returns the input
+ * value.
+ *
+ * When using a wireless connection, one may need to press the spacebar before the input is
+ * visible on the terminal.
+ *
+ * @param value the character to write (a value of type "char" can be used)
+ * @return the character written
+ */
+int putchar(int value);
+/**
+ * Behaves the same as the "print" function, and appends a trailing newline ("\n").
+ *
+ * @param string the string to write
+ * @return the number of characters written, excluding the new line
+ */
+int puts(const char *string);
+
+/**
+ * Prints the formatted string to the specified output stream.
+ *
+ * The specifiers supported by this minimalistic printf() function are:
+ * * @c \%d: Signed integer in base 10 (int)
+ * * @c \%u: Unsigned integer in base 10 (unsigned int)
+ * * @c \%x, @c \%X: Integer in base 16 (unsigned int, int)
+ * * @c \%p: Pointer (void *, int *, ...)
+ * * @c \%c: Character (char)
+ * * @c \%s: Null-terminated string (char *)
+ * * @c \%%: Single literal percent sign
+ * * @c \%f: Floating-point number
+ *
+ * Specifiers can be modified with:
+ * * @c 0: Zero-pad, instead of space-pad
+ * * @c a.b: Make the field at least "a" characters wide. If "b" is specified for "%f", changes the
+ * number of digits after the decimal point
+ * * @c -: Left-align, instead of right-align
+ * * @c +: Always display the sign character (displays a leading "+" for positive numbers)
+ * * @c l: Ignored for compatibility
+ *
+ * Invalid format specifiers, or mismatched parameters to specifiers, cause undefined behavior.
+ * Other characters are written out verbatim. Do not use fprintf() on a VEX LCD port.
+ * Use lcdPrint() instead.
+ *
+ * @param stream the stream to write (stdout, uart1, or uart2)
+ * @param formatString the format string as specified above
+ * @return the number of characters written
+ */
+int fprintf(FILE *stream, const char *formatString, ...);
+/**
+ * Prints the formatted string to the debug stream (the PC terminal).
+ *
+ * @param formatString the format string as specified in fprintf()
+ * @return the number of characters written
+ */
+int printf(const char *formatString, ...);
+/**
+ * Prints the formatted string to the string buffer with the specified length limit.
+ *
+ * The length limit, as per the C standard, includes the trailing null character, so an
+ * argument of 256 will cause a maximum of 255 non-null characters to be printed, and one null
+ * terminator in all cases.
+ *
+ * @param buffer the string buffer where characters can be placed
+ * @param limit the maximum number of characters to write
+ * @param formatString the format string as specified in fprintf()
+ * @return the number of characters stored
+ */
+int snprintf(char *buffer, size_t limit, const char *formatString, ...);
+/**
+ * Prints the formatted string to the string buffer.
+ *
+ * If the buffer is not big enough to contain the complete formatted output, undefined behavior
+ * occurs. See snprintf() for a safer version of this function.
+ *
+ * @param buffer the string buffer where characters can be placed
+ * @param formatString the format string as specified in fprintf()
+ * @return the number of characters stored
+ */
+int sprintf(char *buffer, const char *formatString, ...);
+
+/**
+ * LEFT button on LCD for use with lcdReadButtons()
+ */
+#define LCD_BTN_LEFT 1
+/**
+ * CENTER button on LCD for use with lcdReadButtons()
+ */
+#define LCD_BTN_CENTER 2
+/**
+ * RIGHT button on LCD for use with lcdReadButtons()
+ */
+#define LCD_BTN_RIGHT 4
+
+/**
+ * Clears the LCD screen on the specified port.
+ *
+ * Printing to a line implicitly overwrites the contents, so clearing should only be required
+ * at startup.
+ *
+ * @param lcdPort the LCD to clear, either uart1 or uart2
+ */
+void lcdClear(FILE *lcdPort);
+/**
+ * Initializes the LCD port, but does not change the text or settings.
+ *
+ * If the LCD was not initialized before, the text currently on the screen will be undefined.
+ * The port will not be usable with standard serial port functions until the LCD is stopped.
+ *
+ * @param lcdPort the LCD to initialize, either uart1 or uart2
+ */
+void lcdInit(FILE *lcdPort);
+/**
+ * Prints the formatted string to the attached LCD.
+ *
+ * The output string will be truncated as necessary to fit on the LCD screen, 16 characters
+ * wide. It is probably better to generate the string in a local buffer and use lcdSetText()
+ * but this method is provided for convenience.
+ *
+ * @param lcdPort the LCD to write, either uart1 or uart2
+ * @param line the LCD line to write, either 1 or 2
+ * @param formatString the format string as specified in fprintf()
+ */
+#ifdef DOXYGEN
+void lcdPrint(FILE *lcdPort, unsigned char line, const char *formatString, ...);
+#else
+void __attribute__ ((format (printf, 3, 4))) lcdPrint(FILE *lcdPort, unsigned char line,
+ const char *formatString, ...);
+#endif
+/**
+ * Reads the user button status from the LCD display.
+ *
+ * For example, if the left and right buttons are pushed, (1 | 4) = 5 will be returned. 0 is
+ * returned if no buttons are pushed.
+ *
+ * @param lcdPort the LCD to poll, either uart1 or uart2
+ * @return the buttons pressed as a bit mask
+ */
+unsigned int lcdReadButtons(FILE *lcdPort);
+/**
+ * Sets the specified LCD backlight to be on or off.
+ *
+ * Turning it off will save power but may make it more difficult to read in dim conditions.
+ *
+ * @param lcdPort the LCD to adjust, either uart1 or uart2
+ * @param backlight true to turn the backlight on, or false to turn it off
+ */
+void lcdSetBacklight(FILE *lcdPort, bool backlight);
+/**
+ * Prints the string buffer to the attached LCD.
+ *
+ * The output string will be truncated as necessary to fit on the LCD screen, 16 characters
+ * wide. This function, like fprint(), is much, much faster than a formatted routine such as
+ * lcdPrint() and consumes less memory.
+ *
+ * @param lcdPort the LCD to write, either uart1 or uart2
+ * @param line the LCD line to write, either 1 or 2
+ * @param buffer the string to write
+ */
+void lcdSetText(FILE *lcdPort, unsigned char line, const char *buffer);
+/**
+ * Shut down the specified LCD port.
+ *
+ * @param lcdPort the LCD to stop, either uart1 or uart2
+ */
+void lcdShutdown(FILE *lcdPort);
+
+// -------------------- Real-time scheduler functions --------------------
+/**
+ * Only this many tasks can exist at once. Attempts to create further tasks will not succeed
+ * until tasks end or are destroyed, AND the idle task cleans them up.
+ *
+ * Changing this value will not change the limit without a kernel recompile. The idle task
+ * and VEX daemon task count against the limit. The user autonomous() or teleop() also counts
+ * against the limit, so 12 tasks usually remain for other uses.
+ */
+#define TASK_MAX 16
+/**
+ * The maximum number of available task priorities, which run from 0 to 5.
+ *
+ * Changing this value will not change the priority count without a kernel recompile.
+ */
+#define TASK_MAX_PRIORITIES 6
+/**
+ * The lowest priority that can be assigned to a task, which puts it on a level with the idle
+ * task. This may cause severe performance problems and is generally not recommended.
+ */
+#define TASK_PRIORITY_LOWEST 0
+/**
+ * The default task priority, which should be used for most tasks.
+ *
+ * Default tasks such as autonomous() inherit this priority.
+ */
+#define TASK_PRIORITY_DEFAULT 2
+/**
+ * The highest priority that can be assigned to a task. Unlike the lowest priority, this
+ * priority can be safely used without hampering interrupts. Beware of deadlock.
+ */
+#define TASK_PRIORITY_HIGHEST (TASK_MAX_PRIORITIES - 1)
+/**
+ * The recommended stack size for a new task that does an average amount of work. This stack
+ * size is used for default tasks such as autonomous().
+ *
+ * This is probably OK for 4-5 levels of function calls and the use of printf() with several
+ * arguments. Tasks requiring deep recursion or large local buffers will need a bigger stack.
+ */
+#define TASK_DEFAULT_STACK_SIZE 512
+/**
+ * The minimum stack depth for a task. Scheduler state is stored on the stack, so even if the
+ * task never uses the stack, at least this much space must be allocated.
+ *
+ * Function calls and other seemingly innocent constructs may place information on the stack.
+ * Err on the side of a larger stack when possible.
+ */
+#define TASK_MINIMAL_STACK_SIZE 64
+
+/**
+ * Constant returned from taskGetState() when the task is dead or nonexistant.
+ */
+#define TASK_DEAD 0
+/**
+ * Constant returned from taskGetState() when the task is actively executing.
+ */
+#define TASK_RUNNING 1
+/**
+ * Constant returned from taskGetState() when the task is exists and is available to run, but
+ * not currently running.
+ */
+#define TASK_RUNNABLE 2
+/**
+ * Constant returned from taskGetState() when the task is delayed or blocked waiting for a
+ * semaphore, mutex, or I/O operation.
+ */
+#define TASK_SLEEPING 3
+/**
+ * Constant returned from taskGetState() when the task is suspended using taskSuspend().
+ */
+#define TASK_SUSPENDED 4
+
+/**
+ * Type by which tasks are referenced.
+ *
+ * As this is a pointer type, it can be safely passed or stored by value.
+ */
+typedef void * TaskHandle;
+/**
+ * Type by which mutexes are referenced.
+ *
+ * As this is a pointer type, it can be safely passed or stored by value.
+ */
+typedef void * Mutex;
+/**
+ * Type by which semaphores are referenced.
+ *
+ * As this is a pointer type, it can be safely passed or stored by value.
+ */
+typedef void * Semaphore;
+/**
+ * Type for defining task functions. Task functions must accept one parameter of type
+ * "void *"; they need not use it.
+ *
+ * For example:
+ *
+ * void MyTask(void *ignore) {
+ * while (1);
+ * }
+ */
+typedef void (*TaskCode)(void *);
+
+/**
+ * Creates a new task and add it to the list of tasks that are ready to run.
+ *
+ * @param taskCode the function to execute in its own task
+ * @param stackDepth the number of variables available on the stack (4 * stackDepth bytes will
+ * be allocated on the Cortex)
+ * @param parameters an argument passed to the taskCode function
+ * @param priority a value from TASK_PRIORITY_LOWEST to TASK_PRIORITY_HIGHEST determining the
+ * initial priority of the task
+ * @return a handle to the created task, or NULL if an error occurred
+ */
+TaskHandle taskCreate(TaskCode taskCode, const unsigned int stackDepth, void *parameters,
+ const unsigned int priority);
+/**
+ * Delays the current task for a given number of milliseconds.
+ *
+ * Delaying for a period of zero will force a reschedule, where tasks of equal priority may be
+ * scheduled if available. The calling task will still be available for immediate rescheduling
+ * once the other tasks have had their turn or if nothing of equal or higher priority is
+ * available to be scheduled.
+ *
+ * This is not the best method to have a task execute code at predefined intervals, as the
+ * delay time is measured from when the delay is requested. To delay cyclically, use
+ * taskDelayUntil().
+ *
+ * @param msToDelay the number of milliseconds to wait, with 1000 milliseconds per second
+ */
+void taskDelay(const unsigned long msToDelay);
+/**
+ * Delays the current task until a specified time. The task will be unblocked
+ * at the time *previousWakeTime + cycleTime, and *previousWakeTime will be changed to reflect
+ * the time at which the task will unblock.
+ *
+ * If the target time is in the past, no delay occurs, but a reschedule is forced, as if
+ * taskDelay() was called with an argument of zero. If the sum of cycleTime and
+ * *previousWakeTime overflows or underflows, undefined behavior occurs.
+ *
+ * This function should be used by cyclical tasks to ensure a constant execution frequency.
+ * While taskDelay() specifies a wake time relative to the time at which the function is
+ * called, taskDelayUntil() specifies the absolute future time at which it wishes to unblock.
+ * Calling taskDelayUntil with the same cycleTime parameter value in a loop, with
+ * previousWakeTime referring to a local variable initialized to millis(), will cause the
+ * loop to execute with a fixed period.
+ *
+ * @param previousWakeTime a pointer to the location storing the last unblock time, obtained
+ * by using the "&" operator on a variable (e.g. "taskDelayUntil(&now, 50);")
+ * @param cycleTime the number of milliseconds to wait, with 1000 milliseconds per second
+ */
+void taskDelayUntil(unsigned long *previousWakeTime, const unsigned long cycleTime);
+/**
+ * Kills and removes the specified task from the kernel task list.
+ *
+ * Deleting the last task will end the program, possibly leading to undesirable states as
+ * some outputs may remain in their last set configuration.
+ *
+ * NOTE: The idle task is responsible for freeing the kernel allocated memory from tasks that
+ * have been deleted. It is therefore important that the idle task is not starved of
+ * processing time. Memory allocated by the task code is not automatically freed, and should be
+ * freed before the task is deleted.
+ *
+ * @param taskToDelete the task to kill; passing NULL kills the current task
+ */
+void taskDelete(TaskHandle taskToDelete);
+/**
+ * Determines the number of tasks that are currently being managed.
+ *
+ * This includes all ready, blocked and suspended tasks. A task that has been deleted but not
+ * yet freed by the idle task will also be included in the count. Tasks recently created may
+ * take one context switch to be counted.
+ *
+ * @return the number of tasks that are currently running, waiting, or suspended
+ */
+unsigned int taskGetCount();
+/**
+ * Retrieves the state of the specified task. Note that the state of tasks which have died may
+ * be re-used for future tasks, causing the value returned by this function to reflect a
+ * different task than possibly intended in this case.
+ *
+ * @param task Handle to the task to query. Passing NULL will query the current task status
+ * (which will, by definition, be TASK_RUNNING if this call returns)
+ *
+ * @return A value reflecting the task's status, one of the constants TASK_DEAD, TASK_RUNNING,
+ * TASK_RUNNABLE, TASK_SLEEPING, or TASK_SUSPENDED
+ */
+unsigned int taskGetState(TaskHandle task);
+/**
+ * Obtains the priority of the specified task.
+ *
+ * @param task the task to check; passing NULL checks the current task
+ * @return the priority of that task from 0 to TASK_MAX_PRIORITIES
+ */
+unsigned int taskPriorityGet(const TaskHandle task);
+/**
+ * Sets the priority of the specified task.
+ *
+ * A context switch may occur before the function returns if the priority being set is higher
+ * than the currently executing task and the task being mutated is available to be scheduled.
+ *
+ * @param task the task to change; passing NULL changes the current task
+ * @param newPriority a value between TASK_PRIORITY_LOWEST and TASK_PRIORITY_HIGHEST inclusive
+ * indicating the new task priority
+ */
+void taskPrioritySet(TaskHandle task, const unsigned int newPriority);
+/**
+ * Resumes the specified task.
+ *
+ * A task that has been suspended by one or more calls to taskSuspend() will be made available
+ * for scheduling again by a call to taskResume(). If the task was not suspended at the time
+ * of the call to taskResume(), undefined behavior occurs.
+ *
+ * @param taskToResume the task to change; passing NULL is not allowed as the current task
+ * cannot be suspended (it is obviously running if this function is called)
+ */
+void taskResume(TaskHandle taskToResume);
+/**
+ * Starts a task which will periodically call the specified function.
+ *
+ * Intended for use as a quick-start skeleton for cyclic tasks with higher priority than the
+ * "main" tasks. The created task will have priority TASK_PRIORITY_DEFAULT + 1 with the default
+ * stack size. To customize behavior, create a task manually with the specified function.
+ *
+ * This task will automatically terminate after one further function invocation when the robot
+ * is disabled or when the robot mode is switched.
+ *
+ * @param fn the function to call in this loop
+ * @param increment the delay between successive calls in milliseconds; the taskDelayUntil()
+ * function is used for accurate cycle timing
+ * @return a handle to the task, or NULL if an error occurred
+ */
+TaskHandle taskRunLoop(void (*fn)(void), const unsigned long increment);
+/**
+ * Suspends the specified task.
+ *
+ * When suspended a task will not be scheduled, regardless of whether it might be otherwise
+ * available to run.
+ *
+ * @param taskToSuspend the task to suspend; passing NULL suspends the current task
+ */
+void taskSuspend(TaskHandle taskToSuspend);
+
+/**
+ * Creates a semaphore intended for synchronizing tasks. To prevent some critical code from
+ * simultaneously modifying a shared resource, use mutexes instead.
+ *
+ * Semaphores created using this function can be accessed using the semaphoreTake() and
+ * semaphoreGive() functions. The mutex functions must not be used on objects of this type.
+ *
+ * This type of object does not need to have balanced take and give calls, so priority
+ * inheritance is not used. Semaphores can be signalled by an interrupt routine.
+ *
+ * @return a handle to the created semaphore
+ */
+Semaphore semaphoreCreate();
+/**
+ * Signals a semaphore. Tasks waiting for a signal using semaphoreTake() will be unblocked by
+ * this call and can continue execution.
+ *
+ * Slow processes can give semaphores when ready, and fast processes waiting to take the
+ * semaphore will continue at that point.
+ *
+ * @param semaphore the semaphore to signal
+ * @return true if the semaphore was successfully given, or false if the semaphore was not
+ * taken since the last give
+ */
+bool semaphoreGive(Semaphore semaphore);
+/**
+ * Waits on a semaphore. If the semaphore is already in the "taken" state, the current task
+ * will wait for the semaphore to be signaled. Other tasks can run during this time.
+ *
+ * @param semaphore the semaphore to wait
+ * @param blockTime the maximum time to wait for the semaphore to be given, where -1
+ * specifies an infinite timeout
+ * @return true if the semaphore was successfully taken, or false if the timeout expired
+ */
+bool semaphoreTake(Semaphore semaphore, const unsigned long blockTime);
+/**
+ * Deletes the specified semaphore. This function can be dangerous; deleting semaphores being
+ * waited on by a task may cause deadlock or a crash.
+ *
+ * @param semaphore the semaphore to destroy
+ */
+void semaphoreDelete(Semaphore semaphore);
+
+/**
+ * Creates a mutex intended to allow only one task to use a resource at a time. For signalling
+ * and synchronization, try using semaphores.
+ *
+ * Mutexes created using this function can be accessed using the mutexTake() and mutexGive()
+ * functions. The semaphore functions must not be used on objects of this type.
+ *
+ * This type of object uses a priority inheritance mechanism so a task 'taking' a mutex MUST
+ * ALWAYS 'give' the mutex back once the mutex is no longer required.
+ *
+ * @return a handle to the created mutex
+ */
+Mutex mutexCreate();
+/**
+ * Relinquishes a mutex so that other tasks can use the resource it guards. The mutex must be
+ * held by the current task using a corresponding call to mutexTake.
+ *
+ * @param mutex the mutex to release
+ * @return true if the mutex was released, or false if the mutex was not already held
+ */
+bool mutexGive(Mutex mutex);
+/**
+ * Requests a mutex so that other tasks cannot simultaneously use the resource it guards.
+ * The mutex must not already be held by the current task. If another task already
+ * holds the mutex, the function will wait for the mutex to be released. Other tasks can run
+ * during this time.
+ *
+ * @param mutex the mutex to request
+ * @param blockTime the maximum time to wait for the mutex to be available, where -1
+ * specifies an infinite timeout
+ * @return true if the mutex was successfully taken, or false if the timeout expired
+ */
+bool mutexTake(Mutex mutex, const unsigned long blockTime);
+/**
+ * Deletes the specified mutex. This function can be dangerous; deleting semaphores being
+ * waited on by a task may cause deadlock or a crash.
+ *
+ * @param mutex the mutex to destroy
+ */
+void mutexDelete(Mutex mutex);
+
+/**
+ * Wiring-compatible alias of taskDelay().
+ *
+ * @param time the duration of the delay in milliseconds (1 000 milliseconds per second)
+ */
+void delay(const unsigned long time);
+/**
+ * Wait for approximately the given number of microseconds.
+ *
+ * The method used for delaying this length of time may vary depending on the argument.
+ * The current task will always be delayed by at least the specified period, but possibly much
+ * more depending on CPU load. In general, this function is less reliable than delay(). Using
+ * this function in a loop may hog processing time from other tasks.
+ *
+ * @param us the duration of the delay in microseconds (1 000 000 microseconds per second)
+ */
+void delayMicroseconds(const unsigned long us);
+/**
+ * Returns the number of microseconds since Cortex power-up. There are 10^6 microseconds in a
+ * second, so as a 32-bit integer, this will overflow and wrap back to zero every two hours or
+ * so.
+ *
+ * This function is Wiring-compatible.
+ *
+ * @return the number of microseconds since the Cortex was turned on or the last overflow
+ */
+unsigned long micros();
+/**
+ * Returns the number of milliseconds since Cortex power-up. There are 1000 milliseconds in a
+ * second, so as a 32-bit integer, this will not overflow for 50 days.
+ *
+ * This function is Wiring-compatible.
+ *
+ * @return the number of milliseconds since the Cortex was turned on
+ */
+unsigned long millis();
+/**
+ * Alias of taskDelay() intended to help EasyC users.
+ *
+ * @param time the duration of the delay in milliseconds (1 000 milliseconds per second)
+ */
+void wait(const unsigned long time);
+/**
+ * Alias of taskDelayUntil() intended to help EasyC users.
+ *
+ * @param previousWakeTime a pointer to the last wakeup time
+ * @param time the duration of the delay in milliseconds (1 000 milliseconds per second)
+ */
+void waitUntil(unsigned long *previousWakeTime, const unsigned long time);
+
+// End C++ extern to C
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/Nate's Position Testing/Shooter Testing/include/main.h b/Nate's Position Testing/Shooter Testing/include/main.h new file mode 100644 index 0000000..b6da316 --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/include/main.h @@ -0,0 +1,119 @@ +/** @file main.h
+ * @brief Header file for global functions
+ *
+ * Any experienced C or C++ programmer knows the importance of header files. For those who
+ * do not, a header file allows multiple files to reference functions in other files without
+ * necessarily having to see the code (and therefore causing a multiple definition). To make
+ * a function in "opcontrol.c", "auto.c", "main.c", or any other C file visible to the core
+ * implementation files, prototype it here.
+ *
+ * This file is included by default in the predefined stubs in each VEX Cortex PROS Project.
+ *
+ * Copyright (c) 2011-2014, Purdue University ACM SIG BOTS.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * * Neither the name of Purdue University ACM SIG BOTS nor the
+ * names of its contributors may be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL PURDUE UNIVERSITY ACM SIG BOTS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Purdue Robotics OS contains FreeRTOS (http://www.freertos.org) whose source code may be
+ * obtained from http://sourceforge.net/projects/freertos/files/ or on request.
+ */
+#ifndef MAIN_H_
+
+// This prevents multiple inclusion, which isn't bad for this file but is good practice
+#define MAIN_H_
+
+#include <API.h>
+
+// Allow usage of this file in C++ programs
+#ifdef __cplusplus
+extern "C" {
+#endif
+// A function prototype looks exactly like its declaration, but with a semicolon instead of
+// actual code. If a function does not match a prototype, compile errors will occur.
+
+// Prototypes for initialization, operator control and autonomous
+
+/**
+ * Runs the user autonomous code. This function will be started in its own task with the default
+ * priority and stack size whenever the robot is enabled via the Field Management System or the
+ * VEX Competition Switch in the autonomous mode. If the robot is disabled or communications is
+ * lost, the autonomous task will be stopped by the kernel. Re-enabling the robot will restart
+ * the task, not re-start it from where it left off.
+ *
+ * Code running in the autonomous task cannot access information from the VEX Joystick. However,
+ * the autonomous function can be invoked from another task if a VEX Competition Switch is not
+ * available, and it can access joystick information if called in this way.
+ *
+ * The autonomous task may exit, unlike operatorControl() which should never exit. If it does
+ * so, the robot will await a switch to another mode or disable/enable cycle.
+ */
+void autonomous();
+/**
+ * Runs pre-initialization code. This function will be started in kernel mode one time while the
+ * VEX Cortex is starting up. As the scheduler is still paused, most API functions will fail.
+ *
+ * The purpose of this function is solely to set the default pin modes (pinMode()) and port
+ * states (digitalWrite()) of limit switches, push buttons, and solenoids. It can also safely
+ * configure a UART port (usartOpen()) but cannot set up an LCD (lcdInit()).
+ */
+void initializeIO();
+/**
+ * Runs user initialization code. This function will be started in its own task with the default
+ * priority and stack size once when the robot is starting up. It is possible that the VEXnet
+ * communication link may not be fully established at this time, so reading from the VEX
+ * Joystick may fail.
+ *
+ * This function should initialize most sensors (gyro, encoders, ultrasonics), LCDs, global
+ * variables, and IMEs.
+ *
+ * This function must exit relatively promptly, or the operatorControl() and autonomous() tasks
+ * will not start. An autonomous mode selection menu like the pre_auton() in other environments
+ * can be implemented in this task if desired.
+ */
+void initialize();
+/**
+ * Runs the user operator control code. This function will be started in its own task with the
+ * default priority and stack size whenever the robot is enabled via the Field Management System
+ * or the VEX Competition Switch in the operator control mode. If the robot is disabled or
+ * communications is lost, the operator control task will be stopped by the kernel. Re-enabling
+ * the robot will restart the task, not resume it from where it left off.
+ *
+ * If no VEX Competition Switch or Field Management system is plugged in, the VEX Cortex will
+ * run the operator control task. Be warned that this will also occur if the VEX Cortex is
+ * tethered directly to a computer via the USB A to A cable without any VEX Joystick attached.
+ *
+ * Code running in this task can take almost any action, as the VEX Joystick is available and
+ * the scheduler is operational. However, proper use of delay() or taskDelayUntil() is highly
+ * recommended to give other tasks (including system tasks such as updating LCDs) time to run.
+ *
+ * This task should never exit; it should end with some kind of infinite loop, even if empty.
+ */
+extern Encoder encoder1,encoder2;
+void operatorControl();
+
+// End C++ export structure
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/Nate's Position Testing/Shooter Testing/src/Makefile b/Nate's Position Testing/Shooter Testing/src/Makefile new file mode 100644 index 0000000..865f1e7 --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/src/Makefile @@ -0,0 +1,50 @@ +# Makefile for compiling PROS projects
+
+# Path to project root (NO trailing slash!)
+ROOT=..
+# Binary output directory
+BINDIR=$(ROOT)/bin
+
+# Nothing below here needs to be modified by typical users
+
+# Include common aspects of this project
+-include $(ROOT)/common.mk
+
+ASMSRC:=$(wildcard *.$(ASMEXT))
+ASMOBJ:=$(patsubst %.o,$(BINDIR)/%.o,$(ASMSRC:.$(ASMEXT)=.o))
+HEADERS:=$(wildcard *.$(HEXT))
+### Special section for Cortex projects ###
+HEADERS_2:=$(wildcard ../include/*.$(HEXT))
+### End special section ###
+CSRC=$(wildcard *.$(CEXT))
+COBJ:=$(patsubst %.o,$(BINDIR)/%.o,$(CSRC:.$(CEXT)=.o))
+CPPSRC:=$(wildcard *.$(CPPEXT))
+CPPOBJ:=$(patsubst %.o,$(BINDIR)/%.o,$(CPPSRC:.$(CPPEXT)=.o))
+OUT:=$(BINDIR)/$(OUTNAME)
+
+.PHONY: all
+
+# By default, compile program
+all: .
+
+# Compiles the program if anything is changed
+.: $(ASMOBJ) $(COBJ) $(CPPOBJ)
+ @touch .
+
+# Assembly source file management
+$(ASMOBJ): $(BINDIR)/%.o: %.$(ASMEXT)
+ @echo AS $<
+ @$(AS) $(AFLAGS) -o $@ $<
+
+### Special section for Cortex projects ###
+
+# Object management
+$(COBJ): $(BINDIR)/%.o: %.$(CEXT) $(HEADERS) $(HEADERS_2)
+ @echo CC $(INCLUDE) $<
+ @$(CC) $(INCLUDE) $(CFLAGS) -o $@ $<
+
+$(CPPOBJ): $(BINDIR)/%.o: %.$(CPPEXT) $(HEADERS) $(HEADERS_2)
+ @echo CPC $(INCLUDE) $<
+ @$(CPPCC) $(INCLUDE) $(CPPFLAGS) -o $@ $<
+
+### End special section ###
diff --git a/Nate's Position Testing/Shooter Testing/src/auto.c b/Nate's Position Testing/Shooter Testing/src/auto.c new file mode 100644 index 0000000..9df57af --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/src/auto.c @@ -0,0 +1,52 @@ +/** @file auto.c
+ * @brief File for autonomous code
+ *
+ * This file should contain the user autonomous() function and any functions related to it.
+ *
+ * Copyright (c) 2011-2014, Purdue University ACM SIG BOTS.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * * Neither the name of Purdue University ACM SIG BOTS nor the
+ * names of its contributors may be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL PURDUE UNIVERSITY ACM SIG BOTS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Purdue Robotics OS contains FreeRTOS (http://www.freertos.org) whose source code may be
+ * obtained from http://sourceforge.net/projects/freertos/files/ or on request.
+ */
+
+#include "main.h"
+
+/*
+ * Runs the user autonomous code. This function will be started in its own task with the default
+ * priority and stack size whenever the robot is enabled via the Field Management System or the
+ * VEX Competition Switch in the autonomous mode. If the robot is disabled or communications is
+ * lost, the autonomous task will be stopped by the kernel. Re-enabling the robot will restart
+ * the task, not re-start it from where it left off.
+ *
+ * Code running in the autonomous task cannot access information from the VEX Joystick. However,
+ * the autonomous function can be invoked from another task if a VEX Competition Switch is not
+ * available, and it can access joystick information if called in this way.
+ *
+ * The autonomous task may exit, unlike operatorControl() which should never exit. If it does
+ * so, the robot will await a switch to another mode or disable/enable cycle.
+ */
+void autonomous() {
+}
diff --git a/Nate's Position Testing/Shooter Testing/src/init.c b/Nate's Position Testing/Shooter Testing/src/init.c new file mode 100644 index 0000000..fd9eeb4 --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/src/init.c @@ -0,0 +1,84 @@ +/** @file init.c
+ * @brief File for initialization code
+ *
+ * This file should contain the user initialize() function and any functions related to it.
+ *
+ * Copyright (c) 2011-2014, Purdue University ACM SIG BOTS.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * * Neither the name of Purdue University ACM SIG BOTS nor the
+ * names of its contributors may be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL PURDUE UNIVERSITY ACM SIG BOTS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Purdue Robotics OS contains FreeRTOS (http://www.freertos.org) whose source code may be
+ * obtained from http://sourceforge.net/projects/freertos/files/ or on request.
+ */
+
+#include "main.h"
+Encoder encoder1,encoder2;
+/*
+ * Runs pre-initialization code. This function will be started in kernel mode one time while the
+ * VEX Cortex is starting up. As the scheduler is still paused, most API functions will fail.
+ *
+ * The purpose of this function is solely to set the default pin modes (pinMode()) and port
+ * states (digitalWrite()) of limit switches, push buttons, and solenoids. It can also safely
+ * configure a UART port (usartOpen()) but cannot set up an LCD (lcdInit()).
+ */
+void initializeIO() {
+
+
+ pinMode(1,INPUT);
+ pinMode(2,INPUT);
+ pinMode(3,INPUT);
+ pinMode(4,INPUT);
+ pinMode(5,INPUT);
+ pinMode(6,INPUT);
+ pinMode(7,INPUT);
+ pinMode(8,INPUT);
+
+
+
+
+// Setup sensors.
+
+
+
+
+}/*
+ * Runs user initialization code. This function will be started in its own task with the default
+ * priority and stack size once when the robot is starting up. It is possible that the VEXnet
+ * communication link may not be fully established at this time, so reading from the VEX
+ * Joystick may fail.
+ *
+ * This function should initialize most sensors (gyro, encoders, ultrasonics), LCDs, global
+ * variables, and IMEs.
+ *
+ * This function must exit relatively promptly, or the operatorControl() and autonomous() tasks
+ * will not start. An autonomous mode selection menu like the pre_auton() in other environments
+ * can be implemented in this task if desired.
+ */
+void initialize() {
+ lcdInit(uart2);
+ lcdClear(uart2);
+ lcdSetBacklight(uart2,1);
+ encoder1 = encoderInit(3,4,true);
+ encoder2 = encoderInit(5,6,true);
+}
diff --git a/Nate's Position Testing/Shooter Testing/src/opcontrol.c b/Nate's Position Testing/Shooter Testing/src/opcontrol.c new file mode 100644 index 0000000..66fe496 --- /dev/null +++ b/Nate's Position Testing/Shooter Testing/src/opcontrol.c @@ -0,0 +1,125 @@ +/** @file opcontrol.c
+ * @brief File for operator control code
+ *
+ * This file should contain the user operatorControl() function and any functions related to it.
+ *
+ * Copyright (c) 2011-2014, Purdue University ACM SIG BOTS.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * * Neither the name of Purdue University ACM SIG BOTS nor the
+ * names of its contributors may be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL PURDUE UNIVERSITY ACM SIG BOTS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Purdue Robotics OS contains FreeRTOS (http://www.freertos.org) whose source code may be
+ * obtained from http://sourceforge.net/projects/freertos/files/ or on request.
+ */
+#include "main.h"
+#define round(x) ((x)>=0?(long)((x)+0.5):(long)((x)-0.5))
+/*
+ * Runs the user operator control code. This function will be started in its own task with the
+ * default priority and stack size whenever the robot is enabled via the Field Management System
+ * or the VEX Competition Switch in the operator control mode. If the robot is disabled or
+ * communications is lost, the operator control task will be stopped by the kernel. Re-enabling
+ * the robot will restart the task, not resume it from where it left off.
+ *
+ * If no VEX Competition Switch or Field Management system is plugged in, the VEX Cortex will
+ * run the operator control task. Be warned that this will also occur if the VEX Cortex is
+ * tethered directly to a computer via the USB A to A cable without any VEX Joystick attached.
+ *
+ * Code running in this task can take almost any action, as the VEX Joystick is available and
+ * the scheduler is operational. However, proper use of delay() or taskDelayUntil() is highly
+ * recommended to give other tasks (including system tasks such as updating LCDs) time to run.
+ *
+ * This task should never exit; it should end with some kind of infinite loop, even if empty.
+ *
+lDist*r=theta
+rDist*(r+15)=theta
+cDist*(r+7.5)=theta
+theta/lDist=r
+rDist*(theta/lDist+15)=theta
+rDist*theta/lDist+15*rDist=theta
+rDist/lDist+15*rDist/theta=1
+1-15*rDist/theta=rDist/lDist
+theta=(1-15*rDist)*lDist/rDist
+theta=(lDist-15*rDist*lDist)/rDist
+theta=lDist/rDist-heading*lDist
+theta=
+*/
+static int rRot,lRot,cRot,time1,time2,iHeading;
+static float lDist,
+ theta,
+ rDist,
+ cDist,
+ wheelD=3,
+ pi=3.14159,
+ heading=15,
+ startTheta,
+ fHeading;
+/* notes for Clyne:
+ * Other processes should not interupt the collection of data:
+ * rotation calculation should be and data collection should be a high priority/primary task
+ * Main task= manages tasks, init variables, reset functions (sensors, etc)
+ * Primary = sensor data collections and calculations
+ * Secondary = drive tasks
+ *
+ *
+ *
+ */
+void operatorControl() {
+ heading=startTheta;
+ while (1) {
+ time1=micros();
+ cRot=(encoderGet(encoder1)-encoderGet(encoder2));
+ cDist=(cRot*pi)/120;
+ fHeading=(cDist/12)*(360/(2*pi));
+ iHeading=round(fHeading)%360;
+
+ lcdPrint(uart2,1,"iHeading: %d",iHeading);
+
+ if(fHeading<360){
+ motorSet(10,-60);
+ motorSet(1,20);
+
+ }else{
+ motorSet(10,0);
+ motorSet(1,0);
+
+ }
+ /* lRot=encoderGet(encoder1);
+ rRot=encoderGet(encoder2);
+ lDist=(lRot*pi)/120;
+ rDist=(rRot*pi)/120;
+ lcdPrint(uart2,1,"iHeading: %d",iHeading);
+ if(digitalRead(1)==0){
+ motorSet(1,120);
+ }
+ else if(digitalRead(2)==0){
+ motorSet(10,-120);
+ }
+ else{
+ motorSet(1,0);
+ motorSet(10,0);
+ }
+ */
+ delay(20);
+
+ }
+}
diff --git a/Position Calculator.numbers b/Position Calculator.numbers Binary files differnew file mode 100644 index 0000000..d3f9e9b --- /dev/null +++ b/Position Calculator.numbers diff --git a/Positioning or something.numbers b/Positioning or something.numbers Binary files differnew file mode 100644 index 0000000..79a1665 --- /dev/null +++ b/Positioning or something.numbers diff --git a/To Do:Read.rtf b/To Do:Read.rtf new file mode 100644 index 0000000..a5f9208 --- /dev/null +++ b/To Do:Read.rtf @@ -0,0 +1,8 @@ +{\rtf1\ansi\ansicpg1252\cocoartf1404\cocoasubrtf130 +{\fonttbl\f0\fswiss\fcharset0 Helvetica;} +{\colortbl;\red255\green255\blue255;} +\margl1440\margr1440\vieww10800\viewh8400\viewkind0 +\pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\pardirnatural\partightenfactor0 + +\f0\fs24 \cf0 Articles/PDFs to Read:\ +{\field{\*\fldinst{HYPERLINK "http://www.ridgesoft.com/articles/trackingposition/TrackingPosition.pdf"}}{\fldrslt http://www.ridgesoft.com/articles/trackingposition/TrackingPosition.pdf}}}
\ No newline at end of file |